@mionjs/run-types 0.8.8 → 0.13.0

package/dist/cjs/createRTFunctions.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFormatTransformFn = exports.createRestoreFromJsonFn = exports.createPrepareForJsonFn = exports.createRemoveUnknownKeysFn = exports.createGetValidationErrorsFn = exports.createValidateFn = void 0;
+exports.createJsonEncoderFn = createJsonEncoderFn;
+exports.createJsonDecoderFn = createJsonDecoderFn;
+exports.getRTFunction = getRTFunction;
+const rtUtils_ts_1 = require("./runtypes/rtUtils.js");
+const entryTuple_ts_1 = require("./runtypes/entryTuple.js");
+function resolveTupleEntry(fnName, identityFn, val, args) {
+    const runTypeId = (0, rtUtils_ts_1.isRunTypeValue)(val) ? val.id : undefined;
+    return (0, entryTuple_ts_1.resolveEntryTupleFn)(fnName, identityFn, runTypeId, args);
+}
+function createTypeFnArgsFunction(fnName, identityFn) {
+    return (val, _options, args) => resolveTupleEntry(fnName, identityFn, val, args);
+}
+function createRTFunction(fnName, identityFn) {
+    return (val, args) => resolveTupleEntry(fnName, identityFn, val, args);
+}
+const identityValueFn = (v) => v;
+const getValidationErrorsIdentity = () => [];
+exports.createValidateFn = createTypeFnArgsFunction('createValidateFn', (() => true));
+exports.createGetValidationErrorsFn = createTypeFnArgsFunction('createGetValidationErrorsFn', getValidationErrorsIdentity);
+exports.createRemoveUnknownKeysFn = createTypeFnArgsFunction('createRemoveUnknownKeysFn', identityValueFn);
+exports.createPrepareForJsonFn = createTypeFnArgsFunction('createPrepareForJsonFn', identityValueFn);
+exports.createRestoreFromJsonFn = createTypeFnArgsFunction('createRestoreFromJsonFn', identityValueFn);
+exports.createFormatTransformFn = createRTFunction('createFormatTransformFn', identityValueFn);
+const jsonStringifyFallback = (v) => JSON.stringify(v);
+const jsonParseFallback = (s) => JSON.parse(s);
+function createJsonEncoderFn(valOrSchema, _options, id) {
+    return resolveTupleEntry('createJsonEncoderFn', jsonStringifyFallback, valOrSchema, id);
+}
+function createJsonDecoderFn(valOrSchema, options, id) {
+    return resolveTupleEntry('createJsonDecoderFn', jsonParseFallback, valOrSchema, id);
+}
+function getRTFunction(injected, fallback) {
+    const identityFn = (fallback ?? ((value) => value));
+    return (0, entryTuple_ts_1.resolveEntryTupleFn)('getRTFunction', identityFn, undefined, injected);
+}

package/dist/cjs/enrich/createFriendlyText.d.ts

@@ -0,0 +1,25 @@
+import type { RTValidationError, RTValidationErrorPathSegment } from '../createRTFunctions.ts';
+import type { FriendlyText } from './friendlyText.ts';
+export interface FriendlyMessage {
+    path: string;
+    label: string;
+    message: string;
+}
+export interface FriendlyRenderer {
+    label(path: string | RTValidationErrorPathSegment[]): string;
+    errors(errs: RTValidationError[]): FriendlyMessage[];
+}
+export declare function createFriendlyText<T>(map: FriendlyText<T>): FriendlyRenderer;
+export interface FriendlyI18nOptions<T> {
+    locale: string | {
+        readonly value: string;
+    };
+    translations: Partial<Record<string, FriendlyText<T>>>;
+    currency?: string | {
+        readonly value: string;
+    };
+    sourceLocale?: string;
+    strict?: boolean;
+}
+export declare function resolveLocale<T>(locale: string, translations: Partial<Record<string, FriendlyText<T>>>): string | undefined;
+export declare function createFriendlyTextI18n<T>(source: FriendlyText<T>, options: FriendlyI18nOptions<T>): FriendlyRenderer;

