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

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

@@ -1,93 +0,0 @@
-import path from "path";
-import { fs, getAliasConfig, logger } from "@modern-js/utils";
-import { tsconfigPathsBeforeHookFactory } from "./tsconfigPathsPlugin";
-import { TypescriptLoader } from "./typescriptLoader";
-const readTsConfigByFile = (tsConfigFile, tsInstance) => {
-  const parsedCmd = tsInstance.getParsedCommandLineOfConfigFile(tsConfigFile, void 0, tsInstance.sys);
-  const { options, fileNames, projectReferences } = parsedCmd;
-  return {
-    options,
-    fileNames,
-    projectReferences
-  };
-};
-const copyFiles = async (from, to, appDirectory) => {
-  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",
-        ".js"
-      ].includes(path.extname(src)) && !src.endsWith("tsconfig.json")
-    });
-  }
-};
-const compileByTs = async (appDirectory, config, compileOptions) => {
-  logger.info(`Running ts compile...`);
-  const { sourceDirs, distDir, tsconfigPath } = compileOptions;
-  if (!tsconfigPath) {
-    return;
-  }
-  const ts = new TypescriptLoader({
-    appDirectory
-  }).load();
-  const createProgram = ts.createIncrementalProgram || ts.createProgram;
-  const formatHost = getFormatHost(ts);
-  const { alias } = config;
-  const aliasOption = getAliasConfig(alias, {
-    appDirectory,
-    tsconfigPath
-  });
-  const { paths = {}, absoluteBaseUrl = "./" } = aliasOption;
-  const { options, fileNames, projectReferences } = readTsConfigByFile(tsconfigPath, ts);
-  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(ts, {
-    rootNames,
-    projectReferences,
-    options: {
-      rootDir: appDirectory,
-      outDir: distDir,
-      ...options
-    }
-  });
-  const tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
-  const emitResult = program.emit(void 0, void 0, void 0, void 0, {
-    before: [
-      tsconfigPathsPlugin
-    ]
-  });
-  const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-  const { noEmitOnError } = options;
-  if (allDiagnostics.length > 0) {
-    logger.error(ts.formatDiagnosticsWithColorAndContext([
-      ...new Set(allDiagnostics)
-    ], formatHost));
-    if (typeof noEmitOnError === "undefined" || noEmitOnError === true) {
-      if (compileOptions.throwErrorInsteadOfExit) {
-        logger.error("TypeScript compilation failed");
-      } else {
-        process.exit(1);
-      }
-    }
-  }
-  for (const source of sourceDirs) {
-    await copyFiles(source, distDir, appDirectory);
-  }
-  logger.info(`Ts compile succeed`);
-};
-const getFormatHost = (ts) => {
-  return {
-    getCanonicalFileName: (path2) => path2,
-    getCurrentDirectory: ts.sys.getCurrentDirectory,
-    getNewLine: () => ts.sys.newLine
-  };
-};
-export {
-  compileByTs
-};

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

@@ -1,170 +0,0 @@
-import * as os from "os";
-import path, { dirname, posix } from "path";
-import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
-import * as ts from "typescript";
-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) => {
-        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 {
-            var _node_moduleSpecifier;
-            const importPathWithQuotes = node === null || node === void 0 ? void 0 : (_node_moduleSpecifier = node.moduleSpecifier) === null || _node_moduleSpecifier === void 0 ? void 0 : _node_moduleSpecifier.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.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 {
-            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/typescriptLoader.js

@@ -1,24 +0,0 @@
-class TypescriptLoader {
-  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.');
-    }
-  }
-  constructor({ appDirectory }) {
-    this.appDirectory = appDirectory;
-  }
-}
-export {
-  TypescriptLoader
-};