@modern-js/server-utils 1.17.0 → 1.18.1-alpha.0

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

@@ -0,0 +1,180 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import path from 'path';
+import { logger, getAlias, fs } from '@modern-js/utils';
+import ts from 'typescript';
+import { TypescriptLoader } from "./typescript-loader";
+import { tsconfigPathsBeforeHookFactory } from "./tsconfig-paths-plugin";
+
+var readTsConfigByFile = function readTsConfigByFile(tsConfigFile) {
+  var parsedCmd = ts.getParsedCommandLineOfConfigFile(tsConfigFile, undefined, ts.sys);
+  var _ref = parsedCmd,
+      options = _ref.options,
+      fileNames = _ref.fileNames,
+      projectReferences = _ref.projectReferences;
+  return {
+    options: options,
+    fileNames: fileNames,
+    projectReferences: projectReferences
+  };
+};
+
+var copyFiles = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(from, to, tsconfigPath) {
+    var basename, targetDir;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fs.pathExists(from);
+
+          case 2:
+            if (!_context.sent) {
+              _context.next = 7;
+              break;
+            }
+
+            basename = path.basename(from);
+            targetDir = path.join(to, basename);
+            _context.next = 7;
+            return fs.copy(from, targetDir, {
+              filter: function filter(src) {
+                return !['.ts'].includes(path.extname(src)) && src !== tsconfigPath;
+              }
+            });
+
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function copyFiles(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+export var compileByTs = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(appDirectory, modernConfig, compileOptions) {
+    var sourceDirs, distDir, tsconfigPath, ts, createProgram, formatHost, alias, aliasOption, _aliasOption$paths, paths, _aliasOption$absolute, absoluteBaseUrl, _readTsConfigByFile, options, fileNames, projectReferences, sourcePosixPaths, rootNames, program, tsconfigPathsPlugin, emitResult, allDiagnostics, _iterator, _step, source;
+
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            logger.info("Running ts compile...");
+            sourceDirs = compileOptions.sourceDirs, distDir = compileOptions.distDir, tsconfigPath = compileOptions.tsconfigPath;
+
+            if (tsconfigPath) {
+              _context2.next = 4;
+              break;
+            }
+
+            return _context2.abrupt("return");
+
+          case 4:
+            ts = new TypescriptLoader({
+              appDirectory: appDirectory
+            }).load();
+            createProgram = ts.createIncrementalProgram || ts.createProgram;
+            formatHost = getFormatHost(ts);
+            alias = modernConfig.source.alias;
+            aliasOption = getAlias(alias || {}, {
+              appDirectory: appDirectory,
+              tsconfigPath: tsconfigPath
+            });
+            _aliasOption$paths = aliasOption.paths, paths = _aliasOption$paths === void 0 ? {} : _aliasOption$paths, _aliasOption$absolute = aliasOption.absoluteBaseUrl, absoluteBaseUrl = _aliasOption$absolute === void 0 ? './' : _aliasOption$absolute;
+            _readTsConfigByFile = readTsConfigByFile(tsconfigPath), 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: rootNames,
+              projectReferences: projectReferences,
+              options: _objectSpread({
+                rootDir: appDirectory,
+                outDir: distDir
+              }, options)
+            });
+            tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
+            emitResult = program.emit(undefined, undefined, undefined, undefined, {
+              before: [tsconfigPathsPlugin]
+            });
+            allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+
+            if (allDiagnostics.length > 0) {
+              logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost)); // eslint-disable-next-line no-process-exit
+
+              process.exit(1);
+            }
+
+            _iterator = _createForOfIteratorHelper(sourceDirs);
+            _context2.prev = 19;
+
+            _iterator.s();
+
+          case 21:
+            if ((_step = _iterator.n()).done) {
+              _context2.next = 27;
+              break;
+            }
+
+            source = _step.value;
+            _context2.next = 25;
+            return copyFiles(source, distDir, tsconfigPath);
+
+          case 25:
+            _context2.next = 21;
+            break;
+
+          case 27:
+            _context2.next = 32;
+            break;
+
+          case 29:
+            _context2.prev = 29;
+            _context2.t0 = _context2["catch"](19);
+
+            _iterator.e(_context2.t0);
+
+          case 32:
+            _context2.prev = 32;
+
+            _iterator.f();
+
+            return _context2.finish(32);
+
+          case 35:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[19, 29, 32, 35]]);
+  }));
+
+  return function compileByTs(_x4, _x5, _x6) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+var getFormatHost = function getFormatHost(ts) {
+  return {
+    getCanonicalFileName: function getCanonicalFileName(path) {
+      return path;
+    },
+    getCurrentDirectory: ts.sys.getCurrentDirectory,
+    getNewLine: function getNewLine() {
+      return ts.sys.newLine;
+    }
+  };
+};

