@gabrielbryk/json-schema-to-zod 2.10.1 → 2.11.1

package/dist/utils/extractInlineObject.js

@@ -0,0 +1,119 @@
+import { parseSchema } from "../parsers/parseSchema.js";
+/**
+ * Rule 1 from Zod v4: Put Object Types at Top-Level
+ *
+ * Extracts inline object schemas to top-level declarations when they have a title.
+ * This prevents embedding object schema declarations inside unions/intersections
+ * which can break recursive type inference.
+ *
+ * We extract any titled object schema, including those with:
+ * - $refs to other schemas (dependency ordering handles this)
+ * - Composition keywords (oneOf/anyOf/allOf for validation or extension)
+ *
+ * @returns The reference name if extracted, or null if not extractable
+ */
+export const extractInlineObject = (schema, refs, path) => {
+    // Skip if not an object
+    if (typeof schema !== "object" || schema === null) {
+        return null;
+    }
+    // Skip if it's a $ref - already handled by ref resolution
+    if ("$ref" in schema || "$dynamicRef" in schema) {
+        return null;
+    }
+    // Only extract objects with titles
+    const title = schema.title;
+    if (!title) {
+        return null;
+    }
+    const schemaObj = schema;
+    // Must be object-like: explicit type: object with properties
+    // Be conservative to avoid creating circular dependencies:
+    // - Skip if it has composition keywords (oneOf/anyOf/allOf) - these can create cycles
+    // - Skip if any property has a $ref - these can create ordering issues
+    if (schemaObj.type !== "object" || !schemaObj.properties) {
+        return null;
+    }
+    // Skip schemas with composition keywords as they can create circular type dependencies
+    if (schemaObj.anyOf || schemaObj.oneOf || schemaObj.allOf) {
+        return null;
+    }
+    // Skip if any property has a $ref - these can cause ordering issues
+    if (hasNestedRef(schemaObj)) {
+        return null;
+    }
+    // Generate a unique name from the title
+    const baseName = sanitizeIdentifier(title);
+    const refName = getUniqueName(baseName, refs.usedNames);
+    refs.usedNames?.add(refName);
+    // Check if already declared
+    if (refs.declarations?.has(refName)) {
+        return refName;
+    }
+    // Mark as in progress to handle potential recursion
+    refs.inProgress?.add(refName);
+    // Parse the schema to get its declaration
+    const parsed = parseSchema(schema, {
+        ...refs,
+        path,
+        currentSchemaName: refName,
+    });
+    refs.inProgress?.delete(refName);
+    // Add to declarations with type - parseSchema returns SchemaRepresentation directly
+    refs.declarations?.set(refName, parsed);
+    // Track dependencies - the extracted schema depends on current, and current depends on extracted
+    if (refs.currentSchemaName) {
+        const currentDeps = refs.dependencies?.get(refs.currentSchemaName) ?? new Set();
+        currentDeps.add(refName);
+        refs.dependencies?.set(refs.currentSchemaName, currentDeps);
+    }
+    return refName;
+};
+/**
+ * Check if a schema contains any $ref - these can cause ordering issues when extracted.
+ */
+const hasNestedRef = (schema) => {
+    const checkValue = (value) => {
+        if (typeof value !== "object" || value === null) {
+            return false;
+        }
+        if (Array.isArray(value)) {
+            return value.some(checkValue);
+        }
+        const obj = value;
+        if (typeof obj.$ref === "string" || typeof obj.$dynamicRef === "string") {
+            return true;
+        }
+        for (const key of Object.keys(obj)) {
+            if (checkValue(obj[key])) {
+                return true;
+            }
+        }
+        return false;
+    };
+    return checkValue(schema);
+};
+const sanitizeIdentifier = (value) => {
+    // Convert to PascalCase and remove invalid characters
+    const words = value
+        .replace(/[^a-zA-Z0-9_$\s]/g, " ")
+        .split(/\s+/)
+        .filter(Boolean);
+    const pascalCase = words
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join("");
+    const cleaned = pascalCase.replace(/^[^a-zA-Z_$]+/, "").replace(/[^a-zA-Z0-9_$]/g, "");
+    return cleaned || "InlineSchema";
+};
+const getUniqueName = (baseName, used) => {
+    if (!used || !used.has(baseName)) {
+        return baseName;
+    }
+    let counter = 2;
+    let candidate = `${baseName}${counter}`;
+    while (used.has(candidate)) {
+        counter += 1;
+        candidate = `${baseName}${counter}`;
+    }
+    return candidate;
+};

