@mionjs/run-types 0.8.10 → 0.13.2

package/dist/cjs/runtypes/rtUtils.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRunTypeValue = isRunTypeValue;
+exports.getRTUtils = getRTUtils;
+exports.getRTFnCaches = getRTFnCaches;
+exports.buildPureFnFactoryFromCode = buildPureFnFactoryFromCode;
+exports.buildFactoryFromCode = buildFactoryFromCode;
+exports.entryCode = entryCode;
+const classSerializerRegistry_ts_1 = require("./classSerializerRegistry.js");
+const circular_ts_1 = require("./circular.js");
+function isRunTypeValue(val) {
+    return typeof val === 'object' && val !== null && typeof val.id === 'string' && 'kind' in val;
+}
+const rtFnsCache = {};
+const pureFnsCache = {};
+const runTypesCache = {};
+const findRTForTypeMemo = new Map();
+const rtUtils = {
+    addToRTCache(comp) {
+        rtFnsCache[comp.rtFnHash] = comp;
+        findRTForTypeMemo.clear();
+    },
+    removeFromRTCache(comp) {
+        if (!rtFnsCache[comp.rtFnHash])
+            return;
+        rtFnsCache[comp.rtFnHash] = undefined;
+        findRTForTypeMemo.clear();
+    },
+    getRT(rtFnHash) {
+        const entry = rtFnsCache[rtFnHash];
+        if (!entry)
+            return undefined;
+        materializeRTFn(entry);
+        return entry;
+    },
+    findRTForType(familyTag, typeId) {
+        const memoKey = familyTag + '\u0000' + typeId;
+        const hit = findRTForTypeMemo.get(memoKey);
+        if (hit !== undefined) {
+            if (hit === null)
+                return undefined;
+            materializeRTFn(hit);
+            return hit;
+        }
+        const suffix = '_' + typeId;
+        for (const key of Object.keys(rtFnsCache)) {
+            if (!key.endsWith(suffix))
+                continue;
+            const entry = rtFnsCache[key];
+            if (!entry || entry.familyTag !== familyTag)
+                continue;
+            materializeRTFn(entry);
+            findRTForTypeMemo.set(memoKey, entry);
+            return entry;
+        }
+        findRTForTypeMemo.set(memoKey, null);
+        return undefined;
+    },
+    getRTFn(rtFnHash) {
+        const entry = rtFnsCache[rtFnHash];
+        if (!entry)
+            throw new Error(`RT function not found for rtFnHash ${rtFnHash}`);
+        materializeRTFn(entry);
+        return entry.fn;
+    },
+    hasRTFn(rtFnHash) {
+        return !!rtFnsCache[rtFnHash];
+    },
+    addPureFn(id, compiledFn) {
+        if (!id)
+            throw new Error('Pure function id must be a non-empty string');
+        const key = id;
+        const existing = pureFnsCache[key];
+        if (existing)
+            return existing;
+        pureFnsCache[key] = compiledFn;
+        return compiledFn;
+    },
+    usePureFn(key) {
+        const compiled = pureFnsCache[key];
+        if (!compiled)
+            throw new Error(`Pure function not found for key "${key}"`);
+        initPureFunction(compiled);
+        return compiled.fn;
+    },
+    getPureFn(key) {
+        const compiled = pureFnsCache[key];
+        if (!compiled)
+            return;
+        initPureFunction(compiled);
+        return compiled.fn;
+    },
+    getCompiledPureFn(key) {
+        return pureFnsCache[key];
+    },
+    hasPureFn(key) {
+        return !!pureFnsCache[key];
+    },
+    getPureFnByKey(key) {
+        const compiled = pureFnsCache[key];
+        if (!compiled)
+            return;
+        initPureFunction(compiled);
+        return compiled.fn;
+    },
+    hasPureFnByKey(key) {
+        return !!pureFnsCache[key];
+    },
+    getCompiledPureFnByKey(key) {
+        return pureFnsCache[key];
+    },
+    addRunType(id, runType) {
+        if (!id)
+            throw new Error('Run-type id must be a non-empty string');
+        runTypesCache[id] = runType;
+        return runType;
+    },
+    removeRunType(id) {
+        if (!runTypesCache[id])
+            return;
+        runTypesCache[id] = undefined;
+    },
+    getRunType(id) {
+        return runTypesCache[id];
+    },
+    useRunType(id) {
+        const rt = runTypesCache[id];
+        if (!rt)
+            throw new Error(`Run-type not found for id "${id}"`);
+        return rt;
+    },
+    hasRunType(id) {
+        return !!runTypesCache[id];
+    },
+    knowsType(typeId) {
+        if (runTypesCache[typeId])
+            return true;
+        const suffix = '_' + typeId;
+        for (const key of Object.keys(rtFnsCache)) {
+            if (key.endsWith(suffix) && rtFnsCache[key])
+                return true;
+        }
+        return false;
+    },
+    alwaysThrowFactory(message) {
+        return () => {
+            throw new Error(message);
+        };
+    },
+    circularError(path) {
+        return new circular_ts_1.CircularReferenceError(path);
+    },
+    getClassSerializer(typeId, className) {
+        return (0, classSerializerRegistry_ts_1.getClassSerializer)(typeId, className);
+    },
+    csEpoch() {
+        return (0, classSerializerRegistry_ts_1.classSerializerEpoch)();
+    },
+    deserializeClass(entry, data, keys) {
+        return (0, classSerializerRegistry_ts_1.deserializeClass)(entry, data, keys);
+    },
+};
+function getRTUtils() {
+    return rtUtils;
+}
+function getRTFnCaches() {
+    return {
+        rtFnsCache: rtFnsCache,
+        pureFnsCache: pureFnsCache,
+    };
+}
+function initPureFunction(compiled) {
+    if (compiled.fn)
+        return;
+    let factory = compiled.createPureFn;
+    if (!factory) {
+        factory = buildPureFnFactoryFromCode(compiled.paramNames, compiled.code ?? '');
+        compiled.createPureFn = factory;
+    }
+    compiled.fn = factory(rtUtils);
+}
+function buildPureFnFactoryFromCode(paramNames, code) {
+    return new Function(...paramNames, `'use strict'; ${code}`);
+}
+function buildFactoryFromCode(code) {
+    return new Function('utl', `'use strict'; ${code}`);
+}
+function entryCode(entry) {
+    if (entry.code !== undefined)
+        return entry.code;
+    if (entry.createRTFn) {
+        const src = entry.createRTFn.toString();
+        const open = src.indexOf('{');
+        const close = src.lastIndexOf('}');
+        const derived = open >= 0 && close > open ? src.slice(open + 1, close) : '';
+        entry.code = derived;
+        return derived;
+    }
+    return '';
+}
+const materializing = new Set();
+function materializeRTFn(entry) {
+    if (entry.fn)
+        return;
+    if (materializing.has(entry.rtFnHash))
+        return;
+    if (!entry.createRTFn && !entry.code)
+        return;
+    materializing.add(entry.rtFnHash);
+    try {
+        if (!entry.createRTFn)
+            entry.createRTFn = buildFactoryFromCode(entryCode(entry));
+        entry.fn = entry.createRTFn(rtUtils);
+    }
+    finally {
+        materializing.delete(entry.rtFnHash);
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare const __rtFormatName: unique symbol;
+export declare const __rtFormatParams: unique symbol;
+export declare const __rtFormatBrand: unique symbol;
+export declare const __rtContains: unique symbol;
+export declare const __rtPatternProps: unique symbol;
+export declare const __rtPropNames: unique symbol;
+export declare const __rtLabels: unique symbol;

package/dist/cjs/runtypes/sentinelKeys.js

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

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

@@ -0,0 +1,53 @@
+import type { __rtFormatName, __rtFormatParams, __rtFormatBrand, __rtContains, __rtPatternProps, __rtPropNames } from './sentinelKeys.ts';
+type StripMetaSentinelKeys = typeof __rtFormatName | typeof __rtFormatParams | typeof __rtFormatBrand | typeof __rtContains | typeof __rtPatternProps | typeof __rtPropNames;
+type StripMetaUrl = typeof globalThis extends {
+    URL: {
+        prototype: infer I;
+    };
+} ? I : never;
+type _StripMetaDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
+export type JsonValue = string | number | boolean | unknown[] | {
+    [key: string]: unknown;
+} | null;
+type StripMetaHasStructuredArm<T> = true extends (T extends string | number | bigint | boolean | null | undefined ? false : T extends readonly unknown[] ? false : T extends object ? StripMetaNoNamedKeys<T> extends true ? false : true : false) ? true : false;
+type StripMetaFmtPart<T> = typeof __rtFormatName extends keyof T ? typeof __rtFormatParams extends keyof T ? {
+    readonly [__rtFormatName]?: T[typeof __rtFormatName & keyof T];
+    readonly [__rtFormatParams]?: T[typeof __rtFormatParams & keyof T];
+} : {
+    readonly [__rtFormatName]?: T[typeof __rtFormatName & keyof T];
+} : unknown;
+type StripMetaContainsPart<T> = typeof __rtContains extends keyof T ? {
+    readonly [__rtContains]?: T[typeof __rtContains & keyof T];
+} : unknown;
+type StripMetaPatternPropsPart<T> = typeof __rtPatternProps extends keyof T ? {
+    readonly [__rtPatternProps]?: T[typeof __rtPatternProps & keyof T];
+} : unknown;
+type StripMetaPropNamesPart<T> = typeof __rtPropNames extends keyof T ? {
+    readonly [__rtPropNames]?: T[typeof __rtPropNames & keyof T];
+} : unknown;
+type StripMetaUnbrandLit<T, Base> = T extends (infer U) & StripMetaFmtPart<T> ? [Extract<keyof U, StripMetaSentinelKeys>] extends [never] ? U : Base : Base;
+type StripMetaUnbrandCollection<T> = T extends ReadonlyMap<infer K, infer V> ? T extends Map<any, any> ? Map<K, V> : ReadonlyMap<K, V> : T extends ReadonlySet<infer U> ? T extends Set<any> ? Set<U> : ReadonlySet<U> : T;
+type StripMetaUnbrandTuple<T, Depth extends number> = T extends (infer U) & StripMetaFmtPart<T> & StripMetaContainsPart<T> & StripMetaPatternPropsPart<T> & StripMetaPropNamesPart<T> ? [Extract<keyof U, StripMetaSentinelKeys>] extends [never] ? U extends readonly unknown[] ? {
+    [K in keyof U]: StripRunTypeMeta<U[K], _StripMetaDepth[Depth]>;
+} : T : T : T;
+export type StripRunTypeMeta<T, Depth extends number = 8> = Depth extends 0 ? unknown : unknown extends T ? T : [JsonValue] extends [T] ? [T] extends [JsonValue] ? StripMetaHasStructuredArm<T> extends true ? StripMetaNode<T, Depth> : JsonValue : StripMetaNode<T, Depth> : StripMetaNode<T, Depth>;
+type StripMetaNode<T, Depth extends number> = T extends string ? string extends T ? string : T extends {
+    readonly [__rtFormatBrand]: string;
+} ? string : Extract<keyof T, StripMetaSentinelKeys> extends never ? T : StripMetaUnbrandLit<T, string> : T extends number ? number extends T ? number : T extends {
+    readonly [__rtFormatBrand]: string;
+} ? number : Extract<keyof T, StripMetaSentinelKeys> extends never ? T : StripMetaUnbrandLit<T, number> : T extends bigint ? bigint extends T ? bigint : T extends {
+    readonly [__rtFormatBrand]: string;
+} ? bigint : Extract<keyof T, StripMetaSentinelKeys> extends never ? T : StripMetaUnbrandLit<T, bigint> : T extends boolean ? Extract<keyof T, StripMetaSentinelKeys> extends never ? T : T extends true ? true : T extends false ? false : boolean : T extends null | undefined ? T : T extends Date ? Date : T extends (...args: never[]) => unknown ? T : T extends readonly unknown[] ? StripMetaArray<T, Depth> : T extends object ? StripMetaObject<T, Depth> : T;
+type StripMetaArray<T extends readonly unknown[], Depth extends number> = Extract<keyof T, StripMetaSentinelKeys> extends never ? {
+    [K in keyof T]: StripRunTypeMeta<T[K], _StripMetaDepth[Depth]>;
+} : number extends T['length'] ? T extends readonly (infer E)[] ? T extends unknown[] ? StripRunTypeMeta<E, _StripMetaDepth[Depth]>[] : readonly StripRunTypeMeta<E, _StripMetaDepth[Depth]>[] : T : StripMetaUnbrandTuple<T, Depth>;
+type StripMetaLiteralKeys<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K extends symbol ? never : K]-?: 0;
+};
+type StripMetaNoNamedKeys<T> = Record<never, never> extends StripMetaLiteralKeys<T> ? true : false;
+type StripMetaObject<T extends object, Depth extends number> = Extract<keyof T, StripMetaSentinelKeys> extends never ? keyof T extends never ? T : T extends ReadonlyMap<any, any> | ReadonlySet<any> | StripMetaUrl ? T : {
+    [K in keyof T as K extends symbol ? never : K]: string extends K ? StripMetaNoNamedKeys<T> extends true ? StripRunTypeMeta<T[K], _StripMetaDepth[Depth]> : unknown : number extends K ? StripMetaNoNamedKeys<T> extends true ? StripRunTypeMeta<T[K], _StripMetaDepth[Depth]> : unknown : StripRunTypeMeta<T[K], _StripMetaDepth[Depth]>;
+} : T extends ReadonlyMap<any, any> | ReadonlySet<any> ? StripMetaUnbrandCollection<T> : T extends StripMetaUrl ? StripMetaUrl : Exclude<keyof T, StripMetaSentinelKeys | symbol> extends never ? unknown : {
+    [K in keyof T as K extends symbol ? never : K]: string extends K ? StripMetaNoNamedKeys<T> extends true ? StripRunTypeMeta<T[K], _StripMetaDepth[Depth]> : unknown : number extends K ? StripMetaNoNamedKeys<T> extends true ? StripRunTypeMeta<T[K], _StripMetaDepth[Depth]> : unknown : StripRunTypeMeta<T[K], _StripMetaDepth[Depth]>;
+};
+export {};

