@mui/internal-docs-infra 0.1.0 → 0.1.1-alpha.0

package/build/esm/loadPrecomputedCodeHighlighter/replacePrecomputeValue.js

@@ -0,0 +1,37 @@
+/**
+ * Replaces 'precompute: true' with the actual precomputed data in source code.
+ *
+ * This function performs a precise replacement of the boolean true value in
+ * 'precompute: true' expressions with the provided data object, keeping the
+ * rest of the source code unchanged.
+ *
+ * @param source - The source code string containing 'precompute: true'
+ * @param precomputeData - The data object to replace the true value with
+ * @returns The modified source code with precompute data injected
+ *
+ * @example
+ * ```typescript
+ * const source = `
+ * export const demo = createDemo(
+ *   import.meta.url,
+ *   { Component },
+ *   { precompute: true }
+ * );
+ * `;
+ *
+ * const data = { variants: { default: { code: "..." } } };
+ * const result = replacePrecomputeValue(source, data);
+ * // Result will have 'precompute: true' replaced with 'precompute: { variants: { default: { code: "..." } } }'
+ * ```
+ */
+export function replacePrecomputeValue(source, precomputeData) {
+  // Regex to match 'precompute: true' with optional whitespace
+  var precomputeRegex = /precompute\s*:\s*true/g;
+
+  // Convert the data to a properly formatted JSON string
+  var precomputeDataString = JSON.stringify(precomputeData, null, 2);
+
+  // Replace 'precompute: true' with 'precompute: {data}'
+  // The regex will match the exact pattern and we replace just that part
+  return source.replace(precomputeRegex, "precompute: ".concat(precomputeDataString));
+}

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

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

package/build/esm/loadServerCodeMeta/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/loadServerCodeMeta/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/build/esm/loadServerCodeMeta/index.js

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

package/build/esm/loadServerCodeMeta/serverLoadCodeMeta.d.ts

@@ -0,0 +1,24 @@
+import type { LoadCodeMeta } from "../CodeHighlighter/types.js";
+export interface CreateLoadCodeMetaOptions {}
+/**
+ * Default serverLoadCodeMeta 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 serverLoadCodeMeta: 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 createServerLoadCodeMeta(_options?: CreateLoadCodeMetaOptions): LoadCodeMeta;

package/build/esm/loadServerCodeMeta/serverLoadCodeMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverLoadCodeMeta.d.ts","sourceRoot":"","sources":["../../../src/loadServerCodeMeta/serverLoadCodeMeta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAQ,MAAM,0BAA0B,CAAC;AAInE,MAAM,WAAW,yBAAyB;CAEzC;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,cAA6B,CAAC;AAE7D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,GAAE,yBAA8B,GAAG,YAAY,CA4B/F"}

package/build/esm/loadServerCodeMeta/serverLoadCodeMeta.js

@@ -0,0 +1,77 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+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";
+/**
+ * Default serverLoadCodeMeta 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 serverLoadCodeMeta = createServerLoadCodeMeta();
+
+/**
+ * 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 createServerLoadCodeMeta() {
+  var _options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return /*#__PURE__*/function () {
+    var _loadCodeMeta = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(url) {
+      var filePath, source, demoCall, code, resolvedVariantMap;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            // Remove file:// prefix if present to get file path
+            filePath = url.replace('file://', ''); // Read the source file to find createDemo calls
+            _context.next = 3;
+            return readFile(filePath, 'utf-8');
+          case 3:
+            source = _context.sent;
+            _context.next = 6;
+            return parseCreateFactoryCall(source, filePath);
+          case 6:
+            demoCall = _context.sent;
+            if (!(!demoCall || !demoCall.variants)) {
+              _context.next = 9;
+              break;
+            }
+            return _context.abrupt("return", {});
+          case 9:
+            code = {}; // Resolve all variant paths and get them as file URLs
+            _context.next = 12;
+            return resolveVariantPathsWithFs(demoCall.variants);
+          case 12:
+            resolvedVariantMap = _context.sent;
+            // Build Code object from the resolved variant map
+            Array.from(resolvedVariantMap.entries()).forEach(function (_ref) {
+              var _ref2 = _slicedToArray(_ref, 2),
+                variantName = _ref2[0],
+                fileUrl = _ref2[1];
+              code[variantName] = fileUrl;
+            });
+            return _context.abrupt("return", code);
+          case 15:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function loadCodeMeta(_x) {
+      return _loadCodeMeta.apply(this, arguments);
+    }
+    return loadCodeMeta;
+  }();
+}

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

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

