@modern-js/server-utils 2.4.1-beta.0 → 2.5.1-alpha.0

package/dist/esm-node/compilers/babel/index.js

@@ -0,0 +1,116 @@
+import * as path from "path";
+import {
+  getBabelChain,
+  applyUserBabelConfig
+} from "@modern-js/babel-preset-lib";
+import { fs, json5, getAliasConfig } from "@modern-js/utils";
+import { compiler } from "@modern-js/babel-compiler";
+import { FILE_EXTENSIONS } from "../../common";
+export * from "@babel/core";
+const readTsConfig = (tsconfigPath, noExistReturn = null) => {
+  if (!fs.existsSync(tsconfigPath)) {
+    return noExistReturn;
+  }
+  const content = fs.readFileSync(tsconfigPath, "utf-8");
+  return json5.parse(content);
+};
+const existTsConfigFile = (tsconfigAbsolutePath) => {
+  const tsconfig = readTsConfig(tsconfigAbsolutePath);
+  return Boolean(tsconfig);
+};
+const getBabelConfig = (libPresetOption, syntaxOption) => {
+  const chain = getBabelChain(libPresetOption, syntaxOption);
+  return {
+    sourceType: "unambiguous",
+    ...chain.toJSON()
+  };
+};
+const resolveBabelConfig = (appDirectory, config, option) => {
+  const { globalVars, alias, babelConfig, define } = config;
+  const globalDefineVars = define && Object.entries(define).reduce((object, [key, value]) => {
+    object[key] = JSON.stringify(value);
+    return object;
+  }, {});
+  const aliasConfig = getAliasConfig(alias, {
+    appDirectory,
+    ...option
+  });
+  const babelChain = getBabelChain(
+    {
+      appDirectory,
+      enableReactPreset: true,
+      enableTypescriptPreset: true,
+      alias: aliasConfig,
+      envVars: [],
+      globalVars: {
+        ...globalVars,
+        ...globalDefineVars
+      }
+    },
+    {
+      type: option.type,
+      syntax: option.syntax
+    }
+  );
+  const envOptions = babelChain.preset("@babel/preset-env").options();
+  babelChain.preset("@babel/preset-env").use(require.resolve("@babel/preset-env"), [
+    {
+      ...envOptions[0],
+      loose: true
+    }
+  ]);
+  babelChain.plugin("babel-plugin-transform-typescript-metadata").use(
+    require.resolve("babel-plugin-transform-typescript-metadata"),
+    []
+  );
+  babelChain.plugin("@babel/plugin-proposal-decorators").use(require.resolve("@babel/plugin-proposal-decorators"), [
+    { legacy: true }
+  ]);
+  babelChain.plugin("@babel/plugin-proposal-class-properties").use(require.resolve("@babel/plugin-proposal-class-properties"), [
+    {
+      loose: true
+    }
+  ]);
+  const internalBabelConfig = { ...babelChain.toJSON() };
+  return applyUserBabelConfig(internalBabelConfig, babelConfig);
+};
+const compileByBabel = async (appDirectory, config, compileOptions) => {
+  const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+  const results = await Promise.all(
+    sourceDirs.map(async (sourceDir) => {
+      const babelConfig = resolveBabelConfig(appDirectory, config, {
+        tsconfigPath: tsconfigPath ? tsconfigPath : "",
+        syntax: "es6+",
+        type: "commonjs"
+      });
+      if (await fs.pathExists(sourceDir)) {
+        const basename = path.basename(sourceDir);
+        const targetDir = path.join(distDir, basename);
+        await fs.copy(sourceDir, targetDir, {
+          filter: (src) => ![".ts", ".js"].includes(path.extname(src)) && src !== tsconfigPath
+        });
+      }
+      return compiler(
+        {
+          rootDir: appDirectory,
+          distDir,
+          sourceDir,
+          extensions: FILE_EXTENSIONS
+        },
+        babelConfig
+      );
+    })
+  );
+  results.forEach((result) => {
+    if (result.code === 1) {
+      throw new Error(result.message);
+    }
+  });
+};
+export {
+  compileByBabel,
+  existTsConfigFile,
+  getBabelConfig,
+  readTsConfig,
+  resolveBabelConfig
+};

