@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.4

package/esm/pipeline/syncPageIndex/createMarkdownNodes.js

@@ -1,5 +1,3 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _extends from "@babel/runtime/helpers/esm/extends";
 /**
  * createMarkdownNodes.ts - Helper functions for creating MD AST nodes
  *
@@ -30,12 +28,10 @@ function normalizeChildren(children) {
   }
 
   // Convert to array if not already
-  var childArray = Array.isArray(children) ? children : [children];
+  const childArray = Array.isArray(children) ? children : [children];
 
   // Convert strings to text nodes
-  return childArray.map(function (child) {
-    return typeof child === 'string' ? text(child) : child;
-  });
+  return childArray.map(child => typeof child === 'string' ? text(child) : child);
 }
 
 /**
@@ -121,8 +117,7 @@ export function inlineCode(value) {
  * @param excludeFormatting - If true, don't count formatting characters like backticks, brackets, etc.
  *                            This allows "`false`" and "false" to both be treated as length 5.
  */
-function getPhrasingContentLength(node) {
-  var excludeFormatting = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+function getPhrasingContentLength(node, excludeFormatting = false) {
   switch (node.type) {
     case 'text':
       return node.value.length;
@@ -131,37 +126,27 @@ function getPhrasingContentLength(node) {
       return node.value.length + (excludeFormatting ? 0 : 2);
     case 'emphasis':
       // Asterisks/underscores add chars, but exclude them if normalizing
-      return (node.children || []).reduce(function (sum, child) {
-        return sum + getPhrasingContentLength(child, excludeFormatting);
-      }, excludeFormatting ? 0 : 2 // *text* or _text_ adds 2 chars
+      return (node.children || []).reduce((sum, child) => sum + getPhrasingContentLength(child, excludeFormatting), excludeFormatting ? 0 : 2 // *text* or _text_ adds 2 chars
       );
     case 'strong':
       // Double asterisks/underscores add chars, but exclude them if normalizing
-      return (node.children || []).reduce(function (sum, child) {
-        return sum + getPhrasingContentLength(child, excludeFormatting);
-      }, excludeFormatting ? 0 : 4 // **text** or __text__ adds 4 chars
+      return (node.children || []).reduce((sum, child) => sum + getPhrasingContentLength(child, excludeFormatting), excludeFormatting ? 0 : 4 // **text** or __text__ adds 4 chars
       );
     case 'delete':
       // Tildes add chars, but exclude them if normalizing
-      return (node.children || []).reduce(function (sum, child) {
-        return sum + getPhrasingContentLength(child, excludeFormatting);
-      }, excludeFormatting ? 0 : 4 // ~~text~~ adds 4 chars
+      return (node.children || []).reduce((sum, child) => sum + getPhrasingContentLength(child, excludeFormatting), excludeFormatting ? 0 : 4 // ~~text~~ adds 4 chars
       );
     case 'link':
       {
-        var _node$url;
         // [text](url) format adds chars, but exclude them if normalizing
-        var childrenLength = (node.children || []).reduce(function (sum, child) {
-          return sum + getPhrasingContentLength(child, excludeFormatting);
-        }, 0);
-        return excludeFormatting ? childrenLength : childrenLength + 4 + (((_node$url = node.url) == null ? void 0 : _node$url.length) || 0); // [](url) adds 4 + url length
+        const childrenLength = (node.children || []).reduce((sum, child) => sum + getPhrasingContentLength(child, excludeFormatting), 0);
+        return excludeFormatting ? childrenLength : childrenLength + 4 + (node.url?.length || 0); // [](url) adds 4 + url length
       }
     case 'image':
       {
-        var _node$url2;
         // ![alt](url) format
-        var altLength = (node.alt || '').length;
-        return excludeFormatting ? altLength : altLength + 5 + (((_node$url2 = node.url) == null ? void 0 : _node$url2.length) || 0); // ![](url) adds 5 + url length
+        const altLength = (node.alt || '').length;
+        return excludeFormatting ? altLength : altLength + 5 + (node.url?.length || 0); // ![](url) adds 5 + url length
       }
     case 'break':
       return 0;
@@ -177,35 +162,33 @@ function getPhrasingContentLength(node) {
  * @param excludeFormatting - If true, don't count formatting chars when calculating width
  * @returns Table cell node
  */
-function tableCell(content, widthIncrements) {
-  var excludeFormatting = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  var children = normalizeChildren(content);
+function tableCell(content, widthIncrements, excludeFormatting = true) {
+  const children = normalizeChildren(content);
   if (widthIncrements) {
     // Calculate total visual length of all content
-    var totalLength = children.reduce(function (sum, child) {
-      return sum + getPhrasingContentLength(child, excludeFormatting);
-    }, 0);
+    const totalLength = children.reduce((sum, child) => sum + getPhrasingContentLength(child, excludeFormatting), 0);
 
     // Calculate padding needed
-    var paddingNeeded = Math.ceil(totalLength / widthIncrements) * widthIncrements - totalLength;
+    const paddingNeeded = Math.ceil(totalLength / widthIncrements) * widthIncrements - totalLength;
 
     // Add padding as trailing spaces to the last text node, or create a new text node
     if (paddingNeeded > 0) {
-      var spaces = new Array(paddingNeeded).fill(' ').join('');
+      const spaces = new Array(paddingNeeded).fill(' ').join('');
 
       // Find the last text node and append spaces (reverse search)
-      var lastTextIndex = -1;
-      for (var i = children.length - 1; i >= 0; i -= 1) {
+      let lastTextIndex = -1;
+      for (let i = children.length - 1; i >= 0; i -= 1) {
         if (children[i].type === 'text') {
           lastTextIndex = i;
           break;
         }
       }
       if (lastTextIndex >= 0) {
-        var lastText = children[lastTextIndex];
-        children[lastTextIndex] = _extends(_extends({}, lastText), {}, {
-          value: "".concat(lastText.value).concat(spaces)
-        });
+        const lastText = children[lastTextIndex];
+        children[lastTextIndex] = {
+          ...lastText,
+          value: `${lastText.value}${spaces}`
+        };
       } else {
         // No text node found, add a new text node with just spaces
         children.push(text(spaces));
@@ -214,7 +197,7 @@ function tableCell(content, widthIncrements) {
   }
   return {
     type: 'tableCell',
-    children: children
+    children
   };
 }
 
@@ -226,9 +209,7 @@ function tableCell(content, widthIncrements) {
 function tableRow(cells, widthIncrements) {
   return {
     type: 'tableRow',
-    children: cells.map(function (cell) {
-      return tableCell(cell, widthIncrements);
-    })
+    children: cells.map(cell => tableCell(cell, widthIncrements))
   };
 }
 
@@ -240,11 +221,9 @@ function tableRow(cells, widthIncrements) {
  * @param {number} [widthIncrements] - Optional value to control the increments that tables expand for cleaner
  * @returns {Object} A table node
  */
-export function table(headers, rows) {
-  var alignment = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-  var widthIncrements = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 7;
+export function table(headers, rows, alignment = null, widthIncrements = 7) {
   // Convert alignment strings to AST format
-  var align = headers.map(function (_, index) {
+  const align = headers.map((_, index) => {
     if (!alignment || !alignment[index]) {
       return null;
     }
@@ -259,18 +238,16 @@ export function table(headers, rows) {
   });
 
   // Create header row
-  var headerRow = tableRow(headers);
+  const headerRow = tableRow(headers);
 
   // Create data rows - rows is actually an array of arrays
-  var dataRows = rows.map(function (row) {
-    return tableRow(row, widthIncrements);
-  });
+  const dataRows = rows.map(row => tableRow(row, widthIncrements));
 
   // Return table node
   return {
     type: 'table',
-    align: align,
-    children: [headerRow].concat(_toConsumableArray(dataRows))
+    align,
+    children: [headerRow, ...dataRows]
   };
 }
 
@@ -298,8 +275,8 @@ export function comment(value, ref) {
 export function link(url, children, title) {
   return {
     type: 'link',
-    url: url,
-    title: title,
+    url,
+    title,
     children: normalizeChildren(children)
   };
 }

package/esm/pipeline/syncPageIndex/mergeMetadataMarkdown.js

@@ -1,10 +1,3 @@
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-var _excluded = ["descriptionMarkdown"];
 import { markdownToMetadata, metadataToMarkdown } from "./metadataToMarkdown.js";
 
 /**
@@ -48,162 +41,116 @@ import { markdownToMetadata, metadataToMarkdown } from "./metadataToMarkdown.js"
  * // Result preserves Button, Checkbox order from existing markdown, adds Input at the end
  * ```
  */
-export function mergeMetadataMarkdown(_x, _x2) {
-  return _mergeMetadataMarkdown.apply(this, arguments);
-}
-function _mergeMetadataMarkdown() {
-  _mergeMetadataMarkdown = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(existingMarkdown, newMetadata) {
-    var options,
-      indexWrapperComponent,
-      path,
-      existingMetadata,
-      effectiveWrapper,
-      newPagesMap,
-      _iterator,
-      _step,
-      page,
-      pages,
-      addedPaths,
-      _iterator2,
-      _step2,
-      existingPage,
-      newPage,
-      descriptionMarkdown,
-      existingPageWithoutDescriptionMarkdown,
-      merged,
-      _iterator3,
-      _step3,
-      _newPage,
-      pageWithTag,
-      alphabeticalSortMarker,
-      requestsAlphabeticalSort,
-      mergedMetadata,
-      _args = arguments;
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
-          indexWrapperComponent = options.indexWrapperComponent, path = options.path; // If no existing markdown, just convert the new metadata
-          // Use the provided wrapper unless it's null (which means remove)
-          if (existingMarkdown) {
-            _context.n = 1;
-            break;
-          }
-          return _context.a(2, metadataToMarkdown(newMetadata, {
-            indexWrapperComponent: indexWrapperComponent === null ? undefined : indexWrapperComponent,
-            path: path
-          }));
-        case 1:
-          _context.n = 2;
-          return markdownToMetadata(existingMarkdown);
-        case 2:
-          existingMetadata = _context.v;
-          if (existingMetadata) {
-            _context.n = 3;
-            break;
-          }
-          return _context.a(2, metadataToMarkdown(newMetadata, {
-            indexWrapperComponent: indexWrapperComponent === null ? undefined : indexWrapperComponent,
-            path: path
-          }));
-        case 3:
-          if (indexWrapperComponent === undefined) {
-            effectiveWrapper = existingMetadata.indexWrapperComponent;
-          } else if (indexWrapperComponent === null) {
-            effectiveWrapper = undefined;
-          } else {
-            effectiveWrapper = indexWrapperComponent;
-          }
+export async function mergeMetadataMarkdown(existingMarkdown, newMetadata, options = {}) {
+  const {
+    indexWrapperComponent,
+    path
+  } = options;
 
-          // Create a map of new pages by path for quick lookup
-          newPagesMap = new Map();
-          _iterator = _createForOfIteratorHelper(newMetadata.pages);
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              page = _step.value;
-              newPagesMap.set(page.path, page);
-            }
+  // If no existing markdown, just convert the new metadata
+  // Use the provided wrapper unless it's null (which means remove)
+  if (!existingMarkdown) {
+    return metadataToMarkdown(newMetadata, {
+      indexWrapperComponent: indexWrapperComponent === null ? undefined : indexWrapperComponent,
+      path
+    });
+  }
 
-            // Build the merged pages array, preserving order from existing markdown
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
-          pages = [];
-          addedPaths = new Set(); // First, add all pages that exist in the existing markdown, in their original order
-          _iterator2 = _createForOfIteratorHelper(existingMetadata.pages);
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              existingPage = _step2.value;
-              newPage = newPagesMap.get(existingPage.path);
-              if (newPage) {
-                // Page exists in both - merge the metadata, preferring new values
-                // Only exclude descriptionMarkdown if newPage provides a new description
-                descriptionMarkdown = existingPage.descriptionMarkdown, existingPageWithoutDescriptionMarkdown = _objectWithoutPropertiesLoose(existingPage, _excluded);
-                merged = _extends(_extends(_extends({}, newPage.description ? existingPageWithoutDescriptionMarkdown : existingPage), newPage), {}, {
-                  // Preserve tags from existing (user-managed, program should never delete tags)
-                  tags: existingPage.tags,
-                  // Preserve skipDetailSection from existing (user-managed for external links)
-                  skipDetailSection: existingPage.skipDetailSection,
-                  // Preserve sections from existing if new doesn't have them
-                  sections: newPage.sections || existingPage.sections
-                });
-                pages.push(merged);
-                addedPaths.add(newPage.path);
-              }
-              // If page doesn't exist in new metadata, it's been removed - don't include it
-            }
+  // Parse the existing markdown to get the current order
+  const existingMetadata = await markdownToMetadata(existingMarkdown);
 
-            // Then, add any new pages that weren't in the existing markdown
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
-          }
-          _iterator3 = _createForOfIteratorHelper(newMetadata.pages);
-          try {
-            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-              _newPage = _step3.value;
-              if (!addedPaths.has(_newPage.path)) {
-                // This is a new page - automatically add the [New] tag
-                pageWithTag = _extends(_extends({}, _newPage), {}, {
-                  tags: _newPage.tags ? [].concat(_toConsumableArray(_newPage.tags), ['New']) : ['New']
-                });
-                pages.push(pageWithTag);
-                addedPaths.add(_newPage.path);
-              }
-            }
+  // If parsing failed, just use the new metadata
+  if (!existingMetadata) {
+    return metadataToMarkdown(newMetadata, {
+      indexWrapperComponent: indexWrapperComponent === null ? undefined : indexWrapperComponent,
+      path
+    });
+  }
 
-            // If alphabetical sorting is requested, sort pages alphabetically by title
-          } catch (err) {
-            _iterator3.e(err);
-          } finally {
-            _iterator3.f();
-          }
-          alphabeticalSortMarker = "[//]: # 'This file is autogenerated, but the following list can be modified. Automatically sorted alphabetically.'";
-          requestsAlphabeticalSort = existingMarkdown.includes(alphabeticalSortMarker);
-          if (requestsAlphabeticalSort) {
-            pages = pages.sort(function (a, b) {
-              var titleA = a.title || a.slug;
-              var titleB = b.title || b.slug;
-              return titleA.localeCompare(titleB);
-            });
-          }
+  // Determine effective wrapper component:
+  // - undefined: preserve existing
+  // - null: explicitly remove
+  // - string: use provided value
+  let effectiveWrapper;
+  if (indexWrapperComponent === undefined) {
+    effectiveWrapper = existingMetadata.indexWrapperComponent;
+  } else if (indexWrapperComponent === null) {
+    effectiveWrapper = undefined;
+  } else {
+    effectiveWrapper = indexWrapperComponent;
+  }
 
-          // Create the final metadata with merged pages
-          mergedMetadata = {
-            title: newMetadata.title,
-            // Always use the new title
-            pages: pages
-          }; // Preserve the alphabetical sorting marker if it was present
-          return _context.a(2, metadataToMarkdown(mergedMetadata, {
-            editableMarker: requestsAlphabeticalSort ? alphabeticalSortMarker : undefined,
-            indexWrapperComponent: effectiveWrapper,
-            path: path
-          }));
-      }
-    }, _callee);
-  }));
-  return _mergeMetadataMarkdown.apply(this, arguments);
+  // Create a map of new pages by path for quick lookup
+  const newPagesMap = new Map();
+  for (const page of newMetadata.pages) {
+    newPagesMap.set(page.path, page);
+  }
+
+  // Build the merged pages array, preserving order from existing markdown
+  let pages = [];
+  const addedPaths = new Set();
+
+  // First, add all pages that exist in the existing markdown, in their original order
+  for (const existingPage of existingMetadata.pages) {
+    const newPage = newPagesMap.get(existingPage.path);
+    if (newPage) {
+      // Page exists in both - merge the metadata, preferring new values
+      // Only exclude descriptionMarkdown if newPage provides a new description
+      const {
+        descriptionMarkdown,
+        ...existingPageWithoutDescriptionMarkdown
+      } = existingPage;
+      const merged = {
+        ...(newPage.description ? existingPageWithoutDescriptionMarkdown : existingPage),
+        ...newPage,
+        // Preserve tags from existing (user-managed, program should never delete tags)
+        tags: existingPage.tags,
+        // Preserve skipDetailSection from existing (user-managed for external links)
+        skipDetailSection: existingPage.skipDetailSection,
+        // Preserve sections from existing if new doesn't have them
+        sections: newPage.sections || existingPage.sections
+      };
+      pages.push(merged);
+      addedPaths.add(newPage.path);
+    }
+    // If page doesn't exist in new metadata, it's been removed - don't include it
+  }
+
+  // Then, add any new pages that weren't in the existing markdown
+  for (const newPage of newMetadata.pages) {
+    if (!addedPaths.has(newPage.path)) {
+      // This is a new page - automatically add the [New] tag
+      const pageWithTag = {
+        ...newPage,
+        tags: newPage.tags ? [...newPage.tags, 'New'] : ['New']
+      };
+      pages.push(pageWithTag);
+      addedPaths.add(newPage.path);
+    }
+  }
+
+  // If alphabetical sorting is requested, sort pages alphabetically by title
+  const alphabeticalSortMarker = "[//]: # 'This file is autogenerated, but the following list can be modified. Automatically sorted alphabetically.'";
+  const requestsAlphabeticalSort = existingMarkdown.includes(alphabeticalSortMarker);
+  if (requestsAlphabeticalSort) {
+    pages = pages.sort((a, b) => {
+      const titleA = a.title || a.slug;
+      const titleB = b.title || b.slug;
+      return titleA.localeCompare(titleB);
+    });
+  }
+
+  // Create the final metadata with merged pages
+  const mergedMetadata = {
+    title: newMetadata.title,
+    // Always use the new title
+    pages
+  };
+
+  // Preserve the alphabetical sorting marker if it was present
+  return metadataToMarkdown(mergedMetadata, {
+    editableMarker: requestsAlphabeticalSort ? alphabeticalSortMarker : undefined,
+    indexWrapperComponent: effectiveWrapper,
+    path
+  });
 }