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

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

@@ -0,0 +1,87 @@
+import { transform } from "@babel/core";
+import plugin from "../src";
+var 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", function() {
+  var transformerOpts = {
+    babelrc: false,
+    plugins: [
+      [
+        plugin,
+        {
+          root: "./test/testproject/src",
+          alias: {
+            test: "./test/testproject/test"
+          }
+        }
+      ]
+    ]
+  };
+  calls.forEach(function(name) {
+    describe(name, function() {
+      it("should resolve the path based on the root config", function() {
+        var code = "".concat(name, '("components/Header/SubHeader", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, '("./test/testproject/src/components/Header/SubHeader", ...args);'));
+      });
+      it("should alias the path", function() {
+        var code = "".concat(name, '("test", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, '("./test/testproject/test", ...args);'));
+      });
+      it("should not change a relative path", function() {
+        var code = "".concat(name, '("./utils", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, '("./utils", ...args);'));
+      });
+      it("should handle no arguments", function() {
+        var code = "".concat(name, "();");
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, "();"));
+      });
+      it("should handle the first argument not being a string literal", function() {
+        var code = "".concat(name, "(path, ...args);");
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, "(path, ...args);"));
+      });
+      it("should handle an empty path", function() {
+        var code = "".concat(name, "('', ...args);");
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, "('', ...args);"));
+      });
+      it("should ignore the call if the method name is not fully matched (suffix)", function() {
+        var code = "".concat(name, '.after("components/Sidebar/Footer", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, '.after("components/Sidebar/Footer", ...args);'));
+      });
+      it("should ignore the call if the method name is not fully matched (prefix)", function() {
+        var code = "before.".concat(name, '("components/Sidebar/Footer", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("before.".concat(name, '("components/Sidebar/Footer", ...args);'));
+      });
+    });
+  });
+  it("should resolve the path if the method name is a string literal", function() {
+    var code = 'require["resolve"]("components/Sidebar/Footer", ...args);';
+    var 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", function() {
+    var code = 'unknown("components/Sidebar/Footer", ...args);';
+    var result = transform(code, transformerOpts);
+    expect(result.code).toBe('unknown("components/Sidebar/Footer", ...args);');
+  });
+});

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

@@ -0,0 +1,68 @@
+import { transform } from "babel-core";
+import plugin from "../src";
+var calls = [
+  "customMethod.something"
+];
+describe("custom calls", function() {
+  var transformerOpts = {
+    babelrc: false,
+    plugins: [
+      [
+        plugin,
+        {
+          root: "./test/testproject/src",
+          alias: {
+            test: "./test/testproject/test"
+          },
+          transformFunctions: [
+            "customMethod.something"
+          ]
+        }
+      ]
+    ]
+  };
+  calls.forEach(function(name) {
+    describe(name, function() {
+      it("should resolve the path based on the root config", function() {
+        var code = "".concat(name, '("components/Header/SubHeader", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, '("./test/testproject/src/components/Header/SubHeader", ...args);'));
+      });
+      it("should alias the path", function() {
+        var code = "".concat(name, '("test", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, '("./test/testproject/test", ...args);'));
+      });
+      it("should not change a relative path", function() {
+        var code = "".concat(name, '("./utils", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, '("./utils", ...args);'));
+      });
+      it("should handle no arguments", function() {
+        var code = "".concat(name, "();");
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, "();"));
+      });
+      it("should handle the first argument not being a string literal", function() {
+        var code = "".concat(name, "(path, ...args);");
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, "(path, ...args);"));
+      });
+      it("should handle an empty path", function() {
+        var code = "".concat(name, "('', ...args);");
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, "('', ...args);"));
+      });
+      it("should ignore the call if the method name is not fully matched (suffix)", function() {
+        var code = "".concat(name, '.after("components/Sidebar/Footer", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("".concat(name, '.after("components/Sidebar/Footer", ...args);'));
+      });
+      it("should ignore the call if the method name is not fully matched (prefix)", function() {
+        var code = "before.".concat(name, '("components/Sidebar/Footer", ...args);');
+        var result = transform(code, transformerOpts);
+        expect(result.code).toBe("before.".concat(name, '("components/Sidebar/Footer", ...args);'));
+      });
+    });
+  });
+});

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