package/dist/esm-node/compilers/typescript/index.js

@@ -0,0 +1,88 @@
+import path from "path";
+import { logger, getAliasConfig, fs } from "@modern-js/utils";
+import ts from "typescript";
+import { TypescriptLoader } from "./typescript-loader";
+import { tsconfigPathsBeforeHookFactory } from "./tsconfig-paths-plugin";
+const readTsConfigByFile = (tsConfigFile) => {
+  const parsedCmd = ts.getParsedCommandLineOfConfigFile(
+    tsConfigFile,
+    void 0,
+    ts.sys
+  );
+  const { options, fileNames, projectReferences } = parsedCmd;
+  return { options, fileNames, projectReferences };
+};
+const copyFiles = async (from, to, appDirectory, tsconfigPath) => {
+  if (await fs.pathExists(from)) {
+    const relativePath = path.relative(appDirectory, from);
+    const targetDir = path.join(to, relativePath);
+    await fs.copy(from, targetDir, {
+      filter: (src) => ![".ts"].includes(path.extname(src)) && src !== tsconfigPath
+    });
+  }
+};
+const compileByTs = async (appDirectory, config, compileOptions) => {
+  logger.info(`Running ts compile...`);
+  const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+  if (!tsconfigPath) {
+    return;
+  }
+  const ts2 = new TypescriptLoader({
+    appDirectory
+  }).load();
+  const createProgram = ts2.createIncrementalProgram || ts2.createProgram;
+  const formatHost = getFormatHost(ts2);
+  const { alias } = config;
+  const aliasOption = getAliasConfig(alias, {
+    appDirectory,
+    tsconfigPath
+  });
+  const { paths = {}, absoluteBaseUrl = "./" } = aliasOption;
+  const { options, fileNames, projectReferences } = readTsConfigByFile(tsconfigPath);
+  const sourcePosixPaths = sourceDirs.map(
+    (sourceDir) => sourceDir.split(path.sep).join(path.posix.sep)
+  );
+  const rootNames = fileNames.filter((fileName) => {
+    return fileName.endsWith(".d.ts") || sourcePosixPaths.some((sourceDir) => {
+      return fileName.includes(sourceDir);
+    });
+  });
+  const program = createProgram.call(ts2, {
+    rootNames,
+    projectReferences,
+    options: {
+      rootDir: appDirectory,
+      outDir: distDir,
+      ...options
+    }
+  });
+  const tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(
+    ts2,
+    absoluteBaseUrl,
+    paths
+  );
+  const emitResult = program.emit(void 0, void 0, void 0, void 0, {
+    before: [tsconfigPathsPlugin]
+  });
+  const allDiagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  if (allDiagnostics.length > 0) {
+    logger.error(
+      ts2.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost)
+    );
+    process.exit(1);
+  }
+  for (const source of sourceDirs) {
+    await copyFiles(source, distDir, appDirectory, tsconfigPath);
+  }
+  logger.info(`Ts compile succeed`);
+};
+const getFormatHost = (ts2) => {
+  return {
+    getCanonicalFileName: (path2) => path2,
+    getCurrentDirectory: ts2.sys.getCurrentDirectory,
+    getNewLine: () => ts2.sys.newLine
+  };
+};
+export {
+  compileByTs
+};

package/dist/esm-node/compilers/typescript/tsconfig-paths-plugin.js

