@modern-js/utils 2.26.0 → 2.28.0

package/dist/esm/cli/is/project.js

@@ -1,21 +1,24 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import pkgUp from "../../../compiled/pkg-up";
 import { getArgv } from "../commands";
 import { fs, minimist, semver } from "../../compiled";
 import { createDebugger } from "../common";
 import { ensureArray } from "../ensure";
-const debug = createDebugger("judge-depExists");
-export const isDepExists = (appDirectory, name) => {
-  const pkgPath = path.resolve(appDirectory, "./package.json");
+var debug = createDebugger("judge-depExists");
+export var isDepExists = function(appDirectory, name) {
+  var pkgPath = path.resolve(appDirectory, "./package.json");
   if (!fs.existsSync(pkgPath)) {
-    debug(`can't find package.json under: %s`, appDirectory);
+    debug("can't find package.json under: %s", appDirectory);
     return false;
   }
-  const json = require(pkgPath);
-  const { dependencies = {}, devDependencies = {} } = json;
+  var json = require(pkgPath);
+  var _json_dependencies = json.dependencies, dependencies = _json_dependencies === void 0 ? {} : _json_dependencies, _json_devDependencies = json.devDependencies, devDependencies = _json_devDependencies === void 0 ? {} : _json_devDependencies;
   return dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name);
 };
