@mionjs/run-types 0.13.2 → 0.14.0

package/dist/cjs/mocking/mockRandom.js

@@ -1,106 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-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

@@ -1,11 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-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

@@ -1,238 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-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

@@ -1,233 +0,0 @@
-"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

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