@modern-js/server-utils 2.10.0 → 2.11.1-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @modern-js/server-utils
 
+## 2.11.0
+
+### Patch Changes
+
+- Updated dependencies [cfb058f]
+- Updated dependencies [0bd018b]
+- Updated dependencies [5d624fd]
+- Updated dependencies [e2466a1]
+- Updated dependencies [02bb383]
+- Updated dependencies [381a3b9]
+- Updated dependencies [7a60f10]
+- Updated dependencies [274b2e5]
+- Updated dependencies [b9e1c54]
+  - @modern-js/utils@2.11.0
+  - @modern-js/babel-preset-lib@2.11.0
+  - @modern-js/babel-compiler@2.11.0
+
 ## 2.10.0
 
 ### Patch Changes

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

@@ -97,11 +97,17 @@ const compileByTs = async (appDirectory, config, compileOptions) => {
     before: [tsconfigPathsPlugin]
   });
   const allDiagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  const { noEmitOnError } = options;
   if (allDiagnostics.length > 0) {
     import_utils.logger.error(
-      ts2.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost)
+      ts2.formatDiagnosticsWithColorAndContext(
+        [...new Set(allDiagnostics)],
+        formatHost
+      )
     );
-    process.exit(1);
+    if (typeof noEmitOnError === "undefined" || noEmitOnError === false) {
+      process.exit(1);
+    }
   }
   for (const source of sourceDirs) {
     await copyFiles(source, distDir, appDirectory, tsconfigPath);

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

@@ -1,3 +1,11 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -40,6 +48,12 @@ function _defineProperty(obj, key, value) {
     }
     return obj;
 }
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _objectSpread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -55,6 +69,17 @@ function _objectSpread(target) {
     }
     return target;
 }
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
 var __generator = this && this.__generator || function(thisArg, body) {
     var f, y, t, g, _ = {
         label: 0,
@@ -207,7 +232,7 @@ var copyFiles = function() {
 }();
 var compileByTs = function() {
     var _ref = _asyncToGenerator(function(appDirectory, config, compileOptions) {
-        var sourceDirs, distDir, tsconfigPath, ts2, createProgram, formatHost, alias, aliasOption, _aliasOption_paths, paths, _aliasOption_absoluteBaseUrl, absoluteBaseUrl, _readTsConfigByFile, options, fileNames, projectReferences, sourcePosixPaths, rootNames, program, tsconfigPathsPlugin, emitResult, allDiagnostics, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, source, err;
+        var sourceDirs, distDir, tsconfigPath, ts2, 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 __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -253,9 +278,12 @@ var compileByTs = function() {
                         ]
                     });
                     allDiagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+                    noEmitOnError = options.noEmitOnError;
                     if (allDiagnostics.length > 0) {
-                        logger.error(ts2.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
-                        process.exit(1);
+                        logger.error(ts2.formatDiagnosticsWithColorAndContext(_toConsumableArray(new Set(allDiagnostics)), formatHost));
+                        if (typeof noEmitOnError === "undefined" || noEmitOnError === false) {
+                            process.exit(1);
+                        }
                     }
                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     _state.label = 1;

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

@@ -65,11 +65,17 @@ const compileByTs = async (appDirectory, config, compileOptions) => {
     before: [tsconfigPathsPlugin]
   });
   const allDiagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  const { noEmitOnError } = options;
   if (allDiagnostics.length > 0) {
     logger.error(
-      ts2.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost)
+      ts2.formatDiagnosticsWithColorAndContext(
+        [...new Set(allDiagnostics)],
+        formatHost
+      )
     );
-    process.exit(1);
+    if (typeof noEmitOnError === "undefined" || noEmitOnError === false) {
+      process.exit(1);
+    }
   }
   for (const source of sourceDirs) {
     await copyFiles(source, distDir, appDirectory, tsconfigPath);

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
+};