@modern-js/utils 2.69.4 → 3.0.0-alpha.0

package/dist/esm-node/cli/is/config.js

@@ -1,50 +0,0 @@
-import { MAIN_ENTRY_NAME } from "../constants";
-import { isEmpty } from "./type";
-const isSSR = (config) => {
-  const { server } = config;
-  if (server === null || server === void 0 ? void 0 : server.ssr) {
-    return true;
-  }
-  if ((server === null || server === void 0 ? void 0 : server.ssrByEntries) && !isEmpty(server.ssrByEntries)) {
-    for (const name of Object.keys(server.ssrByEntries)) {
-      if (server.ssrByEntries[name]) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-const isUseSSRBundle = (config) => {
-  const { output } = config;
-  if (output === null || output === void 0 ? void 0 : output.ssg) {
-    return true;
-  }
-  return isSSR(config);
-};
-const isUseRsc = (config) => {
-  var _config_server;
-  return config === null || config === void 0 ? void 0 : (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.rsc;
-};
-const isServiceWorker = (config) => {
-  var _deploy_worker;
-  const { output, deploy } = config;
-  if ((deploy === null || deploy === void 0 ? void 0 : (_deploy_worker = deploy.worker) === null || _deploy_worker === void 0 ? void 0 : _deploy_worker.ssr) && ((output === null || output === void 0 ? void 0 : output.ssg) || isSSR(config))) {
-    return true;
-  }
-  return false;
-};
-const isSSGEntry = (config, entryName, entrypoints) => {
-  var _config_source;
-  const ssgConfig = config.output.ssg;
-  const useSSG = isSingleEntry(entrypoints, (_config_source = config.source) === null || _config_source === void 0 ? void 0 : _config_source.mainEntryName) ? Boolean(ssgConfig) : ssgConfig === true || typeof (ssgConfig === null || ssgConfig === void 0 ? void 0 : ssgConfig[0]) === "function" || Boolean(ssgConfig === null || ssgConfig === void 0 ? void 0 : ssgConfig[entryName]);
-  return useSSG;
-};
-const isSingleEntry = (entrypoints, mainEntryName = MAIN_ENTRY_NAME) => entrypoints.length === 1 && entrypoints[0].entryName === mainEntryName;
-export {
-  isSSGEntry,
-  isSSR,
-  isServiceWorker,
-  isSingleEntry,
-  isUseRsc,
-  isUseSSRBundle
-};

package/dist/esm-node/cli/is/env.js

@@ -1,12 +0,0 @@
-const getNodeEnv = () => process.env.NODE_ENV || "development";
-const isDev = () => getNodeEnv() === "development";
-const isProd = () => getNodeEnv() === "production";
-const isTest = () => getNodeEnv() === "test";
-const isBrowser = () => typeof window !== "undefined";
-export {
-  getNodeEnv,
-  isBrowser,
-  isDev,
-  isProd,
-  isTest
-};

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

@@ -1,105 +0,0 @@
-import path from "path";
-import pkgUp from "../../../compiled/pkg-up";
-import { fs, minimist, semver } from "../../compiled";
-import { getArgv } from "../commands";
-import { createDebugger } from "../common";
-import { ensureArray } from "../ensure";
-const debug = createDebugger("judge-depExists");
-const isDepExists = (appDirectory, name) => {
-  const pkgPath = path.resolve(appDirectory, "./package.json");
-  if (!fs.existsSync(pkgPath)) {
-    debug(`can't find package.json under: %s`, appDirectory);
-    return false;
-  }
-  const json = require(pkgPath);
-  const { dependencies = {}, devDependencies = {} } = json;
-  return dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name);
-};
-const isPackageInstalled = (name, resolvePaths) => {
-  try {
-    require.resolve(name, {
-      paths: ensureArray(resolvePaths)
-    });
-    return true;
-  } catch (err) {
-    return false;
-  }
-};
-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;
-};
-const isWebOnly = async () => {
-  const options = minimist(getArgv());
-  return Boolean(options["web-only"]);
-};
-const isVersionBeyond17 = (version) => {
-  return semver.gte(semver.minVersion(version), "17.0.0");
-};
-const getReactVersion = (cwd) => {
-  const pkgPath = pkgUp.sync({
-    cwd
-  });
-  if (!pkgPath) {
-    return false;
-  }
-  const pkgInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-  const deps = {
-    ...pkgInfo.devDependencies,
-    ...pkgInfo.dependencies
-  };
-  if (typeof deps.react !== "string") {
-    return false;
-  }
-  try {
-    const reactPath = require.resolve("react/package.json", {
-      paths: [
-        cwd
-      ]
-    });
-    const reactVersion = JSON.parse(fs.readFileSync(reactPath, "utf8")).version;
-    return reactVersion;
-  } catch (error) {
-    console.error("Failed to resolve React version:", error);
-    return false;
-  }
-};
-const isBeyondReact17 = (cwd) => {
-  const reactVersion = getReactVersion(cwd);
-  if (!reactVersion) {
-    return false;
-  }
-  return isVersionBeyond17(reactVersion);
-};
-const isSupportAutomaticJsx = (cwd) => {
-  const reactVersion = getReactVersion(cwd);
-  if (!reactVersion) {
-    return false;
-  }
-  return semver.satisfies(semver.minVersion(reactVersion), ">=16.14.0");
-};
-const isReact18 = (cwd = process.cwd()) => {
-  const reactVersion = getReactVersion(cwd);
-  if (!reactVersion) {
-    return false;
-  }
-  return semver.gte(semver.minVersion(reactVersion), "18.0.0");
-};
-const isTypescript = (root) => fs.existsSync(path.resolve(root, "./tsconfig.json"));
-export {
-  getReactVersion,
-  isApiOnly,
-  isBeyondReact17,
-  isDepExists,
-  isPackageInstalled,
-  isReact18,
-  isSupportAutomaticJsx,
-  isTypescript,
-  isVersionBeyond17,
-  isWebOnly
-};

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

@@ -1,36 +0,0 @@
-function isString(str) {
-  return typeof str === "string";
-}
-function isUndefined(obj) {
-  return typeof obj === "undefined";
-}
-function isArray(obj) {
-  return Array.isArray(obj);
-}
-function isFunction(func) {
-  return typeof func === "function";
-}
-function isObject(obj) {
-  return obj !== null && typeof obj === "object";
-}
-function isPlainObject(obj) {
-  return isObject(obj) && Object.prototype.toString.call(obj) === "[object Object]";
-}
-function isPromise(obj) {
-  return Boolean(obj) && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
-}
-function isRegExp(obj) {
-  return Object.prototype.toString.call(obj) === "[object RegExp]";
-}
-const isEmpty = (o) => Object.entries(o).length === 0 && o.constructor === Object;
-export {
-  isArray,
-  isEmpty,
-  isFunction,
-  isObject,
-  isPlainObject,
-  isPromise,
-  isRegExp,
-  isString,
-  isUndefined
-};

package/dist/esm-node/cli/logger.js

@@ -1,5 +0,0 @@
-import { logger, createLogger } from "rslog";
-export {
-  createLogger,
-  logger
-};

package/dist/esm-node/cli/monorepo.js

@@ -1,67 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { glob, yaml } from "../compiled";
-const PACKAGE_MAX_DEPTH = 5;
-const WORKSPACE_FILES = {
-  YARN: "package.json",
-  PNPM: "pnpm-workspace.yaml",
-  LERNA: "lerna.json"
-};
-const isLerna = (root) => fs.existsSync(path.join(root, WORKSPACE_FILES.LERNA));
-const isYarnWorkspaces = (root) => {
-  var _json_workspaces;
-  const pkg = path.join(root, WORKSPACE_FILES.YARN);
-  if (!fs.existsSync(pkg)) {
-    return false;
-  }
-  const json = JSON.parse(fs.readFileSync(pkg, "utf8"));
-  return Boolean((_json_workspaces = json.workspaces) === null || _json_workspaces === void 0 ? void 0 : _json_workspaces.packages);
-};
-const isPnpmWorkspaces = (root) => fs.existsSync(path.join(root, WORKSPACE_FILES.PNPM));
-const isMonorepo = (root) => isLerna(root) || isYarnWorkspaces(root) || isPnpmWorkspaces(root);
-const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH) => {
-  let inMonorepo = false;
-  let monorepoRoot = appDirectory;
-  for (let depth = 0; depth < maxDepth; depth++) {
-    if (isMonorepo(appDirectory)) {
-      inMonorepo = true;
-      break;
-    }
-    monorepoRoot = path.dirname(appDirectory);
-  }
-  return inMonorepo ? monorepoRoot : void 0;
-};
-const getMonorepoPackages = (root) => {
-  let packages = [];
-  if (isYarnWorkspaces(root)) {
-    const json = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
-    ({ packages } = json.workspaces);
-  } else if (isLerna(root)) {
-    const json = JSON.parse(fs.readFileSync(path.resolve(root, "lerna.json"), "utf8"));
-    ({ packages } = json);
-  } else {
-    ({ packages } = yaml.load(fs.readFileSync(path.join(root, WORKSPACE_FILES.PNPM), "utf8")));
-  }
-  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 [];
-};
-export {
-  findMonorepoRoot,
-  getMonorepoPackages,
-  isLerna,
-  isMonorepo,
-  isPnpmWorkspaces,
-  isYarnWorkspaces
-};

package/dist/esm-node/cli/package.js

@@ -1,66 +0,0 @@
-import { execa } from "../compiled";
-async function getPnpmVersion() {
-  const { stdout } = await execa("pnpm", [
-    "--version"
-  ]);
-  return stdout;
-}
-async function canUseNpm() {
-  try {
-    await execa("npm", [
-      "--version"
-    ], {
-      env: process.env
-    });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-async function canUseYarn() {
-  try {
-    await execa("yarn", [
-      "--version"
-    ], {
-      env: process.env
-    });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-async function canUsePnpm() {
-  try {
-    await execa("pnpm", [
-      "--version"
-    ], {
-      env: process.env
-    });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-function removeModuleSyncFromExports(exports) {
-  if (typeof exports !== "object" || exports === null) {
-    return exports;
-  }
-  if (Array.isArray(exports)) {
-    return exports.map(removeModuleSyncFromExports);
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(exports)) {
-    if (key === "module-sync") {
-      continue;
-    }
-    result[key] = removeModuleSyncFromExports(value);
-  }
-  return result;
-}
-export {
-  canUseNpm,
-  canUsePnpm,
-  canUseYarn,
-  getPnpmVersion,
-  removeModuleSyncFromExports
-};

package/dist/esm-node/cli/path.js

@@ -1,48 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { nanoid, upath } from "../compiled";
-const isPathString = (test) => path.posix.basename(test) !== test || path.win32.basename(test) !== test;
-const isRelativePath = (test) => /^\.\.?($|[\\/])/.test(test);
-const normalizeOutputPath = (s) => s.replace(/\\/g, "\\\\");
-const normalizeToPosixPath = (p) => upath.normalizeSafe(path.normalize(p || "")).replace(/^([a-zA-Z]+):/, (_, m) => `/${m.toLowerCase()}`);
-const getTemplatePath = (prefix) => {
-  const tmpRoot = fs.realpathSync(os.tmpdir());
-  const parts = [
-    tmpRoot
-  ];
-  prefix && parts.push(prefix);
-  parts.push(nanoid());
-  return path.resolve(...parts);
-};
-function getRealTemporaryDirectory() {
-  let ret = null;
-  try {
-    ret = os.tmpdir();
-    ret = fs.realpathSync(ret);
-  } catch {
-  }
-  return ret;
-}
-function splitPathString(str) {
-  return str.split(/[\\/]/);
-}
-const removeLeadingSlash = (s) => s.replace(/^\/+/, "");
-const removeTailSlash = (s) => s.replace(/\/+$/, "");
-const removeSlash = (s) => removeLeadingSlash(removeTailSlash(s));
-function formatImportPath(str) {
-  return str.replace(/\\/g, "/");
-}
-export {
-  formatImportPath,
-  getRealTemporaryDirectory,
-  getTemplatePath,
-  isPathString,
-  isRelativePath,
-  normalizeOutputPath,
-  normalizeToPosixPath,
-  removeLeadingSlash,
-  removeSlash,
-  removeTailSlash,
-  splitPathString
-};

package/dist/esm-node/cli/port.js

@@ -1,48 +0,0 @@
-import net from "net";
-import { chalk } from "../compiled";
-import { logger } from "./logger";
-const getPort = async (expectPort, { tryLimits = 20, strictPort = false, slient = false } = {}) => {
-  let port = expectPort;
-  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;
-      }
-      port++;
-      attempts++;
-    }
-  }
-  if (port !== original) {
-    if (strictPort) {
-      throw new Error(`Port "${original}" is occupied, please choose another one.`);
-    } else if (!slient) {
-      logger.info(`Port ${original} is in use. ${chalk.yellow(`using port ${port}.`)}`);
-    }
-  }
-  return port;
-};
-export {
-  getPort
-};

package/dist/esm-node/cli/prettyInstructions.js

@@ -1,90 +0,0 @@
-import { isIPv6 } from "net";
-import os from "os";
-import { chalk } from "../compiled";
-import { DEFAULT_DEV_HOST } from "./constants";
-import { isDev, isSingleEntry } from "./is";
-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;
-      if (detail.family === familyV4Value) {
-        ipv4Interfaces.push(detail);
-      }
-    });
-  });
-  return ipv4Interfaces;
-};
-const getHostInUrl = (host) => {
-  if (isIPv6(host)) {
-    return host === "::" ? "[::1]" : `[${host}]`;
-  }
-  return host;
-};
-const getAddressUrls = (protocol = "http", port, host) => {
-  const LOCAL_LABEL = "Local:  ";
-  const NETWORK_LABEL = "Network:  ";
-  const isLocalhost = (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}://${getHostInUrl(host)}:${port}`
-      }
-    ];
-  }
-  const ipv4Interfaces = getIpv4Interfaces();
-  return ipv4Interfaces.reduce((memo, detail) => {
-    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}`
-      });
-    }
-    return memo;
-  }, []);
-};
-const prettyInstructions = (appContext, config) => {
-  var _config_dev, _config_tools_devServer, _config_tools, _config_dev1, _config_source, _config_dev2;
-  const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
-  const isHttps = isDev() && ((config === null || config === void 0 ? void 0 : (_config_dev = config.dev) === null || _config_dev === void 0 ? void 0 : _config_dev.https) || (config === null || config === void 0 ? void 0 : (_config_tools = config.tools) === null || _config_tools === void 0 ? void 0 : (_config_tools_devServer = _config_tools.devServer) === null || _config_tools_devServer === void 0 ? void 0 : _config_tools_devServer.https));
-  const urls = getAddressUrls(isHttps ? "https" : "http", port, (_config_dev1 = config.dev) === null || _config_dev1 === void 0 ? void 0 : _config_dev1.host);
-  const routes = !apiOnly ? serverRoutes.filter((route) => route.entryName) : serverRoutes;
-  let message = "\n";
-  if (isSingleEntry(entrypoints, (_config_source = config.source) === null || _config_source === void 0 ? void 0 : _config_source.mainEntryName) || apiOnly) {
-    message += urls.map(({ label, url }) => `  ${chalk.bold(`> ${label.padEnd(10)}`)}${chalk.cyanBright(normalizeUrl(`${url}/${routes[0].urlPath}`))}
-`).join("");
-  } else {
-    const maxNameLength = Math.max(...routes.map((r) => r.entryName.length));
-    urls.forEach(({ label, url }) => {
-      message += `  ${chalk.bold(`> ${label}`)}${routes.length === 0 ? chalk.cyanBright(url) : ""}
-`;
-      routes.forEach(({ entryName, urlPath, isSSR }) => {
-        if (!checkedEntries.includes(entryName)) {
-          return;
-        }
-        message += `    ${chalk.yellowBright(isSSR ? "λ" : "○")}  ${chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}
-`;
-      });
-    });
-    message += "\n";
-    message += chalk.cyanBright("  λ (Server) server-side renders at runtime\n");
-    message += chalk.cyanBright("  ○ (Static) client-side renders as static HTML\n");
-  }
-  if ((_config_dev2 = config.dev) === null || _config_dev2 === void 0 ? void 0 : _config_dev2.cliShortcuts) {
-    message += `  ${chalk.dim("> press")} ${chalk.bold("h + enter")} ${chalk.dim("to show shortcuts")}
-`;
-  }
-  return message;
-};
-export {
-  getAddressUrls,
-  prettyInstructions
-};

package/dist/esm-node/cli/require.js

@@ -1,111 +0,0 @@
-const import_meta = {};
-import { isAbsolute } from "node:path";
-import { pathToFileURL } from "node:url";
-import { findExists } from "./fs";
-async function compatibleRequire(path, interop = true) {
-  if (path.endsWith(".json")) {
-    return require(path);
-  }
-  let requiredModule;
-  try {
-    requiredModule = require(path);
-  } catch (err) {
-    if (err.code === "ERR_REQUIRE_ESM") {
-      const modulePath = isAbsolute(path) ? pathToFileURL(path).href : path;
-      if (process.env.NODE_ENV === "development") {
-        const timestamp = Date.now();
-        requiredModule = await import(`${modulePath}?t=${timestamp}`);
-      } else {
-        requiredModule = await import(modulePath);
-      }
-      return interop ? requiredModule.default : requiredModule;
-    } else {
-      throw err;
-    }
-  }
-  return interop && (requiredModule === null || requiredModule === void 0 ? void 0 : requiredModule.__esModule) ? requiredModule.default : requiredModule;
-}
-async function loadFromProject(moduleName, appDir) {
-  let requiredModule;
-  const paths = [
-    appDir,
-    process.cwd()
-  ];
-  try {
-    if (typeof require !== "undefined") {
-      const modulePath = require.resolve(moduleName, {
-        paths
-      });
-      requiredModule = require(modulePath);
-    } else {
-      const { createRequire } = await import("node:module");
-      const require1 = createRequire(import_meta.url);
-      const modulePath = require1.resolve(moduleName, {
-        paths
-      });
-      const moduleUrl = pathToFileURL(modulePath).href;
-      requiredModule = await import(moduleUrl);
-    }
-    return requiredModule.default || requiredModule;
-  } catch (error) {
-    if (error.code === "MODULE_NOT_FOUND") {
-      throw new Error(`Cannot find module ${moduleName}.`);
-    }
-    throw error;
-  }
-}
-const dynamicImport = new Function("modulePath", "return import(modulePath)");
-const requireExistModule = async (filename, opt) => {
-  const final = {
-    extensions: [
-      ".ts",
-      ".js"
-    ],
-    interop: true,
-    ...opt
-  };
-  const exist = findExists(final.extensions.map((ext) => `${filename}${ext}`));
-  if (!exist) {
-    return null;
-  }
-  return compatibleRequire(exist, final.interop);
-};
-const cleanRequireCache = (filelist) => {
-  filelist.forEach((filepath) => {
-    delete require.cache[filepath];
-  });
-};
-function deleteRequireCache(path) {
-  if (require.cache[path]) {
-    delete require.cache[path];
-  }
-  if (module.children) {
-    module.children = module.children.filter((item) => item.filename !== path);
-  }
-}
-const tryResolve = (name, resolvePath) => {
-  let filePath = "";
-  try {
-    filePath = require.resolve(name, {
-      paths: [
-        resolvePath
-      ]
-    });
-    delete require.cache[filePath];
-  } catch (err) {
-    if (err.code === "MODULE_NOT_FOUND") {
-      throw new Error(`Can not find module ${name}.`);
-    }
-    throw err;
-  }
-  return filePath;
-};
-export {
-  cleanRequireCache,
-  compatibleRequire,
-  deleteRequireCache,
-  dynamicImport,
-  loadFromProject,
-  requireExistModule,
-  tryResolve
-};