@mui/internal-docs-infra 0.2.3-canary.9 → 0.3.1-canary.1

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.js

@@ -2,16 +2,24 @@ import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIt
 import _regenerator from "@babel/runtime/helpers/esm/regenerator";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import { loadVariant } from "../../CodeHighlighter/loadVariant.js";
+// webpack does not like node: imports
+// eslint-disable-next-line n/prefer-node-protocol
+import path from 'path';
+// eslint-disable-next-line n/prefer-node-protocol
+import { fileURLToPath, pathToFileURL } from 'url';
+import { loadCodeVariant } from "../loadCodeVariant/loadCodeVariant.js";
 import { createParseSource } from "../parseSource/index.js";
 // TODO: re-enable following benchmarking
 // import { TypescriptToJavascriptTransformer } from '../transformTypescriptToJavascript';
 
 import { parseCreateFactoryCall } from "./parseCreateFactoryCall.js";
-import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { resolveVariantPathsWithFs } from "../loadServerCodeMeta/resolveModulePathWithFs.js";
 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';
+
 /**
  * Webpack loader that processes demo files and precomputes variant data.
  *
@@ -28,18 +36,46 @@ export function loadPrecomputedCodeHighlighter(_x) {
 }
 function _loadPrecomputedCodeHighlighter() {
   _loadPrecomputedCodeHighlighter = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source) {
-    var _this = this;
-    var callback, demoCall, variantData, allDependencies, resolvedVariantMap, loadSource, sourceTransformers, sourceParser, variantPromises, variantResults, _iterator, _step, result, modifiedSource, _t2;
+    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, this.resourcePath);
+          return parseCreateFactoryCall(source, resourceFileUrl);
         case 2:
           demoCall = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Parsed Factory',
+            measure: 'Factory Parsing'
+          }, [functionName, relativePath]);
+
+          // If no createDemo call found, return the source unchanged
           if (demoCall) {
             _context2.n = 3;
             break;
@@ -61,6 +97,11 @@ function _loadPrecomputedCodeHighlighter() {
           return resolveVariantPathsWithFs(demoCall.variants || {});
         case 5:
           resolvedVariantMap = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Paths Resolved',
+            measure: 'Path Resolution'
+          }, [functionName, relativePath]);
+
           // Create loader functions
           loadSource = createLoadServerSource({
             includeDependencies: true,
@@ -69,15 +110,26 @@ function _loadPrecomputedCodeHighlighter() {
           // const sourceTransformers: SourceTransformers = [TypescriptToJavascriptTransformer];
           // TODO: maybe we should have `loadPrecomputedCodeHighlighterWithJsToTs`
           sourceTransformers = []; // Create sourceParser promise for syntax highlighting
-          sourceParser = createParseSource(); // Process variants in parallel
+          sourceParser = createParseSource();
+          functionsInitMark = performanceMeasure(currentMark, {
+            mark: 'Functions Init',
+            measure: 'Functions Init'
+          }, [functionName, relativePath]);
+          currentMark = functionsInitMark;
+
+          // 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, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadVariant, processedVariant, dependencies, _t;
+              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) {
@@ -99,7 +151,7 @@ function _loadPrecomputedCodeHighlighter() {
                   case 2:
                     _context.p = 2;
                     _context.n = 3;
-                    return loadVariant(fileUrl,
+                    return loadCodeVariant(fileUrl,
                     // URL for the variant entry point (already includes file://)
                     variantName, variant, {
                       sourceParser: sourceParser,
@@ -113,9 +165,13 @@ function _loadPrecomputedCodeHighlighter() {
                       output: _this.getOptions().output || 'hastGzip'
                     });
                   case 3:
-                    _yield$loadVariant = _context.v;
-                    processedVariant = _yield$loadVariant.code;
-                    dependencies = _yield$loadVariant.dependencies;
+                    _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,
@@ -151,24 +207,46 @@ function _loadPrecomputedCodeHighlighter() {
                 });
               }
             }
-
-            // Replace the factory function call with the actual precomputed data
           } catch (err) {
             _iterator.e(err);
           } finally {
             _iterator.f();
           }
-          modifiedSource = replacePrecomputeValue(source, variantData, demoCall); // Add all dependencies to webpack's watch list
+          currentMark = performanceMeasure(functionsInitMark, {
+            mark: 'All Variants Loaded',
+            measure: 'Complete Variants Loading'
+          }, [functionName, relativePath], true);
+
+          // 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]);
+
+          // Add all dependencies to webpack's watch list
           allDependencies.forEach(function (dep) {
-            // Strip 'file://' prefix if present before adding to webpack's dependency tracking
-            _this.addDependency(dep.startsWith('file://') ? dep.slice(7) : 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 = 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);

package/esm/pipeline/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js

@@ -254,19 +254,19 @@ function parseVariantsObjectFromObject(obj, importMap, namedExportsMap, function
 
 /**
  * Helper function to convert the new parseImportsAndComments format to a Map
- * that maps import names to their resolved paths
+ * that maps import names to their resolved URLs
  */
 function buildImportMap(importResult, allowExternalVariants) {
   var importMap = new Map();
   Object.values(importResult.relative).forEach(function (_ref) {
-    var path = _ref.path,
+    var url = _ref.url,
       names = _ref.names;
     names.forEach(function (_ref2) {
       var name = _ref2.name,
         alias = _ref2.alias;
       // Use alias if available, otherwise use the original name
       var nameToUse = alias || name;
-      importMap.set(nameToUse, path);
+      importMap.set(nameToUse, url);
     });
   });
 

package/esm/pipeline/loadPrecomputedCodeHighlighter/performanceLogger.d.ts

@@ -0,0 +1,30 @@
+export declare function logPerformance(entry: PerformanceEntry, notableMs: number, showWrapperMeasures: boolean, filterContext?: string): void;
+export declare function createPerformanceLogger(notableMs: number, showWrapperMeasures: boolean, filterContext?: string): PerformanceObserverCallback;
+export declare function nameMark(functionName: string, event: string, context: string[], wrapper?: boolean): string;
+/**
+ * Helper to create a performance mark and measure in one call.
+ *
+ * @param startMark - Optional start mark name for the measure (typically currentMark)
+ * @param names - Object with mark and measure names
+ * @param context - Array of context strings [functionName, ...context]
+ * @param wrapper - Whether this is a wrapper measure (uses pipe delimiter)
+ * @returns The mark name that was created
+ *
+ * @example
+ * ```ts
+ * currentMark = performanceMeasure(
+ *   currentMark,
+ *   { mark: 'processed', measure: 'processing' },
+ *   [functionName, relativePath],
+ *   true,
+ * );
+ * ```
+ */
+export declare function performanceMeasure(startMark: string | undefined, names: {
+  mark: string;
+  measure: string;
+} | {
+  prefix?: string;
+  mark: string;
+  measure: string;
+}, context: string[], wrapper?: boolean): string;

package/esm/pipeline/loadPrecomputedCodeHighlighter/performanceLogger.js

@@ -0,0 +1,77 @@
+import _arrayLikeToArray from "@babel/runtime/helpers/esm/arrayLikeToArray";
+import _toArray from "@babel/runtime/helpers/esm/toArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+export function logPerformance(entry, notableMs, showWrapperMeasures, filterContext) {
+  if (entry.duration < notableMs) {
+    return;
+  }
+
+  // If filterContext is provided, only log entries that include it
+  if (filterContext && !entry.name.includes(filterContext)) {
+    return;
+  }
+  var delim = '-';
+  var message = entry.name;
+  if (message.startsWith('| ')) {
+    if (!showWrapperMeasures) {
+      return;
+    }
+    delim = '|';
+    message = message.slice(2);
+  }
+  var duration = Math.round(entry.duration).toString().padStart(4, ' ');
+  console.warn("".concat(duration, "ms ").concat(delim, " ").concat(message));
+}
+export function createPerformanceLogger(notableMs, showWrapperMeasures, filterContext) {
+  var performanceLogger = function performanceLogger(list) {
+    var _iterator = _createForOfIteratorHelper(list.getEntries()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        logPerformance(entry, notableMs, showWrapperMeasures, filterContext);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  };
+  return performanceLogger;
+}
+export function nameMark(functionName, event, context) {
+  var wrapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  return "".concat(wrapper ? '| ' : '').concat(functionName, " ").concat(wrapper ? '|' : '-', " ").concat(event, " - ").concat(context.join(' - '));
+}
+
+/**
+ * Helper to create a performance mark and measure in one call.
+ *
+ * @param startMark - Optional start mark name for the measure (typically currentMark)
+ * @param names - Object with mark and measure names
+ * @param context - Array of context strings [functionName, ...context]
+ * @param wrapper - Whether this is a wrapper measure (uses pipe delimiter)
+ * @returns The mark name that was created
+ *
+ * @example
+ * ```ts
+ * currentMark = performanceMeasure(
+ *   currentMark,
+ *   { mark: 'processed', measure: 'processing' },
+ *   [functionName, relativePath],
+ *   true,
+ * );
+ * ```
+ */
+export function performanceMeasure(startMark, names, context) {
+  var wrapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var _context = _toArray(context),
+    functionName = _context[0],
+    restContext = _arrayLikeToArray(_context).slice(1);
+  var prefix = 'prefix' in names && names.prefix ? "".concat(names.prefix, " ") : '';
+  var markName = nameMark(functionName, "".concat(prefix).concat(names.mark), restContext, wrapper);
+  var measureName = nameMark(functionName, "".concat(prefix).concat(names.measure), restContext, wrapper);
+  performance.mark(markName);
+  performance.measure(measureName, startMark, markName);
+  return markName;
+}

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/loadPrecomputedCodeHighlighterClient.js

@@ -5,11 +5,15 @@ import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 // webpack does not like node: imports
 // eslint-disable-next-line n/prefer-node-protocol
 import { readFile } from 'fs/promises';
+// eslint-disable-next-line n/prefer-node-protocol
+import path from 'path';
+// eslint-disable-next-line n/prefer-node-protocol
+import { fileURLToPath, pathToFileURL } from 'url';
 import { parseCreateFactoryCall } from "../loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js";
 import { generateResolvedExternals } from "./generateResolvedExternals.js";
-import { loadVariant } from "../../CodeHighlighter/loadVariant.js";
+import { loadCodeVariant } from "../loadCodeVariant/loadCodeVariant.js";
 import { createLoadServerSource } from "../loadServerSource/index.js";
-import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { resolveVariantPathsWithFs } from "../loadServerCodeMeta/resolveModulePathWithFs.js";
 import { getFileNameFromUrl } from "../loaderUtils/index.js";
 import { mergeExternals } from "../loaderUtils/mergeExternals.js";
 import { filterRuntimeExternals } from "./filterRuntimeExternals.js";
@@ -34,15 +38,19 @@ export function loadPrecomputedCodeHighlighterClient(_x) {
 function _loadPrecomputedCodeHighlighterClient() {
   _loadPrecomputedCodeHighlighterClient = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source) {
     var _this = this;
-    var callback, demoCall, allDependencies, allExternalsArray, clientDir, indexPath, indexDemoCall, indexSource, resolvedVariantMap, loadSource, variantPromises, variantResults, _iterator, _step, result, allExternals, runtimeExternals, _generateResolvedExte, importLines, resolvedExternals, precomputeData, modifiedSource, _t2, _t3;
+    var callback, resourceFileUrl, demoCall, allDependencies, allExternalsArray, clientDir, indexPath, indexFileUrl, indexDemoCall, indexSource, resolvedVariantMap, loadSource, variantPromises, variantResults, _iterator, _step, result, allExternals, runtimeExternals, _generateResolvedExte, importLines, resolvedExternals, precomputeData, modifiedSource, _t2, _t3;
     return _regenerator().w(function (_context2) {
       while (1) switch (_context2.p = _context2.n) {
         case 0:
           callback = this.async();
           this.cacheable();
           _context2.p = 1;
+          // 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(); // Parse the source to find a single createDemoClient call
+          // Use metadataOnly mode since client calls only have (url, options?) arguments
           _context2.n = 2;
-          return parseCreateFactoryCall(source, this.resourcePath, {
+          return parseCreateFactoryCall(source, resourceFileUrl, {
             metadataOnly: true
           });
         case 2:
@@ -72,8 +80,9 @@ function _loadPrecomputedCodeHighlighterClient() {
           allDependencies = [];
           allExternalsArray = []; // For client files, we need to read the corresponding index.ts to get variants
           // The client.ts and index.ts should be in the same directory
-          clientDir = this.resourcePath.substring(0, this.resourcePath.lastIndexOf('/'));
-          indexPath = "".concat(clientDir, "/index.ts"); // Read and parse the index.ts file to get variant information
+          clientDir = path.dirname(this.resourcePath);
+          indexPath = path.join(clientDir, 'index.ts'); // Convert to file:// URL for parseCreateFactoryCall
+          indexFileUrl = pathToFileURL(indexPath).toString(); // Read and parse the index.ts file to get variant information
           indexDemoCall = null;
           _context2.p = 6;
           _context2.n = 7;
@@ -83,7 +92,7 @@ function _loadPrecomputedCodeHighlighterClient() {
           // Add index.ts as a dependency for hot reloading
           this.addDependency(indexPath);
           _context2.n = 8;
-          return parseCreateFactoryCall(indexSource, indexPath);
+          return parseCreateFactoryCall(indexSource, indexFileUrl);
         case 8:
           indexDemoCall = _context2.v;
           _context2.n = 10;
@@ -116,7 +125,7 @@ function _loadPrecomputedCodeHighlighterClient() {
           variantPromises = Array.from(resolvedVariantMap.entries()).map(/*#__PURE__*/function () {
             var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
               var _indexDemoCall$namedE;
-              var _ref3, variantName, fileUrl, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadVariant, dependencies, externals, _t;
+              var _ref3, variantName, fileUrl, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadCodeVarian, dependencies, externals, _t;
               return _regenerator().w(function (_context) {
                 while (1) switch (_context.p = _context.n) {
                   case 0:
@@ -142,7 +151,7 @@ function _loadPrecomputedCodeHighlighterClient() {
                   case 2:
                     _context.p = 2;
                     _context.n = 3;
-                    return loadVariant(fileUrl,
+                    return loadCodeVariant(fileUrl,
                     // URL for the variant entry point (already includes file://)
                     variantName, variant, {
                       loadSource: loadSource,
@@ -152,9 +161,9 @@ function _loadPrecomputedCodeHighlighterClient() {
                       disableTransforms: true
                     });
                   case 3:
-                    _yield$loadVariant = _context.v;
-                    dependencies = _yield$loadVariant.dependencies;
-                    externals = _yield$loadVariant.externals;
+                    _yield$loadCodeVarian = _context.v;
+                    dependencies = _yield$loadCodeVarian.dependencies;
+                    externals = _yield$loadCodeVarian.externals;
                     return _context.a(2, {
                       variantName: variantName,
                       dependencies: dependencies,
@@ -213,8 +222,9 @@ function _loadPrecomputedCodeHighlighterClient() {
 
           // Add all dependencies to webpack's watch list
           allDependencies.forEach(function (dep) {
-            // Strip 'file://' prefix if present before adding to webpack's dependency tracking
-            _this.addDependency(dep.startsWith('file://') ? dep.slice(7) : 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);
           });
           callback(null, modifiedSource);
           _context2.n = 15;

package/esm/pipeline/loadPrecomputedSitemap/index.d.ts

@@ -0,0 +1,2 @@
+import { loadPrecomputedSitemap } from "./loadPrecomputedSitemap.js";
+export default loadPrecomputedSitemap;

package/esm/pipeline/loadPrecomputedSitemap/index.js

@@ -0,0 +1,4 @@
+// This is export format a Webpack / Turbopack loader expects
+
+import { loadPrecomputedSitemap } from "./loadPrecomputedSitemap.js";
+export default loadPrecomputedSitemap;

package/esm/pipeline/loadPrecomputedSitemap/loadPrecomputedSitemap.d.ts

@@ -0,0 +1,10 @@
+import type { LoaderContext } from 'webpack';
+export type LoaderOptions = {
+  performance?: {
+    logging?: boolean;
+    notableMs?: number;
+    showWrapperMeasures?: boolean;
+    significantDependencyCountThreshold?: number;
+  };
+};
+export declare function loadPrecomputedSitemap(this: LoaderContext<LoaderOptions>, source: string): Promise<void>;