@mui/internal-docs-infra 0.12.1-canary.30 → 0.12.1-canary.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-docs-infra",
-  "version": "0.12.1-canary.30",
+  "version": "0.12.1-canary.32",
   "author": "MUI Team",
   "description": "MUI Infra - internal documentation creation tools.",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "@orama/stopwords": "^3.1.18",
     "@wooorm/starry-night": "^3.10.0",
     "autoprefixer": "^10.5.4",
-    "chalk": "^5.6.2",
+    "chalk": "^6.0.0",
     "clipboard-copy": "^4.0.1",
     "es-toolkit": "^1.49.0",
     "fflate": "^0.8.3",
@@ -804,5 +804,5 @@
   "bin": {
     "docs-infra": "./cli/index.mjs"
   },
-  "gitSha": "572e3cf0688164ad834cee4c5d64d91d2bce1d68"
+  "gitSha": "14edbfe69366e1a1e506acaf77d33186d6e4090c"
 }

package/pipeline/loadServerTypesText/parseTypesMarkdown.mjs

@@ -76,6 +76,16 @@ function extractInlineCodeOrText(node) {
   return '';
 }
 
+/** Extract inline-code values from mdast phrasing content. */
+function extractInlineCodeValues(nodes) {
+  return nodes.flatMap(node => {
+    if (node.type === 'inlineCode') {
+      return node.value;
+    }
+    return 'children' in node ? extractInlineCodeValues(node.children) : [];
+  });
+}
+
 /**
  * A target for batch HAST conversion: a setter to assign the result and the mdast nodes to convert.
  */
