Function normalizeSchemaForTypeScript

scripts/codegen/typescript.ts:254–336

(schema: JSONSchema7)

}

export function normalizeSchemaForTypeScript(schema: JSONSchema7): JSONSchema7 {
    const root = structuredClone(schema) as JSONSchema7 & {
        definitions?: Record<string, unknown>;
        $defs?: Record<string, unknown>;
    };
    const definitions = { ...(root.definitions ?? {}) };
    const draftDefinitionAliases = new Map<string, string>();

    for (const [key, value] of Object.entries(root.$defs ?? {})) {
        if (key in definitions) {
            // The definitions entry is authoritative (it went through the full pipeline).
            // Drop the $defs duplicate and rewrite any $ref pointing at it to use definitions.
            draftDefinitionAliases.set(key, key);
        } else {
            draftDefinitionAliases.set(key, key);
            definitions[key] = value;
        }
    }

    root.definitions = definitions;
    delete root.$defs;

    const rewrite = (value: unknown): unknown => {
        if (Array.isArray(value)) {
            return value.map(rewrite);
        }
        if (!value || typeof value !== "object") {
            return value;
        }

        const rewritten = Object.fromEntries(
            Object.entries(value as Record<string, unknown>).map(([key, child]) => [key, rewrite(child)])
        ) as Record<string, unknown>;

        // The TypeScript codegen doesn't distinguish opaque JSON from any
        // other unconstrained value, so drop the marker before feeding the
        // schema to json-schema-to-typescript. C# codegen reads the marker
        // from its own (un-normalized) view of the schema and emits
        // `JsonElement` instead.
        stripOpaqueJsonMarker(rewritten);

        const enumValueDescriptions = getEnumValueDescriptions(rewritten as JSONSchema7);
        if (enumValueDescriptions && Array.isArray(rewritten.enum) && rewritten.enum.every((entry) => typeof entry === "string")) {
            rewritten.tsType = (rewritten.enum as string[])
                .map((entry) => {
                    const comment = enumValueDescriptions[entry];
                    const literal = JSON.stringify(entry);
                    return comment ? `${tsDocCommentText(comment)}\n| ${literal}` : `| ${literal}`;
                })
                .join("\n");
            delete rewritten.type;
            delete rewritten.enum;
            delete rewritten["x-enumDescriptions"];
        }

        if (typeof rewritten.$ref === "string") {
            const externalRef = parseExternalSchemaRef(rewritten.$ref);
            if (externalRef && EXTERNAL_SCHEMA_TS_IMPORT[externalRef.schemaFile]) {