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

package/pipeline/loaderUtils/processRelativeImports.js

@@ -1,329 +0,0 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-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 parseImports
- * @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 processRelativeImports(source, importResult, resolvedPathsMap, storeAt) {
-  var extraFiles = {};
-
-  // For flat mode, we need to handle naming conflicts intelligently
-  if (storeAt === 'flat') {
-    var result = processFlatMode(importResult, resolvedPathsMap);
-
-    // Create import path mapping for rewriting
-    var importPathMapping = new Map();
-
-    // Build a reverse mapping from resolved paths to extraFiles keys
-    var resolvedToExtraFile = new Map();
-    Object.entries(result.extraFiles).forEach(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-        extraFileKey = _ref2[0],
-        fileUrl = _ref2[1];
-      var resolvedPath = fileUrl.replace('file://', '');
-      resolvedToExtraFile.set(resolvedPath, extraFileKey);
-    });
-
-    // For each import, find its resolved path and map to the corresponding extraFile key
-    Object.entries(importResult).forEach(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 2),
-        relativePath = _ref4[0],
-        importInfo = _ref4[1];
-      var resolvedPath = resolvedPathsMap.get(importInfo.path);
-      if (resolvedPath) {
-        var extraFileKey = resolvedToExtraFile.get(resolvedPath);
-        if (extraFileKey) {
-          // For JavaScript modules, remove the extension; for other files (CSS, JSON, etc.), keep it
-          var isJavascriptModule = isJavaScriptModule(relativePath);
-          var newPath = extraFileKey;
-          if (isJavascriptModule) {
-            // Handle TypeScript declaration files (.d.ts) properly
-            if (newPath.endsWith('.d.ts')) {
-              newPath = newPath.replace(/\.d\.ts$/, '');
-            } else {
-              newPath = newPath.replace(/\.[^/.]+$/, '');
-            }
-          }
-          // For non-JS modules (CSS, JSON, etc.), keep the full path with extension
-
-          importPathMapping.set(relativePath, newPath);
-        }
-      }
-    });
-
-    // Rewrite the source with the mapping
-    var rewrittenSource = rewriteImportsToSameDirectory(source, importPathMapping);
-    return {
-      processedSource: rewrittenSource,
-      extraFiles: result.extraFiles
-    };
-  }
-
-  // Process each import and generate extraFiles for non-flat modes
-  Object.entries(importResult).forEach(function (_ref5) {
-    var _ref6 = _slicedToArray(_ref5, 2),
-      relativePath = _ref6[0],
-      importInfo = _ref6[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;
-          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;
-          default:
-            keyPath = "".concat(relativePath).concat(fileExtension);
-        }
-      }
-      extraFiles[keyPath] = "file://".concat(resolvedPath);
-    }
-  });
-  return {
-    processedSource: source,
-    extraFiles: extraFiles
-  };
-}
-
-/**
- * Processes flat mode with intelligent conflict resolution
- */
-function processFlatMode(importResult, resolvedPathsMap) {
-  var extraFiles = {};
-  var fileMapping = [];
-
-  // First pass: collect all files and their path segments
-  Object.entries(importResult).forEach(function (_ref7) {
-    var _ref8 = _slicedToArray(_ref7, 2),
-      _relativePath = _ref8[0],
-      importInfo = _ref8[1];
-    var resolvedPath = resolvedPathsMap.get(importInfo.path);
-    if (resolvedPath) {
-      var fileExtension = getFileNameFromUrl(resolvedPath).extension;
-      var pathSegments = resolvedPath.split('/').filter(Boolean);
-      fileMapping.push({
-        resolvedPath: resolvedPath,
-        extension: fileExtension,
-        segments: pathSegments
-      });
-    }
-  });
-
-  // Second pass: determine candidate names and group by conflicts
-  var candidateNames = new Map();
-  var nameGroups = new Map();
-  for (var _i = 0, _fileMapping = fileMapping; _i < _fileMapping.length; _i++) {
-    var file = _fileMapping[_i];
-    var fileName = file.segments[file.segments.length - 1];
-    var isIndexFile = fileName.startsWith('index.');
-    var candidateName = void 0;
-    if (isIndexFile) {
-      // For index files, use the parent directory name + extension
-      var parentDir = file.segments[file.segments.length - 2];
-      candidateName = "".concat(parentDir).concat(file.extension);
-    } else {
-      candidateName = fileName;
-    }
-    candidateNames.set(file.resolvedPath, candidateName);
-    if (!nameGroups.has(candidateName)) {
-      nameGroups.set(candidateName, []);
-    }
-    nameGroups.get(candidateName).push(file.resolvedPath);
-  }
-
-  // Third pass: resolve conflicts for all files in conflicting groups
-  var finalNames = new Map();
-  nameGroups.forEach(function (paths, candidateName) {
-    if (paths.length === 1) {
-      // No conflict, use the candidate name
-      finalNames.set(paths[0], candidateName);
-    } else {
-      // Conflict detected, find optimal minimal distinguishing paths for all files
-      var conflictingFiles = paths.map(function (resolvedPath) {
-        return fileMapping.find(function (f) {
-          return f.resolvedPath === resolvedPath;
-        });
-      });
-
-      // Check if we can resolve conflicts by treating some files differently
-      // This specifically handles cases like:
-      // - /path/to/a/Component.js and /path/to/Component.js (parent-child relationship)
-
-      // Find files that are "shorter" (parent level) compared to others
-      var minLength = Math.min.apply(Math, _toConsumableArray(conflictingFiles.map(function (f) {
-        return f.segments.length;
-      })));
-      var maxLengthForSmart = Math.max.apply(Math, _toConsumableArray(conflictingFiles.map(function (f) {
-        return f.segments.length;
-      })));
-      if (maxLengthForSmart > minLength) {
-        // We have files at different depths, check if it's a parent-child scenario
-        var shorterFiles = conflictingFiles.filter(function (file) {
-          return file.segments.length === minLength;
-        });
-        var longerFiles = conflictingFiles.filter(function (file) {
-          return file.segments.length > minLength;
-        });
-        if (shorterFiles.length === 1 && longerFiles.length >= 1) {
-          // Check if the shorter file is truly a "parent" of the longer files
-          var shorterFile = shorterFiles[0];
-          var shorterPath = shorterFile.segments.slice(0, -1).join('/'); // Remove filename
-
-          // Check if all longer files share the same prefix as the shorter file
-          var allLongerFilesAreChildren = longerFiles.every(function (longerFile) {
-            var longerPath = longerFile.segments.slice(0, shorterFile.segments.length - 1).join('/');
-            return longerPath === shorterPath;
-          });
-          if (allLongerFilesAreChildren) {
-            // This is a true parent-child scenario, apply smart resolution
-
-            // For longer files, find distinguishing index
-            var _distinguishingIndex = -1;
-            var maxLongerLength = Math.max.apply(Math, _toConsumableArray(longerFiles.map(function (f) {
-              return f.segments.length;
-            })));
-            var _loop = function _loop(i) {
-              var segmentsAtIndex = new Set(longerFiles.map(function (f) {
-                return f.segments[i];
-              }).filter(Boolean));
-              if (segmentsAtIndex.size === longerFiles.length) {
-                _distinguishingIndex = i;
-                return 1; // break
-              }
-            };
-            for (var i = 0; i < maxLongerLength; i += 1) {
-              if (_loop(i)) break;
-            }
-            if (_distinguishingIndex !== -1) {
-              // Generate names for longer files using distinguishing segment
-              var _iterator = _createForOfIteratorHelper(longerFiles),
-                _step;
-              try {
-                for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                  var _file = _step.value;
-                  var _fileName = _file.segments[_file.segments.length - 1];
-                  var _isIndexFile = _fileName.startsWith('index.');
-                  var distinguishingSegment = _file.segments[_distinguishingIndex];
-                  var finalName = void 0;
-                  if (_isIndexFile) {
-                    var _parentDir = _file.segments[_file.segments.length - 2];
-                    finalName = "".concat(distinguishingSegment, "/").concat(_parentDir).concat(_file.extension);
-                  } else {
-                    finalName = "".concat(distinguishingSegment, "/").concat(_fileName);
-                  }
-                  finalNames.set(_file.resolvedPath, finalName);
-                }
-
-                // For shorter files, use the candidate name as-is (no conflicts after disambiguation)
-              } catch (err) {
-                _iterator.e(err);
-              } finally {
-                _iterator.f();
-              }
-              var _iterator2 = _createForOfIteratorHelper(shorterFiles),
-                _step2;
-              try {
-                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                  var shortFile = _step2.value;
-                  finalNames.set(shortFile.resolvedPath, candidateName);
-                }
-              } catch (err) {
-                _iterator2.e(err);
-              } finally {
-                _iterator2.f();
-              }
-              return; // Successfully resolved
-            }
-          }
-        }
-      }
-
-      // Fallback to original algorithm if smart resolution fails
-      var distinguishingIndex = -1;
-      var maxLength = Math.max.apply(Math, _toConsumableArray(conflictingFiles.map(function (f) {
-        return f.segments.length;
-      })));
-      var _loop2 = function _loop2(_i2) {
-        var segmentsAtIndex = new Set(conflictingFiles.map(function (f) {
-          return f.segments[_i2];
-        }).filter(Boolean));
-        if (segmentsAtIndex.size === conflictingFiles.length) {
-          distinguishingIndex = _i2;
-          return 1; // break
-        }
-      };
-      for (var _i2 = 0; _i2 < maxLength; _i2 += 1) {
-        if (_loop2(_i2)) break;
-      }
-      if (distinguishingIndex === -1) {
-        throw new Error("Cannot find distinguishing segment for files: ".concat(paths.join(', ')));
-      }
-
-      // Generate names using the distinguishing segment
-      var _iterator3 = _createForOfIteratorHelper(conflictingFiles),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _file2 = _step3.value;
-          var _fileName2 = _file2.segments[_file2.segments.length - 1];
-          var _isIndexFile2 = _fileName2.startsWith('index.');
-          var _distinguishingSegment = _file2.segments[distinguishingIndex];
-          var _finalName = void 0;
-          if (_isIndexFile2) {
-            var _parentDir2 = _file2.segments[_file2.segments.length - 2];
-            _finalName = "".concat(_distinguishingSegment, "/").concat(_parentDir2).concat(_file2.extension);
-          } else {
-            _finalName = "".concat(_distinguishingSegment, "/").concat(_fileName2);
-          }
-          finalNames.set(_file2.resolvedPath, _finalName);
-        }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
-      }
-    }
-  });
-
-  // Fourth pass: build the extraFiles mapping
-  finalNames.forEach(function (finalName, resolvedPath) {
-    extraFiles["./".concat(finalName)] = "file://".concat(resolvedPath);
-  });
-  return {
-    processedSource: '',
-    // Will be set by caller after rewriting
-    extraFiles: extraFiles
-  };
-}