package/dist/cjs/runtypes/stripRunTypeMeta.js

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

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

@@ -0,0 +1,14 @@
+import type { __rtFormatName, __rtFormatParams, __rtFormatBrand } from './sentinelKeys.ts';
+export type TypeFormatBase = string | number | bigint | Date;
+export type TypeFormatParams = Record<string, unknown>;
+export type TypeFormat<Base extends TypeFormatBase, Name extends string, Params extends object, BrandName extends string = never> = Base & FormatBrand<Name, Params> & ([BrandName] extends [never] ? unknown : NominalBrand<BrandName>);
+export interface FormatBrand<Name extends string, Params extends object> {
+    readonly [__rtFormatName]?: Name;
+    readonly [__rtFormatParams]?: Params;
+}
+export interface NominalBrand<BrandName extends string> {
+    readonly [__rtFormatBrand]: BrandName;
+}
+export type FormatNameOf<T> = typeof __rtFormatName extends keyof T ? NonNullable<T[typeof __rtFormatName & keyof T]> & string : never;
+export type FormatParamsOf<T> = typeof __rtFormatParams extends keyof T ? NonNullable<T[typeof __rtFormatParams & keyof T]> : never;
+export type FormatBrandNameOf<T> = typeof __rtFormatBrand extends keyof T ? T[typeof __rtFormatBrand & keyof T] & string : never;