package/dist/cjs/enrich/createFriendlyText.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFriendlyText = createFriendlyText;
+exports.resolveLocale = resolveLocale;
+exports.createFriendlyTextI18n = createFriendlyTextI18n;
+const PLACEHOLDER = /\$\[(\w+)\]/g;
+const DEFAULT_LOCALE = 'en';
+const pluralRulesCache = new Map();
+const boundNumberFormatCache = new Map();
+const boundDateFormatCache = new Map();
+function cachedPluralRules(locale) {
+    let rules = pluralRulesCache.get(locale);
+    if (!rules) {
+        rules = new Intl.PluralRules(locale, { type: 'cardinal' });
+        pluralRulesCache.set(locale, rules);
+    }
+    return rules;
+}
+function cachedBoundNumberFormat(locale, currency) {
+    const key = locale + '\0' + (currency ?? '');
+    let format = boundNumberFormatCache.get(key);
+    if (!format) {
+        try {
+            format = currency ? new Intl.NumberFormat(locale, { style: 'currency', currency }) : new Intl.NumberFormat(locale);
+        }
+        catch {
+            format = new Intl.NumberFormat(locale);
+        }
+        boundNumberFormatCache.set(key, format);
+    }
+    return format;
+}
+const DATE_BOUND_OPTIONS = {
+    date: { dateStyle: 'medium' },
+    temporalPlainDate: { dateStyle: 'medium' },
+    temporalPlainYearMonth: { year: 'numeric', month: 'long' },
+    dateTime: { dateStyle: 'medium', timeStyle: 'short' },
+    nativeDate: { dateStyle: 'medium', timeStyle: 'short' },
+    temporalInstant: { dateStyle: 'medium', timeStyle: 'short' },
+    temporalZonedDateTime: { dateStyle: 'medium', timeStyle: 'short' },
+    temporalPlainDateTime: { dateStyle: 'medium', timeStyle: 'short' },
+    time: { timeStyle: 'short' },
+    temporalPlainTime: { timeStyle: 'short' },
+};
+function cachedBoundDateFormat(locale, formatName) {
+    const key = locale + '\0' + formatName;
+    let format = boundDateFormatCache.get(key);
+    if (!format) {
+        format = new Intl.DateTimeFormat(locale, DATE_BOUND_OPTIONS[formatName]);
+        boundDateFormatCache.set(key, format);
+    }
+    return format;
+}
+function selectPlural(leaf, bound, locale) {
+    const count = Number(bound);
+    if (!Number.isFinite(count))
+        return leaf.other;
+    const category = cachedPluralRules(locale).select(count);
+    return leaf[category] || leaf.other;
+}
+function segmentKey(seg) {
+    if (typeof seg === 'string' || typeof seg === 'number')
+        return seg;
+    return seg.key;
+}
+function descend(node, seg) {
+    if (!node)
+        return undefined;
+    if (typeof seg === 'string')
+        return node[seg];
+    if (typeof seg === 'number')
+        return node.rt$slots ? node.rt$slots[seg] : node.rt$items;
+    return seg.failed === 'mapKey' ? node.rt$keys : node.rt$values;
+}
+function nodeAt(root, path) {
+    let node = root;
+    for (const seg of path)
+        node = descend(node, seg);
+    return node;
+}
+function rawLabel(path) {
+    for (let i = path.length - 1; i >= 0; i--) {
+        if (typeof path[i] === 'string')
+            return path[i];
+    }
+    const tail = path.length ? segmentKey(path[path.length - 1]) : undefined;
+    return tail === undefined ? '' : String(tail);
+}
+function pathToString(path) {
+    return path.map((seg) => String(segmentKey(seg))).join('.');
+}
+function constraintKey(format) {
+    if (!format)
+        return 'type';
+    const tail = format.formatPath[format.formatPath.length - 1];
+    return tail !== undefined ? String(tail) : format.name;
+}
+function primitiveVal(val) {
+    const kind = typeof val;
+    if (kind === 'string' || kind === 'number' || kind === 'boolean' || kind === 'bigint') {
+        return val;
+    }
+    return undefined;
+}
+function numericIndex(path) {
+    for (let i = path.length - 1; i >= 0; i--) {
+        const key = segmentKey(path[i]);
+        if (typeof key === 'number')
+            return key;
+    }
+    return undefined;
+}
+function interpolate(template, ctx) {
+    return template.replace(PLACEHOLDER, (whole, name) => {
+        if (name === 'label')
+            return ctx.label;
+        if (name === 'val')
+            return ctx.valText ?? '';
+        if (name === 'path')
+            return ctx.path;
+        if (name === 'index')
+            return ctx.index === undefined ? '' : String(ctx.index);
+        return whole;
+    });
+}
+function groupSignature(path) {
+    return path.map((seg) => (typeof seg === 'object' ? `${seg.key} ${seg.failed ?? ''}` : String(seg))).join('.');
+}
+function groupByPath(errs) {
+    const groups = [];
+    const bySignature = new Map();
+    for (const err of errs) {
+        const signature = groupSignature(err.path);
+        let group = bySignature.get(signature);
+        if (!group) {
+            group = { path: err.path, pathStr: pathToString(err.path), errors: [] };
+            bySignature.set(signature, group);
+            groups.push(group);
+        }
+        group.errors.push(err);
+    }
+    return groups;
+}
+function renderBoundText(state, format, val) {
+    if (val === undefined)
+        return undefined;
+    if (!state.i18n || !format)
+        return String(val);
+    if (format.isCurrency) {
+        const numeric = Number(val);
+        if (!Number.isFinite(numeric))
+            return String(val);
+        return cachedBoundNumberFormat(state.rootLocale, state.currency).format(numeric);
+    }
+    if (DATE_BOUND_OPTIONS[format.name] && (typeof val === 'string' || typeof val === 'number')) {
+        const date = new Date(val);
+        if (Number.isNaN(date.getTime()))
+            return String(val);
+        return cachedBoundDateFormat(state.rootLocale, format.name).format(date);
+    }
+    return String(val);
+}
+const labelFor = (node, path) => node?.rt$label || rawLabel(path);
+function resolveTemplate(node, key, val, mapLocale) {
+    const errorTemplates = node?.rt$errors;
+    if (!errorTemplates)
+        return undefined;
+    return leafTemplate(errorTemplates[key], val, mapLocale) ?? leafTemplate(errorTemplates.rt$default, val, mapLocale);
+}
+function leafTemplate(leaf, val, mapLocale) {
+    if (leaf === undefined)
+        return undefined;
+    const template = typeof leaf === 'string' ? leaf : selectPlural(leaf, val, mapLocale);
+    return template || undefined;
+}
+function renderLabel(state, path) {
+    const segs = typeof path === 'string' ? (path === '' ? [] : path.split('.')) : path;
+    const node = nodeAt(state.root, segs);
+    if (node?.rt$label)
+        return node.rt$label;
+    const sourceNode = state.source ? nodeAt(state.source, segs) : undefined;
+    return labelFor(sourceNode, segs);
+}
+function renderErrors(state, errs) {
+    const out = [];
+    for (const group of groupByPath(errs)) {
+        const node = nodeAt(state.root, group.path);
+        const sourceNode = state.source ? nodeAt(state.source, group.path) : undefined;
+        const label = node?.rt$label || sourceNode?.rt$label || rawLabel(group.path);
+        const index = numericIndex(group.path);
+        const first = group.errors[0];
+        const firstVal = primitiveVal(first.format?.val);
+        const rootProvides = resolveTemplate(node, constraintKey(first.format), firstVal, state.rootLocale) !== undefined;
+        const defaultNode = rootProvides ? node : sourceNode;
+        const defaultLocale = rootProvides ? state.rootLocale : state.sourceLocale;
+        const catchAll = leafTemplate(defaultNode?.rt$errors?.rt$default, firstVal, defaultLocale);
+        if (catchAll !== undefined) {
+            out.push({
+                path: group.pathStr,
+                label,
+                message: interpolate(catchAll, {
+                    label,
+                    valText: renderBoundText(state, first.format, firstVal),
+                    path: group.pathStr,
+                    index,
+                }),
+            });
+            continue;
+        }
+        for (const err of group.errors) {
+            const key = constraintKey(err.format);
+            const val = primitiveVal(err.format?.val);
+            const template = resolveTemplate(node, key, val, state.rootLocale) ?? resolveTemplate(sourceNode, key, val, state.sourceLocale);
+            const message = template
+                ? interpolate(template, {
+                    label,
+                    valText: renderBoundText(state, err.format, val),
+                    path: group.pathStr,
+                    index,
+                })
+                : `${label || 'value'} is invalid`;
+            out.push({ path: group.pathStr, label, message });
+        }
+    }
+    return out;
+}
+function createFriendlyText(map) {
+    const state = {
+        root: map,
+        rootLocale: DEFAULT_LOCALE,
+        sourceLocale: DEFAULT_LOCALE,
+    };
+    return {
+        label: (path) => renderLabel(state, path),
+        errors: (errs) => renderErrors(state, errs),
+    };
+}
+function resolveLocale(locale, translations) {
+    if (!locale)
+        return undefined;
+    const have = (tag) => translations[tag] !== undefined;
+    const parts = locale.split('-');
+    for (let keep = parts.length; keep >= 1; keep--) {
+        const candidate = parts.slice(0, keep).join('-');
+        if (have(candidate))
+            return candidate;
+    }
+    const baseLanguage = parts[0].toLowerCase();
+    for (const tag of Object.keys(translations)) {
+        if (translations[tag] !== undefined && tag.split('-')[0].toLowerCase() === baseLanguage)
+            return tag;
+    }
+    return undefined;
+}
+function createFriendlyTextI18n(source, options) {
+    const sourceRoot = source;
+    const sourceLocale = options.sourceLocale ?? DEFAULT_LOCALE;
+    const state = () => {
+        const active = typeof options.locale === 'object' ? options.locale.value : options.locale;
+        const matched = resolveLocale(active, options.translations);
+        const translation = matched !== undefined ? options.translations[matched] : undefined;
+        return {
+            root: translation ?? sourceRoot,
+            rootLocale: translation ? matched : sourceLocale,
+            source: translation ? sourceRoot : undefined,
+            sourceLocale,
+            i18n: true,
+            currency: typeof options.currency === 'object' ? options.currency.value : options.currency,
+        };
+    };
+    return {
+        label: (path) => renderLabel(state(), path),
+        errors: (errs) => renderErrors(state(), errs),
+    };
+}

