@mionjs/run-types 0.8.8 → 0.13.0

package/dist/cjs/mocking/mockRandom.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeMockRandom = exports.MockRandom = void 0;
+exports.mulberry32 = mulberry32;
+const constants_mock_ts_1 = require("./constants.mock.js");
+function splitmix32(seed) {
+    let z = (seed + 0x9e3779b9) | 0;
+    z = Math.imul(z ^ (z >>> 16), 0x21f0aaad);
+    z = Math.imul(z ^ (z >>> 15), 0x735a2d97);
+    return (z ^ (z >>> 15)) >>> 0;
+}
+function mulberry32(state) {
+    let current = state >>> 0;
+    return function next() {
+        current = (current + 0x6d2b79f5) | 0;
+        let t = Math.imul(current ^ (current >>> 15), 1 | current);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+const SEEDED_NOW_MS = 1_700_000_000_000;
+class MockRandom {
+    next;
+    constructor(seed) {
+        this.next = seed === undefined ? undefined : mulberry32(splitmix32(seed));
+    }
+    float() {
+        return this.next ? this.next() : Math.random();
+    }
+    int(min = 0, max = 10000) {
+        return Math.floor(this.float() * (max - min + 1)) + min;
+    }
+    pick(list) {
+        return list[this.int(0, list.length - 1)];
+    }
+    boolean() {
+        return this.float() < 0.5;
+    }
+    bigint(min = 0, max = 10000) {
+        return BigInt(this.int(min, max));
+    }
+    number(min = 0, max = 10000) {
+        if (min > max)
+            throw new Error('min cannot be greater than max');
+        return this.int(min, max);
+    }
+    string(length, allowedChars = constants_mock_ts_1.stringCharSet, disallowedChars = '') {
+        const len = length ?? this.int(0, 30);
+        if (allowedChars.length === 0)
+            throw new Error('Can not generate random string as allowedChars cannot be empty');
+        const allowedCharSet = allowedChars
+            .split('')
+            .filter((char) => !disallowedChars.includes(char))
+            .join('');
+        if (allowedCharSet.length === 0)
+            throw new Error('Can not generate random string as allowedChars and disallowedChars are mutually exclusive');
+        return Array.from({ length: len }, () => allowedCharSet[this.int(0, allowedCharSet.length - 1)]).join('');
+    }
+    symbol(name, length, charsSet) {
+        const symbolName = name ?? this.string(length, charsSet);
+        return Symbol(symbolName);
+    }
+    regExp(list = constants_mock_ts_1.mockRegExpsList) {
+        return list[this.int(0, list.length - 1)];
+    }
+    date(minDate = new Date(0), maxDate) {
+        const min = typeof minDate === 'number' ? minDate : minDate.getTime();
+        const max = maxDate === undefined ? this.now() : typeof maxDate === 'number' ? maxDate : maxDate.getTime();
+        if (min > max)
+            throw new Error('minDate cannot be greater than maxDate');
+        return new Date(this.int(min, max));
+    }
+    any(anyList = constants_mock_ts_1.anyValuesList) {
+        return anyList[this.int(0, anyList.length - 1)];
+    }
+    now() {
+        return this.next ? SEEDED_NOW_MS : Date.now();
+    }
+    uuidV4() {
+        if (!this.next) {
+            const globalCrypto = globalThis.crypto;
+            if (globalCrypto?.randomUUID)
+                return globalCrypto.randomUUID();
+        }
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+            const rand = (this.float() * 16) | 0;
+            const value = char === 'x' ? rand : (rand & 0x3) | 0x8;
+            return value.toString(16);
+        });
+    }
+    uuidV7() {
+        const timeMs = this.next ? SEEDED_NOW_MS + this.int(0, 0xffffff) : Date.now();
+        const timeHex = timeMs.toString(16).padStart(12, '0').slice(-12);
+        const randHex = (count) => {
+            let out = '';
+            for (let i = 0; i < count; i++)
+                out += Math.floor(this.float() * 16).toString(16);
+            return out;
+        };
+        const variant = ((Math.floor(this.float() * 16) & 0x3) | 0x8).toString(16);
+        const full = timeHex + '7' + randHex(3) + variant + randHex(15);
+        return `${full.slice(0, 8)}-${full.slice(8, 12)}-${full.slice(12, 16)}-${full.slice(16, 20)}-${full.slice(20, 32)}`;
+    }
+}
+exports.MockRandom = MockRandom;
+exports.nativeMockRandom = new MockRandom();

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

