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

package/dist/cjs/compilers/typescript/index.js

@@ -40,10 +40,10 @@ const readTsConfigByFile = (tsConfigFile) => {
   const { options, fileNames, projectReferences } = parsedCmd;
   return { options, fileNames, projectReferences };
 };
-const copyFiles = async (from, to, tsconfigPath) => {
+const copyFiles = async (from, to, appDirectory, tsconfigPath) => {
   if (await import_utils.fs.pathExists(from)) {
-    const basename = import_path.default.basename(from);
-    const targetDir = import_path.default.join(to, basename);
+    const relativePath = import_path.default.relative(appDirectory, from);
+    const targetDir = import_path.default.join(to, relativePath);
     await import_utils.fs.copy(from, targetDir, {
       filter: (src) => ![".ts"].includes(import_path.default.extname(src)) && src !== tsconfigPath
     });
@@ -100,7 +100,7 @@ const compileByTs = async (appDirectory, config, compileOptions) => {
     process.exit(1);
   }
   for (const source of sourceDirs) {
-    await copyFiles(source, distDir, tsconfigPath);
+    await copyFiles(source, distDir, appDirectory, tsconfigPath);
   }
   import_utils.logger.info(`Ts compile succeed`);
 };

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

@@ -165,8 +165,8 @@ var readTsConfigByFile = function(tsConfigFile) {
     };
 };
 var copyFiles = function() {
-    var _ref = _asyncToGenerator(function(from, to, tsconfigPath) {
-        var basename, targetDir;
+    var _ref = _asyncToGenerator(function(from, to, appDirectory, tsconfigPath) {
+        var relativePath, targetDir;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -179,8 +179,8 @@ var copyFiles = function() {
                         3,
                         3
                     ];
-                    basename = path.basename(from);
-                    targetDir = path.join(to, basename);
+                    relativePath = path.relative(appDirectory, from);
+                    targetDir = path.join(to, relativePath);
                     return [
                         4,
                         fs.copy(from, targetDir, {
@@ -201,7 +201,7 @@ var copyFiles = function() {
             }
         });
     });
-    return function copyFiles(from, to, tsconfigPath) {
+    return function copyFiles(from, to, appDirectory, tsconfigPath) {
         return _ref.apply(this, arguments);
     };
 }();
@@ -276,7 +276,7 @@ var compileByTs = function() {
                     source = _step.value;
                     return [
                         4,
-                        copyFiles(source, distDir, tsconfigPath)
+                        copyFiles(source, distDir, appDirectory, tsconfigPath)
                     ];
                 case 3:
                     _state.sent();

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

@@ -12,10 +12,10 @@ const readTsConfigByFile = (tsConfigFile) => {
   const { options, fileNames, projectReferences } = parsedCmd;
   return { options, fileNames, projectReferences };
 };
-const copyFiles = async (from, to, tsconfigPath) => {
+const copyFiles = async (from, to, appDirectory, tsconfigPath) => {
   if (await fs.pathExists(from)) {
-    const basename = path.basename(from);
-    const targetDir = path.join(to, basename);
+    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
     });
@@ -72,7 +72,7 @@ const compileByTs = async (appDirectory, config, compileOptions) => {
     process.exit(1);
   }
   for (const source of sourceDirs) {
-    await copyFiles(source, distDir, tsconfigPath);
+    await copyFiles(source, distDir, appDirectory, tsconfigPath);
   }
   logger.info(`Ts compile succeed`);
 };

package/dist/js/modern/common/index.js

@@ -0,0 +1,55 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import * as path from "path";
+import { fs } from "@modern-js/utils";
+import { compileByTs } from "../compilers/typescript";
+import { compileByBabel } from "../compilers/babel";
+const FILE_EXTENSIONS = [".js", ".ts", ".mjs", ".ejs"];
+const validateAbsolutePath = (filename, message) => {
+  if (!path.isAbsolute(filename)) {
+    throw new Error(message);
+  }
+};
+const validateAbsolutePaths = (filenames, messageFunc) => {
+  filenames.forEach(
+    (filename) => validateAbsolutePath(filename, messageFunc(filename))
+  );
+};
+const compile = (appDirectory, modernConfig, compileOptions) => __async(void 0, null, function* () {
+  var _a;
+  const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+  validateAbsolutePaths(
+    sourceDirs,
+    (dir) => `source dir ${dir} is not an absolute path.`
+  );
+  validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
+  const compiler = (_a = modernConfig == null ? void 0 : modernConfig.server) == null ? void 0 : _a.compiler;
+  const isTsProject = tsconfigPath && (yield fs.pathExists(tsconfigPath));
+  if (!isTsProject || compiler === "babel") {
+    yield compileByBabel(appDirectory, modernConfig, compileOptions);
+  } else {
+    yield compileByTs(appDirectory, modernConfig, compileOptions);
+  }
+});
+export {
+  FILE_EXTENSIONS,
+  compile
+};

package/dist/js/modern/compilers/babel/index.js

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+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 __spreadValues({
+    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, __spreadValues({
+    appDirectory
+  }, option));
+  const babelChain = getBabelChain(
+    {
+      appDirectory,
+      enableReactPreset: true,
+      enableTypescriptPreset: true,
+      alias: aliasConfig,
+      envVars: [],
+      globalVars: __spreadValues(__spreadValues({}, 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"), [
+    __spreadProps(__spreadValues({}, 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 = __spreadValues({}, babelChain.toJSON());
+  return applyUserBabelConfig(internalBabelConfig, babelConfig);
+};
+const compileByBabel = (appDirectory, config, compileOptions) => __async(void 0, null, function* () {
+  const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+  const results = yield Promise.all(
+    sourceDirs.map((sourceDir) => __async(void 0, null, function* () {
+      const babelConfig = resolveBabelConfig(appDirectory, config, {
+        tsconfigPath: tsconfigPath ? tsconfigPath : "",
+        syntax: "es6+",
+        type: "commonjs"
+      });
+      if (yield fs.pathExists(sourceDir)) {
+        const basename = path.basename(sourceDir);
+        const targetDir = path.join(distDir, basename);
+        yield 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/js/modern/compilers/typescript/index.js

@@ -0,0 +1,123 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+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 = (from, to, tsconfigPath) => __async(void 0, null, function* () {
+  if (yield fs.pathExists(from)) {
+    const basename = path.basename(from);
+    const targetDir = path.join(to, basename);
+    yield fs.copy(from, targetDir, {
+      filter: (src) => ![".ts"].includes(path.extname(src)) && src !== tsconfigPath
+    });
+  }
+});
+const compileByTs = (appDirectory, config, compileOptions) => __async(void 0, null, function* () {
+  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: __spreadValues({
+      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) {
+    yield copyFiles(source, distDir, 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/js/modern/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 (e) {
+            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 (e) {
+      }
+    }
+    try {
+      const packagePath = require.resolve(text, {
+        paths: [process.cwd(), ...module.paths]
+      });
+      if (packagePath) {
+        return text;
+      }
+    } catch (e) {
+    }
+  }
+  const resolvedPath = posix.relative(dirname(sf.fileName), result) || "./";
+  return resolvedPath[0] === "." ? resolvedPath : `./${resolvedPath}`;
+}
+export {
+  tsconfigPathsBeforeHookFactory
+};

package/dist/js/modern/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/js/modern/index.js

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