@@ -0,0 +1,187 @@
+import * as os from "os";
+import path, { dirname, posix } from "path";
+import * as ts from "typescript";
+import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
+const isRegExpKey = (str) => {
+  return str.startsWith("^") || str.endsWith("$");
+};
+const resolveAliasPath = (baseUrl, filePath) => {
+  if (filePath.startsWith(".") || filePath.startsWith("..")) {
+    return path.resolve(baseUrl, filePath);
+  }
+  return filePath;
+};
+const createAliasMatcher = (baseUrl, alias) => {
+  const aliasPairs = Object.keys(alias).reduce((o, key) => {
+    if (isRegExpKey(key)) {
+      const regexp = new RegExp(key);
+      const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+      o.push([regexp, aliasPath]);
+    } else {
+      const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+      o.push([key, aliasPath]);
+    }
+    return o;
+  }, []);
+  const cacheMap = /* @__PURE__ */ new Map();
+  return (requestedModule) => {
+    if (cacheMap.has(requestedModule)) {
+      return cacheMap.get(requestedModule);
+    }
+    for (const [key, value] of aliasPairs) {
+      if (key instanceof RegExp) {
+        if (key.test(requestedModule)) {
+          cacheMap.set(requestedModule, value);
+          return value;
+        }
+      }
+      if (requestedModule === key) {
+        cacheMap.set(requestedModule, value);
+        return value;
+      }
+    }
+  };
+};
+const isDynamicImport = (tsBinary, node) => {
+  return tsBinary.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
+};
+function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
+  const tsPaths = {};
+  const alias = {};
+  Object.keys(paths).forEach((key) => {
+    if (Array.isArray(paths[key])) {
+      tsPaths[key] = paths[key];
+    } else {
+      alias[key] = paths[key];
+    }
+  });
+  const matchAliasPath = createAliasMatcher(baseUrl, alias);
+  const matchTsPath = createMatchPath(baseUrl, tsPaths, ["main"]);
+  const matchPath = (requestedModule, readJSONSync, fileExists, extensions) => {
+    const result = matchTsPath(
+      requestedModule,
+      readJSONSync,
+      fileExists,
+      extensions
+    );
+    if (result) {
+      return result;
+    }
+    return matchAliasPath(requestedModule);
+  };
+  if (Object.keys(paths).length === 0) {
+    return void 0;
+  }
+  return (ctx) => {
+    return (sf) => {
+      const visitNode = (node) => {
+        var _a;
+        if (isDynamicImport(tsBinary, node)) {
+          const importPathWithQuotes = node.arguments[0].getText(sf);
+          const text = importPathWithQuotes.slice(
+            1,
+            importPathWithQuotes.length - 1
+          );
+          const result = getNotAliasedPath(sf, matchPath, text);
+          if (!result) {
+            return node;
+          }
+          return tsBinary.factory.updateCallExpression(
+            node,
+            node.expression,
+            node.typeArguments,
+            tsBinary.factory.createNodeArray([
+              tsBinary.factory.createStringLiteral(result)
+            ])
+          );
+        }
+        if (tsBinary.isImportDeclaration(node) || tsBinary.isExportDeclaration(node) && node.moduleSpecifier) {
+          try {
+            const importPathWithQuotes = (_a = node == null ? void 0 : node.moduleSpecifier) == null ? void 0 : _a.getText();
+            if (!importPathWithQuotes) {
+              return node;
+            }
+            const text = importPathWithQuotes.substring(
+              1,
+              importPathWithQuotes.length - 1
+            );
+            const result = getNotAliasedPath(sf, matchPath, text);
+            if (!result) {
+              return node;
+            }
+            const moduleSpecifier = tsBinary.factory.createStringLiteral(result);
+            moduleSpecifier.parent = node.moduleSpecifier.parent;
+            let newNode;
+            if (tsBinary.isImportDeclaration(node)) {
+              newNode = tsBinary.factory.updateImportDeclaration(
+                node,
+                node.decorators,
+                node.modifiers,
+                node.importClause,
+                moduleSpecifier,
+                node.assertClause
+              );
+            } else {
+              newNode = tsBinary.factory.updateExportDeclaration(
+                node,
+                node.decorators,
+                node.modifiers,
+                node.isTypeOnly,
+                node.exportClause,
+                moduleSpecifier,
+                node.assertClause
+              );
+            }
+            newNode.flags = node.flags;
+            return newNode;
+          } catch {
+            return node;
+          }
+        }
+        return tsBinary.visitEachChild(node, visitNode, ctx);
+      };
+      return tsBinary.visitNode(sf, visitNode);
+    };
+  };
+}
+function getNotAliasedPath(sf, matcher, text) {
+  let result = matcher(text, void 0, void 0, [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx"
+  ]);
+  if (!result) {
+    return;
+  }
+  if (os.platform() === "win32") {
+    result = result.replace(/\\/g, "/");
+  }
+  if (!path.isAbsolute(result)) {
+    if (!result.startsWith(".") && !result.startsWith("..")) {
+      try {
+        const packagePath = require.resolve(result, {
+          paths: [process.cwd(), ...module.paths]
+        });
+        if (packagePath) {
+          return result;
+        }
+      } catch {
+      }
+    }
+    try {
+      const packagePath = require.resolve(text, {
+        paths: [process.cwd(), ...module.paths]
+      });
+      if (packagePath) {
+        return text;
+      }
+    } catch {
+    }
+  }
+  const resolvedPath = posix.relative(dirname(sf.fileName), result) || "./";
+  return resolvedPath[0] === "." ? resolvedPath : `./${resolvedPath}`;
+}
+export {
+  tsconfigPathsBeforeHookFactory
+};

