@modern-js/server-utils 2.25.2 → 2.26.1-alpha.0

package/dist/esm/compilers/babel/plugins/babel-plugin-module-resolver/test/mapToRelative.test.js

@@ -0,0 +1,16 @@
+import path from "path";
+import mapToRelative from "../src/mapToRelative";
+describe("mapToRelative", function() {
+  describe("should map to relative path with a custom cwd", function() {
+    it("with a relative filename", function() {
+      var currentFile = "./utils/test/file.js";
+      var result = mapToRelative(path.resolve("./test"), currentFile, "utils/dep");
+      expect(result).toBe("../dep");
+    });
+    it("with an absolute filename", function() {
+      var currentFile = path.resolve("./utils/test/file.js");
+      var result = mapToRelative(path.resolve("."), currentFile, "utils/dep");
+      expect(result).toBe("../dep");
+    });
+  });
+});

package/dist/esm/compilers/babel/plugins/babel-plugin-module-resolver/test/normalizeOptions.test.js

@@ -0,0 +1,45 @@
+import normalizeOptions from "../src/normalizeOptions";
+describe("normalizeOptions", function() {
+  beforeEach(function() {
+    normalizeOptions.resetRecomputations();
+  });
+  it("should return the memoized options when the dirnames are the same", function() {
+    var options = {};
+    var result = normalizeOptions("path/a.js", options);
+    var result2 = normalizeOptions("path/b.js", options);
+    expect(result).toBe(result2);
+    expect(normalizeOptions.recomputations()).toEqual(1);
+  });
+  it("should return the memoized options when the special paths are the same", function() {
+    var options = {};
+    var result = normalizeOptions("unknown", options);
+    var result2 = normalizeOptions("unknown", options);
+    expect(result).toBe(result2);
+    expect(normalizeOptions.recomputations()).toEqual(1);
+  });
+  it("should recompute when the options object is not the same", function() {
+    var options = {};
+    var options2 = {};
+    var result = normalizeOptions("path/to/file.js", options);
+    var result2 = normalizeOptions("path/to/file.js", options2);
+    expect(result).not.toBe(result2);
+    expect(normalizeOptions.recomputations()).toEqual(2);
+  });
+  it("should correctly normalize alias option if it is an array", function() {
+    var options = {
+      alias: [
+        {
+          foo: "A",
+          bar: "B"
+        },
+        {
+          baz: "C"
+        }
+      ]
+    };
+    var alias = normalizeOptions("path/to/file.js", options).alias;
+    expect(alias[0][0]).toEqual(/^foo(\/.*|)$/);
+    expect(alias[1][0]).toEqual(/^bar(\/.*|)$/);
+    expect(alias[2][0]).toEqual(/^baz(\/.*|)$/);
+  });
+});

package/dist/esm/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/package.json

@@ -0,0 +1 @@
+{}

package/dist/esm/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/test/tools.js

@@ -0,0 +1,2 @@
+export default function x() {
+}

package/dist/esm/compilers/babel/preset/alias.js

@@ -4,7 +4,7 @@ import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import path from "path";
 import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
 import { getUserAlias } from "@modern-js/utils";
