docusaurus-plugin-generate-schema-docs 1.8.3 → 1.8.5

package/helpers/schemaToTableData.js

@@ -7,8 +7,7 @@ import { getExamples } from './example-helper';
  * nested group gets a unique visual position on the right side.
  */
 function computeOwnBracket(level, parentGroupBrackets) {
-  const bracketIndex = parentGroupBrackets.length;
-  return { level, bracketIndex };
+  return { level, bracketIndex: parentGroupBrackets.length };
 }
 
 function materializeConditionalBranchSchema(branchSchema, parentSchema) {
@@ -30,45 +29,146 @@ function materializeConditionalBranchSchema(branchSchema, parentSchema) {
       .map((name) => [name, parentSchema.properties[name]]),
   );
 
-  if (Object.keys(branchProperties).length === 0) {
-    return branchSchema;
-  }
-
-  return {
-    ...branchSchema,
-    type: 'object',
-    properties: branchProperties,
-  };
+  return Object.keys(branchProperties).length === 0
+    ? branchSchema
+    : { ...branchSchema, type: 'object', properties: branchProperties };
 }
 
 function hasRenderableAdditionalProperties(schemaNode) {
   return !!(
-    schemaNode &&
-    schemaNode.additionalProperties &&
+    schemaNode?.additionalProperties &&
     typeof schemaNode.additionalProperties === 'object' &&
     !Array.isArray(schemaNode.additionalProperties)
   );
 }
 
 function getRenderablePatternProperties(schemaNode) {
-  if (!schemaNode?.patternProperties) {
-    return [];
-  }
-
+  if (!schemaNode?.patternProperties) return [];
   return Object.entries(schemaNode.patternProperties)
-    .filter(
-      ([, patternSchema]) =>
-        patternSchema &&
-        typeof patternSchema === 'object' &&
-        !Array.isArray(patternSchema),
-    )
-    .map(([pattern, patternSchema]) => [
+    .filter(([, s]) => s && typeof s === 'object' && !Array.isArray(s))
+    .map(([pattern, s]) => [
       `patternProperties /${pattern}/`,
-      {
-        ...patternSchema,
-        'x-schema-keyword-row': true,
-      },
+      { ...s, 'x-schema-keyword-row': true },
+    ]);
+}
+
+function isEffectivelyEmpty(schemaNode) {
+  if (
+    schemaNode.type !== 'object' &&
+    typeof schemaNode.properties === 'undefined'
+  ) {
+    return false;
+  }
+  if (schemaNode.oneOf || schemaNode.anyOf || schemaNode.if) return false;
+  if (!schemaNode.properties || Object.keys(schemaNode.properties).length === 0)
+    return true;
+  return Object.values(schemaNode.properties).every(isEffectivelyEmpty);
+}
+
+// --- Step 4: extracted containerType resolution ---
+function resolveContainerType(
+  propSchema,
+  {
+    hasNestedProperties,
+    hasAdditionalProperties,
+    hasArrayItems,
+    isChoiceWrapper,
+    isConditionalWrapper,
+    choiceOptionsAreObjects,
+  },
+) {
+  if (hasNestedProperties || hasAdditionalProperties) return 'object';
+  if (
+    isChoiceWrapper &&
+    (propSchema.type === 'object' || choiceOptionsAreObjects)
+  )
+    return 'object';
+  if (isConditionalWrapper && propSchema.type === 'object') return 'object';
+  if (hasArrayItems) return 'array';
+  return null;
+}
+
+/**
+ * Returns whether a property schema has children and what container type it renders as.
+ * Also returns flags used for child-building dispatch.
+ */
+function getContainerInfo(propSchema) {
+  const isChoiceWrapper = !!(propSchema.oneOf || propSchema.anyOf);
+  const isConditionalWrapper = !!(
+    propSchema.if &&
+    (propSchema.then || propSchema.else)
+  );
+  const hasNestedProperties = !!propSchema.properties;
+  const hasAdditionalProperties = hasRenderableAdditionalProperties(propSchema);
+  const hasArrayItems =
+    propSchema.type === 'array' &&
+    !!(propSchema.items?.properties || propSchema.items?.if);
+  const choiceOptionsAreObjects =
+    isChoiceWrapper &&
+    (propSchema.oneOf || propSchema.anyOf).some(
+      (opt) => opt.type === 'object' || opt.properties,
+    );
+
+  const hasChildren =
+    hasNestedProperties ||
+    hasAdditionalProperties ||
+    hasArrayItems ||
+    isChoiceWrapper ||
+    isConditionalWrapper;
+
+  const containerType = resolveContainerType(propSchema, {
+    hasNestedProperties,
+    hasAdditionalProperties,
+    hasArrayItems,
+    isChoiceWrapper,
+    isConditionalWrapper,
+    choiceOptionsAreObjects,
+  });
+
+  return {
+    hasChildren,
+    containerType,
+    isChoiceWrapper,
+    isConditionalWrapper,
+    hasArrayItems,
+    hasAdditionalProperties,
+  };
+}
+
+// --- Step 1: Row factory functions ---
+function makeBaseRow(overrides) {
+  return {
+    hasChildren: false,
+    containerType: null,
+    ...overrides,
+  };
+}
+
+function makePropertyRow(fields) {
+  return makeBaseRow({ type: 'property', ...fields });
+}
+
+function makeChoiceRow(fields) {
+  return makeBaseRow({ type: 'choice', ...fields });
+}
+
+function makeConditionalRow(fields) {
+  return makeBaseRow({ type: 'conditional', ...fields });
+}
+
+// --- Step 2: buildPropEntries helper ---
+function buildPropEntries(subSchema, patternPropertyEntries) {
+  const entries = subSchema.properties
+    ? Object.entries(subSchema.properties)
+    : [];
+  if (hasRenderableAdditionalProperties(subSchema)) {
+    entries.push([
+      'additionalProperties',
+      { ...subSchema.additionalProperties, 'x-schema-keyword-row': true },
     ]);
+  }
+  entries.push(...patternPropertyEntries);
+  return entries;
 }
 
 function processOptions(
@@ -83,179 +183,111 @@ function processOptions(
 ) {
   return choices.map((optionSchema, index) => {
     const optionTitle = optionSchema.title || 'Option';
+    const isLast = index === choices.length - 1 && choiceIsLastInGroup;
 
-    // Determine if this is the last option in the list.
-    // If it is NOT the last option, its children must not close the visual tree branch.
-    const isLastOption = index === choices.length - 1;
-
-    let optionRows = [];
-
-    // This is a primitive type (string, number, etc.) within a choice
+    let rows;
     if (optionSchema.type && !optionSchema.properties) {
+      // Primitive type within a choice
       const isRequired = requiredArray.includes(path[path.length - 1]);
       const constraints = getConstraints(optionSchema);
-      if (isRequired) {
-        constraints.unshift('required');
-      }
-
-      optionRows.push({
-        type: 'property',
-        // The name of the property is the name of the parent property that holds the choice
-        name: path.length > 0 ? path[path.length - 1] : optionTitle,
-        path: [...path, `(${optionTitle})`],
-        // If it's a top-level choice (like user_id), the level is the same as the choice itself.
-        // Otherwise, it's nested.
-        level: level,
-        required: isRequired,
-        propertyType: optionSchema.type,
-        description: optionSchema.description,
-        examples: getExamples(optionSchema),
-        constraints: constraints,
-        // Keep connector lines open when the enclosing choice block isn't truly last.
-        isLastInGroup: isLastOption && choiceIsLastInGroup,
-        hasChildren: false,
-        containerType: null,
-        continuingLevels: [...continuingLevels],
-        groupBrackets: [...groupBrackets],
-      });
+      if (isRequired) constraints.unshift('required');
+      rows = [
+        makePropertyRow({
+          name: path.length > 0 ? path[path.length - 1] : optionTitle,
+          path: [...path, `(${optionTitle})`],
+          level,
+          required: isRequired,
+          propertyType: optionSchema.type,
+          description: optionSchema.description,
+          examples: getExamples(optionSchema),
+          constraints,
+          isLastInGroup: isLast,
+          continuingLevels: [...continuingLevels],
+          groupBrackets: [...groupBrackets],
+        }),
+      ];
     } else {
-      // This is a complex object within a choice
-      optionRows = schemaToTableData(
+      rows = schemaToTableData(
         optionSchema,
-        // If nested in a property (like payment_method), the sub-properties start at the same level as the choice
-        // Otherwise, they are one level deeper.
         level,
         isNestedInProperty ? [] : path,
         continuingLevels,
-        isLastOption && choiceIsLastInGroup,
+        isLast,
         groupBrackets,
       );
     }
 
-    return {
-      title: optionTitle,
-      description: optionSchema.description,
-      rows: optionRows,
-    };
+    return { title: optionTitle, description: optionSchema.description, rows };
   });
 }
 
-export function schemaToTableData(
-  schema,
-  level = 0,
-  path = [],
-  parentContinuingLevels = [],
-  isLastOption = true,
-  parentGroupBrackets = [],
-) {
-  const flatRows = [];
+// --- Row building (module-level, each function returns its rows) ---
 
-  function isEffectivelyEmpty(schemaNode) {
-    if (
-      schemaNode.type !== 'object' &&
-      typeof schemaNode.properties === 'undefined'
-    ) {
-      return false;
-    }
-    if (schemaNode.oneOf || schemaNode.anyOf || schemaNode.if) {
-      return false;
-    }
-    if (
-      !schemaNode.properties ||
-      Object.keys(schemaNode.properties).length === 0
-    ) {
-      return true;
-    }
-    return Object.values(schemaNode.properties).every(isEffectivelyEmpty);
-  }
+function buildConditionalRow(
+  subSchema,
+  currentLevel,
+  currentPath,
+  continuingLevels,
+  currentGroupBrackets = [],
+  ownContinuingLevels,
+  conditionalIsLastInGroup = true,
+) {
+  const ownBracket = computeOwnBracket(currentLevel, currentGroupBrackets);
+  const innerGroupBrackets = [...currentGroupBrackets, ownBracket];
 
-  function buildConditionalRow(
-    subSchema,
+  const conditionRows = schemaToTableData(
+    subSchema.if,
     currentLevel,
     currentPath,
     continuingLevels,
-    currentGroupBrackets = [],
-    ownContinuingLevels,
-    conditionalIsLastInGroup = true,
-  ) {
-    // Inner rows (condition, branches) inherit the parent's continuingLevels.
-    // The immediate parent connector (currentLevel - 1) is handled by the
-    // ConditionalRows component via its ancestorLevels.push(level - 1).
-    const innerContinuingLevels = [...continuingLevels];
+    false, // branches always follow condition rows, so they are never "last"
+    innerGroupBrackets,
+  ).map((row) => ({ ...row, isCondition: true }));
+
+  const hasElse = !!subSchema.else;
+  const branches = [];
+
+  if (subSchema.then) {
+    branches.push({
+      title: 'Then',
+      description: subSchema.then.description,
+      rows: schemaToTableData(
+        materializeConditionalBranchSchema(subSchema.then, subSchema),
+        currentLevel,
+        currentPath,
+        continuingLevels,
+        !hasElse && conditionalIsLastInGroup,
+        innerGroupBrackets,
+      ),
+    });
+  }
 
-    // Compute the bracket for this if/then/else group
-    const ownBracket = computeOwnBracket(currentLevel, currentGroupBrackets);
-    const innerGroupBrackets = [...currentGroupBrackets, ownBracket];
-
-    const conditionRows = schemaToTableData(
-      subSchema.if,
-      currentLevel,
-      currentPath,
-      innerContinuingLevels,
-      false, // branches always follow condition rows, so they are never "last"
-      innerGroupBrackets,
-    ).map((row) => ({ ...row, isCondition: true }));
-
-    const hasThen = !!subSchema.then;
-    const hasElse = !!subSchema.else;
-
-    const branches = [];
-    if (hasThen) {
-      // Then is NOT the last branch if Else exists — use innerContinuingLevels
-      // to keep the parent line flowing. If Then IS the last branch, use original.
-      const thenLevels = hasElse ? innerContinuingLevels : continuingLevels;
-      const thenSchema = materializeConditionalBranchSchema(
-        subSchema.then,
-        subSchema,
-      );
-      branches.push({
-        title: 'Then',
-        description: subSchema.then.description,
-        rows: schemaToTableData(
-          thenSchema,
-          currentLevel,
-          currentPath,
-          thenLevels,
-          // Keep branch connectors open if this conditional block isn't truly last.
-          !hasElse && conditionalIsLastInGroup,
-          innerGroupBrackets,
-        ),
-      });
-    }
-    if (hasElse) {
-      // Else is always the last branch — use original continuingLevels
-      const elseSchema = materializeConditionalBranchSchema(
-        subSchema.else,
-        subSchema,
-      );
-      branches.push({
-        title: 'Else',
-        description: subSchema.else.description,
-        rows: schemaToTableData(
-          elseSchema,
-          currentLevel,
-          currentPath,
-          continuingLevels,
-          conditionalIsLastInGroup,
-          innerGroupBrackets,
-        ),
-      });
-    }
+  if (hasElse) {
+    branches.push({
+      title: 'Else',
+      description: subSchema.else.description,
+      rows: schemaToTableData(
+        materializeConditionalBranchSchema(subSchema.else, subSchema),
+        currentLevel,
+        currentPath,
+        continuingLevels,
+        conditionalIsLastInGroup,
+        innerGroupBrackets,
+      ),
+    });
+  }
 
-    // ownContinuingLevels (when provided) includes currentLevel for the row's
-    // header/toggle rendering, since sibling properties' tree lines must continue.
-    // Merge with innerContinuingLevels to also include the parent level.
-    const rowContinuingLevels = ownContinuingLevels
-      ? [...new Set([...innerContinuingLevels, ...ownContinuingLevels])]
-      : innerContinuingLevels;
+  // ownContinuingLevels (when provided) includes currentLevel for the row's
+  // header/toggle rendering, since sibling properties' tree lines must continue.
+  const rowContinuingLevels = ownContinuingLevels
+    ? [...new Set([...continuingLevels, ...ownContinuingLevels])]
+    : continuingLevels;
 
-    flatRows.push({
-      type: 'conditional',
+  return [
+    makeConditionalRow({
       path: [...currentPath, 'if/then/else'],
       level: currentLevel,
       isLastInGroup: conditionalIsLastInGroup,
-      hasChildren: false,
-      containerType: null,
       continuingLevels: [...rowContinuingLevels],
       groupBrackets: [...currentGroupBrackets],
       condition: {
@@ -264,335 +296,340 @@ export function schemaToTableData(
         rows: conditionRows,
       },
       branches,
-    });
+    }),
+  ];
+}
+
+// Dispatches child row building after a property row has been pushed.
+function buildPropertyChildren(
+  ctx,
+  propSchema,
+  currentLevel,
+  newPath,
+  childContinuingLevels,
+  currentGroupBrackets,
+  isLast,
+  {
+    isChoiceWrapper,
+    isConditionalWrapper,
+    hasArrayItems,
+    hasAdditionalProperties,
+  },
+) {
+  const rows = [];
+
+  if (propSchema.properties) {
+    rows.push(
+      ...buildRows(
+        ctx,
+        propSchema,
+        currentLevel + 1,
+        newPath,
+        propSchema.required,
+        childContinuingLevels,
+        currentGroupBrackets,
+      ),
+    );
+  } else if (propSchema.type === 'object' && hasAdditionalProperties) {
+    rows.push(
+      ...buildRows(
+        ctx,
+        propSchema,
+        currentLevel + 1,
+        newPath,
+        [],
+        childContinuingLevels,
+        currentGroupBrackets,
+      ),
+    );
+  } else if (hasArrayItems) {
+    const itemPath = [...newPath, '[n]'];
+    if (propSchema.items.properties) {
+      rows.push(
+        ...buildRows(
+          ctx,
+          propSchema.items,
+          currentLevel + 1,
+          itemPath,
+          propSchema.items.required,
+          childContinuingLevels,
+          currentGroupBrackets,
+        ),
+      );
+    }
+    if (
+      propSchema.items.if &&
+      (propSchema.items.then || propSchema.items.else)
+    ) {
+      rows.push(
+        ...buildConditionalRow(
+          propSchema.items,
+          currentLevel + 1,
+          itemPath,
+          childContinuingLevels,
+          currentGroupBrackets,
+          undefined,
+          isLast,
+        ),
+      );
+    }
+  } else if (isChoiceWrapper) {
+    // Complex choice property (e.g. payment_method): property row already pushed,
+    // now add the nested choice row.
+    const choiceType = propSchema.oneOf ? 'oneOf' : 'anyOf';
+    const ownBracket = computeOwnBracket(
+      currentLevel + 1,
+      currentGroupBrackets,
+    );
+    const innerBrackets = [...currentGroupBrackets, ownBracket];
+    rows.push(
+      makeChoiceRow({
+        choiceType,
+        path: [...newPath, choiceType],
+        level: currentLevel + 1,
+        title: propSchema.title,
+        description: null,
+        isLastInGroup: true,
+        continuingLevels: childContinuingLevels,
+        groupBrackets: [...currentGroupBrackets],
+        options: processOptions(
+          propSchema[choiceType],
+          currentLevel + 1,
+          newPath,
+          true,
+          propSchema.required,
+          childContinuingLevels,
+          innerBrackets,
+        ),
+      }),
+    );
   }
 
-  function buildRows(
-    subSchema,
-    currentLevel,
-    currentPath,
-    requiredFromParent = [],
-    continuingLevels = [],
-    currentGroupBrackets = [],
-  ) {
-    if (!subSchema) return;
+  // Handle if/then/else nested inside a property without its own properties.
+  // When propSchema HAS properties, the recursive buildRows call above
+  // already handles if/then/else via the root-level check at the end of buildRows.
+  if (isConditionalWrapper && !propSchema.properties) {
+    rows.push(
+      ...buildConditionalRow(
+        propSchema,
+        currentLevel + 1,
+        newPath,
+        childContinuingLevels,
+        currentGroupBrackets,
+        undefined,
+        isLast,
+      ),
+    );
+  }
 
-    const patternPropertyEntries = getRenderablePatternProperties(subSchema);
+  return rows;
+}
 
-    if (
-      subSchema.properties ||
-      hasRenderableAdditionalProperties(subSchema) ||
-      patternPropertyEntries.length > 0
-    ) {
-      const propEntries = subSchema.properties
-        ? Object.entries(subSchema.properties)
-        : [];
-      if (hasRenderableAdditionalProperties(subSchema)) {
-        propEntries.push([
-          'additionalProperties',
+function buildPropertyRows(
+  ctx,
+  subSchema,
+  currentLevel,
+  currentPath,
+  requiredFromParent,
+  continuingLevels,
+  currentGroupBrackets,
+  visiblePropEntries,
+  hasSiblingChoices,
+) {
+  const rows = [];
+
+  visiblePropEntries.forEach(([name, propSchema], index) => {
+    const newPath = [...currentPath, name];
+    const isLastProp =
+      index === visiblePropEntries.length - 1 && !hasSiblingChoices;
+    const isLast =
+      isLastProp && (currentLevel !== ctx.topLevel || ctx.isLastOption);
+
+    // If this is not the last item, add currentLevel to continuing levels for children
+    // so ancestor tree lines keep flowing through all descendants.
+    const childContinuingLevels = isLast
+      ? [...continuingLevels]
+      : [...continuingLevels, currentLevel];
+
+    const {
+      hasChildren,
+      containerType,
+      isChoiceWrapper,
+      isConditionalWrapper,
+      hasArrayItems,
+      hasAdditionalProperties,
+    } = getContainerInfo(propSchema);
+
+    // A "simple" choice has scalar options (no nested properties) and renders inline.
+    // A "complex" choice has object options and needs its own property row first.
+    const isSimpleChoice = isChoiceWrapper && containerType === null;
+
+    if (isSimpleChoice) {
+      const choiceType = propSchema.oneOf ? 'oneOf' : 'anyOf';
+      const ownBracket = computeOwnBracket(currentLevel, currentGroupBrackets);
+      rows.push(
+        makeChoiceRow({
+          choiceType,
+          name,
+          path: newPath,
+          level: currentLevel,
+          title: propSchema.title,
+          description: propSchema.description,
+          isLastInGroup: isLast,
+          continuingLevels: [...continuingLevels],
+          groupBrackets: [...currentGroupBrackets],
+          options: processOptions(
+            propSchema[choiceType],
+            currentLevel,
+            newPath,
+            false,
+            subSchema.required || requiredFromParent,
+            childContinuingLevels,
+            [...currentGroupBrackets, ownBracket],
+            isLast,
+          ),
+        }),
+      );
+    } else {
+      const isRequired =
+        (subSchema.required || requiredFromParent)?.includes(name) || false;
+      const constraints = getConstraints(propSchema);
+      if (isRequired) constraints.unshift('required');
+
+      rows.push(
+        makePropertyRow({
+          name,
+          path: newPath,
+          level: currentLevel,
+          required: isRequired,
+          propertyType:
+            propSchema.type || (propSchema.enum ? 'enum' : 'object'),
+          description: propSchema.description,
+          examples: getExamples(propSchema),
+          constraints,
+          isLastInGroup: isLast,
+          hasChildren,
+          containerType,
+          continuingLevels: [...continuingLevels],
+          groupBrackets: [...currentGroupBrackets],
+          isSchemaKeywordRow: propSchema['x-schema-keyword-row'] === true,
+          keepConnectorOpen: propSchema['x-keep-connector-open'] === true,
+        }),
+      );
+
+      rows.push(
+        ...buildPropertyChildren(
+          ctx,
+          propSchema,
+          currentLevel,
+          newPath,
+          childContinuingLevels,
+          currentGroupBrackets,
+          isLast,
           {
-            ...subSchema.additionalProperties,
-            'x-schema-keyword-row': true,
+            isChoiceWrapper,
+            isConditionalWrapper,
+            hasArrayItems,
+            hasAdditionalProperties,
           },
-        ]);
-      }
-      propEntries.push(...patternPropertyEntries);
-      const hasSiblingChoices = !!(
-        subSchema.oneOf ||
-        subSchema.anyOf ||
-        subSchema.if
+        ),
       );
-
-      // Filter out properties that should be skipped to get accurate count
-      const visiblePropEntries = propEntries.filter(([name, propSchema]) => {
-        return !(
-          propSchema['x-gtm-clear'] === true && isEffectivelyEmpty(propSchema)
-        );
-      });
-
-      visiblePropEntries.forEach(([name, propSchema], index) => {
-        const newPath = [...currentPath, name];
-
-        const isLastProp =
-          index === visiblePropEntries.length - 1 && !hasSiblingChoices;
-
-        // Updated Logic:
-        // A property is visually "last" only if it is the last property
-        // AND (it is deeper in the hierarchy OR the parent option itself is the last one).
-        const isLast = isLastProp && (currentLevel !== level || isLastOption);
-
-        const isChoiceWrapper = !!(propSchema.oneOf || propSchema.anyOf);
-        const isConditionalWrapper = !!(
-          propSchema.if &&
-          (propSchema.then || propSchema.else)
-        );
-
-        // Determine if this property has children and what type
-        const hasNestedProperties = !!propSchema.properties;
-        const hasAdditionalProperties =
-          hasRenderableAdditionalProperties(propSchema);
-        const hasArrayItems =
-          propSchema.type === 'array' &&
-          !!(propSchema.items?.properties || propSchema.items?.if);
-        const hasNestedChoice = isChoiceWrapper;
-        const hasNestedConditional = isConditionalWrapper;
-        const hasChildren =
-          hasNestedProperties ||
-          hasAdditionalProperties ||
-          hasArrayItems ||
-          hasNestedChoice ||
-          hasNestedConditional;
-
-        // Determine container type for the symbol
-        let containerType = null;
-        const choiceOptions = propSchema.oneOf || propSchema.anyOf || [];
-        const choiceOptionsAreObjects =
-          isChoiceWrapper &&
-          choiceOptions.some((opt) => opt.type === 'object' || opt.properties);
-        if (
-          hasNestedProperties ||
-          hasAdditionalProperties ||
-          (isChoiceWrapper && propSchema.type === 'object') ||
-          (isConditionalWrapper && propSchema.type === 'object') ||
-          choiceOptionsAreObjects
-        ) {
-          containerType = 'object';
-        } else if (hasArrayItems) {
-          containerType = 'array';
-        }
-
-        // Calculate continuing levels for children
-        // If this is not the last item, add current level to continuing levels for children
-        // If this IS the last item, don't add currentLevel (no more siblings at this level).
-        // We keep all existing continuingLevels intact — they represent ancestor lines
-        // that must continue through all descendants regardless of last-child status.
-        const childContinuingLevels = isLast
-          ? [...continuingLevels]
-          : [...continuingLevels, currentLevel];
-
-        // A "simple" choice property like user_id: { oneOf: [{ type: "string" }, { type: "integer" }] }
-        // where the options are scalar types (no nested properties). These get unwrapped
-        // into a choice row directly without their own property row.
-        // In contrast, choice wrappers whose options are objects with properties
-        // (like contact_method) need their own property row to start a nesting level.
-        const isSimpleChoice =
-          isChoiceWrapper &&
-          !propSchema.properties &&
-          propSchema.type !== 'object' &&
-          !(propSchema.oneOf || propSchema.anyOf).some((opt) => opt.properties);
-
-        if (isSimpleChoice) {
-          const choiceType = propSchema.oneOf ? 'oneOf' : 'anyOf';
-          const choices = propSchema[choiceType];
-          const ownBracket = computeOwnBracket(
-            currentLevel,
-            currentGroupBrackets,
-          );
-          const innerGroupBrackets = [...currentGroupBrackets, ownBracket];
-          flatRows.push({
-            type: 'choice',
-            choiceType,
-            name,
-            path: newPath,
-            level: currentLevel,
-            title: propSchema.title,
-            description: propSchema.description,
-            isLastInGroup: isLast,
-            hasChildren: false,
-            containerType: null,
-            continuingLevels: [...continuingLevels],
-            groupBrackets: [...currentGroupBrackets],
-            options: processOptions(
-              choices,
-              currentLevel,
-              newPath,
-              false,
-              subSchema.required || requiredFromParent,
-              childContinuingLevels,
-              innerGroupBrackets,
-              isLast,
-            ),
-          });
-        } else {
-          // This is a "normal" property or a complex one with a nested choice.
-          const isRequired =
-            (subSchema.required || requiredFromParent)?.includes(name) || false;
-          const constraints = getConstraints(propSchema);
-          if (isRequired) {
-            constraints.unshift('required');
-          }
-
-          flatRows.push({
-            type: 'property',
-            name,
-            path: newPath,
-            level: currentLevel,
-            required: isRequired,
-            propertyType:
-              propSchema.type || (propSchema.enum ? 'enum' : 'object'),
-            description: propSchema.description,
-            examples: getExamples(propSchema),
-            constraints,
-            isLastInGroup: isLast,
-            hasChildren,
-            containerType,
-            continuingLevels: [...continuingLevels],
-            groupBrackets: [...currentGroupBrackets],
-            isSchemaKeywordRow: propSchema['x-schema-keyword-row'] === true,
-            keepConnectorOpen: propSchema['x-keep-connector-open'] === true,
-          });
-
-          if (propSchema.properties) {
-            buildRows(
-              propSchema,
-              currentLevel + 1,
-              newPath,
-              propSchema.required,
-              childContinuingLevels,
-              currentGroupBrackets,
-            );
-          } else if (propSchema.type === 'object' && hasAdditionalProperties) {
-            buildRows(
-              propSchema,
-              currentLevel + 1,
-              newPath,
-              [],
-              childContinuingLevels,
-              currentGroupBrackets,
-            );
-          } else if (
-            propSchema.type === 'array' &&
-            (propSchema.items?.properties || propSchema.items?.if)
-          ) {
-            if (propSchema.items.properties) {
-              buildRows(
-                propSchema.items,
-                currentLevel + 1,
-                [...newPath, '[n]'],
-                propSchema.items.required,
-                childContinuingLevels,
-                currentGroupBrackets,
-              );
-            }
-            // Handle if/then/else inside array items
-            if (
-              propSchema.items.if &&
-              (propSchema.items.then || propSchema.items.else)
-            ) {
-              buildConditionalRow(
-                propSchema.items,
-                currentLevel + 1,
-                [...newPath, '[n]'],
-                childContinuingLevels,
-                currentGroupBrackets,
-                undefined,
-                isLast,
-              );
-            }
-          } else if (isChoiceWrapper) {
-            // This handles the "complex" choice property like payment_method.
-            // A property row has already been created above, now we add the choice row.
-            const choiceType = propSchema.oneOf ? 'oneOf' : 'anyOf';
-            const choices = propSchema[choiceType];
-            const complexOwnBracket = computeOwnBracket(
-              currentLevel + 1,
-              currentGroupBrackets,
-            );
-            const complexInnerBrackets = [
-              ...currentGroupBrackets,
-              complexOwnBracket,
-            ];
-            flatRows.push({
-              type: 'choice',
-              choiceType,
-              path: [...newPath, choiceType], // Make path unique
-              level: currentLevel + 1,
-              title: propSchema.title,
-              description: null,
-              isLastInGroup: true,
-              hasChildren: false,
-              containerType: null,
-              continuingLevels: childContinuingLevels,
-              groupBrackets: [...currentGroupBrackets],
-              options: processOptions(
-                choices,
-                currentLevel + 1,
-                newPath,
-                true,
-                propSchema.required,
-                childContinuingLevels,
-                complexInnerBrackets,
-              ),
-            });
-          }
-
-          // Handle if/then/else nested inside a property without its own properties.
-          // When propSchema HAS properties, the recursive buildRows call above
-          // already handles if/then/else via the root-level check at the end of buildRows.
-          if (isConditionalWrapper && !propSchema.properties) {
-            buildConditionalRow(
-              propSchema,
-              currentLevel + 1,
-              newPath,
-              childContinuingLevels,
-              currentGroupBrackets,
-              undefined,
-              isLast,
-            );
-          }
-        }
-      });
     }
+  });
 
-    // When properties coexist with root-level choices or conditionals,
-    // the header/toggle rows need the tree line at currentLevel to continue.
-    // Only used for the row's own continuingLevels — NOT propagated to inner rows.
-    const hasProperties =
-      subSchema.properties && Object.keys(subSchema.properties).length > 0;
-    const ownContinuingLevels =
-      hasProperties && !continuingLevels.includes(currentLevel)
-        ? [...continuingLevels, currentLevel]
-        : [...continuingLevels];
-
-    // This handles choices at the root of a schema
-    const choiceType = subSchema.oneOf
-      ? 'oneOf'
-      : subSchema.anyOf
-        ? 'anyOf'
-        : null;
-    if (choiceType) {
-      const choices = subSchema[choiceType];
-      const ownBracket = computeOwnBracket(currentLevel, currentGroupBrackets);
-      const innerGroupBrackets = [...currentGroupBrackets, ownBracket];
-      const choiceIsLastInGroup =
-        isLastOption && !(subSchema.if && (subSchema.then || subSchema.else));
-      flatRows.push({
-        type: 'choice',
+  return rows;
+}
+
+function buildRows(
+  ctx,
+  subSchema,
+  currentLevel,
+  currentPath,
+  requiredFromParent = [],
+  continuingLevels = [],
+  currentGroupBrackets = [],
+) {
+  if (!subSchema) return [];
+
+  const rows = [];
+  const patternPropertyEntries = getRenderablePatternProperties(subSchema);
+  const hasAnyProperties =
+    subSchema.properties ||
+    hasRenderableAdditionalProperties(subSchema) ||
+    patternPropertyEntries.length > 0;
+
+  if (hasAnyProperties) {
+    const propEntries = buildPropEntries(subSchema, patternPropertyEntries);
+    const hasSiblingChoices = !!(
+      subSchema.oneOf ||
+      subSchema.anyOf ||
+      subSchema.if
+    );
+    const visiblePropEntries = propEntries.filter(
+      ([, propSchema]) =>
+        !(propSchema['x-gtm-clear'] === true && isEffectivelyEmpty(propSchema)),
+    );
+
+    rows.push(
+      ...buildPropertyRows(
+        ctx,
+        subSchema,
+        currentLevel,
+        currentPath,
+        requiredFromParent,
+        continuingLevels,
+        currentGroupBrackets,
+        visiblePropEntries,
+        hasSiblingChoices,
+      ),
+    );
+  }
+
+  // When properties coexist with root-level choices or conditionals,
+  // the header/toggle rows need the tree line at currentLevel to continue.
+  // Only used for the row's own continuingLevels — NOT propagated to inner rows.
+  const hasProperties =
+    subSchema.properties && Object.keys(subSchema.properties).length > 0;
+  const ownContinuingLevels =
+    hasProperties && !continuingLevels.includes(currentLevel)
+      ? [...continuingLevels, currentLevel]
+      : [...continuingLevels];
+
+  const choiceType = subSchema.oneOf
+    ? 'oneOf'
+    : subSchema.anyOf
+      ? 'anyOf'
+      : null;
+  if (choiceType) {
+    const ownBracket = computeOwnBracket(currentLevel, currentGroupBrackets);
+    const choiceIsLastInGroup =
+      ctx.isLastOption && !(subSchema.if && (subSchema.then || subSchema.else));
+    rows.push(
+      makeChoiceRow({
         choiceType,
         path: currentPath,
         level: currentLevel,
         title: subSchema.title,
         description: subSchema.description,
         isLastInGroup: choiceIsLastInGroup,
-        hasChildren: false,
-        containerType: null,
         continuingLevels: [...ownContinuingLevels],
         groupBrackets: [...currentGroupBrackets],
         options: processOptions(
-          choices,
+          subSchema[choiceType],
           currentLevel,
           currentPath,
           false,
           subSchema.required || requiredFromParent,
           continuingLevels,
-          innerGroupBrackets,
+          [...currentGroupBrackets, ownBracket],
           choiceIsLastInGroup,
         ),
-      });
-    } else if (!subSchema.properties && subSchema.type) {
-      // This handles a schema that is just a single primitive type
-      flatRows.push({
-        type: 'property',
+      }),
+    );
+  } else if (!subSchema.properties && subSchema.type) {
+    // Root-level primitive schema
+    rows.push(
+      makePropertyRow({
         name: subSchema.title || '<value>',
         path: currentPath,
         level: currentLevel,
@@ -602,30 +639,40 @@ export function schemaToTableData(
         examples: getExamples(subSchema),
         constraints: getConstraints(subSchema),
         isLastInGroup: true,
-        hasChildren: false,
-        containerType: null,
         continuingLevels: [...continuingLevels],
         groupBrackets: [...currentGroupBrackets],
-      });
-    }
+      }),
+    );
+  }
 
-    // Handle if/then/else at the schema root (or sub-schema root)
-    if (subSchema.if && (subSchema.then || subSchema.else)) {
-      // ownContinuingLevels includes currentLevel for the row's header/toggle rendering.
-      // Inner rows (condition, branches) use the original continuingLevels.
-      buildConditionalRow(
+  if (subSchema.if && (subSchema.then || subSchema.else)) {
+    rows.push(
+      ...buildConditionalRow(
         subSchema,
         currentLevel,
         currentPath,
         continuingLevels,
         currentGroupBrackets,
         hasProperties ? [...ownContinuingLevels] : undefined,
-        isLastOption,
-      );
-    }
+        ctx.isLastOption,
+      ),
+    );
   }
 
-  buildRows(
+  return rows;
+}
+
+export function schemaToTableData(
+  schema,
+  level = 0,
+  path = [],
+  parentContinuingLevels = [],
+  isLastOption = true,
+  parentGroupBrackets = [],
+) {
+  const ctx = { topLevel: level, isLastOption };
+  return buildRows(
+    ctx,
     schema,
     level,
     path,
@@ -633,5 +680,4 @@ export function schemaToTableData(
     parentContinuingLevels,
     parentGroupBrackets,
   );
-  return flatRows;
 }