docusaurus-plugin-generate-schema-docs 1.7.0 → 1.8.0

package/components/PropertyRow.js

@@ -125,6 +125,7 @@ export default function PropertyRow({ row, isLastInGroup, bracketEnds }) {
           rowSpan={rowSpan}
           style={{ ...indentStyle, ...continuingLinesStyle }}
           className={clsx(
+            'property-cell',
             level > 0 && `level-${level}`,
             isLastInGroup && 'is-last',
             hasChildren && 'has-children',
@@ -143,7 +144,7 @@ export default function PropertyRow({ row, isLastInGroup, bracketEnds }) {
         </td>
 
         {/* The first constraint cell */}
-        <td>
+        <td className="constraint-cell">
           {firstConstraint && (
             <code
               className={clsx(
@@ -181,7 +182,7 @@ export default function PropertyRow({ row, isLastInGroup, bracketEnds }) {
       {/* Render subsequent constraints in their own rows */}
       {remainingConstraints.map((constraint) => (
         <tr className={clsx(required && 'required-row')} key={constraint}>
-          <td>
+          <td className="constraint-cell">
             <code
               className={clsx(
                 'constraint-code',

package/components/SchemaRows.css

@@ -63,10 +63,19 @@
 }
 
 .schema-table th:first-child,
-.schema-table td:first-child {
+.schema-table td.property-cell {
   border-left: none;
 }
 
+/*
+ * Constraint-only continuation rows render a single cell; in those rows that
+ * cell is also :first-child, but it still needs the separator before the
+ * "Constraints" column.
+ */
+.schema-table td.constraint-cell {
+  border-left: 1px solid var(--ifm-table-border-color);
+}
+
 .schema-table thead th {
   border-bottom: 2px solid var(--ifm-table-border-color);
 }

package/helpers/exampleModel.js

@@ -0,0 +1,70 @@
+import { schemaToExamples } from './schemaToExamples';
+import {
+  DEFAULT_SNIPPET_TARGET_ID,
+  findClearableProperties,
+  generateSnippetForTarget,
+  getSnippetTarget,
+} from './snippetTargets';
+
+export function resolveExampleTargets(schema) {
+  const configured = schema?.['x-tracking-targets'];
+  const targetIds =
+    Array.isArray(configured) && configured.length > 0
+      ? configured
+      : [DEFAULT_SNIPPET_TARGET_ID];
+
+  const targets = targetIds
+    .map((id) => {
+      try {
+        return getSnippetTarget(id);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+
+  if (targets.length > 0) return targets;
+  return [getSnippetTarget(DEFAULT_SNIPPET_TARGET_ID)];
+}
+
+export function buildExampleModel(schema, { dataLayerName } = {}) {
+  const exampleGroups = schemaToExamples(schema);
+  const targets = resolveExampleTargets(schema);
+
+  if (!exampleGroups || exampleGroups.length === 0) {
+    return {
+      targets,
+      variantGroups: [],
+      isSimpleDefault: false,
+    };
+  }
+
+  const variantGroups = exampleGroups.map((group) => ({
+    property: group.property,
+    options: group.options.map((option, index) => ({
+      id: `${group.property}-${index}`,
+      title: option.title,
+      example: option.example,
+      snippets: Object.fromEntries(
+        targets.map((target) => [
+          target.id,
+          generateSnippetForTarget({
+            targetId: target.id,
+            example: option.example,
+            schema,
+            dataLayerName,
+          }),
+        ]),
+      ),
+    })),
+  }));
+
+  return {
+    targets,
+    variantGroups,
+    isSimpleDefault:
+      variantGroups.length === 1 && variantGroups[0].property === 'default',
+  };
+}
+
+export { findClearableProperties };

package/helpers/schema-processing.js

@@ -1,5 +1,33 @@
 import path from 'path';
+import fs from 'fs';
 import processSchema from './processSchema.js';
+import mergeJsonSchema from 'json-schema-merge-allof';
+
+function mergePropertySchemas(baseProperties = {}, optionProperties = {}) {
+  const mergedProperties = {
+    ...baseProperties,
+    ...optionProperties,
+  };
+
+  for (const key of Object.keys(baseProperties)) {
+    if (!Object.prototype.hasOwnProperty.call(optionProperties, key)) {
+      continue;
+    }
+
+    mergedProperties[key] = mergeJsonSchema(
+      {
+        allOf: [baseProperties[key], optionProperties[key]],
+      },
+      {
+        resolvers: {
+          defaultResolver: mergeJsonSchema.options.resolvers.title,
+        },
+      },
+    );
+  }
+
+  return mergedProperties;
+}
 
 export function slugify(text) {
   if (!text) {
@@ -20,7 +48,15 @@ export async function processOneOfSchema(schema, filePath) {
   const choiceType = schema.oneOf ? 'oneOf' : null;
 
   if (choiceType) {
-    const parentWithoutChoice = { ...schema };
+    let parentSchema = schema;
+
+    // When the root schema is loaded from disk, use its processed form so
+    // parent-level allOf refs (e.g. shared dataLayer metadata) are preserved.
+    if (filePath && fs.existsSync(filePath)) {
+      parentSchema = await processSchema(filePath);
+    }
+
+    const parentWithoutChoice = { ...parentSchema };
     delete parentWithoutChoice[choiceType];
 
     for (const option of schema[choiceType]) {
@@ -34,10 +70,10 @@ export async function processOneOfSchema(schema, filePath) {
 
       // Merge the parent schema with the resolved option schema
       const newSchema = { ...parentWithoutChoice, ...resolvedOption };
-      newSchema.properties = {
-        ...parentWithoutChoice.properties,
-        ...resolvedOption.properties,
-      };
+      newSchema.properties = mergePropertySchemas(
+        parentWithoutChoice.properties,
+        resolvedOption.properties,
+      );
 
       let slug;
       const hadId = resolvedOption.$id && resolvedOption.$id.endsWith('.json');