@@ -0,0 +1,7 @@
+import type { FormatAnnotation } from '../runtypes/formatAnnotation.ts';
+import type { RunTypeKindValue } from '../go-generated/runTypeKind.generated.ts';
+import type { MockRandom } from './mockRandom.ts';
+import type { MockOptions } from './mockTypes.ts';
+export type MockFormatFn = (annotation: FormatAnnotation, random?: MockRandom, options?: MockOptions) => unknown;
+export declare function registerMockingFunction(kind: RunTypeKindValue, fn: MockFormatFn): void;
+export declare function getMockingFunction(kind: RunTypeKindValue): MockFormatFn | undefined;

package/dist/cjs/mocking/mockRegistry.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMockingFunction = registerMockingFunction;
+exports.getMockingFunction = getMockingFunction;
+const registry = new Map();
+function registerMockingFunction(kind, fn) {
+    registry.set(kind, fn);
+}
+function getMockingFunction(kind) {
+    return registry.get(kind);
+}

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

@@ -0,0 +1,5 @@
+import type { MockRandom } from './mockRandom.ts';
+import type { FormatAnnotation } from '../runtypes/formatAnnotation.ts';
+export declare function pickSample(samples: readonly string[] | undefined, random: MockRandom): string | undefined;
+export declare function negativeForStringFormat(annotation: FormatAnnotation | undefined, value: unknown): unknown;
+export declare function mockUrlObject(annotation: FormatAnnotation | undefined, random?: MockRandom): URL;