package/dist/cjs/runtypes/typeFormat.js

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

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

@@ -0,0 +1,114 @@
+import type { RTUtils } from './rtUtils.ts';
+import type { FormatAnnotation } from './formatAnnotation.ts';
+import type { ValidateFn, GetValidationErrorsFn, RemoveUnknownKeysFn, PrepareForJsonFn, RestoreFromJsonFn } from '../createRTFunctions.ts';
+export type PureFunction = (...args: any[]) => any;
+export type PureFunctionFactory = (rtUtils: RTUtils) => PureFunction;
+export interface PureFunctionData {
+    readonly id: string;
+    readonly paramNames: string[];
+    readonly code?: string;
+    readonly pureFnDependencies?: Array<string>;
+}
+export interface CompiledPureFunction extends PureFunctionData {
+    createPureFn?: PureFunctionFactory;
+    fn?: PureFunction;
+}
+export interface SchemaChecks {
+    contains?: {
+        child: RunType;
+        min: number;
+        max: number;
+    }[];
+    patternProps?: {
+        source: string;
+        key?: RunType;
+        value: RunType;
+    }[];
+    propNames?: RunType[];
+}
+export interface RunType<T = unknown> extends SchemaChecks {
+    id: string;
+    kind: unknown;
+    subKind?: unknown;
+    typeName?: unknown;
+    name?: unknown;
+    literal?: unknown;
+    optional?: unknown;
+    readonly?: unknown;
+    nonEnumerable?: boolean;
+    isAbstract?: unknown;
+    isStatic?: unknown;
+    visibility?: unknown;
+    isSafeName?: unknown;
+    position?: unknown;
+    isCircular?: boolean;
+    notSupported?: boolean;
+    jsonMaxBytes?: number;
+    flags?: unknown;
+    description?: unknown;
+    defaultVal?: unknown;
+    enumVal?: unknown;
+    values?: unknown;
+    child?: RunType;
+    index?: RunType;
+    return?: RunType;
+    indexType?: RunType;
+    parameters?: RunType[];
+    children?: RunType[];
+    safeUnionChildren?: RunType[];
+    unionDiscriminators?: unknown;
+    typeMeta?: unknown;
+    formatAnnotation?: FormatAnnotation;
+    typeArguments?: RunType[];
+    arguments?: RunType[];
+    extendsArguments?: RunType[];
+    implements?: RunType[];
+    extends?: RunType;
+    classType?: object;
+    readonly __rtType?: {
+        t: T;
+    };
+    [extra: string]: unknown;
+}
+export type RunTypesCache = Record<string, RunType>;
+export type AnyFn = (...args: any[]) => any;
+export type CompiledFnArgs = {
+    vλl: string;
+    [key: string]: string;
+};
+export interface CompiledFnData {
+    readonly typeName: string;
+    readonly fnID: string;
+    readonly familyTag?: string;
+    readonly rtFnHash: string;
+    readonly args: CompiledFnArgs;
+    readonly defaultParamValues: CompiledFnArgs;
+    readonly isNoop?: boolean;
+    readonly code?: string;
+    readonly rtDependencies?: Array<string>;
+    readonly pureFnDependencies?: Array<string>;
+    paramNames?: string[];
+    readonly alwaysThrowMessage?: string;
+}
+export interface CompiledTypeFn<Fn extends AnyFn = AnyFn> extends CompiledFnData {
+    readonly createRTFn?: (utl: RTUtils) => Fn;
+    readonly fn?: Fn;
+}
+export type InitializedTypeFn<Fn extends AnyFn = AnyFn> = CompiledTypeFn<Fn> & Required<Pick<CompiledTypeFn<Fn>, 'createRTFn' | 'fn'>>;
+export type ValidateRTFn = CompiledTypeFn<ValidateFn>;
+export type GetValidationErrorsRTFn = CompiledTypeFn<GetValidationErrorsFn>;
+export type RemoveUnknownKeysRTFn = CompiledTypeFn<RemoveUnknownKeysFn>;
+export type PrepareForJsonRTFn = CompiledTypeFn<PrepareForJsonFn>;
+export type PrepareForJsonSafeRTFn = CompiledTypeFn<PrepareForJsonFn>;
+export type RestoreFromJsonRTFn = CompiledTypeFn<RestoreFromJsonFn>;
+export type TypesFunctionsCache = Record<string, CompiledTypeFn>;
+export type PureFunctionsCache = Record<string, CompiledPureFunction>;
+export type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export type DeepRequired<T> = T extends object ? {
+    [P in keyof T]?: DeepRequired<T[P]>;
+} : T;
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/dist/cjs/runtypes/types.js

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

