@mionjs/run-types 0.13.2 → 0.14.0

package/dist/cjs/runtypes/classSerializerRegistry.js

@@ -1,141 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.classSerializerEpoch = classSerializerEpoch;
-exports.registerClassSerializer = registerClassSerializer;
-exports.getClassSerializer = getClassSerializer;
-exports.isClassSerializerRegistered = isClassSerializerRegistered;
-exports.deserializeClass = deserializeClass;
-exports.unregisterClassSerializer = unregisterClassSerializer;
-exports.clearClassSerializers = clearClassSerializers;
-const entryTuple_ts_1 = require("./entryTuple.js");
-const rtUtils_ts_1 = require("./rtUtils.js");
-const classSerializers = new Map();
-const classSerializersByName = new Map();
-const classStates = new Map();
-const warnedAmbiguousNames = new Set();
-let epoch = 0;
-function classSerializerEpoch() {
-    return epoch;
-}
-function classSerializerIdentity(id, cls) {
-    if ((0, entryTuple_ts_1.isEntryTuple)(id)) {
-        (0, entryTuple_ts_1.initFromTuple)(id);
-        const key = (0, entryTuple_ts_1.entryTupleKey)(id);
-        const separator = key.indexOf('_');
-        if (separator === entryTuple_ts_1.FN_HASH_LEN)
-            return { typeId: key.slice(entryTuple_ts_1.FN_HASH_LEN + 1), entryKey: key };
-        return { typeId: key };
-    }
-    if (typeof id === 'string' && id.length > 0)
-        return { typeId: id };
-    throw new Error(`[mion] registerClassSerializer(${cls.name || '<anonymous>'}): no type id injected. ` +
-        `The @mionjs/devtools plugin must process the registration file so the class's ` +
-        `type id can be injected (the registry is keyed by type id + class name).`);
-}
-function classSerializerName(identity, cls) {
-    if (identity.entryKey !== undefined) {
-        const typeName = (0, rtUtils_ts_1.getRTFnCaches)().rtFnsCache[identity.entryKey]?.typeName;
-        if (typeof typeName === 'string' && typeName.length > 0)
-            return typeName;
-    }
-    const node = (0, rtUtils_ts_1.getRTUtils)().getRunType(identity.typeId);
-    const typeName = node?.typeName;
-    if (typeof typeName === 'string' && typeName.length > 0)
-        return typeName;
-    return cls.name || undefined;
-}
-function indexByName(name, entry) {
-    let entries = classSerializersByName.get(name);
-    if (!entries) {
-        entries = new Set();
-        classSerializersByName.set(name, entries);
-    }
-    entries.add(entry);
-    if (entries.size > 1 && !warnedAmbiguousNames.has(name)) {
-        warnedAmbiguousNames.add(name);
-        console.warn(`[mion] registerClassSerializer: ${entries.size} different classes named "${name}" are registered. ` +
-            `The class-name fallback is disabled for "${name}" — only exact-instantiation matches will use the registry ` +
-            `(other generic instantiations of these classes fall back to structural decode).`);
-    }
-}
-function registerClassSerializer(cls, handler, id) {
-    if (typeof cls !== 'function')
-        throw new Error('registerClassSerializer: cls must be a class constructor');
-    const identity = classSerializerIdentity(id, cls);
-    let state = classStates.get(cls);
-    if (!state) {
-        state = { entry: { cls }, keys: new Set() };
-        classStates.set(cls, state);
-    }
-    state.entry.serialize = handler?.serialize;
-    state.entry.deserialize = handler?.deserialize;
-    state.keys.add(identity.typeId);
-    classSerializers.set(identity.typeId, state.entry);
-    const name = classSerializerName(identity, cls);
-    if (name && state.name === undefined) {
-        state.name = name;
-        indexByName(name, state.entry);
-    }
-    epoch++;
-}
-function getClassSerializer(typeId, className) {
-    const exact = classSerializers.get(typeId);
-    if (exact)
-        return exact;
-    if (!className)
-        return undefined;
-    const entries = classSerializersByName.get(className);
-    if (!entries || entries.size !== 1)
-        return undefined;
-    return entries.values().next().value;
-}
-function isClassSerializerRegistered(cls) {
-    return classStates.has(cls);
-}
-function deserializeClass(entry, data, keys) {
-    if (entry.deserialize)
-        return entry.deserialize(data);
-    let instance;
-    try {
-        instance = new entry.cls();
-    }
-    catch (err) {
-        const original = err instanceof Error ? err.message : String(err);
-        const name = entry.cls.name || '<anonymous>';
-        throw new Error(`[data-class-constructor-failed] Cannot reconstruct class "${name}": the automatic \`new ${name}()\` failed, ` +
-            `so its constructor needs arguments. Register a \`deserialize\` handler: ` +
-            `registerClassSerializer(${name}, {deserialize: (data) => new ${name}(/* … */)}). ` +
-            `Original error: ${original}`);
-    }
-    const source = data;
-    const target = instance;
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = source[key];
-        if (value !== undefined)
-            target[key] = value;
-    }
-    return instance;
-}
-function unregisterClassSerializer(cls) {
-    const state = classStates.get(cls);
-    if (!state)
-        return;
-    for (const key of state.keys)
-        classSerializers.delete(key);
-    if (state.name !== undefined) {
-        const entries = classSerializersByName.get(state.name);
-        entries?.delete(state.entry);
-        if (entries && entries.size === 0)
-            classSerializersByName.delete(state.name);
-    }
-    classStates.delete(cls);
-    epoch++;
-}
-function clearClassSerializers() {
-    classSerializers.clear();
-    classSerializersByName.clear();
-    classStates.clear();
-    warnedAmbiguousNames.clear();
-    epoch++;
-}