package/dist/js/treeshaking/compilers/typescript/tsconfig-paths-plugin.js

@@ -0,0 +1,202 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import * as os from 'os';
+import path, { dirname, posix } from 'path';
+import * as ts from 'typescript';
+import { createMatchPath } from 'tsconfig-paths';
+
+var isRegExpKey = function isRegExpKey(str) {
+  return str.startsWith('^') || str.endsWith('$');
+};
+
+var resolveAliasPath = function resolveAliasPath(baseUrl, filePath) {
+  // exclude absolute path and alias
+  if (filePath.startsWith('.') || filePath.startsWith('..')) {
+    return path.resolve(baseUrl, filePath);
+  }
+
+  return filePath;
+};
+
+var createAliasMatcher = function createAliasMatcher(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 _aliasPath = resolveAliasPath(baseUrl, alias[key]);
+
+      o.push([key, _aliasPath]);
+    }
+
+    return o;
+  }, []);
+  var cacheMap = new Map(); // eslint-disable-next-line consistent-return
+
+  return function (requestedModule) {
+    if (cacheMap.has(requestedModule)) {
+      return cacheMap.get(requestedModule);
+    }
+
+    var _iterator = _createForOfIteratorHelper(aliasPairs),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+            key = _step$value[0],
+            value = _step$value[1];
+
+        if (key instanceof RegExp) {
+          if (key.test(requestedModule)) {
+            cacheMap.set(requestedModule, value);
+            return value;
+          }
+        }
+
+        if (requestedModule === key) {
+          cacheMap.set(requestedModule, value);
+          return value;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  };
+};
+
+var isDynamicImport = function isDynamicImport(tsBinary, node) {
+  return tsBinary.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
+};
+
+export 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 matchPath(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 undefined;
+  }
+
+  return function (ctx) {
+    return function (sf) {
+      var visitNode = function visitNode(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 _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;
+            }
+
+            var _text = _importPathWithQuotes.substring(1, _importPathWithQuotes.length - 1);
+
+            var _result = getNotAliasedPath(sf, matchPath, _text);
+
+            if (!_result) {
+              return node;
+            }
+
+            var moduleSpecifier = tsBinary.factory.createStringLiteral(_result);
+            moduleSpecifier.parent = node.moduleSpecifier.parent;
+
+            if (tsBinary.isImportDeclaration(node)) {
+              return tsBinary.factory.updateImportDeclaration(node, node.decorators, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
+            } else {
+              return tsBinary.factory.updateExportDeclaration(node, node.decorators, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+            }
+          } catch (_unused) {
+            return node;
+          }
+        }
+
+        return tsBinary.visitEachChild(node, visitNode, ctx);
+      };
+
+      return tsBinary.visitNode(sf, visitNode);
+    };
+  };
+} // fork from https://github.com/nestjs/nest-cli/blob/HEAD/lib/compiler/hooks/tsconfig-paths.hook.ts
+
+function getNotAliasedPath(sf, matcher, text) {
+  var result = matcher(text, undefined, undefined, ['.ts', '.tsx', '.js', '.jsx']);
+
+  if (!result) {
+    return;
+  }
+
+  if (os.platform() === 'win32') {
+    result = result.replace(/\\/g, '/');
+  }
+
+  if (!path.isAbsolute(result)) {
+    // handle alias to alias
+    if (!result.startsWith('.') && !result.startsWith('..')) {
+      try {
+        // Installed packages (node modules) should take precedence over root files with the same name.
+        // Ref: https://github.com/nestjs/nest-cli/issues/838
+        var packagePath = require.resolve(result, {
+          paths: [process.cwd()].concat(_toConsumableArray(module.paths))
+        });
+
+        if (packagePath) {
+          // eslint-disable-next-line consistent-return
+          return result;
+        }
+      } catch (_unused2) {}
+    }
+
+    try {
+      // Installed packages (node modules) should take precedence over root files with the same name.
+      // Ref: https://github.com/nestjs/nest-cli/issues/838
+      var _packagePath = require.resolve(text, {
+        paths: [process.cwd()].concat(_toConsumableArray(module.paths))
+      });
+
+      if (_packagePath) {
+        // eslint-disable-next-line consistent-return
+        return text;
+      }
+    } catch (_unused3) {}
+  }
+
+  var resolvedPath = posix.relative(dirname(sf.fileName), result) || './'; // eslint-disable-next-line consistent-return
+
+  return resolvedPath[0] === '.' ? resolvedPath : "./".concat(resolvedPath);
+}