package/dist/cjs/standard/createJsonSchemaFn.d.ts

@@ -0,0 +1,8 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { InjectTypeFnArgs } from '../markers.ts';
+import type { StandardJSONSchemaOptions } from './spec.ts';
+import type { JsonSchemaDocFn } from './jsonSchemaDoc.ts';
+export type JsonSchemaFn = (options?: StandardJSONSchemaOptions) => Record<string, unknown>;
+export declare const jsonSchemaDocFallback: JsonSchemaDocFn;
+export declare function createJsonSchemaFn<T>(runType: RunType<T>, ids?: InjectTypeFnArgs<T, 'jsonSchema'>): JsonSchemaFn;
+export declare function createJsonSchemaFn<T>(val?: T, ids?: InjectTypeFnArgs<T, 'jsonSchema'>): JsonSchemaFn;

package/dist/cjs/standard/createJsonSchemaFn.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaDocFallback = void 0;
+exports.createJsonSchemaFn = createJsonSchemaFn;
+const rtUtils_ts_1 = require("../runtypes/rtUtils.js");
+const entryTuple_ts_1 = require("../runtypes/entryTuple.js");
+const jsonSchemaDoc_ts_1 = require("./jsonSchemaDoc.js");
+const jsonSchemaDocFallback = () => {
+    throw new Error('createJsonSchemaFn(): no compiled schema document. @mionjs/devtools must be active for the jsonSchema cache entry to exist.');
+};
+exports.jsonSchemaDocFallback = jsonSchemaDocFallback;
+function createJsonSchemaFn(valOrSchema, ids) {
+    const runTypeId = (0, rtUtils_ts_1.isRunTypeValue)(valOrSchema) ? valOrSchema.id : undefined;
+    const docFn = (0, entryTuple_ts_1.resolveEntryTupleFn)('createJsonSchemaFn', exports.jsonSchemaDocFallback, runTypeId, ids);
+    return (0, jsonSchemaDoc_ts_1.buildJsonSchemaConverter)(docFn).input;
+}

