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

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @modern-js/server-utils
 
+## 2.26.0
+
+### Patch Changes
+
+- 1fb5804: fix: should load typescript from direct dependencies on demand
+  fix: 按需从直接依赖中加载 typescript
+  - @modern-js/babel-preset-base@2.26.0
+  - @modern-js/babel-compiler@2.26.0
+  - @modern-js/utils@2.26.0
+
 ## 2.25.2
 
 ### Patch Changes

package/dist/cjs/common/index.js

@@ -20,8 +20,6 @@ _export(exports, {
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _path = /* @__PURE__ */ _interop_require_wildcard._(require("path"));
 const _utils = require("@modern-js/utils");
-const _typescript = require("../compilers/typescript");
-const _babel = require("../compilers/babel");
 const FILE_EXTENSIONS = [
   ".js",
   ".ts",
@@ -44,8 +42,10 @@ 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 _utils.fs.pathExists(tsconfigPath);
   if (!isTsProject || compiler === "babel") {
-    await (0, _babel.compileByBabel)(appDirectory, modernConfig, compileOptions);
+    const { compileByBabel } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../compilers/babel")));
+    await compileByBabel(appDirectory, modernConfig, compileOptions);
   } else {
-    await (0, _typescript.compileByTs)(appDirectory, modernConfig, compileOptions);
+    const { compileByTs } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../compilers/typescript")));
+    await compileByTs(appDirectory, modernConfig, compileOptions);
   }
 };

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  resolvePath: function() {
+    return _resolvePath.default;
+  },
+  default: function() {
+    return _default;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _normalizeOptions = /* @__PURE__ */ _interop_require_default._(require("./normalizeOptions"));
+const _resolvePath = /* @__PURE__ */ _interop_require_default._(require("./resolvePath"));
+const _call = /* @__PURE__ */ _interop_require_default._(require("./transformers/call"));
+const _import = /* @__PURE__ */ _interop_require_default._(require("./transformers/import"));
+const importVisitors = {
+  CallExpression: _call.default,
+  "ImportDeclaration|ExportDeclaration": _import.default
+};
+const visitor = {
+  Program: {
+    enter(programPath, state) {
+      programPath.traverse(importVisitors, state);
+    },
+    exit(programPath, state) {
+      programPath.traverse(importVisitors, state);
+    }
+  }
+};
+const _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 = (0, _normalizeOptions.default)(currentFile, this.opts);
+    this.moduleResolverVisited = /* @__PURE__ */ new Set();
+  },
+  visitor,
+  post() {
+    this.moduleResolverVisited.clear();
+  }
+});

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "warn", {
+  enumerable: true,
+  get: function() {
+    return warn;
+  }
+});
+function warn(...args) {
+  console.warn(...args);
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function() {
+    return mapPathString;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _resolvePath = /* @__PURE__ */ _interop_require_default._(require("./resolvePath"));
+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 || _resolvePath.default;
+  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/cjs/compilers/babel/plugins/babel-plugin-module-resolver/src/mapToRelative.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function() {
+    return mapToRelative;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
+const _utils = require("./utils");
+function mapToRelative(cwd, currentFile, module) {
+  let from = _path.default.dirname(currentFile);
+  let to = _path.default.normalize(module);
+  from = _path.default.resolve(cwd, from);
+  to = _path.default.resolve(cwd, to);
+  const moduleMapped = _path.default.relative(from, to);
+  return (0, _utils.toPosixPath)(moduleMapped);
+}

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function() {
+    return _default;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _fs = /* @__PURE__ */ _interop_require_default._(require("fs"));
+const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
+const _reselect = require("reselect");
+const _findbabelconfig = /* @__PURE__ */ _interop_require_default._(require("find-babel-config"));
+const _glob = /* @__PURE__ */ _interop_require_default._(require("glob"));
+const _pkgup = /* @__PURE__ */ _interop_require_default._(require("pkg-up"));
+const _utils = require("./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.default.sync(startPath).file,
+  packagejson: (startPath) => _pkgup.default.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.default.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.default.resolve(cwd, dirPath)).reduce((resolvedDirs, absDirPath) => {
+    if (_glob.default.hasMagic(absDirPath)) {
+      const roots = _glob.default.sync(absDirPath).filter((resolvedPath) => _fs.default.lstatSync(resolvedPath).isDirectory());
+      return [
+        ...resolvedDirs,
+        ...roots
+      ];
+    }
+    return [
+      ...resolvedDirs,
+      absDirPath
+    ];
+  }, []);
+}
+function getAliasTarget(key, isKeyRegExp) {
+  const regExpPattern = isKeyRegExp ? key : `^${(0, _utils.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";
+}
+const _default = (0, _reselect.createSelector)(
+  // The currentFile should have an extension; otherwise it's considered a special value
+  (currentFile) => currentFile.includes(".") ? _path.default.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/cjs/compilers/babel/plugins/babel-plugin-module-resolver/src/resolvePath.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function() {
+    return resolvePath;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
+const _log = require("./log");
+const _mapToRelative = /* @__PURE__ */ _interop_require_default._(require("./mapToRelative"));
+const _normalizeOptions = /* @__PURE__ */ _interop_require_default._(require("./normalizeOptions"));
+const _utils = require("./utils");
+function getRelativePath(sourcePath, currentFile, absFileInRoot, opts) {
+  const realSourceFileExtension = _path.default.extname(absFileInRoot);
+  const sourceFileExtension = _path.default.extname(sourcePath);
+  let relativePath = (0, _mapToRelative.default)(opts.cwd, currentFile, absFileInRoot);
+  if (realSourceFileExtension !== sourceFileExtension) {
+    relativePath = (0, _utils.replaceExtension)(relativePath, opts);
+  }
+  return (0, _utils.toLocalPath)((0, _utils.toPosixPath)(relativePath));
+}
+function findPathInRoots(sourcePath, { extensions, root }) {
+  let resolvedSourceFile;
+  root.some((basedir) => {
+    resolvedSourceFile = (0, _utils.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 = (0, _utils.nodeResolvePath)(modulePath, currentFile, extensions);
+  if (resolvedPath === null && loglevel !== "silent") {
+    (0, _log.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 ((0, _utils.isRelativePath)(asf)) {
+        return (0, _utils.toLocalPath)((0, _utils.toPosixPath)((0, _mapToRelative.default)(opts.cwd, currentFile, asf)));
+      }
+      return asf;
+    }).find((src) => (0, _utils.nodeResolvePath)(src, _path.default.dirname(currentFile), opts.extensions));
+  }
+  if ((0, _utils.isRelativePath)(aliasedSourceFile)) {
+    return (0, _utils.toLocalPath)((0, _utils.toPosixPath)((0, _mapToRelative.default)(opts.cwd, currentFile, aliasedSourceFile)));
+  }
+  if (process.env.NODE_ENV !== "production") {
+    checkIfPackageExists(aliasedSourceFile, currentFile, opts.extensions, opts.loglevel);
+  }
+  return aliasedSourceFile;
+}
+const resolvers = [
+  resolvePathFromAliasConfig,
+  resolvePathFromRootConfig
+];
+function resolvePath(sourcePath, currentFile, opts) {
+  if ((0, _utils.isRelativePath)(sourcePath)) {
+    return sourcePath;
+  }
+  const normalizedOpts = (0, _normalizeOptions.default)(currentFile, opts);
+  const absoluteCurrentFile = _path.default.resolve(currentFile);
+  let resolvedPath = null;
+  resolvers.some((resolver) => {
+    resolvedPath = resolver(sourcePath, absoluteCurrentFile, normalizedOpts);
+    return resolvedPath !== null;
+  });
+  return resolvedPath;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function() {
+    return transformCall;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _utils = require("../utils");
+const _mapPath = /* @__PURE__ */ _interop_require_default._(require("../mapPath"));
+function transformCall(nodePath, state) {
+  if (state.moduleResolverVisited.has(nodePath)) {
+    return;
+  }
+  const calleePath = nodePath.get("callee");
+  const isNormalCall = state.normalizedOpts.transformFunctions.some((pattern) => (0, _utils.matchesPattern)(state.types, calleePath, pattern));
+  if (isNormalCall || (0, _utils.isImportCall)(state.types, nodePath)) {
+    state.moduleResolverVisited.add(nodePath);
+    (0, _mapPath.default)(nodePath.get("arguments.0"), state);
+  }
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function() {
+    return transformImport;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _mapPath = /* @__PURE__ */ _interop_require_default._(require("../mapPath"));
+function transformImport(nodePath, state) {
+  if (state.moduleResolverVisited.has(nodePath)) {
+    return;
+  }
+  state.moduleResolverVisited.add(nodePath);
+  (0, _mapPath.default)(nodePath.get("source"), state);
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  nodeResolvePath: function() {
+    return nodeResolvePath;
+  },
+  isRelativePath: function() {
+    return isRelativePath;
+  },
+  toPosixPath: function() {
+    return toPosixPath;
+  },
+  toLocalPath: function() {
+    return toLocalPath;
+  },
+  stripExtension: function() {
+    return stripExtension;
+  },
+  replaceExtension: function() {
+    return replaceExtension;
+  },
+  matchesPattern: function() {
+    return matchesPattern;
+  },
+  isImportCall: function() {
+    return isImportCall;
+  },
+  escapeRegExp: function() {
+    return escapeRegExp;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
+const _resolve = /* @__PURE__ */ _interop_require_default._(require("resolve"));
+function nodeResolvePath(modulePath, basedir, extensions) {
+  try {
+    return _resolve.default.sync(modulePath, {
+      basedir,
+      extensions
+    });
+  } catch (e) {
+    return null;
+  }
+}
+function isRelativePath(nodePath) {
+  return nodePath.match(/^\.?\.\//);
+}
+function toPosixPath(modulePath) {
+  return modulePath.replace(/\\/g, "/");
+}
+function toLocalPath(modulePath) {
+  let localPath = modulePath.replace(/\/index$/, "");
+  if (!isRelativePath(localPath)) {
+    localPath = `./${localPath}`;
+  }
+  return localPath;
+}
+function stripExtension(modulePath, stripExtensions) {
+  let name = _path.default.basename(modulePath);
+  stripExtensions.some((extension) => {
+    if (name.endsWith(extension)) {
+      name = name.slice(0, name.length - extension.length);
+      return true;
+    }
+    return false;
+  });
+  return name;
+}
+function replaceExtension(modulePath, opts) {
+  const filename = stripExtension(modulePath, opts.stripExtensions);
+  return _path.default.join(_path.default.dirname(modulePath), filename);
+}
+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;
+}
+function isImportCall(types, calleePath) {
+  return types.isImport(calleePath.node.callee);
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/call.test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _core = require("@babel/core");
+const _src = /* @__PURE__ */ _interop_require_default._(require("../src"));
+const calls = [
+  "require",
+  "require.resolve",
+  "System.import",
+  "jest.genMockFromModule",
+  "jest.mock",
+  "jest.unmock",
+  "jest.doMock",
+  "jest.dontMock",
+  "jest.setMock",
+  "jest.requireActual",
+  "jest.requireMock",
+  "require.requireActual",
+  "require.requireMock"
+];
+describe("function and method calls", () => {
+  const transformerOpts = {
+    babelrc: false,
+    plugins: [
+      [
+        _src.default,
+        {
+          root: "./test/testproject/src",
+          alias: {
+            test: "./test/testproject/test"
+          }
+        }
+      ]
+    ]
+  };
+  calls.forEach((name) => {
+    describe(name, () => {
+      it("should resolve the path based on the root config", () => {
+        const code = `${name}("components/Header/SubHeader", ...args);`;
+        const result = (0, _core.transform)(code, transformerOpts);
+        expect(result.code).toBe(`${name}("./test/testproject/src/components/Header/SubHeader", ...args);`);
+      });
+      it("should alias the path", () => {
+        const code = `${name}("test", ...args);`;
+        const result = (0, _core.transform)(code, transformerOpts);
+        expect(result.code).toBe(`${name}("./test/testproject/test", ...args);`);
+      });
+      it("should not change a relative path", () => {
+        const code = `${name}("./utils", ...args);`;
+        const result = (0, _core.transform)(code, transformerOpts);
+        expect(result.code).toBe(`${name}("./utils", ...args);`);
+      });
+      it("should handle no arguments", () => {
+        const code = `${name}();`;
+        const result = (0, _core.transform)(code, transformerOpts);
+        expect(result.code).toBe(`${name}();`);
+      });
+      it("should handle the first argument not being a string literal", () => {
+        const code = `${name}(path, ...args);`;
+        const result = (0, _core.transform)(code, transformerOpts);
+        expect(result.code).toBe(`${name}(path, ...args);`);
+      });
+      it("should handle an empty path", () => {
+        const code = `${name}('', ...args);`;
+        const result = (0, _core.transform)(code, transformerOpts);
+        expect(result.code).toBe(`${name}('', ...args);`);
+      });
+      it("should ignore the call if the method name is not fully matched (suffix)", () => {
+        const code = `${name}.after("components/Sidebar/Footer", ...args);`;
+        const result = (0, _core.transform)(code, transformerOpts);
+        expect(result.code).toBe(`${name}.after("components/Sidebar/Footer", ...args);`);
+      });
+      it("should ignore the call if the method name is not fully matched (prefix)", () => {
+        const code = `before.${name}("components/Sidebar/Footer", ...args);`;
+        const result = (0, _core.transform)(code, transformerOpts);
+        expect(result.code).toBe(`before.${name}("components/Sidebar/Footer", ...args);`);
+      });
+    });
+  });
+  it("should resolve the path if the method name is a string literal", () => {
+    const code = 'require["resolve"]("components/Sidebar/Footer", ...args);';
+    const result = (0, _core.transform)(code, transformerOpts);
+    expect(result.code).toBe('require["resolve"]("./test/testproject/src/components/Sidebar/Footer", ...args);');
+  });
+  it("should ignore the call if the method name is unknown", () => {
+    const code = 'unknown("components/Sidebar/Footer", ...args);';
+    const result = (0, _core.transform)(code, transformerOpts);
+    expect(result.code).toBe('unknown("components/Sidebar/Footer", ...args);');
+  });
+});