@mionjs/run-types 0.8.8 → 0.13.0

package/dist/cjs/mocking/childMatch.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.childSchemaMatches = childSchemaMatches;
+exports.isMockSamplingError = isMockSamplingError;
+const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
+const rtUtils_ts_1 = require("../runtypes/rtUtils.js");
+const structuralFormat_ts_1 = require("./structuralFormat.js");
+const isMultipleOf_ts_1 = require("./isMultipleOf.js");
+const MAX_MATCH_DEPTH = 16;
+function childSchemaMatches(value, child) {
+    return matches(value, child, 0);
+}
+function matches(value, node, depth) {
+    if (depth > MAX_MATCH_DEPTH)
+        throw childMatchError('recursion exceeded MAX_MATCH_DEPTH');
+    const kind = node.kind;
+    switch (kind) {
+        case runTypeKind_generated_ts_1.RunTypeKind.ref: {
+            const resolved = (0, rtUtils_ts_1.getRTUtils)().getRunType(node.id);
+            if (!resolved)
+                throw childMatchError(`unresolvable ref '${String(node.id)}'`);
+            return matches(value, resolved, depth + 1);
+        }
+        case runTypeKind_generated_ts_1.RunTypeKind.any:
+        case runTypeKind_generated_ts_1.RunTypeKind.unknown:
+            return true;
+        case runTypeKind_generated_ts_1.RunTypeKind.never:
+            return false;
+        case runTypeKind_generated_ts_1.RunTypeKind.null:
+            return value === null;
+        case runTypeKind_generated_ts_1.RunTypeKind.undefined:
+        case runTypeKind_generated_ts_1.RunTypeKind.void:
+            return value === undefined;
+        case runTypeKind_generated_ts_1.RunTypeKind.boolean:
+            return typeof value === 'boolean';
+        case runTypeKind_generated_ts_1.RunTypeKind.string:
+            return typeof value === 'string' && formatMatches(value, node.formatAnnotation);
+        case runTypeKind_generated_ts_1.RunTypeKind.number:
+            return Number.isFinite(value) && numberParamsMatch(value, node.formatAnnotation);
+        case runTypeKind_generated_ts_1.RunTypeKind.bigint:
+            return typeof value === 'bigint' && bigintParamsMatch(value, node.formatAnnotation);
+        case runTypeKind_generated_ts_1.RunTypeKind.literal:
+            return literalMatches(value, node);
+        case runTypeKind_generated_ts_1.RunTypeKind.enum: {
+            const values = Array.isArray(node.values) ? node.values : [];
+            return values.some((entry) => entry === value);
+        }
+        case runTypeKind_generated_ts_1.RunTypeKind.object:
+            return (typeof value === 'object' &&
+                value !== null &&
+                (0, structuralFormat_ts_1.structuralFormatAccepts)(value, node.formatAnnotation) &&
+                patternKeysSatisfied(value, node, depth));
+        case runTypeKind_generated_ts_1.RunTypeKind.array:
+            if (!Array.isArray(value) || !(0, structuralFormat_ts_1.structuralFormatAccepts)(value, node.formatAnnotation))
+                return false;
+            if (!containsSatisfied(value, node, depth))
+                return false;
+            return node.child ? value.every((item) => matches(item, node.child, depth + 1)) : true;
+        case runTypeKind_generated_ts_1.RunTypeKind.tuple: {
+            if (!Array.isArray(value))
+                return false;
+            if (!(0, structuralFormat_ts_1.structuralFormatAccepts)(value, node.formatAnnotation))
+                return false;
+            if (!containsSatisfied(value, node, depth))
+                return false;
+            const members = node.children ?? [];
+            const lastMember = members[members.length - 1];
+            const restMember = lastMember !== undefined && restElement(lastMember) !== undefined ? lastMember : undefined;
+            const fixed = restMember === undefined ? members : members.slice(0, -1);
+            const required = fixed.filter((member) => !member.optional).length;
+            if (value.length < required)
+                return false;
+            if (restMember === undefined && value.length > fixed.length)
+                return false;
+            return value.every((item, i) => {
+                if (i < fixed.length)
+                    return fixed[i] ? matches(item, memberChild(fixed[i]), depth + 1) : false;
+                const element = restElement(restMember);
+                return element === undefined ? true : matches(item, element, depth + 1);
+            });
+        }
+        case runTypeKind_generated_ts_1.RunTypeKind.union:
+            return (node.children ?? []).some((arm) => matches(value, arm, depth + 1));
+        case runTypeKind_generated_ts_1.RunTypeKind.objectLiteral: {
+            if (typeof value !== 'object' || value === null || Array.isArray(value))
+                return false;
+            if (!(0, structuralFormat_ts_1.structuralFormatAccepts)(value, node.formatAnnotation))
+                return false;
+            if (!patternKeysSatisfied(value, node, depth))
+                return false;
+            const record = value;
+            for (const member of node.children ?? []) {
+                if (member.kind === runTypeKind_generated_ts_1.RunTypeKind.indexSignature) {
+                    const valueChild = member.child;
+                    if (valueChild && !Object.values(record).every((entry) => matches(entry, valueChild, depth + 1)))
+                        return false;
+                    continue;
+                }
+                const name = member.name;
+                if (name === undefined)
+                    continue;
+                if (!(name in record)) {
+                    if (member.optional)
+                        continue;
+                    return false;
+                }
+                if (!matches(record[name], memberChild(member), depth + 1))
+                    return false;
+            }
+            return true;
+        }
+        default:
+            throw childMatchError(`cannot test a candidate against child kind ${kind}`);
+    }
+}
+function memberChild(member) {
+    return member.child ?? member;
+}
+function containsSatisfied(items, node, depth) {
+    const entries = node.contains;
+    if (!entries || entries.length === 0)
+        return true;
+    for (const entry of entries) {
+        let count = 0;
+        for (const item of items)
+            if (matches(item, entry.child, depth + 1))
+                count++;
+        if (count < entry.min)
+            return false;
+        if (entry.max >= 0 && count > entry.max)
+            return false;
+    }
+    return true;
+}
+function patternKeysSatisfied(record, node, depth) {
+    const patternProps = node.patternProps;
+    if (patternProps && patternProps.length > 0) {
+        for (const entry of patternProps) {
+            for (const [key, entryValue] of Object.entries(record)) {
+                if (new RegExp(entry.source).test(key) && !matches(entryValue, entry.value, depth + 1))
+                    return false;
+            }
+        }
+    }
+    const propNames = node.propNames;
+    if (propNames && propNames.length > 0) {
+        for (const entry of propNames) {
+            for (const key of Object.keys(record)) {
+                if (!matches(key, entry, depth + 1))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+function restElement(member) {
+    if (member.kind === runTypeKind_generated_ts_1.RunTypeKind.rest)
+        return member.child;
+    if (Array.isArray(member.flags) && member.flags.includes('rest'))
+        return member.child;
+    const child = member.child;
+    if (child && child.kind === runTypeKind_generated_ts_1.RunTypeKind.rest)
+        return child.child;
+    return undefined;
+}
+function literalMatches(value, node) {
+    const literal = node.literal;
+    if (Array.isArray(node.flags) && node.flags.includes('bigint')) {
+        return typeof value === 'bigint' && value.toString() === String(literal);
+    }
+    return value === literal;
+}
+function patternTest(param, value) {
+    const pattern = param;
+    if (!pattern || typeof pattern.source !== 'string') {
+        throw childMatchError('pattern param without a literal source');
+    }
+    return new RegExp(pattern.source, typeof pattern.flags === 'string' ? pattern.flags : '').test(value);
+}
+const NAMED_STRING_FORMATS = {
+    email: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+    uuid: (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value),
+    date: (value) => /^\d{4}-\d{2}-\d{2}$/.test(value),
+    time: (value) => /^\d{2}:\d{2}(:\d{2})?/.test(value),
+    dateTime: (value) => /^\d{4}-\d{2}-\d{2}[Tt ]/.test(value),
+    ip: (value) => /^(\d{1,3}\.){3}\d{1,3}$/.test(value) || value.includes(':'),
+    domain: (value) => /^[a-z0-9-]+(\.[a-z0-9-]+)+$/i.test(value),
+    url: (value) => {
+        try {
+            new URL(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+};
+function formatMatches(value, annotation) {
+    if (!annotation)
+        return true;
+    const name = annotation.name;
+    const params = annotation.params ?? {};
+    if (name === 'stringFormat')
+        return stringParamsMatch(value, params);
+    if (params.pattern)
+        return stringParamsMatch(value, params);
+    const named = NAMED_STRING_FORMATS[name];
+    if (!named)
+        throw childMatchError(`no runtime test for string format '${name}'`);
+    return named(value);
+}
+function stringParamsMatch(value, params) {
+    for (const [key, param] of Object.entries(params)) {
+        switch (key) {
+            case 'contentMediaType': {
+                if (param !== 'application/json')
+                    break;
+                try {
+                    JSON.parse(params.contentEncoding === 'base64' ? atob(value) : value);
+                }
+                catch {
+                    return false;
+                }
+                break;
+            }
+            case 'contentEncoding':
+                break;
+            case 'minLength':
+                if (typeof param === 'number' && value.length < param)
+                    return false;
+                break;
+            case 'maxLength':
+                if (typeof param === 'number' && value.length > param)
+                    return false;
+                break;
+            case 'length':
+                if (typeof param === 'number' && value.length !== param)
+                    return false;
+                break;
+            case 'pattern':
+                if (!patternTest(param, value))
+                    return false;
+                break;
+            case 'allowedChars':
+                if (!patternTest(param, value))
+                    return false;
+                break;
+            case 'disallowedChars':
+                if (patternTest(param, value))
+                    return false;
+                break;
+            case 'allowedValues':
+                if (Array.isArray(param) && !param.includes(value))
+                    return false;
+                break;
+            case 'disallowedValues':
+                if (Array.isArray(param) && param.includes(value))
+                    return false;
+                break;
+            case 'idna':
+                if (param !== 'ascii')
+                    throw childMatchError(`no runtime test for idna '${String(param)}'`);
+                break;
+            case 'mockSamples':
+                break;
+            default:
+                throw childMatchError(`no runtime test for string param '${key}'`);
+        }
+    }
+    return true;
+}
+function numberParamsMatch(value, annotation) {
+    if (!annotation)
+        return true;
+    const params = annotation.params ?? {};
+    for (const [key, param] of Object.entries(params)) {
+        switch (key) {
+            case 'min':
+                if (typeof param === 'number' && value < param)
+                    return false;
+                break;
+            case 'max':
+                if (typeof param === 'number' && value > param)
+                    return false;
+                break;
+            case 'gt':
+                if (typeof param === 'number' && value <= param)
+                    return false;
+                break;
+            case 'lt':
+                if (typeof param === 'number' && value >= param)
+                    return false;
+                break;
+            case 'integer':
+                if (param === true && !Number.isInteger(value))
+                    return false;
+                break;
+            case 'multipleOf': {
+                const tolerance = params.multipleOfTolerance;
+                if (typeof param === 'number' &&
+                    param !== 0 &&
+                    !(0, isMultipleOf_ts_1.isMultipleOf)(value, param, typeof tolerance === 'number' ? tolerance : undefined))
+                    return false;
+                break;
+            }
+            case 'multipleOfTolerance':
+            case 'isCurrency':
+            case 'mockSamples':
+                break;
+            default:
+                throw childMatchError(`no runtime test for number param '${key}'`);
+        }
+    }
+    return true;
+}
+function bigintParamsMatch(value, annotation) {
+    if (!annotation)
+        return true;
+    const params = annotation.params ?? {};
+    for (const [key, param] of Object.entries(params)) {
+        switch (key) {
+            case 'min':
+                if (value < BigInt(param))
+                    return false;
+                break;
+            case 'max':
+                if (value > BigInt(param))
+                    return false;
+                break;
+            case 'gt':
+                if (value <= BigInt(param))
+                    return false;
+                break;
+            case 'lt':
+                if (value >= BigInt(param))
+                    return false;
+                break;
+            case 'multipleOf': {
+                const divisor = BigInt(param);
+                if (divisor !== 0n && value % divisor !== 0n)
+                    return false;
+                break;
+            }
+            case 'mockSamples':
+                break;
+            default:
+                throw childMatchError(`no runtime test for bigint param '${key}'`);
+        }
+    }
+    return true;
+}
+function childMatchError(reason) {
+    return new Error(`Cannot mock a constrained child (${reason}). Provide a MockData pool for this type (enrich) with values that satisfy the constraint.`);
+}
+function isMockSamplingError(error) {
+    return error instanceof Error && error.message.startsWith('Cannot mock a constrained child');
+}

package/dist/cjs/mocking/constants.mock.d.ts

@@ -0,0 +1,7 @@
+import type { MockOptions } from './mockTypes.ts';
+export declare const mockRegExpsList: RegExp[];
+export declare const stringCharSet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 .>?<~!@#$%^&*()_+-=[]{}|;:,";
+export declare const emailLocalPartSymbols = "._%-";
+export declare const anyValuesList: unknown[];
+export declare const mockObjectList: object[];
+export declare const defaultMockOptions: MockOptions;

package/dist/cjs/mocking/constants.mock.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMockOptions = exports.mockObjectList = exports.anyValuesList = exports.emailLocalPartSymbols = exports.stringCharSet = exports.mockRegExpsList = void 0;
+exports.mockRegExpsList = [
+    /abc/,
+    /def/,
+    /123/,
+    /xyz/,
+    /[\w]+/,
+    /\d{3}-\d{3}-\d{4}/,
+    /[A-Z]/,
+    /[a-z]/,
+    /\d+/,
+    /\s+/,
+    /^https:\/\/[\w.-]+\.[a-zA-Z]{2,}$/i,
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i,
+    /\b\d{2}\/\d{2}\/\d{4}\b/,
+    /\b\d{1,2}:\d{2}\b/,
+    /\b\d{1,2}:\d{2}:\d{2}\b/,
+    /\b\d{1,2}\/\d{1,2}\/\d{2}\b/,
+    /\b\d{1,2}\/\d{1,2}\/\d{4}\b/,
+    /\b\d{1,2}:\d{2}:\d{2} [AP]M\b/,
+    /\b\d{1,2}:\d{2} [AP]M\b/,
+    /abc/gi,
+    /['"]/,
+    /\/(.*)\/(.*)?/,
+    /\/\//,
+    /`/,
+    /\/\\\//,
+];
+exports.stringCharSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 .>?<~!@#$%^&*()_+-=[]{}|;:,';
+exports.emailLocalPartSymbols = '._%-';
+exports.anyValuesList = [
+    {},
+    { hello: 'world' },
+    [],
+    [1, 3, 'hello'],
+    'hello',
+    1234,
+    BigInt(1),
+    true,
+    false,
+    null,
+    undefined,
+    Symbol('hello'),
+    -124,
+    0,
+    124,
+    0.1,
+    -0.1,
+    Infinity,
+    NaN,
+    new Date(),
+    /abc/,
+    new Map([
+        ['zero', 0],
+        ['one', 1],
+        ['two', 2],
+        ['three', 3],
+        ['four', 4],
+    ]),
+    new Set(['zero', 1, 2, 3, 'four']),
+];
+exports.mockObjectList = [
+    {},
+    { a: 1 },
+    { b: 2 },
+    { a: 1, b: 'hello' },
+    { a: 1, b: 2, c: 3 },
+    { a: 'hello', b: 2, c: 'wold', d: 4 },
+];
+exports.defaultMockOptions = {
+    anyValuesList: exports.anyValuesList,
+    promiseTimeOut: 1,
+    regexpList: exports.mockRegExpsList,
+    maxRandomStringLength: 100,
+    stringCharSet: exports.stringCharSet,
+    maxRandomItemsLength: 60,
+    optionalProbability: 0.5,
+    objectList: exports.mockObjectList,
+    maxStackDepth: 50,
+    maxMockRecursion: 10,
+    nonDataTypes: false,
+    invalid: false,
+    invalidLeafProbability: 0.85,
+    seed: undefined,
+};

package/dist/cjs/mocking/createMockData.d.ts

@@ -0,0 +1,8 @@
+import './mockStringFormat.ts';
+import './mockNumberFormat.ts';
+import './mockBigIntFormat.ts';
+import type { RunType } from '../runtypes/types.ts';
+import type { CompTimeHints, InjectRunTypeId } from '../index.ts';
+import type { MockTypeFn, RunTypeMockOptions } from './mockTypes.ts';
+export declare function createMockDataFn<T>(runType: RunType<T>, options?: CompTimeHints<RunTypeMockOptions<T>>, id?: InjectRunTypeId<T>): MockTypeFn<T>;
+export declare function createMockDataFn<T>(val?: T, options?: CompTimeHints<RunTypeMockOptions<T>>, id?: InjectRunTypeId<T>): MockTypeFn<T>;

package/dist/cjs/mocking/createMockData.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockDataFn = createMockDataFn;
+const rtUtils_ts_1 = require("../runtypes/rtUtils.js");
+const entryTuple_ts_1 = require("../runtypes/entryTuple.js");
+require("./mockStringFormat.js");
+require("./mockNumberFormat.js");
+require("./mockBigIntFormat.js");
+const mockType_ts_1 = require("./mockType.js");
+const mockInvalid_ts_1 = require("./mockInvalid.js");
+const mockRandom_ts_1 = require("./mockRandom.js");
+const constants_mock_ts_1 = require("./constants.mock.js");
+function createMockDataFn(valOrSchema, options, id) {
+    let injectedId = id;
+    if ((0, entryTuple_ts_1.isEntryTuple)(id)) {
+        (0, entryTuple_ts_1.initFromTuple)(id);
+        injectedId = (0, entryTuple_ts_1.entryTupleKey)(id);
+    }
+    const effectiveId = (0, rtUtils_ts_1.isRunTypeValue)(valOrSchema) ? valOrSchema.id : injectedId;
+    if (effectiveId === undefined) {
+        throw new Error('createMockDataFn(): no id injected. @mionjs/devtools must be active for createMockDataFn to resolve the runtype graph.');
+    }
+    const utils = (0, rtUtils_ts_1.getRTUtils)();
+    const runType = utils.getRunType(effectiveId);
+    if (!runType) {
+        throw new Error(`createMockDataFn(): no RunType entry for "${effectiveId}" in rtUtils. The build pipeline didn't emit a cache entry for that runtype.`);
+    }
+    const factoryOpts = mergeMockOptions(undefined, options);
+    return ((callOpts) => {
+        const merged = mergeMockOptions(factoryOpts, callOpts);
+        const mockOpts = merged.mock;
+        mockOpts.random = mockOpts.seed === undefined ? mockRandom_ts_1.nativeMockRandom : new mockRandom_ts_1.MockRandom(mockOpts.seed);
+        if (mockOpts.invalid)
+            return (0, mockInvalid_ts_1.mockRunTypeInvalid)(runType, merged, []);
+        return (0, mockType_ts_1.mockRunType)(runType, merged, []);
+    });
+}
+function mergeMockOptions(factoryOpts, callOpts) {
+    const factoryMock = factoryOpts?.mock;
+    const callMock = callOpts?.mock;
+    const merged = {
+        ...constants_mock_ts_1.defaultMockOptions,
+        ...factoryMock,
+        ...callMock,
+    };
+    const data = (callOpts?.data ?? factoryOpts?.data);
+    const result = { mock: merged };
+    if (data !== undefined) {
+        result.data = data;
+        result.dataNode = data;
+    }
+    return result;
+}

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

@@ -0,0 +1,4 @@
+export { createMockDataFn } from './createMockData.ts';
+export type { MockOptions, MockTypeFn, RunTypeMockOptions } from './mockTypes.ts';
+export { MockRandom } from './mockRandom.ts';
+export { registerMockingFunction, type MockFormatFn } from './mockRegistry.ts';

package/dist/cjs/mocking/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMockingFunction = exports.MockRandom = exports.createMockDataFn = void 0;
+var createMockData_ts_1 = require("./createMockData.js");
+Object.defineProperty(exports, "createMockDataFn", { enumerable: true, get: function () { return createMockData_ts_1.createMockDataFn; } });
+var mockRandom_ts_1 = require("./mockRandom.js");
+Object.defineProperty(exports, "MockRandom", { enumerable: true, get: function () { return mockRandom_ts_1.MockRandom; } });
+var mockRegistry_ts_1 = require("./mockRegistry.js");
+Object.defineProperty(exports, "registerMockingFunction", { enumerable: true, get: function () { return mockRegistry_ts_1.registerMockingFunction; } });

package/dist/cjs/mocking/isMultipleOf.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_MULTIPLE_OF_TOLERANCE: number;
+export declare function isMultipleOf(value: number, step: number, tolerance?: number): boolean;

package/dist/cjs/mocking/isMultipleOf.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MULTIPLE_OF_TOLERANCE = void 0;
+exports.isMultipleOf = isMultipleOf;
+exports.DEFAULT_MULTIPLE_OF_TOLERANCE = 4 * Number.EPSILON;
+function isMultipleOf(value, step, tolerance = exports.DEFAULT_MULTIPLE_OF_TOLERANCE) {
+    if (Number.isInteger(step))
+        return value % step === 0;
+    const quotient = value / step;
+    return Math.abs(quotient - Math.round(quotient)) <= Math.abs(quotient) * tolerance;
+}

package/dist/cjs/mocking/mockBigIntFormat.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/mocking/mockBigIntFormat.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
+const mockRegistry_ts_1 = require("./mockRegistry.js");
+const mockRandom_ts_1 = require("./mockRandom.js");
+const mockBigIntFormat = (annotation, random = mockRandom_ts_1.nativeMockRandom) => {
+    if (annotation.name !== 'bigintFormat')
+        return undefined;
+    return mockBigIntParams((annotation.params ?? {}), random);
+};
+(0, mockRegistry_ts_1.registerMockingFunction)(runTypeKind_generated_ts_1.RunTypeKind.bigint, mockBigIntFormat);
+const MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+function mockBigIntParams(params, random) {
+    let min = params.min !== undefined ? toBig(params.min) : -99999n;
+    let max = params.max !== undefined ? toBig(params.max) : 99999n;
+    if (params.gt !== undefined)
+        min = toBig(params.gt) + 1n;
+    if (params.lt !== undefined)
+        max = toBig(params.lt) - 1n;
+    const minNum = Number(min > MIN_SAFE ? min : MIN_SAFE);
+    const maxNum = Number(max < MAX_SAFE ? max : MAX_SAFE);
+    let result = BigInt(random.int(minNum, maxNum));
+    if (params.multipleOf !== undefined) {
+        const multipleOf = toBig(params.multipleOf);
+        result = (result / multipleOf) * multipleOf;
+    }
+    return result;
+}
+function toBig(value) {
+    if (typeof value === 'bigint')
+        return value;
+    if (typeof value === 'number')
+        return BigInt(Math.trunc(value));
+    if (value !== null && typeof value === 'object' && 'val' in value)
+        return toBig(value.val);
+    return BigInt(String(value).replace(/n$/, ''));
+}

package/dist/cjs/mocking/mockDateTimeBounds.d.ts

@@ -0,0 +1,13 @@
+import type { DateFmt, TimeFmt, DateTimeParams } from '../formats/datetime/stringDateTimeFormats.ts';
+import type { MockRandom } from './mockRandom.ts';
+interface BoundInputs {
+    min?: string;
+    max?: string;
+    gt?: string;
+    lt?: string;
+}
+export declare function mockBoundedDate(layout: DateFmt, bounds: BoundInputs, random: MockRandom): string;
+export declare function mockBoundedTime(layout: TimeFmt, bounds: BoundInputs, random: MockRandom): string;
+export declare function mockBoundedDateTime(params: Partial<DateTimeParams>, random: MockRandom): string;
+export declare function mockBoundedNativeDate(bounds: BoundInputs, random: MockRandom): Date;
+export {};