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

package/build/loaderUtils/processImports.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processImportsWithStoreAt = processImportsWithStoreAt;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _rewriteImports = require("./rewriteImports");
+var _resolveModulePath = require("./resolveModulePath");
+var _getFileNameFromUrl = require("./getFileNameFromUrl");
+/**
+ * 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
+ */
+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 = (0, _rewriteImports.rewriteImportsToSameDirectory)(source, allResolvedPaths);
+  }
+
+  // Process each import and generate extraFiles
+  Object.entries(importResult).forEach(function (_ref) {
+    var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+      relativePath = _ref2[0],
+      importInfo = _ref2[1];
+    var resolvedPath = resolvedPathsMap.get(importInfo.path);
+    if (resolvedPath) {
+      var fileExtension = (0, _getFileNameFromUrl.getFileNameFromUrl)(resolvedPath).extension;
+      var isJavascriptModule = (0, _resolveModulePath.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((0, _getFileNameFromUrl.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((0, _getFileNameFromUrl.getFileNameFromUrl)(resolvedPath).fileName);
+            break;
+          default:
+            keyPath = "".concat(relativePath).concat(fileExtension);
+        }
+      }
+      extraFiles[keyPath] = "file://".concat(resolvedPath);
+    }
+  });
+  return {
+    processedSource: processedSource,
+    extraFiles: extraFiles
+  };
+}

package/build/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/loaderUtils/resolveImports.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveImports = resolveImports;
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+function resolveImports(_x, _x2) {
+  return _resolveImports.apply(this, arguments);
+}
+function _resolveImports() {
+  _resolveImports = (0, _asyncToGenerator2["default"])(/*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee(code, filePath) {
+    var result, importRegex, importMatch, _loop;
+    return (0, _regeneratorRuntime2["default"])().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__*/(0, _regeneratorRuntime2["default"])().mark(function _loop() {
+            var _importMatch, _importMatch2, defaultImport, namespaceImport, namedImportsStr, modulePath, basePath, resolvedPath, namedImports;
+            return (0, _regeneratorRuntime2["default"])().wrap(function _loop$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _importMatch = importMatch, _importMatch2 = (0, _slicedToArray2["default"])(_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/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>>;