package/dist/cjs/enrich/friendlyText.d.ts

@@ -0,0 +1,56 @@
+import type { __rtFormatName } from '../runtypes/sentinelKeys.ts';
+import type { FormatErrorKeys } from '../go-generated/formatErrorKeys.generated.ts';
+export type FriendlyTemplate = string;
+export type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+export type PluralTemplate = {
+    other: FriendlyTemplate;
+} & Partial<Record<PluralCategory, FriendlyTemplate>>;
+export type TemplateLeaf = FriendlyTemplate | PluralTemplate;
+type CountBearingKeys = 'minLength' | 'maxLength' | 'min' | 'max' | 'lt' | 'gt';
+type ConstraintTemplates<Name extends keyof FormatErrorKeys> = {
+    type: FriendlyTemplate;
+} & {
+    [K in FormatErrorKeys[Name]]?: K extends CountBearingKeys ? TemplateLeaf : FriendlyTemplate;
+} & {
+    rt$default?: never;
+};
+type DefaultOnlyTemplates = {
+    rt$default: FriendlyTemplate;
+    type?: never;
+};
+type BareTemplates = DefaultOnlyTemplates | ({
+    type: FriendlyTemplate;
+} & {
+    rt$default?: never;
+});
+export type ErrorTemplates<F = never> = [F] extends [never] ? BareTemplates : F extends {
+    readonly [__rtFormatName]?: infer Name;
+} ? [NonNullable<Name>] extends [keyof FormatErrorKeys] ? DefaultOnlyTemplates | ConstraintTemplates<NonNullable<Name>> : BareTemplates : BareTemplates;
+export interface FriendlyMeta<F = never> {
+    rt$label: string;
+    rt$errors: ErrorTemplates<F>;
+    rt$typeName?: string;
+}
+type FriendlyLeaf = string | number | boolean | bigint | null | undefined | Date | RegExp | FriendlyUrl;
+type FriendlyUrl = typeof globalThis extends {
+    URL: {
+        prototype: infer I;
+    };
+} ? I : never;
+type _FriendlyDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
+export type FriendlyNode<T, Depth extends number = 8> = Depth extends 0 ? FriendlyMeta : T extends FriendlyLeaf ? FriendlyMeta<T> : T extends ReadonlyMap<any, any> ? T extends ReadonlyMap<infer K, infer V> ? FriendlyMeta & {
+    rt$keys: FriendlyNode<K, _FriendlyDepth[Depth]>;
+    rt$values: FriendlyNode<V, _FriendlyDepth[Depth]>;
+} : FriendlyMeta : T extends ReadonlySet<any> ? T extends ReadonlySet<infer U> ? FriendlyMeta & {
+    rt$values: FriendlyNode<U, _FriendlyDepth[Depth]>;
+} : FriendlyMeta : T extends readonly unknown[] ? number extends T['length'] ? FriendlyMeta & {
+    rt$items: FriendlyNode<T[number], _FriendlyDepth[Depth]>;
+} : FriendlyMeta & {
+    rt$slots: {
+        [K in keyof T]: FriendlyNode<T[K], _FriendlyDepth[Depth]>;
+    };
+} : T extends object ? FriendlyMeta & {
+    [K in keyof T]-?: FriendlyNode<T[K], _FriendlyDepth[Depth]>;
+} : FriendlyMeta;
+export type FriendlyText<T> = FriendlyNode<T>;
+export {};

