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

package/{build/loadServerSource/serverLoadSource.d.ts → pipeline/loadServerSource/loadServerSource.d.ts}

@@ -1,5 +1,5 @@
-import type { LoadSource } from "../CodeHighlighter/types.js";
-import { type StoreAtMode } from "../loaderUtils/processImports.js";
+import type { LoadSource } from "../../CodeHighlighter/types.js";
+import { type StoreAtMode } from "../loaderUtils/processRelativeImports.js";
 interface LoadSourceOptions {
   maxDepth?: number;
   maxFiles?: number;
@@ -7,12 +7,12 @@ interface LoadSourceOptions {
   storeAt?: StoreAtMode;
 }
 /**
- * Default serverLoadSource function that reads a file and extracts its dependencies.
+ * 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 serverLoadSource: LoadSource;
+export declare const loadServerSource: LoadSource;
 /**
  * Creates a loadSource function that reads a file and extracts its dependencies.
  *
@@ -21,5 +21,5 @@ export declare const serverLoadSource: LoadSource;
  *   - '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 declare function createLoadServerSource(options?: LoadSourceOptions): LoadSource;
 export {};

package/pipeline/loadServerSource/loadServerSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadServerSource.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loadServerSource/loadServerSource.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,6BAA6B,CAAC;AAGzE,OAAO,EAA0B,KAAK,WAAW,EAAE,MAAM,uCAAuC,CAAC;AAGjG,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,CA8ElF"}

package/pipeline/loadServerSource/loadServerSource.js

@@ -0,0 +1,135 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { readFile } from 'node:fs/promises';
+import { parseImports } from "../loaderUtils/index.js";
+import { resolveImportResultWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { processRelativeImports } from "../loaderUtils/processRelativeImports.js";
+import { isJavaScriptModule } from "../loaderUtils/resolveModulePath.js";
+/**
+ * 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 var loadServerSource = createLoadServerSource();
+
+/**
+ * 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 createLoadServerSource() {
+  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, _yield$parseImports, importResult, externals, transformedExternals, _i, _Object$entries, _Object$entries$_i, modulePath, externalImport, relativeImportsCompatible, _i2, _Object$entries2, _Object$entries2$_i, importPath, _Object$entries2$_i$, path, names, includeTypeDefs, resolvedPathsMap, _processRelativeImpor, 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 parseImports(source, filePath);
+          case 11:
+            _yield$parseImports = _context.sent;
+            importResult = _yield$parseImports.relative;
+            externals = _yield$parseImports.externals;
+            // Transform externals from parseImports format to simplified format
+            transformedExternals = {};
+            for (_i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
+              _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), modulePath = _Object$entries$_i[0], externalImport = _Object$entries$_i[1];
+              transformedExternals[modulePath] = externalImport.names.map(function (importName) {
+                return {
+                  name: importName.name,
+                  type: importName.type,
+                  isType: importName.isType
+                };
+              });
+            }
+            if (!(Object.keys(importResult).length === 0)) {
+              _context.next = 18;
+              break;
+            }
+            return _context.abrupt("return", {
+              source: source,
+              externals: Object.keys(transformedExternals).length > 0 ? transformedExternals : undefined
+            });
+          case 18:
+            // Convert to format expected by resolveImportResultWithFs and processImports
+            relativeImportsCompatible = {};
+            for (_i2 = 0, _Object$entries2 = Object.entries(importResult); _i2 < _Object$entries2.length; _i2++) {
+              _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2), importPath = _Object$entries2$_i[0], _Object$entries2$_i$ = _Object$entries2$_i[1], path = _Object$entries2$_i$.path, names = _Object$entries2$_i$.names, includeTypeDefs = _Object$entries2$_i$.includeTypeDefs;
+              relativeImportsCompatible[importPath] = _objectSpread({
+                path: path,
+                names: names.map(function (_ref) {
+                  var name = _ref.name,
+                    alias = _ref.alias;
+                  return alias || name;
+                })
+              }, includeTypeDefs && {
+                includeTypeDefs: includeTypeDefs
+              });
+            }
+
+            // Resolve import paths, handling JS/TS modules and static assets appropriately
+            _context.next = 22;
+            return resolveImportResultWithFs(relativeImportsCompatible);
+          case 22:
+            resolvedPathsMap = _context.sent;
+            // Process imports using the consolidated helper function
+            _processRelativeImpor = processRelativeImports(source, relativeImportsCompatible, resolvedPathsMap, storeAt), processedSource = _processRelativeImpor.processedSource, extraFiles = _processRelativeImpor.extraFiles; // Build dependencies list for recursive loading
+            extraDependencies = Object.values(importResult).map(function (_ref2) {
+              var path = _ref2.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,
+              externals: Object.keys(transformedExternals).length > 0 ? transformedExternals : undefined
+            });
+          case 26:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function loadSource(_x) {
+      return _loadSource.apply(this, arguments);
+    }
+    return loadSource;
+  }();
+}

package/pipeline/loaderUtils/externalsToPackages.d.ts

@@ -0,0 +1 @@
+export declare function externalsToPackages(externals: string[]): Record<string, true>;

package/pipeline/loaderUtils/externalsToPackages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"externalsToPackages.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/externalsToPackages.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAiB7E"}

package/pipeline/loaderUtils/externalsToPackages.js

@@ -0,0 +1,46 @@
+export function externalsToPackages(externals) {
+  var packages = {};
+  externals.forEach(function (external) {
+    // Filter out path aliases that start with @/
+    if (external.startsWith('@/')) {
+      return;
+    }
+
+    // Extract package name from import path
+    var packageName = extractPackageName(external);
+    if (packageName) {
+      packages[packageName] = true;
+    }
+  });
+  return packages;
+}
+
+/**
+ * Extracts the package name from an import path.
+ * Examples:
+ * - 'react' -> 'react'
+ * - 'react-dom' -> 'react-dom'
+ * - '@mui/internal-docs-infra/CodeHighlighter' -> '@mui/internal-docs-infra'
+ * - '@mui/internal-docs-infra/parseSource' -> '@mui/internal-docs-infra'
+ * - 'lodash/get' -> 'lodash'
+ * - 'some-package/submodule/deep' -> 'some-package'
+ */
+function extractPackageName(importPath) {
+  if (!importPath) {
+    return null;
+  }
+
+  // Handle scoped packages (starting with @)
+  if (importPath.startsWith('@')) {
+    var _parts = importPath.split('/');
+    if (_parts.length >= 2) {
+      // Return @scope/package-name
+      return "".concat(_parts[0], "/").concat(_parts[1]);
+    }
+    return null;
+  }
+
+  // Handle regular packages
+  var parts = importPath.split('/');
+  return parts[0] || null;
+}

package/pipeline/loaderUtils/extractNameAndSlugFromUrl.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Extracts and formats a name and slug from a URL path.
+ * This utility takes the last meaningful segment of a URL path and formats it
+ * into both a human-readable title and a URL-friendly slug.
+ *
+ * - Strips common file extensions (index.js, index.ts, index.tsx, etc.)
+ * - Converts kebab-case to Title Case for names
+ * - Ensures slugs are in kebab-case format
+ */
+/**
+ * Extracts and formats a name and slug from a URL path
+ * @param url - The URL to extract from (can be file:// URL or regular path)
+ * @returns Object containing the formatted name and slug
+ *
+ * @example
+ * extractNameAndSlugFromUrl('file:///app/components/demos/advanced-keyboard/index.ts')
+ * // Returns: { name: 'Advanced Keyboard', slug: 'advanced-keyboard' }
+ *
+ * @example
+ * extractNameAndSlugFromUrl('/src/components/button-group.tsx')
+ * // Returns: { name: 'Button Group', slug: 'button-group' }
+ *
+ * @example
+ * extractNameAndSlugFromUrl('/src/components/customButton.tsx')
+ * // Returns: { name: 'Custom Button', slug: 'custom-button' }
+ *
+ * @example
+ * extractNameAndSlugFromUrl('https://example.com/docs/getting-started/')
+ * // Returns: { name: 'Getting Started', slug: 'getting-started' }
+ */
+export declare function extractNameAndSlugFromUrl(url: string): {
+  name: string;
+  slug: string;
+};

package/pipeline/loaderUtils/extractNameAndSlugFromUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractNameAndSlugFromUrl.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/extractNameAndSlugFromUrl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA4HH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAgBrF"}

package/pipeline/loaderUtils/extractNameAndSlugFromUrl.js

@@ -0,0 +1,161 @@
+/**
+ * Extracts and formats a name and slug from a URL path.
+ * This utility takes the last meaningful segment of a URL path and formats it
+ * into both a human-readable title and a URL-friendly slug.
+ *
+ * - Strips common file extensions (index.js, index.ts, index.tsx, etc.)
+ * - Converts kebab-case to Title Case for names
+ * - Ensures slugs are in kebab-case format
+ */
+
+/**
+ * Converts a camelCase string to kebab-case
+ * @param camelCase - The camelCase string to convert
+ * @returns kebab-case string
+ */
+function camelToKebabCase(camelCase) {
+  return camelCase
+  // Insert hyphens before uppercase letters that follow lowercase letters or numbers
+  .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+  // Insert hyphens before numbers that follow letters
+  .replace(/([a-zA-Z])([0-9])/g, '$1-$2')
+  // Insert hyphens before letters that follow numbers
+  .replace(/([0-9])([a-zA-Z])/g, '$1-$2').toLowerCase();
+}
+
+/**
+ * Converts a camelCase string to Title Case with spaces
+ * @param camelCase - The camelCase string to convert
+ * @returns Title case string with spaces
+ */
+function camelToTitleCase(camelCase) {
+  return camelCase
+  // Insert spaces before uppercase letters that follow lowercase letters or numbers
+  .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+  // Insert spaces before numbers that follow letters
+  .replace(/([a-zA-Z])([0-9])/g, '$1 $2')
+  // Insert spaces before letters that follow numbers
+  .replace(/([0-9])([a-zA-Z])/g, '$1 $2')
+  // Capitalize the first letter
+  .replace(/^./, function (str) {
+    return str.toUpperCase();
+  });
+}
+
+/**
+ * Converts a kebab-case string to Title Case
+ * @param kebabCase - The kebab-case string to convert
+ * @returns Title case string
+ */
+function kebabToTitleCase(kebabCase) {
+  return kebabCase.split(/[-_]/) // Split on both hyphens and underscores
+  .map(function (word) {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  }).join(' ');
+}
+
+/**
+ * Detects if a string is camelCase or PascalCase
+ * @param str - The string to check
+ * @returns true if the string is camelCase or PascalCase
+ */
+function isCamelCase(str) {
+  // Check if it matches the camelCase/PascalCase pattern:
+  // - Only contains letters and numbers
+  // - Has at least one transition from lowercase letter or number to uppercase letter
+  // - Doesn't contain hyphens, underscores, or spaces
+  return /^[a-zA-Z][a-zA-Z0-9]*$/.test(str) && /[a-z0-9][A-Z]/.test(str);
+}
+
+/**
+ * Converts a string to kebab-case
+ * @param str - The string to convert
+ * @returns kebab-case string
+ */
+function toKebabCase(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Extracts the last meaningful segment from a URL path
+ * @param url - The URL to extract from
+ * @returns The last meaningful path segment
+ */
+function extractLastSegment(url) {
+  // Handle file: URLs by removing the protocol
+  var path = url;
+  if (url.startsWith('file:')) {
+    path = url.replace(/^file:\/\//, '');
+  }
+
+  // Strip query parameters and hash fragments before processing
+  path = path.split('?')[0].split('#')[0];
+
+  // Split the path into segments and filter out empty ones
+  var segments = path.split('/').filter(Boolean);
+  if (segments.length === 0) {
+    throw new Error('Could not extract meaningful segment from URL');
+  }
+
+  // Get the last segment
+  var lastSegment = segments[segments.length - 1];
+
+  // Handle index files - any file that starts with 'index.'
+  if (lastSegment.startsWith('index.')) {
+    // If it's an index file, use the parent directory name
+    if (segments.length < 2) {
+      throw new Error('Cannot extract name from index file without parent directory');
+    }
+    lastSegment = segments[segments.length - 2];
+  } else {
+    // Strip everything after the first dot from non-index files
+    // This handles all extensions: .js, .d.ts, .module.css, .config.dev.js, etc.
+    var firstDotIndex = lastSegment.indexOf('.');
+    if (firstDotIndex !== -1) {
+      lastSegment = lastSegment.substring(0, firstDotIndex);
+    }
+  }
+  if (!lastSegment) {
+    throw new Error('Could not extract meaningful segment from URL');
+  }
+  return lastSegment;
+}
+
+/**
+ * Extracts and formats a name and slug from a URL path
+ * @param url - The URL to extract from (can be file:// URL or regular path)
+ * @returns Object containing the formatted name and slug
+ *
+ * @example
+ * extractNameAndSlugFromUrl('file:///app/components/demos/advanced-keyboard/index.ts')
+ * // Returns: { name: 'Advanced Keyboard', slug: 'advanced-keyboard' }
+ *
+ * @example
+ * extractNameAndSlugFromUrl('/src/components/button-group.tsx')
+ * // Returns: { name: 'Button Group', slug: 'button-group' }
+ *
+ * @example
+ * extractNameAndSlugFromUrl('/src/components/customButton.tsx')
+ * // Returns: { name: 'Custom Button', slug: 'custom-button' }
+ *
+ * @example
+ * extractNameAndSlugFromUrl('https://example.com/docs/getting-started/')
+ * // Returns: { name: 'Getting Started', slug: 'getting-started' }
+ */
+export function extractNameAndSlugFromUrl(url) {
+  var segment = extractLastSegment(url);
+
+  // Check if the segment is camelCase and handle it appropriately
+  if (isCamelCase(segment)) {
+    return {
+      name: camelToTitleCase(segment),
+      slug: camelToKebabCase(segment)
+    };
+  }
+
+  // For kebab-case, snake_case, or other formats, use the existing logic
+  return {
+    name: kebabToTitleCase(segment),
+    slug: toKebabCase(segment)
+  };
+}

package/pipeline/loaderUtils/getFileNameFromUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFileNameFromUrl.d.ts","sourceRoot":"","sources":["../../../src/pipeline/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/pipeline/loaderUtils/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./parseImports.js";
+export * from "./resolveModulePath.js";
+export * from "./rewriteImports.js";
+export * from "./processRelativeImports.js";
+export * from "./getFileNameFromUrl.js";
+export * from "./extractNameAndSlugFromUrl.js";
+export * from "./externalsToPackages.js";

package/pipeline/loaderUtils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC"}

package/pipeline/loaderUtils/index.js

@@ -0,0 +1,7 @@
+export * from "./parseImports.js";
+export * from "./resolveModulePath.js";
+export * from "./rewriteImports.js";
+export * from "./processRelativeImports.js";
+export * from "./getFileNameFromUrl.js";
+export * from "./extractNameAndSlugFromUrl.js";
+export * from "./externalsToPackages.js";

package/pipeline/loaderUtils/mergeExternals.d.ts

@@ -0,0 +1,32 @@
+import type { Externals } from "../../CodeHighlighter/types.js";
+/**
+ * Merges multiple externals objects into a single object, combining imports from the same module.
+ * Deduplicates imports by name and type within each module.
+ *
+ * @param externalsArray Array of externals objects to merge
+ * @returns Merged externals object
+ *
+ * @example
+ * ```typescript
+ * const externals1 = {
+ *   'react': [{ name: 'React', type: 'default' }],
+ *   'lodash': [{ name: 'map', type: 'named' }]
+ * };
+ *
+ * const externals2 = {
+ *   'react': [{ name: 'useState', type: 'named' }],
+ *   'lodash': [{ name: 'map', type: 'named' }] // duplicate - will be removed
+ * };
+ *
+ * const merged = mergeExternals([externals1, externals2]);
+ * // Result:
+ * // {
+ * //   'react': [
+ * //     { name: 'React', type: 'default' },
+ * //     { name: 'useState', type: 'named' }
+ * //   ],
+ * //   'lodash': [{ name: 'map', type: 'named' }]
+ * // }
+ * ```
+ */
+export declare function mergeExternals(externalsArray: Array<Externals>): Externals;

package/pipeline/loaderUtils/mergeExternals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeExternals.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/mergeExternals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,cAAc,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,SAAS,CA4B1E"}

package/pipeline/loaderUtils/mergeExternals.js

@@ -0,0 +1,72 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+/**
+ * Merges multiple externals objects into a single object, combining imports from the same module.
+ * Deduplicates imports by name and type within each module.
+ *
+ * @param externalsArray Array of externals objects to merge
+ * @returns Merged externals object
+ *
+ * @example
+ * ```typescript
+ * const externals1 = {
+ *   'react': [{ name: 'React', type: 'default' }],
+ *   'lodash': [{ name: 'map', type: 'named' }]
+ * };
+ *
+ * const externals2 = {
+ *   'react': [{ name: 'useState', type: 'named' }],
+ *   'lodash': [{ name: 'map', type: 'named' }] // duplicate - will be removed
+ * };
+ *
+ * const merged = mergeExternals([externals1, externals2]);
+ * // Result:
+ * // {
+ * //   'react': [
+ * //     { name: 'React', type: 'default' },
+ * //     { name: 'useState', type: 'named' }
+ * //   ],
+ * //   'lodash': [{ name: 'map', type: 'named' }]
+ * // }
+ * ```
+ */
+export function mergeExternals(externalsArray) {
+  var merged = {};
+  var _iterator = _createForOfIteratorHelper(externalsArray),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var externals = _step.value;
+      var _loop = function _loop() {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          modulePath = _Object$entries$_i[0],
+          imports = _Object$entries$_i[1];
+        if (!merged[modulePath]) {
+          // First time seeing this module, copy all imports
+          merged[modulePath] = _toConsumableArray(imports);
+        } else {
+          // Module already exists, merge imports and deduplicate
+          var existingImports = merged[modulePath];
+          var newImports = imports.filter(function (newImport) {
+            // Check if this import already exists (same name, type, and isType)
+            return !existingImports.some(function (existingImport) {
+              return existingImport.name === newImport.name && existingImport.type === newImport.type && existingImport.isType === newImport.isType;
+            });
+          });
+
+          // Add only the new imports that don't already exist
+          merged[modulePath] = [].concat(_toConsumableArray(existingImports), _toConsumableArray(newImports));
+        }
+      };
+      for (var _i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
+        _loop();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return merged;
+}

package/pipeline/loaderUtils/parseImports.d.ts

@@ -0,0 +1,20 @@
+interface ImportName {
+  name: string;
+  alias?: string;
+  type: 'default' | 'named' | 'namespace';
+  isType?: boolean;
+}
+interface RelativeImport {
+  path: string;
+  names: ImportName[];
+  includeTypeDefs?: true;
+}
+interface ExternalImport {
+  names: ImportName[];
+}
+interface ParseImportsResult {
+  relative: Record<string, RelativeImport>;
+  externals: Record<string, ExternalImport>;
+}
+export declare function parseImports(code: string, _filePath: string): Promise<ParseImportsResult>;
+export {};

package/pipeline/loaderUtils/parseImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseImports.d.ts","sourceRoot":"","sources":["../../../src/pipeline/loaderUtils/parseImports.ts"],"names":[],"mappings":"AAEA,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,WAAW,CAAC;IACxC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,eAAe,CAAC,EAAE,IAAI,CAAC;CACxB;AAED,UAAU,cAAc;IACtB,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB;AAED,UAAU,kBAAkB;IAC1B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACzC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC3C;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0Q/F"}