@modern-js/utils 2.13.4 → 2.14.0

package/dist/{pathSerializer.js → cjs/pathSerializer.js}

@@ -56,7 +56,7 @@ function applyMatcherReplacement(matchers, str, options = {}) {
 const createDefaultPathMatchers = (root) => {
   const ret = [
     {
-      match: new RegExp("(?<=\\/)(\\.pnpm\\/.+?\\/node_modules)(?=\\/)"),
+      match: /(?<=\/)(\.pnpm\/.+?\/node_modules)(?=\/)/,
       mark: "pnpmInner"
     }
   ];

package/dist/{prettyInstructions.js → cjs/prettyInstructions.js}

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(prettyInstructions_exports);
 var import_os = __toESM(require("os"));
 var import_compiled = require("./compiled");
 var import_is = require("./is");
+var import_constants = require("./constants");
 const normalizeUrl = (url) => url.replace(/([^:]\/)\/+/g, "$1");
 const getIpv4Interfaces = () => {
   const interfaces = import_os.default.networkInterfaces();
@@ -49,24 +50,41 @@ const getIpv4Interfaces = () => {
   });
   return ipv4Interfaces;
 };
-const getAddressUrls = (protocol = "http", port) => {
+const getAddressUrls = (protocol = "http", port, host) => {
+  const LOCAL_LABEL = "Local:  ";
+  const NETWORK_LABEL = "Network:  ";
+  const isLocalhost = (url) => url == null ? void 0 : url.includes("localhost");
+  if (host && host !== import_constants.DEFAULT_DEV_HOST) {
+    return [
+      {
+        label: isLocalhost(host) ? LOCAL_LABEL : NETWORK_LABEL,
+        url: `${protocol}://${host}:${port}`
+      }
+    ];
+  }
   const ipv4Interfaces = getIpv4Interfaces();
   return ipv4Interfaces.reduce((memo, detail) => {
-    let label = "Network:  ";
-    let url = `${protocol}://${detail.address}:${port}`;
-    if (detail.address.includes(`localhost`) || detail.internal) {
-      label = "Local:  ";
-      url = `${protocol}://localhost:${port}`;
+    if (isLocalhost(detail.address) || detail.internal) {
+      memo.push({
+        label: LOCAL_LABEL,
+        url: `${protocol}://localhost:${port}`
+      });
+    } else {
+      memo.push({
+        label: NETWORK_LABEL,
+        url: `${protocol}://${detail.address}:${port}`
+      });
     }
-    memo.push({ label, url });
     return memo;
   }, []);
 };
 const prettyInstructions = (appContext, config) => {
+  var _a;
   const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
   const urls = getAddressUrls(
     config.dev.https && (0, import_is.isDev)() ? "https" : "http",
-    port
+    port,
+    (_a = config.dev) == null ? void 0 : _a.host
   );
   const routes = !apiOnly ? serverRoutes.filter((route) => route.entryName) : serverRoutes;
   let message = "App running at:\n\n";

package/dist/{react.js → cjs/react.js}

@@ -2,22 +2,8 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -52,7 +38,10 @@ const isBeyondReact17 = (cwd) => {
     return false;
   }
   const pkgInfo = JSON.parse(import__.fs.readFileSync(pkgPath, "utf8"));
-  const deps = __spreadValues(__spreadValues({}, pkgInfo.devDependencies), pkgInfo.dependencies);
+  const deps = {
+    ...pkgInfo.devDependencies,
+    ...pkgInfo.dependencies
+  };
   if (typeof deps.react !== "string") {
     return false;
   }

package/dist/cjs/runtime/index.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+module.exports = __toCommonJS(runtime_exports);
+__reExport(runtime_exports, require("./parsed"), module.exports);

package/dist/cjs/runtime/parsed.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parsed_exports = {};
+__export(parsed_exports, {
+  parsedJSONFromElement: () => parsedJSONFromElement
+});
+module.exports = __toCommonJS(parsed_exports);
+const parsedJSONFromElement = (id) => {
+  const element = document.getElementById(id);
+  if (element) {
+    try {
+      const parsed = JSON.parse(element.textContent || "");
+      return parsed;
+    } catch (e) {
+      console.error(`parse ${id} error`, e);
+      return void 0;
+    }
+  }
+  return void 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsedJSONFromElement
+});

package/dist/{runtimeExports.js → cjs/runtimeExports.js}

@@ -57,7 +57,7 @@ const createRuntimeExportsUtils = memo(
           import_compiled.fs.appendFileSync(entryExportFile, `${statement}
 `);
         }
-      } catch (e) {
+      } catch {
       }
     };
     const getPath = () => entryExportFile;

package/dist/{universal → cjs/universal}/nestedRoutes.js

@@ -1,24 +1,7 @@
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -50,7 +33,7 @@ const transformNestedRoutes = (routes) => {
   return (0, import_react_router_dom.createRoutesFromElements)(routeElements);
 };
 const renderNestedRoute = (nestedRoute, options = {}) => {
-  const { children, index, id, component, isRoot, lazyImport } = nestedRoute;
+  const { children, index, id, component, isRoot, lazyImport, config } = nestedRoute;
   const Component = component;
   const { parent, DeferredDataComponent, props = {} } = options;
   const routeProps = {
@@ -61,7 +44,7 @@ const renderNestedRoute = (nestedRoute, options = {}) => {
     action: nestedRoute.action,
     hasErrorBoundary: nestedRoute.hasErrorBoundary,
     shouldRevalidate: nestedRoute.shouldRevalidate,
-    handle: nestedRoute.handle,
+    handle: typeof config === "object" ? config == null ? void 0 : config.handle : {},
     index: nestedRoute.index,
     element: nestedRoute.element,
     errorElement: nestedRoute.errorElement
@@ -83,7 +66,7 @@ const renderNestedRoute = (nestedRoute, options = {}) => {
       element = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {});
     } else if (isRoot) {
       element = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, __spreadValues({}, props)),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ...props }),
         typeof document === "undefined" && DeferredDataComponent && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DeferredDataComponent, {})
       ] });
     } else if (lazyImport) {
@@ -100,7 +83,7 @@ const renderNestedRoute = (nestedRoute, options = {}) => {
   const childElements = children == null ? void 0 : children.map((childRoute) => {
     return renderNestedRoute(childRoute, { parent: nestedRoute });
   });
-  const routeElement = index ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_router_dom.Route, __spreadProps(__spreadValues({}, routeProps), { index: true }), id) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_router_dom.Route, __spreadProps(__spreadValues({}, routeProps), { index: false, children: childElements }), id);
+  const routeElement = index ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_router_dom.Route, { ...routeProps, index: true }, id) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_router_dom.Route, { ...routeProps, index: false, children: childElements }, id);
   return routeElement;
 };
 function createLoader(route) {

package/dist/cjs/version.js

@@ -0,0 +1,59 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var version_exports = {};
+__export(version_exports, {
+  getPnpmVersion: () => getPnpmVersion,
+  isReact18: () => isReact18
+});
+module.exports = __toCommonJS(version_exports);
+var import_path = __toESM(require("path"));
+var import_compiled = require("./compiled");
+async function getPnpmVersion() {
+  const { stdout } = await (0, import_compiled.execa)("pnpm", ["--version"]);
+  return stdout;
+}
+const isReact18 = (cwd) => {
+  const pkgPath = import_path.default.join(cwd, "package.json");
+  if (!import_compiled.fs.existsSync(pkgPath)) {
+    return false;
+  }
+  const pkgInfo = JSON.parse(import_compiled.fs.readFileSync(pkgPath, "utf8"));
+  const deps = {
+    ...pkgInfo.devDependencies,
+    ...pkgInfo.dependencies
+  };
+  if (typeof deps.react !== "string") {
+    return false;
+  }
+  return import_compiled.semver.satisfies(import_compiled.semver.minVersion(deps.react), ">=18.0.0");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPnpmVersion,
+  isReact18
+});