package/build/esm/loadServerSource/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/loadServerSource/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/build/esm/loadServerSource/index.js

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

package/build/esm/loadServerSource/serverLoadSource.d.ts

@@ -0,0 +1,25 @@
+import type { LoadSource } from "../CodeHighlighter/types.js";
+import { type StoreAtMode } from "../loaderUtils/processImports.js";
+interface LoadSourceOptions {
+  maxDepth?: number;
+  maxFiles?: number;
+  includeDependencies?: boolean;
+  storeAt?: StoreAtMode;
+}
+/**
+ * Default serverLoadSource 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 serverLoadSource: 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 createServerLoadSource(options?: LoadSourceOptions): LoadSource;
+export {};

package/build/esm/loadServerSource/serverLoadSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverLoadSource.d.ts","sourceRoot":"","sources":["../../../src/loadServerSource/serverLoadSource.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAG3D,OAAO,EAA6B,KAAK,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5F,UAAU,iBAAiB;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,YAA2B,CAAC;AAEzD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,iBAAsB,GAAG,UAAU,CAmDlF"}

package/build/esm/loadServerSource/serverLoadSource.js

@@ -0,0 +1,100 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { readFile } from 'node:fs/promises';
+import { resolveImports } from "../loaderUtils/resolveImports.js";
+import { resolveImportResultWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { processImportsWithStoreAt } from "../loaderUtils/processImports.js";
+import { isJavaScriptModule } from "../loaderUtils/resolveModulePath.js";
+/**
+ * Default serverLoadSource 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 var serverLoadSource = createServerLoadSource();
+
+/**
+ * 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 function createServerLoadSource() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$includeDepen = options.includeDependencies,
+    includeDependencies = _options$includeDepen === void 0 ? true : _options$includeDepen,
+    _options$storeAt = options.storeAt,
+    storeAt = _options$storeAt === void 0 ? 'flat' : _options$storeAt;
+  return /*#__PURE__*/function () {
+    var _loadSource = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(url) {
+      var filePath, source, isJavascriptModuleFile, importResult, resolvedPathsMap, _processImportsWithSt, processedSource, extraFiles, extraDependencies;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            // Remove file:// prefix if present
+            filePath = url.replace('file://', ''); // Read the file
+            _context.next = 3;
+            return readFile(filePath, 'utf8');
+          case 3:
+            source = _context.sent;
+            if (includeDependencies) {
+              _context.next = 6;
+              break;
+            }
+            return _context.abrupt("return", {
+              source: source
+            });
+          case 6:
+            // Check if this is a static asset file (non-JS/TS modules)
+            isJavascriptModuleFile = isJavaScriptModule(filePath);
+            if (isJavascriptModuleFile) {
+              _context.next = 9;
+              break;
+            }
+            return _context.abrupt("return", {
+              source: source
+            });
+          case 9:
+            _context.next = 11;
+            return resolveImports(source, filePath);
+          case 11:
+            importResult = _context.sent;
+            if (!(Object.keys(importResult).length === 0)) {
+              _context.next = 14;
+              break;
+            }
+            return _context.abrupt("return", {
+              source: source
+            });
+          case 14:
+            _context.next = 16;
+            return resolveImportResultWithFs(importResult);
+          case 16:
+            resolvedPathsMap = _context.sent;
+            // Process imports using the consolidated helper function
+            _processImportsWithSt = processImportsWithStoreAt(source, importResult, resolvedPathsMap, storeAt), processedSource = _processImportsWithSt.processedSource, extraFiles = _processImportsWithSt.extraFiles; // Build dependencies list for recursive loading
+            extraDependencies = Object.values(importResult).map(function (_ref) {
+              var path = _ref.path;
+              return resolvedPathsMap.get(path);
+            }).filter(function (path) {
+              return path !== undefined;
+            });
+            return _context.abrupt("return", {
+              source: processedSource,
+              extraFiles: Object.keys(extraFiles).length > 0 ? extraFiles : undefined,
+              extraDependencies: extraDependencies.length > 0 ? extraDependencies : undefined
+            });
+          case 20:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function loadSource(_x) {
+      return _loadSource.apply(this, arguments);
+    }
+    return loadSource;
+  }();
+}

