@mui/internal-docs-infra 0.1.1-canary.9 → 0.2.0-alpha.2

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/generateResolvedExternals.js

@@ -0,0 +1,198 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+/**
+ * Generates a unique import name based on module path and original name
+ */
+function generateUniqueImportName(originalName, modulePath, type, usedNames) {
+  // If no conflict, use original name
+  if (!usedNames.has(originalName)) {
+    return originalName;
+  }
+
+  // For conflicts, strategy depends on type and context:
+  // - Namespace imports: always use numbered suffixes
+  // - Named imports from simple test cases (lib1, lib2, etc.): use numbered suffixes
+  // - Other cases: try module-based names first
+
+  var wantsNumberedSuffix = type === 'namespace' || modulePath.startsWith('lib') && /^lib\d+$/.test(modulePath);
+  if (wantsNumberedSuffix) {
+    // Use numbered suffixes
+    var attempt = 1;
+    var _uniqueName = "".concat(originalName).concat(attempt);
+    while (usedNames.has(_uniqueName)) {
+      attempt += 1;
+      _uniqueName = "".concat(originalName).concat(attempt);
+    }
+    return _uniqueName;
+  }
+
+  // For real modules, try module-based names first
+  var moduleKey = modulePath.replace(/[@/.-]/g, '') // Remove special characters
+  .toLowerCase().slice(0, 20); // Limit length
+
+  var uniqueName = "".concat(originalName).concat(moduleKey);
+
+  // If that's still taken, try numbered suffixes
+  if (usedNames.has(uniqueName)) {
+    var _attempt = 1;
+    do {
+      uniqueName = "".concat(originalName).concat(_attempt);
+      _attempt += 1;
+    } while (usedNames.has(uniqueName));
+  }
+  return uniqueName;
+}
+
+/**
+ * Helper function to check if a string is a valid JavaScript identifier
+ */
+function isValidIdentifier(str) {
+  // JavaScript identifier rules: must start with letter, $, or _, followed by letters, digits, $, or _
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str);
+}
+
+/**
+ * Generates both import statements and resolved externals object
+ * Returns the import statements and the externals as a JavaScript object
+ */
+export function generateResolvedExternals(externals) {
+  var moduleImports = {};
+  var usedNames = new Set();
+  var seenImports = new Set();
+
+  // First pass: collect all imports and resolve naming conflicts
+  for (var _i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      modulePath = _Object$entries$_i[0],
+      importItems = _Object$entries$_i[1];
+    if (!moduleImports[modulePath]) {
+      moduleImports[modulePath] = {
+        named: [],
+        namespace: []
+      };
+    }
+    var _iterator = _createForOfIteratorHelper(importItems),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _step.value,
+          originalName = _step$value.name,
+          type = _step$value.type,
+          isType = _step$value.isType;
+        // Skip type-only imports and empty names
+        if (isType || !originalName.trim()) {
+          continue;
+        }
+        var importKey = "".concat(modulePath, ":").concat(originalName, ":").concat(type);
+
+        // Skip duplicates
+        if (seenImports.has(importKey)) {
+          continue;
+        }
+        seenImports.add(importKey);
+        var uniqueName = generateUniqueImportName(originalName, modulePath, type, usedNames);
+        usedNames.add(uniqueName);
+        if (type === 'default') {
+          moduleImports[modulePath]["default"] = uniqueName;
+        } else if (type === 'named') {
+          moduleImports[modulePath].named.push({
+            original: originalName,
+            unique: uniqueName
+          });
+        } else if (type === 'namespace') {
+          moduleImports[modulePath].namespace.push(uniqueName);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  // Second pass: generate consolidated import statements and resolved externals
+  var imports = [];
+  var resolvedExternalsObject = {};
+  for (var _i2 = 0, _Object$entries2 = Object.entries(moduleImports); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+      _modulePath = _Object$entries2$_i[0],
+      moduleImport = _Object$entries2$_i[1];
+    var hasDefault = moduleImport["default"] !== undefined;
+    var hasNamed = moduleImport.named.length > 0;
+    var hasNamespace = moduleImport.namespace.length > 0;
+
+    // Skip modules that have no valid imports
+    if (!hasDefault && !hasNamed && !hasNamespace) {
+      continue;
+    }
+    var importParts = [];
+
+    // Add default import
+    if (moduleImport["default"]) {
+      importParts.push(moduleImport["default"]);
+    }
+
+    // Add named imports (consolidated into one statement)
+    if (moduleImport.named.length > 0) {
+      var namedImports = moduleImport.named.map(function (_ref) {
+        var original = _ref.original,
+          unique = _ref.unique;
+        return original === unique ? original : "".concat(original, " as ").concat(unique);
+      }).join(', ');
+      importParts.push("{ ".concat(namedImports, " }"));
+    }
+
+    // Generate import statement
+    if (importParts.length > 0) {
+      imports.push("import ".concat(importParts.join(', '), " from '").concat(_modulePath, "';"));
+    }
+
+    // Add namespace imports (separate statements as they can't be combined)
+    var _iterator2 = _createForOfIteratorHelper(moduleImport.namespace),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var namespaceName = _step2.value;
+        imports.push("import * as ".concat(namespaceName, " from '").concat(_modulePath, "';"));
+      }
+
+      // Generate resolved externals entry for this module
+      // For invalid JavaScript identifiers, use the quoted version as the key
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    var objectKey = isValidIdentifier(_modulePath) ? _modulePath : "\"".concat(_modulePath, "\"");
+    var resolvedValue = void 0;
+    if (hasDefault && !hasNamed && !hasNamespace) {
+      // Single default export - use direct assignment (e.g., 'react': React)
+      resolvedValue = moduleImport["default"];
+    } else if (!hasDefault && hasNamed && !hasNamespace) {
+      // Named exports only - use object syntax (e.g., '@mui/material': { Button, TextField })
+      var namedExports = moduleImport.named.map(function (_ref2) {
+        var original = _ref2.original;
+        return original;
+      }).join(', ');
+      resolvedValue = "{ ".concat(namedExports, " }");
+    } else if (!hasDefault && !hasNamed && hasNamespace) {
+      // Single namespace export - use direct assignment (e.g., 'lodash': lodash)
+      resolvedValue = moduleImport.namespace[0];
+    } else if (hasDefault) {
+      // Mixed imports - prefer default for the resolved externals
+      resolvedValue = moduleImport["default"];
+    } else if (hasNamespace) {
+      // Mixed imports - use namespace if no default
+      resolvedValue = moduleImport.namespace[0];
+    } else {
+      continue; // Should not happen, but safety check
+    }
+
+    // Add to the resolved externals object using the object key
+    resolvedExternalsObject[objectKey] = resolvedValue;
+  }
+  return {
+    imports: imports,
+    resolvedExternals: resolvedExternalsObject
+  };
+}

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

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

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/index.js

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

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/injectImportsIntoSource.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Injects import statements into source code after 'use client' directive.
+ * Handles proper placement of imports in client components.
+ */
+export declare function injectImportsIntoSource(source: string, importLines: string[]): string;

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/injectImportsIntoSource.js

@@ -0,0 +1,21 @@
+/**
+ * Injects import statements into source code after 'use client' directive.
+ * Handles proper placement of imports in client components.
+ */
+export function injectImportsIntoSource(source, importLines) {
+  if (importLines.length === 0) {
+    return source;
+  }
+  var importString = "".concat(importLines.join('\n'), "\n\n");
+
+  // Check if file starts with 'use client'
+  var useClientMatch = source.match(/^['"]use client['"]\s*;\s*\n/);
+  if (useClientMatch) {
+    // Insert after 'use client' directive
+    var afterUseClient = useClientMatch[0];
+    return "".concat(afterUseClient).concat(importString).concat(source.slice(afterUseClient.length));
+  }
+
+  // Insert at the beginning
+  return "".concat(importString).concat(source);
+}

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/loadPrecomputedCodeHighlighterClient.d.ts

@@ -0,0 +1,15 @@
+import type { LoaderContext } from 'webpack';
+export type LoaderOptions = {};
+/**
+ * Webpack loader that processes demo client files and precomputes externals.
+ *
+ * Finds createDemoClient calls and injects all required externals as imports
+ * at the top of the file, then passes them to the function as precompute.externals.
+ *
+ * The pattern expected is: create*Client(import.meta.url, { options: true })
+ * The result will be: create*Client(import.meta.url, { options: true, precompute: { externals } })
+ *
+ * Automatically skips processing if skipPrecompute: true is set.
+ */
+export declare function loadPrecomputedCodeHighlighterClient(this: LoaderContext<LoaderOptions>, source: string): Promise<void>;
+export default loadPrecomputedCodeHighlighterClient;

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/loadPrecomputedCodeHighlighterClient.js

@@ -0,0 +1,233 @@
+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 { readFile } from 'fs/promises';
+import { parseCreateFactoryCall } from "../loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js";
+import { generateResolvedExternals } from "./generateResolvedExternals.js";
+import { loadVariant } from "../../CodeHighlighter/loadVariant.js";
+import { createLoadServerSource } from "../loadServerSource/index.js";
+import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { getFileNameFromUrl } from "../loaderUtils/index.js";
+import { mergeExternals } from "../loaderUtils/mergeExternals.js";
+import { filterRuntimeExternals } from "./filterRuntimeExternals.js";
+import { injectImportsIntoSource } from "./injectImportsIntoSource.js";
+import { replacePrecomputeValue } from "../loadPrecomputedCodeHighlighter/replacePrecomputeValue.js";
+/**
+ * Webpack loader that processes demo client files and precomputes externals.
+ *
+ * Finds createDemoClient calls and injects all required externals as imports
+ * at the top of the file, then passes them to the function as precompute.externals.
+ *
+ * The pattern expected is: create*Client(import.meta.url, { options: true })
+ * The result will be: create*Client(import.meta.url, { options: true, precompute: { externals } })
+ *
+ * Automatically skips processing if skipPrecompute: true is set.
+ */
+export function loadPrecomputedCodeHighlighterClient(_x) {
+  return _loadPrecomputedCodeHighlighterClient.apply(this, arguments);
+}
+
+// Default export for webpack loader
+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;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.p = _context2.n) {
+        case 0:
+          callback = this.async();
+          this.cacheable();
+          _context2.p = 1;
+          _context2.n = 2;
+          return parseCreateFactoryCall(source, this.resourcePath, {
+            metadataOnly: true
+          });
+        case 2:
+          demoCall = _context2.v;
+          if (demoCall) {
+            _context2.n = 3;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 3:
+          if (demoCall.functionName.includes('Client')) {
+            _context2.n = 4;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 4:
+          if (!demoCall.options.skipPrecompute) {
+            _context2.n = 5;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 5:
+          // Load variant data for all variants to collect externals
+          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
+          indexDemoCall = null;
+          _context2.p = 6;
+          _context2.n = 7;
+          return readFile(indexPath, 'utf-8');
+        case 7:
+          indexSource = _context2.v;
+          // Add index.ts as a dependency for hot reloading
+          this.addDependency(indexPath);
+          _context2.n = 8;
+          return parseCreateFactoryCall(indexSource, indexPath);
+        case 8:
+          indexDemoCall = _context2.v;
+          _context2.n = 10;
+          break;
+        case 9:
+          _context2.p = 9;
+          _t2 = _context2.v;
+          // If we can't read index.ts, we can't determine variants
+          console.warn("Could not read ".concat(indexPath, " to determine variants for client: ").concat(_t2));
+          callback(null, source);
+          return _context2.a(2);
+        case 10:
+          if (!(!indexDemoCall || !indexDemoCall.variants)) {
+            _context2.n = 11;
+            break;
+          }
+          console.warn("No createDemo call or variants found in ".concat(indexPath, " for client processing"));
+          callback(null, source);
+          return _context2.a(2);
+        case 11:
+          _context2.n = 12;
+          return resolveVariantPathsWithFs(indexDemoCall.variants);
+        case 12:
+          resolvedVariantMap = _context2.v;
+          // Create loader functions
+          loadSource = createLoadServerSource({
+            includeDependencies: true,
+            storeAt: 'flat' // TODO: choose whichever is most performant as it shouldn't affect the output
+          }); // Process variants in parallel to collect externals
+          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;
+              return _regenerator().w(function (_context) {
+                while (1) switch (_context.p = _context.n) {
+                  case 0:
+                    _ref3 = _slicedToArray(_ref, 2), variantName = _ref3[0], fileUrl = _ref3[1];
+                    namedExport = (_indexDemoCall$namedE = indexDemoCall.namedExports) == null ? void 0 : _indexDemoCall$namedE[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 loadVariant(fileUrl,
+                    // URL for the variant entry point (already includes file://)
+                    variantName, variant, {
+                      loadSource: loadSource,
+                      // For loading source files and dependencies
+                      maxDepth: 5,
+                      disableParsing: true,
+                      disableTransforms: true
+                    });
+                  case 3:
+                    _yield$loadVariant = _context.v;
+                    dependencies = _yield$loadVariant.dependencies;
+                    externals = _yield$loadVariant.externals;
+                    return _context.a(2, {
+                      variantName: variantName,
+                      dependencies: dependencies,
+                      // All files that were loaded
+                      externals: externals // Combined externals from all loaded files
+                    });
+                  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 = 13;
+          return Promise.all(variantPromises);
+        case 13:
+          variantResults = _context2.v;
+          // Process results and collect dependencies and externals
+          _iterator = _createForOfIteratorHelper(variantResults);
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              result = _step.value;
+              if (result) {
+                result.dependencies.forEach(function (file) {
+                  allDependencies.push(file);
+                });
+                // Collect externals for proper merging
+                allExternalsArray.push(result.externals);
+              }
+            }
+
+            // Properly merge externals from all variants
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          allExternals = mergeExternals(allExternalsArray); // Filter out type-only imports since they don't exist at runtime
+          runtimeExternals = filterRuntimeExternals(allExternals); // Generate import statements and resolved externals object
+          _generateResolvedExte = generateResolvedExternals(runtimeExternals), importLines = _generateResolvedExte.imports, resolvedExternals = _generateResolvedExte.resolvedExternals; // Add externals argument to the createDemoClient call using replacePrecomputeValue first
+          // (before injecting imports, so the original positions are still valid)
+          // with passPrecomputeAsIs enabled so externals are passed as resolved objects
+          precomputeData = {
+            externals: resolvedExternals
+          };
+          modifiedSource = replacePrecomputeValue(source, precomputeData, demoCall, {
+            passPrecomputeAsIs: true
+          }); // Then inject imports at the top of the file (after 'use client' if present)
+          modifiedSource = injectImportsIntoSource(modifiedSource, importLines);
+
+          // 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);
+          });
+          callback(null, modifiedSource);
+          _context2.n = 15;
+          break;
+        case 14:
+          _context2.p = 14;
+          _t3 = _context2.v;
+          callback(_t3 instanceof Error ? _t3 : new Error(String(_t3)));
+        case 15:
+          return _context2.a(2);
+      }
+    }, _callee2, this, [[6, 9], [1, 14]]);
+  }));
+  return _loadPrecomputedCodeHighlighterClient.apply(this, arguments);
+}
+export default loadPrecomputedCodeHighlighterClient;

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

