docusaurus-theme-openapi-docs 0.0.0-1314 → 0.0.0-1332

package/lib/theme/Schema/index.js

@@ -77,171 +77,14 @@ const DiscriminatorTabs_1 = __importDefault(
   require("@theme/DiscriminatorTabs")
 );
 const Markdown_1 = __importDefault(require("@theme/Markdown"));
+const normalize_1 = require("@theme/Schema/normalize");
 const SchemaExpansion_1 = require("@theme/SchemaExpansion");
 const SchemaItem_1 = __importDefault(require("@theme/SchemaItem"));
 const SchemaTabs_1 = __importDefault(require("@theme/SchemaTabs"));
 const TabItem_1 = __importDefault(require("@theme/TabItem"));
-// eslint-disable-next-line import/no-extraneous-dependencies
-const allof_merge_1 = require("allof-merge");
 const clsx_1 = __importDefault(require("clsx"));
 const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
 const schema_1 = require("../../markdown/schema");
-// eslint-disable-next-line import/no-extraneous-dependencies
-// const jsonSchemaMergeAllOf = require("json-schema-merge-allof");
-/**
- * Strip `additionalProperties: false` from sibling allOf members so the
- * strict-AND semantics of `allof-merge` don't collapse the result to an
- * unsatisfiable empty schema.
- *
- * Per JSON Schema, two allOf members that each set `additionalProperties: false`
- * with disjoint `properties` sets define an unsatisfiable schema (no value can
- * satisfy both — each member rejects the other's properties). `allof-merge` is
- * technically correct to drop all properties in that case, but it leaves the
- * rendered schema blank.
- *
- * NSwag and Swashbuckle emit this pattern by default whenever a model uses
- * inheritance/composition, so it's the dominant style for .NET-generated specs.
- * Redoc, Swagger UI, and Stoplight all union the properties and ignore the
- * conflicting flag — the approach this helper emulates by stripping the flag
- * before delegating to `allof-merge`. The flag is render-irrelevant anyway:
- * `additionalProperties: false` is treated identically to `undefined` by the
- * AdditionalProperties component below (line ~641).
- *
- * Strips from every allOf member whenever the parent has ≥2 members. The
- * collapse triggers symmetrically (both siblings strict) or asymmetrically
- * (one strict member rejects another's properties as "additional"), so the
- * presence of multiple members is the right gate. Single-member allOf is left
- * alone — it can't conflict with anything.
- *
- * See https://github.com/PaloAltoNetworks/docusaurus-openapi-docs/issues/1119
- * Mirrored in plugin: docusaurus-plugin-openapi-docs/src/markdown/createSchema.ts
- */
-const stripConflictingAdditionalProps = (node) => {
-  if (Array.isArray(node)) return node.map(stripConflictingAdditionalProps);
-  if (!node || typeof node !== "object") return node;
-  let working = node;
-  if (Array.isArray(node.allOf) && node.allOf.length > 1) {
-    const hasStrictMember = node.allOf.some(
-      (m) => m && m.additionalProperties === false
-    );
-    if (hasStrictMember) {
-      working = {
-        ...node,
-        allOf: node.allOf.map((m) => {
-          if (m && m.additionalProperties === false) {
-            const { additionalProperties: _drop, ...rest } = m;
-            return rest;
-          }
-          return m;
-        }),
-      };
-    }
-  }
-  const result = {};
-  for (const [k, v] of Object.entries(working)) {
-    result[k] = stripConflictingAdditionalProps(v);
-  }
-  return result;
-};
-const mergeAllOf = (allOf) => {
-  const onMergeError = (msg) => {
-    console.warn(msg);
-  };
-  const mergedSchemas = (0, allof_merge_1.merge)(
-    stripConflictingAdditionalProps(allOf),
-    {
-      onMergeError,
-    }
-  );
-  return mergedSchemas ?? {};
-};
-/**
- * Fold sibling fields into each `oneOf`/`anyOf` branch via allOf-merge, so each
- * branch is self-contained. Mirrors Redoc's `SchemaModel.initOneOf` behavior.
- * Without this, when an `allOf` override redefines a nested property with
- * `oneOf`, the merged schema ends up with both `properties` and `oneOf` as
- * siblings — and the renderer prints the shared properties twice.
- *
- * See https://github.com/PaloAltoNetworks/docusaurus-openapi-docs/issues/1218
- */
-const foldSiblingsIntoBranches = (schema) => {
-  const branchKey = schema?.oneOf
-    ? "oneOf"
-    : schema?.anyOf
-      ? "anyOf"
-      : undefined;
-  if (!branchKey) return schema;
-  const branches = schema[branchKey];
-  if (!Array.isArray(branches) || branches.length === 0) return schema;
-  const siblings = { ...schema };
-  delete siblings[branchKey];
-  if (Object.keys(siblings).length === 0) return schema;
-  const folded = branches.map((branch) =>
-    mergeAllOf({ allOf: [siblings, branch] })
-  );
-  return { [branchKey]: folded };
-};
-/**
- * Recursively searches for a property in a schema, including nested
- * oneOf, anyOf, and allOf structures. This is needed for discriminators
- * where the property definition may be in a nested schema.
- */
-const findProperty = (schema, propertyName) => {
-  // Check direct properties first
-  if (schema.properties?.[propertyName]) {
-    return schema.properties[propertyName];
-  }
-  // Search in oneOf schemas
-  if (schema.oneOf) {
-    for (const subschema of schema.oneOf) {
-      const found = findProperty(subschema, propertyName);
-      if (found) return found;
-    }
-  }
-  // Search in anyOf schemas
-  if (schema.anyOf) {
-    for (const subschema of schema.anyOf) {
-      const found = findProperty(subschema, propertyName);
-      if (found) return found;
-    }
-  }
-  // Search in allOf schemas
-  if (schema.allOf) {
-    for (const subschema of schema.allOf) {
-      const found = findProperty(subschema, propertyName);
-      if (found) return found;
-    }
-  }
-  return undefined;
-};
-/**
- * Recursively searches for a discriminator in a schema, including nested
- * oneOf, anyOf, and allOf structures.
- */
-const findDiscriminator = (schema) => {
-  if (schema.discriminator) {
-    return schema.discriminator;
-  }
-  if (schema.oneOf) {
-    for (const subschema of schema.oneOf) {
-      const found = findDiscriminator(subschema);
-      if (found) return found;
-    }
-  }
-  if (schema.anyOf) {
-    for (const subschema of schema.anyOf) {
-      const found = findDiscriminator(subschema);
-      if (found) return found;
-    }
-  }
-  if (schema.allOf) {
-    for (const subschema of schema.allOf) {
-      const found = findDiscriminator(subschema);
-      if (found) return found;
-    }
-  }
-  return undefined;
-};
 // Renders string as markdown, useful for descriptions and qualifiers
 const MarkdownWrapper = ({ text }) => {
   return react_1.default.createElement(
@@ -392,6 +235,14 @@ const AnyOneOf = ({ schema, schemaType, schemaPath }) => {
           react_1.default.createElement(
             TabItem_1.default,
             { key: index, label: label, value: `${uniqueId}-${index}-item` },
+            anyOneSchema.description &&
+              react_1.default.createElement(
+                "div",
+                { style: { marginLeft: "1rem" } },
+                react_1.default.createElement(MarkdownWrapper, {
+                  text: anyOneSchema.description,
+                })
+              ),
             (isPrimitive(anyOneSchema) || anyOneSchema.const) &&
               react_1.default.createElement(SchemaItem_1.default, {
                 collapsible: false,
@@ -570,6 +421,14 @@ const PropertyDiscriminator = ({
             react_1.default.createElement(
               TabItem_1.default,
               { key: index, label: key, value: `${index}-item-discriminator` },
+              discriminator.mapping[key]?.description &&
+                react_1.default.createElement(
+                  "div",
+                  { style: { marginLeft: "1rem" } },
+                  react_1.default.createElement(MarkdownWrapper, {
+                    text: discriminator.mapping[key].description,
+                  })
+                ),
               react_1.default.createElement(SchemaNode, {
                 schema: discriminator.mapping[key],
                 schemaType: schemaType,
@@ -599,11 +458,13 @@ const PropertyDiscriminator = ({
 const DiscriminatorNode = ({ discriminator, schema, schemaType }) => {
   let discriminatedSchemas = {};
   let inferredMapping = {};
-  // Search for the discriminator property in the schema, including nested structures
+  // Search for the discriminator property in the schema, including nested
+  // structures. Cached recursive lookup replaces the O(subtree) findProperty
+  // walk that caused #1525's O(N^2) render cost.
   const discriminatorProperty =
-    findProperty(schema, discriminator.propertyName) ?? {};
+    (0, normalize_1.findPropertyDeep)(schema, discriminator.propertyName) ?? {};
   if (schema.allOf) {
-    const mergedSchemas = mergeAllOf(schema);
+    const mergedSchemas = (0, normalize_1.mergeAllOf)(schema);
     if (mergedSchemas.oneOf || mergedSchemas.anyOf) {
       discriminatedSchemas = mergedSchemas.oneOf || mergedSchemas.anyOf;
     }
@@ -623,7 +484,7 @@ const DiscriminatorNode = ({ discriminator, schema, schemaType }) => {
     // Handle discriminated schema with allOf
     let mergedSubSchema = {};
     if (subSchema.allOf) {
-      mergedSubSchema = mergeAllOf(subSchema);
+      mergedSubSchema = (0, normalize_1.mergeAllOf)(subSchema);
     }
     const subProperties = subSchema.properties || mergedSubSchema.properties;
     // Add a safeguard check to avoid referencing subProperties if it's undefined
@@ -664,6 +525,17 @@ const DiscriminatorNode = ({ discriminator, schema, schemaType }) => {
 const AdditionalProperties = ({ schema, schemaType }) => {
   const additionalProperties = schema.additionalProperties;
   if (!additionalProperties) return null;
+  if ((0, normalize_1.isCircularMarker)(additionalProperties)) {
+    return react_1.default.createElement(SchemaItem_1.default, {
+      name: "property name*",
+      required: false,
+      schemaName: additionalProperties,
+      schema: additionalProperties,
+      collapsible: false,
+      discriminator: false,
+      children: null,
+    });
+  }
   // Handle free-form objects
   if (
     additionalProperties === true ||
@@ -774,10 +646,26 @@ const SchemaNodeDetails = ({
   );
 };
 const Items = ({ schema, schemaType, schemaPath }) => {
+  if ((0, normalize_1.isCircularMarker)(schema.items)) {
+    return react_1.default.createElement(
+      "div",
+      { style: { marginLeft: ".5rem" } },
+      react_1.default.createElement(ArrayBrackets_1.OpeningArrayBracket, null),
+      react_1.default.createElement(SchemaItem_1.default, {
+        collapsible: false,
+        name: "",
+        schemaName: schema.items,
+        schema: schema.items,
+        discriminator: false,
+        children: null,
+      }),
+      react_1.default.createElement(ArrayBrackets_1.ClosingArrayBracket, null)
+    );
+  }
   // Process schema.items to handle allOf merging
   let itemsSchema = schema.items;
   if (schema.items?.allOf) {
-    itemsSchema = mergeAllOf(schema.items);
+    itemsSchema = (0, normalize_1.mergeAllOf)(schema.items);
   }
   // Handle complex schemas with multiple schema types
   const hasOneOfAnyOf = itemsSchema?.oneOf || itemsSchema?.anyOf;
@@ -790,7 +678,7 @@ const Items = ({ schema, schemaType, schemaPath }) => {
     // property rendering. See issue #1218.
     const renderSchema =
       hasOneOfAnyOf && hasProperties
-        ? foldSiblingsIntoBranches(itemsSchema)
+        ? (0, normalize_1.foldSiblingsIntoBranches)(itemsSchema)
         : itemsSchema;
     const renderHasProperties =
       hasOneOfAnyOf && hasProperties ? false : hasProperties;
@@ -874,6 +762,17 @@ const SchemaEdge = ({
   ) {
     return null;
   }
+  if ((0, normalize_1.isCircularMarker)(schema)) {
+    return react_1.default.createElement(SchemaItem_1.default, {
+      collapsible: false,
+      name: name,
+      required: Array.isArray(required) ? required.includes(name) : required,
+      schemaName: schema,
+      schema: schema,
+      discriminator: false,
+      children: null,
+    });
+  }
   const schemaName = (0, schema_1.getSchemaName)(schema);
   if (discriminator && discriminator.propertyName === name) {
     return react_1.default.createElement(PropertyDiscriminator, {
@@ -941,6 +840,17 @@ const SchemaEdge = ({
       schemaPath: schemaPath,
     });
   }
+  if ((0, normalize_1.isCircularMarker)(schema.items)) {
+    return react_1.default.createElement(SchemaNodeDetails, {
+      name: name,
+      schemaName: schemaName,
+      required: required,
+      nullable: schema.nullable,
+      schema: schema,
+      schemaType: schemaType,
+      schemaPath: schemaPath,
+    });
+  }
   if (schema.allOf) {
     // handle circular properties
     if (
@@ -959,7 +869,7 @@ const SchemaEdge = ({
         children: null,
       });
     }
-    const mergedSchemas = mergeAllOf(schema);
+    const mergedSchemas = (0, normalize_1.mergeAllOf)(schema);
     if (
       (schemaType === "request" && mergedSchemas.readOnly) ||
       (schemaType === "response" && mergedSchemas.writeOnly)
@@ -1026,7 +936,9 @@ function renderChildren(schema, schemaType, schemaPath) {
   const hasOneOfAnyOf = !!(schema.oneOf || schema.anyOf);
   const hasProperties = !!schema.properties;
   const folded =
-    hasOneOfAnyOf && hasProperties ? foldSiblingsIntoBranches(schema) : schema;
+    hasOneOfAnyOf && hasProperties
+      ? (0, normalize_1.foldSiblingsIntoBranches)(schema)
+      : schema;
   const renderProperties =
     hasOneOfAnyOf && hasProperties ? false : hasProperties;
   return react_1.default.createElement(
@@ -1063,7 +975,11 @@ function renderChildren(schema, schemaType, schemaPath) {
       })
   );
 }
-const SchemaNode = ({ schema, schemaType, schemaPath }) => {
+const SchemaNode = ({ schema: rawSchema, schemaType, schemaPath }) => {
+  const schema = (0, react_1.useMemo)(
+    () => (0, normalize_1.normalizeSchema)(rawSchema),
+    [rawSchema]
+  );
   if (
     (schemaType === "request" && schema.readOnly) ||
     (schemaType === "response" && schema.writeOnly)
@@ -1071,12 +987,13 @@ const SchemaNode = ({ schema, schemaType, schemaPath }) => {
     return null;
   }
   // Resolve discriminator recursively so nested oneOf/anyOf/allOf compositions
-  // can still render discriminator tabs.
+  // can still render discriminator tabs. Cached via getDiscriminator so per-
+  // render cost is O(1) amortized (see #1525).
   let workingSchema = schema;
   const resolvedDiscriminator =
-    schema.discriminator ?? findDiscriminator(schema);
+    schema.discriminator ?? (0, normalize_1.getDiscriminator)(schema);
   if (schema.allOf && !schema.discriminator && resolvedDiscriminator) {
-    workingSchema = mergeAllOf(schema);
+    workingSchema = (0, normalize_1.mergeAllOf)(schema);
   }
   if (!workingSchema.discriminator && resolvedDiscriminator) {
     workingSchema.discriminator = resolvedDiscriminator;
@@ -1096,7 +1013,7 @@ const SchemaNode = ({ schema, schemaType, schemaPath }) => {
     const hasMultipleChoices = oneOfItems.length > 1;
     if (hasMultipleChoices) {
       // Render each oneOf/anyOf constraint first, then shared properties
-      const mergedSchemas = mergeAllOf(schema);
+      const mergedSchemas = (0, normalize_1.mergeAllOf)(schema);
       if (
         (schemaType === "request" && mergedSchemas.readOnly) ||
         (schemaType === "response" && mergedSchemas.writeOnly)
@@ -1138,7 +1055,7 @@ const SchemaNode = ({ schema, schemaType, schemaPath }) => {
       );
     }
     // For other allOf cases, use standard merge behavior
-    const mergedSchemas = mergeAllOf(schema);
+    const mergedSchemas = (0, normalize_1.mergeAllOf)(schema);
     if (
       (schemaType === "request" && mergedSchemas.readOnly) ||
       (schemaType === "response" && mergedSchemas.writeOnly)
@@ -1151,7 +1068,7 @@ const SchemaNode = ({ schema, schemaType, schemaPath }) => {
     const hasProperties = !!mergedSchemas.properties;
     const folded =
       hasOneOfAnyOf && hasProperties
-        ? foldSiblingsIntoBranches(mergedSchemas)
+        ? (0, normalize_1.foldSiblingsIntoBranches)(mergedSchemas)
         : mergedSchemas;
     const renderProperties =
       hasOneOfAnyOf && hasProperties ? false : hasProperties;

package/lib/theme/Schema/normalize.d.ts

@@ -0,0 +1,41 @@
+export declare function isCircularMarker(value: unknown): value is string;
+export declare function mergeAllOf(schema: any): any;
+/**
+ * Fold sibling fields into each oneOf/anyOf branch via allOf-merge so each
+ * branch is self-contained. See #1218.
+ *
+ * Skipped when a discriminator is present: DiscriminatorNode already renders
+ * sibling properties at the top level, and folding would duplicate the
+ * discriminator metadata into each branch (causing nested DiscriminatorNode
+ * renders inside tabs — see #1525 follow-up).
+ *
+ * Called by normalizeSchema after allOf resolution. Uses mergeAllOf internally
+ * to compose `{ allOf: [siblings, branch] }` per branch — the WeakMap caches
+ * in stripConflictingAdditionalProps prevent redundant work on shared subtrees.
+ */
+export declare function foldSiblingsIntoBranches(schema: any): any;
+export declare function getDiscriminator(schema: any): any | undefined;
+/**
+ * Cached recursive property lookup. Searches schema.properties first, then
+ * into oneOf/anyOf/allOf branches. Returns O(1) on repeated calls with the
+ * same (schema, propertyName) pair — replaces the O(subtree) findProperty
+ * walk that caused #1525's O(N^2) render cost.
+ */
+export declare function findPropertyDeep(schema: any, propertyName: string): any | undefined;
+/**
+ * Identity-stable schema pass-through. Returns the input as-is so SchemaNode
+ * useMemo dependencies stay stable across renders.
+ *
+ * Earlier iterations of this function eagerly merged allOf and folded
+ * siblings into oneOf/anyOf branches, but those operations need to stay
+ * conditional inside SchemaNode and DiscriminatorNode — eager versions
+ * caused cartesian product expansion (allOf with multiple oneOfs) and
+ * double-folding regressions. The render-time helpers below
+ * (mergeAllOf, foldSiblingsIntoBranches) are still cached via the WeakMap
+ * inside stripConflictingAdditionalProps, so per-render cost stays bounded.
+ *
+ * The perf win for #1525 comes from getDiscriminator's WeakMap cache
+ * replacing the O(subtree) findDiscriminator walk, not from eager
+ * normalization here.
+ */
+export declare function normalizeSchema(schema: any): any;

package/lib/theme/Schema/normalize.js

@@ -0,0 +1,210 @@
+"use strict";
+/* ============================================================================
+ * Copyright (c) Palo Alto Networks
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ * ========================================================================== */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCircularMarker = isCircularMarker;
+exports.mergeAllOf = mergeAllOf;
+exports.foldSiblingsIntoBranches = foldSiblingsIntoBranches;
+exports.getDiscriminator = getDiscriminator;
+exports.findPropertyDeep = findPropertyDeep;
+exports.normalizeSchema = normalizeSchema;
+// eslint-disable-next-line import/no-extraneous-dependencies
+const allof_merge_1 = require("allof-merge");
+function isCircularMarker(value) {
+  return typeof value === "string" && value.startsWith("circular(");
+}
+/**
+ * Strip `additionalProperties: false` from sibling allOf members so
+ * allof-merge doesn't collapse to an unsatisfiable empty schema. See #1119.
+ *
+ * NOT cached: DiscriminatorNode mutates raw subschemas (deletes the
+ * discriminator property from each branch to avoid duplicate rendering).
+ * A WeakMap cache would return the pre-mutation deep clone on subsequent
+ * mergeAllOf calls, causing deleted properties to reappear inside tab
+ * content. Matches prod's per-call behavior.
+ */
+function stripConflictingAdditionalProps(node) {
+  if (Array.isArray(node)) return node.map(stripConflictingAdditionalProps);
+  if (!node || typeof node !== "object") return node;
+  let working = node;
+  if (Array.isArray(node.allOf) && node.allOf.length > 1) {
+    const hasStrictMember = node.allOf.some(
+      (m) => m && m.additionalProperties === false
+    );
+    if (hasStrictMember) {
+      working = {
+        ...node,
+        allOf: node.allOf.map((m) => {
+          if (m && m.additionalProperties === false) {
+            const { additionalProperties: _drop, ...rest } = m;
+            return rest;
+          }
+          return m;
+        }),
+      };
+    }
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(working)) {
+    result[k] = stripConflictingAdditionalProps(v);
+  }
+  return result;
+}
+function mergeAllOf(schema) {
+  const onMergeError = (msg) => console.warn(msg);
+  const merged = (0, allof_merge_1.merge)(
+    stripConflictingAdditionalProps(schema),
+    {
+      onMergeError,
+    }
+  );
+  return merged ?? {};
+}
+// Keys that are parent-level metadata and should NOT be folded into branches.
+const METADATA_KEYS = new Set([
+  "title",
+  "description",
+  "discriminator",
+  "deprecated",
+  "externalDocs",
+  "example",
+  "examples",
+  "xml",
+  "nullable",
+  "readOnly",
+  "writeOnly",
+  "default",
+]);
+/**
+ * Fold sibling fields into each oneOf/anyOf branch via allOf-merge so each
+ * branch is self-contained. See #1218.
+ *
+ * Skipped when a discriminator is present: DiscriminatorNode already renders
+ * sibling properties at the top level, and folding would duplicate the
+ * discriminator metadata into each branch (causing nested DiscriminatorNode
+ * renders inside tabs — see #1525 follow-up).
+ *
+ * Called by normalizeSchema after allOf resolution. Uses mergeAllOf internally
+ * to compose `{ allOf: [siblings, branch] }` per branch — the WeakMap caches
+ * in stripConflictingAdditionalProps prevent redundant work on shared subtrees.
+ */
+function foldSiblingsIntoBranches(schema) {
+  const branchKey = schema?.oneOf
+    ? "oneOf"
+    : schema?.anyOf
+      ? "anyOf"
+      : undefined;
+  if (!branchKey) return schema;
+  const branches = schema[branchKey];
+  if (!Array.isArray(branches) || branches.length === 0) return schema;
+  // Discriminator schemas rely on top-level properties being intact so
+  // DiscriminatorNode can locate the discriminator property and render
+  // shared siblings at the top level. Leave them alone.
+  if (schema.discriminator) return schema;
+  // Build siblings from non-metadata keys only. Metadata (title, description,
+  // examples, etc.) belongs at the top level and must not be folded.
+  const siblings = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key !== branchKey && !METADATA_KEYS.has(key) && !key.startsWith("x-")) {
+      siblings[key] = value;
+    }
+  }
+  if (Object.keys(siblings).length === 0) return schema;
+  const folded = branches.map((branch) =>
+    mergeAllOf({ allOf: [siblings, branch] })
+  );
+  const result = { [branchKey]: folded };
+  for (const key of Object.keys(schema)) {
+    if (key !== branchKey && (METADATA_KEYS.has(key) || key.startsWith("x-"))) {
+      result[key] = schema[key];
+    }
+  }
+  return result;
+}
+// WeakMap caches keyed by object identity — shared-reference subtrees from
+// $RefParser.dereference are looked up once, and cycles short-circuit.
+const discriminatorCache = new WeakMap();
+const findPropertyCache = new WeakMap();
+/**
+ * Cached recursive discriminator lookup. Returns O(1) on repeated calls
+ * with the same object reference (common after normalizeSchema).
+ */
+const BRANCH_KEYS = ["oneOf", "anyOf", "allOf"];
+function getDiscriminator(schema) {
+  if (!schema || typeof schema !== "object") return undefined;
+  if (discriminatorCache.has(schema)) {
+    const cached = discriminatorCache.get(schema);
+    return cached === null ? undefined : cached;
+  }
+  discriminatorCache.set(schema, null);
+  let result = schema.discriminator;
+  if (!result) {
+    for (const key of BRANCH_KEYS) {
+      const branches = schema[key];
+      if (!Array.isArray(branches)) continue;
+      for (const branch of branches) {
+        result = getDiscriminator(branch);
+        if (result) break;
+      }
+      if (result) break;
+    }
+  }
+  discriminatorCache.set(schema, result ?? null);
+  return result;
+}
+/**
+ * Cached recursive property lookup. Searches schema.properties first, then
+ * into oneOf/anyOf/allOf branches. Returns O(1) on repeated calls with the
+ * same (schema, propertyName) pair — replaces the O(subtree) findProperty
+ * walk that caused #1525's O(N^2) render cost.
+ */
+function findPropertyDeep(schema, propertyName) {
+  if (!schema || typeof schema !== "object") return undefined;
+  let cache = findPropertyCache.get(schema);
+  if (cache && cache.has(propertyName)) {
+    const cached = cache.get(propertyName);
+    return cached === null ? undefined : cached;
+  }
+  if (!cache) {
+    cache = new Map();
+    findPropertyCache.set(schema, cache);
+  }
+  cache.set(propertyName, null);
+  let result = schema.properties?.[propertyName];
+  if (!result) {
+    for (const key of BRANCH_KEYS) {
+      const branches = schema[key];
+      if (!Array.isArray(branches)) continue;
+      for (const branch of branches) {
+        result = findPropertyDeep(branch, propertyName);
+        if (result) break;
+      }
+      if (result) break;
+    }
+  }
+  cache.set(propertyName, result ?? null);
+  return result;
+}
+/**
+ * Identity-stable schema pass-through. Returns the input as-is so SchemaNode
+ * useMemo dependencies stay stable across renders.
+ *
+ * Earlier iterations of this function eagerly merged allOf and folded
+ * siblings into oneOf/anyOf branches, but those operations need to stay
+ * conditional inside SchemaNode and DiscriminatorNode — eager versions
+ * caused cartesian product expansion (allOf with multiple oneOfs) and
+ * double-folding regressions. The render-time helpers below
+ * (mergeAllOf, foldSiblingsIntoBranches) are still cached via the WeakMap
+ * inside stripConflictingAdditionalProps, so per-render cost stays bounded.
+ *
+ * The perf win for #1525 comes from getDiscriminator's WeakMap cache
+ * replacing the O(subtree) findDiscriminator walk, not from eager
+ * normalization here.
+ */
+function normalizeSchema(schema) {
+  return schema;
+}

package/lib/theme/Schema/normalize.test.d.ts

@@ -0,0 +1 @@
+export {};