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

package/esm/pipeline/loadCodeVariant/diffHast.js

@@ -1,60 +1,25 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { create, patch } from 'jsondiffpatch';
-var differ = create({
+const differ = create({
   omitRemovedValues: true,
   cloneDiffValues: true
 });
-export function diffHast(_x, _x2, _x3, _x4, _x5) {
-  return _diffHast.apply(this, arguments);
-}
-function _diffHast() {
-  _diffHast = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source, parsedSource, filename, transforms, parseSource) {
-    var transformed;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.n) {
-        case 0:
-          _context2.n = 1;
-          return Promise.all(Object.entries(transforms).map(/*#__PURE__*/function () {
-            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
-              var _ref3, key, transform, patched, transformedSource, parsedTransform, delta;
-              return _regenerator().w(function (_context) {
-                while (1) switch (_context.n) {
-                  case 0:
-                    _ref3 = _slicedToArray(_ref, 2), key = _ref3[0], transform = _ref3[1];
-                    patched = patch(source.split('\n'), transform.delta);
-                    if (Array.isArray(patched)) {
-                      _context.n = 1;
-                      break;
-                    }
-                    throw new Error("Patch for ".concat(key, " did not return an array"));
-                  case 1:
-                    transformedSource = patched.join('\n');
-                    _context.n = 2;
-                    return parseSource(transformedSource, transform.fileName || filename);
-                  case 2:
-                    parsedTransform = _context.v;
-                    // TODO: further optimize this delta, it looks a little noisy
-                    delta = differ.diff(parsedSource, parsedTransform);
-                    return _context.a(2, _defineProperty({}, key, _extends(_extends({}, transform), {}, {
-                      delta: delta
-                    })));
-                }
-              }, _callee);
-            }));
-            return function (_x6) {
-              return _ref2.apply(this, arguments);
-            };
-          }()));
-        case 1:
-          transformed = _context2.v;
-          return _context2.a(2, Object.assign.apply(Object, [{}].concat(_toConsumableArray(transformed))));
+export async function diffHast(source, parsedSource, filename, transforms, parseSource) {
+  const transformed = await Promise.all(Object.entries(transforms).map(async ([key, transform]) => {
+    const patched = patch(source.split('\n'), transform.delta);
+    if (!Array.isArray(patched)) {
+      throw new Error(`Patch for ${key} did not return an array`);
+    }
+    const transformedSource = patched.join('\n');
+    const parsedTransform = await parseSource(transformedSource, transform.fileName || filename);
+
+    // TODO: further optimize this delta, it looks a little noisy
+    const delta = differ.diff(parsedSource, parsedTransform);
+    return {
+      [key]: {
+        ...transform,
+        delta
       }
-    }, _callee2);
+    };
   }));
-  return _diffHast.apply(this, arguments);
+  return Object.assign({}, ...transformed);
 }

package/esm/pipeline/loadCodeVariant/examineCodeVariant.js

@@ -1,4 +1,3 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 /**
  * Variant examination utility for analyzing variant structure and paths
  */