package/dist/cjs/standard/createStandardSchema.d.ts

@@ -0,0 +1,18 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { DataOnly } from '../runtypes/dataOnly.ts';
+import type { ValidateOptions } from '../createRTFunctions.ts';
+import type { CompTimeFnArgs, InjectTypeFnArgs } from '../markers.ts';
+import type { RTValidationIssue } from './issueMapping.ts';
+import type { StandardSchemaSuccessResult, StandardSchemaProps, StandardJSONSchemaConverter } from './spec.ts';
+export interface RTValidationFailureResult {
+    readonly issues: ReadonlyArray<RTValidationIssue>;
+}
+export type RTValidationResult<Output> = StandardSchemaSuccessResult<Output> | RTValidationFailureResult;
+export interface RTStandardSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': Omit<StandardSchemaProps<Input, Output>, 'validate'> & {
+        readonly validate: (value: unknown) => RTValidationResult<Output> | Promise<RTValidationResult<Output>>;
+        readonly jsonSchema: StandardJSONSchemaConverter;
+    };
+}
+export declare function createStandardSchema<T>(runType: RunType<T>, options?: CompTimeFnArgs<ValidateOptions>, ids?: InjectTypeFnArgs<T, 'validate', 'validationErrors', 'jsonSchema'>): RTStandardSchemaV1<DataOnly<T>>;
+export declare function createStandardSchema<T>(val?: T, options?: CompTimeFnArgs<ValidateOptions>, ids?: InjectTypeFnArgs<T, 'validate', 'validationErrors', 'jsonSchema'>): RTStandardSchemaV1<DataOnly<T>>;