@@ -0,0 +1,71 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { transform } from "@babel/core";
+import plugin from "../src";
+describe("import()", function() {
+  var transformerOpts = {
+    babelrc: false,
+    plugins: [
+      // We need to add the corresponding syntax plugin
+      // in order to parse the `import()`-calls
+      "@babel/plugin-syntax-dynamic-import",
+      [
+        plugin,
+        {
+          // 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", function() {
+    var code = 'import("components/Header/SubHeader").then(() => {}).catch(() => {});';
+    var result = transform(code, transformerOpts);
+    expect(result.code).toBe('import("./test/testproject/src/components/Header/SubHeader").then(() => {}).catch(() => {});');
+  });
+  it("should alias the path", function() {
+    var code = 'import("test").then(() => {}).catch(() => {});';
+    var result = transform(code, transformerOpts);
+    expect(result.code).toBe('import("./test/testproject/test").then(() => {}).catch(() => {});');
+  });
+  it("should not change a relative path", function() {
+    var code = 'import("./utils").then(() => {}).catch(() => {});';
+    var result = transform(code, transformerOpts);
+    expect(result.code).toBe('import("./utils").then(() => {}).catch(() => {});');
+  });
+  it("should handle the first argument not being a string literal", function() {
+    var code = "import(path).then(() => {}).catch(() => {});";
+    var result = transform(code, transformerOpts);
+    expect(result.code).toBe("import(path).then(() => {}).catch(() => {});");
+  });
+  it("should handle an empty path", function() {
+    var code = 'import("").then(() => {}).catch(() => {});';
+    var result = transform(code, transformerOpts);
+    expect(result.code).toBe('import("").then(() => {}).catch(() => {});');
+  });
+  it("should handle imports added by other transforms", function() {
+    var options = _object_spread_props(_object_spread({}, transformerOpts), {
+      plugins: [
+        function fakePlugin(param) {
+          var types = param.types;
+          return {
+            visitor: {
+              Identifier: function Identifier(path) {
+                path.replaceWith(types.Import());
+              }
+            }
+          };
+        }
+      ].concat(_to_consumable_array(transformerOpts.plugins))
+    });
+    var code = 'boo("components/Header/SubHeader");';
+    var result = transform(code, options);
+    expect(result.code).toBe('import("./test/testproject/src/components/Header/SubHeader");');
+  });
+});

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

@@ -0,0 +1,124 @@
+import { _ as _tagged_template_literal } from "@swc/helpers/_/_tagged_template_literal";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+function _templateObject() {
+  var data = _tagged_template_literal([
+    '\n        "use strict";\n\n        Object.defineProperty(exports, "__esModule", {\n          value: true\n        });\n        exports.something = void 0;\n        let something;\n        exports.something = something;\n      '
+  ]);
+  _templateObject = function _templateObject3() {
+    return data;
+  };
+  return data;
+}
+function _templateObject1() {
+  var data = _tagged_template_literal([
+    '\n      function test() {\n        return "components/Sidebar/Footer";\n      }\n    '
+  ]);
+  _templateObject1 = function _templateObject12() {
+    return data;
+  };
+  return data;
+}
+function _templateObject2() {
+  var data = _tagged_template_literal([
+    '\n      function test() {\n        return "components/Sidebar/Footer";\n      }\n    '
+  ]);
+  _templateObject2 = function _templateObject22() {
+    return data;
+  };
+  return data;
+}
+import { transform } from "@babel/core";
+import transformToCommonJsPlugin from "@babel/plugin-transform-modules-commonjs";
+import { stripIndent } from "common-tags";
+import plugin from "../src";
+describe("import and export statement", function() {
+  var testImport = function testImport2(source, output, transformerOpts2) {
+    it("with an import statement", function() {
+      var code = 'import something from "'.concat(source, '";');
+      var result = transform(code, transformerOpts2);
+      expect(result.code).toBe('import something from "'.concat(output, '";'));
+    });
+    it('with an "export from" statement', function() {
+      var code = 'export { something } from "'.concat(source, '";');
+      var result = transform(code, transformerOpts2);
+      expect(result.code).toBe('export { something } from "'.concat(output, '";'));
+    });
+    it("with an export statement", function() {
+      var code = "let something; export { something }";
+      var result = transform(code, transformerOpts2);
+      expect(result.code).toBe("let something;\nexport { something };");
+    });
+  };
+  var testImportWithCommonJSTransform = function testImportWithCommonJSTransform2(source, output, transformerOpts2) {
+    var transformerOptsWithCommonJs = {
+      babelrc: false,
+      plugins: _to_consumable_array(transformerOpts2.plugins).concat([
+        [
+          transformToCommonJsPlugin,
+          {
+            noInterop: true
+          }
+        ]
+      ])
+    };
+    it("with a transformed require statement", function() {
+      var code = 'var something = require("'.concat(source, '");');
+      var result = transform(code, transformerOptsWithCommonJs);
+      expect(result.code).toContain('require("'.concat(output, '");'));
+    });
+    it("with a transformed import statement", function() {
+      var code = 'import something from "'.concat(source, '";');
+      var result = transform(code, transformerOptsWithCommonJs);
+      expect(result.code).toContain('require("'.concat(output, '");'));
+    });
+    it('with a transformed "export from" statement', function() {
+      var code = 'export { something } from "'.concat(source, '";');
+      var result = transform(code, transformerOptsWithCommonJs);
+      expect(result.code).toContain('require("'.concat(output, '");'));
+    });
+    it("with a transformed export statement", function() {
+      var code = "let something; export { something };";
+      var result = transform(code, transformerOptsWithCommonJs);
+      expect(result.code).toBe(stripIndent(_templateObject()));
+    });
+  };
+  var testImports = function testImports2(source, output, transformerOpts2) {
+    testImport(source, output, transformerOpts2);
+    testImportWithCommonJSTransform(source, output, transformerOpts2);
+  };
+  var transformerOpts = {
+    babelrc: false,
+    plugins: [
+      [
+        plugin,
+        {
+          root: "./test/testproject/src",
+          alias: {
+            test: "./test/testproject/test",
+            "@babel/core": "@babel/core/lib"
+          }
+        }
+      ]
+    ]
+  };
+  describe("should resolve the path based on the root config", function() {
+    testImports("components/Header/SubHeader", "./test/testproject/src/components/Header/SubHeader", transformerOpts);
+  });
+  describe("should alias the path", function() {
+    testImports("test", "./test/testproject/test", transformerOpts);
+  });
+  describe("should not change a relative path", function() {
+    testImports("./utils", "./utils", transformerOpts);
+  });
+  describe("should handle an empty path", function() {
+    testImports("", "", transformerOpts);
+  });
+  describe("should only apply the alias once", function() {
+    testImports("@babel/core/transform", "@babel/core/lib/transform", transformerOpts);
+  });
+  describe("should ignore the call if a non-import statement is used", function() {
+    var code = stripIndent(_templateObject1());
+    var result = transform(code, transformerOpts);
+    expect(result.code).toBe(stripIndent(_templateObject2()));
+  });
+});