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

package/esm/pipeline/loadCodeVariant/transformSource.js

@@ -1,18 +1,14 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { create } from 'jsondiffpatch';
 import { toText } from 'hast-util-to-text';
 import { decompress, strFromU8 } from 'fflate';
 import { decode } from 'uint8-to-base64';
-var differ = create({
+const differ = create({
   omitRemovedValues: true,
   cloneDiffValues: true
 });
-function decompressAsync(input) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return new Promise(function (resolve, reject) {
-    decompress(input, options, function (err, output) {
+function decompressAsync(input, options = {}) {
+  return new Promise((resolve, reject) => {
+    decompress(input, options, (err, output) => {
       if (err) {
         reject(err);
       } else {
@@ -21,123 +17,57 @@ function decompressAsync(input) {
     });
   });
 }
-export function transformSource(_x, _x2, _x3) {
-  return _transformSource.apply(this, arguments);
-}
-function _transformSource() {
-  _transformSource = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source, fileName, sourceTransformers) {
-    var transforms;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.n) {
-        case 0:
-          _context2.n = 1;
-          return Promise.all(sourceTransformers.map(/*#__PURE__*/function () {
-            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
-              var extensions, transformer, sourceString, decompressed, transformed, splitSource, _t, _t2;
-              return _regenerator().w(function (_context) {
-                while (1) switch (_context.p = _context.n) {
-                  case 0:
-                    extensions = _ref.extensions, transformer = _ref.transformer;
-                    if (extensions.some(function (ext) {
-                      return fileName.endsWith(".".concat(ext));
-                    })) {
-                      _context.n = 1;
-                      break;
-                    }
-                    return _context.a(2, undefined);
-                  case 1:
-                    _context.p = 1;
-                    if (!(typeof source === 'string')) {
-                      _context.n = 2;
-                      break;
-                    }
-                    sourceString = source;
-                    _context.n = 6;
-                    break;
-                  case 2:
-                    if (!('hastJson' in source)) {
-                      _context.n = 3;
-                      break;
-                    }
-                    sourceString = toText(JSON.parse(source.hastJson));
-                    _context.n = 6;
-                    break;
-                  case 3:
-                    if (!('hastGzip' in source)) {
-                      _context.n = 5;
-                      break;
-                    }
-                    _t = strFromU8;
-                    _context.n = 4;
-                    return decompressAsync(decode(source.hastGzip), {
-                      consume: true
-                    });
-                  case 4:
-                    decompressed = _t(_context.v);
-                    sourceString = toText(JSON.parse(decompressed));
-                    _context.n = 6;
-                    break;
-                  case 5:
-                    sourceString = toText(source);
-                  case 6:
-                    _context.n = 7;
-                    return transformer(sourceString, fileName);
-                  case 7:
-                    transformed = _context.v;
-                    if (!transformed) {
-                      _context.n = 8;
-                      break;
-                    }
-                    splitSource = sourceString.split('\n');
-                    return _context.a(2, Object.keys(transformed).reduce(function (acc, key) {
-                      var delta = differ.diff(splitSource, transformed[key].source.split('\n'));
-                      acc[key] = {
-                        delta: delta,
-                        fileName: transformed[key].fileName
-                      };
-                      return acc;
-                    }, {}));
-                  case 8:
-                    return _context.a(2, undefined);
-                  case 9:
-                    _context.p = 9;
-                    _t2 = _context.v;
-                    throw new Error("Failed to transform source code (file: ".concat(fileName, "): ").concat(_t2 instanceof Error && _t2.message));
-                  case 10:
-                    return _context.a(2);
-                }
-              }, _callee, null, [[1, 9]]);
-            }));
-            return function (_x4) {
-              return _ref2.apply(this, arguments);
-            };
-          }()));
-        case 1:
-          transforms = _context2.v;
-          if (!(transforms.length === 0 || transforms.every(function (t) {
-            return t === undefined;
-          }))) {
-            _context2.n = 2;
-            break;
-          }
-          return _context2.a(2, undefined);
-        case 2:
-          return _context2.a(2, transforms.reduce(function (acc, transform) {
-            if (transform) {
-              Object.entries(transform).forEach(function (_ref3) {
-                var _ref4 = _slicedToArray(_ref3, 2),
-                  key = _ref4[0],
-                  value = _ref4[1];
-                if (acc[key]) {
-                  throw new Error("Duplicate key found in source transformations: ".concat(key));
-                }
-                acc[key] = value;
-              });
-            }
-            return acc;
-          }, {}));
+export async function transformSource(source, fileName, sourceTransformers) {
+  const transforms = await Promise.all(sourceTransformers.map(async ({
+    extensions,
+    transformer
+  }) => {
+    if (!extensions.some(ext => fileName.endsWith(`.${ext}`))) {
+      return undefined;
+    }
+    try {
+      let sourceString;
+      if (typeof source === 'string') {
+        sourceString = source;
+      } else if ('hastJson' in source) {
+        sourceString = toText(JSON.parse(source.hastJson));
+      } else if ('hastGzip' in source) {
+        const decompressed = strFromU8(await decompressAsync(decode(source.hastGzip), {
+          consume: true
+        }));
+        sourceString = toText(JSON.parse(decompressed));
+      } else {
+        sourceString = toText(source);
+      }
+      const transformed = await transformer(sourceString, fileName);
+      if (transformed) {
+        const splitSource = sourceString.split('\n');
+        return Object.keys(transformed).reduce((acc, key) => {
+          const delta = differ.diff(splitSource, transformed[key].source.split('\n'));
+          acc[key] = {
+            delta,
+            fileName: transformed[key].fileName
+          };
+          return acc;
+        }, {});
       }
-    }, _callee2);
+      return undefined;
+    } catch (error) {
+      throw new Error(`Failed to transform source code (file: ${fileName}): ${error instanceof Error && error.message}`);
+    }
   }));
-  return _transformSource.apply(this, arguments);
+  if (transforms.length === 0 || transforms.every(t => t === undefined)) {
+    return undefined;
+  }
+  return transforms.reduce((acc, transform) => {
+    if (transform) {
+      Object.entries(transform).forEach(([key, value]) => {
+        if (acc[key]) {
+          throw new Error(`Duplicate key found in source transformations: ${key}`);
+        }
+        acc[key] = value;
+      });
+    }
+    return acc;
+  }, {});
 }

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.js

@@ -1,7 +1,3 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 // webpack does not like node: imports
 // eslint-disable-next-line n/prefer-node-protocol
 import path from 'path';
@@ -18,7 +14,7 @@ import { replacePrecomputeValue } from "./replacePrecomputeValue.js";
 import { createLoadServerSource } from "../loadServerSource/index.js";
 import { getFileNameFromUrl } from "../loaderUtils/index.js";
 import { createPerformanceLogger, logPerformance, performanceMeasure } from "./performanceLogger.js";
-var functionName = 'Load Precomputed Code Highlighter';
+const functionName = 'Load Precomputed Code Highlighter';
 
 /**
  * Webpack loader that processes demo files and precomputes variant data.
@@ -31,227 +27,170 @@ var functionName = 'Load Precomputed Code Highlighter';
  *
  * Automatically skips processing if skipPrecompute: true is set.
  */
-export function loadPrecomputedCodeHighlighter(_x) {
-  return _loadPrecomputedCodeHighlighter.apply(this, arguments);
-}
-function _loadPrecomputedCodeHighlighter() {
-  _loadPrecomputedCodeHighlighter = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source) {
-    var _options$performance$,
-      _options$performance,
-      _options$performance$2,
-      _options$performance2,
-      _options$performance3,
-      _this = this;
-    var callback, options, performanceNotableMs, performanceShowWrapperMeasures, relativePath, observer, currentMark, resourceFileUrl, _observer, _observer2, demoCall, variantData, allDependencies, resolvedVariantMap, loadSource, sourceTransformers, sourceParser, functionsInitMark, variantPromises, variantResults, _iterator, _step, result, modifiedSource, _observer3, _observer4, _t2;
-    return _regenerator().w(function (_context2) {
-      while (1) switch (_context2.p = _context2.n) {
-        case 0:
-          callback = this.async();
-          this.cacheable();
-          options = this.getOptions();
-          performanceNotableMs = (_options$performance$ = (_options$performance = options.performance) == null ? void 0 : _options$performance.notableMs) != null ? _options$performance$ : 100;
-          performanceShowWrapperMeasures = (_options$performance$2 = (_options$performance2 = options.performance) == null ? void 0 : _options$performance2.showWrapperMeasures) != null ? _options$performance$2 : false;
-          relativePath = path.relative(this.rootContext || process.cwd(), this.resourcePath);
-          observer = undefined;
-          if ((_options$performance3 = options.performance) != null && _options$performance3.logging) {
-            observer = new PerformanceObserver(createPerformanceLogger(performanceNotableMs, performanceShowWrapperMeasures, relativePath));
-            observer.observe({
-              entryTypes: ['measure']
-            });
-          }
-          currentMark = performanceMeasure(undefined, {
-            mark: 'Start',
-            measure: 'Start'
-          }, [functionName, relativePath], true); // Convert the filesystem path to a file:// URL for cross-platform compatibility
-          // pathToFileURL handles Windows drive letters correctly (e.g., C:\... → file:///C:/...)
-          resourceFileUrl = pathToFileURL(this.resourcePath).toString();
-          _context2.p = 1;
-          _context2.n = 2;
-          return parseCreateFactoryCall(source, resourceFileUrl);
-        case 2:
-          demoCall = _context2.v;
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Parsed Factory',
-            measure: 'Factory Parsing'
-          }, [functionName, relativePath]);
+export async function loadPrecomputedCodeHighlighter(source) {
+  const callback = this.async();
+  this.cacheable();
+  const options = this.getOptions();
+  const performanceNotableMs = options.performance?.notableMs ?? 100;
+  const performanceShowWrapperMeasures = options.performance?.showWrapperMeasures ?? false;
+  const relativePath = path.relative(this.rootContext || process.cwd(), this.resourcePath);
+  let observer = undefined;
+  if (options.performance?.logging) {
+    observer = new PerformanceObserver(createPerformanceLogger(performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+    observer.observe({
+      entryTypes: ['measure']
+    });
+  }
+  let currentMark = performanceMeasure(undefined, {
+    mark: 'Start',
+    measure: 'Start'
+  }, [functionName, relativePath], true);
 
-          // If no createDemo call found, return the source unchanged
-          if (demoCall) {
-            _context2.n = 3;
-            break;
-          }
-          callback(null, source);
-          return _context2.a(2);
-        case 3:
-          if (!demoCall.options.skipPrecompute) {
-            _context2.n = 4;
-            break;
-          }
-          callback(null, source);
-          return _context2.a(2);
-        case 4:
-          // Load variant data for all variants
-          variantData = {};
-          allDependencies = []; // Resolve all variant entry point paths using resolveVariantPathsWithFs
-          _context2.n = 5;
-          return resolveVariantPathsWithFs(demoCall.variants || {});
-        case 5:
-          resolvedVariantMap = _context2.v;
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Paths Resolved',
-            measure: 'Path Resolution'
-          }, [functionName, relativePath]);
+  // Convert the filesystem path to a file:// URL for cross-platform compatibility
+  // pathToFileURL handles Windows drive letters correctly (e.g., C:\... → file:///C:/...)
+  const resourceFileUrl = pathToFileURL(this.resourcePath).toString();
+  try {
+    // Parse the source to find a single createDemo call
+    const demoCall = await parseCreateFactoryCall(source, resourceFileUrl);
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Parsed Factory',
+      measure: 'Factory Parsing'
+    }, [functionName, relativePath]);
 
-          // Create loader functions
-          loadSource = createLoadServerSource({
-            includeDependencies: true,
-            storeAt: 'flat' // TODO: this should be configurable
-          }); // Setup source transformers for TypeScript to JavaScript conversion
-          // const sourceTransformers: SourceTransformers = [TypescriptToJavascriptTransformer];
-          // TODO: maybe we should have `loadPrecomputedCodeHighlighterWithJsToTs`
-          sourceTransformers = []; // Create sourceParser promise for syntax highlighting
-          sourceParser = createParseSource();
-          functionsInitMark = performanceMeasure(currentMark, {
-            mark: 'Functions Init',
-            measure: 'Functions Init'
-          }, [functionName, relativePath]);
-          currentMark = functionsInitMark;
+    // If no createDemo call found, return the source unchanged
+    if (!demoCall) {
+      callback(null, source);
+      return;
+    }
 
-          // Process variants in parallel
-          variantPromises = Array.from(resolvedVariantMap.entries()).map(/*#__PURE__*/function () {
-            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
-              var _demoCall$namedExport;
-              var _ref3, variantName, fileUrl, variantMark, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadCodeVarian, processedVariant, dependencies, _t;
-              return _regenerator().w(function (_context) {
-                while (1) switch (_context.p = _context.n) {
-                  case 0:
-                    _ref3 = _slicedToArray(_ref, 2), variantName = _ref3[0], fileUrl = _ref3[1];
-                    variantMark = performanceMeasure(functionsInitMark, {
-                      mark: 'Variant Started',
-                      measure: 'Variant Start'
-                    }, [functionName, variantName, relativePath], true);
-                    namedExport = (_demoCall$namedExport = demoCall.namedExports) == null ? void 0 : _demoCall$namedExport[variantName];
-                    variant = fileUrl;
-                    if (!namedExport) {
-                      _context.n = 2;
-                      break;
-                    }
-                    _getFileNameFromUrl = getFileNameFromUrl(variant), fileName = _getFileNameFromUrl.fileName;
-                    if (fileName) {
-                      _context.n = 1;
-                      break;
-                    }
-                    throw new Error("Cannot determine fileName from URL \"".concat(variant, "\" for variant \"").concat(variantName, "\". ") + "Please ensure the URL has a valid file extension.");
-                  case 1:
-                    variant = {
-                      url: fileUrl,
-                      fileName: fileName,
-                      namedExport: namedExport
-                    };
-                  case 2:
-                    _context.p = 2;
-                    _context.n = 3;
-                    return loadCodeVariant(fileUrl,
-                    // URL for the variant entry point (already includes file://)
-                    variantName, variant, {
-                      sourceParser: sourceParser,
-                      // For syntax highlighting
-                      loadSource: loadSource,
-                      // For loading source files and dependencies
-                      loadVariantMeta: undefined,
-                      sourceTransformers: sourceTransformers,
-                      // For TypeScript to JavaScript conversion
-                      maxDepth: 5,
-                      output: _this.getOptions().output || 'hastGzip'
-                    });
-                  case 3:
-                    _yield$loadCodeVarian = _context.v;
-                    processedVariant = _yield$loadCodeVarian.code;
-                    dependencies = _yield$loadCodeVarian.dependencies;
-                    performanceMeasure(variantMark, {
-                      mark: 'Variant Loaded',
-                      measure: 'Variant Loading'
-                    }, [functionName, variantName, relativePath], true);
-                    return _context.a(2, {
-                      variantName: variantName,
-                      variantData: processedVariant,
-                      // processedVariant is a complete VariantCode
-                      dependencies: dependencies // All files that were loaded
-                    });
-                  case 4:
-                    _context.p = 4;
-                    _t = _context.v;
-                    throw new Error("Failed to load variant ".concat(variantName, " from ").concat(fileUrl, ": ").concat(_t));
-                  case 5:
-                    return _context.a(2);
-                }
-              }, _callee, null, [[2, 4]]);
-            }));
-            return function (_x2) {
-              return _ref2.apply(this, arguments);
-            };
-          }());
-          _context2.n = 6;
-          return Promise.all(variantPromises);
-        case 6:
-          variantResults = _context2.v;
-          // Process results and collect dependencies
-          _iterator = _createForOfIteratorHelper(variantResults);
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              result = _step.value;
-              if (result) {
-                variantData[result.variantName] = result.variantData;
-                result.dependencies.forEach(function (file) {
-                  allDependencies.push(file);
-                });
-              }
-            }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
-          currentMark = performanceMeasure(functionsInitMark, {
-            mark: 'All Variants Loaded',
-            measure: 'Complete Variants Loading'
-          }, [functionName, relativePath], true);
+    // If skipPrecompute is true, return the source unchanged
+    if (demoCall.options.skipPrecompute) {
+      callback(null, source);
+      return;
+    }
 
-          // Replace the factory function call with the actual precomputed data
-          modifiedSource = replacePrecomputeValue(source, variantData, demoCall);
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Replaced Precompute',
-            measure: 'Precompute Replacement'
-          }, [functionName, relativePath]);
+    // Load variant data for all variants
+    const variantData = {};
+    const allDependencies = [];
 