package/dist/cjs/standard/createStandardSchema.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStandardSchema = createStandardSchema;
+const rtUtils_ts_1 = require("../runtypes/rtUtils.js");
+const entryTuple_ts_1 = require("../runtypes/entryTuple.js");
+const issueMapping_ts_1 = require("./issueMapping.js");
+const jsonSchemaDoc_ts_1 = require("./jsonSchemaDoc.js");
+const createJsonSchemaFn_ts_1 = require("./createJsonSchemaFn.js");
+const validateFallback = (() => true);
+const errorsFallback = () => [];
+function createStandardSchema(valOrSchema, options, ids) {
+    const runTypeId = (0, rtUtils_ts_1.isRunTypeValue)(valOrSchema) ? valOrSchema.id : undefined;
+    const valInjected = (0, entryTuple_ts_1.entryTupleAt)(ids, 0);
+    const verrInjected = (0, entryTuple_ts_1.entryTupleAt)(ids, 1);
+    const jscInjected = (0, entryTuple_ts_1.entryTupleAt)(ids, 2);
+    const validate = (0, entryTuple_ts_1.resolveEntryTupleFn)('createValidateFn', validateFallback, runTypeId, valInjected);
+    const getErrors = (0, entryTuple_ts_1.resolveEntryTupleFn)('createGetValidationErrorsFn', errorsFallback, runTypeId, verrInjected);
+    const docFn = (0, entryTuple_ts_1.resolveEntryTupleFn)('createJsonSchemaFn', createJsonSchemaFn_ts_1.jsonSchemaDocFallback, runTypeId, jscInjected);
+    const props = {
+        version: 1,
+        vendor: 'mion',
+        jsonSchema: (0, jsonSchemaDoc_ts_1.buildJsonSchemaConverter)(docFn),
+        validate(value) {
+            if (validate(value))
+                return { value: value };
+            return { issues: (0, issueMapping_ts_1.runTypeErrorsToIssues)(getErrors(value)) };
+        },
+    };
+    return { '~standard': props };
+}