package/build/esm/loaderUtils/getFileNameFromUrl.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Extracts the filename and extension from a URL or file path.
+ * This function is isomorphic and works in both Node.js and browser environments.
+ *
+ * @param url - The URL or file path to extract the filename from
+ * @returns An object containing the filename and extension
+ */
+export declare function getFileNameFromUrl(url: string): {
+  fileName: string;
+  extension: string;
+};

package/build/esm/loaderUtils/getFileNameFromUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFileNameFromUrl.d.ts","sourceRoot":"","sources":["../../../src/loaderUtils/getFileNameFromUrl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAoBvF"}

package/build/esm/loaderUtils/getFileNameFromUrl.js

@@ -0,0 +1,32 @@
+/**
+ * Extracts the filename and extension from a URL or file path.
+ * This function is isomorphic and works in both Node.js and browser environments.
+ *
+ * @param url - The URL or file path to extract the filename from
+ * @returns An object containing the filename and extension
+ */
+export function getFileNameFromUrl(url) {
+  try {
+    // Use URL constructor to handle various URL formats
+    var urlObj = new URL(url);
+    var pathname = urlObj.pathname;
+    var fileName = pathname.split('/').pop() || '';
+
+    // Extract extension (including the dot)
+    var lastDotIndex = fileName.lastIndexOf('.');
+    var extension = lastDotIndex > 0 ? fileName.substring(lastDotIndex) : '';
+    return {
+      fileName: fileName,
+      extension: extension
+    };
+  } catch (_unused) {
+    // If URL parsing fails, fall back to simple string manipulation
+    var _fileName = url.split('/').pop() || url;
+    var _lastDotIndex = _fileName.lastIndexOf('.');
+    var _extension = _lastDotIndex > 0 ? _fileName.substring(_lastDotIndex) : '';
+    return {
+      fileName: _fileName,
+      extension: _extension
+    };
+  }
+}

package/build/esm/loaderUtils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./resolveImports.js";
+export * from "./resolveModulePath.js";
+export * from "./rewriteImports.js";
+export * from "./processImports.js";
+export * from "./getFileNameFromUrl.js";

package/build/esm/loaderUtils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/loaderUtils/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}

package/build/esm/loaderUtils/index.js

@@ -0,0 +1,5 @@
+export * from "./resolveImports.js";
+export * from "./resolveModulePath.js";
+export * from "./rewriteImports.js";
+export * from "./processImports.js";
+export * from "./getFileNameFromUrl.js";

package/build/esm/loaderUtils/processImports.d.ts

