@modern-js/server-utils 2.69.4 → 3.0.0-alpha.0

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

@@ -1,202 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import path from "path";
-import { fs, getAliasConfig, logger } from "@modern-js/utils";
-import { tsconfigPathsBeforeHookFactory } from "./tsconfigPathsPlugin";
-import { TypescriptLoader } from "./typescriptLoader";
-var readTsConfigByFile = function(tsConfigFile, tsInstance) {
-  var parsedCmd = tsInstance.getParsedCommandLineOfConfigFile(tsConfigFile, void 0, tsInstance.sys);
-  var options = parsedCmd.options, fileNames = parsedCmd.fileNames, projectReferences = parsedCmd.projectReferences;
-  return {
-    options,
-    fileNames,
-    projectReferences
-  };
-};
-var copyFiles = function() {
-  var _ref = _async_to_generator(function(from, to, appDirectory) {
-    var relativePath, targetDir;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return [
-            4,
-            fs.pathExists(from)
-          ];
-        case 1:
-          if (!_state.sent())
-            return [
-              3,
-              3
-            ];
-          relativePath = path.relative(appDirectory, from);
-          targetDir = path.join(to, relativePath);
-          return [
-            4,
-            fs.copy(from, targetDir, {
-              filter: function(src) {
-                return ![
-                  ".ts",
-                  ".js"
-                ].includes(path.extname(src)) && !src.endsWith("tsconfig.json");
-              }
-            })
-          ];
-        case 2:
-          _state.sent();
-          _state.label = 3;
-        case 3:
-          return [
-            2
-          ];
-      }
-    });
-  });
-  return function copyFiles2(from, to, appDirectory) {
-    return _ref.apply(this, arguments);
-  };
-}();
-var compileByTs = function() {
-  var _ref = _async_to_generator(function(appDirectory, config, compileOptions) {
-    var sourceDirs, distDir, tsconfigPath, ts, createProgram, formatHost, alias, aliasOption, _aliasOption_paths, paths, _aliasOption_absoluteBaseUrl, absoluteBaseUrl, _readTsConfigByFile, options, fileNames, projectReferences, sourcePosixPaths, rootNames, program, tsconfigPathsPlugin, emitResult, allDiagnostics, noEmitOnError, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, source, err;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          logger.info("Running ts compile...");
-          sourceDirs = compileOptions.sourceDirs, distDir = compileOptions.distDir, tsconfigPath = compileOptions.tsconfigPath;
-          if (!tsconfigPath) {
-            return [
-              2
-            ];
-          }
-          ts = new TypescriptLoader({
-            appDirectory
-          }).load();
-          createProgram = ts.createIncrementalProgram || ts.createProgram;
-          formatHost = getFormatHost(ts);
-          alias = config.alias;
-          aliasOption = getAliasConfig(alias, {
-            appDirectory,
-            tsconfigPath
-          });
-          _aliasOption_paths = aliasOption.paths, paths = _aliasOption_paths === void 0 ? {} : _aliasOption_paths, _aliasOption_absoluteBaseUrl = aliasOption.absoluteBaseUrl, absoluteBaseUrl = _aliasOption_absoluteBaseUrl === void 0 ? "./" : _aliasOption_absoluteBaseUrl;
-          _readTsConfigByFile = readTsConfigByFile(tsconfigPath, ts), options = _readTsConfigByFile.options, fileNames = _readTsConfigByFile.fileNames, projectReferences = _readTsConfigByFile.projectReferences;
-          sourcePosixPaths = sourceDirs.map(function(sourceDir) {
-            return sourceDir.split(path.sep).join(path.posix.sep);
-          });
-          rootNames = fileNames.filter(function(fileName) {
-            return fileName.endsWith(".d.ts") || sourcePosixPaths.some(function(sourceDir) {
-              return fileName.includes(sourceDir);
-            });
-          });
-          program = createProgram.call(ts, {
-            rootNames,
-            projectReferences,
-            options: _object_spread({
-              rootDir: appDirectory,
-              outDir: distDir
-            }, options)
-          });
-          tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
-          emitResult = program.emit(void 0, void 0, void 0, void 0, {
-            before: [
-              tsconfigPathsPlugin
-            ]
-          });
-          allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-          noEmitOnError = options.noEmitOnError;
-          if (allDiagnostics.length > 0) {
-            logger.error(ts.formatDiagnosticsWithColorAndContext(_to_consumable_array(new Set(allDiagnostics)), formatHost));
-            if (typeof noEmitOnError === "undefined" || noEmitOnError === true) {
-              if (compileOptions.throwErrorInsteadOfExit) {
-                logger.error("TypeScript compilation failed");
-              } else {
-                process.exit(1);
-              }
-            }
-          }
-          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-          _state.label = 1;
-        case 1:
-          _state.trys.push([
-            1,
-            6,
-            7,
-            8
-          ]);
-          _iterator = sourceDirs[Symbol.iterator]();
-          _state.label = 2;
-        case 2:
-          if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
-            return [
-              3,
-              5
-            ];
-          source = _step.value;
-          return [
-            4,
-            copyFiles(source, distDir, appDirectory)
-          ];
-        case 3:
-          _state.sent();
-          _state.label = 4;
-        case 4:
-          _iteratorNormalCompletion = true;
-          return [
-            3,
-            2
-          ];
-        case 5:
-          return [
-            3,
-            8
-          ];
-        case 6:
-          err = _state.sent();
-          _didIteratorError = true;
-          _iteratorError = err;
-          return [
-            3,
-            8
-          ];
-        case 7:
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-          return [
-            7
-          ];
-        case 8:
-          logger.info("Ts compile succeed");
-          return [
-            2
-          ];
-      }
-    });
-  });
-  return function compileByTs2(appDirectory, config, compileOptions) {
-    return _ref.apply(this, arguments);
-  };
-}();
-var getFormatHost = function(ts) {
-  return {
-    getCanonicalFileName: function(path2) {
-      return path2;
-    },
-    getCurrentDirectory: ts.sys.getCurrentDirectory,
-    getNewLine: function() {
-      return ts.sys.newLine;
-    }
-  };
-};
-export {
-  compileByTs
-};

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