@@ -0,0 +1 @@
+export * from "./loadServerCodeMeta.js";

package/esm/pipeline/loadServerCodeMeta/index.js

@@ -0,0 +1 @@
+export * from "./loadServerCodeMeta.js";

package/esm/pipeline/loadServerCodeMeta/loadServerCodeMeta.d.ts

@@ -0,0 +1,24 @@
+import type { LoadCodeMeta } from "../../CodeHighlighter/types.js";
+export interface CreateLoadCodeMetaOptions {}
+/**
+ * Default loadServerCodeMeta function that resolves variant paths from demo files.
+ * This function is used to load code metadata for demos, specifically resolving paths for variants defined in the demo files.
+ * It reads the demo file, parses it to find `createDemo` calls with variants, and resolves the paths for those variants.
+ * It returns a Code object mapping variant names to their resolved file URLs.
+ */
+export declare const loadServerCodeMeta: LoadCodeMeta;
+/**
+ * Creates a loadCodeMeta function that resolves variant paths from demo files.
+ *
+ * This factory function creates a LoadCodeMeta implementation that:
+ * 1. Parses the demo file to find createDemo calls with variants
+ * 2. Resolves all variant entry point paths using resolveVariantPaths
+ * 3. Returns a Code object mapping variant names to their resolved file URLs
+ *
+ * The actual loading, parsing, and transformation of the variants is handled
+ * elsewhere by the CodeHighlighter component using loadVariant.
+ *
+ * @param options - Configuration options (currently unused)
+ * @returns LoadCodeMeta function that takes a URL and returns Promise<Code>
+ */
+export declare function createLoadServerCodeMeta(_options?: CreateLoadCodeMetaOptions): LoadCodeMeta;