@@ -8,38 +7,36 @@ import { getUrlParts, calculateMaxSourceBackNavigation } from "./pathUtils.js";
  * Create path context for processing files with extended information
  */
 export function examineCodeVariant(variant) {
-  var hasMetadata = variant.extraFiles ? Object.values(variant.extraFiles).some(function (file) {
-    return _typeof(file) === 'object' && file.metadata;
-  }) : false;
+  const hasMetadata = variant.extraFiles ? Object.values(variant.extraFiles).some(file => typeof file === 'object' && file.metadata) : false;
 
   // Calculate maxSourceBackNavigation based only on extraFiles structure
-  var maxSourceBackNavigation = variant.extraFiles ? calculateMaxSourceBackNavigation(variant.extraFiles) : 0;
+  const maxSourceBackNavigation = variant.extraFiles ? calculateMaxSourceBackNavigation(variant.extraFiles) : 0;
 
   // Parse URL to determine path structure
-  var urlDirectory = [];
-  var rootLevel = '';
-  var pathInwardFromRoot = '';
+  let urlDirectory = [];
+  let rootLevel = '';
+  let pathInwardFromRoot = '';
   if (variant.url && variant.url.includes('://')) {
     try {
-      var pathComponents = getUrlParts(variant.url);
+      const pathComponents = getUrlParts(variant.url);
       if (pathComponents.length > 0) {
         // Check if the last component looks like a filename (has an extension)
-        var lastComponent = pathComponents[pathComponents.length - 1];
-        var hasFileExtension = lastComponent.includes('.') && /\.[a-zA-Z0-9]+$/.test(lastComponent);
+        const lastComponent = pathComponents[pathComponents.length - 1];
+        const hasFileExtension = lastComponent.includes('.') && /\.[a-zA-Z0-9]+$/.test(lastComponent);
 
         // If it has a file extension, exclude it from directory components
-        var directoryComponents = hasFileExtension ? pathComponents.slice(0, -1) : pathComponents;
+        const directoryComponents = hasFileExtension ? pathComponents.slice(0, -1) : pathComponents;
         urlDirectory = directoryComponents;
         rootLevel = directoryComponents[0] || '';
 
         // Only calculate pathInwardFromRoot if there's actual back navigation
         if (maxSourceBackNavigation > 0 && directoryComponents.length >= maxSourceBackNavigation) {
           // Take the last maxSourceBackNavigation components as the pathInwardFromRoot
-          var relevantComponents = directoryComponents.slice(-maxSourceBackNavigation);
+          const relevantComponents = directoryComponents.slice(-maxSourceBackNavigation);
           pathInwardFromRoot = relevantComponents.join('/');
         }
       }
-    } catch (_unused) {
+    } catch {
       // If URL parsing fails, keep defaults
       urlDirectory = [];
       rootLevel = '';
@@ -48,26 +45,26 @@ export function examineCodeVariant(variant) {
   }
 
   // We keep the URL info for compatibility, but don't use it for calculations
-  var hasUrl = Boolean(variant.url);
-  var actualUrl = variant.url;
+  const hasUrl = Boolean(variant.url);
+  const actualUrl = variant.url;
   if (hasUrl && actualUrl) {
     return {
       hasUrl: true,
-      hasMetadata: hasMetadata,
-      maxSourceBackNavigation: maxSourceBackNavigation,
-      urlDirectory: urlDirectory,
-      rootLevel: rootLevel,
-      pathInwardFromRoot: pathInwardFromRoot,
-      actualUrl: actualUrl
+      hasMetadata,
+      maxSourceBackNavigation,
+      urlDirectory,
+      rootLevel,
+      pathInwardFromRoot,
+      actualUrl
     };
   }
   return {
     hasUrl: false,
-    hasMetadata: hasMetadata,
-    maxSourceBackNavigation: maxSourceBackNavigation,
-    urlDirectory: urlDirectory,
-    rootLevel: rootLevel,
-    pathInwardFromRoot: pathInwardFromRoot,
+    hasMetadata,
+    maxSourceBackNavigation,
+    urlDirectory,
+    rootLevel,
+    pathInwardFromRoot,
     actualUrl: undefined
   };
 }

package/esm/pipeline/loadCodeVariant/flattenCodeVariant.js

@@ -1,4 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
 /**
  * Flatten variant utility to convert a VariantCode into a flat files list
  * Handles relative path resolution and metadata file scoping
@@ -13,10 +12,10 @@ import { addPathsToVariant } from "./addCodeVariantPaths.js";
  * Uses addPathsToVariant for path resolution logic
  */
 export function flattenCodeVariant(variant) {
-  var result = {};
+  const result = {};
 
   // Use addPathsToVariant to get the structured paths
-  var variantWithPaths = addPathsToVariant(variant);
+  const variantWithPaths = addPathsToVariant(variant);
 
   // Add main file if it exists
   if (variantWithPaths.path && variantWithPaths.source !== undefined) {
@@ -27,8 +26,7 @@ export function flattenCodeVariant(variant) {
 
   // Add extra files if they exist
   if (variantWithPaths.extraFiles) {
-    for (var _i = 0, _Object$values = Object.values(variantWithPaths.extraFiles); _i < _Object$values.length; _i++) {
-      var fileWithPath = _Object$values[_i];
+    for (const fileWithPath of Object.values(variantWithPaths.extraFiles)) {
       // Skip files that are just URLs or missing a path
       if (typeof fileWithPath === 'string' || !fileWithPath.path) {
         continue;
@@ -38,11 +36,12 @@ export function flattenCodeVariant(variant) {
       if (!fileWithPath.source && fileWithPath.source !== '') {
         continue;
       }
-      result[fileWithPath.path] = _extends({
-        source: stringOrHastToString(fileWithPath.source || '')
-      }, fileWithPath.metadata && {
-        metadata: fileWithPath.metadata
-      });
+      result[fileWithPath.path] = {
+        source: stringOrHastToString(fileWithPath.source || ''),
+        ...(fileWithPath.metadata && {
+          metadata: fileWithPath.metadata
+        })
+      };
     }
   }
   return result;

package/esm/pipeline/loadCodeVariant/hasAllCodeVariants.js

@@ -43,17 +43,17 @@ function isSourceLoaded(code, needsHighlight) {
  * ```
  */
 export function hasAllVariants(variants, code, needsHighlight) {
-  return variants.every(function (variant) {
-    var codeVariant = code == null ? void 0 : code[variant];
+  return variants.every(variant => {
+    const codeVariant = code?.[variant];
     if (!codeVariant || typeof codeVariant === 'string' || !isSourceLoaded(codeVariant, needsHighlight)) {
       return false;
     }
-    var extraFiles = codeVariant.extraFiles;
+    const extraFiles = codeVariant.extraFiles;
     if (!extraFiles) {
       return true;
     }
-    return Object.keys(extraFiles).every(function (file) {
-      var extraFile = extraFiles[file];
+    return Object.keys(extraFiles).every(file => {
+      const extraFile = extraFiles[file];
       if (!extraFile || typeof extraFile === 'string' || !isSourceLoaded(extraFile, needsHighlight)) {
         return false;
       }