package/dist/cjs/enrich/friendlyText.js

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

package/dist/cjs/enrich/mockData.d.ts

@@ -0,0 +1,53 @@
+type _MockDepth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
+type MockDataUrl = typeof globalThis extends {
+    URL: {
+        prototype: infer I;
+    };
+} ? I : never;
+export type MockNode<T, Depth extends number = 8> = Depth extends 0 ? {
+    pool: T[];
+} : T extends ReadonlyMap<any, any> ? T extends ReadonlyMap<infer K, infer V> ? {
+    rt$keys: MockNode<K, _MockDepth[Depth]>;
+    rt$values: MockNode<V, _MockDepth[Depth]>;
+    rt$size?: number | [number, number];
+} : {
+    pool: T[];
+} : T extends ReadonlySet<any> ? T extends ReadonlySet<infer U> ? {
+    rt$values: MockNode<U, _MockDepth[Depth]>;
+    rt$size?: number | [number, number];
+} : {
+    pool: T[];
+} : T extends readonly unknown[] ? number extends T['length'] ? {
+    rt$items: MockNode<T[number], _MockDepth[Depth]>;
+    rt$length?: number | [number, number];
+} : {
+    rt$slots: {
+        [K in keyof T]: MockNode<T[K], _MockDepth[Depth]>;
+    };
+} : T extends number ? {
+    pool: number[];
+    min?: number;
+    max?: number;
+} : T extends string ? {
+    pool: string[];
+} : T extends Date ? {
+    pool: Date[];
+    min?: Date;
+    max?: Date;
+} : T extends MockDataUrl ? {
+    pool: MockDataUrl[];
+} : T extends RegExp ? {
+    pool: RegExp[];
+} : T extends boolean ? {
+    pool: boolean[];
+} : T extends bigint ? {
+    pool: bigint[];
+} : T extends object ? {
+    [K in keyof T]-?: MockNode<T[K], _MockDepth[Depth]>;
+} & {
+    rt$optional?: number;
+} : {
+    pool: T[];
+};
+export type MockData<T> = MockNode<T>;
+export {};