package/dist/cjs/standard/issueMapping.d.ts

@@ -0,0 +1,12 @@
+import type { RTValidationError, RTPathSegment, TypeFormatError } from '../createRTFunctions.ts';
+import type { StandardSchemaIssue } from './spec.ts';
+export interface RTValidationIssue<Format extends TypeFormatError = TypeFormatError> extends StandardSchemaIssue {
+    readonly message: string;
+    readonly path: ReadonlyArray<PropertyKey | RTPathSegment>;
+    readonly expected: string;
+    readonly format?: Format;
+}
+export interface IssueMappingOptions {
+    message?: (err: RTValidationError) => string;
+}
+export declare function runTypeErrorsToIssues<Format extends TypeFormatError>(errs: RTValidationError<Format>[], options?: IssueMappingOptions): RTValidationIssue<Format>[];

package/dist/cjs/standard/issueMapping.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTypeErrorsToIssues = runTypeErrorsToIssues;
+function constraintName(format) {
+    if (!format)
+        return 'type';
+    const tail = format.formatPath[format.formatPath.length - 1];
+    return tail !== undefined ? String(tail) : format.name;
+}
+function primitiveBound(val) {
+    return typeof val === 'string' || typeof val === 'number' || typeof val === 'bigint' || typeof val === 'boolean'
+        ? val
+        : undefined;
+}
+function defaultMessage(err) {
+    if (err.expected === 'circular')
+        return 'Circular reference';
+    if (!err.format)
+        return `Expected ${err.expected}`;
+    const constraint = constraintName(err.format);
+    const bound = primitiveBound(err.format.val);
+    if (bound === 'any')
+        return `Failed ${err.format.name} constraint`;
+    if (bound === undefined || String(bound) === constraint)
+        return `Failed ${constraint} constraint`;
+    return `Failed ${constraint} constraint (${String(bound)})`;
+}
+function runTypeErrorsToIssues(errs, options) {
+    const render = options?.message ?? defaultMessage;
+    return errs.map((err) => ({
+        message: render(err),
+        path: err.path,
+        expected: err.expected,
+        ...(err.format ? { format: err.format } : {}),
+    }));
+}

package/dist/cjs/standard/jsonSchemaDoc.d.ts

@@ -0,0 +1,7 @@
+import type { StandardJSONSchemaConverter } from './spec.ts';
+export type JsonSchemaDocFn = () => Record<string, unknown>;
+export declare const JSON_SCHEMA_TARGET = "draft-2020-12";
+export declare const JSON_SCHEMA_DIALECT_KEYWORDS: readonly ["jsType", "jsResolved", "rtFormat", "rtFormatParams", "tsIndexes", "tsFunction", "tsTemplate", "tsLabels", "tsReadonly", "tsMeta"];
+export declare function closeDeclaredObjects(value: unknown): unknown;
+export declare function stripDialect(value: unknown): unknown;
+export declare function buildJsonSchemaConverter(docFn: JsonSchemaDocFn): StandardJSONSchemaConverter;