@@ -0,0 +1,19 @@
+export type StoreAtMode = 'canonical' | 'import' | 'flat';
+export interface ProcessImportsResult {
+  processedSource: string;
+  extraFiles: Record<string, string>;
+}
+/**
+ * Processes imports based on the specified storage mode, automatically handling
+ * source rewriting when needed (e.g., for 'flat' mode).
+ *
+ * @param source - The original source code
+ * @param importResult - The result from resolveImports
+ * @param resolvedPathsMap - Map from import paths to resolved file paths
+ * @param storeAt - How to process the imports
+ * @returns Object with processed source and extraFiles mapping
+ */
+export declare function processImportsWithStoreAt(source: string, importResult: Record<string, {
+  path: string;
+  names: string[];
+}>, resolvedPathsMap: Map<string, string>, storeAt: StoreAtMode): ProcessImportsResult;

package/build/esm/loaderUtils/processImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processImports.d.ts","sourceRoot":"","sources":["../../../src/loaderUtils/processImports.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1D,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,EAC/D,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACrC,OAAO,EAAE,WAAW,GACnB,oBAAoB,CAsEtB"}

package/build/esm/loaderUtils/processImports.js

@@ -0,0 +1,82 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { rewriteImportsToSameDirectory } from "./rewriteImports.js";
+import { isJavaScriptModule } from "./resolveModulePath.js";
+import { getFileNameFromUrl } from "./getFileNameFromUrl.js";
+/**
+ * Processes imports based on the specified storage mode, automatically handling
+ * source rewriting when needed (e.g., for 'flat' mode).
+ *
+ * @param source - The original source code
+ * @param importResult - The result from resolveImports
+ * @param resolvedPathsMap - Map from import paths to resolved file paths
+ * @param storeAt - How to process the imports
+ * @returns Object with processed source and extraFiles mapping
+ */
+export function processImportsWithStoreAt(source, importResult, resolvedPathsMap, storeAt) {
+  var processedSource = source;
+  var extraFiles = {};
+
+  // For flat mode, automatically rewrite imports to same directory
+  if (storeAt === 'flat') {
+    var allResolvedPaths = new Set(resolvedPathsMap.values());
+    processedSource = rewriteImportsToSameDirectory(source, allResolvedPaths);
+  }
+
+  // Process each import and generate extraFiles
+  Object.entries(importResult).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      relativePath = _ref2[0],
+      importInfo = _ref2[1];
+    var resolvedPath = resolvedPathsMap.get(importInfo.path);
+    if (resolvedPath) {
+      var fileExtension = getFileNameFromUrl(resolvedPath).extension;
+      var isJavascriptModule = isJavaScriptModule(relativePath);
+      var keyPath;
+      if (!isJavascriptModule) {
+        // For static assets (CSS, JSON, etc.), use the original import path as-is since it already has the extension
+        switch (storeAt) {
+          case 'canonical':
+          case 'import':
+            keyPath = relativePath;
+            break;
+          case 'flat':
+            // For flat mode, use just the filename from the original import
+            keyPath = "./".concat(getFileNameFromUrl(relativePath).fileName);
+            break;
+          default:
+            keyPath = relativePath;
+        }
+      } else {
+        // For JS/TS modules, apply the existing logic
+        switch (storeAt) {
+          case 'canonical':
+            // Show the full resolved path including index files when they exist
+            // e.g., import '../Component' resolved to '/src/Component/index.js'
+            // becomes extraFiles: { '../Component/index.js': 'file:///src/Component/index.js' }
+            keyPath = "".concat(relativePath).concat(resolvedPath.endsWith("/index".concat(fileExtension)) ? "/index".concat(fileExtension) : fileExtension);
+            break;
+          case 'import':
+            // Use the original import path with the actual file extension
+            // e.g., import '../Component' with '/src/Component/index.js'
+            // becomes extraFiles: { '../Component.js': 'file:///src/Component/index.js' }
+            keyPath = "".concat(relativePath).concat(fileExtension);
+            break;
+          case 'flat':
+            // Flatten all files to current directory using just the filename
+            // e.g., import '../Component' with '/src/Component/index.js'
+            // becomes extraFiles: { './index.js': 'file:///src/Component/index.js' }
+            // Note: This mode also requires rewriting imports in the source code (handled above)
+            keyPath = "./".concat(getFileNameFromUrl(resolvedPath).fileName);
+            break;
+          default:
+            keyPath = "".concat(relativePath).concat(fileExtension);
+        }
+      }
+      extraFiles[keyPath] = "file://".concat(resolvedPath);
+    }
+  });
+  return {
+    processedSource: processedSource,
+    extraFiles: extraFiles
+  };
+}