package/dist/cjs/mocking/mockStringFormat.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickSample = pickSample;
+exports.negativeForStringFormat = negativeForStringFormat;
+exports.mockUrlObject = mockUrlObject;
+const mockRegistry_ts_1 = require("./mockRegistry.js");
+const mockRandom_ts_1 = require("./mockRandom.js");
+const credit_card_pure_fns_ts_1 = require("../formats/string/credit-card-pure-fns.js");
+const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
+const mockDateTimeBounds_ts_1 = require("./mockDateTimeBounds.js");
+function mockStringFormat(annotation, random = mockRandom_ts_1.nativeMockRandom, options) {
+    const params = annotation.params ?? {};
+    switch (annotation.name) {
+        case 'stringFormat':
+            return mockStringParams(params, random);
+        case 'uuid':
+            return mockUuid(params, random);
+        case 'creditCard':
+            return mockCreditCard(params, random, options);
+        case 'date': {
+            const dateParams = params;
+            return (0, mockDateTimeBounds_ts_1.mockBoundedDate)(dateParams.format ?? 'ISO', dateParams, random);
+        }
+        case 'time': {
+            const timeParams = params;
+            return (0, mockDateTimeBounds_ts_1.mockBoundedTime)(timeParams.format ?? 'ISO', timeParams, random);
+        }
+        case 'dateTime':
+            return (0, mockDateTimeBounds_ts_1.mockBoundedDateTime)(params, random);
+        case 'ip':
+            return mockIp(params, random);
+        case 'domain':
+            return lengthFiltered(params, () => mockDomain(params, random));
+        case 'email':
+            return lengthFiltered(params, () => mockEmail(params, random));
+        case 'url':
+            return lengthFiltered(params, () => mockUrl(params, random));
+        default:
+            return undefined;
+    }
+}
+(0, mockRegistry_ts_1.registerMockingFunction)(runTypeKind_generated_ts_1.RunTypeKind.string, mockStringFormat);
+function mockStringParams(params, random) {
+    if (params.allowedValues)
+        return pickSample(params.allowedValues.val, random) ?? '';
+    const sample = pickSample(filterSamplesByLength(params.mockSamples ?? patternSampleList(params.pattern) ?? toSampleList(params.disallowedValues?.mockSamples), params), random);
+    if (sample !== undefined)
+        return sample;
+    if (params.contentMediaType === 'application/json') {
+        return params.contentEncoding === 'base64' ? 'e30=' : '{}';
+    }
+    const charSet = params.allowedChars?.val ?? asCharString(params.disallowedChars?.mockSamples);
+    if (charSet)
+        return randomStringFrom(charSet, Math.max(1, pickMockLength(params, random)), random);
+    if (params.pattern !== undefined) {
+        throw new Error('StringFormat: a `pattern` needs `mockSamples` compatible with the length bounds to mock — ' +
+            'none survived (every sample violates length/minLength/maxLength), or none exist. The build ' +
+            'auto-generates them from the regex; building without the plugin/CLI (or with patternSampleCount 0) ' +
+            'requires declaring mockSamples explicitly.');
+    }
+    return randomString(pickMockLength(params, random), random);
+}
+function patternSampleList(pattern) {
+    const samples = pattern?.mockSamples;
+    return toSampleList(samples);
+}
+function filterSamplesByLength(samples, params) {
+    if (!samples || samples.length === 0)
+        return samples;
+    if (params.length === undefined && params.minLength === undefined && params.maxLength === undefined)
+        return samples;
+    return samples.filter((sample) => {
+        if (params.length !== undefined && sample.length !== params.length)
+            return false;
+        if (params.minLength !== undefined && sample.length < params.minLength)
+            return false;
+        if (params.maxLength !== undefined && sample.length > params.maxLength)
+            return false;
+        return true;
+    });
+}
+function pickSample(samples, random) {
+    if (!samples || samples.length === 0)
+        return undefined;
+    return samples[random.int(0, samples.length - 1)];
+}
+function toSampleList(samples) {
+    if (samples === undefined)
+        return undefined;
+    return typeof samples === 'string' ? [samples] : samples;
+}
+function asCharString(samples) {
+    return typeof samples === 'string' ? samples : undefined;
+}
+function randomStringFrom(chars, length, random) {
+    if (chars.length === 0)
+        return '';
+    let out = '';
+    for (let i = 0; i < length; i++)
+        out += chars[random.int(0, chars.length - 1)];
+    return out;
+}
+function pickMockLength(params, random) {
+    if (params.length !== undefined)
+        return params.length;
+    if (params.maxLength !== undefined && params.minLength !== undefined) {
+        return random.int(params.minLength, params.maxLength);
+    }
+    if (params.maxLength !== undefined)
+        return random.int(0, params.maxLength);
+    if (params.minLength !== undefined)
+        return random.int(params.minLength, params.minLength + 8);
+    return random.int(1, 16);
+}
+const MOCK_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+function randomString(length, random) {
+    let out = '';
+    for (let i = 0; i < length; i++)
+        out += MOCK_CHARS[random.int(0, MOCK_CHARS.length - 1)];
+    return out;
+}
+function mockUuid(params, random) {
+    return params.version === '7' ? random.uuidV7() : random.uuidV4();
+}
+const TEST_CARD_NUMBERS = {
+    visa: ['4111111111111111', '4012888888881881', '4222222222222'],
+    mastercard: ['5555555555554444', '5105105105105100', '2223003122003222'],
+    amex: ['378282246310005', '371449635398431', '378734493671000'],
+    discover: ['6011111111111117', '6011000990139424'],
+    jcb: ['3530111333300000', '3566002020360505'],
+    diners: ['30569309025904', '38520000023237'],
+    unionpay: ['6200000000000005'],
+    maestro: ['6759649826438453', '6304000000000000'],
+};
+function generateCardNumber(network, random) {
+    const rule = (0, credit_card_pure_fns_ts_1.getCardNetworkRules)()[network];
+    const [low, high] = rule.prefixes[random.int(0, rule.prefixes.length - 1)];
+    const prefix = String(random.int(Number(low), Number(high))).padStart(low.length, '0');
+    const length = rule.lengths[random.int(0, rule.lengths.length - 1)];
+    let body = prefix.slice(0, length - 1);
+    while (body.length < length - 1)
+        body += String(random.int(0, 9));
+    return body + (0, credit_card_pure_fns_ts_1.luhnCheckDigit)(body);
+}
+function mockCreditCard(params, random, options) {
+    const networks = params.networks?.length ? params.networks : credit_card_pure_fns_ts_1.CARD_NETWORKS;
+    const network = networks[random.int(0, networks.length - 1)];
+    if (options?.testCreditCards) {
+        const pool = TEST_CARD_NUMBERS[network];
+        return pool[random.int(0, pool.length - 1)];
+    }
+    return generateCardNumber(network, random);
+}
+function negativeForStringFormat(annotation, value) {
+    if (annotation?.name !== 'creditCard' || typeof value !== 'string')
+        return undefined;
+    for (let i = value.length - 1; i >= 0; i--) {
+        const charCode = value.charCodeAt(i);
+        if (charCode < 48 || charCode > 57)
+            continue;
+        return value.slice(0, i) + String((charCode - 48 + 1) % 10) + value.slice(i + 1);
+    }
+    return 'not-a-card';
+}
+function mockIp(params, random) {
+    if (params.version === 4)
+        return mockIpV4(params, random);
+    if (params.version === 6)
+        return mockIpV6(params, random);
+    return random.float() > 0.5 ? mockIpV4(params, random) : mockIpV6(params, random);
+}
+function mockIpV4(params, random) {
+    if (params.allowLocalHost && random.float() > 0.8) {
+        return params.allowPort ? `localhost:${randomPort(random)}` : 'localhost';
+    }
+    const address = Array.from({ length: 4 }, () => random.int(0, 255)).join('.');
+    return params.allowPort ? `${address}:${randomPort(random)}` : address;
+}
+function mockIpV6(params, random) {
+    if (random.float() > 0.8) {
+        const loopback = random.float() > 0.5 ? '0:0:0:0:0:0:0:1' : '::1';
+        return params.allowPort ? `[${loopback}]` : loopback;
+    }
+    const address = Array.from({ length: 8 }, () => Math.floor(random.float() * 0xffff).toString(16)).join(':');
+    return params.allowPort ? `[${address}]:${randomPort(random)}` : address;
+}
+function randomPort(random) {
+    return random.int(0, 65535);
+}
+function mockDomain(params, random) {
+    if (params.allowedValues) {
+        const allowed = pickSample(params.allowedValues.val, random);
+        if (allowed !== undefined)
+            return allowed;
+    }
+    if (params.names || params.tld) {
+        const name = pickSample(domainPartSamples(params.names), random) ?? 'example';
+        const tld = pickSample(domainPartSamples(params.tld), random) ?? 'com';
+        return `${name}.${tld}`;
+    }
+    return pickSample(params.mockSamples ?? patternSampleList(asPattern(params.pattern)), random) ?? 'example.com';
+}
+function domainPartSamples(part) {
+    if (!part)
+        return undefined;
+    return toSampleList(part.mockSamples) ?? patternSampleList(asPattern(part.pattern));
+}
+function lengthFiltered(params, draw) {
+    const { minLength, maxLength } = params;
+    if (minLength === undefined && maxLength === undefined)
+        return draw();
+    for (let attempt = 0; attempt < 32; attempt++) {
+        const candidate = draw();
+        const size = [...candidate].length;
+        if ((minLength === undefined || size >= minLength) && (maxLength === undefined || size <= maxLength)) {
+            return candidate;
+        }
+    }
+    throw new Error('Cannot mock format: no sample satisfied the minLength/maxLength bounds after 32 attempts — widen the bounds or provide mockSamples that fit.');
+}
+function mockEmail(params, random) {
+    if (params.localPart || params.domain) {
+        const local = params.localPart ? mockStringParams(params.localPart, random) : 'user';
+        const domain = params.domain ? mockDomain(params.domain, random) : 'example.com';
+        return `${local}@${domain}`;
+    }
+    return pickSample(params.mockSamples ?? patternSampleList(asPattern(params.pattern)), random) ?? 'john@example.com';
+}
+function mockUrlObject(annotation, random = mockRandom_ts_1.nativeMockRandom) {
+    const params = (annotation?.name === 'nativeUrl' ? annotation.params : undefined) ?? {};
+    return new URL(lengthFiltered(params, () => new URL(mockUrl(params, random)).href));
+}
+function mockUrl(params, random) {
+    return pickSample(params.mockSamples ?? patternSampleList(asPattern(params.pattern)), random) ?? 'https://example.com';
+}
+function asPattern(pattern) {
+    return pattern;
+}

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

