@modern-js/utils 2.26.0 → 2.28.0

package/dist/esm/cli/path.js

@@ -1,49 +1,73 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import path from "path";
 import os from "os";
 import fs from "fs";
 import { nanoid, upath, lodash as _ } from "../compiled";
-export const isPathString = (test) => path.posix.basename(test) !== test || path.win32.basename(test) !== test;
-export const isRelativePath = (test) => /^\.\.?($|[\\/])/.test(test);
-export const normalizeOutputPath = (s) => s.replace(/\\/g, "\\\\");
-export const normalizeToPosixPath = (p) => upath.normalizeSafe(path.normalize(p || "")).replace(/^([a-zA-Z]+):/, (_2, m) => `/${m.toLowerCase()}`);
-export const getTemplatePath = (prefix) => {
-  const tmpRoot = fs.realpathSync(os.tmpdir());
-  const parts = [
+export var isPathString = function(test) {
+  return path.posix.basename(test) !== test || path.win32.basename(test) !== test;
+};
+export var isRelativePath = function(test) {
+  return /^\.\.?($|[\\/])/.test(test);
+};
+export var normalizeOutputPath = function(s) {
+  return s.replace(/\\/g, "\\\\");
+};
+export var normalizeToPosixPath = function(p) {
+  return upath.normalizeSafe(path.normalize(p || "")).replace(/^([a-zA-Z]+):/, function(_2, m) {
+    return "/".concat(m.toLowerCase());
+  });
+};
+export var getTemplatePath = function(prefix) {
+  var _path;
+  var tmpRoot = fs.realpathSync(os.tmpdir());
+  var parts = [
     tmpRoot
   ];
   prefix && parts.push(prefix);
   parts.push(nanoid());
-  return path.resolve(...parts);
+  return (_path = path).resolve.apply(_path, _to_consumable_array(parts));
 };
 export function compilePathMatcherRegExp(match) {
   if (typeof match !== "string") {
     return match;
   }
-  const escaped = _.escapeRegExp(match);
-  return new RegExp(`(?<=\\W|^)${escaped}(?=\\W|$)`);
+  var escaped = _.escapeRegExp(match);
+  return new RegExp("(?<=\\W|^)".concat(escaped, "(?=\\W|$)"));
 }
-export const _joinPathParts = (_part, i, parts) => _(parts).filter((part) => ![
-  "/",
-  "\\"
-].includes(part)).tap((parts2) => parts2.unshift("")).slice(0, i + 2).join("/");
+export var _joinPathParts = function(_part, i, parts) {
+  return _(parts).filter(function(part) {
+    return ![
+      "/",
+      "\\"
+    ].includes(part);
+  }).tap(function(parts2) {
+    return parts2.unshift("");
+  }).slice(0, i + 2).join("/");
+};
 export function upwardPaths(start) {
   return _(start).split(/[/\\]/).filter(Boolean).map(_joinPathParts).reverse().push("/").value();
 }
 export function getRealTemporaryDirectory() {
-  let ret = null;
+  var ret = null;
   try {
     ret = os.tmpdir();
     ret = fs.realpathSync(ret);
-  } catch {
+  } catch (e) {
   }
   return ret;
 }
 export function splitPathString(str) {
   return str.split(/[\\/]/);
 }
-export const removeLeadingSlash = (s) => s.replace(/^\/+/, "");
-export const removeTailSlash = (s) => s.replace(/\/+$/, "");
-export const removeSlash = (s) => removeLeadingSlash(removeTailSlash(s));
-export const cutNameByHyphen = (s) => {
+export var removeLeadingSlash = function(s) {
+  return s.replace(/^\/+/, "");
+};
+export var removeTailSlash = function(s) {
+  return s.replace(/\/+$/, "");
+};
+export var removeSlash = function(s) {
+  return removeLeadingSlash(removeTailSlash(s));
+};
+export var cutNameByHyphen = function(s) {
   return s.split(/[-_]/)[0];
 };

package/dist/esm/cli/pathSerializer.js

@@ -1,34 +1,48 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import os from "os";
 import _ from "../../compiled/lodash";
 import { compilePathMatcherRegExp, normalizeToPosixPath, getRealTemporaryDirectory, splitPathString, upwardPaths } from "./path";
-export const matchUpwardPathsAsUnknown = (p) => _(upwardPaths(normalizeToPosixPath(p))).map((match) => ({
-  match,
-  mark: "unknown"
-})).slice(1, -1).value();
-export function applyPathMatcher(matcher, str, options = {}) {
-  const regex = compilePathMatcherRegExp(matcher.match);
-  const replacer = (substring, ...args) => {
+export var matchUpwardPathsAsUnknown = function(p) {
+  return _(upwardPaths(normalizeToPosixPath(p))).map(function(match) {
+    return {
+      match: match,
+      mark: "unknown"
+    };
+  }).slice(1, -1).value();
+};
+export function applyPathMatcher(matcher, str) {
+  var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  var regex = compilePathMatcherRegExp(matcher.match);
+  var replacer = function(substring) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    var _matcher;
     if (options.minPartials && splitPathString(substring).length < options.minPartials) {
       return substring;
     }
-    const ret = typeof matcher.mark === "string" ? matcher.mark : matcher.mark(substring, ...args);
-    return `<${_.snakeCase(ret).toUpperCase()}>`;
+    var ret = typeof matcher.mark === "string" ? matcher.mark : (_matcher = matcher).mark.apply(_matcher, [
+      substring
+    ].concat(_to_consumable_array(args)));
+    return "<".concat(_.snakeCase(ret).toUpperCase(), ">");
   };
   return str.replace(regex, replacer);
 }
-export function applyMatcherReplacement(matchers, str, options = {}) {
-  return matchers.reduce((ret, matcher) => {
+export function applyMatcherReplacement(matchers, str) {
+  var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  return matchers.reduce(function(ret, matcher) {
     return applyPathMatcher(matcher, ret, options);
   }, str);
 }
-export const createDefaultPathMatchers = (root) => {
-  const ret = [
+export var createDefaultPathMatchers = function(root) {
+  var _ret;
+  var ret = [
     {
       match: RegExp("(?<=\\/)(\\.pnpm\\/.+?\\/node_modules)(?=\\/)"),
       mark: "pnpmInner"
     }
   ];
-  const tmpdir = getRealTemporaryDirectory();
+  var tmpdir = getRealTemporaryDirectory();
   tmpdir && ret.push({
     match: tmpdir,
     mark: "temp"
@@ -41,6 +55,6 @@ export const createDefaultPathMatchers = (root) => {
     match: os.homedir(),
     mark: "home"
   });
-  ret.push(...matchUpwardPathsAsUnknown(root));
+  (_ret = ret).push.apply(_ret, _to_consumable_array(matchUpwardPathsAsUnknown(root)));
   return ret;
 };

package/dist/esm/cli/port.js

@@ -1,44 +1,93 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import net from "net";
 import { chalk } from "../compiled";
 import { logger } from "./logger";
-export const getPort = async (port, { tryLimits = 20, strictPort = false } = {}) => {
-  if (typeof port === "string") {
-    port = parseInt(port, 10);
-  }
-  if (strictPort) {
-    tryLimits = 1;
-  }
-  const original = port;
-  let found = false;
-  let attempts = 0;
-  while (!found && attempts <= tryLimits) {
-    try {
-      await new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.unref();
-        server.on("error", reject);
-        server.listen({
-          port,
-          host: "0.0.0.0"
-        }, () => {
-          found = true;
-          server.close(resolve);
-        });
-      });
-    } catch (e) {
-      if (e.code !== "EADDRINUSE") {
-        throw e;
+export var getPort = function() {
+  var _ref = _async_to_generator(function(port) {
+    var _ref2, _ref_tryLimits, tryLimits, _ref_strictPort, strictPort, original, found, attempts, e;
+    var _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _ref2 = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {}, _ref_tryLimits = _ref2.tryLimits, tryLimits = _ref_tryLimits === void 0 ? 20 : _ref_tryLimits, _ref_strictPort = _ref2.strictPort, strictPort = _ref_strictPort === void 0 ? false : _ref_strictPort;
+          if (typeof port === "string") {
+            port = parseInt(port, 10);
+          }
+          if (strictPort) {
+            tryLimits = 1;
+          }
+          original = port;
+          found = false;
+          attempts = 0;
+          _state.label = 1;
+        case 1:
+          if (!(!found && attempts <= tryLimits))
+            return [
+              3,
+              6
+            ];
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            ,
+            5
+          ]);
+          return [
+            4,
+            new Promise(function(resolve, reject) {
+              var server = net.createServer();
+              server.unref();
+              server.on("error", reject);
+              server.listen({
+                port: port,
+                host: "0.0.0.0"
+              }, function() {
+                found = true;
+                server.close(resolve);
+              });
+            })
+          ];
+        case 3:
+          _state.sent();
+          return [
+            3,
+            5
+          ];
+        case 4:
+          e = _state.sent();
+          if (e.code !== "EADDRINUSE") {
+            throw e;
+          }
+          port++;
+          attempts++;
+          return [
+            3,
+            5
+          ];
+        case 5:
+          return [
+            3,
+            1
+          ];
+        case 6:
+          if (port !== original) {
+            if (strictPort) {
+              throw new Error('Port "'.concat(original, '" is occupied, please choose another one.'));
+            } else {
+              logger.info("Something is already running on port ".concat(original, ". ").concat(chalk.yellow("Use port ".concat(port, " instead."))));
+            }
+          }
+          return [
+            2,
+            port
+          ];
       }
-      port++;
-      attempts++;
-    }
-  }
-  if (port !== original) {
-    if (strictPort) {
-      throw new Error(`Port "${original}" is occupied, please choose another one.`);
-    } else {
-      logger.info(`Something is already running on port ${original}. ${chalk.yellow(`Use port ${port} instead.`)}`);
-    }
-  }
-  return port;
-};
+    });
+  });
+  return function getPort2(port) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/esm/cli/prettyInstructions.js

@@ -1,14 +1,17 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import os from "os";
 import { chalk } from "../compiled";
 import { isDev, isSingleEntry } from "./is";
 import { DEFAULT_DEV_HOST } from "./constants";
-const normalizeUrl = (url) => url.replace(/([^:]\/)\/+/g, "$1");
-const getIpv4Interfaces = () => {
-  const interfaces = os.networkInterfaces();
-  const ipv4Interfaces = [];
-  Object.keys(interfaces).forEach((key) => {
-    interfaces[key].forEach((detail) => {
-      const familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
+var normalizeUrl = function(url) {
+  return url.replace(/([^:]\/)\/+/g, "$1");
+};
+var getIpv4Interfaces = function() {
+  var interfaces = os.networkInterfaces();
+  var ipv4Interfaces = [];
+  Object.keys(interfaces).forEach(function(key) {
+    interfaces[key].forEach(function(detail) {
+      var familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
       if (detail.family === familyV4Value) {
         ipv4Interfaces.push(detail);
       }
@@ -16,57 +19,66 @@ const getIpv4Interfaces = () => {
   });
   return ipv4Interfaces;
 };
-export const getAddressUrls = (protocol = "http", port, host) => {
-  const LOCAL_LABEL = "Local:  ";
-  const NETWORK_LABEL = "Network:  ";
-  const isLocalhost = (url) => {
-    return url === null || url === void 0 ? void 0 : url.includes("localhost");
+export var getAddressUrls = function() {
+  var protocol = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "http", port = arguments.length > 1 ? arguments[1] : void 0, host = arguments.length > 2 ? arguments[2] : void 0;
+  var LOCAL_LABEL = "Local:  ";
+  var NETWORK_LABEL = "Network:  ";
+  var isLocalhost = function(url) {
+    var _url;
+    return (_url = url) === null || _url === void 0 ? void 0 : _url.includes("localhost");
   };
   if (host && host !== DEFAULT_DEV_HOST) {
     return [
       {
         label: isLocalhost(host) ? LOCAL_LABEL : NETWORK_LABEL,
-        url: `${protocol}://${host}:${port}`
+        url: "".concat(protocol, "://").concat(host, ":").concat(port)
       }
     ];
   }
-  const ipv4Interfaces = getIpv4Interfaces();
-  return ipv4Interfaces.reduce((memo, detail) => {
+  var ipv4Interfaces = getIpv4Interfaces();
+  return ipv4Interfaces.reduce(function(memo, detail) {
     if (isLocalhost(detail.address) || detail.internal) {
       memo.push({
         label: LOCAL_LABEL,
-        url: `${protocol}://localhost:${port}`
+        url: "".concat(protocol, "://localhost:").concat(port)
       });
     } else {
       memo.push({
         label: NETWORK_LABEL,
-        url: `${protocol}://${detail.address}:${port}`
+        url: "".concat(protocol, "://").concat(detail.address, ":").concat(port)
       });
     }
     return memo;
   }, []);
 };
-export const prettyInstructions = (appContext, config) => {
+export var prettyInstructions = function(appContext, config) {
   var _appContext_builder_context_devServer, _appContext_builder, _config_dev;
-  const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
-  const isHttps = isDev() && ((_appContext_builder_context_devServer = (_appContext_builder = appContext.builder) === null || _appContext_builder === void 0 ? void 0 : _appContext_builder.context.devServer) === null || _appContext_builder_context_devServer === void 0 ? void 0 : _appContext_builder_context_devServer.https);
-  const urls = getAddressUrls(isHttps ? "https" : "http", port, (_config_dev = config.dev) === null || _config_dev === void 0 ? void 0 : _config_dev.host);
-  const routes = !apiOnly ? serverRoutes.filter((route) => route.entryName) : serverRoutes;
-  let message = "App running at:\n\n";
+  var entrypoints = appContext.entrypoints, serverRoutes = appContext.serverRoutes, port = appContext.port, apiOnly = appContext.apiOnly, checkedEntries = appContext.checkedEntries;
+  var isHttps = isDev() && ((_appContext_builder = appContext.builder) === null || _appContext_builder === void 0 ? void 0 : (_appContext_builder_context_devServer = _appContext_builder.context.devServer) === null || _appContext_builder_context_devServer === void 0 ? void 0 : _appContext_builder_context_devServer.https);
+  var urls = getAddressUrls(isHttps ? "https" : "http", port, (_config_dev = config.dev) === null || _config_dev === void 0 ? void 0 : _config_dev.host);
+  var routes = !apiOnly ? serverRoutes.filter(function(route) {
+    return route.entryName;
+  }) : serverRoutes;
+  var message = "App running at:\n\n";
   if (isSingleEntry(entrypoints) || apiOnly) {
-    message += urls.map(({ label, url }) => `  ${chalk.bold(`> ${label.padEnd(10)}`)}${chalk.cyanBright(normalizeUrl(`${url}/${routes[0].urlPath}`))}
-`).join("");
+    message += urls.map(function(param) {
+      var label = param.label, url = param.url;
+      return "  ".concat(chalk.bold("> ".concat(label.padEnd(10)))).concat(chalk.cyanBright(normalizeUrl("".concat(url, "/").concat(routes[0].urlPath))), "\n");
+    }).join("");
   } else {
-    const maxNameLength = Math.max(...routes.map((r) => r.entryName.length));
-    urls.forEach(({ label, url }) => {
-      message += `  ${chalk.bold(`> ${label}`)}
-`;
-      routes.forEach(({ entryName, urlPath, isSSR }) => {
+    var _Math;
+    var maxNameLength = (_Math = Math).max.apply(_Math, _to_consumable_array(routes.map(function(r) {
+      return r.entryName.length;
+    })));
+    urls.forEach(function(param) {
+      var label = param.label, url = param.url;
+      message += "  ".concat(chalk.bold("> ".concat(label)), "\n");
+      routes.forEach(function(param2) {
+        var entryName = param2.entryName, urlPath = param2.urlPath, isSSR = param2.isSSR;
         if (!checkedEntries.includes(entryName)) {
           return;
         }
-        message += `    ${chalk.yellowBright(isSSR ? "λ" : "○")}  ${chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}
-`;
+        message += "    ".concat(chalk.yellowBright(isSSR ? "λ" : "○"), "  ").concat(chalk.yellowBright(entryName.padEnd(maxNameLength + 8))).concat(chalk.cyanBright(normalizeUrl("".concat(url, "/").concat(urlPath))), "\n");
       });
     });
     message += "\n";

package/dist/esm/cli/require.js

@@ -1,27 +1,31 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { findExists } from "./fs";
-export const compatRequire = (filePath, interop = true) => {
-  const mod = require(filePath);
-  const rtnESMDefault = interop && (mod === null || mod === void 0 ? void 0 : mod.__esModule);
+export var compatRequire = function(filePath) {
+  var interop = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+  var _mod;
+  var mod = require(filePath);
+  var rtnESMDefault = interop && ((_mod = mod) === null || _mod === void 0 ? void 0 : _mod.__esModule);
   return rtnESMDefault ? mod.default : mod;
 };
-export const dynamicImport = new Function("modulePath", "return import(modulePath)");
-export const requireExistModule = (filename, opt) => {
-  const final = {
+export var dynamicImport = new Function("modulePath", "return import(modulePath)");
+export var requireExistModule = function(filename, opt) {
+  var final = _object_spread({
     extensions: [
       ".ts",
       ".js"
     ],
-    interop: true,
-    ...opt
-  };
-  const exist = findExists(final.extensions.map((ext) => `${filename}${ext}`));
+    interop: true
+  }, opt);
+  var exist = findExists(final.extensions.map(function(ext) {
+    return "".concat(filename).concat(ext);
+  }));
   if (!exist) {
     return null;
   }
   return compatRequire(exist, final.interop);
 };
-export const cleanRequireCache = (filelist) => {
-  filelist.forEach((filepath) => {
+export var cleanRequireCache = function(filelist) {
+  filelist.forEach(function(filepath) {
     delete require.cache[filepath];
   });
 };
@@ -30,11 +34,13 @@ export function deleteRequireCache(path) {
     delete require.cache[path];
   }
   if (module.children) {
-    module.children = module.children.filter((item) => item.filename !== path);
+    module.children = module.children.filter(function(item) {
+      return item.filename !== path;
+    });
   }
 }
-export const tryResolve = (name, resolvePath) => {
-  let filePath = "";
+export var tryResolve = function(name, resolvePath) {
+  var filePath = "";
   try {
     filePath = require.resolve(name, {
       paths: [
@@ -44,7 +50,7 @@ export const tryResolve = (name, resolvePath) => {
     delete require.cache[filePath];
   } catch (err) {
     if (err.code === "MODULE_NOT_FOUND") {
-      throw new Error(`Can not find module ${name}.`);
+      throw new Error("Can not find module ".concat(name, "."));
     }
     throw err;
   }

package/dist/esm/cli/runtimeExports.js

@@ -1,35 +1,41 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import path from "path";
 import { fs } from "../compiled";
 import { normalizeOutputPath } from "./path";
-const memo = (fn) => {
-  const cache = /* @__PURE__ */ new Map();
-  return (...params) => {
-    const stringifiedParams = JSON.stringify(params);
-    const cachedResult = cache.get(stringifiedParams);
+var memo = function(fn) {
+  var cache = /* @__PURE__ */ new Map();
+  return function() {
+    for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+      params[_key] = arguments[_key];
+    }
+    var stringifiedParams = JSON.stringify(params);
+    var cachedResult = cache.get(stringifiedParams);
     if (cachedResult) {
       return cachedResult;
     }
-    const res = fn(...params);
+    var res = fn.apply(void 0, _to_consumable_array(params));
     cache.set(stringifiedParams, res);
     return res;
   };
 };
-export const createRuntimeExportsUtils = memo((pwd = "", namespace = "index") => {
-  const entryExportFile = path.join(pwd, `.runtime-exports/${namespace}.js`);
-  const addExport = (statement) => {
+export var createRuntimeExportsUtils = memo(function() {
+  var pwd = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "", namespace = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "index";
+  var entryExportFile = path.join(pwd, ".runtime-exports/".concat(namespace, ".js"));
+  var addExport = function(statement) {
     statement = normalizeOutputPath(statement);
     try {
       fs.ensureFileSync(entryExportFile);
       if (!fs.readFileSync(entryExportFile, "utf8").includes(statement)) {
-        fs.appendFileSync(entryExportFile, `${statement}
-`);
+        fs.appendFileSync(entryExportFile, "".concat(statement, "\n"));
       }
-    } catch {
+    } catch (e) {
     }
   };
-  const getPath = () => entryExportFile;
+  var getPath = function() {
+    return entryExportFile;
+  };
   return {
-    addExport,
-    getPath
+    addExport: addExport,
+    getPath: getPath
   };
 });