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

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

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

@@ -1,92 +0,0 @@
-"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);');
-  });
-});

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

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _babelcore = require("babel-core");
-const _src = /* @__PURE__ */ _interop_require_default._(require("../src"));
-const calls = [
-  "customMethod.something"
-];
-describe("custom calls", () => {
-  const transformerOpts = {
-    babelrc: false,
-    plugins: [
-      [
-        _src.default,
-        {
-          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 = (0, _babelcore.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, _babelcore.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, _babelcore.transform)(code, transformerOpts);
-        expect(result.code).toBe(`${name}("./utils", ...args);`);
-      });
-      it("should handle no arguments", () => {
-        const code = `${name}();`;
-        const result = (0, _babelcore.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, _babelcore.transform)(code, transformerOpts);
-        expect(result.code).toBe(`${name}(path, ...args);`);
-      });
-      it("should handle an empty path", () => {
-        const code = `${name}('', ...args);`;
-        const result = (0, _babelcore.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, _babelcore.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, _babelcore.transform)(code, transformerOpts);
-        expect(result.code).toBe(`before.${name}("components/Sidebar/Footer", ...args);`);
-      });
-    });
-  });
-});

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

@@ -1,74 +0,0 @@
-"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"));
-describe("import()", () => {
-  const transformerOpts = {
-    babelrc: false,
-    plugins: [
-      // We need to add the corresponding syntax plugin
-      // in order to parse the `import()`-calls
-      "@babel/plugin-syntax-dynamic-import",
-      [
-        _src.default,
-        {
-          // root: [path.resolve(__dirname, './testproject/src')],
-          root: [
-            "./test/testproject/src"
-          ],
-          alias: {
-            test: "./test/testproject/test"
-          }
-        }
-      ]
-    ]
-  };
-  it("should resolve the path based on the root config", () => {
-    const code = 'import("components/Header/SubHeader").then(() => {}).catch(() => {});';
-    const result = (0, _core.transform)(code, transformerOpts);
-    expect(result.code).toBe('import("./test/testproject/src/components/Header/SubHeader").then(() => {}).catch(() => {});');
-  });
-  it("should alias the path", () => {
-    const code = 'import("test").then(() => {}).catch(() => {});';
-    const result = (0, _core.transform)(code, transformerOpts);
-    expect(result.code).toBe('import("./test/testproject/test").then(() => {}).catch(() => {});');
-  });
-  it("should not change a relative path", () => {
-    const code = 'import("./utils").then(() => {}).catch(() => {});';
-    const result = (0, _core.transform)(code, transformerOpts);
-    expect(result.code).toBe('import("./utils").then(() => {}).catch(() => {});');
-  });
-  it("should handle the first argument not being a string literal", () => {
-    const code = "import(path).then(() => {}).catch(() => {});";
-    const result = (0, _core.transform)(code, transformerOpts);
-    expect(result.code).toBe("import(path).then(() => {}).catch(() => {});");
-  });
-  it("should handle an empty path", () => {
-    const code = 'import("").then(() => {}).catch(() => {});';
-    const result = (0, _core.transform)(code, transformerOpts);
-    expect(result.code).toBe('import("").then(() => {}).catch(() => {});');
-  });
-  it("should handle imports added by other transforms", () => {
-    const options = {
-      ...transformerOpts,
-      plugins: [
-        function fakePlugin({ types }) {
-          return {
-            visitor: {
-              Identifier(path) {
-                path.replaceWith(types.Import());
-              }
-            }
-          };
-        },
-        ...transformerOpts.plugins
-      ]
-    };
-    const code = 'boo("components/Header/SubHeader");';
-    const result = (0, _core.transform)(code, options);
-    expect(result.code).toBe('import("./test/testproject/src/components/Header/SubHeader");');
-  });
-});

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

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _core = require("@babel/core");
-const _plugintransformmodulescommonjs = /* @__PURE__ */ _interop_require_default._(require("@babel/plugin-transform-modules-commonjs"));
-const _commontags = require("common-tags");
-const _src = /* @__PURE__ */ _interop_require_default._(require("../src"));
-describe("import and export statement", () => {
-  function testImport(source, output, transformerOpts2) {
-    it("with an import statement", () => {
-      const code = `import something from "${source}";`;
-      const result = (0, _core.transform)(code, transformerOpts2);
-      expect(result.code).toBe(`import something from "${output}";`);
-    });
-    it('with an "export from" statement', () => {
-      const code = `export { something } from "${source}";`;
-      const result = (0, _core.transform)(code, transformerOpts2);
-      expect(result.code).toBe(`export { something } from "${output}";`);
-    });
-    it("with an export statement", () => {
-      const code = "let something; export { something }";
-      const result = (0, _core.transform)(code, transformerOpts2);
-      expect(result.code).toBe("let something;\nexport { something };");
-    });
-  }
-  function testImportWithCommonJSTransform(source, output, transformerOpts2) {
-    const transformerOptsWithCommonJs = {
-      babelrc: false,
-      plugins: [
-        ...transformerOpts2.plugins,
-        [
-          _plugintransformmodulescommonjs.default,
-          {
-            noInterop: true
-          }
-        ]
-      ]
-    };
-    it("with a transformed require statement", () => {
-      const code = `var something = require("${source}");`;
-      const result = (0, _core.transform)(code, transformerOptsWithCommonJs);
-      expect(result.code).toContain(`require("${output}");`);
-    });
-    it("with a transformed import statement", () => {
-      const code = `import something from "${source}";`;
-      const result = (0, _core.transform)(code, transformerOptsWithCommonJs);
-      expect(result.code).toContain(`require("${output}");`);
-    });
-    it('with a transformed "export from" statement', () => {
-      const code = `export { something } from "${source}";`;
-      const result = (0, _core.transform)(code, transformerOptsWithCommonJs);
-      expect(result.code).toContain(`require("${output}");`);
-    });
-    it("with a transformed export statement", () => {
-      const code = "let something; export { something };";
-      const result = (0, _core.transform)(code, transformerOptsWithCommonJs);
-      expect(result.code).toBe((0, _commontags.stripIndent)`
-        "use strict";
-
-        Object.defineProperty(exports, "__esModule", {
-          value: true
-        });
-        exports.something = void 0;
-        let something;
-        exports.something = something;
-      `);
-    });
-  }
-  function testImports(source, output, transformerOpts2) {
-    testImport(source, output, transformerOpts2);
-    testImportWithCommonJSTransform(source, output, transformerOpts2);
-  }
-  const transformerOpts = {
-    babelrc: false,
-    plugins: [
-      [
-        _src.default,
-        {
-          root: "./test/testproject/src",
-          alias: {
-            test: "./test/testproject/test",
-            "@babel/core": "@babel/core/lib"
-          }
-        }
-      ]
-    ]
-  };
-  describe("should resolve the path based on the root config", () => {
-    testImports("components/Header/SubHeader", "./test/testproject/src/components/Header/SubHeader", transformerOpts);
-  });
-  describe("should alias the path", () => {
-    testImports("test", "./test/testproject/test", transformerOpts);
-  });
-  describe("should not change a relative path", () => {
-    testImports("./utils", "./utils", transformerOpts);
-  });
-  describe("should handle an empty path", () => {
-    testImports("", "", transformerOpts);
-  });
-  describe("should only apply the alias once", () => {
-    testImports("@babel/core/transform", "@babel/core/lib/transform", transformerOpts);
-  });
-  describe("should ignore the call if a non-import statement is used", () => {
-    const code = (0, _commontags.stripIndent)`
-      function test() {
-        return "components/Sidebar/Footer";
-      }
-    `;
-    const result = (0, _core.transform)(code, transformerOpts);
-    expect(result.code).toBe((0, _commontags.stripIndent)`
-      function test() {
-        return "components/Sidebar/Footer";
-      }
-    `);
-  });
-});