@@ -0,0 +1,13 @@
+import type { MockRandom } from './mockRandom.ts';
+export interface TemporalBounds {
+    min?: string;
+    max?: string;
+    gt?: string;
+    lt?: string;
+}
+export declare function mockTemporal(subKind: number, bounds: TemporalBounds | undefined, random: MockRandom): unknown;
+export declare function temporalBoundsFromAnnotation(annotation: {
+    name?: string;
+    params?: Record<string, unknown>;
+} | undefined): TemporalBounds | undefined;
+export declare function isTemporalSubKind(subKind: number | undefined): boolean;

package/dist/cjs/mocking/mockTemporal.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockTemporal = mockTemporal;
+exports.temporalBoundsFromAnnotation = temporalBoundsFromAnnotation;
+exports.isTemporalSubKind = isTemporalSubKind;
+const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
+function temporal() {
+    const t = globalThis.Temporal;
+    if (!t) {
+        throw new Error('[mion] Temporal is not available in this runtime. ' +
+            'Temporal ships natively in Node 26+ / modern browsers; on older runtimes install a polyfill ' +
+            "(e.g. `globalThis.Temporal = require('temporal-polyfill').Temporal`).");
+    }
+    return t;
+}
+const pad = (n, width = 2) => String(n).padStart(width, '0');
+function randomDateParts(random) {
+    return { year: random.int(1970, 2099), month: random.int(1, 12), day: random.int(1, 28) };
+}
+function randomTimeParts(random) {
+    return { hour: random.int(0, 23), minute: random.int(0, 59), second: random.int(0, 59) };
+}
+function mockPlainDate(random) {
+    const d = randomDateParts(random);
+    return temporal().PlainDate.from(`${pad(d.year, 4)}-${pad(d.month)}-${pad(d.day)}`);
+}
+function mockPlainTime(random) {
+    const tm = randomTimeParts(random);
+    return temporal().PlainTime.from(`${pad(tm.hour)}:${pad(tm.minute)}:${pad(tm.second)}`);
+}
+function mockPlainDateTime(random) {
+    const d = randomDateParts(random);
+    const tm = randomTimeParts(random);
+    return temporal().PlainDateTime.from(`${pad(d.year, 4)}-${pad(d.month)}-${pad(d.day)}T${pad(tm.hour)}:${pad(tm.minute)}:${pad(tm.second)}`);
+}
+function mockPlainYearMonth(random) {
+    const d = randomDateParts(random);
+    return temporal().PlainYearMonth.from(`${pad(d.year, 4)}-${pad(d.month)}`);
+}
+function mockPlainMonthDay(random) {
+    const d = randomDateParts(random);
+    return temporal().PlainMonthDay.from(`${pad(d.month)}-${pad(d.day)}`);
+}
+function mockInstant(random) {
+    return temporal().Instant.fromEpochMilliseconds(random.int(0, 4102444800000));
+}
+function mockZonedDateTime(random) {
+    const d = randomDateParts(random);
+    const tm = randomTimeParts(random);
+    return temporal().ZonedDateTime.from(`${pad(d.year, 4)}-${pad(d.month)}-${pad(d.day)}T${pad(tm.hour)}:${pad(tm.minute)}:${pad(tm.second)}[UTC]`);
+}
+function mockDuration(random) {
+    return temporal().Duration.from(`P${random.int(0, 5)}Y${random.int(0, 11)}M${random.int(0, 27)}DT${random.int(0, 23)}H${random.int(0, 59)}M${random.int(0, 59)}S`);
+}
+const NS_PER_DAY = 86400000000000n;
+const REF_DATE = '1970-01-01';
+function instantFromNs(ns) {
+    return temporal().Instant.fromEpochNanoseconds(ns);
+}
+function boundAdapter(subKind, random) {
+    const T = temporal();
+    switch (subKind) {
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalInstant:
+            return {
+                grid: 1n,
+                now: () => T.Now.instant(),
+                fromLiteral: (s) => T.Instant.from(s),
+                key: (i) => i.epochNanoseconds,
+                fromKey: (k) => T.Instant.fromEpochNanoseconds(k),
+                fallback: () => mockInstant(random),
+            };
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalZonedDateTime:
+            return {
+                grid: 1n,
+                now: () => T.Now.zonedDateTimeISO(),
+                fromLiteral: (s) => T.ZonedDateTime.from(s),
+                key: (i) => i.epochNanoseconds,
+                fromKey: (k) => instantFromNs(k).toZonedDateTimeISO('UTC'),
+                fallback: () => mockZonedDateTime(random),
+            };
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainDate:
+            return {
+                grid: NS_PER_DAY,
+                now: () => T.Now.plainDateISO(),
+                fromLiteral: (s) => T.PlainDate.from(s),
+                key: (i) => i.toZonedDateTime('UTC').epochNanoseconds,
+                fromKey: (k) => instantFromNs(k).toZonedDateTimeISO('UTC').toPlainDate(),
+                fallback: () => mockPlainDate(random),
+            };
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainTime:
+            return {
+                grid: 1n,
+                now: () => T.Now.plainTimeISO(),
+                fromLiteral: (s) => T.PlainTime.from(s),
+                key: (i) => T.PlainDate.from(REF_DATE)
+                    .toPlainDateTime(i)
+                    .toZonedDateTime('UTC').epochNanoseconds,
+                fromKey: (k) => instantFromNs(k).toZonedDateTimeISO('UTC').toPlainTime(),
+                fallback: () => mockPlainTime(random),
+            };
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainDateTime:
+            return {
+                grid: 1n,
+                now: () => T.Now.plainDateTimeISO(),
+                fromLiteral: (s) => T.PlainDateTime.from(s),
+                key: (i) => i.toZonedDateTime('UTC').epochNanoseconds,
+                fromKey: (k) => instantFromNs(k).toZonedDateTimeISO('UTC').toPlainDateTime(),
+                fallback: () => mockPlainDateTime(random),
+            };
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainYearMonth:
+            return {
+                grid: 1n,
+                now: () => T.Now.plainDateISO(),
+                fromLiteral: (s) => T.PlainYearMonth.from(s),
+                key: (i) => {
+                    const ym = i;
+                    return BigInt(ym.year) * 12n + BigInt(ym.month - 1);
+                },
+                fromKey: (k) => T.PlainYearMonth.from({ year: Number(k / 12n), month: Number(k % 12n) + 1 }),
+                fallback: () => mockPlainYearMonth(random),
+            };
+        default:
+            return undefined;
+    }
+}
+function shift(instance, sign, durationStr) {
+    const duration = temporal().Duration.from(durationStr);
+    const shiftable = instance;
+    return sign < 0 ? shiftable.subtract(duration) : shiftable.add(duration);
+}
+function boundKey(adapter, bound) {
+    if (bound.startsWith('now')) {
+        const rest = bound.slice(3);
+        let instance = adapter.now();
+        if (rest)
+            instance = shift(instance, rest[0] === '-' ? -1 : 1, rest.slice(1));
+        return adapter.key(instance);
+    }
+    return adapter.key(adapter.fromLiteral(bound));
+}
+function randomBigIntBelow(n, random) {
+    if (n <= 1n)
+        return 0n;
+    const bits = n.toString(2).length;
+    const mask = (1n << BigInt(bits)) - 1n;
+    let result;
+    do {
+        result = 0n;
+        for (let b = 0; b < bits; b += 30) {
+            result = (result << 30n) | BigInt(Math.floor(random.float() * (1 << 30)));
+        }
+        result &= mask;
+    } while (result >= n);
+    return result;
+}
+function randBigInt(lo, hi, random) {
+    if (hi <= lo)
+        return lo;
+    return lo + randomBigIntBelow(hi - lo + 1n, random);
+}
+function mockBoundedTemporal(adapter, bounds, random) {
+    let lo;
+    let hi;
+    const raise = (candidate) => {
+        if (lo === undefined || candidate > lo)
+            lo = candidate;
+    };
+    const lower = (candidate) => {
+        if (hi === undefined || candidate < hi)
+            hi = candidate;
+    };
+    if (bounds.min !== undefined)
+        raise(boundKey(adapter, bounds.min));
+    if (bounds.gt !== undefined)
+        raise(boundKey(adapter, bounds.gt) + adapter.grid);
+    if (bounds.max !== undefined)
+        lower(boundKey(adapter, bounds.max));
+    if (bounds.lt !== undefined)
+        lower(boundKey(adapter, bounds.lt) - adapter.grid);
+    if (lo === undefined && hi === undefined)
+        return adapter.fallback();
+    const spread = adapter.grid * 18250n;
+    if (lo === undefined)
+        lo = hi - spread;
+    if (hi === undefined)
+        hi = lo + spread;
+    if (hi < lo)
+        hi = lo;
+    return adapter.fromKey(randBigInt(lo, hi, random));
+}
+function mockTemporal(subKind, bounds, random) {
+    if (bounds) {
+        const adapter = boundAdapter(subKind, random);
+        if (adapter)
+            return mockBoundedTemporal(adapter, bounds, random);
+    }
+    switch (subKind) {
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalInstant:
+            return mockInstant(random);
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalZonedDateTime:
+            return mockZonedDateTime(random);
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainDate:
+            return mockPlainDate(random);
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainTime:
+            return mockPlainTime(random);
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainDateTime:
+            return mockPlainDateTime(random);
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainYearMonth:
+            return mockPlainYearMonth(random);
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalPlainMonthDay:
+            return mockPlainMonthDay(random);
+        case runTypeKind_generated_ts_1.RunTypeSubKind.temporalDuration:
+            return mockDuration(random);
+        default:
+            return undefined;
+    }
+}
+function temporalBoundsFromAnnotation(annotation) {
+    if (!annotation || !annotation.name || !annotation.name.startsWith('temporal'))
+        return undefined;
+    const params = annotation.params ?? {};
+    const pick = (key) => (typeof params[key] === 'string' ? params[key] : undefined);
+    const min = pick('min');
+    const max = pick('max');
+    const gt = pick('gt');
+    const lt = pick('lt');
+    if (min === undefined && max === undefined && gt === undefined && lt === undefined)
+        return undefined;
+    return { min, max, gt, lt };
+}
+function isTemporalSubKind(subKind) {
+    return subKind !== undefined && subKind >= runTypeKind_generated_ts_1.RunTypeSubKind.temporalInstant && subKind <= runTypeKind_generated_ts_1.RunTypeSubKind.temporalDuration;
+}

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

@@ -0,0 +1,3 @@
+import type { RunTypeMockOptions } from './mockTypes.ts';
+import type { RunType } from '../runtypes/types.ts';
+export declare function mockRunType(runType: RunType, options: RunTypeMockOptions, stack?: RunType[]): unknown;