@@ -533,6 +543,9 @@ export async function parseTypesMarkdown(content, ordering) {
   const allTypes = [];
   const descriptionTargets = [];
   const externalTypes = {};
+  const parsedVariantTypes = {};
+  const typeNameMap = {};
+  const parsedVariantTypeNameMapKeys = {};
 
   // Track current context
   let currentH3Name = null;
@@ -553,6 +566,7 @@ export async function parseTypesMarkdown(content, ordering) {
   let lastParamExampleName = null;
   let lastPropReferencesName = null;
   let lastParamReferencesName = null;
+  let metadataSection = null;
 
   // Helper to flush the current section
   const flushSection = () => {
@@ -697,6 +711,12 @@ export async function parseTypesMarkdown(content, ordering) {
     if (node.type === 'heading' && node.depth === 2) {
       flushSection();
       const text = extractText(node.children);
+      metadataSection = null;
+      if (text === 'Export Groups') {
+        metadataSection = 'export-groups';
+      } else if (text === 'Canonical Types') {
+        metadataSection = 'canonical-types';
+      }
       if (text === 'External Types') {
         inExternalTypes = true;
       } else if (text === 'Additional Types') {
@@ -712,6 +732,7 @@ export async function parseTypesMarkdown(content, ordering) {
     if (node.type === 'heading' && node.depth === 3) {
       flushSection();
       inExternalTypes = false;
+      metadataSection = null;
       currentH3Name = extractText(node.children);
       continue;
     }
@@ -722,6 +743,36 @@ export async function parseTypesMarkdown(content, ordering) {
       continue;
     }
 
+    // Handle generated metadata lists
+    if (node.type === 'list' && metadataSection) {
+      for (const item of node.children) {
+        const children = item.children.flatMap(child => child.type === 'paragraph' ? child.children : []);
+        const separatorIndex = children.findIndex(child => child.type === 'text' && child.value.includes(':'));
+        const namesBeforeSeparator = extractInlineCodeValues(children.slice(0, separatorIndex === -1 ? children.length : separatorIndex));
+        const namesAfterSeparator = separatorIndex === -1 ? [] : extractInlineCodeValues(children.slice(separatorIndex + 1));
+        if (metadataSection === 'export-groups') {
+          const variantName = namesBeforeSeparator[0];
+          if (variantName) {
+            parsedVariantTypes[variantName] = separatorIndex === -1 ? [variantName] : namesAfterSeparator;
+          }
+        } else {
+          const [canonicalName, ...variants] = namesBeforeSeparator;
+          if (!canonicalName || separatorIndex === -1) {
+            continue;
+          }
+          for (const flatName of namesAfterSeparator) {
+            typeNameMap[flatName] = canonicalName;
+          }
+          for (const variant of variants) {
+            const keys = parsedVariantTypeNameMapKeys[variant] ?? [];
+            keys.push(...namesAfterSeparator);
+            parsedVariantTypeNameMapKeys[variant] = keys;
+          }
+        }
+      }
+      continue;
+    }
+
     // Handle code blocks
     if (node.type === 'code') {
       if (inExternalTypes && currentExternalTypeName) {
@@ -833,97 +884,8 @@ export async function parseTypesMarkdown(content, ordering) {
 
   // Flush the last section
   flushSection();
-
-  // Parse metadata from human-readable sections instead of JSON comments
-  // The new format uses "## Export Groups" and "## Canonical Types" sections
-
-  // Parse Export Groups section
-  // Format: - `VariantName`: `Type1`, `Type2` (or just `- VariantName` if key equals single value)
-  let variantTypes = null;
-  const exportGroupsMatch = content.match(/## Export Groups\n([\s\S]*?)(?=\n## |$)/);
-  if (exportGroupsMatch) {
-    variantTypes = {};
-    const lines = exportGroupsMatch[1].trim().split('\n');
-    for (const line of lines) {
-      // Match: - `VariantName`: `Type1`, `Type2` OR - `VariantName`
-      const withValuesMatch = line.match(/^- `([^`]+)`:\s*(.+)$/);
-      const singleMatch = line.match(/^- `([^`]+)`$/);
-      if (withValuesMatch) {
-        const variantName = withValuesMatch[1];
-        // Extract all backtick-wrapped values
-        const values = withValuesMatch[2].match(/`([^`]+)`/g);
-        variantTypes[variantName] = values ? values.map(v => v.slice(1, -1)) : [];
-      } else if (singleMatch) {
-        // Key equals value - the variant name IS the single type
-        const variantName = singleMatch[1];
-        variantTypes[variantName] = [variantName];
-      }
-    }
-    // Only keep variantTypes if we found entries
-    if (Object.keys(variantTypes).length === 0) {
-      variantTypes = null;
-    }
-  }
-
-  // Parse Canonical Types section
-  // Format: - `CanonicalName` (`Variant1`, `Variant2`): `FlatName1`, `FlatName2`
-  // OR:     - `CanonicalName`: `FlatName1`, `FlatName2` (no variant annotation)
-  const typeNameMap = {};
-  let variantTypeNameMapKeys = null;
-  const canonicalTypesMatch = content.match(/## Canonical Types\n([\s\S]*?)(?=\n## |$)/);
-  if (canonicalTypesMatch) {
-    variantTypeNameMapKeys = {};
-    const lines = canonicalTypesMatch[1].trim().split('\n');
-    for (const line of lines) {
-      // Match: - `CanonicalName` (`Variant1`, `Variant2`): `FlatName1`, `FlatName2`
-      // OR:    - `CanonicalName`: `FlatName1`, `FlatName2`
-      const withVariantMatch = line.match(/^- `([^`]+)`\s+\(([^)]+)\):\s*(.+)$/);
-      const withoutVariantMatch = line.match(/^- `([^`]+)`:\s*(.+)$/);
-      let canonicalName;
-      let flatNamesStr;
-      let variants = [];
-      if (withVariantMatch) {
-        canonicalName = withVariantMatch[1];
-        // Extract variants from parentheses
-        const variantStr = withVariantMatch[2];
-        const variantMatches = variantStr.match(/`([^`]+)`/g);
-        variants = variantMatches ? variantMatches.map(v => v.slice(1, -1)) : [];
-        flatNamesStr = withVariantMatch[3];
-      } else if (withoutVariantMatch) {
-        canonicalName = withoutVariantMatch[1];
-        flatNamesStr = withoutVariantMatch[2];
-        // No variant annotation - applies to all variants
-      } else {
-        continue;
-      }
-
-      // Extract all flat names
-      const flatNameMatches = flatNamesStr.match(/`([^`]+)`/g);
-      const flatNames = flatNameMatches ? flatNameMatches.map(v => v.slice(1, -1)) : [];
-
-      // Build typeNameMap (flat name -> canonical name)
-      for (const flatName of flatNames) {
-        typeNameMap[flatName] = canonicalName;
-      }
-
-      // Build variantTypeNameMapKeys (variant -> list of keys)
-      // If no variants specified, we don't track variant-specific keys
-      if (variants.length > 0) {
-        for (const variant of variants) {
-          if (!variantTypeNameMapKeys[variant]) {
-            variantTypeNameMapKeys[variant] = [];
-          }
-          for (const flatName of flatNames) {
-            variantTypeNameMapKeys[variant].push(flatName);
-          }
-        }
-      }
-    }
-    // Only keep variantTypeNameMapKeys if we found entries
-    if (Object.keys(variantTypeNameMapKeys).length === 0) {
-      variantTypeNameMapKeys = null;
-    }
-  }
+  const variantTypes = Object.keys(parsedVariantTypes).length > 0 ? parsedVariantTypes : null;
+  const variantTypeNameMapKeys = Object.keys(parsedVariantTypeNameMapKeys).length > 0 ? parsedVariantTypeNameMapKeys : null;
 
   // Convert all description mdast nodes to HAST in parallel
   await convertDescriptions(descriptionTargets);