@modern-js/utils 2.26.0 → 2.27.0

package/dist/esm/cli/monorepo.js

@@ -1,39 +1,44 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import fs from "fs";
 import path from "path";
 import { glob, yaml } from "../compiled";
-const PACKAGE_MAX_DEPTH = 5;
-const WORKSPACE_FILES = {
+var PACKAGE_MAX_DEPTH = 5;
+var WORKSPACE_FILES = {
   YARN: "package.json",
   PNPM: "pnpm-workspace.yaml",
   LERNA: "lerna.json"
 };
-export const isLerna = (root) => fs.existsSync(path.join(root, WORKSPACE_FILES.LERNA));
-export const isYarnWorkspaces = (root) => {
+export var isLerna = function(root) {
+  return fs.existsSync(path.join(root, WORKSPACE_FILES.LERNA));
+};
+export var isYarnWorkspaces = function(root) {
   var _json_workspaces;
-  const pkg = path.join(root, WORKSPACE_FILES.YARN);
+  var pkg = path.join(root, WORKSPACE_FILES.YARN);
   if (!fs.existsSync(pkg)) {
     return false;
   }
-  const json = JSON.parse(fs.readFileSync(pkg, "utf8"));
+  var json = JSON.parse(fs.readFileSync(pkg, "utf8"));
   return Boolean((_json_workspaces = json.workspaces) === null || _json_workspaces === void 0 ? void 0 : _json_workspaces.packages);
 };
-export const isPnpmWorkspaces = (root) => fs.existsSync(path.join(root, WORKSPACE_FILES.PNPM));
-export const isMonorepo = (root) => isLerna(root) || isYarnWorkspaces(root) || isPnpmWorkspaces(root);
-export const isModernjsMonorepo = (root) => {
-  const pkgJsonPath = path.join(root, "package.json");
+export var isPnpmWorkspaces = function(root) {
+  return fs.existsSync(path.join(root, WORKSPACE_FILES.PNPM));
+};
+export var isMonorepo = function(root) {
+  return isLerna(root) || isYarnWorkspaces(root) || isPnpmWorkspaces(root);
+};
+export var isModernjsMonorepo = function(root) {
+  var pkgJsonPath = path.join(root, "package.json");
   if (!fs.existsSync(pkgJsonPath)) {
     return false;
   }
-  const json = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
-  const deps = {
-    ...json.dependencies || {},
-    ...json.devDependencies || {}
-  };
+  var json = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+  var deps = _object_spread({}, json.dependencies || {}, json.devDependencies || {});
   return Boolean(deps["@modern-js/monorepo-tools"]);
 };
-export const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH) => {
-  let inMonorepo = false;
-  for (let depth = 0; depth < maxDepth; depth++) {
+export var findMonorepoRoot = function(appDirectory) {
+  var maxDepth = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : PACKAGE_MAX_DEPTH;
+  var inMonorepo = false;
+  for (var depth = 0; depth < maxDepth; depth++) {
     if (isMonorepo(appDirectory)) {
       inMonorepo = true;
       break;
@@ -42,29 +47,37 @@ export const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH) =>
   }
   return inMonorepo ? appDirectory : void 0;
 };
-export const getMonorepoPackages = (root) => {
-  let packages = [];
+export var getMonorepoPackages = function(root) {
+  var packages = [];
   if (isYarnWorkspaces(root)) {
-    const json = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
-    ({ packages } = json.workspaces);
+    var json = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    packages = json.workspaces.packages;
   } else if (isLerna(root)) {
-    const json = JSON.parse(fs.readFileSync(path.resolve(root, "lerna.json"), "utf8"));
-    ({ packages } = json);
+    var json1 = JSON.parse(fs.readFileSync(path.resolve(root, "lerna.json"), "utf8"));
+    packages = json1.packages;
   } else {
-    ({ packages } = yaml.load(fs.readFileSync(path.join(root, WORKSPACE_FILES.PNPM), "utf8")));
+    packages = yaml.load(fs.readFileSync(path.join(root, WORKSPACE_FILES.PNPM), "utf8")).packages;
   }
   if (packages) {
-    return packages.map((name) => (
-      // The trailing / ensures only dirs are picked up
-      glob.sync(path.join(root, `${name}/`), {
-        ignore: [
-          "**/node_modules/**"
-        ]
-      })
-    )).reduce((acc, val) => acc.concat(val), []).filter((filepath) => fs.existsSync(path.resolve(filepath, "package.json"))).map((filepath) => ({
-      path: filepath,
-      name: JSON.parse(fs.readFileSync(path.resolve(filepath, "package.json"), "utf8")).name
-    }));
+    return packages.map(function(name) {
+      return (
+        // The trailing / ensures only dirs are picked up
+        glob.sync(path.join(root, "".concat(name, "/")), {
+          ignore: [
+            "**/node_modules/**"
+          ]
+        })
+      );
+    }).reduce(function(acc, val) {
+      return acc.concat(val);
+    }, []).filter(function(filepath) {
+      return fs.existsSync(path.resolve(filepath, "package.json"));
+    }).map(function(filepath) {
+      return {
+        path: filepath,
+        name: JSON.parse(fs.readFileSync(path.resolve(filepath, "package.json"), "utf8")).name
+      };
+    });
   }
   return [];
 };

package/dist/esm/cli/package.js

@@ -1,43 +1,161 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { execa } from "../compiled";
-export async function getPnpmVersion() {
-  const { stdout } = await execa("pnpm", [
-    "--version"
-  ]);
-  return stdout;
-}
-export async function canUseNpm() {
-  try {
-    await execa("npm", [
-      "--version"
-    ], {
-      env: process.env
+export function getPnpmVersion() {
+  return _getPnpmVersion.apply(this, arguments);
+}
+function _getPnpmVersion() {
+  _getPnpmVersion = _async_to_generator(function() {
+    var stdout;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            execa("pnpm", [
+              "--version"
+            ])
+          ];
+        case 1:
+          stdout = _state.sent().stdout;
+          return [
+            2,
+            stdout
+          ];
+      }
+    });
+  });
+  return _getPnpmVersion.apply(this, arguments);
+}
+export function canUseNpm() {
+  return _canUseNpm.apply(this, arguments);
+}
+function _canUseNpm() {
+  _canUseNpm = _async_to_generator(function() {
+    var e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _state.trys.push([
+            0,
+            2,
+            ,
+            3
+          ]);
+          return [
+            4,
+            execa("npm", [
+              "--version"
+            ], {
+              env: process.env
+            })
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2,
+            true
+          ];
+        case 2:
+          e = _state.sent();
+          return [
+            2,
+            false
+          ];
+        case 3:
+          return [
+            2
+          ];
+      }
     });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-export async function canUseYarn() {
-  try {
-    await execa("yarn", [
-      "--version"
-    ], {
-      env: process.env
+  });
+  return _canUseNpm.apply(this, arguments);
+}
+export function canUseYarn() {
+  return _canUseYarn.apply(this, arguments);
+}
+function _canUseYarn() {
+  _canUseYarn = _async_to_generator(function() {
+    var e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _state.trys.push([
+            0,
+            2,
+            ,
+            3
+          ]);
+          return [
+            4,
+            execa("yarn", [
+              "--version"
+            ], {
+              env: process.env
+            })
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2,
+            true
+          ];
+        case 2:
+          e = _state.sent();
+          return [
+            2,
+            false
+          ];
+        case 3:
+          return [
+            2
+          ];
+      }
     });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-export async function canUsePnpm() {
-  try {
-    await execa("pnpm", [
-      "--version"
-    ], {
-      env: process.env
+  });
+  return _canUseYarn.apply(this, arguments);
+}
+export function canUsePnpm() {
+  return _canUsePnpm.apply(this, arguments);
+}
+function _canUsePnpm() {
+  _canUsePnpm = _async_to_generator(function() {
+    var e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _state.trys.push([
+            0,
+            2,
+            ,
+            3
+          ]);
+          return [
+            4,
+            execa("pnpm", [
+              "--version"
+            ], {
+              env: process.env
+            })
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2,
+            true
+          ];
+        case 2:
+          e = _state.sent();
+          return [
+            2,
+            false
+          ];
+        case 3:
+          return [
+            2
+          ];
+      }
     });
-    return true;
-  } catch (e) {
-    return false;
-  }
+  });
+  return _canUsePnpm.apply(this, arguments);
 }

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