@mionjs/run-types 0.8.10 → 0.13.2

package/dist/mocking/mockType.js

@@ -0,0 +1,808 @@
+import { RunTypeKind, RunTypeSubKind } from '../go-generated/runTypeKind.generated.js';
+import { getMockingFunction } from './mockRegistry.js';
+import { childSchemaMatches, isMockSamplingError } from './childMatch.js';
+import { canonicalJson, isStructuralFormat, structuralFormatAccepts } from './structuralFormat.js';
+import { getRTUtils } from '../runtypes/rtUtils.js';
+import { nativeMockRandom } from './mockRandom.js';
+import { stringCharSet } from './constants.mock.js';
+import { mockBoundedNativeDate } from './mockDateTimeBounds.js';
+import { mockTemporal, isTemporalSubKind, temporalBoundsFromAnnotation } from './mockTemporal.js';
+import { mockUrlObject } from './mockStringFormat.js';
+export function mockRunType(runType, options, stack = []) {
+    stack.push(runType);
+    try {
+        const baseMockOpts = options.mock;
+        const nestLevel = countOccurrences(stack, runType);
+        if (nestLevel > baseMockOpts.maxMockRecursion)
+            return undefined;
+        const decayed = nestLevel > 1 ? decayOptionsForNesting(options, nestLevel) : options;
+        let mocked = mockSwitch(runType, decayed, stack);
+        if (runType.formatAnnotation && mocked !== undefined) {
+            const transform = lookupFormatTransform(runType.id);
+            if (transform)
+                mocked = transform(mocked);
+        }
+        return mocked;
+    }
+    finally {
+        stack.pop();
+    }
+}
+const FORMAT_TRANSFORM_FAMILY = 'fmt';
+function lookupFormatTransform(id) {
+    const entry = getRTUtils().findRTForType(FORMAT_TRANSFORM_FAMILY, id);
+    if (!entry || entry.isNoop || !entry.fn)
+        return undefined;
+    return entry.fn;
+}
+function countOccurrences(stack, target) {
+    let count = 0;
+    for (let i = 0; i < stack.length; i++) {
+        if (stack[i] === target)
+            count++;
+    }
+    return count;
+}
+function decayOptionsForNesting(options, nestLevel) {
+    const mOps = options.mock;
+    const maxDepth = mOps.maxMockRecursion;
+    const divisor = nestLevel;
+    const newProv = nestLevel >= maxDepth ? 0 : mOps.optionalProbability / divisor;
+    const newMaxLength = nestLevel >= maxDepth ? 0 : decayItemsLength(mOps.maxRandomItemsLength, nestLevel);
+    const next = {
+        ...mOps,
+        optionalProbability: newProv,
+        maxRandomItemsLength: newMaxLength,
+    };
+    if (mOps.optionalPropertyProbability) {
+        const entries = Object.entries(mOps.optionalPropertyProbability).map(([key, value]) => {
+            const decayed = nestLevel > maxDepth ? 0 : value / divisor;
+            return [key, decayed];
+        });
+        next.optionalPropertyProbability = Object.fromEntries(entries);
+    }
+    if (mOps.arrayLength !== undefined) {
+        next.arrayLength = nestLevel >= maxDepth ? 0 : decayItemsLength(mOps.arrayLength, nestLevel);
+    }
+    if (mOps.parentObj)
+        next.parentObj = {};
+    return { ...options, mock: next };
+}
+function decayItemsLength(length, nestLevel) {
+    return Math.round(length / nestLevel);
+}
+function isItemCollection(runType) {
+    const kind = runType.kind;
+    if (kind === RunTypeKind.array || kind === RunTypeKind.rest || kind === RunTypeKind.indexSignature)
+        return true;
+    if (kind === RunTypeKind.tupleMember || kind === RunTypeKind.parameter) {
+        return Array.isArray(runType.flags) && runType.flags.includes('rest');
+    }
+    const subKind = runType.subKind;
+    return kind === RunTypeKind.class && (subKind === RunTypeSubKind.map || subKind === RunTypeSubKind.set);
+}
+const COLLECTION_LEVEL_STEP = 2;
+function shrinkForNestedItems(options, stack) {
+    let nestLevel = 1;
+    for (let i = 0; i < stack.length; i++)
+        if (isItemCollection(stack[i]))
+            nestLevel += COLLECTION_LEVEL_STEP;
+    const mOps = options.mock;
+    return { ...options, mock: { ...mOps, maxRandomItemsLength: decayItemsLength(mOps.maxRandomItemsLength, nestLevel) } };
+}
+function withDataNode(options, next) {
+    if (options.dataNode === next)
+        return options;
+    return { ...options, dataNode: next };
+}
+function asDataNode(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value))
+        return value;
+    return undefined;
+}
+function childDataNodeByName(node, name) {
+    if (!node || name === undefined)
+        return undefined;
+    return asDataNode(node[name]);
+}
+function dataPool(node) {
+    if (node && Array.isArray(node.pool) && node.pool.length > 0)
+        return node.pool;
+    return undefined;
+}
+function dataArrayLength(node, random) {
+    const len = node?.rt$length;
+    if (typeof len === 'number')
+        return len;
+    if (Array.isArray(len) && len.length === 2)
+        return random.int(len[0], len[1]);
+    return undefined;
+}
+const STRUCTURAL_MOCK_ATTEMPTS = 32;
+function mockSwitch(runType, options, stack) {
+    const structural = isStructuralFormat(runType.formatAnnotation) ? runType.formatAnnotation : undefined;
+    if (!structural)
+        return mockKindSwitch(runType, options, stack);
+    for (let attempt = 0; attempt < STRUCTURAL_MOCK_ATTEMPTS; attempt++) {
+        const attemptOptions = attempt < STRUCTURAL_MOCK_ATTEMPTS / 2
+            ? options
+            : { ...options, mock: { ...options.mock, arrayLength: attempt % 3 } };
+        const candidate = mockKindSwitch(runType, attemptOptions, stack);
+        if (!structuralFormatAccepts(candidate, structural))
+            continue;
+        return candidate;
+    }
+    throw new Error(`Cannot mock a structural format: ${STRUCTURAL_MOCK_ATTEMPTS} candidates all failed the ${String(runType.formatAnnotation?.name)} constraints. ` +
+        'Provide a MockData pool for this type (enrich) with values that satisfy them.');
+}
+function mockKindSwitch(runType, options, stack) {
+    const mOps = options.mock;
+    const random = mOps.random ?? nativeMockRandom;
+    const kind = runType.kind;
+    const dataNode = options.dataNode;
+    const pool = dataPool(dataNode);
+    if (pool)
+        return random.pick(pool);
+    if (runType.formatAnnotation) {
+        const mockFn = getMockingFunction(kind);
+        if (mockFn) {
+            const mocked = mockFn(runType.formatAnnotation, random, mOps);
+            if (mocked !== undefined)
+                return mocked;
+        }
+    }
+    switch (kind) {
+        case RunTypeKind.never:
+            throw new Error('Cannot mock never type.');
+        case RunTypeKind.any:
+        case RunTypeKind.unknown:
+            return random.any(mOps.anyValuesList);
+        case RunTypeKind.string:
+            return random.string(mOps.stringLength ?? random.int(1, mOps.maxRandomStringLength), mOps.stringCharSet || stringCharSet);
+        case RunTypeKind.number: {
+            const min = typeof dataNode?.min === 'number' ? dataNode.min : mOps.minNumber;
+            const max = typeof dataNode?.max === 'number' ? dataNode.max : mOps.maxNumber;
+            return random.number(min, max);
+        }
+        case RunTypeKind.boolean:
+            return random.boolean();
+        case RunTypeKind.bigint:
+            return random.bigint(mOps.minNumber, mOps.maxNumber);
+        case RunTypeKind.null:
+            return null;
+        case RunTypeKind.undefined:
+            return undefined;
+        case RunTypeKind.void:
+            return undefined;
+        case RunTypeKind.regexp:
+            return mOps.nonDataTypes ? random.regExp(mOps.regexpList) : undefined;
+        case RunTypeKind.symbol:
+            return random.symbol(mOps.symbolName, mOps.symbolLength, mOps.symbolCharSet);
+        case RunTypeKind.literal:
+            return runType.literal;
+        case RunTypeKind.object:
+            return random.pick(mOps.objectList);
+        case RunTypeKind.enum: {
+            const values = runType.values;
+            if (!Array.isArray(values) || values.length === 0) {
+                throw new Error('Cannot mock enum without values.');
+            }
+            const index = mOps.enumIndex ?? random.int(0, values.length - 1);
+            return values[index];
+        }
+        case RunTypeKind.enumMember:
+            throw new Error('Mock enum member is not supported.');
+        case RunTypeKind.class: {
+            const subKind = runType.subKind;
+            if (subKind === RunTypeSubKind.date) {
+                const dateParams = runType.formatAnnotation?.name === 'nativeDate' ? runType.formatAnnotation.params : undefined;
+                if (dateParams &&
+                    (dateParams.min !== undefined ||
+                        dateParams.max !== undefined ||
+                        dateParams.gt !== undefined ||
+                        dateParams.lt !== undefined)) {
+                    return mockBoundedNativeDate({
+                        min: dateParams.min,
+                        max: dateParams.max,
+                        gt: dateParams.gt,
+                        lt: dateParams.lt,
+                    }, random);
+                }
+                const minDate = dataNode?.min instanceof Date ? dataNode.min : mOps.minDate;
+                const maxDate = dataNode?.max instanceof Date ? dataNode.max : mOps.maxDate;
+                return random.date(minDate, maxDate);
+            }
+            if (subKind === RunTypeSubKind.map)
+                return mockMap(runType, withDataNode(options, undefined), stack);
+            if (subKind === RunTypeSubKind.set)
+                return mockSet(runType, withDataNode(options, undefined), stack);
+            if (subKind === RunTypeSubKind.url)
+                return mockUrlObject(runType.formatAnnotation, random);
+            if (isTemporalSubKind(subKind)) {
+                const bounds = temporalBoundsFromAnnotation(runType.formatAnnotation);
+                return mockTemporal(subKind, bounds, random);
+            }
+            if (subKind === RunTypeSubKind.nonSerializable) {
+                if (mOps.nonDataTypes)
+                    return mockNonSerializableNative(runType);
+                throw new Error('Mock is disabled for non-serializable types.');
+            }
+            return buildObjectLiteral(runType, options, stack, mOps);
+        }
+        case RunTypeKind.array: {
+            const child = runType.child;
+            if (!child)
+                throw new Error('Cannot mock array: child runtype missing.');
+            const annotation = runType.formatAnnotation;
+            const arrayParams = annotation?.name === 'formattedArray' ? (annotation.params ?? {}) : undefined;
+            const length = clampToItemBounds(arrayParams, dataArrayLength(dataNode, random) ?? mOps.arrayLength ?? random.int(0, mOps.maxRandomItemsLength));
+            const childOpts = withDataNode(shrinkForNestedItems(options, stack), asDataNode(dataNode?.rt$items));
+            const containsChecks = (runType.contains ?? []);
+            if (containsChecks.length > 0) {
+                const matchedByEntry = [];
+                for (const entry of containsChecks) {
+                    if (entry.max >= 0 && entry.min > entry.max) {
+                        throw new Error('Cannot mock contains: minContains exceeds maxContains — the schema is provably empty.');
+                    }
+                    const entryItems = [];
+                    for (let n = 0; n < entry.min; n++) {
+                        const item = mockRunType(entry.child, childOpts, stack);
+                        if (!childSchemaMatches(item, child)) {
+                            throw new Error('Cannot mock contains: the contains child and the items type are contradictory. ' +
+                                'Provide a MockData pool for this type (enrich).');
+                        }
+                        entryItems.push(item);
+                    }
+                    matchedByEntry.push(entryItems);
+                }
+                const matched = matchedByEntry.flat();
+                const items = [...matched];
+                let fillerAttempts = 0;
+                while (items.length < Math.max(length, matched.length) && fillerAttempts < 64) {
+                    fillerAttempts++;
+                    const filler = mockRunType(child, childOpts, stack);
+                    if (containsChecks.every((entry) => !childSchemaMatches(filler, entry.child)))
+                        items.push(filler);
+                }
+                if (arrayParams?.uniqueItems === true) {
+                    const seen = new Set();
+                    const unique = items.filter((item) => {
+                        const key = canonicalJson(item);
+                        if (seen.has(key))
+                            return false;
+                        seen.add(key);
+                        return true;
+                    });
+                    containsChecks.forEach((entry, index) => {
+                        const surviving = matchedByEntry[index].filter((item) => unique.includes(item)).length;
+                        if (surviving < entry.min) {
+                            throw new Error('Cannot mock contains with uniqueItems: the contains child cannot produce enough distinct values. ' +
+                                'Provide a MockData pool for this type (enrich).');
+                        }
+                    });
+                    return unique;
+                }
+                return items;
+            }
+            if (length === 0)
+                return [];
+            if (arrayParams?.uniqueItems === true) {
+                const seen = new Set();
+                const items = [];
+                let attempts = 0;
+                while (items.length < length && attempts < length * 32) {
+                    attempts++;
+                    const item = mockRunType(child, childOpts, stack);
+                    const key = canonicalJson(item);
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    items.push(item);
+                }
+                const minItems = typeof arrayParams.minItems === 'number' ? arrayParams.minItems : 0;
+                if (items.length < minItems) {
+                    throw new Error(`Cannot mock a uniqueItems array: the element type cannot produce ${minItems} distinct values. ` +
+                        'Provide a MockData pool for this type (enrich) with enough distinct samples.');
+                }
+                return items;
+            }
+            const items = [];
+            for (let i = 0; i < length; i++)
+                items.push(mockRunType(child, childOpts, stack));
+            return items;
+        }
+        case RunTypeKind.tuple: {
+            const children = (runType.children ?? []);
+            const perElemOptions = mOps.tupleOptions ?? mOps.paramsOptions;
+            const itemsNode = asDataNode(dataNode?.rt$items);
+            const baseOpts = withDataNode(options, itemsNode);
+            const params = children.map((member, index) => {
+                const childOpts = perElemOptions?.[index] ? mergeChildOptions(baseOpts, perElemOptions[index]) : baseOpts;
+                return mockRunType(member, childOpts, stack);
+            });
+            const lastMember = children[children.length - 1];
+            const flattened = lastMember && isRestTupleMember(lastMember) && Array.isArray(params[params.length - 1])
+                ? [...params.slice(0, -1), ...params[params.length - 1]]
+                : params;
+            const annotation = runType.formatAnnotation;
+            let shaped = flattened;
+            if (annotation?.name === 'formattedArray') {
+                const arrayParams = (annotation.params ?? {});
+                if (arrayParams.uniqueItems === true) {
+                    const seen = new Set();
+                    shaped = shaped.filter((item) => {
+                        const key = canonicalJson(item);
+                        if (seen.has(key))
+                            return false;
+                        seen.add(key);
+                        return true;
+                    });
+                }
+                if (typeof arrayParams.maxItems === 'number' && shaped.length > arrayParams.maxItems) {
+                    shaped = shaped.slice(0, arrayParams.maxItems);
+                }
+            }
+            const tupleContains = (runType.contains ?? []);
+            for (const entry of tupleContains) {
+                const overCount = shaped.filter((item) => childSchemaMatches(item, entry.child)).length;
+                if (entry.min > 0 || (entry.max >= 0 && overCount > entry.max)) {
+                    throw new Error('Cannot mock contains over a tuple (prefixItems) base. Provide a MockData pool for this type (enrich).');
+                }
+            }
+            return shaped;
+        }
+        case RunTypeKind.tupleMember:
+        case RunTypeKind.parameter: {
+            const child = runType.child;
+            if (!child)
+                return undefined;
+            if (Array.isArray(runType.flags) && runType.flags.includes('rest') && child.kind !== RunTypeKind.rest) {
+                const length = random.int(0, mOps.maxRandomItemsLength);
+                const itemOpts = shrinkForNestedItems(options, stack);
+                const items = [];
+                for (let i = 0; i < length; i++)
+                    items.push(mockRunType(child, itemOpts, stack));
+                return items;
+            }
+            if (runType.optional && !isRestTupleMember(runType)) {
+                if (random.float() > mOps.optionalProbability)
+                    return undefined;
+            }
+            return mockRunType(child, options, stack);
+        }
+        case RunTypeKind.rest: {
+            const child = runType.child;
+            if (!child)
+                return [];
+            const length = random.int(0, mOps.maxRandomItemsLength);
+            const itemOpts = shrinkForNestedItems(options, stack);
+            const items = [];
+            for (let i = 0; i < length; i++)
+                items.push(mockRunType(child, itemOpts, stack));
+            return items;
+        }
+        case RunTypeKind.objectLiteral:
+        case RunTypeKind.intersection:
+            return buildObjectLiteral(runType, options, stack, mOps);
+        case RunTypeKind.property:
+        case RunTypeKind.propertySignature: {
+            const child = runType.child;
+            if (!child)
+                return undefined;
+            const name = runType.name;
+            const perPropProb = mOps.optionalPropertyProbability;
+            const probability = perPropProb && name !== undefined && perPropProb[name] !== undefined ? perPropProb[name] : mOps.optionalProbability;
+            if (probability < 0 || probability > 1) {
+                throw new Error('optionalProbability must be between 0 and 1');
+            }
+            if (runType.optional && random.float() > probability)
+                return undefined;
+            return mockRunType(child, options, stack);
+        }
+        case RunTypeKind.indexSignature: {
+            const child = runType.child;
+            const keyType = runType.index;
+            if (!child || !keyType)
+                return {};
+            const length = random.int(0, mOps.maxRandomItemsLength);
+            const valueOpts = shrinkForNestedItems(options, stack);
+            const parent = mOps.parentObj ?? {};
+            const keyKind = keyType.kind;
+            for (let i = 0; i < length; i++) {
+                let propName;
+                switch (keyKind) {
+                    case RunTypeKind.number:
+                        propName = i;
+                        break;
+                    case RunTypeKind.string:
+                        propName = `key${i}`;
+                        break;
+                    case RunTypeKind.symbol:
+                        propName = Symbol.for(`key${i}`);
+                        break;
+                    case RunTypeKind.templateLiteral: {
+                        const buildKey = () => buildTemplateLiteralString(keyType, mOps, random);
+                        let candidate = buildKey();
+                        for (let attempt = 0; attempt < 5 && Object.prototype.hasOwnProperty.call(parent, candidate); attempt++) {
+                            candidate = buildKey();
+                        }
+                        propName = candidate;
+                        break;
+                    }
+                    default:
+                        throw new Error(`Invalid index signature key kind: ${keyKind}`);
+                }
+                parent[propName] = mockRunType(child, valueOpts, stack);
+            }
+            return parent;
+        }
+        case RunTypeKind.union: {
+            const allChildren = (runType.children ?? []);
+            const survivors = allChildren.filter((member) => !member.notSupported);
+            const children = survivors.length > 0 ? survivors : allChildren;
+            if (children.length === 0)
+                throw new Error('Cannot mock union with no branches.');
+            if (mOps.unionIndex !== undefined && (mOps.unionIndex < 0 || mOps.unionIndex >= children.length)) {
+                throw new Error('unionIndex must be between 0 and the number of types in the union.');
+            }
+            const index = mOps.unionIndex ?? random.int(0, children.length - 1);
+            if (mOps.unionIndex !== undefined)
+                return mockRunType(children[index], options, stack);
+            let samplingFailure;
+            for (let offset = 0; offset < children.length; offset++) {
+                const arm = children[(index + offset) % children.length];
+                try {
+                    return mockRunType(arm, options, stack);
+                }
+                catch (error) {
+                    if (!isMockSamplingError(error))
+                        throw error;
+                    samplingFailure = error;
+                }
+            }
+            throw samplingFailure;
+        }
+        case RunTypeKind.templateLiteral:
+            return buildTemplateLiteralString(runType, mOps, random);
+        case RunTypeKind.promise: {
+            const child = runType.child;
+            const timeOut = mOps.promiseTimeOut || 0;
+            const resolveInner = () => (child ? mockRunType(child, options, stack) : undefined);
+            return new Promise((resolve, reject) => {
+                const finish = () => {
+                    if (mOps.promiseReject)
+                        reject(mOps.promiseReject);
+                    else
+                        resolve(resolveInner());
+                };
+                if (timeOut > 0)
+                    setTimeout(finish, timeOut);
+                else
+                    finish();
+            });
+        }
+        case RunTypeKind.function:
+        case RunTypeKind.callSignature:
+        case RunTypeKind.method:
+        case RunTypeKind.methodSignature:
+            return mOps.nonDataTypes ? mockNonDataFunction() : undefined;
+        default:
+            throw new Error(`Cannot mock runType: kind ${kind} is not yet supported by the mock walker.`);
+    }
+}
+function buildObjectLiteral(runType, options, stack, mOps) {
+    const children = (runType.children ?? []);
+    const parent = mOps.parentObj ?? {};
+    const dataNode = options.dataNode;
+    for (const member of children) {
+        const memberKind = member.kind;
+        if (memberKind === RunTypeKind.method || memberKind === RunTypeKind.methodSignature) {
+            const methodName = member.name;
+            if (mOps.nonDataTypes && methodName !== undefined)
+                parent[methodName] = mockNonDataFunction();
+            continue;
+        }
+        if (memberKind === RunTypeKind.indexSignature) {
+            const indexed = mockRunType(member, options, stack);
+            if (indexed && typeof indexed === 'object')
+                Object.assign(parent, indexed);
+            continue;
+        }
+        const name = member.name;
+        if (name === undefined)
+            continue;
+        const memberOpts = withDataNode(options, childDataNodeByName(dataNode, name));
+        const value = mockRunType(member, memberOpts, stack);
+        parent[name] = value;
+    }
+    const annotation = runType.formatAnnotation;
+    if (annotation?.name === 'formattedObject') {
+        const params = (annotation.params ?? {});
+        const declared = new Set();
+        let indexMember;
+        for (const member of children) {
+            if (member.kind === RunTypeKind.indexSignature)
+                indexMember = member;
+            const name = member.name;
+            if (name !== undefined)
+                declared.add(name);
+        }
+        const stringList = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+        const closed = Array.isArray(params.closed) ? params.closed : undefined;
+        const closedPatterns = stringList(params.closedPatterns).map((source) => new RegExp(source));
+        const trimDisallowedKeys = () => {
+            if (!closed)
+                return;
+            for (const key of Object.keys(parent)) {
+                if (declared.has(key) || closed.includes(key))
+                    continue;
+                if (closedPatterns.some((regexp) => regexp.test(key)))
+                    continue;
+                delete parent[key];
+            }
+        };
+        trimDisallowedKeys();
+        if (typeof params.maxProperties === 'number') {
+            for (const key of Object.keys(parent)) {
+                if (Object.keys(parent).length <= params.maxProperties)
+                    break;
+                if (!declared.has(key))
+                    delete parent[key];
+            }
+        }
+        if (typeof params.minProperties === 'number' && indexMember) {
+            let attempts = 0;
+            while (Object.keys(parent).length < params.minProperties && attempts < 32) {
+                attempts++;
+                const indexed = mockRunType(indexMember, options, stack);
+                if (indexed && typeof indexed === 'object')
+                    Object.assign(parent, indexed);
+                trimDisallowedKeys();
+            }
+            if (typeof params.maxProperties === 'number') {
+                for (const key of Object.keys(parent)) {
+                    if (Object.keys(parent).length <= params.maxProperties)
+                        break;
+                    if (!declared.has(key))
+                        delete parent[key];
+                }
+            }
+        }
+    }
+    const patternProps = (runType.patternProps ?? []);
+    if (patternProps.length > 0) {
+        const regexes = patternProps.map((entry) => new RegExp(entry.source));
+        const valueOpts = shrinkForNestedItems(options, stack);
+        for (const key of Object.keys(parent)) {
+            const matching = patternProps.filter((_entry, index) => regexes[index].test(key));
+            if (matching.length === 1)
+                parent[key] = mockRunType(matching[0].value, valueOpts, stack);
+            else if (matching.length > 1)
+                delete parent[key];
+        }
+        patternProps.forEach((entry, index) => {
+            if (!entry.key)
+                return;
+            const generated = mockRunType(entry.key, options, stack);
+            if (typeof generated === 'string' && regexes[index].test(generated) && !(generated in parent)) {
+                const others = patternProps.some((_other, otherIndex) => otherIndex !== index && regexes[otherIndex].test(generated));
+                if (!others)
+                    parent[generated] = mockRunType(entry.value, valueOpts, stack);
+            }
+        });
+    }
+    const propNames = runType.propNames;
+    if (propNames && propNames.length > 0) {
+        const declaredNames = new Set();
+        for (const member of children) {
+            const name = member.name;
+            if (name !== undefined)
+                declaredNames.add(name);
+        }
+        for (const key of Object.keys(parent)) {
+            if (declaredNames.has(key))
+                continue;
+            const entryValue = parent[key];
+            delete parent[key];
+            for (let attempt = 0; attempt < 8; attempt++) {
+                const renamed = mockRunType(propNames[0], options, stack);
+                if (typeof renamed !== 'string' || renamed in parent)
+                    continue;
+                if (!propNames.every((entry) => childSchemaMatches(renamed, entry)))
+                    continue;
+                parent[renamed] = entryValue;
+                break;
+            }
+        }
+    }
+    return parent;
+}
+function mockNonDataFunction() {
+    return () => undefined;
+}
+function mockNonSerializableNative(runType) {
+    const className = typeof runType.typeName === 'string' ? runType.typeName : typeof runType.name === 'string' ? runType.name : '';
+    switch (className) {
+        case 'ArrayBuffer':
+            return new ArrayBuffer(8);
+        case 'SharedArrayBuffer':
+            return typeof SharedArrayBuffer !== 'undefined' ? new SharedArrayBuffer(8) : new ArrayBuffer(8);
+        case 'DataView':
+            return new DataView(new ArrayBuffer(8));
+        case 'Int8Array':
+            return new Int8Array([1, 2, 3]);
+        case 'Int32Array':
+            return new Int32Array([1, 2, 3]);
+        case 'Float64Array':
+            return new Float64Array([1.5, 2.5]);
+        default:
+            return new Uint8Array([1, 2, 3]);
+    }
+}
+function isRestTupleMember(member) {
+    if (member.kind === RunTypeKind.rest)
+        return true;
+    if (Array.isArray(member.flags) && member.flags.includes('rest'))
+        return true;
+    const child = member.child;
+    return child !== undefined && child.kind === RunTypeKind.rest;
+}
+function mergeChildOptions(options, childMock) {
+    const parentMock = options.mock;
+    return { ...options, mock: { ...childMock, random: childMock.random ?? parentMock.random } };
+}
+function clampToItemBounds(params, length) {
+    if (!params)
+        return length;
+    if (typeof params.maxItems === 'number' && length > params.maxItems)
+        length = params.maxItems;
+    if (typeof params.minItems === 'number' && length < params.minItems)
+        length = params.minItems;
+    return length;
+}
+function structuralParamsOf(runType, name) {
+    const annotation = runType.formatAnnotation;
+    return annotation?.name === name ? (annotation.params ?? {}) : undefined;
+}
+const COLLECTION_DRAW_ATTEMPTS = 32;
+function drawCollectionEntries(spec) {
+    const entries = [];
+    const takenKeys = new Set();
+    const seenValues = new Set();
+    const keep = (entry) => {
+        const insertKey = spec.insertKeyOf(entry);
+        if (takenKeys.has(insertKey))
+            return false;
+        if (spec.unique) {
+            const valueKey = canonicalJson(entry);
+            if (seenValues.has(valueKey))
+                return false;
+            seenValues.add(valueKey);
+        }
+        takenKeys.add(insertKey);
+        entries.push(entry);
+        return true;
+    };
+    for (const check of spec.containsChecks) {
+        if (check.max >= 0 && check.min > check.max) {
+            throw new Error('Cannot mock contains: minContains exceeds maxContains — the schema is provably empty.');
+        }
+        for (let n = 0; n < check.min; n++) {
+            let placed = false;
+            for (let attempt = 0; attempt < COLLECTION_DRAW_ATTEMPTS && !placed; attempt++)
+                placed = keep(spec.drawMatch(check.child));
+            if (!placed)
+                throw new Error(spec.collapseError);
+        }
+    }
+    let attempts = 0;
+    while (entries.length < spec.length && attempts < Math.max(spec.length, 1) * COLLECTION_DRAW_ATTEMPTS) {
+        attempts++;
+        const filler = spec.drawFiller();
+        if (spec.containsChecks.some((check) => childSchemaMatches(filler, check.child)))
+            continue;
+        keep(filler);
+    }
+    return entries;
+}
+function mockMap(runType, options, stack) {
+    const mOps = options.mock;
+    const random = mOps.random ?? nativeMockRandom;
+    const args = (runType.arguments ?? []);
+    const keyType = args[0]?.child;
+    const valueType = args[1]?.child;
+    const result = new Map();
+    if (!keyType || !valueType)
+        return result;
+    const mapParams = structuralParamsOf(runType, 'formattedMap');
+    const entryOpts = shrinkForNestedItems(options, stack);
+    const entries = drawCollectionEntries({
+        length: clampToItemBounds(mapParams, mOps.arrayLength ?? random.int(0, mOps.maxRandomItemsLength)),
+        containsChecks: (runType.contains ?? []),
+        unique: mapParams?.uniqueItems === true,
+        drawMatch: (child) => {
+            const drawn = mockRunType(child, entryOpts, stack);
+            const pair = Array.isArray(drawn) && drawn.length === 2 ? [drawn[0], drawn[1]] : [undefined, undefined];
+            if (!childSchemaMatches(pair[0], keyType))
+                pair[0] = mockRunType(keyType, entryOpts, stack);
+            if (!childSchemaMatches(pair[1], valueType))
+                pair[1] = mockRunType(valueType, entryOpts, stack);
+            if (!childSchemaMatches(pair, child)) {
+                throw new Error('Cannot mock contains: the contains child and the Map entry type are contradictory (a Map entry is its ' +
+                    '[key, value] pair). Provide a MockData pool for this type (enrich).');
+            }
+            return pair;
+        },
+        drawFiller: () => [mockRunType(keyType, entryOpts, stack), mockRunType(valueType, entryOpts, stack)],
+        insertKeyOf: (pair) => pair[0],
+        collapseError: 'Cannot mock contains: a Map holds one entry per key, so the drawn matches collapsed and minContains cannot ' +
+            'be reached. Provide a MockData pool for this type (enrich).',
+    });
+    for (const [key, value] of entries)
+        result.set(key, value);
+    return result;
+}
+function mockSet(runType, options, stack) {
+    const mOps = options.mock;
+    const random = mOps.random ?? nativeMockRandom;
+    const args = (runType.arguments ?? []);
+    const elementType = args[0]?.child;
+    if (!elementType)
+        return new Set();
+    const setParams = structuralParamsOf(runType, 'formattedSet');
+    const memberOpts = shrinkForNestedItems(options, stack);
+    const members = drawCollectionEntries({
+        length: clampToItemBounds(setParams, mOps.arrayLength ?? random.int(0, mOps.maxRandomItemsLength)),
+        containsChecks: (runType.contains ?? []),
+        unique: setParams?.uniqueItems === true,
+        drawMatch: (child) => {
+            const item = mockRunType(child, memberOpts, stack);
+            if (!childSchemaMatches(item, elementType)) {
+                throw new Error('Cannot mock contains: the contains child and the Set member type are contradictory. ' +
+                    'Provide a MockData pool for this type (enrich).');
+            }
+            return item;
+        },
+        drawFiller: () => mockRunType(elementType, memberOpts, stack),
+        insertKeyOf: (member) => member,
+        collapseError: 'Cannot mock contains: a Set holds one copy of a member, so the drawn matches collapsed and minContains ' +
+            'cannot be reached. Provide a MockData pool for this type (enrich).',
+    });
+    return new Set(members);
+}
+function buildTemplateLiteralString(runType, mOps, random) {
+    const envelope = (runType.literal ?? null);
+    const layout = envelope?.templateLiteral;
+    if (!layout || !Array.isArray(layout.texts))
+        return '';
+    const texts = layout.texts;
+    const placeholders = Array.isArray(layout.placeholders) ? layout.placeholders : [];
+    let out = '';
+    for (let i = 0; i < texts.length; i++) {
+        out += texts[i];
+        if (i < placeholders.length) {
+            out += renderTemplateLiteralPlaceholder(placeholders[i], mOps, random);
+        }
+    }
+    return out;
+}
+function renderTemplateLiteralPlaceholder(span, mOps, random) {
+    if (!span)
+        return '';
+    const kind = typeof span.kind === 'number' ? span.kind : -1;
+    switch (kind) {
+        case RunTypeKind.literal:
+            return span.literal === undefined ? '' : String(span.literal);
+        case RunTypeKind.number:
+            return String(random.number(mOps.minNumber, mOps.maxNumber));
+        case RunTypeKind.bigint:
+            return String(random.bigint(mOps.minNumber, mOps.maxNumber));
+        case RunTypeKind.string:
+        case RunTypeKind.any:
+        case RunTypeKind.unknown:
+            return random.string(mOps.stringLength ?? random.int(1, mOps.maxRandomStringLength), mOps.stringCharSet || stringCharSet);
+        default:
+            return '';
+    }
+}
+//# sourceMappingURL=mockType.js.map