@mui/internal-babel-plugin-resolve-imports 1.0.19 → 2.0.0

package/index.js

@@ -41,74 +41,82 @@ module.exports = function plugin({ types: t }, { outExtension }) {
   const cache = new Map();
   const extensions = ['.ts', '.tsx', '.js', '.jsx'];
   const extensionsSet = new Set(extensions);
-  return {
-    visitor: {
-      ImportOrExportDeclaration(path, state) {
-        if (path.isExportDefaultDeclaration()) {
-          // Can't export default from an import specifier
-          return;
-        }
 
-        if (
-          (path.isExportDeclaration() && path.node.exportKind === 'type') ||
-          (path.isImportDeclaration() && path.node.importKind === 'type')
-        ) {
-          // Ignore type imports, they will get compiled away anyway
-          return;
-        }
+  /**
+   *
+   * @param {babel.NodePath<babel.types.StringLiteral>} importSource
+   * @param {babel.PluginPass} state
+   */
+  function doResolve(importSource, state) {
+    const importedPath = importSource.node.value;
 
-        const source =
-          /** @type {babel.NodePath<babel.types.StringLiteral | null | undefined> } */ (
-            path.get('source')
-          );
+    if (!importedPath.startsWith('.')) {
+      // Only handle relative imports
+      return;
+    }
 
-        if (!source.node) {
-          // Ignore import without source
-          return;
-        }
+    if (!state.filename) {
+      throw new Error('filename is not defined');
+    }
 
-        const importedPath = source.node.value;
+    const importerPath = state.filename;
+    const importerDir = nodePath.dirname(importerPath);
+    // start from fully resolved import path
+    const absoluteImportPath = nodePath.resolve(importerDir, importedPath);
 
-        if (!importedPath.startsWith('.')) {
-          // Only handle relative imports
-          return;
-        }
+    let resolvedPath = cache.get(absoluteImportPath);
 
-        if (!state.filename) {
-          throw new Error('filename is not defined');
-        }
+    if (!resolvedPath) {
+      // resolve to actual file
+      resolvedPath = resolve(absoluteImportPath, { extensions });
 
-        const importerPath = state.filename;
-        const importerDir = nodePath.dirname(importerPath);
-        // start from fully resolved import path
-        const absoluteImportPath = nodePath.resolve(importerDir, importedPath);
+      if (!resolvedPath) {
+        throw new Error(`could not resolve "${importedPath}" from "${state.filename}"`);
+      }
 
-        let resolvedPath = cache.get(absoluteImportPath);
+      const resolvedExtension = nodePath.extname(resolvedPath);
+      if (outExtension && extensionsSet.has(resolvedExtension)) {
+        // replace extension
+        resolvedPath = nodePath.resolve(
+          nodePath.dirname(resolvedPath),
+          nodePath.basename(resolvedPath, resolvedExtension) + outExtension,
+        );
+      }
 
-        if (!resolvedPath) {
-          // resolve to actual file
-          resolvedPath = resolve(absoluteImportPath, { extensions });
+      cache.set(absoluteImportPath, resolvedPath);
+    }
 
-          if (!resolvedPath) {
-            throw new Error(`could not resolve "${importedPath}" from "${state.filename}"`);
-          }
+    const relativeResolvedPath = nodePath.relative(importerDir, resolvedPath);
+    const importSpecifier = pathToNodeImportSpecifier(relativeResolvedPath);
 
-          const resolvedExtension = nodePath.extname(resolvedPath);
-          if (outExtension && extensionsSet.has(resolvedExtension)) {
-            // replace extension
-            resolvedPath = nodePath.resolve(
-              nodePath.dirname(resolvedPath),
-              nodePath.basename(resolvedPath, resolvedExtension) + outExtension,
-            );
-          }
+    importSource.replaceWith(t.stringLiteral(importSpecifier));
+  }
 
-          cache.set(absoluteImportPath, resolvedPath);
+  return {
+    visitor: {
+      TSImportType(path, state) {
+        const source = path.get('argument');
+        doResolve(source, state);
+      },
+      ImportExpression(path, state) {
+        const source = path.get('source');
+        if (source.isStringLiteral()) {
+          doResolve(source, state);
         }
-
-        const relativeResolvedPath = nodePath.relative(importerDir, resolvedPath);
-        const importSpecifier = pathToNodeImportSpecifier(relativeResolvedPath);
-
-        source.replaceWith(t.stringLiteral(importSpecifier));
+      },
+      ImportDeclaration(path, state) {
+        const source = path.get('source');
+        doResolve(source, state);
+      },
+      ExportNamedDeclaration(path, state) {
+        const source = path.get('source');
+        if (source.isStringLiteral()) {
+          doResolve(source, state);
+        }
+      },
+      ExportAllDeclaration(path, state) {
+        const source = path.get('source');
+        doResolve(source, state);
       },
     },
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-babel-plugin-resolve-imports",
-  "version": "1.0.19",
+  "version": "2.0.0",
   "author": "MUI Team",
   "description": "babel plugin that resolves import specifiers to their actual output file.",
   "main": "./index.js",
@@ -14,7 +14,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "resolve": "^1.22.9"
+    "resolve": "^1.22.10"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",