package/dist/cjs/enrich/mockData.js

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

package/dist/cjs/fnHash.d.ts

@@ -0,0 +1,8 @@
+import { FN_HASHES } from './go-generated/fnHashes.generated.ts';
+export type FnHashKey = keyof typeof FN_HASHES;
+export interface FnHashOptions {
+    numberMode?: string;
+    strategy?: string;
+    rejectCircularRefs?: boolean;
+}
+export declare function getFnHash(fnKey: FnHashKey | (string & {}), options?: FnHashOptions): string;

package/dist/cjs/fnHash.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFnHash = getFnHash;
+const fnHashes_generated_ts_1 = require("./go-generated/fnHashes.generated.js");
+function numberModeOptionName(mode) {
+    if (mode === 'typeof')
+        return 'numberTypeof';
+    if (mode === 'notNaN')
+        return 'numberNotNaN';
+    return '';
+}
+function validateVariantToken(options) {
+    if (!options)
+        return '';
+    const numberModeName = numberModeOptionName(options.numberMode);
+    let suffix = 'N';
+    let hit = false;
+    for (const [name, letter] of fnHashes_generated_ts_1.VALIDATE_OPTION_LETTERS) {
+        if (name === numberModeName) {
+            suffix += letter;
+            hit = true;
+        }
+    }
+    return hit ? suffix : '';
+}
+function getFnHash(fnKey, options) {
+    const entry = fnHashes_generated_ts_1.FN_HASHES[fnKey];
+    if (!entry)
+        throw new Error(`getFnHash: unknown fnKey ${JSON.stringify(fnKey)}`);
+    let token = '';
+    if (entry.axis === 'validateOptions')
+        token = validateVariantToken(options);
+    else if (entry.axis === 'jsonStrategy')
+        token = options?.strategy ?? entry.defaultVariant ?? '';
+    if (entry.circularGuarded && options?.rejectCircularRefs)
+        token += 'C';
+    const hash = entry.variants[token];
+    if (hash === undefined)
+        throw new Error(`getFnHash: fnKey ${JSON.stringify(fnKey)} has no ${JSON.stringify(token)} variant`);
+    return hash;
+}