package/esm/pipeline/loadServerCodeMeta/loadServerCodeMeta.js

@@ -0,0 +1,90 @@
+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 { readFile } from 'node:fs/promises';
+import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { parseCreateFactoryCall } from "../loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js";
+import { getFileNameFromUrl } from "../loaderUtils/index.js";
+/**
+ * Default loadServerCodeMeta function that resolves variant paths from demo files.
+ * This function is used to load code metadata for demos, specifically resolving paths for variants defined in the demo files.
+ * It reads the demo file, parses it to find `createDemo` calls with variants, and resolves the paths for those variants.
+ * It returns a Code object mapping variant names to their resolved file URLs.
+ */
+export var loadServerCodeMeta = createLoadServerCodeMeta();
+
+/**
+ * Creates a loadCodeMeta function that resolves variant paths from demo files.
+ *
+ * This factory function creates a LoadCodeMeta implementation that:
+ * 1. Parses the demo file to find createDemo calls with variants
+ * 2. Resolves all variant entry point paths using resolveVariantPaths
+ * 3. Returns a Code object mapping variant names to their resolved file URLs
+ *
+ * The actual loading, parsing, and transformation of the variants is handled
+ * elsewhere by the CodeHighlighter component using loadVariant.
+ *
+ * @param options - Configuration options (currently unused)
+ * @returns LoadCodeMeta function that takes a URL and returns Promise<Code>
+ */
+export function createLoadServerCodeMeta() {
+  var _options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return /*#__PURE__*/function () {
+    var _loadCodeMeta = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(url) {
+      var filePath, source, demoCall, code, resolvedVariantMap;
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            // Remove file:// prefix if present to get file path
+            filePath = url.replace('file://', ''); // Read the source file to find createDemo calls
+            _context.n = 1;
+            return readFile(filePath, 'utf-8');
+          case 1:
+            source = _context.v;
+            _context.n = 2;
+            return parseCreateFactoryCall(source, filePath);
+          case 2:
+            demoCall = _context.v;
+            if (!(!demoCall || !demoCall.variants)) {
+              _context.n = 3;
+              break;
+            }
+            return _context.a(2, {});
+          case 3:
+            code = {}; // Resolve all variant paths and get them as file URLs
+            _context.n = 4;
+            return resolveVariantPathsWithFs(demoCall.variants || {});
+          case 4:
+            resolvedVariantMap = _context.v;
+            // Build Code object from the resolved variant map
+            Array.from(resolvedVariantMap.entries()).forEach(function (_ref) {
+              var _demoCall$namedExport;
+              var _ref2 = _slicedToArray(_ref, 2),
+                variantName = _ref2[0],
+                fileUrl = _ref2[1];
+              var namedExport = (_demoCall$namedExport = demoCall.namedExports) == null ? void 0 : _demoCall$namedExport[variantName];
+              code[variantName] = fileUrl;
+              if (namedExport) {
+                var _getFileNameFromUrl = getFileNameFromUrl(fileUrl),
+                  fileName = _getFileNameFromUrl.fileName;
+                if (!fileName) {
+                  throw new Error("Cannot determine fileName from URL \"".concat(fileUrl, "\" for variant \"").concat(variantName, "\". ") + "Please ensure the URL has a valid file extension.");
+                }
+                code[variantName] = {
+                  url: fileUrl,
+                  fileName: fileName,
+                  namedExport: namedExport
+                };
+              }
+              // TODO: will this cause loadVariantMeta not to run? Maybe we should always run it
+            });
+            return _context.a(2, code);
+        }
+      }, _callee);
+    }));
+    function loadCodeMeta(_x) {
+      return _loadCodeMeta.apply(this, arguments);
+    }
+    return loadCodeMeta;
+  }();
+}

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