package/build/esm/loaderUtils/resolveImports.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveImports(code: string, filePath: string): Promise<Record<string, {
+  path: string;
+  names: string[];
+}>>;

package/build/esm/loaderUtils/resolveImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveImports.d.ts","sourceRoot":"","sources":["../../../src/loaderUtils/resolveImports.ts"],"names":[],"mappings":"AAAA,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC,CAkC5D"}

package/build/esm/loaderUtils/resolveImports.js

@@ -0,0 +1,71 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+export function resolveImports(_x, _x2) {
+  return _resolveImports.apply(this, arguments);
+}
+function _resolveImports() {
+  _resolveImports = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(code, filePath) {
+    var result, importRegex, importMatch, _loop;
+    return _regeneratorRuntime().wrap(function _callee$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          result = {};
+          importRegex = /import\s+(?:(\w+)|\*\s+as\s+(\w+)|{([^}]+)})\s+from\s+['"]([^'"]+)['"]/g;
+          importMatch = importRegex.exec(code);
+          _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+            var _importMatch, _importMatch2, defaultImport, namespaceImport, namedImportsStr, modulePath, basePath, resolvedPath, namedImports;
+            return _regeneratorRuntime().wrap(function _loop$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _importMatch = importMatch, _importMatch2 = _slicedToArray(_importMatch, 5), defaultImport = _importMatch2[1], namespaceImport = _importMatch2[2], namedImportsStr = _importMatch2[3], modulePath = _importMatch2[4]; // Only process relative imports
+                  if (modulePath.startsWith('.')) {
+                    basePath = filePath.substring(0, filePath.lastIndexOf('/'));
+                    resolvedPath = new URL(modulePath, "file://".concat(basePath, "/")).pathname;
+                    if (!result[modulePath]) {
+                      result[modulePath] = {
+                        path: resolvedPath,
+                        names: []
+                      };
+                    }
+                    if (defaultImport) {
+                      result[modulePath].names.push(defaultImport);
+                    } else if (namespaceImport) {
+                      result[modulePath].names.push(namespaceImport);
+                    } else if (namedImportsStr) {
+                      // Handle named imports like { ComponentName, Component2 as Alias }
+                      namedImports = namedImportsStr.split(',').map(function (s) {
+                        return s.trim();
+                      });
+                      namedImports.forEach(function (namedImport) {
+                        var cleanImport = namedImport.split(' as ')[0].trim();
+                        result[modulePath].names.push(cleanImport);
+                      });
+                    }
+                  }
+                  importMatch = importRegex.exec(code);
+                case 3:
+                case "end":
+                  return _context.stop();
+              }
+            }, _loop);
+          });
+        case 4:
+          if (!(importMatch !== null)) {
+            _context2.next = 8;
+            break;
+          }
+          return _context2.delegateYield(_loop(), "t0", 6);
+        case 6:
+          _context2.next = 4;
+          break;
+        case 8:
+          return _context2.abrupt("return", result);
+        case 9:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee);
+  }));
+  return _resolveImports.apply(this, arguments);
+}