package/dist/cjs/runtypes/dataOnly.d.ts

@@ -1,29 +0,0 @@
-import type { __rtFormatName, __rtContains, __rtPatternProps, __rtPropNames } from './sentinelKeys.ts';
-type DataOnlyUrl = typeof globalThis extends {
-    URL: {
-        prototype: infer I;
-    };
-} ? I : never;
-export interface DataOnlyNativeExtra {
-    url: DataOnlyUrl;
-}
-type DataOnlyNative = Date | DataOnlyNativeExtra[keyof DataOnlyNativeExtra];
-type DataOnlyStripped = symbol | RegExp | ((...args: never[]) => unknown) | (abstract new (...args: never[]) => unknown) | {
-    then: (...args: never[]) => unknown;
-} | ArrayBuffer | SharedArrayBuffer | ArrayBufferView;
-type _DataOnlyDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
-export type DataOnly<T, Depth extends number = 8> = Depth extends 0 ? T : unknown extends T ? T : T extends DataOnlyStripped ? never : T extends string | number | boolean | bigint | null | undefined | DataOnlyNative ? T : DataOnlySentinelKept<T> extends true ? T : DataOnlyLadder<T, Depth>;
-type DataOnlySentinelKeys = typeof __rtFormatName | typeof __rtContains | typeof __rtPatternProps | typeof __rtPropNames;
-type DataOnlySentinelKept<T> = Extract<keyof T, DataOnlySentinelKeys> extends never ? (string extends keyof T ? DataOnlyRecordSentinelKept<T> : false) : true;
-type DataOnlySentinelProbe<X, Shape> = [X] extends [never] ? false : X extends Shape ? true : false;
-type DataOnlyProperStringLiteral<X> = [X] extends [never] ? false : string extends X ? false : X extends string ? true : false;
-type DataOnlyRecordSentinelKept<T> = true extends DataOnlyProperStringLiteral<NonNullable<T[typeof __rtFormatName & keyof T]>> | DataOnlySentinelProbe<NonNullable<T[typeof __rtPatternProps & keyof T]>, Record<string, {
-    rt$value: unknown;
-}>> | DataOnlySentinelProbe<NonNullable<T[typeof __rtPropNames & keyof T]>, string> ? true : false;
-type DataOnlyLadder<T, Depth extends number> = T extends ReadonlyMap<any, any> ? T extends ReadonlyMap<infer K, infer V> ? T extends Map<any, any> ? Map<DataOnly<K, _DataOnlyDepth[Depth]>, DataOnly<V, _DataOnlyDepth[Depth]>> : ReadonlyMap<DataOnly<K, _DataOnlyDepth[Depth]>, DataOnly<V, _DataOnlyDepth[Depth]>> : never : T extends ReadonlySet<any> ? T extends ReadonlySet<infer U> ? T extends Set<any> ? Set<DataOnly<U, _DataOnlyDepth[Depth]>> : ReadonlySet<DataOnly<U, _DataOnlyDepth[Depth]>> : never : T extends readonly unknown[] ? {
-    -readonly [K in keyof T]: DataOnly<T[K], _DataOnlyDepth[Depth]>;
-} : T extends object ? [keyof T] extends [never] ? T : {
-    [K in keyof T as K extends symbol | '__proto__' ? never : [DataOnly<T[K], _DataOnlyDepth[Depth]>] extends [undefined] ? [DataOnly<T[K], _DataOnlyDepth[Depth]>] extends [never] ? never : DataOnlyOptionalStripped<T, K> extends true ? never : K : K]: DataOnly<T[K], _DataOnlyDepth[Depth]>;
-} : T;
-type DataOnlyOptionalStripped<T, K extends keyof T> = [T[K]] extends [undefined] ? false : {} extends Record<K, never> ? false : {} extends Pick<T, K> ? true : false;
-export {};