package/dist/cjs/formats/bigintFormats.d.ts

@@ -0,0 +1,41 @@
+import { TypeFormat } from '../runtypes/typeFormat.ts';
+export interface BigIntParams {
+    min?: bigint;
+    max?: bigint;
+    lt?: bigint;
+    gt?: bigint;
+    multipleOf?: bigint;
+    minimum?: bigint;
+    maximum?: bigint;
+    exclusiveMinimum?: bigint;
+    exclusiveMaximum?: bigint;
+}
+export type BigInt<P extends BigIntParams = {}, BrandName extends string = never> = TypeFormat<bigint, 'bigintFormat', P, BrandName>;
+export type BigPositive = BigInt<{
+    min: 0n;
+}>;
+export type BigNegative = BigInt<{
+    max: 0n;
+}>;
+export type BigPositiveInt = BigInt<{
+    min: 0n;
+    multipleOf: 1n;
+}>;
+export type BigNegativeInt = BigInt<{
+    max: 0n;
+    multipleOf: 1n;
+}>;
+export type BigInt64 = BigInt<{
+    min: -9223372036854775808n;
+    max: 9223372036854775807n;
+}>;
+export type BigUInt64 = BigInt<{
+    min: 0n;
+    max: 18446744073709551615n;
+}>;
+export declare const bigPositive: (id?: import("../markers.ts").InjectRunTypeId<BigPositive> | undefined) => import("../index.ts").RunType<BigPositive>;
+export declare const bigNegative: (id?: import("../markers.ts").InjectRunTypeId<BigNegative> | undefined) => import("../index.ts").RunType<BigNegative>;
+export declare const bigPositiveInt: (id?: import("../markers.ts").InjectRunTypeId<BigPositiveInt> | undefined) => import("../index.ts").RunType<BigPositiveInt>;
+export declare const bigNegativeInt: (id?: import("../markers.ts").InjectRunTypeId<BigNegativeInt> | undefined) => import("../index.ts").RunType<BigNegativeInt>;
+export declare const bigInt64: (id?: import("../markers.ts").InjectRunTypeId<BigInt64> | undefined) => import("../index.ts").RunType<BigInt64>;
+export declare const bigUInt64: (id?: import("../markers.ts").InjectRunTypeId<BigUInt64> | undefined) => import("../index.ts").RunType<BigUInt64>;