package/pipeline/loaderUtils/resolveModulePath.d.ts

@@ -1,87 +0,0 @@
-/**
- * Default file extensions for JavaScript/TypeScript modules that can be resolved
- */
-export declare const JAVASCRIPT_MODULE_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx", ".d.ts"];
-/**
- * Extension priority for type-only imports - prioritize .d.ts first
- */
-export declare const TYPE_IMPORT_EXTENSIONS: readonly [".d.ts", ".ts", ".tsx", ".js", ".jsx"];
-/**
- * Extension priority for value imports - standard priority with .d.ts last
- */
-export declare const VALUE_IMPORT_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx", ".d.ts"];
-/**
- * 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[];
-}
-export interface TypeAwareResolveResult {
-  import: string;
-  typeImport?: 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
- * @param includeTypeDefs - If true, returns both import and typeImport paths with different extension priorities
- * @returns Promise<string | TypeAwareResolveResult> - The resolved file path(s)
- */
-export declare function resolveModulePath(modulePath: string, readDirectory: DirectoryReader, options?: ResolveModulePathOptions, includeTypeDefs?: boolean): Promise<string | TypeAwareResolveResult>;
-/**
- * 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 new type-aware resolveModulePath function internally.
- *
- * @param importResult - The result from parseImports 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[];
-  includeTypeDefs?: true;
-}>, 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/pipeline/loaderUtils/resolveModulePath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolveModulePath.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/resolveModulePath.ts"],"names":[],"mappings":"AA4BA;;GAEG;AACH,eAAO,MAAM,4BAA4B,kDAAmD,CAAC;AAE7F;;GAEG;AACH,eAAO,MAAM,sBAAsB,kDAAmD,CAAC;AAEvF;;GAEG;AACH,eAAO,MAAM,uBAAuB,kDAAmD,CAAC;AAExF;;;;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,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,eAAe,EAC9B,OAAO,GAAE,wBAA6B,EACtC,eAAe,CAAC,EAAE,OAAO,GACxB,OAAO,CAAC,MAAM,GAAG,sBAAsB,CAAC,CAqB1C;AAqTD;;;;;;;;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,CAiJ9B;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC,EACvF,aAAa,EAAE,eAAe,EAC9B,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA8D9B;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"}