package/dist/utils/liftInlineObjects.js

@@ -0,0 +1,476 @@
+import { generateNameFromPath } from "./namingService.js";
+import { buildRefRegistry } from "./buildRefRegistry.js";
+import { resolveRef } from "./resolveRef.js";
+import { resolveUri } from "./resolveUri.js";
+/**
+ * Conservatively lift inline object-like schemas into top-level $defs.
+ * Skips when disabled or when candidates are ambiguous (contains $ref/dynamicRef).
+ */
+export const liftInlineObjects = (schema, options) => {
+    if (!options.enable || typeof schema !== "object" || schema === null) {
+        return { schema, defs: getDefs(schema), addedDefNames: [], pathToDefName: new Map() };
+    }
+    // Clone to avoid mutating user-provided schema
+    const root = JSON.parse(JSON.stringify(schema));
+    const defs = getDefs(root);
+    const existingNames = new Set(Object.keys(defs));
+    const addedDefNames = [];
+    const pathToDefName = new Map();
+    const hashToDef = new Map();
+    const { registry: refRegistry, rootBaseUri } = buildRefRegistry(root);
+    const cyclePaths = computeCyclicPaths(root, refRegistry, rootBaseUri);
+    const parentBase = options.parentName ?? (typeof root.title === "string" ? root.title : "Root");
+    const transformed = visit(root, {
+        path: [],
+        inDefs: false,
+        parentName: parentBase,
+        defs,
+        existingNames,
+        addedDefNames,
+        pathToDefName,
+        nameForPath: options.nameForPath,
+        dedup: options.dedup === true,
+        hashToDef,
+        refRegistry,
+        rootBaseUri,
+        allowInDefs: options.allowInDefs !== false,
+        rootSchema: root,
+        cyclePaths,
+    });
+    // Persist defs back on root
+    transformed.$defs = defs;
+    return { schema: transformed, defs, addedDefNames, pathToDefName };
+};
+const allowedHoistContexts = [
+    "properties",
+    "patternProperties",
+    "additionalProperties",
+    "items",
+    "additionalItems",
+    "dependentSchemas",
+    "contains",
+    "unevaluatedProperties",
+];
+const visit = (node, ctx) => {
+    if (Array.isArray(node)) {
+        return node.map((entry, index) => visit(entry, { ...ctx, path: [...ctx.path, index], context: ctx.context }));
+    }
+    if (typeof node !== "object" || node === null)
+        return node;
+    const obj = node;
+    const isRef = typeof obj.$ref === "string" || typeof obj.$dynamicRef === "string";
+    const isObjectLike = isObjectSchema(obj);
+    const canLift = isObjectLike &&
+        !isRef &&
+        ctx.path.length > 0 &&
+        ctx.context !== undefined &&
+        allowedHoistContexts.includes(ctx.context) &&
+        !subtreeHasCycle(obj, ctx, ctx.path) &&
+        // Allow refs inside the candidate; only block if the candidate itself is a ref/dynamicRef (handled above).
+        !isRecursiveRef(obj, ctx) &&
+        !isMetaOnly(obj);
+    if (canLift) {
+        const branchInfo = extractCallConst(ctx);
+        // Use schema's own title, fall back to parent schema title (e.g., from oneOf branch)
+        const schemaTitle = typeof obj.title === "string" ? obj.title : ctx.parentSchemaTitle;
+        const defName = generateNameFromPath({
+            parentName: ctx.parentName,
+            path: ctx.path,
+            existingNames: ctx.existingNames,
+            branchInfo,
+            schemaTitle,
+            nameForPath: ctx.nameForPath,
+        });
+        ctx.existingNames.add(defName);
+        ctx.addedDefNames.push(defName);
+        ctx.pathToDefName.set(ctx.path.join("/"), defName);
+        const candidateClone = deepTransform(obj, ctx, false);
+        const hash = ctx.dedup ? structuralHash(candidateClone) : null;
+        if (hash && ctx.hashToDef.has(hash)) {
+            const existingName = ctx.hashToDef.get(hash);
+            return { $ref: `#/$defs/${existingName}` };
+        }
+        if (hash) {
+            ctx.hashToDef.set(hash, defName);
+        }
+        ctx.defs[defName] = candidateClone;
+        return { $ref: `#/$defs/${defName}` };
+    }
+    return deepTransform(obj, ctx, false);
+};
+const deepTransform = (obj, ctx, forceInDefs) => {
+    const nextInDefs = ctx.inDefs || forceInDefs;
+    const clone = { ...obj };
+    // Extract current object's title to pass to children (e.g., oneOf branch title)
+    const currentTitle = typeof obj.title === "string" ? obj.title : undefined;
+    // $defs are handled via ctx.defs; skip hoisting inside them.
+    // properties - pass current schema's title as parentSchemaTitle for child properties
+    if (clone.properties && typeof clone.properties === "object") {
+        const newProps = {};
+        for (const [key, value] of Object.entries(clone.properties)) {
+            newProps[key] = visit(value, {
+                ...ctx,
+                path: [...ctx.path, key],
+                inDefs: nextInDefs,
+                context: "properties",
+                parentSchemaTitle: currentTitle,
+            });
+        }
+        clone.properties = newProps;
+    }
+    // $defs traversal (hoist inside defs if allowed)
+    if (clone.$defs && typeof clone.$defs === "object" && ctx.allowInDefs) {
+        const defsObj = clone.$defs;
+        for (const [key, value] of Object.entries(defsObj)) {
+            const visited = visit(value, { ...ctx, path: [...ctx.path, "$defs", key], inDefs: true, context: "root" });
+            ctx.defs[key] = visited;
+        }
+        clone.$defs = ctx.defs;
+    }
+    // patternProperties
+    if (clone.patternProperties && typeof clone.patternProperties === "object") {
+        const newPatterns = {};
+        for (const [key, value] of Object.entries(clone.patternProperties)) {
+            newPatterns[key] = visit(value, { ...ctx, path: [...ctx.path, key], inDefs: nextInDefs, context: "patternProperties" });
+        }
+        clone.patternProperties = newPatterns;
+    }
+    // additionalProperties
+    if (clone.additionalProperties && typeof clone.additionalProperties === "object") {
+        clone.additionalProperties = visit(clone.additionalProperties, {
+            ...ctx,
+            path: [...ctx.path, "additionalProperties"],
+            inDefs: nextInDefs,
+            context: "additionalProperties",
+        });
+    }
+    // items / additionalItems
+    if (clone.items) {
+        clone.items = visit(clone.items, { ...ctx, path: [...ctx.path, "items"], inDefs: nextInDefs, context: "items" });
+    }
+    if (clone.additionalItems) {
+        clone.additionalItems = visit(clone.additionalItems, {
+            ...ctx,
+            path: [...ctx.path, "additionalItems"],
+            inDefs: nextInDefs,
+            context: "additionalItems",
+        });
+    }
+    // compositions
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        if (Array.isArray(clone[keyword])) {
+            clone[keyword] = clone[keyword].map((entry, index) => visit(entry, { ...ctx, path: [...ctx.path, keyword, index], inDefs: nextInDefs, context: keyword }));
+        }
+    }
+    // conditionals
+    for (const keyword of ["if", "then", "else", "not", "contains", "unevaluatedProperties"]) {
+        if (clone[keyword]) {
+            clone[keyword] = visit(clone[keyword], { ...ctx, path: [...ctx.path, keyword], inDefs: nextInDefs, context: keyword });
+        }
+    }
+    // dependentSchemas
+    if (clone.dependentSchemas && typeof clone.dependentSchemas === "object") {
+        const newDeps = {};
+        for (const [key, value] of Object.entries(clone.dependentSchemas)) {
+            newDeps[key] = visit(value, {
+                ...ctx,
+                path: [...ctx.path, "dependentSchemas", key],
+                inDefs: nextInDefs,
+                context: "dependentSchemas",
+            });
+        }
+        clone.dependentSchemas = newDeps;
+    }
+    return clone;
+};
+const getDefs = (schema) => {
+    if (typeof schema === "object" && schema !== null && typeof schema.$defs === "object") {
+        return { ...schema.$defs };
+    }
+    return {};
+};
+const isObjectSchema = (schema) => {
+    if (schema.type === "object")
+        return true;
+    return Boolean(schema.properties || schema.patternProperties || schema.additionalProperties || schema.required || schema.unevaluatedProperties);
+};
+const isMetaOnly = (schema) => {
+    const keys = Object.keys(schema);
+    return keys.every((k) => ["title", "description", "$id", "$schema", "$anchor", "$dynamicAnchor", "examples"].includes(k));
+};
+const isRecursiveRef = (schema, ctx) => {
+    // Only guard when refs are present on the schema itself
+    const ref = typeof schema.$ref === "string" ? schema.$ref : typeof schema.$dynamicRef === "string" ? schema.$dynamicRef : null;
+    if (!ref)
+        return false;
+    const resolved = resolveRef(schema, ref, {
+        path: ctx.path,
+        seen: new Map(),
+        refRegistry: ctx.refRegistry,
+        rootBaseUri: ctx.rootBaseUri,
+        root: ctx.defs,
+    });
+    if (!resolved)
+        return false;
+    // If the resolved schema is this schema (self) or an ancestor along the path, treat as recursive
+    const pointerKey = resolved.pointerKey;
+    if (!pointerKey)
+        return false;
+    // Check if pointer resolves back to current path or its prefix
+    const currentPathStr = ctx.path.join("/");
+    const targetPathStr = resolved.path.join("/");
+    return targetPathStr === currentPathStr || currentPathStr.startsWith(targetPathStr);
+};
+const structuralHash = (schema) => {
+    const normalize = (value) => {
+        if (Array.isArray(value))
+            return value.map(normalize);
+        if (value && typeof value === "object") {
+            const obj = value;
+            const entries = Object.entries(obj)
+                .filter(([key]) => !["title", "description"].includes(key))
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([k, v]) => [k, normalize(v)]);
+            return Object.fromEntries(entries);
+        }
+        return value;
+    };
+    const normalized = normalize(schema);
+    return JSON.stringify(normalized);
+};
+const extractCallConst = (ctx) => {
+    // Inspect the parent object (path minus last segment) for a call const to use as branch info
+    if (!ctx.rootSchema || ctx.path.length === 0)
+        return undefined;
+    const parentPath = ctx.path.slice(0, -1);
+    const parentNode = getAtPath(ctx.rootSchema, parentPath);
+    if (parentNode && typeof parentNode === "object" && parentNode.properties) {
+        const props = parentNode.properties;
+        const callProp = props["call"];
+        if (callProp && typeof callProp === "object" && callProp.const) {
+            const v = callProp.const;
+            if (typeof v === "string")
+                return v;
+        }
+    }
+    return undefined;
+};
+const getAtPath = (root, path) => {
+    let current = root;
+    for (const segment of path) {
+        if (typeof current !== "object" || current === null)
+            return undefined;
+        if (typeof segment === "number") {
+            if (Array.isArray(current) && segment < current.length) {
+                current = current[segment];
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            current = current[segment];
+        }
+    }
+    return current;
+};
+const normalizePath = (path) => {
+    const skip = new Set(["properties", "patternProperties", "dependentSchemas"]);
+    const normalized = [];
+    for (const segment of path) {
+        if (typeof segment === "string" && skip.has(segment))
+            continue;
+        normalized.push(segment);
+    }
+    return normalized.join("/");
+};
+const computeCyclicPaths = (schema, refRegistry, rootBaseUri) => {
+    const edges = new Map();
+    const nodes = new Set();
+    const addEdge = (from, to) => {
+        if (!edges.has(from))
+            edges.set(from, new Set());
+        edges.get(from).add(to);
+    };
+    const walk = (node, path, baseUri, ownerPath) => {
+        if (typeof node !== "object" || node === null)
+            return;
+        const obj = node;
+        const pathStr = normalizePath(path);
+        const ownerStr = normalizePath(ownerPath);
+        nodes.add(pathStr);
+        nodes.add(ownerStr);
+        const nextBase = typeof obj.$id === "string" ? resolveUri(baseUri, obj.$id) : baseUri;
+        const ref = typeof obj.$ref === "string" ? obj.$ref : typeof obj.$dynamicRef === "string" ? obj.$dynamicRef : obj.$recursiveRef;
+        if (typeof ref === "string") {
+            const resolved = resolveRef(obj, ref, {
+                path,
+                refRegistry,
+                rootBaseUri,
+                root: schema,
+                currentBaseUri: nextBase,
+                seen: new Map(),
+            });
+            if (resolved) {
+                const targetPath = normalizePath(resolved.path);
+                addEdge(ownerStr, targetPath);
+                nodes.add(targetPath);
+            }
+        }
+        // $defs
+        if (obj.$defs && typeof obj.$defs === "object") {
+            for (const [defKey, defVal] of Object.entries(obj.$defs)) {
+                const childPath = [...path, "$defs", defKey];
+                addEdge(ownerStr, normalizePath(childPath));
+                walk(defVal, childPath, nextBase, childPath);
+            }
+        }
+        // properties
+        if (obj.properties && typeof obj.properties === "object") {
+            for (const [propKey, propVal] of Object.entries(obj.properties)) {
+                const childPath = [...path, propKey];
+                addEdge(ownerStr, normalizePath(childPath));
+                walk(propVal, childPath, nextBase, childPath);
+            }
+        }
+        // patternProperties
+        if (obj.patternProperties && typeof obj.patternProperties === "object") {
+            for (const [patKey, patVal] of Object.entries(obj.patternProperties)) {
+                const childPath = [...path, patKey];
+                addEdge(ownerStr, normalizePath(childPath));
+                walk(patVal, childPath, nextBase, childPath);
+            }
+        }
+        // dependentSchemas
+        if (obj.dependentSchemas && typeof obj.dependentSchemas === "object") {
+            for (const [depKey, depVal] of Object.entries(obj.dependentSchemas)) {
+                const childPath = [...path, depKey];
+                addEdge(ownerStr, normalizePath(childPath));
+                walk(depVal, childPath, nextBase, childPath);
+            }
+        }
+        // additionalProperties / items / contains / unevaluatedProperties / not / if / then / else
+        const singleKeys = [
+            "additionalProperties",
+            "items",
+            "additionalItems",
+            "contains",
+            "unevaluatedProperties",
+            "not",
+            "if",
+            "then",
+            "else",
+        ];
+        for (const key of singleKeys) {
+            const value = obj[key];
+            if (value && typeof value === "object") {
+                const childPath = [...path, key];
+                addEdge(ownerStr, normalizePath(childPath));
+                walk(value, childPath, nextBase, childPath);
+            }
+        }
+        // compositions
+        for (const key of ["allOf", "anyOf", "oneOf"]) {
+            const value = obj[key];
+            if (Array.isArray(value)) {
+                value.forEach((v, i) => {
+                    const childPath = [...path, key, i];
+                    if (typeof v === "object" && v !== null)
+                        addEdge(ownerStr, normalizePath(childPath));
+                    walk(v, childPath, nextBase, childPath);
+                });
+            }
+        }
+    };
+    walk(schema, [], rootBaseUri, []);
+    const cycles = new Set();
+    const index = new Map();
+    const lowLink = new Map();
+    const onStack = new Set();
+    const stack = [];
+    let currentIndex = 0;
+    const strongConnect = (v) => {
+        index.set(v, currentIndex);
+        lowLink.set(v, currentIndex);
+        currentIndex += 1;
+        stack.push(v);
+        onStack.add(v);
+        const targets = edges.get(v) ?? new Set();
+        for (const w of targets) {
+            if (!index.has(w)) {
+                strongConnect(w);
+                lowLink.set(v, Math.min(lowLink.get(v), lowLink.get(w)));
+            }
+            else if (onStack.has(w)) {
+                lowLink.set(v, Math.min(lowLink.get(v), index.get(w)));
+            }
+        }
+        if (lowLink.get(v) === index.get(v)) {
+            const scc = [];
+            let w;
+            do {
+                w = stack.pop();
+                if (w === undefined)
+                    break;
+                onStack.delete(w);
+                scc.push(w);
+            } while (w !== v);
+            const hasSelfLoop = (edges.get(v) ?? new Set()).has(v);
+            if (scc.length > 1 || hasSelfLoop) {
+                scc.forEach((n) => cycles.add(n));
+            }
+        }
+    };
+    nodes.forEach((n) => {
+        if (!index.has(n))
+            strongConnect(n);
+    });
+    return cycles;
+};
+const subtreeHasCycle = (node, ctx, pathPrefix) => {
+    // Keywords that create structural recursion (require z.lazy()) vs property references
+    // When a schema is reached through these keywords and participates in a cycle,
+    // it will generate z.lazy() which causes type annotation issues when lifted
+    const structuralKeywords = new Set([
+        "additionalProperties", "items", "additionalItems", "contains",
+        "unevaluatedProperties", "not", "if", "then", "else",
+        "allOf", "anyOf", "oneOf"
+    ]);
+    const rootPathStr = normalizePath(pathPrefix);
+    const walk = (value, path, parentContext) => {
+        if (typeof value !== "object" || value === null)
+            return false;
+        const obj = value;
+        // Check if this node has a $ref that points back to the root or an ancestor
+        // This would create self-referential recursion which blocks lifting
+        const ref = typeof obj.$ref === "string" ? obj.$ref : typeof obj.$dynamicRef === "string" ? obj.$dynamicRef : null;
+        if (ref) {
+            // Resolve the ref to see if it points to root or an ancestor
+            if (ref.startsWith("#/")) {
+                const refPath = ref.slice(2).split("/");
+                const refPathStr = normalizePath(refPath);
+                // If the ref points to the root path or a prefix of it, this is self-referential
+                if (refPathStr === rootPathStr || rootPathStr.startsWith(refPathStr + "/")) {
+                    return true;
+                }
+            }
+            // Otherwise, $ref to external definitions don't create inline recursion
+            return false;
+        }
+        const pathStr = normalizePath(path);
+        // Only check cycle membership if we got here through a structural keyword
+        // (not through "properties" which just creates named refs, not z.lazy())
+        // For the root node, use the context from the visitor (ctx.context)
+        const effectiveContext = parentContext ?? ctx.context;
+        if (effectiveContext !== undefined && structuralKeywords.has(effectiveContext)) {
+            if (ctx.cyclePaths.has(pathStr))
+                return true;
+        }
+        for (const [key, child] of Object.entries(obj)) {
+            if (walk(child, [...path, key], key))
+                return true;
+        }
+        return false;
+    };
+    return walk(node, pathPrefix, null);
+};

package/dist/utils/namingService.js

@@ -0,0 +1,58 @@
+/**
+ * Generate a stable PascalCase name for a lifted inline schema.
+ * - Uses parentName as a base (default: Root).
+ * - Adds path segments (properties/indices) to disambiguate.
+ * - Applies suffixes to avoid collisions.
+ * - Allows an optional hook to override naming.
+ */
+export const generateNameFromPath = (options) => {
+    const { parentName, path, existingNames, branchInfo, nameForPath, schemaTitle } = options;
+    if (nameForPath) {
+        const custom = nameForPath(path, { parentName, existingNames, branchInfo });
+        if (custom) {
+            return ensureUnique(custom, existingNames);
+        }
+    }
+    const baseParent = parentName ? toPascalCase(parentName) : "Root";
+    const branchSegment = branchInfo ? toPascalCase(String(branchInfo)) : undefined;
+    const segments = path.map((segment) => {
+        if (typeof segment === "number") {
+            return `Option${segment}`;
+        }
+        const pascal = toPascalCase(segment);
+        return pascal || "Anon";
+    });
+    const preferredTitle = schemaTitle ? toPascalCase(schemaTitle) : undefined;
+    if (preferredTitle && !existingNames.has(preferredTitle)) {
+        return preferredTitle;
+    }
+    const prefix = branchSegment ? [baseParent, branchSegment] : [baseParent];
+    let fallbackBase = [...prefix, ...segments].join("") || baseParent;
+    for (let k = 1; k <= segments.length; k += 1) {
+        const candidate = [...prefix, ...segments.slice(-k)].join("");
+        if (candidate && !existingNames.has(candidate)) {
+            return candidate;
+        }
+    }
+    // If we still collide, prefer the title with suffix if available, otherwise suffix the full path.
+    if (preferredTitle) {
+        fallbackBase = preferredTitle;
+    }
+    return ensureUnique(fallbackBase, existingNames);
+};
+const ensureUnique = (candidate, existingNames) => {
+    if (!existingNames.has(candidate))
+        return candidate;
+    let i = 2;
+    while (existingNames.has(`${candidate}${i}`)) {
+        i += 1;
+    }
+    return `${candidate}${i}`;
+};
+const toPascalCase = (value) => {
+    return value
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+};