-var resolvePath = require("babel-plugin-module-resolver").resolvePath;
+var resolvePath = require("../plugins/babel-plugin-module-resolver/src").resolvePath;
 var defaultPaths = {
   "@": [
     "./src"
@@ -56,7 +56,7 @@ export var aliasPlugin = function(alias) {
     ".mjs"
   ];
   return [
-    "babel-plugin-module-resolver",
+    "../plugins/babel-plugin-module-resolver/src",
     {
       root: absoluteBaseUrl,
       alias: mergedPaths,

package/dist/esm/compilers/typescript/index.js

@@ -4,11 +4,10 @@ import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { logger, getAliasConfig, fs } from "@modern-js/utils";
-import ts from "typescript";
 import { TypescriptLoader } from "./typescriptLoader";
 import { tsconfigPathsBeforeHookFactory } from "./tsconfigPathsPlugin";
-var readTsConfigByFile = function(tsConfigFile) {
-  var parsedCmd = ts.getParsedCommandLineOfConfigFile(tsConfigFile, void 0, ts.sys);
+var readTsConfigByFile = function(tsConfigFile, tsInstance) {
+  var parsedCmd = tsInstance.getParsedCommandLineOfConfigFile(tsConfigFile, void 0, tsInstance.sys);
   var options = parsedCmd.options, fileNames = parsedCmd.fileNames, projectReferences = parsedCmd.projectReferences;
   return {
     options: options,
@@ -60,7 +59,7 @@ var copyFiles = function() {
 }();
 export var compileByTs = function() {
   var _ref = _async_to_generator(function(appDirectory, config, compileOptions) {
-    var sourceDirs, distDir, tsconfigPath, ts2, createProgram, formatHost, alias, aliasOption, _aliasOption_paths, paths, _aliasOption_absoluteBaseUrl, absoluteBaseUrl, _readTsConfigByFile, options, fileNames, projectReferences, sourcePosixPaths, rootNames, program, tsconfigPathsPlugin, emitResult, allDiagnostics, noEmitOnError, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, source, err;
+    var sourceDirs, distDir, tsconfigPath, ts, createProgram, formatHost, alias, aliasOption, _aliasOption_paths, paths, _aliasOption_absoluteBaseUrl, absoluteBaseUrl, _readTsConfigByFile, options, fileNames, projectReferences, sourcePosixPaths, rootNames, program, tsconfigPathsPlugin, emitResult, allDiagnostics, noEmitOnError, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, source, err;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -71,18 +70,18 @@ export var compileByTs = function() {
               2
             ];
           }
-          ts2 = new TypescriptLoader({
+          ts = new TypescriptLoader({
             appDirectory: appDirectory
           }).load();
-          createProgram = ts2.createIncrementalProgram || ts2.createProgram;
-          formatHost = getFormatHost(ts2);
+          createProgram = ts.createIncrementalProgram || ts.createProgram;
+          formatHost = getFormatHost(ts);
           alias = config.alias;
           aliasOption = getAliasConfig(alias, {
             appDirectory: appDirectory,
             tsconfigPath: tsconfigPath
           });
           _aliasOption_paths = aliasOption.paths, paths = _aliasOption_paths === void 0 ? {} : _aliasOption_paths, _aliasOption_absoluteBaseUrl = aliasOption.absoluteBaseUrl, absoluteBaseUrl = _aliasOption_absoluteBaseUrl === void 0 ? "./" : _aliasOption_absoluteBaseUrl;
-          _readTsConfigByFile = readTsConfigByFile(tsconfigPath), options = _readTsConfigByFile.options, fileNames = _readTsConfigByFile.fileNames, projectReferences = _readTsConfigByFile.projectReferences;
+          _readTsConfigByFile = readTsConfigByFile(tsconfigPath, ts), options = _readTsConfigByFile.options, fileNames = _readTsConfigByFile.fileNames, projectReferences = _readTsConfigByFile.projectReferences;
           sourcePosixPaths = sourceDirs.map(function(sourceDir) {
             return sourceDir.split(path.sep).join(path.posix.sep);
           });
@@ -91,7 +90,7 @@ export var compileByTs = function() {
               return fileName.includes(sourceDir);
             });
           });
-          program = createProgram.call(ts2, {
+          program = createProgram.call(ts, {
             rootNames: rootNames,
             projectReferences: projectReferences,
             options: _object_spread({
@@ -99,16 +98,16 @@ export var compileByTs = function() {
               outDir: distDir
             }, options)
           });
-          tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts2, absoluteBaseUrl, paths);
+          tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
           emitResult = program.emit(void 0, void 0, void 0, void 0, {
             before: [
               tsconfigPathsPlugin
             ]
           });
-          allDiagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+          allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
           noEmitOnError = options.noEmitOnError;
           if (allDiagnostics.length > 0) {
-            logger.error(ts2.formatDiagnosticsWithColorAndContext(_to_consumable_array(new Set(allDiagnostics)), formatHost));
+            logger.error(ts.formatDiagnosticsWithColorAndContext(_to_consumable_array(new Set(allDiagnostics)), formatHost));
             if (typeof noEmitOnError === "undefined" || noEmitOnError === true) {
               process.exit(1);
             }
@@ -182,14 +181,14 @@ export var compileByTs = function() {
     return _ref.apply(this, arguments);
   };
 }();
-var getFormatHost = function(ts2) {
+var getFormatHost = function(ts) {
   return {
     getCanonicalFileName: function(path2) {
       return path2;
     },
-    getCurrentDirectory: ts2.sys.getCurrentDirectory,
+    getCurrentDirectory: ts.sys.getCurrentDirectory,
     getNewLine: function() {
-      return ts2.sys.newLine;
+      return ts.sys.newLine;
     }
   };
 };

package/dist/esm-node/common/index.js

@@ -1,7 +1,5 @@
 import * as path from "path";
 import { fs } from "@modern-js/utils";
-import { compileByTs } from "../compilers/typescript";
-import { compileByBabel } from "../compilers/babel";
 export const FILE_EXTENSIONS = [
   ".js",
   ".ts",
@@ -24,8 +22,10 @@ export const compile = async (appDirectory, modernConfig, compileOptions) => {
   const compiler = modernConfig === null || modernConfig === void 0 ? void 0 : (_modernConfig_server = modernConfig.server) === null || _modernConfig_server === void 0 ? void 0 : _modernConfig_server.compiler;
   const isTsProject = tsconfigPath && await fs.pathExists(tsconfigPath);
   if (!isTsProject || compiler === "babel") {
+    const { compileByBabel } = await import("../compilers/babel");
     await compileByBabel(appDirectory, modernConfig, compileOptions);
   } else {
+    const { compileByTs } = await import("../compilers/typescript");
     await compileByTs(appDirectory, modernConfig, compileOptions);
   }
 };

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/index.js

@@ -0,0 +1,37 @@
+import normalizeOptions from "./normalizeOptions";
+import resolvePath from "./resolvePath";
+import transformCall from "./transformers/call";
+import transformImport from "./transformers/import";
+export { resolvePath };
+const importVisitors = {
+  CallExpression: transformCall,
+  "ImportDeclaration|ExportDeclaration": transformImport
+};
+const visitor = {
+  Program: {
+    enter(programPath, state) {
+      programPath.traverse(importVisitors, state);
+    },
+    exit(programPath, state) {
+      programPath.traverse(importVisitors, state);
+    }
+  }
+};
+export default ({ types }) => ({
+  name: "module-resolver",
+  manipulateOptions(opts) {
+    if (opts.filename === void 0) {
+      opts.filename = "unknown";
+    }
+  },
+  pre(file) {
+    this.types = types;
+    const currentFile = file.opts.filename;
+    this.normalizedOpts = normalizeOptions(currentFile, this.opts);
+    this.moduleResolverVisited = /* @__PURE__ */ new Set();
+  },
+  visitor,
+  post() {
+    this.moduleResolverVisited.clear();
+  }
+});

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/log.js

@@ -0,0 +1,3 @@
+export function warn(...args) {
+  console.warn(...args);
+}

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/mapPath.js

@@ -0,0 +1,17 @@
+import defaultResolvePath from "./resolvePath";
+export default function mapPathString(nodePath, state) {
+  if (!state.types.isStringLiteral(nodePath)) {
+    return;
+  }
+  const sourcePath = nodePath.node.value;
+  const currentFile = state.file.opts.filename;
+  const resolvePath = state.normalizedOpts.customResolvePath || defaultResolvePath;
+  const modulePath = resolvePath(sourcePath, currentFile, state.opts);
+  if (modulePath) {
+    if (nodePath.node.pathResolved) {
+      return;
+    }
+    nodePath.replaceWith(state.types.stringLiteral(modulePath));
+    nodePath.node.pathResolved = true;
+  }
+}

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/mapToRelative.js

@@ -0,0 +1,10 @@
+import path from "path";
+import { toPosixPath } from "./utils";
+export default function mapToRelative(cwd, currentFile, module) {
+  let from = path.dirname(currentFile);
+  let to = path.normalize(module);
+  from = path.resolve(cwd, from);
+  to = path.resolve(cwd, to);
+  const moduleMapped = path.relative(from, to);
+  return toPosixPath(moduleMapped);
+}

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/normalizeOptions.js

@@ -0,0 +1,146 @@
+import fs from "fs";
+import path from "path";
+import { createSelector } from "reselect";
+import findBabelConfig from "find-babel-config";
+import glob from "glob";
+import pkgUp from "pkg-up";
+import { escapeRegExp } from "./utils";
+const defaultExtensions = [
+  ".js",
+  ".jsx",
+  ".es",
+  ".es6",
+  ".mjs"
+];
+const defaultTransformedFunctions = [
+  "require",
+  "require.resolve",
+  "System.import",
+  // Jest methods
+  "jest.genMockFromModule",
+  "jest.mock",
+  "jest.unmock",
+  "jest.doMock",
+  "jest.dontMock",
+  "jest.setMock",
+  "jest.requireActual",
+  "jest.requireMock",
+  // Older Jest methods
+  "require.requireActual",
+  "require.requireMock"
+];
+function isRegExp(string) {
+  return string.startsWith("^") || string.endsWith("$");
+}
+const specialCwd = {
+  babelrc: (startPath) => findBabelConfig.sync(startPath).file,
+  packagejson: (startPath) => pkgUp.sync({
+    cwd: startPath
+  })
+};
+function normalizeCwd(optsCwd, currentFile) {
+  let cwd;
+  if (optsCwd in specialCwd) {
+    const startPath = currentFile === "unknown" ? "./" : currentFile;
+    const computedCwd = specialCwd[optsCwd](startPath);
+    cwd = computedCwd ? path.dirname(computedCwd) : null;
+  } else {
+    cwd = optsCwd;
+  }
+  return cwd || process.cwd();
+}
+function normalizeRoot(optsRoot, cwd) {
+  if (!optsRoot) {
+    return [];
+  }
+  const rootArray = Array.isArray(optsRoot) ? optsRoot : [
+    optsRoot
+  ];
+  return rootArray.map((dirPath) => path.resolve(cwd, dirPath)).reduce((resolvedDirs, absDirPath) => {
+    if (glob.hasMagic(absDirPath)) {
+      const roots = glob.sync(absDirPath).filter((resolvedPath) => fs.lstatSync(resolvedPath).isDirectory());
+      return [
+        ...resolvedDirs,
+        ...roots
+      ];
+    }
+    return [
+      ...resolvedDirs,
+      absDirPath
+    ];
+  }, []);
+}
+function getAliasTarget(key, isKeyRegExp) {
+  const regExpPattern = isKeyRegExp ? key : `^${escapeRegExp(key)}(/.*|)$`;
+  return new RegExp(regExpPattern);
+}
+function getAliasSubstitute(value, isKeyRegExp) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (!isKeyRegExp) {
+    return ([, match]) => {
+      if (Array.isArray(value)) {
+        return value.map((v) => `${v}${match}`);
+      }
+      return `${value}${match}`;
+    };
+  }
+  const parts = value.split("\\\\");
+  return (execResult) => parts.map((part) => part.replace(/\\\d+/g, (number) => execResult[number.slice(1)] || "")).join("\\");
+}
+function normalizeAlias(optsAlias) {
+  if (!optsAlias) {
+    return [];
+  }
+  const aliasArray = Array.isArray(optsAlias) ? optsAlias : [
+    optsAlias
+  ];
+  return aliasArray.reduce((aliasPairs, alias) => {
+    const aliasKeys = Object.keys(alias);
+    aliasKeys.forEach((key) => {
+      const isKeyRegExp = isRegExp(key);
+      aliasPairs.push([
+        getAliasTarget(key, isKeyRegExp),
+        getAliasSubstitute(alias[key], isKeyRegExp)
+      ]);
+    });
+    return aliasPairs;
+  }, []);
+}
+function normalizeTransformedFunctions(optsTransformFunctions) {
+  if (!optsTransformFunctions) {
+    return defaultTransformedFunctions;
+  }
+  return [
+    ...defaultTransformedFunctions,
+    ...optsTransformFunctions
+  ];
+}
+function normalizeLoglevel(optsLoglevel) {
+  return optsLoglevel || "warn";
+}
+export default createSelector(
+  // The currentFile should have an extension; otherwise it's considered a special value
+  (currentFile) => currentFile.includes(".") ? path.dirname(currentFile) : currentFile,
+  (_, opts) => opts,
+  (currentFile, opts) => {
+    const cwd = normalizeCwd(opts.cwd, currentFile);
+    const root = normalizeRoot(opts.root, cwd);
+    const alias = normalizeAlias(opts.alias);
+    const loglevel = normalizeLoglevel(opts.loglevel);
+    const transformFunctions = normalizeTransformedFunctions(opts.transformFunctions);
+    const extensions = opts.extensions || defaultExtensions;
+    const stripExtensions = opts.stripExtensions || extensions;
+    return {
+      cwd,
+      root,
+      alias,
+      loglevel,
+      transformFunctions,
+      extensions,
+      stripExtensions,
+      customResolvePath: opts.resolvePath
+    };
+  }
+);

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/resolvePath.js

@@ -0,0 +1,81 @@
+import path from "path";
+import { warn } from "./log";
+import mapToRelative from "./mapToRelative";
+import normalizeOptions from "./normalizeOptions";
+import { nodeResolvePath, replaceExtension, isRelativePath, toLocalPath, toPosixPath } from "./utils";
+function getRelativePath(sourcePath, currentFile, absFileInRoot, opts) {
+  const realSourceFileExtension = path.extname(absFileInRoot);
+  const sourceFileExtension = path.extname(sourcePath);
+  let relativePath = mapToRelative(opts.cwd, currentFile, absFileInRoot);
+  if (realSourceFileExtension !== sourceFileExtension) {
+    relativePath = replaceExtension(relativePath, opts);
+  }
+  return toLocalPath(toPosixPath(relativePath));
+}
+function findPathInRoots(sourcePath, { extensions, root }) {
+  let resolvedSourceFile;
+  root.some((basedir) => {
+    resolvedSourceFile = nodeResolvePath(`./${sourcePath}`, basedir, extensions);
+    return resolvedSourceFile !== null;
+  });
+  return resolvedSourceFile;
+}
+function resolvePathFromRootConfig(sourcePath, currentFile, opts) {
+  const absFileInRoot = findPathInRoots(sourcePath, opts);
+  if (!absFileInRoot) {
+    return null;
+  }
+  return getRelativePath(sourcePath, currentFile, absFileInRoot, opts);
+}
+function checkIfPackageExists(modulePath, currentFile, extensions, loglevel) {
+  const resolvedPath = nodeResolvePath(modulePath, currentFile, extensions);
+  if (resolvedPath === null && loglevel !== "silent") {
+    warn(`Could not resolve "${modulePath}" in file ${currentFile}.`);
+  }
+}
+function resolvePathFromAliasConfig(sourcePath, currentFile, opts) {
+  let aliasedSourceFile;
+  opts.alias.find(([regExp, substitute]) => {
+    const execResult = regExp.exec(sourcePath);
+    if (execResult === null) {
+      return false;
+    }
+    aliasedSourceFile = substitute(execResult);
+    return true;
+  });
+  if (!aliasedSourceFile) {
+    return null;
+  }
+  if (Array.isArray(aliasedSourceFile)) {
+    return aliasedSourceFile.map((asf) => {
+      if (isRelativePath(asf)) {
+        return toLocalPath(toPosixPath(mapToRelative(opts.cwd, currentFile, asf)));
+      }
+      return asf;
+    }).find((src) => nodeResolvePath(src, path.dirname(currentFile), opts.extensions));
+  }
+  if (isRelativePath(aliasedSourceFile)) {
+    return toLocalPath(toPosixPath(mapToRelative(opts.cwd, currentFile, aliasedSourceFile)));
+  }
+  if (process.env.NODE_ENV !== "production") {
+    checkIfPackageExists(aliasedSourceFile, currentFile, opts.extensions, opts.loglevel);
+  }
+  return aliasedSourceFile;
+}
+const resolvers = [
+  resolvePathFromAliasConfig,
+  resolvePathFromRootConfig
+];
+export default function resolvePath(sourcePath, currentFile, opts) {
+  if (isRelativePath(sourcePath)) {
+    return sourcePath;
+  }
+  const normalizedOpts = normalizeOptions(currentFile, opts);
+  const absoluteCurrentFile = path.resolve(currentFile);
+  let resolvedPath = null;
+  resolvers.some((resolver) => {
+    resolvedPath = resolver(sourcePath, absoluteCurrentFile, normalizedOpts);
+    return resolvedPath !== null;
+  });
+  return resolvedPath;
+}

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/transformers/call.js

@@ -0,0 +1,13 @@
+import { matchesPattern, isImportCall } from "../utils";
+import mapPathString from "../mapPath";
+export default function transformCall(nodePath, state) {
+  if (state.moduleResolverVisited.has(nodePath)) {
+    return;
+  }
+  const calleePath = nodePath.get("callee");
+  const isNormalCall = state.normalizedOpts.transformFunctions.some((pattern) => matchesPattern(state.types, calleePath, pattern));
+  if (isNormalCall || isImportCall(state.types, nodePath)) {
+    state.moduleResolverVisited.add(nodePath);
+    mapPathString(nodePath.get("arguments.0"), state);
+  }
+}

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/transformers/import.js

@@ -0,0 +1,8 @@
+import mapPathString from "../mapPath";
+export default function transformImport(nodePath, state) {
+  if (state.moduleResolverVisited.has(nodePath)) {
+    return;
+  }
+  state.moduleResolverVisited.add(nodePath);
+  mapPathString(nodePath.get("source"), state);
+}

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/src/utils.js

@@ -0,0 +1,57 @@
+import path from "path";
+import resolve from "resolve";
+export function nodeResolvePath(modulePath, basedir, extensions) {
+  try {
+    return resolve.sync(modulePath, {
+      basedir,
+      extensions
+    });
+  } catch (e) {
+    return null;
+  }
+}
+export function isRelativePath(nodePath) {
+  return nodePath.match(/^\.?\.\//);
+}
+export function toPosixPath(modulePath) {
+  return modulePath.replace(/\\/g, "/");
+}
+export function toLocalPath(modulePath) {
+  let localPath = modulePath.replace(/\/index$/, "");
+  if (!isRelativePath(localPath)) {
+    localPath = `./${localPath}`;
+  }
+  return localPath;
+}
+export function stripExtension(modulePath, stripExtensions) {
+  let name = path.basename(modulePath);
+  stripExtensions.some((extension) => {
+    if (name.endsWith(extension)) {
+      name = name.slice(0, name.length - extension.length);
+      return true;
+    }
+    return false;
+  });
+  return name;
+}
+export function replaceExtension(modulePath, opts) {
+  const filename = stripExtension(modulePath, opts.stripExtensions);
+  return path.join(path.dirname(modulePath), filename);
+}
+export function matchesPattern(types, calleePath, pattern) {
+  const { node } = calleePath;
+  if (types.isMemberExpression(node)) {
+    return calleePath.matchesPattern(pattern);
+  }
+  if (!types.isIdentifier(node) || pattern.includes(".")) {
+    return false;
+  }
+  const name = pattern.split(".")[0];
+  return node.name === name;
+}
+export function isImportCall(types, calleePath) {
+  return types.isImport(calleePath.node.callee);
+}
+export function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}