package/dist/cjs/runtypes/dataOnly.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/runtypes/entryTuple.d.ts

@@ -1,101 +0,0 @@
-import type { RTUtils } from './rtUtils.ts';
-import type { AnyFn, CompiledFnArgs, CompiledFnData, CompiledPureFunction, CompiledTypeFn, RunType } from './types.ts';
-declare const KIND_RUN_TYPE = 0;
-declare const KIND_PURE_FN = 2;
-declare const KIND_MISSING = 3;
-declare const KIND_RUN_TYPE_BUNDLE = 4;
-declare const KIND_RUN_TYPE_FACADE = 5;
-export declare const FN_HASH_LEN = 4;
-export type EntryDepsThunk = () => readonly EntryTuple[];
-export type RunTypeIni = (rtu: RTUtils) => void;
-declare const RUN_TYPE_FIELD_KEYS: readonly ["id", "kind", "subKind", "typeName", "name", "literal", "optional", "readonly", "isAbstract", "isStatic", "visibility", "isSafeName", "position", "isCircular", "flags", "description", "defaultVal", "enumVal", "values", "notSupported", "nonEnumerable", "jsonMaxBytes"];
-export type RunTypeRowRecord = Pick<RunType, (typeof RUN_TYPE_FIELD_KEYS)[number]>;
-type RunTypeRel = number | string | object;
-export type RunTypeRelRow = readonly (RunTypeRel | readonly RunTypeRel[] | undefined)[];
-export interface RunTypeRecord extends RunTypeRowRecord {
-    entryKind: typeof KIND_RUN_TYPE;
-    deps: EntryDepsThunk | undefined;
-    ini: RunTypeIni | undefined;
-}
-export interface RunTypeBundleRecord {
-    entryKind: typeof KIND_RUN_TYPE_BUNDLE;
-    deps: EntryDepsThunk | undefined;
-    ini: RunTypeIni | undefined;
-    key: string;
-    rows: readonly RunTypeRow[];
-    rels: readonly (RunTypeRelRow | undefined)[];
-}
-export interface RunTypeFacadeRecord {
-    entryKind: typeof KIND_RUN_TYPE_FACADE;
-    deps: EntryDepsThunk | undefined;
-    ini: undefined;
-    key: string;
-}
-export interface FnTypeRecord extends Pick<CompiledTypeFn, 'rtFnHash' | 'typeName' | 'isNoop' | 'rtDependencies' | 'pureFnDependencies' | 'createRTFn' | 'alwaysThrowMessage'> {
-    familyTag: string;
-    deps: EntryDepsThunk | undefined;
-    ini: undefined;
-    code: CompiledFnData['code'] | undefined;
-}
-export interface PureFnRecord extends Pick<CompiledPureFunction, 'paramNames' | 'code' | 'pureFnDependencies' | 'createPureFn'> {
-    entryKind: typeof KIND_PURE_FN;
-    deps: EntryDepsThunk | undefined;
-    ini: undefined;
-    key: string;
-}
-export interface MissingRecord {
-    entryKind: typeof KIND_MISSING;
-    deps: undefined;
-    ini: undefined;
-    key: string;
-}
-type TupleFrom<R, K extends readonly (keyof R)[]> = {
-    [I in keyof K]: R[K[I]];
-};
-declare const ENTRY_HEAD_KEYS: readonly ["entryKind", "deps", "ini"];
-type RunTypeRowRequiredKeys = readonly ['id', 'kind'];
-type RunTypeRowTrimmedKeys = typeof RUN_TYPE_FIELD_KEYS extends readonly [unknown, unknown, ...infer Rest] ? Rest : never;
-export declare const RUN_TYPE_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "id", "kind", "subKind", "typeName", "name", "literal", "optional", "readonly", "isAbstract", "isStatic", "visibility", "isSafeName", "position", "isCircular", "flags", "description", "defaultVal", "enumVal", "values", "notSupported", "nonEnumerable", "jsonMaxBytes"];
-export declare const RUN_TYPE_BUNDLE_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "key", "rows", "rels"];
-export declare const RUN_TYPE_FACADE_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "key"];
-declare const FN_TYPE_REQUIRED_KEYS: readonly ["familyTag", "deps", "ini", "rtFnHash", "typeName"];
-declare const FN_TYPE_TRIMMED_KEYS: readonly ["code", "isNoop", "rtDependencies", "pureFnDependencies", "createRTFn", "alwaysThrowMessage"];
-export declare const FN_TYPE_TUPLE_KEYS: readonly ["familyTag", "deps", "ini", "rtFnHash", "typeName", "code", "isNoop", "rtDependencies", "pureFnDependencies", "createRTFn", "alwaysThrowMessage"];
-declare const PURE_FN_REQUIRED_KEYS: readonly ["entryKind", "deps", "ini", "key", "paramNames", "code", "pureFnDependencies"];
-declare const PURE_FN_TRIMMED_KEYS: readonly ["createPureFn"];
-export declare const PURE_FN_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "key", "paramNames", "code", "pureFnDependencies", "createPureFn"];
-declare const MISSING_TUPLE_KEYS: readonly ["entryKind", "deps", "ini", "key"];
-export type RunTypeRow = readonly [
-    ...TupleFrom<RunTypeRowRecord, RunTypeRowRequiredKeys>,
-    ...Partial<TupleFrom<RunTypeRowRecord, RunTypeRowTrimmedKeys>>
-];
-export type RunTypeTuple = readonly [
-    ...TupleFrom<RunTypeRecord, readonly [...typeof ENTRY_HEAD_KEYS, ...RunTypeRowRequiredKeys]>,
-    ...Partial<TupleFrom<RunTypeRecord, RunTypeRowTrimmedKeys>>
-];
-export type RunTypeBundleTuple = readonly [...TupleFrom<RunTypeBundleRecord, typeof RUN_TYPE_BUNDLE_TUPLE_KEYS>];
-export type RunTypeFacadeTuple = readonly [...TupleFrom<RunTypeFacadeRecord, typeof RUN_TYPE_FACADE_TUPLE_KEYS>];
-export type FnTypeTuple = readonly [
-    ...TupleFrom<FnTypeRecord, typeof FN_TYPE_REQUIRED_KEYS>,
-    ...Partial<TupleFrom<FnTypeRecord, typeof FN_TYPE_TRIMMED_KEYS>>
-];
-export type PureFnTuple = readonly [
-    ...TupleFrom<PureFnRecord, typeof PURE_FN_REQUIRED_KEYS>,
-    ...Partial<TupleFrom<PureFnRecord, typeof PURE_FN_TRIMMED_KEYS>>
-];
-export type MissingTuple = readonly [...TupleFrom<MissingRecord, typeof MISSING_TUPLE_KEYS>];
-export type EntryTuple = RunTypeTuple | RunTypeBundleTuple | RunTypeFacadeTuple | FnTypeTuple | PureFnTuple | MissingTuple;
-export declare function isEntryTuple(value: unknown): value is EntryTuple;
-export declare function entryTupleKey(tuple: EntryTuple): string;
-export declare function isMissingTuple(value: unknown): boolean;
-interface FamilyMeta {
-    fnID: string;
-    args: () => CompiledFnArgs;
-    defaultParamValues: () => CompiledFnArgs;
-    noop: AnyFn;
-}
-export declare const familyMeta: Record<string, FamilyMeta>;
-export declare function initFromTuple(root: EntryTuple): void;
-export declare function entryTupleAt(injected: unknown, index: number): EntryTuple | undefined;
-export declare function resolveEntryTupleFn<F extends AnyFn>(fnName: string, identityFn: F, runTypeId: string | undefined, injected: unknown): F;
-export {};