package/build/esm/loaderUtils/resolveModulePath.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Default file extensions for JavaScript/TypeScript modules that can be resolved
+ */
+export declare const JAVASCRIPT_MODULE_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx"];
+/**
+ * Checks if a file path or import path represents a JavaScript/TypeScript module
+ * @param path - The file path or import path to check
+ * @returns true if it's a JS/TS module, false otherwise
+ */
+export declare function isJavaScriptModule(path: string): boolean;
+export interface DirectoryEntry {
+  name: string;
+  isFile: boolean;
+  isDirectory: boolean;
+}
+export type DirectoryReader = (path: string) => Promise<DirectoryEntry[]>;
+export interface ResolveModulePathOptions {
+  /**
+   * Array of file extensions to try when resolving modules.
+   * Default: ['.ts', '.tsx', '.js', '.jsx']
+   */
+  extensions?: string[];
+}
+/**
+ * Resolves a module path by reading directory contents to find matching files.
+ * This is more efficient than checking each file individually with stat calls.
+ *
+ * Given a path like `/Code/mui-public/packages/docs-infra/docs/app/components/code-highlighter/demos/code/BasicCode`,
+ * this function will try to find the actual file by checking for:
+ * - `BasicCode.ts`, `BasicCode.tsx`, `BasicCode.js`, `BasicCode.jsx`
+ * - `BasicCode/index.ts`, `BasicCode/index.tsx`, `BasicCode/index.js`, `BasicCode/index.jsx`
+ *
+ * @param modulePath - The module path to resolve (without file extension)
+ * @param readDirectory - Function to read directory contents
+ * @param options - Configuration options
+ * @returns Promise<string> - The resolved file path, or throws if not found
+ */
+export declare function resolveModulePath(modulePath: string, readDirectory: DirectoryReader, options?: ResolveModulePathOptions): Promise<string>;
+/**
+ * Resolves multiple module paths efficiently by grouping them by directory
+ * and performing batch directory lookups.
+ *
+ * @param modulePaths - Array of module paths to resolve (without file extensions)
+ * @param readDirectory - Function to read directory contents
+ * @param options - Configuration options
+ * @returns Promise<Map<string, string>> - Map from input path to resolved file path
+ */
+export declare function resolveModulePaths(modulePaths: string[], readDirectory: DirectoryReader, options?: ResolveModulePathOptions): Promise<Map<string, string>>;
+/**
+ * Resolves import result by separating JavaScript modules from static assets,
+ * only resolving JavaScript modules and returning a combined map.
+ * This function uses the resolveModulePaths function internally but requires
+ * a DirectoryReader to be provided.
+ *
+ * @param importResult - The result from resolveImports containing all imports
+ * @param readDirectory - Function to read directory contents
+ * @param options - Configuration options for module resolution
+ * @returns Promise<Map<string, string>> - Map from import path to resolved file path
+ */
+export declare function resolveImportResult(importResult: Record<string, {
+  path: string;
+  names: string[];
+}>, readDirectory: DirectoryReader, options?: ResolveModulePathOptions): Promise<Map<string, string>>;
+/**
+ * Resolves variant paths from a variants object mapping variant names to their file paths.
+ * This function extracts the paths, resolves them using resolveModulePaths, and returns
+ * a map from variant name to resolved file URL.
+ *
+ * @param variants - Object mapping variant names to their file paths
+ * @param readDirectory - Function to read directory contents
+ * @param options - Configuration options for module resolution
+ * @returns Promise<Map<string, string>> - Map from variant name to resolved file URL
+ */
+export declare function resolveVariantPaths(variants: Record<string, string>, readDirectory: DirectoryReader, options?: ResolveModulePathOptions): Promise<Map<string, string>>;

package/build/esm/loaderUtils/resolveModulePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveModulePath.d.ts","sourceRoot":"","sources":["../../../src/loaderUtils/resolveModulePath.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,4BAA4B,yCAA0C,CAAC;AAEpF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOxD;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;AAE1E,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,eAAe,EAC9B,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAyFjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,EAAE,EACrB,aAAa,EAAE,eAAe,EAC9B,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA+I9B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,EAC/D,aAAa,EAAE,eAAe,EAC9B,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAmC9B;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,aAAa,EAAE,eAAe,EAC9B,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgB9B"}