Function rewrite

scripts/codegen/typescript.ts:276–333

(value: unknown)

    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]) {
                rewritten.tsType = externalRef.definitionName;
                for (const key of Object.keys(rewritten)) {
                    if (key !== "tsType") {
                        delete rewritten[key];
                    }
                }
            } else if (rewritten.$ref.startsWith("#/$defs/")) {
                const definitionName = rewritten.$ref.slice("#/$defs/".length);
                rewritten.$ref = `#/definitions/${draftDefinitionAliases.get(definitionName) ?? definitionName}`;
            }
            // json-schema-to-typescript treats sibling keywords alongside $ref as a
            // new inline type instead of reusing the referenced definition.  Strip
            // siblings so that $ref-only objects compile to a single shared type.
            if ("$ref" in rewritten) {
                for (const key of Object.keys(rewritten)) {
                    if (key !== "$ref") delete rewritten[key];
                }
            }
        }

        return rewritten;
    };