-export const isPackageInstalled = (name, resolvePaths) => {
+export var isPackageInstalled = function(name, resolvePaths) {
   try {
     require.resolve(name, {
       paths: ensureArray(resolvePaths)
@@ -25,49 +28,83 @@ export const isPackageInstalled = (name, resolvePaths) => {
     return false;
   }
 };
-export const isApiOnly = async (appDirectory, entryDir, apiDir) => {
-  const existApi = await fs.pathExists(apiDir !== null && apiDir !== void 0 ? apiDir : path.join(appDirectory, "api"));
-  const existSrc = await fs.pathExists(path.join(appDirectory, entryDir !== null && entryDir !== void 0 ? entryDir : "src"));
-  const options = minimist(getArgv());
-  if (options["api-only"]) {
-    return true;
-  }
-  return existApi && !existSrc;
-};
-export const isWebOnly = async () => {
-  const options = minimist(getArgv());
-  return Boolean(options["web-only"]);
-};
-export const isBeyondReact17 = (cwd) => {
-  const pkgPath = pkgUp.sync({
-    cwd
+export var isApiOnly = function() {
+  var _ref = _async_to_generator(function(appDirectory, entryDir, apiDir) {
+    var existApi, existSrc, options;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            fs.pathExists(apiDir !== null && apiDir !== void 0 ? apiDir : path.join(appDirectory, "api"))
+          ];
+        case 1:
+          existApi = _state.sent();
+          return [
+            4,
+            fs.pathExists(path.join(appDirectory, entryDir !== null && entryDir !== void 0 ? entryDir : "src"))
+          ];
+        case 2:
+          existSrc = _state.sent();
+          options = minimist(getArgv());
+          if (options["api-only"]) {
+            return [
+              2,
+              true
+            ];
+          }
+          return [
+            2,
+            existApi && !existSrc
+          ];
+      }
+    });
+  });
+  return function isApiOnly2(appDirectory, entryDir, apiDir) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var isWebOnly = function() {
+  var _ref = _async_to_generator(function() {
+    var options;
+    return _ts_generator(this, function(_state) {
+      options = minimist(getArgv());
+      return [
+        2,
+        Boolean(options["web-only"])
+      ];
+    });
+  });
+  return function isWebOnly2() {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var isBeyondReact17 = function(cwd) {
+  var pkgPath = pkgUp.sync({
+    cwd: cwd
   });
   if (!pkgPath) {
     return false;
   }
-  const pkgInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-  const deps = {
-    ...pkgInfo.devDependencies,
-    ...pkgInfo.dependencies
-  };
+  var pkgInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  var deps = _object_spread({}, pkgInfo.devDependencies, pkgInfo.dependencies);
   if (typeof deps.react !== "string") {
     return false;
   }
   return semver.satisfies(semver.minVersion(deps.react), ">=17.0.0");
 };
-export const isReact18 = (cwd) => {
-  const pkgPath = path.join(cwd, "package.json");
+export var isReact18 = function(cwd) {
+  var pkgPath = path.join(cwd, "package.json");
   if (!fs.existsSync(pkgPath)) {
     return false;
   }
-  const pkgInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-  const deps = {
-    ...pkgInfo.devDependencies,
-    ...pkgInfo.dependencies
-  };
+  var pkgInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  var deps = _object_spread({}, pkgInfo.devDependencies, pkgInfo.dependencies);
   if (typeof deps.react !== "string") {
     return false;
   }
   return semver.satisfies(semver.minVersion(deps.react), ">=18.0.0");
 };
-export const isTypescript = (root) => fs.existsSync(path.resolve(root, "./tsconfig.json"));
+export var isTypescript = function(root) {
+  return fs.existsSync(path.resolve(root, "./tsconfig.json"));
+};

package/dist/esm/cli/is/type.js

@@ -22,4 +22,6 @@ export function isPromise(obj) {
 export function isRegExp(obj) {
   return Object.prototype.toString.call(obj) === "[object RegExp]";
 }
-export const isEmpty = (o) => Object.entries(o).length === 0 && o.constructor === Object;
+export var isEmpty = function(o) {
+  return Object.entries(o).length === 0 && o.constructor === Object;
+};

package/dist/esm/cli/logger.js

@@ -1,12 +1,17 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _to_array } from "@swc/helpers/_/_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import chalk from "../../compiled/chalk";
-const LOG_LEVEL = {
+var LOG_LEVEL = {
   error: 0,
   warn: 1,
   info: 2,
   debug: 3,
   log: 4
 };
-const LOG_TYPES = {
+var LOG_TYPES = {
   error: {
     color: "red",
     label: "error",
@@ -36,12 +41,30 @@ const LOG_TYPES = {
     level: "log"
   }
 };
-const DEFAULT_CONFIG = {
+var DEFAULT_CONFIG = {
   displayLabel: true,
   uppercaseLabel: false
 };
-class Logger {
-  _log(type, message, ...args) {
+var Logger = /* @__PURE__ */ function() {
+  "use strict";
+  function Logger2() {
+    var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var _this = this;
+    _class_call_check(this, Logger2);
+    this.level = options.level || LOG_TYPES.log.level;
+    this.config = _object_spread({}, DEFAULT_CONFIG, options.config || {});
+    this.types = _object_spread({}, LOG_TYPES, options.types || {});
+    this.longestLabel = this.getLongestLabel();
+    Object.keys(this.types).forEach(function(type) {
+      _this[type] = _this._log.bind(_this, type);
+    });
+  }
+  var _proto = Logger2.prototype;
+  _proto._log = function _log(type, message) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    var _console;
     if (message === void 0 || message === null) {
       console.log();
       return;
@@ -49,55 +72,43 @@ class Logger {
     if (LOG_LEVEL[type] > LOG_LEVEL[this.level]) {
       return;
     }
-    let label = "";
-    let text = "";
-    const logType = this.types[type];
+    var label = "";
+    var text = "";
+    var logType = this.types[type];
     if (this.config.displayLabel && logType.label) {
       label = this.config.uppercaseLabel ? logType.label.toUpperCase() : logType.label;
       label = label.padEnd(this.longestLabel.length);
       label = chalk.bold(logType.color ? chalk[logType.color](label) : label);
     }
-    if (message instanceof Error) {
+    if (_instanceof(message, Error)) {
       if (message.stack) {
-        const [name, ...rest] = message.stack.split("\n");
-        text = `${name}
-${chalk.grey(rest.join("\n"))}`;
+        var _message_stack_split = _to_array(message.stack.split("\n")), name = _message_stack_split[0], rest = _message_stack_split.slice(1);
+        text = "".concat(name, "\n").concat(chalk.grey(rest.join("\n")));
       } else {
         text = message.message;
       }
     } else {
-      text = `${message}`;
+      text = "".concat(message);
     }
-    const log = label.length > 0 ? `${label} ${text}` : text;
-    console.log(log, ...args);
-  }
-  getLongestLabel() {
-    let longestLabel = "";
-    Object.keys(this.types).forEach((type) => {
-      const { label = "" } = this.types[type];
+    var log = label.length > 0 ? "".concat(label, " ").concat(text) : text;
+    (_console = console).log.apply(_console, [
+      log
+    ].concat(_to_consumable_array(args)));
+  };
+  _proto.getLongestLabel = function getLongestLabel() {
+    var _this = this;
+    var longestLabel = "";
+    Object.keys(this.types).forEach(function(type) {
+      var _this_types_type = _this.types[type], _this_types_type_label = _this_types_type.label, label = _this_types_type_label === void 0 ? "" : _this_types_type_label;
       if (label.length > longestLabel.length) {
         longestLabel = label;
       }
     });
     return longestLabel;
-  }
-  constructor(options = {}) {
-    this.level = options.level || LOG_TYPES.log.level;
-    this.config = {
-      ...DEFAULT_CONFIG,
-      ...options.config || {}
-    };
-    this.types = {
-      ...LOG_TYPES,
-      ...options.types || {}
-    };
-    this.longestLabel = this.getLongestLabel();
-    Object.keys(this.types).forEach((type) => {
-      this[type] = this._log.bind(this, type);
-    });
-  }
-}
-const logger = new Logger();
+  };
+  return Logger2;
+}();
+var logger = new Logger();
 logger.Logger = Logger;
 export { Logger };
 export { logger };

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