package/dist/cjs/formats/bigintFormats.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigUInt64 = exports.bigInt64 = exports.bigNegativeInt = exports.bigPositiveInt = exports.bigNegative = exports.bigPositive = void 0;
+const builderCore_ts_1 = require("../runtypes/builderCore.js");
+exports.bigPositive = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigNegative = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigPositiveInt = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigNegativeInt = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigInt64 = (0, builderCore_ts_1.presetBuilder)('bigint');
+exports.bigUInt64 = (0, builderCore_ts_1.presetBuilder)('bigint');

package/dist/cjs/formats/datetime/dateFormats.d.ts

@@ -0,0 +1,10 @@
+import { TypeFormat } from '../../runtypes/typeFormat.ts';
+import type { MinMax, DateTimeBound } from './dateTimeParams.ts';
+export type NativeDateParams = MinMax<DateTimeBound>;
+export type Date<P extends NativeDateParams = {}, BrandName extends string = never> = TypeFormat<globalThis.Date, 'nativeDate', P, BrandName>;
+export type DateFuture = Date<{
+    min: 'now';
+}>;
+export type DatePast = Date<{
+    max: 'now';
+}>;

package/dist/cjs/formats/datetime/dateFormats.js

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

package/dist/cjs/formats/datetime/dateTime-pure-fns.d.ts

@@ -0,0 +1,21 @@
+export declare const isDateString: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_MnJ72PqkyXHiSP">;
+export declare const isDateString_YMD: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_gFl-yXbCxJqWgQ">;
+export declare const isDateString_DMY: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_PQVLEBllZckw8I">;
+export declare const isDateString_MDY: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_-y__pOnrgnvRMz">;
+export declare const isDateString_YM: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_GfQK19ktpvibuZ">;
+export declare const isDateString_MD: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_NJ9TCGDnkv_9Mn">;
+export declare const isDateString_DM: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_Eube1z0GFHuqlM">;
+export declare const isHours: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_d8U9HjmMsNFd6Z">;
+export declare const isMinutes: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_cgwpjq6rGsI8jb">;
+export declare const isSeconds: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_n_ZOWff4X3qBMQ">;
+export declare const isSecondsWithMs: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_6E7qWsIwaFRGn6">;
+export declare const isSecondsWithLeap: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_lFYcgG5ZSI-8em">;
+export declare const isTimeZone: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_EYsxRHRDgAykA_">;
+export declare const isTimeString_ISO: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_OCJ1B0-ZCAwagS">;
+export declare const isTimeString_ISO_TZ: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_qMsNYN8hy_sC8i">;
+export declare const isTimeString_HHmmss: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_IyjvBbz0zSlgCJ">;
+export declare const isTimeString_HHmm: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_hiotRbfSKFAuK4">;
+export declare const isTimeString_mmss: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_2xtQHAMu-yOBo6">;
+export declare const dateStrToMs: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_THkAA-KNR1HeAe">;
+export declare const timeStrToMs: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_t-ntJ9S0FuxkC2">;
+export declare const relativeNowKey: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_s-tZDRlQfCG5m2">;