Configuration

RunTypes reads its settings from the plugins list in your tsconfig.json. Configure a project once, and every build tool (Vite, Rollup, webpack, Rspack, esbuild) picks it up.

Option Reference

Every option is optional; leave one out and the default applies. Set them in your tsconfig plugin entry, shown under Setting Options.

Marker Packages

The markers object says where the marker types (InjectRunTypeId, InjectTypeFnArgs, CompTimeArgs, PureFunction) may come from. You need it only when a library declares them itself: the compiler trusts a marker only from a package it knows, so an unknown package leaves your type as unknown. The build reports this as marker-untrusted-package and names the package to add.

{
  "compilerOptions": {
    "plugins": [
      {
        "name": "mion",
        "markers": {"packages": ["@my-org/runtypes-markers"]}
      }
    ]
  }
}

Translations

The i18n object configures translations for your FriendlyText maps:

Setting Options

Add an entry named mion under compilerOptions.plugins in your tsconfig.json. A @mionjs/devtools bundler plugin option or a CLI flag overrides that entry, which overrides the built-in default. Two exceptions: options that describe the build itself (such as tsconfig) are plugin only, and the i18n object, which belongs to the enrich command, is tsconfig only.

{
  "compilerOptions": {
    "plugins": [
      {
        "name": "mion",
        "emitMode": "code",
        "moduleMode": "default",
        "i18n": {"sourceLocale": "en", "locales": ["es", "pl"]}
      }
    ]
  }
}

import {defineConfig} from 'vite';
import runtypes from '@mionjs/devtools/runtypes/vite';

export default defineConfig({
  plugins: [runtypes({emitMode: 'functions'})],
});

Typed Output

emitMode: 'ts' writes the generated functions as typed .ts modules, for compilers that turn TypeScript into native code and need the types to optimize it. Each type gets a data-only copy (no methods) in its own module under <genDir>/types/t/. The modules pass the strictest tsconfig and run the same logic as the both output. The code sent to clients does not change.

/** User */
export type T_OMOvTMe = {id: number; name: string};

function g_Eq2V_OMOvTMe(_utl: RTUtils): (v: unknown) => v is T_OMOvTMe {
  function Eq2V_OMOvTMe(v: any): v is T_OMOvTMe {
    return typeof v === 'object' && v !== null && Number.isFinite(v.id) && typeof v.name === 'string';
  }
  return Eq2V_OMOvTMe;
}

Syncing Enrichment Files During Dev

The @mionjs/devtools bundler plugin can scaffold and sync your committed FriendlyText and MockData maps while your dev server runs, instead of you running the enrichment CLI. Turn it on with an enrich object on the plugin (never in your tsconfig); it runs only in dev and watch. Like enrich --update, it updates the file structure but never fills in translated strings or any other value you wrote.

import {defineConfig} from 'vite';
import runtypes from '@mionjs/devtools/runtypes/vite';

export default defineConfig({
  plugins: [
    runtypes({
      enrich: {
        friendly: true,
        mock: true,
        i18n: {sourceLocale: 'en', locales: ['es', 'pl']},
        suppressHmr: true,
      },
    }),
  ],
});

Enrichment Check on Production Builds

With enrich set, a production build never writes. The plugin runs a read-only check instead (the build equivalent of enrich --require-complete), and fails the build if any file is out of date, missing, still carries an unfilled blank, or holds a stale @rtOrphan entry.

The Build Cache

RunTypes keeps a cache under node_modules/.cache/mion so a rebuild can skip types that did not change. It is on when your tsconfig sets incremental (or composite), and off otherwise; there is no separate option.

{
  "compilerOptions": {
    "incremental": true
  }
}