package/dist/js/treeshaking/compilers/typescript/typescript-loader.js

@@ -0,0 +1,39 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export var TypescriptLoader = /*#__PURE__*/function () {
+  function TypescriptLoader(_ref) {
+    var appDirectory = _ref.appDirectory;
+
+    _classCallCheck(this, TypescriptLoader);
+
+    _defineProperty(this, "tsBinary", void 0);
+
+    _defineProperty(this, "appDirectory", void 0);
+
+    this.appDirectory = appDirectory;
+  }
+
+  _createClass(TypescriptLoader, [{
+    key: "load",
+    value: 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 TypescriptLoader;
+}();

package/dist/js/treeshaking/index.js

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

package/dist/types/common/index.d.ts

@@ -0,0 +1,14 @@
+import type { NormalizedConfig } from '@modern-js/core';
+export interface Pattern {
+  from: string;
+  to: string;
+  tsconfigPath?: string;
+}
+export interface CompileOptions {
+  sourceDirs: string[];
+  distDir: string;
+  tsconfigPath?: string;
+}
+export declare type CompileFunc = (appDirectory: string, modernConfig: NormalizedConfig, compileOptions: CompileOptions) => Promise<void>;
+export declare const FILE_EXTENSIONS: string[];
+export declare const compile: CompileFunc;

package/dist/types/{babel.d.ts → compilers/babel/index.d.ts}

@@ -1,6 +1,7 @@
 import { ILibPresetOption, ISyntaxOption } from '@modern-js/babel-preset-lib';
 import { TransformOptions } from '@babel/core';
 import type { NormalizedConfig } from '@modern-js/core';
+import { CompileFunc } from '../../common';
 export * from '@babel/core';
 export interface ITsconfig {
   compilerOptions?: {
@@ -24,4 +25,5 @@ export interface IPackageModeValue {
   syntax: 'es5' | 'es6+';
   tsconfigPath: string;
 }
-export declare const resolveBabelConfig: (appDirectory: string, modernConfig: NormalizedConfig, option: IPackageModeValue) => any;
+export declare const resolveBabelConfig: (appDirectory: string, modernConfig: NormalizedConfig, option: IPackageModeValue) => any;
+export declare const compileByBabel: CompileFunc;

package/dist/types/compilers/typescript/index.d.ts

@@ -0,0 +1,2 @@
+import type { CompileFunc } from '../../common';
+export declare const compileByTs: CompileFunc;

package/dist/types/compilers/typescript/tsconfig-paths-plugin.d.ts

@@ -0,0 +1,2 @@
+import * as ts from 'typescript';
+export declare function tsconfigPathsBeforeHookFactory(tsBinary: typeof ts, baseUrl: string, paths: Record<string, string[] | string>): ((ctx: ts.TransformationContext) => ts.Transformer<any>) | undefined;

package/dist/types/compilers/typescript/typescript-loader.d.ts

@@ -0,0 +1,11 @@
+import type ts from 'typescript';
+export declare class TypescriptLoader {
+  private tsBinary?;
+  private appDirectory?;
+  constructor({
+    appDirectory
+  }: {
+    appDirectory: string;
+  });
+  load(): typeof ts;
+}

package/dist/types/index.d.ts

@@ -1 +1,2 @@
-export * from './babel';
+export * from './compilers/babel';
+export { compile } from './common';

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.17.0",
+  "version": "1.18.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -35,16 +35,18 @@
     "@babel/preset-env": "^7.18.0",
     "@babel/preset-typescript": "^7.17.12",
     "@babel/runtime": "^7.18.0",
-    "@modern-js/babel-preset-lib": "1.17.0",
-    "@modern-js/plugin": "1.17.0",
-    "@modern-js/utils": "1.17.0",
+    "@modern-js/babel-compiler": "^1.18.1-alpha.0",
+    "@modern-js/babel-preset-lib": "1.18.1-alpha.0",
+    "@modern-js/plugin": "1.18.1-alpha.0",
+    "@modern-js/utils": "1.18.1-alpha.0",
     "babel-plugin-module-resolver": "^4.1.0",
-    "babel-plugin-transform-typescript-metadata": "^0.3.2"
+    "babel-plugin-transform-typescript-metadata": "^0.3.2",
+    "tsconfig-paths": "3.14.1"
   },
   "devDependencies": {
-    "@modern-js/core": "1.17.0",
-    "@scripts/build": "1.17.0",
-    "@scripts/jest-config": "1.17.0",
+    "@modern-js/core": "1.18.1-alpha.0",
+    "@scripts/build": "1.18.1-alpha.0",
+    "@scripts/jest-config": "1.18.1-alpha.0",
     "@types/babel__core": "^7.1.15",
     "@types/jest": "^27",
     "@types/node": "^14",
@@ -82,6 +84,7 @@
   },
   "scripts": {
     "new": "modern new",
+    "dev": "modern build --watch",
     "build": "wireit",
     "test": "wireit"
   },

package/dist/js/treeshaking/babel.js

@@ -1,74 +0,0 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import { getBabelChain, applyUserBabelConfig } from '@modern-js/babel-preset-lib';
-import { fs, json5, getAlias, applyOptionsChain } from '@modern-js/utils';
-export * from '@babel/core';
-export var readTsConfig = function readTsConfig(tsconfigPath) {
-  var noExistReturn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
-  // 如果不存在，则返回 noExistReturn
-  if (!fs.existsSync(tsconfigPath)) {
-    return noExistReturn;
-  }
-
-  var content = fs.readFileSync(tsconfigPath, 'utf-8');
-  return json5.parse(content);
-};
-export var existTsConfigFile = function existTsConfigFile(tsconfigAbsolutePath) {
-  var tsconfig = readTsConfig(tsconfigAbsolutePath);
-  return Boolean(tsconfig);
-};
-export var getBabelConfig = function getBabelConfig(libPresetOption, syntaxOption) {
-  var chain = getBabelChain(libPresetOption, syntaxOption);
-  return _objectSpread({
-    sourceType: 'unambiguous'
-  }, chain.toJSON());
-};
-export var resolveBabelConfig = function resolveBabelConfig(appDirectory, modernConfig, option // FIXME: babel type can't pass type checking
-) {
-  var _modernConfig$source = modernConfig.source,
-      envVars = _modernConfig$source.envVars,
-      globalVars = _modernConfig$source.globalVars,
-      _modernConfig$source$ = _modernConfig$source.jsxTransformRuntime,
-      jsxTransformRuntime = _modernConfig$source$ === void 0 ? 'automatic' : _modernConfig$source$,
-      userLodashOption = modernConfig.tools.lodash; // alias config
-
-  var aliasConfig = getAlias(modernConfig.source.alias, _objectSpread({
-    appDirectory: appDirectory
-  }, option)); // lodash config
-
-  var lodashOptions = applyOptionsChain({
-    id: ['lodash', 'ramda']
-  }, // TODO: 需要处理类型问题
-  userLodashOption); // babel config
-
-  var babelChain = getBabelChain({
-    appDirectory: appDirectory,
-    enableReactPreset: true,
-    enableTypescriptPreset: true,
-    alias: aliasConfig,
-    envVars: envVars,
-    globalVars: globalVars,
-    lodashOptions: lodashOptions,
-    jsxTransformRuntime: jsxTransformRuntime
-  }, {
-    type: option.type,
-    syntax: option.syntax
-  });
-  var envOptions = babelChain.preset('@babel/preset-env').options();
-  babelChain.preset('@babel/preset-env').use(require.resolve('@babel/preset-env'), [_objectSpread(_objectSpread({}, 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
-  }]); // resolve "Definitely assigned fields cannot be initialized here, but only in the constructor."
-
-  babelChain.plugin('@babel/plugin-proposal-class-properties').use(require.resolve('@babel/plugin-proposal-class-properties'), [{
-    loose: true
-  }]);
-
-  var internalBabelConfig = _objectSpread({}, babelChain.toJSON());
-
-  var userBabelConfig = modernConfig.tools.babel;
-  return applyUserBabelConfig(internalBabelConfig, userBabelConfig);
-};