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

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
+const _mapToRelative = /* @__PURE__ */ _interop_require_default._(require("../src/mapToRelative"));
+describe("mapToRelative", () => {
+  describe("should map to relative path with a custom cwd", () => {
+    it("with a relative filename", () => {
+      const currentFile = "./utils/test/file.js";
+      const result = (0, _mapToRelative.default)(_path.default.resolve("./test"), currentFile, "utils/dep");
+      expect(result).toBe("../dep");
+    });
+    it("with an absolute filename", () => {
+      const currentFile = _path.default.resolve("./utils/test/file.js");
+      const result = (0, _mapToRelative.default)(_path.default.resolve("."), currentFile, "utils/dep");
+      expect(result).toBe("../dep");
+    });
+  });
+});

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _normalizeOptions = /* @__PURE__ */ _interop_require_default._(require("../src/normalizeOptions"));
+describe("normalizeOptions", () => {
+  beforeEach(() => {
+    _normalizeOptions.default.resetRecomputations();
+  });
+  it("should return the memoized options when the dirnames are the same", () => {
+    const options = {};
+    const result = (0, _normalizeOptions.default)("path/a.js", options);
+    const result2 = (0, _normalizeOptions.default)("path/b.js", options);
+    expect(result).toBe(result2);
+    expect(_normalizeOptions.default.recomputations()).toEqual(1);
+  });
+  it("should return the memoized options when the special paths are the same", () => {
+    const options = {};
+    const result = (0, _normalizeOptions.default)("unknown", options);
+    const result2 = (0, _normalizeOptions.default)("unknown", options);
+    expect(result).toBe(result2);
+    expect(_normalizeOptions.default.recomputations()).toEqual(1);
+  });
+  it("should recompute when the options object is not the same", () => {
+    const options = {};
+    const options2 = {};
+    const result = (0, _normalizeOptions.default)("path/to/file.js", options);
+    const result2 = (0, _normalizeOptions.default)("path/to/file.js", options2);
+    expect(result).not.toBe(result2);
+    expect(_normalizeOptions.default.recomputations()).toEqual(2);
+  });
+  it("should correctly normalize alias option if it is an array", () => {
+    const options = {
+      alias: [
+        {
+          foo: "A",
+          bar: "B"
+        },
+        {
+          baz: "C"
+        }
+      ]
+    };
+    const { alias } = (0, _normalizeOptions.default)("path/to/file.js", options);
+    expect(alias[0][0]).toEqual(/^foo(\/.*|)$/);
+    expect(alias[1][0]).toEqual(/^bar(\/.*|)$/);
+    expect(alias[2][0]).toEqual(/^baz(\/.*|)$/);
+  });
+});

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/example-file.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/node_modules/first/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/node_modules/second/index.js

@@ -0,0 +1 @@
+"use strict";

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

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

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/actions/something.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/app.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/components/App.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/components/Header/SubHeader.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/components/Header/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/components/Root.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/components/Sidebar/Footer/SidebarFooterButton.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/components/Sidebar/Footer/index.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/constants/actions.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/constants.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/libs/custom.modernizr3.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/nodemodule.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/rn/index.android.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/compilers/babel/plugins/babel-plugin-module-resolver/test/testproject/src/rn/index.ios.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function() {
+    return x;
+  }
+});
+function x() {
+}

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

@@ -12,7 +12,7 @@ const _interop_require_default = require("@swc/helpers/_/_interop_require_defaul
 const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
 const _tsconfigpaths = require("@modern-js/utils/tsconfig-paths");
 const _utils = require("@modern-js/utils");
-const { resolvePath } = require("babel-plugin-module-resolver");
+const { resolvePath } = require("../plugins/babel-plugin-module-resolver/src");
 const defaultPaths = {
   "@": [
     "./src"
@@ -73,7 +73,7 @@ const aliasPlugin = (alias) => {
     ".mjs"
   ];
   return [
-    "babel-plugin-module-resolver",
+    "../plugins/babel-plugin-module-resolver/src",
     {
       root: absoluteBaseUrl,
       alias: mergedPaths,

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

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

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

@@ -0,0 +1,8 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+export function warn() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  var _console;
+  (_console = console).warn.apply(_console, _to_consumable_array(args));
+}

package/dist/esm/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;
+  }
+  var sourcePath = nodePath.node.value;
+  var currentFile = state.file.opts.filename;
+  var resolvePath = state.normalizedOpts.customResolvePath || defaultResolvePath;
+  var 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/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) {
+  var from = path.dirname(currentFile);
+  var to = path.normalize(module);
+  from = path.resolve(cwd, from);
+  to = path.resolve(cwd, to);
+  var moduleMapped = path.relative(from, to);
+  return toPosixPath(moduleMapped);
+}

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

@@ -0,0 +1,162 @@
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+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";
+var defaultExtensions = [
+  ".js",
+  ".jsx",
+  ".es",
+  ".es6",
+  ".mjs"
+];
+var 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("$");
+}
+var specialCwd = {
+  babelrc: function(startPath) {
+    return findBabelConfig.sync(startPath).file;
+  },
+  packagejson: function(startPath) {
+    return pkgUp.sync({
+      cwd: startPath
+    });
+  }
+};
+function normalizeCwd(optsCwd, currentFile) {
+  var cwd;
+  if (optsCwd in specialCwd) {
+    var startPath = currentFile === "unknown" ? "./" : currentFile;
+    var computedCwd = specialCwd[optsCwd](startPath);
+    cwd = computedCwd ? path.dirname(computedCwd) : null;
+  } else {
+    cwd = optsCwd;
+  }
+  return cwd || process.cwd();
+}
+function normalizeRoot(optsRoot, cwd) {
+  if (!optsRoot) {
+    return [];
+  }
+  var rootArray = Array.isArray(optsRoot) ? optsRoot : [
+    optsRoot
+  ];
+  return rootArray.map(function(dirPath) {
+    return path.resolve(cwd, dirPath);
+  }).reduce(function(resolvedDirs, absDirPath) {
+    if (glob.hasMagic(absDirPath)) {
+      var roots = glob.sync(absDirPath).filter(function(resolvedPath) {
+        return fs.lstatSync(resolvedPath).isDirectory();
+      });
+      return _to_consumable_array(resolvedDirs).concat(_to_consumable_array(roots));
+    }
+    return _to_consumable_array(resolvedDirs).concat([
+      absDirPath
+    ]);
+  }, []);
+}
+function getAliasTarget(key, isKeyRegExp) {
+  var regExpPattern = isKeyRegExp ? key : "^".concat(escapeRegExp(key), "(/.*|)$");
+  return new RegExp(regExpPattern);
+}
+function getAliasSubstitute(value, isKeyRegExp) {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (!isKeyRegExp) {
+    return function(param) {
+      var _param = _sliced_to_array(param, 2), match = _param[1];
+      if (Array.isArray(value)) {
+        return value.map(function(v) {
+          return "".concat(v).concat(match);
+        });
+      }
+      return "".concat(value).concat(match);
+    };
+  }
+  var parts = value.split("\\\\");
+  return function(execResult) {
+    return parts.map(function(part) {
+      return part.replace(/\\\d+/g, function(number) {
+        return execResult[number.slice(1)] || "";
+      });
+    }).join("\\");
+  };
+}
+function normalizeAlias(optsAlias) {
+  if (!optsAlias) {
+    return [];
+  }
+  var aliasArray = Array.isArray(optsAlias) ? optsAlias : [
+    optsAlias
+  ];
+  return aliasArray.reduce(function(aliasPairs, alias) {
+    var aliasKeys = Object.keys(alias);
+    aliasKeys.forEach(function(key) {
+      var isKeyRegExp = isRegExp(key);
+      aliasPairs.push([
+        getAliasTarget(key, isKeyRegExp),
+        getAliasSubstitute(alias[key], isKeyRegExp)
+      ]);
+    });
+    return aliasPairs;
+  }, []);
+}
+function normalizeTransformedFunctions(optsTransformFunctions) {
+  if (!optsTransformFunctions) {
+    return defaultTransformedFunctions;
+  }
+  return _to_consumable_array(defaultTransformedFunctions).concat(_to_consumable_array(optsTransformFunctions));
+}
+function normalizeLoglevel(optsLoglevel) {
+  return optsLoglevel || "warn";
+}
+export default createSelector(
+  // The currentFile should have an extension; otherwise it's considered a special value
+  function(currentFile) {
+    return currentFile.includes(".") ? path.dirname(currentFile) : currentFile;
+  },
+  function(_, opts) {
+    return opts;
+  },
+  function(currentFile, opts) {
+    var cwd = normalizeCwd(opts.cwd, currentFile);
+    var root = normalizeRoot(opts.root, cwd);
+    var alias = normalizeAlias(opts.alias);
+    var loglevel = normalizeLoglevel(opts.loglevel);
+    var transformFunctions = normalizeTransformedFunctions(opts.transformFunctions);
+    var extensions = opts.extensions || defaultExtensions;
+    var stripExtensions = opts.stripExtensions || extensions;
+    return {
+      cwd: cwd,
+      root: root,
+      alias: alias,
+      loglevel: loglevel,
+      transformFunctions: transformFunctions,
+      extensions: extensions,
+      stripExtensions: stripExtensions,
+      customResolvePath: opts.resolvePath
+    };
+  }
+);

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

@@ -0,0 +1,86 @@
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+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) {
+  var realSourceFileExtension = path.extname(absFileInRoot);
+  var sourceFileExtension = path.extname(sourcePath);
+  var relativePath = mapToRelative(opts.cwd, currentFile, absFileInRoot);
+  if (realSourceFileExtension !== sourceFileExtension) {
+    relativePath = replaceExtension(relativePath, opts);
+  }
+  return toLocalPath(toPosixPath(relativePath));
+}
+function findPathInRoots(sourcePath, param) {
+  var extensions = param.extensions, root = param.root;
+  var resolvedSourceFile;
+  root.some(function(basedir) {
+    resolvedSourceFile = nodeResolvePath("./".concat(sourcePath), basedir, extensions);
+    return resolvedSourceFile !== null;
+  });
+  return resolvedSourceFile;
+}
+function resolvePathFromRootConfig(sourcePath, currentFile, opts) {
+  var absFileInRoot = findPathInRoots(sourcePath, opts);
+  if (!absFileInRoot) {
+    return null;
+  }
+  return getRelativePath(sourcePath, currentFile, absFileInRoot, opts);
+}
+function checkIfPackageExists(modulePath, currentFile, extensions, loglevel) {
+  var resolvedPath = nodeResolvePath(modulePath, currentFile, extensions);
+  if (resolvedPath === null && loglevel !== "silent") {
+    warn('Could not resolve "'.concat(modulePath, '" in file ').concat(currentFile, "."));
+  }
+}
+function resolvePathFromAliasConfig(sourcePath, currentFile, opts) {
+  var aliasedSourceFile;
+  opts.alias.find(function(param) {
+    var _param = _sliced_to_array(param, 2), regExp = _param[0], substitute = _param[1];
+    var 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(function(asf) {
+      if (isRelativePath(asf)) {
+        return toLocalPath(toPosixPath(mapToRelative(opts.cwd, currentFile, asf)));
+      }
+      return asf;
+    }).find(function(src) {
+      return 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;
+}
+var resolvers = [
+  resolvePathFromAliasConfig,
+  resolvePathFromRootConfig
+];
+export default function resolvePath(sourcePath, currentFile, opts) {
+  if (isRelativePath(sourcePath)) {
+    return sourcePath;
+  }
+  var normalizedOpts = normalizeOptions(currentFile, opts);
+  var absoluteCurrentFile = path.resolve(currentFile);
+  var resolvedPath = null;
+  resolvers.some(function(resolver) {
+    resolvedPath = resolver(sourcePath, absoluteCurrentFile, normalizedOpts);
+    return resolvedPath !== null;
+  });
+  return resolvedPath;
+}

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

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

package/dist/esm/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/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: basedir,
+      extensions: extensions
+    });
+  } catch (e) {
+    return null;
+  }
+}
+export function isRelativePath(nodePath) {
+  return nodePath.match(/^\.?\.\//);
+}
+export function toPosixPath(modulePath) {
+  return modulePath.replace(/\\/g, "/");
+}
+export function toLocalPath(modulePath) {
+  var localPath = modulePath.replace(/\/index$/, "");
+  if (!isRelativePath(localPath)) {
+    localPath = "./".concat(localPath);
+  }
+  return localPath;
+}
+export function stripExtension(modulePath, stripExtensions) {
+  var name = path.basename(modulePath);
+  stripExtensions.some(function(extension) {
+    if (name.endsWith(extension)) {
+      name = name.slice(0, name.length - extension.length);
+      return true;
+    }
+    return false;
+  });
+  return name;
+}
+export function replaceExtension(modulePath, opts) {
+  var filename = stripExtension(modulePath, opts.stripExtensions);
+  return path.join(path.dirname(modulePath), filename);
+}
+export function matchesPattern(types, calleePath, pattern) {
+  var node = calleePath.node;
+  if (types.isMemberExpression(node)) {
+    return calleePath.matchesPattern(pattern);
+  }
+  if (!types.isIdentifier(node) || pattern.includes(".")) {
+    return false;
+  }
+  var 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, "\\$&");
+}