package/dist/esm-node/compilers/typescript/typescript-loader.js

@@ -0,0 +1,24 @@
+class TypescriptLoader {
+  constructor({ appDirectory }) {
+    this.appDirectory = appDirectory;
+  }
+  load() {
+    if (this.tsBinary) {
+      return this.tsBinary;
+    }
+    try {
+      const tsPath = require.resolve("typescript", {
+        paths: [this.appDirectory || process.cwd()]
+      });
+      const ts = require(tsPath);
+      return ts;
+    } catch (error) {
+      throw new Error(
+        'TypeScript could not be found! Please, install "typescript" package.'
+      );
+    }
+  }
+}
+export {
+  TypescriptLoader
+};

package/dist/esm-node/index.js

@@ -0,0 +1,5 @@
+export * from "./compilers/babel";
+import { compile } from "./common";
+export {
+  compile
+};

package/package.json

@@ -11,20 +11,19 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.4.1-beta.0",
+  "version": "2.5.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
-  "main": "./dist/js/node/index.js",
-  "module": "./dist/js/treeshaking/index.js",
-  "jsnext:modern": "./dist/js/modern/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
   "exports": {
     ".": {
       "node": {
         "jsnext:source": "./src/index.ts",
-        "import": "./dist/js/modern/index.js",
-        "require": "./dist/js/node/index.js"
+        "import": "./dist/esm-node/index.js",
+        "require": "./dist/cjs/index.js"
       },
-      "default": "./dist/js/treeshaking/index.js"
+      "default": "./dist/esm/index.js"
     }
   },
   "dependencies": {
@@ -34,22 +33,22 @@
     "@babel/preset-env": "^7.18.0",
     "@babel/preset-typescript": "^7.17.12",
     "@babel/runtime": "^7.18.0",
+    "@modern-js/babel-compiler": "2.5.0",
+    "@modern-js/babel-preset-lib": "2.5.0",
+    "@modern-js/utils": "2.5.0",
     "babel-plugin-module-resolver": "^4.1.0",
-    "babel-plugin-transform-typescript-metadata": "^0.3.2",
-    "@modern-js/babel-compiler": "2.4.1-beta.0",
-    "@modern-js/babel-preset-lib": "2.4.1-beta.0",
-    "@modern-js/utils": "2.4.1-beta.0"
+    "babel-plugin-transform-typescript-metadata": "^0.3.2"
   },
   "devDependencies": {
+    "@modern-js/server-core": "2.5.1-alpha.0",
+    "@scripts/build": "2.5.0",
+    "@scripts/jest-config": "2.5.0",
     "@types/babel__core": "^7.1.15",
     "@types/jest": "^27",
     "@types/node": "^14",
     "jest": "^27",
     "ts-jest": "^27.0.4",
-    "typescript": "^4",
-    "@modern-js/server-core": "2.4.1-beta.0",
-    "@scripts/build": "2.4.0",
-    "@scripts/jest-config": "2.4.0"
+    "typescript": "^4"
   },
   "sideEffects": false,
   "publishConfig": {