package/dist/cjs/standard/jsonSchemaDoc.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSON_SCHEMA_DIALECT_KEYWORDS = exports.JSON_SCHEMA_TARGET = void 0;
+exports.closeDeclaredObjects = closeDeclaredObjects;
+exports.stripDialect = stripDialect;
+exports.buildJsonSchemaConverter = buildJsonSchemaConverter;
+exports.JSON_SCHEMA_TARGET = 'draft-2020-12';
+exports.JSON_SCHEMA_DIALECT_KEYWORDS = [
+    'jsType',
+    'jsResolved',
+    'rtFormat',
+    'rtFormatParams',
+    'tsIndexes',
+    'tsFunction',
+    'tsTemplate',
+    'tsLabels',
+    'tsReadonly',
+    'tsMeta',
+];
+const DIALECT_KEY_SET = new Set(exports.JSON_SCHEMA_DIALECT_KEYWORDS);
+function assertTarget(options) {
+    const target = options?.target;
+    if (target !== undefined && target !== exports.JSON_SCHEMA_TARGET) {
+        throw new RangeError(`mion emits '${exports.JSON_SCHEMA_TARGET}' JSON Schema documents; target '${target}' is not supported`);
+    }
+}
+function isPortable(options) {
+    return options?.libraryOptions?.portable === true;
+}
+const ENCODER_STRATEGIES = new Set(['clone', 'mutate', 'compact']);
+function encoderStrategyOf(options) {
+    const raw = options?.libraryOptions?.encoderStrategy;
+    if (raw === undefined)
+        return undefined;
+    if (!ENCODER_STRATEGIES.has(raw)) {
+        const shown = typeof raw === 'string' ? `'${raw}'` : `a ${typeof raw}`;
+        throw new RangeError(`unknown encoderStrategy ${shown} (expected 'clone' | 'mutate')`);
+    }
+    if (raw === 'compact') {
+        throw new RangeError("the 'compact' wire is positional arrays, which this keyed document does not describe; no JSON Schema is emitted for it");
+    }
+    return raw;
+}
+const VALUE_POSITION_KEYS = new Set(['const', 'enum', 'default', 'examples', 'rtFormatParams']);
+function closeDeclaredObjects(value) {
+    if (Array.isArray(value))
+        return value.map(closeDeclaredObjects);
+    if (value === null || typeof value !== 'object')
+        return value;
+    const node = value;
+    const out = {};
+    for (const [key, child] of Object.entries(node)) {
+        out[key] = VALUE_POSITION_KEYS.has(key) ? child : closeDeclaredObjects(child);
+    }
+    const declaredProperties = out.properties;
+    if (out.type === 'object' &&
+        declaredProperties !== null &&
+        typeof declaredProperties === 'object' &&
+        !('additionalProperties' in out)) {
+        out.additionalProperties = false;
+    }
+    return out;
+}
+function stripDialect(value) {
+    if (Array.isArray(value))
+        return value.map(stripDialect);
+    if (value === null || typeof value !== 'object')
+        return value;
+    const node = value;
+    const meta = node.tsMeta;
+    if (meta !== null && typeof meta === 'object' && 'base' in meta) {
+        return stripDialect(meta.base);
+    }
+    const out = {};
+    for (const [key, child] of Object.entries(node)) {
+        if (DIALECT_KEY_SET.has(key))
+            continue;
+        out[key] = stripDialect(child);
+    }
+    return out;
+}
+function buildJsonSchemaConverter(docFn) {
+    const read = (options) => {
+        assertTarget(options);
+        let doc = docFn();
+        const strategy = encoderStrategyOf(options);
+        if (strategy === 'clone') {
+            doc = closeDeclaredObjects(doc);
+        }
+        if (isPortable(options))
+            doc = stripDialect(doc);
+        return doc;
+    };
+    return { input: read, output: read };
+}