@mionjs/run-types 0.8.8 → 0.13.0

package/skills/runtypes-mock-data/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: runtypes-mock-data
+description: Author MockData<T> pools/ranges for createMockDataFn<T>(). Use for realistic mock data, fixtures, seeds.
+---
+
+# Authoring & using `MockData<T>`
+
+- One of two AI-enrichment artifacts in RunTypes. Other: `FriendlyText<T>` (`runtypes-friendly-text` skill).
+- Enrichment is authored once, committed, validated against the type. CLI loop: `rt-enrich-types` skill.
+- Full design: [docs/AI_ENRICHMENT.md](https://github.com/MionKit/mion/blob/main/docs/AI_ENRICHMENT.md).
+- `MockData<T>` = per-field **realistic sample values** (pools, ranges, element + length hints, optional-probability).
+- Feeds `createMockDataFn<T>()`. Generator stays deterministic; map only supplies realistic _values_
+  (believable name, plausible age, valid email).
+
+## When to use it
+
+- `createMockDataFn<T>()` values unrealistic (random strings for names, out-of-domain numbers).
+- Building test fixtures / seed data: pools of real-looking values, still **guaranteed valid** for the type.
+- Scaffolding a type's committed mock mirror file.
+- Random-but-valid is fine → no `data`: generator already mocks every shape (incl. `Date`, `Map`, `Set`).
+
+## Shipped vs designed
+
+- **Shipped**, both exported from `@mionjs/run-types`:
+  - `MockData<T>` DSL type ([`mockData.ts`][md]).
+  - `{ data }` option on `createMockDataFn<T>()` ([`createMockData.ts`][cmd]):
+    `createMockDataFn<T>(undefined, { data })` draws values from the authored pools / ranges.
+  - `enrich` / `enrich --no-emit` CLI: scaffolds the mock mirror file, cross-checks it against the live type
+    (enrich-mock-unknown-field: key not a field of `T`, Warning).
+- **Designed (not yet wired into `enrich --no-emit`):**
+  - enrich-mock-invalid-pool (Error): compiler checks **every pool / range value** against field type + format.
+    At build time, not test runtime (malformed email in the `email` pool). Needs the runtime validator.
+  - enrich-mock-shape-mismatch: structural mismatch, left to the `MockData<T>` mapped type.
+  - enrich-mock-inverted-range: `min > max` / inverted `rt$length`.
+  - enrich-mock-small-pool: pool below a configured floor, off by default.
+- Map is type-checked against `T` by the `MockData<T>` mapped type today regardless.
+
+## Node model: per-field pools / ranges
+
+One recursive node, uniform at every depth. Shape per field kind:
+
+- string → `{ pool: string[] }`
+- number → `{ pool: number[]; min?: number; max?: number }`
+- `Date` → `{ pool: Date[]; min?: Date; max?: Date }`
+- boolean / bigint → `{ pool: boolean[] }` / `{ pool: bigint[] }`
+- array / rest tuple → `{ rt$items: <element node>; rt$length?: number | [number, number] }`
+- fixed tuple → `{ rt$slots: [<node per slot>] }`: positional, fixed length, no `rt$length`
+- `Map` → `{ rt$keys, rt$values: <node>; rt$size?: number | [number, number] }`
+- `Set` → `{ rt$values: <node>; rt$size?: number | [number, number] }`
+- object → `{ [K in keyof T]-?: <child node> } & { rt$optional?: number }`
+
+- **`pool`**: pick a value at random from this list. Empty (`pool: []`) → draw from `min` / `max` instead.
+- **`min` / `max`**: inclusive bounds (numbers, `Date`s).
+- **`rt$items`**: element node for array (and rest-tuple) members. **`rt$slots`**: one node per fixed-tuple position.
+- **`rt$length`**: array length, fixed (`3`) or `[min, max]` range. **`rt$size`**: the Map/Set equivalent.
+- **`rt$optional`**: present-probability (0..1) for optional members on an object node.
+
+## Where the map lives
+
+- Mock mirror file at the type's **definition**: `src/models/user.ts` → `<genDir>/enriched/mock/src/models/user.ts`.
+  Default: `src/.mion/enriched/mock/src/models/user.ts`. Holds `mock<Name>` consts.
+- Layout rules (genDir, `rootDir`, one home per type): `rt-enrich-types` skill.
+- `MockData<T>` is generated **demand-driven**: only for types consumed by a `createMockDataFn` call.
+
+## Feeding it to `createMockDataFn<T>()`
+
+Import the map from the mirror, pass it via `data` (plain, greppable wiring, no injection):
+
+```ts
+import {createMockDataFn} from '@mionjs/run-types/mocking';
+import {mockUser} from '../.mion/enriched/mock/src/models/user';
+import type {User} from '../models/user';
+
+const makeUser = createMockDataFn<User>(undefined, {data: mockUser});
+const sample = makeUser(); // realistic, type-valid User
+```
+
+- `data` rides the same options bag as `{ mock }`: `createMockDataFn<T>(undefined, { data, mock })`.
+- No `data` → mocks mechanically, exactly as before.
+
+End-to-end example (type, filled mirror, consumer) → [example.md](example.md). Read before filling a first map.
+
+## Authoring checklist
+
+- Map goes in the **definition's mock mirror file** (`<genDir>/enriched/mock/<rel>.ts`), not the consumer's file.
+- Type it `MockData<T>` so structure is checked against `T`.
+- `pool` for enumerable/realistic values (names, emails, tags). `min`/`max` for numeric and `Date` ranges.
+- Keep every pool/range value **valid for the field's type + format**.
+  enrich-mock-invalid-pool will reject `score: 150` against `TF.Number<{max: 100}>`.
+- Keep mock pools out of production bundles: import them from tests/seeds only (normal tree-shaking handles it).
+- Aim for a healthy pool size: design notes a floor around 50 for realistic variation.
+  enrich-mock-small-pool is an off-by-default nudge.
+
+[md]: https://github.com/MionKit/mion/blob/main/packages/run-types/src/enrich/mockData.ts
+[cmd]: https://github.com/MionKit/mion/blob/main/packages/run-types/src/mocking/createMockData.ts

package/skills/runtypes-mock-data/example.md

@@ -0,0 +1,54 @@
+# MockData end-to-end example
+
+Type definition → filled mock mirror → consumer.
+
+```ts
+// src/models/user.ts: the DEFINITION
+import type * as TF from '@mionjs/run-types/formats';
+
+export interface User {
+  name: string;
+  age: TF.Number<{min: 0; max: 120}>;
+  tags: string[];
+  profile: {
+    email: TF.Email;
+    score: TF.Number<{min: 0; max: 100}>;
+  };
+}
+```
+
+```ts
+// src/.mion/enriched/mock/src/models/user.ts: the committed mock mirror
+import type {User} from '../../../../../models/user';
+import type {MockData} from '@mionjs/run-types';
+
+export const mockUser: MockData<User> = {
+  name: {pool: ['Alice Martin', 'Liang Wei', 'Fatima Noor', 'Diego Ramirez']},
+  age: {pool: [], min: 18, max: 95}, // empty pool: draw from the range
+  tags: {
+    rt$items: {pool: ['urgent', 'beta', 'vip']}, // element node
+    rt$length: [1, 4], // 1 to 4 tags
+  },
+  profile: {
+    email: {pool: ['alice@example.com', 'liang@corp.io', 'fatima@mail.net']},
+    score: {pool: [], min: 0, max: 100},
+  },
+};
+```
+
+```ts
+// src/test/fixtures.ts: the CONSUMER
+import {createMockDataFn} from '@mionjs/run-types/mocking';
+import {mockUser} from '../.mion/enriched/mock/src/models/user';
+import type {User} from '../models/user';
+
+const makeUser = createMockDataFn<User>(undefined, {data: mockUser});
+
+const fixture = makeUser();
+// e.g. { name: 'Liang Wei', age: 41, tags: ['beta','vip'],
+//        profile: { email: 'alice@example.com', score: 72 } }
+```
+
+- Every value above satisfies `User`.
+- Once enrich-mock-invalid-pool is wired into `enrich --no-emit`: a stray `age: 200` or `email: 'nope'`
+  in the map fails the build, never the test.

package/.dist/cjs/index.cjs

@@ -1,209 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_types = require("./src/types.cjs");
-const src_constants_functions = require("./src/constants.functions.cjs");
-const src_constants_kind = require("./src/constants.kind.cjs");
-const src_constants = require("./src/constants.cjs");
-const src_createRunType = require("./src/createRunType.cjs");
-const src_createRunTypeFunctions = require("./src/createRunTypeFunctions.cjs");
-const src_formats_runtype = require("./src/formats.runtype.cjs");
-const src_lib_typeId = require("./src/lib/typeId.cjs");
-const src_lib_dkProxy = require("./src/lib/dkProxy.cjs");
-const src_lib_baseRunTypeFormat = require("./src/lib/baseRunTypeFormat.cjs");
-const src_lib_baseRunTypes = require("./src/lib/baseRunTypes.cjs");
-const src_lib_formats = require("./src/lib/formats.cjs");
-const src_lib_guards = require("./src/lib/guards.cjs");
-const src_lib_jitFnCompiler = require("./src/lib/jitFnCompiler.cjs");
-const src_lib_jitFnsRegistry = require("./src/lib/jitFnsRegistry.cjs");
-const src_mocking_constants_mock = require("./src/mocking/constants.mock.cjs");
-const src_mocking_mockRegistry = require("./src/mocking/mockRegistry.cjs");
-const src_mocking_mockType = require("./src/mocking/mockType.cjs");
-const src_mocking_mockUtils = require("./src/mocking/mockUtils.cjs");
-const src_runTypesPureFns = require("./src/run-types-pure-fns.cjs");
-exports.__ΩAnyClass = src_types.__ΩAnyClass;
-exports.__ΩAnyFunction = src_types.__ΩAnyFunction;
-exports.__ΩAnyParameterListRunType = src_types.__ΩAnyParameterListRunType;
-exports.__ΩCustomVλl = src_types.__ΩCustomVλl;
-exports.__ΩDKAnnotation = src_types.__ΩDKAnnotation;
-exports.__ΩDeepPartial = src_types.__ΩDeepPartial;
-exports.__ΩDeepRequired = src_types.__ΩDeepRequired;
-exports.__ΩFormatAnnotation = src_types.__ΩFormatAnnotation;
-exports.__ΩJitCode = src_types.__ΩJitCode;
-exports.__ΩJitCompilerOpts = src_types.__ΩJitCompilerOpts;
-exports.__ΩJitFn = src_types.__ΩJitFn;
-exports.__ΩJitFnID = src_types.__ΩJitFnID;
-exports.__ΩMockOperation = src_types.__ΩMockOperation;
-exports.__ΩMockOptions = src_types.__ΩMockOptions;
-exports.__ΩMutable = src_types.__ΩMutable;
-exports.__ΩPartialRunTypeOptions = src_types.__ΩPartialRunTypeOptions;
-exports.__ΩRunType = src_types.__ΩRunType;
-exports.__ΩRunTypeAnnotation = src_types.__ΩRunTypeAnnotation;
-exports.__ΩRunTypeChildAccessor = src_types.__ΩRunTypeChildAccessor;
-exports.__ΩRunTypeFamily = src_types.__ΩRunTypeFamily;
-exports.__ΩRunTypeOptions = src_types.__ΩRunTypeOptions;
-exports.__ΩRunTypeVisitor = src_types.__ΩRunTypeVisitor;
-exports.__ΩSrcCollection = src_types.__ΩSrcCollection;
-exports.__ΩSrcMember = src_types.__ΩSrcMember;
-exports.__ΩSrcType = src_types.__ΩSrcType;
-exports.__ΩStrNumber = src_types.__ΩStrNumber;
-exports.__ΩSubKind = src_types.__ΩSubKind;
-exports.CodeTypes = src_constants_functions.CodeTypes;
-exports.JitFunctions = src_constants_functions.JitFunctions;
-exports.__ΩCodeType = src_constants_functions.__ΩCodeType;
-exports.__ΩJitFnSettings = src_constants_functions.__ΩJitFnSettings;
-exports.jitArgs = src_constants_functions.jitArgs;
-exports.jitArgsWithOptions = src_constants_functions.jitArgsWithOptions;
-exports.jitBinaryDeserializerArgs = src_constants_functions.jitBinaryDeserializerArgs;
-exports.jitBinarySerializerArgs = src_constants_functions.jitBinarySerializerArgs;
-exports.jitDefaultArgs = src_constants_functions.jitDefaultArgs;
-exports.jitDefaultArgsWithOptions = src_constants_functions.jitDefaultArgsWithOptions;
-exports.jitDefaultBinaryDeserializerArgs = src_constants_functions.jitDefaultBinaryDeserializerArgs;
-exports.jitDefaultBinarySerializerArgs = src_constants_functions.jitDefaultBinarySerializerArgs;
-exports.jitDefaultErrorArgs = src_constants_functions.jitDefaultErrorArgs;
-exports.jitErrorArgs = src_constants_functions.jitErrorArgs;
-exports.jitFunctionList = src_constants_functions.jitFunctionList;
-exports.jitFunctionsById = src_constants_functions.jitFunctionsById;
-exports.jitSerializationFunctions = src_constants_functions.jitSerializationFunctions;
-exports.jitValidationFunctions = src_constants_functions.jitValidationFunctions;
-exports.ReflectionKindName = src_constants_kind.ReflectionKindName;
-exports.ReflectionSubKind = src_constants_kind.ReflectionSubKind;
-exports.ReflectionSubNames = src_constants_kind.ReflectionSubNames;
-exports.__ΩAnyKindName = src_constants_kind.__ΩAnyKindName;
-exports.getReflectionName = src_constants_kind.getReflectionName;
-exports.JIT_STACK_TRACE_MESSAGE = src_constants.JIT_STACK_TRACE_MESSAGE;
-exports.MAX_UNION_ITEMS = src_constants.MAX_UNION_ITEMS;
-exports.maxStackErrorMessage = src_constants.maxStackErrorMessage;
-exports.nativeUtilityStringTypes = src_constants.nativeUtilityStringTypes;
-exports.nonSerializableClasses = src_constants.nonSerializableClasses;
-exports.nonSerializableGlobals = src_constants.nonSerializableGlobals;
-exports.validPropertyNameRegExp = src_constants.validPropertyNameRegExp;
-exports.reflectFunction = src_createRunType.reflectFunction;
-exports.runType = src_createRunType.runType;
-exports.createFromBinaryFn = src_createRunTypeFunctions.createFromBinaryFn;
-exports.createIsTypeFn = src_createRunTypeFunctions.createIsTypeFn;
-exports.createMockTypeFn = src_createRunTypeFunctions.createMockTypeFn;
-exports.createPrepareForJsonFn = src_createRunTypeFunctions.createPrepareForJsonFn;
-exports.createRestoreFromJsonFn = src_createRunTypeFunctions.createRestoreFromJsonFn;
-exports.createStringifyJsonFn = src_createRunTypeFunctions.createStringifyJsonFn;
-exports.createToBinaryFn = src_createRunTypeFunctions.createToBinaryFn;
-exports.createToJavascriptFn = src_createRunTypeFunctions.createToJavascriptFn;
-exports.createTypeErrorsFn = src_createRunTypeFunctions.createTypeErrorsFn;
-exports.__ΩTypeFormat = src_formats_runtype.__ΩTypeFormat;
-exports.computeDeepkitFormatID = src_lib_typeId.computeDeepkitFormatID;
-exports.createTypeId = src_lib_typeId.createTypeId;
-exports.getParsedAnnotationOptions = src_lib_dkProxy.getParsedAnnotationOptions;
-exports.getRunTypeAnnotations = src_lib_dkProxy.getRunTypeAnnotations;
-exports.getTypeToObject = src_lib_dkProxy.getTypeToObject;
-exports.BaseRunTypeFormat = src_lib_baseRunTypeFormat.BaseRunTypeFormat;
-exports.AtomicRunType = src_lib_baseRunTypes.AtomicRunType;
-exports.BaseRunType = src_lib_baseRunTypes.BaseRunType;
-exports.CollectionRunType = src_lib_baseRunTypes.CollectionRunType;
-exports.MemberRunType = src_lib_baseRunTypes.MemberRunType;
-exports.defaultIgnoreFormatProps = src_lib_formats.defaultIgnoreFormatProps;
-exports.dependenciesToLiteral = src_lib_formats.dependenciesToLiteral;
-exports.getFormatAnnotation = src_lib_formats.getFormatAnnotation;
-exports.getFormatterFromCache = src_lib_formats.getFormatterFromCache;
-exports.getFormatterKey = src_lib_formats.getFormatterKey;
-exports.getFormatterParams = src_lib_formats.getFormatterParams;
-exports.getRunTypeFormat = src_lib_formats.getRunTypeFormat;
-exports.getRunTypeTransformer = src_lib_formats.getRunTypeTransformer;
-exports.getToLiteralFn = src_lib_formats.getToLiteralFn;
-exports.initFormatAnnotations = src_lib_formats.initFormatAnnotations;
-exports.paramsToLiteral = src_lib_formats.paramsToLiteral;
-exports.registerFormatter = src_lib_formats.registerFormatter;
-exports.hasArguments = src_lib_guards.hasArguments;
-exports.hasExtends = src_lib_guards.hasExtends;
-exports.hasExtendsArguments = src_lib_guards.hasExtendsArguments;
-exports.hasImplements = src_lib_guards.hasImplements;
-exports.hasIndexType = src_lib_guards.hasIndexType;
-exports.hasMembers = src_lib_guards.hasMembers;
-exports.hasParameters = src_lib_guards.hasParameters;
-exports.hasReturn = src_lib_guards.hasReturn;
-exports.hasType = src_lib_guards.hasType;
-exports.hasTypeArguments = src_lib_guards.hasTypeArguments;
-exports.hasTypeParameters = src_lib_guards.hasTypeParameters;
-exports.hasTypes = src_lib_guards.hasTypes;
-exports.isAnyFunctionRunType = src_lib_guards.isAnyFunctionRunType;
-exports.isAnyRunType = src_lib_guards.isAnyRunType;
-exports.isArrayRunType = src_lib_guards.isArrayRunType;
-exports.isAtomicRunType = src_lib_guards.isAtomicRunType;
-exports.isBigIntRunType = src_lib_guards.isBigIntRunType;
-exports.isBooleanRunType = src_lib_guards.isBooleanRunType;
-exports.isCallSignatureRunType = src_lib_guards.isCallSignatureRunType;
-exports.isChildAccessorType = src_lib_guards.isChildAccessorType;
-exports.isClassRunType = src_lib_guards.isClassRunType;
-exports.isCollectionRunType = src_lib_guards.isCollectionRunType;
-exports.isConstructor = src_lib_guards.isConstructor;
-exports.isDateRunType = src_lib_guards.isDateRunType;
-exports.isEnumMemberRunType = src_lib_guards.isEnumMemberRunType;
-exports.isEnumRunType = src_lib_guards.isEnumRunType;
-exports.isFormatParamMeta = src_lib_guards.isFormatParamMeta;
-exports.isFunctionParamsRunType = src_lib_guards.isFunctionParamsRunType;
-exports.isFunctionRunType = src_lib_guards.isFunctionRunType;
-exports.isIndexSignatureRunType = src_lib_guards.isIndexSignatureRunType;
-exports.isInterfaceRunType = src_lib_guards.isInterfaceRunType;
-exports.isIntersectionRunType = src_lib_guards.isIntersectionRunType;
-exports.isJitErrorsCompiler = src_lib_guards.isJitErrorsCompiler;
-exports.isLiteralRunType = src_lib_guards.isLiteralRunType;
-exports.isMemberRunType = src_lib_guards.isMemberRunType;
-exports.isMethodSignatureRunType = src_lib_guards.isMethodSignatureRunType;
-exports.isNativeUtilityStringTypes = src_lib_guards.isNativeUtilityStringTypes;
-exports.isNeverRunType = src_lib_guards.isNeverRunType;
-exports.isNonSerializableClass = src_lib_guards.isNonSerializableClass;
-exports.isNonSerializableObject = src_lib_guards.isNonSerializableObject;
-exports.isNullRunType = src_lib_guards.isNullRunType;
-exports.isNumberRunType = src_lib_guards.isNumberRunType;
-exports.isObjectLiteralRunType = src_lib_guards.isObjectLiteralRunType;
-exports.isObjectRunType = src_lib_guards.isObjectRunType;
-exports.isParameterRunType = src_lib_guards.isParameterRunType;
-exports.isPromiseRunType = src_lib_guards.isPromiseRunType;
-exports.isPropertyRunType = src_lib_guards.isPropertyRunType;
-exports.isPropertySignatureRunType = src_lib_guards.isPropertySignatureRunType;
-exports.isRegexpRunType = src_lib_guards.isRegexpRunType;
-exports.isRunType = src_lib_guards.isRunType;
-exports.isStringRunType = src_lib_guards.isStringRunType;
-exports.isSymbolRunType = src_lib_guards.isSymbolRunType;
-exports.isTupleMemberRunType = src_lib_guards.isTupleMemberRunType;
-exports.isTupleRunType = src_lib_guards.isTupleRunType;
-exports.isUndefinedRunType = src_lib_guards.isUndefinedRunType;
-exports.isUnionRunType = src_lib_guards.isUnionRunType;
-exports.isUnknownRunType = src_lib_guards.isUnknownRunType;
-exports.isVoidRunType = src_lib_guards.isVoidRunType;
-exports.BaseFnCompiler = src_lib_jitFnCompiler.BaseFnCompiler;
-exports.JitErrorsFnCompiler = src_lib_jitFnCompiler.JitErrorsFnCompiler;
-exports.JitFnCompiler = src_lib_jitFnCompiler.JitFnCompiler;
-exports.MockJitCompiler = src_lib_jitFnCompiler.MockJitCompiler;
-exports.createJitCompiler = src_lib_jitFnCompiler.createJitCompiler;
-exports.printClosure = src_lib_jitFnCompiler.printClosure;
-exports.getJITFnName = src_lib_jitFnsRegistry.getJITFnName;
-exports.getJitFnSettings = src_lib_jitFnsRegistry.getJitFnSettings;
-exports.getJitFunctionCompiler = src_lib_jitFnsRegistry.getJitFunctionCompiler;
-exports.registerJitFunctionCompiler = src_lib_jitFnsRegistry.registerJitFunctionCompiler;
-exports.anyValuesList = src_mocking_constants_mock.anyValuesList;
-exports.defaultMockOptions = src_mocking_constants_mock.defaultMockOptions;
-exports.emailLocalPartSymbols = src_mocking_constants_mock.emailLocalPartSymbols;
-exports.mockObjectList = src_mocking_constants_mock.mockObjectList;
-exports.mockRegExpsList = src_mocking_constants_mock.mockRegExpsList;
-exports.stringCharSet = src_mocking_constants_mock.stringCharSet;
-exports.getMockCompiler = src_mocking_mockRegistry.getMockCompiler;
-exports.setMockCompiler = src_mocking_mockRegistry.setMockCompiler;
-exports.mockType = src_mocking_mockType.mockType;
-exports.mockAny = src_mocking_mockUtils.mockAny;
-exports.mockBigInt = src_mocking_mockUtils.mockBigInt;
-exports.mockBoolean = src_mocking_mockUtils.mockBoolean;
-exports.mockDate = src_mocking_mockUtils.mockDate;
-exports.mockNumber = src_mocking_mockUtils.mockNumber;
-exports.mockRecursiveEmptyArray = src_mocking_mockUtils.mockRecursiveEmptyArray;
-exports.mockRegExp = src_mocking_mockUtils.mockRegExp;
-exports.mockString = src_mocking_mockUtils.mockString;
-exports.mockSymbol = src_mocking_mockUtils.mockSymbol;
-exports.random = src_mocking_mockUtils.random;
-exports.randomItem = src_mocking_mockUtils.randomItem;
-exports.cpf_asJSONString = src_runTypesPureFns.cpf_asJSONString;
-exports.cpf_formatErr = src_runTypesPureFns.cpf_formatErr;
-exports.cpf_getUnknownKeysFromArray = src_runTypesPureFns.cpf_getUnknownKeysFromArray;
-exports.cpf_hasUnknownKeysFromArray = src_runTypesPureFns.cpf_hasUnknownKeysFromArray;
-exports.cpf_newRunTypeErr = src_runTypesPureFns.cpf_newRunTypeErr;
-exports.cpf_safeIterableKey = src_runTypesPureFns.cpf_safeIterableKey;
-exports.cpf_sanitizeCompiledFn = src_runTypesPureFns.cpf_sanitizeCompiledFn;
-//# sourceMappingURL=index.cjs.map

package/.dist/cjs/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/cjs/index.d.ts

@@ -1,61 +0,0 @@
-export * from './src/types.ts';
-export * from './src/constants.functions.ts';
-export * from './src/constants.kind.ts';
-export * from './src/constants.ts';
-export * from './src/createRunType.ts';
-export * from './src/createRunTypeFunctions.ts';
-export * from './src/formats.runtype.ts';
-export * from './src/lib/typeId.ts';
-export * from './src/lib/dkProxy.ts';
-export * from './src/lib/baseRunTypeFormat.ts';
-export * from './src/lib/baseRunTypes.ts';
-export * from './src/lib/formats.ts';
-export * from './src/lib/guards.ts';
-export * from './src/lib/jitFnCompiler.ts';
-export * from './src/lib/jitFnsRegistry.ts';
-export * from './src/mocking/constants.mock.ts';
-export * from './src/mocking/mockRegistry.ts';
-export * from './src/mocking/mockType.ts';
-export * from './src/mocking/mockUtils.ts';
-export * from './src/run-types-pure-fns.ts';
-export type * from './src/nodes/atomic/any.ts';
-export type * from './src/nodes/atomic/bigInt.ts';
-export type * from './src/nodes/atomic/boolean.ts';
-export type * from './src/nodes/atomic/date.ts';
-export type * from './src/nodes/atomic/enum.ts';
-export type * from './src/nodes/atomic/enumMember.ts';
-export type * from './src/nodes/atomic/literal.ts';
-export type * from './src/nodes/atomic/never.ts';
-export type * from './src/nodes/atomic/null.ts';
-export type * from './src/nodes/atomic/number.ts';
-export type * from './src/nodes/atomic/object.ts';
-export type * from './src/nodes/atomic/regexp.ts';
-export type * from './src/nodes/atomic/string.ts';
-export type * from './src/nodes/atomic/symbol.ts';
-export type * from './src/nodes/atomic/undefined.ts';
-export type * from './src/nodes/atomic/unknown.ts';
-export type * from './src/nodes/atomic/void.ts';
-export type * from './src/nodes/collection/class.ts';
-export type * from './src/nodes/collection/functionParams.ts';
-export type * from './src/nodes/collection/interface.ts';
-export type * from './src/nodes/collection/intersection.ts';
-export type * from './src/nodes/collection/tuple.ts';
-export type * from './src/nodes/collection/union.ts';
-export type * from './src/nodes/collection/unionDiscriminator.ts';
-export type * from './src/nodes/function/function.ts';
-export type * from './src/nodes/member/array.ts';
-export type * from './src/nodes/member/callSignature.ts';
-export type * from './src/nodes/member/genericMember.ts';
-export type * from './src/nodes/member/indexProperty.ts';
-export type * from './src/nodes/member/method.ts';
-export type * from './src/nodes/member/methodSignature.ts';
-export type * from './src/nodes/member/param.ts';
-export type * from './src/nodes/member/property.ts';
-export type * from './src/nodes/member/restParams.ts';
-export type * from './src/nodes/member/tupleMember.ts';
-export type * from './src/nodes/native/Iterable.ts';
-export type * from './src/nodes/native/map.ts';
-export type * from './src/nodes/native/nonSerializable.ts';
-export type * from './src/nodes/native/promise.ts';
-export type * from './src/nodes/native/set.ts';
-//# sourceMappingURL=index.d.ts.map

package/.dist/cjs/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAQA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iCAAiC,CAAC;AAChD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAG5C,mBAAmB,2BAA2B,CAAC;AAC/C,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,+BAA+B,CAAC;AACnD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,+BAA+B,CAAC;AACnD,mBAAmB,6BAA6B,CAAC;AACjD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,iCAAiC,CAAC;AACrD,mBAAmB,+BAA+B,CAAC;AACnD,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,iCAAiC,CAAC;AACrD,mBAAmB,0CAA0C,CAAC;AAC9D,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,wCAAwC,CAAC;AAC5D,mBAAmB,iCAAiC,CAAC;AACrD,mBAAmB,iCAAiC,CAAC;AACrD,mBAAmB,8CAA8C,CAAC;AAClE,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,6BAA6B,CAAC;AACjD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,uCAAuC,CAAC;AAC3D,mBAAmB,6BAA6B,CAAC;AACjD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,mCAAmC,CAAC;AACvD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,2BAA2B,CAAC;AAC/C,mBAAmB,uCAAuC,CAAC;AAC3D,mBAAmB,+BAA+B,CAAC;AACnD,mBAAmB,2BAA2B,CAAC"}

package/.dist/cjs/package.json

@@ -1 +0,0 @@
-{"type":"commonjs"}

package/.dist/cjs/src/constants.cjs

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const nonSerializableClasses = [
-  // TODO: decide what to do with native errors, they should be easily serializable
-  Error,
-  EvalError,
-  RangeError,
-  ReferenceError,
-  SyntaxError,
-  TypeError,
-  URIError,
-  AggregateError,
-  // Promise, // Promise has it's own RunType
-  // data types
-  WeakMap,
-  WeakSet,
-  DataView,
-  ArrayBuffer,
-  SharedArrayBuffer,
-  Float32Array,
-  Float64Array,
-  Int8Array,
-  Int16Array,
-  Int32Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Uint16Array,
-  Uint32Array,
-  BigInt64Array,
-  BigUint64Array
-];
-const nonSerializableGlobals = [
-  // TODO: decide what to do with native errors, they should be easily serializable
-  "Error",
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError",
-  "AggregateError",
-  // data types
-  "WeakMap",
-  "WeakSet",
-  "DataView",
-  "ArrayBuffer",
-  "SharedArrayBuffer",
-  "Float32Array",
-  "Float64Array",
-  "Int8Array",
-  "Int16Array",
-  "Int32Array",
-  "Uint8Array",
-  "Uint8ClampedArray",
-  "Uint16Array",
-  "Uint32Array",
-  "BigInt64Array",
-  "BigUint64Array",
-  // bellow are common interface names from standard libraries, they added here but not tested
-  "Generator",
-  "GeneratorFunction",
-  "AsyncGenerator",
-  "Iterator",
-  "AsyncGeneratorFunction",
-  "AsyncIterator"
-];
-const nativeUtilityStringTypes = ["Uppercase", "Lowercase", "Capitalize", "Uncapitalize"];
-const validPropertyNameRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-const maxStackErrorMessage = "Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.";
-const JIT_STACK_TRACE_MESSAGE = "\nJIT runType trace => ";
-const MAX_UNION_ITEMS = 2 ** 16 - 1;
-exports.JIT_STACK_TRACE_MESSAGE = JIT_STACK_TRACE_MESSAGE;
-exports.MAX_UNION_ITEMS = MAX_UNION_ITEMS;
-exports.maxStackErrorMessage = maxStackErrorMessage;
-exports.nativeUtilityStringTypes = nativeUtilityStringTypes;
-exports.nonSerializableClasses = nonSerializableClasses;
-exports.nonSerializableGlobals = nonSerializableGlobals;
-exports.validPropertyNameRegExp = validPropertyNameRegExp;
-//# sourceMappingURL=constants.cjs.map

package/.dist/cjs/src/constants.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.cjs","sources":["../../../src/constants.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\n// native javascript objects that are not serializable\nexport const nonSerializableClasses = [\n    // TODO: decide what to do with native errors, they should be easily serializable\n    Error,\n    EvalError,\n    RangeError,\n    ReferenceError,\n    SyntaxError,\n    TypeError,\n    URIError,\n    AggregateError,\n    // Promise, // Promise has it's own RunType\n    // data types\n    WeakMap,\n    WeakSet,\n    DataView,\n    ArrayBuffer,\n    SharedArrayBuffer,\n    Float32Array,\n    Float64Array,\n    Int8Array,\n    Int16Array,\n    Int32Array,\n    Uint8Array,\n    Uint8ClampedArray,\n    Uint16Array,\n    Uint32Array,\n    BigInt64Array,\n    BigUint64Array,\n];\n\n// these are global objects that are not serializable.\n// values are repeated from nonSerializableClasses, as if they are classes or global object depends in typescript stn lib types and these can change\nexport const nonSerializableGlobals = [\n    // TODO: decide what to do with native errors, they should be easily serializable\n    'Error',\n    'EvalError',\n    'RangeError',\n    'ReferenceError',\n    'SyntaxError',\n    'TypeError',\n    'URIError',\n    'AggregateError',\n    // data types\n    'WeakMap',\n    'WeakSet',\n    'DataView',\n    'ArrayBuffer',\n    'SharedArrayBuffer',\n    'Float32Array',\n    'Float64Array',\n    'Int8Array',\n    'Int16Array',\n    'Int32Array',\n    'Uint8Array',\n    'Uint8ClampedArray',\n    'Uint16Array',\n    'Uint32Array',\n    'BigInt64Array',\n    'BigUint64Array',\n    // bellow are common interface names from standard libraries, they added here but not tested\n    'Generator',\n    'GeneratorFunction',\n    'AsyncGenerator',\n    'Iterator',\n    'AsyncGeneratorFunction',\n    'AsyncIterator',\n];\n\n// typescript utility types\nexport const nativeUtilityStringTypes = ['Uppercase', 'Lowercase', 'Capitalize', 'Uncapitalize'];\n\n// other constants\nexport const validPropertyNameRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;\nexport const maxStackErrorMessage =\n    'Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.';\nexport const JIT_STACK_TRACE_MESSAGE = '\\nJIT runType trace => ';\nexport const MAX_UNION_ITEMS = 2 ** 16 - 1;\n"],"names":[],"mappings":";;AAQO,MAAM,yBAAyB;AAAA;AAAA,EAElC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;;AAKG,MAAM,yBAAyB;AAAA;AAAA,EAElC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;;AAIG,MAAM,2BAA2B,CAAC,aAAa,aAAa,cAAc,cAAc;AAGxF,MAAM,0BAA0B;AAChC,MAAM,uBACT;AACG,MAAM,0BAA0B;AAChC,MAAM,kBAAkB,KAAK,KAAK;;;;;;;;"}

package/.dist/cjs/src/constants.d.ts

@@ -1,8 +0,0 @@
-export declare const nonSerializableClasses: (ErrorConstructor | AggregateErrorConstructor | WeakMapConstructor | WeakSetConstructor | DataViewConstructor | ArrayBufferConstructor | SharedArrayBufferConstructor | Float32ArrayConstructor | Float64ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor)[];
-export declare const nonSerializableGlobals: string[];
-export declare const nativeUtilityStringTypes: string[];
-export declare const validPropertyNameRegExp: RegExp;
-export declare const maxStackErrorMessage = "Max compilation nested level reached, either you have a very deeply nested type or there is an error related to circular references un the types.";
-export declare const JIT_STACK_TRACE_MESSAGE = "\nJIT runType trace => ";
-export declare const MAX_UNION_ITEMS: number;
-//# sourceMappingURL=constants.d.ts.map

package/.dist/cjs/src/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/constants.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,sBAAsB,qcA4BlC,CAAC;AAIF,eAAO,MAAM,sBAAsB,UAkClC,CAAC;AAGF,eAAO,MAAM,wBAAwB,UAA2D,CAAC;AAGjG,eAAO,MAAM,uBAAuB,QAA6B,CAAC;AAClE,eAAO,MAAM,oBAAoB,sJACsH,CAAC;AACxJ,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AACjE,eAAO,MAAM,eAAe,QAAc,CAAC"}