@@ -0,0 +1 @@
+export * from "./loadServerSource.js";

package/esm/pipeline/loadServerSource/index.js

@@ -0,0 +1 @@
+export * from "./loadServerSource.js";

package/esm/pipeline/loadServerSource/loadServerSource.d.ts

@@ -0,0 +1,25 @@
+import type { LoadSource } from "../../CodeHighlighter/types.js";
+import { type StoreAtMode } from "../loaderUtils/processRelativeImports.js";
+interface LoadSourceOptions {
+  maxDepth?: number;
+  maxFiles?: number;
+  includeDependencies?: boolean;
+  storeAt?: StoreAtMode;
+}
+/**
+ * Default loadServerSource function that reads a file and extracts its dependencies.
+ * This function is used to load source files for demos, resolving their imports and dependencies.
+ * It reads the source file, resolves its imports, and returns the processed source along with any
+ * additional files and dependencies that were found.
+ */
+export declare const loadServerSource: LoadSource;
+/**
+ * Creates a loadSource function that reads a file and extracts its dependencies.
+ *
+ * @param options.storeAt - Controls how imports are stored in extraFiles:
+ *   - 'canonical': Full resolved path (e.g., '../Component/index.js')
+ *   - 'import': Import path with file extension (e.g., '../Component.js')
+ *   - 'flat': Flattened to current directory with rewritten imports (e.g., './Component.js')
+ */
+export declare function createLoadServerSource(options?: LoadSourceOptions): LoadSource;
+export {};