-          // Add all dependencies to webpack's watch list
-          allDependencies.forEach(function (dep) {
-            // Convert file:// URLs to proper file system paths for webpack's dependency tracking
-            // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
-            _this.addDependency(dep.startsWith('file://') ? fileURLToPath(dep) : dep);
-          });
+    // Resolve all variant entry point paths using resolveVariantPathsWithFs
+    const resolvedVariantMap = await resolveVariantPathsWithFs(demoCall.variants || {});
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Paths Resolved',
+      measure: 'Path Resolution'
+    }, [functionName, relativePath]);
 
-          // log any pending performance entries before completing
-          (_observer = observer) == null || (_observer = _observer.takeRecords()) == null || _observer.forEach(function (entry) {
-            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
-          });
-          (_observer2 = observer) == null || _observer2.disconnect();
-          callback(null, modifiedSource);
-          _context2.n = 8;
-          break;
-        case 7:
-          _context2.p = 7;
-          _t2 = _context2.v;
-          // log any pending performance entries before completing
-          (_observer3 = observer) == null || (_observer3 = _observer3.takeRecords()) == null || _observer3.forEach(function (entry) {
-            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
-          });
-          (_observer4 = observer) == null || _observer4.disconnect();
-          callback(_t2 instanceof Error ? _t2 : new Error(String(_t2)));
-        case 8:
-          return _context2.a(2);
+    // Create loader functions
+    const loadSource = createLoadServerSource({
+      includeDependencies: true,
+      storeAt: 'flat' // TODO: this should be configurable
+    });
+
+    // Setup source transformers for TypeScript to JavaScript conversion
+    // const sourceTransformers: SourceTransformers = [TypescriptToJavascriptTransformer];
+    // TODO: maybe we should have `loadPrecomputedCodeHighlighterWithJsToTs`
+    const sourceTransformers = [];
+
+    // Create sourceParser promise for syntax highlighting
+    const sourceParser = createParseSource();
+    const functionsInitMark = performanceMeasure(currentMark, {
+      mark: 'Functions Init',
+      measure: 'Functions Init'
+    }, [functionName, relativePath]);
+    currentMark = functionsInitMark;
+
+    // Process variants in parallel
+    const variantPromises = Array.from(resolvedVariantMap.entries()).map(async ([variantName, fileUrl]) => {
+      const variantMark = performanceMeasure(functionsInitMark, {
+        mark: 'Variant Started',
+        measure: 'Variant Start'
+      }, [functionName, variantName, relativePath], true);
+      const namedExport = demoCall.namedExports?.[variantName];
+      let variant = fileUrl;
+      if (namedExport) {
+        const {
+          fileName
+        } = getFileNameFromUrl(variant);
+        if (!fileName) {
+          throw new Error(`Cannot determine fileName from URL "${variant}" for variant "${variantName}". ` + `Please ensure the URL has a valid file extension.`);
+        }
+        variant = {
+          url: fileUrl,
+          fileName,
+          namedExport
+        };
       }
-    }, _callee2, this, [[1, 7]]);
-  }));
-  return _loadPrecomputedCodeHighlighter.apply(this, arguments);
+      try {
+        // Use loadCodeVariant to handle all loading, parsing, and transformation
+        // This will recursively load all dependencies using loadSource
+        const {
+          code: processedVariant,
+          dependencies
+        } = await loadCodeVariant(fileUrl,
+        // URL for the variant entry point (already includes file://)
+        variantName, variant, {
+          sourceParser,
+          // For syntax highlighting
+          loadSource,
+          // For loading source files and dependencies
+          loadVariantMeta: undefined,
+          sourceTransformers,
+          // For TypeScript to JavaScript conversion
+          maxDepth: 5,
+          output: this.getOptions().output || 'hastGzip'
+        });
+        performanceMeasure(variantMark, {
+          mark: 'Variant Loaded',
+          measure: 'Variant Loading'
+        }, [functionName, variantName, relativePath], true);
+        return {
+          variantName,
+          variantData: processedVariant,
+          // processedVariant is a complete VariantCode
+          dependencies // All files that were loaded
+        };
+      } catch (error) {
+        throw new Error(`Failed to load variant ${variantName} from ${fileUrl}: ${error}`);
+      }
+    });
+    const variantResults = await Promise.all(variantPromises);
+
+    // Process results and collect dependencies
+    for (const result of variantResults) {
+      if (result) {
+        variantData[result.variantName] = result.variantData;
+        result.dependencies.forEach(file => {
+          allDependencies.push(file);
+        });
+      }
+    }
+    currentMark = performanceMeasure(functionsInitMark, {
+      mark: 'All Variants Loaded',
+      measure: 'Complete Variants Loading'
+    }, [functionName, relativePath], true);
+
+    // Replace the factory function call with the actual precomputed data
+    const modifiedSource = replacePrecomputeValue(source, variantData, demoCall);
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Replaced Precompute',
+      measure: 'Precompute Replacement'
+    }, [functionName, relativePath]);
+
+    // Add all dependencies to webpack's watch list
+    allDependencies.forEach(dep => {
+      // Convert file:// URLs to proper file system paths for webpack's dependency tracking
+      // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
+      this.addDependency(dep.startsWith('file://') ? fileURLToPath(dep) : dep);
+    });
+
+    // log any pending performance entries before completing
+    observer?.takeRecords()?.forEach(entry => logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+    observer?.disconnect();
+    callback(null, modifiedSource);
+  } catch (error) {
+    // log any pending performance entries before completing
+    observer?.takeRecords()?.forEach(entry => logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+    observer?.disconnect();
+    callback(error instanceof Error ? error : new Error(String(error)));
+  }
 }