@@ -1,188 +0,0 @@
-import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
-import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
-import * as os from "os";
-import path, { dirname, posix } from "path";
-import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
-import * as ts from "typescript";
-var isRegExpKey = function(str) {
-  return str.startsWith("^") || str.endsWith("$");
-};
-var resolveAliasPath = function(baseUrl, filePath) {
-  if (filePath.startsWith(".") || filePath.startsWith("..")) {
-    return path.resolve(baseUrl, filePath);
-  }
-  return filePath;
-};
-var createAliasMatcher = function(baseUrl, alias) {
-  var aliasPairs = Object.keys(alias).reduce(function(o, key) {
-    if (isRegExpKey(key)) {
-      var regexp = new RegExp(key);
-      var aliasPath = resolveAliasPath(baseUrl, alias[key]);
-      o.push([
-        regexp,
-        aliasPath
-      ]);
-    } else {
-      var aliasPath1 = resolveAliasPath(baseUrl, alias[key]);
-      o.push([
-        key,
-        aliasPath1
-      ]);
-    }
-    return o;
-  }, []);
-  var cacheMap = /* @__PURE__ */ new Map();
-  return function(requestedModule) {
-    if (cacheMap.has(requestedModule)) {
-      return cacheMap.get(requestedModule);
-    }
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-    try {
-      for (var _iterator = aliasPairs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
-        if (_instanceof(key, RegExp)) {
-          if (key.test(requestedModule)) {
-            cacheMap.set(requestedModule, value);
-            return value;
-          }
-        }
-        if (requestedModule === key) {
-          cacheMap.set(requestedModule, value);
-          return value;
-        }
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
-      }
-    }
-  };
-};
-var isDynamicImport = function(tsBinary, node) {
-  return tsBinary.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
-};
-function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
-  var tsPaths = {};
-  var alias = {};
-  Object.keys(paths).forEach(function(key) {
-    if (Array.isArray(paths[key])) {
-      tsPaths[key] = paths[key];
-    } else {
-      alias[key] = paths[key];
-    }
-  });
-  var matchAliasPath = createAliasMatcher(baseUrl, alias);
-  var matchTsPath = createMatchPath(baseUrl, tsPaths, [
-    "main"
-  ]);
-  var matchPath = function(requestedModule, readJSONSync, fileExists, extensions) {
-    var result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
-    if (result) {
-      return result;
-    }
-    return matchAliasPath(requestedModule);
-  };
-  if (Object.keys(paths).length === 0) {
-    return void 0;
-  }
-  return function(ctx) {
-    return function(sf) {
-      var visitNode = function(node) {
-        if (isDynamicImport(tsBinary, node)) {
-          var importPathWithQuotes = node.arguments[0].getText(sf);
-          var text = importPathWithQuotes.slice(1, importPathWithQuotes.length - 1);
-          var 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 {
-            var _node_moduleSpecifier;
-            var importPathWithQuotes1 = node === null || node === void 0 ? void 0 : (_node_moduleSpecifier = node.moduleSpecifier) === null || _node_moduleSpecifier === void 0 ? void 0 : _node_moduleSpecifier.getText();
-            if (!importPathWithQuotes1) {
-              return node;
-            }
-            var text1 = importPathWithQuotes1.substring(1, importPathWithQuotes1.length - 1);
-            var result1 = getNotAliasedPath(sf, matchPath, text1);
-            if (!result1) {
-              return node;
-            }
-            var moduleSpecifier = tsBinary.factory.createStringLiteral(result1);
-            moduleSpecifier.parent = node.moduleSpecifier.parent;
-            var newNode;
-            if (tsBinary.isImportDeclaration(node)) {
-              newNode = tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
-            } else {
-              newNode = tsBinary.factory.updateExportDeclaration(node, 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) {
-  var 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 {
-        var packagePath = require.resolve(result, {
-          paths: [
-            process.cwd()
-          ].concat(_to_consumable_array(module.paths))
-        });
-        if (packagePath) {
-          return result;
-        }
-      } catch (e) {
-      }
-    }
-    try {
-      var packagePath1 = require.resolve(text, {
-        paths: [
-          process.cwd()
-        ].concat(_to_consumable_array(module.paths))
-      });
-      if (packagePath1) {
-        return text;
-      }
-    } catch (e) {
-    }
-  }
-  var resolvedPath = posix.relative(dirname(sf.fileName), result) || "./";
-  return resolvedPath[0] === "." ? resolvedPath : "./".concat(resolvedPath);
-}
-export {
-  tsconfigPathsBeforeHookFactory
-};

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

@@ -1,30 +0,0 @@
-import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
-var TypescriptLoader = /* @__PURE__ */ function() {
-  "use strict";
-  function TypescriptLoader2(param) {
-    var appDirectory = param.appDirectory;
-    _class_call_check(this, TypescriptLoader2);
-    this.appDirectory = appDirectory;
-  }
-  var _proto = TypescriptLoader2.prototype;
-  _proto.load = function load() {
-    if (this.tsBinary) {
-      return this.tsBinary;
-    }
-    try {
-      var tsPath = require.resolve("typescript", {
-        paths: [
-          this.appDirectory || process.cwd()
-        ]
-      });
-      var ts = require(tsPath);
-      return ts;
-    } catch (error) {
-      throw new Error('TypeScript could not be found! Please, install "typescript" package.');
-    }
-  };
-  return TypescriptLoader2;
-}();
-export {
-  TypescriptLoader
-};

package/dist/esm/index.js

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

package/dist/esm-node/common/index.js

@@ -1,35 +0,0 @@
-import * as path from "path";
-import { fs } from "@modern-js/utils";
-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 = async (appDirectory, modernConfig, compileOptions) => {
-  var _modernConfig_server;
-  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 = modernConfig === null || modernConfig === void 0 ? void 0 : (_modernConfig_server = modernConfig.server) === null || _modernConfig_server === void 0 ? void 0 : _modernConfig_server.compiler;
-  const isTsProject = tsconfigPath && await fs.pathExists(tsconfigPath);
-  if (!isTsProject || compiler === "babel") {
-    const { compileByBabel } = await import("../compilers/babel");
-    await compileByBabel(appDirectory, modernConfig, compileOptions);
-  } else {
-    const { compileByTs } = await import("../compilers/typescript");
-    await compileByTs(appDirectory, modernConfig, compileOptions);
-  }
-};
-export {
-  FILE_EXTENSIONS,
-  compile
-};

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

@@ -1,66 +0,0 @@
-import * as path from "path";
-import { compiler } from "@modern-js/babel-compiler";
-import { fs, getAliasConfig, json5 } from "@modern-js/utils";
-import { FILE_EXTENSIONS } from "../../common";
-import { applyUserBabelConfig, getBabelConfig } from "./preset";
-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 resolveBabelConfig = (appDirectory, config, option, isEsm) => {
-  const { alias, babelConfig } = config;
-  const aliasConfig = getAliasConfig(alias, {
-    appDirectory,
-    ...option
-  });
-  const defaultBabelConfig = getBabelConfig({
-    appDirectory,
-    alias: aliasConfig,
-    isEsm
-  });
-  return applyUserBabelConfig(defaultBabelConfig, babelConfig);
-};
-const compileByBabel = async (appDirectory, config, compileOptions) => {
-  const { sourceDirs, distDir, tsconfigPath, moduleType } = compileOptions;
-  const isEsm = moduleType === "module";
-  const results = await Promise.all(sourceDirs.map(async (sourceDir) => {
-    const babelConfig = resolveBabelConfig(appDirectory, config, {
-      tsconfigPath: tsconfigPath ? tsconfigPath : ""
-    }, isEsm);
-    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,
-  readTsConfig,
-  resolveBabelConfig
-};

package/dist/esm-node/compilers/babel/preset/alias.js

@@ -1,76 +0,0 @@
-import path from "path";
-import { getUserAlias } from "@modern-js/utils";
-import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
-const { resolvePath } = require("@modern-js/babel-plugin-module-resolver");
-const defaultPaths = {
-  "@": [
-    "./src"
-  ]
-};
-const aliasPlugin = (alias) => {
-  const { absoluteBaseUrl, isTsPath, isTsProject = false } = alias;
-  const mergedPaths = isTsPath ? alias.paths || {} : {
-    ...defaultPaths,
-    ...alias.paths || {}
-  };
-  let tsPaths = {};
-  if (isTsProject) {
-    tsPaths = getUserAlias(mergedPaths);
-  }
-  tsPaths = Object.keys(tsPaths).reduce((o, key) => {
-    if (typeof tsPaths[key] === "string") {
-      return {
-        ...o,
-        [`${key}`]: [
-          tsPaths[key]
-        ]
-      };
-    }
-    return {
-      ...o,
-      [`${key}`]: tsPaths[key]
-    };
-  }, {});
-  const resolvePathFn = (sourcePath, currentFile, opts) => {
-    if (sourcePath === "." || sourcePath === "./") {
-      return sourcePath;
-    }
-    const matchPath = createMatchPath(absoluteBaseUrl, tsPaths, [
-      "index"
-    ]);
-    const result = matchPath(sourcePath, void 0, void 0, [
-      ".js",
-      ".jsx",
-      ".ts",
-      ".tsx"
-    ]);
-    if (result) {
-      const relativePath = path.relative(path.dirname(currentFile), path.dirname(result));
-      const fileName = path.basename(result);
-      const filePath = path.normalize(`${relativePath.length === 0 ? "." : relativePath}/${fileName}`).replace(/\\/, "/");
-      return filePath.startsWith(".") ? filePath : `./${filePath}`;
-    }
-    return resolvePath(sourcePath, currentFile, opts);
-  };
-  const typescriptExts = [
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".es",
-    ".es6",
-    ".mjs"
-  ];
-  return [
-    require.resolve("@modern-js/babel-plugin-module-resolver"),
-    {
-      root: absoluteBaseUrl,
-      alias: mergedPaths,
-      resolvePath: isTsPath ? resolvePathFn : void 0,
-      extensions: isTsProject ? typescriptExts : void 0
-    }
-  ];
-};
-export {
-  aliasPlugin
-};

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

@@ -1,36 +0,0 @@
-import { getBabelConfigForNode } from "@modern-js/babel-preset/node";
-import { aliasPlugin } from "./alias";
-const getBabelConfig = (libPresetOption) => {
-  var _config_presets, _config_plugins;
-  const { isEsm } = libPresetOption;
-  const config = getBabelConfigForNode({
-    presetEnv: {
-      loose: true,
-      modules: isEsm ? false : "commonjs",
-      targets: [
-        "node >= 14"
-      ]
-    },
-    pluginDecorators: {
-      version: "legacy"
-    }
-  });
-  (_config_presets = config.presets) === null || _config_presets === void 0 ? void 0 : _config_presets.push([
-    require.resolve("@babel/preset-react"),
-    {
-      runtime: "automatic"
-    }
-  ]);
-  if (libPresetOption.alias) {
-    var _config_plugins1;
-    (_config_plugins1 = config.plugins) === null || _config_plugins1 === void 0 ? void 0 : _config_plugins1.push(aliasPlugin(libPresetOption.alias));
-  }
-  (_config_plugins = config.plugins) === null || _config_plugins === void 0 ? void 0 : _config_plugins.push(require.resolve("babel-plugin-transform-typescript-metadata"));
-  return config;
-};
-export * from "./types";
-import { applyUserBabelConfig } from "@modern-js/utils";
-export {
-  applyUserBabelConfig,
-  getBabelConfig
-};