package/dist/{watch.js → cjs/watch.js}

@@ -25,26 +25,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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());
-  });
-};
 var watch_exports = {};
 __export(watch_exports, {
   WatchChangeType: () => WatchChangeType,
@@ -64,20 +44,20 @@ const watch = (watchDir, runTask, ignored = []) => {
     ignored
   });
   watcher.on("ready", () => ready = true);
-  watcher.on("change", (filePath) => __async(void 0, null, function* () {
+  watcher.on("change", async (filePath) => {
     const changedFilePath = path.resolve(filePath);
-    yield runTask({ changedFilePath, changeType: WatchChangeType.CHANGE });
-  }));
-  watcher.on("add", (filePath) => __async(void 0, null, function* () {
+    await runTask({ changedFilePath, changeType: WatchChangeType.CHANGE });
+  });
+  watcher.on("add", async (filePath) => {
     const changedFilePath = path.resolve(filePath);
     if (ready) {
-      yield runTask({ changedFilePath, changeType: WatchChangeType.ADD });
+      await runTask({ changedFilePath, changeType: WatchChangeType.ADD });
     }
-  }));
-  watcher.on("unlink", (filePath) => __async(void 0, null, function* () {
+  });
+  watcher.on("unlink", async (filePath) => {
     const changedFilePath = path.resolve(filePath);
-    yield runTask({ changedFilePath, changeType: WatchChangeType.UNLINK });
-  }));
+    await runTask({ changedFilePath, changeType: WatchChangeType.UNLINK });
+  });
   watcher.on("error", (err) => {
     throw err;
   });

package/dist/esm/FileSizeReporter.js

@@ -0,0 +1,133 @@
+import fs from "fs";
+import path from "path";
+import {
+  chalk,
+  filesize,
+  stripAnsi,
+  gzipSize,
+  recursiveReaddir
+} from "./compiled";
+import { logger } from "./logger";
+function canReadAsset(asset) {
+  return /\.(js|css)$/.test(asset) && !/service-worker\.js/.test(asset) && !/precache-manifest\.[0-9a-f]+\.js/.test(asset);
+}
+function printFileSizesAfterBuild(webpackStats, previousSizeMap, buildFolder, maxBundleGzipSize, maxChunkGzipSize) {
+  var root = previousSizeMap.root;
+  var sizes = previousSizeMap.sizes;
+  var assets = (webpackStats.stats || [webpackStats]).map(
+    (stats) => stats.toJson({ all: false, assets: true }).assets.filter((asset) => canReadAsset(asset.name)).map((asset) => {
+      var fileContents = fs.readFileSync(path.join(root, asset.name));
+      var size = fileContents.length;
+      var gzippedSize = gzipSize.sync(fileContents);
+      var [previousSize, previousGzipSize] = sizes[removeFileNameHash(root, asset.name)] || [];
+      var sizeDifference = getDifferenceLabel(size, previousSize);
+      var gzipSizeDifference = getDifferenceLabel(
+        gzippedSize,
+        previousGzipSize
+      );
+      return {
+        folder: path.join(
+          path.basename(buildFolder),
+          path.dirname(asset.name)
+        ),
+        name: path.basename(asset.name),
+        gzippedSize,
+        sizeLabel: filesize(size) + (sizeDifference ? " (" + sizeDifference + ")" : ""),
+        gzipSizeLabel: filesize(gzippedSize) + (gzipSizeDifference ? " (" + gzipSizeDifference + ")" : "")
+      };
+    })
+  ).reduce((single, all) => all.concat(single), []);
+  assets.sort((a, b) => b.size - a.size);
+  var longestSizeLabelLength = Math.max.apply(
+    null,
+    assets.map((a) => stripAnsi(a.sizeLabel).length)
+  );
+  var longestFileNameLength = Math.max.apply(
+    null,
+    assets.map((a) => stripAnsi(a.folder + path.sep + a.name).length)
+  );
+  printFileSizesHeader(longestFileNameLength, longestSizeLabelLength);
+  var suggestBundleSplitting = false;
+  assets.forEach((asset) => {
+    var { folder, name, sizeLabel, gzipSizeLabel, gzippedSize } = asset;
+    var fileNameLength = stripAnsi(folder + path.sep + name).length;
+    var sizeLength = stripAnsi(sizeLabel).length;
+    if (sizeLength < longestSizeLabelLength) {
+      var rightPadding = " ".repeat(longestSizeLabelLength - sizeLength);
+      sizeLabel += rightPadding;
+    }
+    var fileNameLabel = chalk.dim(asset.folder + path.sep) + chalk.cyan(asset.name);
+    if (fileNameLength < longestFileNameLength) {
+      var rightPadding = " ".repeat(longestFileNameLength - fileNameLength);
+      fileNameLabel += rightPadding;
+    }
+    var isMainBundle = asset.name.indexOf("main.") === 0;
+    var maxRecommendedSize = isMainBundle ? maxBundleGzipSize : maxChunkGzipSize;
+    var isLarge = maxRecommendedSize && gzippedSize > maxRecommendedSize;
+    if (isLarge && path.extname(asset.name) === ".js") {
+      suggestBundleSplitting = true;
+    }
+    logger.log(
+      "  " + fileNameLabel + "    " + sizeLabel + "    " + (isLarge ? chalk.yellow(gzipSizeLabel) : gzipSizeLabel)
+    );
+  });
+  if (suggestBundleSplitting) {
+    logger.log();
+    logger.warn("The bundle size is significantly larger than recommended.");
+  }
+}
+function printFileSizesHeader(longestFileNameLength, longestSizeLabelLength) {
+  const longestLengths = [longestFileNameLength, longestSizeLabelLength];
+  const headerRow = ["File", "Size", "Gzipped"].reduce((prev, cur, index) => {
+    const length = longestLengths[index];
+    let curLabel = cur;
+    if (length) {
+      curLabel = cur.length < length ? cur + " ".repeat(length - cur.length) : cur;
+    }
+    return prev + curLabel + "    ";
+  }, "  ");
+  logger.log(chalk.bold(chalk.blue(headerRow)));
+}
+function removeFileNameHash(buildFolder, fileName) {
+  return fileName.replace(buildFolder, "").replace(/\\/g, "/").replace(
+    /\/?(.*)(\.[0-9a-f]+)(\.chunk)?(\.js|\.css)/,
+    (match, p1, p2, p3, p4) => p1 + p4
+  );
+}
+function getDifferenceLabel(currentSize, previousSize) {
+  var FIFTY_KILOBYTES = 1024 * 50;
+  var difference = currentSize - previousSize;
+  var fileSize = !Number.isNaN(difference) ? filesize(difference) : 0;
+  if (difference >= FIFTY_KILOBYTES) {
+    return chalk.red("+" + fileSize);
+  } else if (difference < FIFTY_KILOBYTES && difference > 0) {
+    return chalk.yellow("+" + fileSize);
+  } else if (difference < 0) {
+    return chalk.green(fileSize);
+  } else {
+    return "";
+  }
+}
+function measureFileSizesBeforeBuild(buildFolder) {
+  return new Promise((resolve) => {
+    recursiveReaddir(buildFolder, (err, fileNames) => {
+      var sizes;
+      if (!err && fileNames) {
+        sizes = fileNames.filter(canReadAsset).reduce((memo, fileName) => {
+          var contents = fs.readFileSync(fileName);
+          var key = removeFileNameHash(buildFolder, fileName);
+          memo[key] = [contents.length, gzipSize.sync(contents)];
+          return memo;
+        }, {});
+      }
+      resolve({
+        root: buildFolder,
+        sizes: sizes || {}
+      });
+    });
+  });
+}
+export {
+  measureFileSizesBeforeBuild,
+  printFileSizesAfterBuild
+};

package/dist/esm/alias.js

@@ -0,0 +1,61 @@
+import fs from "fs";
+import path from "path";
+import { chalk } from "./compiled";
+import { readTsConfigByFile } from "./readTsConfig";
+import { applyOptionsChain } from "./applyOptionsChain";
+const validAlias = (modernConfig, { tsconfigPath }) => {
+  const {
+    source: { alias }
+  } = modernConfig;
+  if (!alias) {
+    return null;
+  }
+  const isTsProject = fs.existsSync(tsconfigPath);
+  if (!isTsProject) {
+    return null;
+  }
+  const userAlias = getUserAlias(alias);
+  if (Object.keys(userAlias).length > 0) {
+    return chalk.red(
+      'Note: Please use `compilerOptions.paths` in "tsconfig.json" file replace `source.alias` config in "modern.config.js/ts" when project is typescript'
+    );
+  }
+  return null;
+};
+const mergeAlias = (alias) => applyOptionsChain({}, alias);
+const getAliasConfig = (aliasOption, option) => {
+  var _a, _b;
+  const isTsProject = fs.existsSync(option.tsconfigPath);
+  const alias = mergeAlias(aliasOption);
+  if (!isTsProject) {
+    return {
+      absoluteBaseUrl: option.appDirectory,
+      paths: alias,
+      isTsPath: false,
+      isTsProject
+    };
+  }
+  const tsconfig = readTsConfigByFile(option.tsconfigPath);
+  const baseUrl = (_a = tsconfig == null ? void 0 : tsconfig.compilerOptions) == null ? void 0 : _a.baseUrl;
+  return {
+    absoluteBaseUrl: baseUrl ? path.join(option.appDirectory, baseUrl) : option.appDirectory,
+    paths: {
+      ...alias,
+      ...(_b = tsconfig == null ? void 0 : tsconfig.compilerOptions) == null ? void 0 : _b.paths
+    },
+    isTsPath: true,
+    isTsProject
+  };
+};
+const getUserAlias = (alias = {}) => Object.keys(alias).reduce((o, k) => {
+  if (Array.isArray(alias[k])) {
+    o[k] = alias[k];
+  }
+  return o;
+}, {});
+export {
+  getAliasConfig,
+  getUserAlias,
+  mergeAlias,
+  validAlias
+};

package/dist/esm/analyzeProject.js

@@ -0,0 +1,17 @@
+import * as path from "path";
+import { getArgv } from "./commands";
+import { fs, minimist } from "./compiled";
+const isApiOnly = async (appDirectory, entryDir) => {
+  const srcDir = path.join(appDirectory, entryDir != null ? entryDir : "src");
+  const existSrc = await fs.pathExists(srcDir);
+  const options = minimist(getArgv());
+  return !existSrc || Boolean(options["api-only"]);
+};
+const isWebOnly = async () => {
+  const options = minimist(getArgv());
+  return Boolean(options["web-only"]);
+};
+export {
+  isApiOnly,
+  isWebOnly
+};

package/dist/esm/applyOptionsChain.js

@@ -0,0 +1,35 @@
+import { isFunction, logger, isPlainObject } from "./index";
+function applyOptionsChain(defaults, options, utils, mergeFn = Object.assign) {
+  if (!options) {
+    return defaults;
+  }
+  if (isPlainObject(options)) {
+    return mergeFn(defaults, options);
+  } else if (isFunction(options)) {
+    const ret = options(defaults, utils);
+    if (ret) {
+      if (!isPlainObject(ret)) {
+        logger.warn(
+          `${options.name}: Function should mutate the config and return nothing, Or return a cloned or merged version of config object.`
+        );
+      }
+      return ret;
+    }
+  } else if (Array.isArray(options)) {
+    return options.reduce(
+      (memo, cur) => applyOptionsChain(memo, cur, utils, mergeFn),
+      defaults
+    );
+  } else {
+    throw new Error(
+      `applyOptionsChain error:
+default options is: ${JSON.stringify(
+        defaults
+      )}`
+    );
+  }
+  return defaults;
+}
+export {
+  applyOptionsChain
+};