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

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

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

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

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