package/dist/cjs/runtypes/entryTuple.js

@@ -1,395 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.familyMeta = exports.PURE_FN_TUPLE_KEYS = exports.FN_TYPE_TUPLE_KEYS = exports.RUN_TYPE_FACADE_TUPLE_KEYS = exports.RUN_TYPE_BUNDLE_TUPLE_KEYS = exports.RUN_TYPE_TUPLE_KEYS = exports.FN_HASH_LEN = void 0;
-exports.isEntryTuple = isEntryTuple;
-exports.entryTupleKey = entryTupleKey;
-exports.isMissingTuple = isMissingTuple;
-exports.initFromTuple = initFromTuple;
-exports.entryTupleAt = entryTupleAt;
-exports.resolveEntryTupleFn = resolveEntryTupleFn;
-const rtUtils_ts_1 = require("./rtUtils.js");
-const KIND_RUN_TYPE = 0;
-const KIND_PURE_FN = 2;
-const KIND_MISSING = 3;
-const KIND_RUN_TYPE_BUNDLE = 4;
-const KIND_RUN_TYPE_FACADE = 5;
-exports.FN_HASH_LEN = 4;
-const RUN_TYPE_FIELD_KEYS = [
-    'id',
-    'kind',
-    'subKind',
-    'typeName',
-    'name',
-    'literal',
-    'optional',
-    'readonly',
-    'isAbstract',
-    'isStatic',
-    'visibility',
-    'isSafeName',
-    'position',
-    'isCircular',
-    'flags',
-    'description',
-    'defaultVal',
-    'enumVal',
-    'values',
-    'notSupported',
-    'nonEnumerable',
-    'jsonMaxBytes',
-];
-const RUN_TYPE_REL_KEYS = [
-    'child',
-    'children',
-    'index',
-    'return',
-    'indexType',
-    'parameters',
-    'safeUnionChildren',
-    'unionDiscriminators',
-    'typeMeta',
-    'typeArguments',
-    'arguments',
-    'extendsArguments',
-    'implements',
-    'extends',
-];
-const RUN_TYPE_REL_IS_ARRAY = [
-    false,
-    true,
-    false,
-    false,
-    false,
-    true,
-    true,
-    true,
-    true,
-    true,
-    true,
-    true,
-    true,
-    true,
-];
-const ENTRY_HEAD_KEYS = ['entryKind', 'deps', 'ini'];
-exports.RUN_TYPE_TUPLE_KEYS = [...ENTRY_HEAD_KEYS, ...RUN_TYPE_FIELD_KEYS];
-exports.RUN_TYPE_BUNDLE_TUPLE_KEYS = [...ENTRY_HEAD_KEYS, 'key', 'rows', 'rels'];
-exports.RUN_TYPE_FACADE_TUPLE_KEYS = [...ENTRY_HEAD_KEYS, 'key'];
-const FN_TYPE_REQUIRED_KEYS = ['familyTag', 'deps', 'ini', 'rtFnHash', 'typeName'];
-const FN_TYPE_TRIMMED_KEYS = [
-    'code',
-    'isNoop',
-    'rtDependencies',
-    'pureFnDependencies',
-    'createRTFn',
-    'alwaysThrowMessage',
-];
-exports.FN_TYPE_TUPLE_KEYS = [...FN_TYPE_REQUIRED_KEYS, ...FN_TYPE_TRIMMED_KEYS];
-const PURE_FN_REQUIRED_KEYS = [...ENTRY_HEAD_KEYS, 'key', 'paramNames', 'code', 'pureFnDependencies'];
-const PURE_FN_TRIMMED_KEYS = ['createPureFn'];
-exports.PURE_FN_TUPLE_KEYS = [...PURE_FN_REQUIRED_KEYS, ...PURE_FN_TRIMMED_KEYS];
-const MISSING_TUPLE_KEYS = [...ENTRY_HEAD_KEYS, 'key'];
-const SLOT_KIND = 0;
-const SLOT_DEPS = 1;
-const SLOT_KEY = 3;
-const SLOT_ROWS = 4;
-const SLOT_RELS = 5;
-const _pinBundleRels = exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_RELS];
-void _pinBundleRels;
-const _pinBundleHead = [
-    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_KIND],
-    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_DEPS],
-    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[2],
-    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_KEY],
-    exports.RUN_TYPE_BUNDLE_TUPLE_KEYS[SLOT_ROWS],
-];
-const _pinFacadeHead = [
-    exports.RUN_TYPE_FACADE_TUPLE_KEYS[SLOT_KIND],
-    exports.RUN_TYPE_FACADE_TUPLE_KEYS[SLOT_DEPS],
-    exports.RUN_TYPE_FACADE_TUPLE_KEYS[2],
-    exports.RUN_TYPE_FACADE_TUPLE_KEYS[SLOT_KEY],
-];
-const _pinFnTypeHead = [
-    exports.FN_TYPE_TUPLE_KEYS[SLOT_KIND],
-    exports.FN_TYPE_TUPLE_KEYS[SLOT_DEPS],
-    exports.FN_TYPE_TUPLE_KEYS[2],
-    exports.FN_TYPE_TUPLE_KEYS[SLOT_KEY],
-];
-const _pinPureFnHead = [
-    exports.PURE_FN_TUPLE_KEYS[SLOT_KIND],
-    exports.PURE_FN_TUPLE_KEYS[SLOT_DEPS],
-    exports.PURE_FN_TUPLE_KEYS[2],
-    exports.PURE_FN_TUPLE_KEYS[SLOT_KEY],
-];
-const _pinMissingHead = [
-    MISSING_TUPLE_KEYS[SLOT_KIND],
-    MISSING_TUPLE_KEYS[SLOT_DEPS],
-    MISSING_TUPLE_KEYS[2],
-    MISSING_TUPLE_KEYS[SLOT_KEY],
-];
-void _pinBundleHead;
-void _pinFacadeHead;
-void _pinFnTypeHead;
-void _pinPureFnHead;
-void _pinMissingHead;
-function tupleToRecord(keys, tuple) {
-    const record = {};
-    for (let index = 0; index < keys.length; index++) {
-        record[keys[index]] = tuple[index];
-    }
-    return record;
-}
-function isEntryTuple(value) {
-    if (isMissingTuple(value))
-        return true;
-    if (!Array.isArray(value) || value.length <= SLOT_KEY)
-        return false;
-    const deps = value[SLOT_DEPS];
-    return (typeof deps === 'function' || deps === undefined) && typeof value[SLOT_KEY] === 'string';
-}
-function entryTupleKey(tuple) {
-    return tuple[SLOT_KEY];
-}
-function isMissingTuple(value) {
-    return Array.isArray(value) && value[SLOT_KIND] === KIND_MISSING;
-}
-const noopTrue = () => true;
-const noopIdentity = (v) => v;
-const noopErrors = (_v, _pth, er) => er || [];
-const noopStringify = (v) => JSON.stringify(v);
-const noopParse = (s) => JSON.parse(s);
-const valueArgs = () => ({ vλl: 'v' });
-const valueDefaults = () => ({ vλl: '' });
-const errorArgs = () => ({ vλl: 'v', pλth: 'pth', εrr: 'er' });
-const errorDefaults = () => ({ vλl: '', pλth: '[]', εrr: '[]' });
-const valueShaped = (fnID, noop) => ({ fnID, args: valueArgs, defaultParamValues: valueDefaults, noop });
-const errorShaped = (fnID) => ({ fnID, args: errorArgs, defaultParamValues: errorDefaults, noop: noopErrors });
-exports.familyMeta = {
-    val: valueShaped('val', noopTrue),
-    verr: errorShaped('verr'),
-    vst: valueShaped('vst', noopTrue),
-    vest: errorShaped('vest'),
-    vuk: valueShaped('vuk', noopTrue),
-    veuk: errorShaped('veuk'),
-    pj: valueShaped('pj', noopIdentity),
-    rj: valueShaped('rj', noopIdentity),
-    pjs: valueShaped('pjs', noopIdentity),
-    cj: valueShaped('cj', noopIdentity),
-    cjr: valueShaped('cjr', noopIdentity),
-    rjs: valueShaped('rjs', noopIdentity),
-    ruk: valueShaped('ruk', noopIdentity),
-    ruks: valueShaped('ruks', noopIdentity),
-    rukr: valueShaped('rukr', noopIdentity),
-    csr: valueShaped('csr', noopIdentity),
-    fmt: valueShaped('fmt', noopIdentity),
-    jsc: valueShaped('jsc', () => ({})),
-    jeCL: valueShaped('pj', noopStringify),
-    jeMU: valueShaped('pj', noopStringify),
-    jeCO: valueShaped('pj', noopStringify),
-    jdCL: valueShaped('rj', noopParse),
-    jdMU: valueShaped('rj', noopParse),
-    jdCO: valueShaped('rj', noopParse),
-};
-const processedKeys = new Set();
-function initFromTuple(root) {
-    if (isMissingTuple(root))
-        return;
-    if (!isEntryTuple(root))
-        return;
-    const utils = (0, rtUtils_ts_1.getRTUtils)();
-    const fresh = [];
-    collectClosure(root, utils, fresh, new Set());
-    for (const tuple of fresh) {
-        if (tuple[SLOT_KIND] === KIND_RUN_TYPE_BUNDLE)
-            wireBundleRelations(utils, tuple);
-        const ini = tuple[2];
-        if (typeof ini === 'function')
-            ini(utils);
-    }
-}
-function wireBundleRelations(utils, tuple) {
-    const rows = (tuple[SLOT_ROWS] ?? []);
-    const rels = (tuple[SLOT_RELS] ?? []);
-    const added = addedRows.get(tuple);
-    if (rels.length === 0 || !added)
-        return;
-    const byIndex = rows.map((row) => utils.getRunType(row[0]));
-    const resolve = (rel) => typeof rel === 'number' ? byIndex[rel] : typeof rel === 'string' ? utils.getRunType(rel) : rel;
-    for (const i of added) {
-        const relRow = rels[i];
-        if (!relRow)
-            continue;
-        const runType = byIndex[i];
-        if (!runType)
-            continue;
-        const target = runType;
-        for (let slot = 0; slot < RUN_TYPE_REL_KEYS.length; slot++) {
-            const value = relRow[slot];
-            if (value === undefined)
-                continue;
-            target[RUN_TYPE_REL_KEYS[slot]] = RUN_TYPE_REL_IS_ARRAY[slot] ? value.map(resolve) : resolve(value);
-        }
-    }
-}
-function collectClosure(tuple, utils, fresh, visiting) {
-    if (!isEntryTuple(tuple) || isMissingTuple(tuple))
-        return;
-    const key = entryTupleKey(tuple);
-    if (visiting.has(key))
-        return;
-    visiting.add(key);
-    if (processedKeys.has(key) && isStillRegistered(utils, tuple))
-        return;
-    processedKeys.add(key);
-    const deps = tuple[SLOT_DEPS];
-    if (deps)
-        for (const dep of deps())
-            collectClosure(dep, utils, fresh, visiting);
-    if (registerTuple(utils, tuple))
-        fresh.push(tuple);
-}
-function isStillRegistered(utils, tuple) {
-    const slot0 = tuple[SLOT_KIND];
-    const key = entryTupleKey(tuple);
-    if (typeof slot0 === 'string')
-        return utils.hasRTFn(key);
-    if (slot0 === KIND_RUN_TYPE)
-        return utils.hasRunType(key);
-    if (slot0 === KIND_PURE_FN)
-        return utils.hasPureFnByKey(key);
-    if (slot0 === KIND_RUN_TYPE_BUNDLE) {
-        const rows = (tuple[SLOT_ROWS] ?? []);
-        return rows.length === 0 || utils.hasRunType(rows[0][0]);
-    }
-    return true;
-}
-function registerTuple(utils, tuple) {
-    const slot0 = tuple[SLOT_KIND];
-    if (typeof slot0 === 'string')
-        return registerTypeFnTuple(utils, tuple);
-    if (slot0 === KIND_RUN_TYPE_BUNDLE)
-        return registerRunTypeBundle(utils, tuple);
-    if (slot0 === KIND_RUN_TYPE)
-        return registerRunTypeTuple(utils, tuple);
-    if (slot0 === KIND_PURE_FN)
-        return registerPureFnTuple(utils, tuple);
-    if (slot0 === KIND_RUN_TYPE_FACADE)
-        return false;
-    return false;
-}
-function runTypeEntryFromRecord(record) {
-    return {
-        ...record,
-        child: undefined,
-        index: undefined,
-        return: undefined,
-        indexType: undefined,
-        parameters: undefined,
-        children: undefined,
-        safeUnionChildren: undefined,
-        unionDiscriminators: undefined,
-        typeMeta: undefined,
-        typeArguments: undefined,
-        arguments: undefined,
-        extendsArguments: undefined,
-        implements: undefined,
-        extends: undefined,
-        classType: undefined,
-    };
-}
-function registerRunTypeTuple(utils, tuple) {
-    const record = tupleToRecord(exports.RUN_TYPE_TUPLE_KEYS, tuple);
-    if (utils.hasRunType(record.id))
-        return false;
-    utils.addRunType(record.id, runTypeEntryFromRecord(record));
-    return true;
-}
-const addedRows = new WeakMap();
-function registerRunTypeBundle(utils, tuple) {
-    const rows = (tuple[SLOT_ROWS] ?? []);
-    const added = [];
-    rows.forEach((row, index) => {
-        const record = tupleToRecord(RUN_TYPE_FIELD_KEYS, row);
-        const existing = utils.getRunType(record.id);
-        if (!existing) {
-            utils.addRunType(record.id, runTypeEntryFromRecord(record));
-            added.push(index);
-        }
-        else if (existing.jsonMaxBytes === undefined && record.jsonMaxBytes !== undefined) {
-            existing.jsonMaxBytes = record.jsonMaxBytes;
-        }
-    });
-    if (added.length)
-        addedRows.set(tuple, added);
-    return added.length > 0;
-}
-function registerTypeFnTuple(utils, tuple) {
-    const record = tupleToRecord(exports.FN_TYPE_TUPLE_KEYS, tuple);
-    if (utils.hasRTFn(record.rtFnHash))
-        return false;
-    const meta = exports.familyMeta[record.familyTag];
-    if (!meta)
-        return false;
-    const isNoop = record.isNoop === true;
-    const entry = {
-        rtFnHash: record.rtFnHash,
-        fnID: meta.fnID,
-        familyTag: record.familyTag,
-        typeName: record.typeName,
-        args: meta.args(),
-        defaultParamValues: meta.defaultParamValues(),
-        code: record.code,
-        isNoop,
-        rtDependencies: record.rtDependencies,
-        pureFnDependencies: record.pureFnDependencies,
-        createRTFn: record.alwaysThrowMessage !== undefined
-            ? utils.alwaysThrowFactory(record.alwaysThrowMessage)
-            : record.createRTFn,
-        fn: isNoop ? meta.noop : undefined,
-        alwaysThrowMessage: record.alwaysThrowMessage,
-    };
-    utils.addToRTCache(entry);
-    return true;
-}
-function registerPureFnTuple(utils, tuple) {
-    const record = tupleToRecord(exports.PURE_FN_TUPLE_KEYS, tuple);
-    if (utils.hasPureFnByKey(record.key))
-        return false;
-    const entry = {
-        id: record.key,
-        paramNames: record.paramNames,
-        code: record.code,
-        pureFnDependencies: record.pureFnDependencies,
-        createPureFn: record.createPureFn,
-        fn: undefined,
-    };
-    utils.addPureFn(record.key, entry);
-    return true;
-}
-function entryTupleAt(injected, index) {
-    const tuples = injected;
-    return tuples ? tuples[index] : undefined;
-}
-function resolveEntryTupleFn(fnName, identityFn, runTypeId, injected) {
-    const utils = (0, rtUtils_ts_1.getRTUtils)();
-    if (isMissingTuple(injected))
-        return identityFn;
-    if (!isEntryTuple(injected)) {
-        if (runTypeId === undefined) {
-            throw new Error(`${fnName}(): no id injected. @mionjs/devtools must be active for ${fnName} to dispatch to a precompiled factory.`);
-        }
-        if (utils.knowsType(runTypeId))
-            return identityFn;
-        throw new Error(`${fnName}(): no RTCompiledFn entry for run-type id "${runTypeId}" in rtUtils.`);
-    }
-    initFromTuple(injected);
-    let key = entryTupleKey(injected);
-    if (runTypeId !== undefined)
-        key = key.slice(0, exports.FN_HASH_LEN) + '_' + runTypeId;
-    const typeId = key.slice(exports.FN_HASH_LEN + 1);
-    const entry = utils.getRT(key);
-    if (entry)
-        return entry.fn;
-    if (utils.knowsType(typeId))
-        return identityFn;
-    throw new Error(`${fnName}(): no RTCompiledFn entry for "${key}" in rtUtils. The build pipeline didn't emit a factory for that runtype.`);
-}

package/dist/cjs/runtypes/formatAnnotation.d.ts

@@ -1,4 +0,0 @@
-export interface FormatAnnotation<Params extends object = Record<string, unknown>> {
-    name: string;
-    params?: Params;
-}

package/dist/cjs/runtypes/formatAnnotation.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });