@modern-js/server-utils 2.26.1-alpha.1 → 2.28.0

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

@@ -1,16 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

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

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

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

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

@@ -1,37 +0,0 @@
-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

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

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

@@ -1,17 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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, "\\$&");
-}

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

@@ -1,87 +0,0 @@
-import { transform } from "@babel/core";
-import plugin from "../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: [
-      [
-        plugin,
-        {
-          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 = 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 = 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 = transform(code, transformerOpts);
-        expect(result.code).toBe(`${name}("./utils", ...args);`);
-      });
-      it("should handle no arguments", () => {
-        const code = `${name}();`;
-        const result = 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 = transform(code, transformerOpts);
-        expect(result.code).toBe(`${name}(path, ...args);`);
-      });
-      it("should handle an empty path", () => {
-        const code = `${name}('', ...args);`;
-        const result = 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 = 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 = 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 = 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 = transform(code, transformerOpts);
-    expect(result.code).toBe('unknown("components/Sidebar/Footer", ...args);');
-  });
-});

package/dist/esm-node/compilers/babel/plugins/babel-plugin-module-resolver/test/custom-call.test.js

@@ -1,68 +0,0 @@
-import { transform } from "babel-core";
-import plugin from "../src";
-const calls = [
-  "customMethod.something"
-];
-describe("custom calls", () => {
-  const transformerOpts = {
-    babelrc: false,
-    plugins: [
-      [
-        plugin,
-        {
-          root: "./test/testproject/src",
-          alias: {
-            test: "./test/testproject/test"
-          },
-          transformFunctions: [
-            "customMethod.something"
-          ]
-        }
-      ]
-    ]
-  };
-  calls.forEach((name) => {
-    describe(name, () => {
-      it("should resolve the path based on the root config", () => {
-        const code = `${name}("components/Header/SubHeader", ...args);`;
-        const result = 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 = 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 = transform(code, transformerOpts);
-        expect(result.code).toBe(`${name}("./utils", ...args);`);
-      });
-      it("should handle no arguments", () => {
-        const code = `${name}();`;
-        const result = 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 = transform(code, transformerOpts);
-        expect(result.code).toBe(`${name}(path, ...args);`);
-      });
-      it("should handle an empty path", () => {
-        const code = `${name}('', ...args);`;
-        const result = 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 = 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 = transform(code, transformerOpts);
-        expect(result.code).toBe(`before.${name}("components/Sidebar/Footer", ...args);`);
-      });
-    });
-  });
-});