@umijs/utils 4.2.6-alpha.6 → 4.2.6

package/dist/isMonorepo.js

@@ -0,0 +1,44 @@
+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);
+
+// src/isMonorepo.ts
+var isMonorepo_exports = {};
+__export(isMonorepo_exports, {
+  isMonorepo: () => isMonorepo
+});
+module.exports = __toCommonJS(isMonorepo_exports);
+var import_path = require("path");
+var import_fs = require("fs");
+var MONOREPO_FILE = ["pnpm-workspace.yaml", "lerna.json"];
+function isMonorepo(opts) {
+  const pkgPath = (0, import_path.join)(opts.root, "package.json");
+  let pkg = {};
+  try {
+    pkg = require(pkgPath);
+  } catch (e) {
+  }
+  const pkgExist = (0, import_fs.existsSync)(pkgPath);
+  return pkgExist && (MONOREPO_FILE.some((file) => {
+    return (0, import_fs.existsSync)((0, import_path.join)(opts.root, file));
+  }) || // npm workspaces
+  (pkg == null ? void 0 : pkg.workspaces));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isMonorepo
+});

package/dist/isStyleFile.d.ts

@@ -0,0 +1,5 @@
+export declare const AUTO_CSS_MODULE_EXTS: string[];
+export declare const isStyleFile: ({ filename, }: {
+    filename?: string | undefined;
+    ext?: string | undefined;
+}) => boolean | "" | undefined;

package/dist/isStyleFile.js

@@ -0,0 +1,44 @@
+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);
+
+// src/isStyleFile.ts
+var isStyleFile_exports = {};
+__export(isStyleFile_exports, {
+  AUTO_CSS_MODULE_EXTS: () => AUTO_CSS_MODULE_EXTS,
+  isStyleFile: () => isStyleFile
+});
+module.exports = __toCommonJS(isStyleFile_exports);
+var AUTO_CSS_MODULE_EXTS = [
+  ".css",
+  ".less",
+  ".sass",
+  ".scss",
+  ".stylus",
+  ".styl"
+];
+var STYLE_EXT_REGX = /\.(:?css|less|scss|sass|stylus|styl)$/;
+var isStyleFile = ({
+  filename
+}) => {
+  return filename && STYLE_EXT_REGX.test(filename);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTO_CSS_MODULE_EXTS,
+  isStyleFile
+});

package/dist/logger.d.ts

@@ -0,0 +1,21 @@
+export declare const prefixes: {
+    wait: string;
+    error: string;
+    fatal: string;
+    warn: string;
+    ready: string;
+    info: string;
+    event: string;
+    debug: string;
+    profile: string;
+};
+export declare function wait(...message: any[]): void;
+export declare function error(...message: any[]): void;
+export declare function warn(...message: any[]): void;
+export declare function ready(...message: any[]): void;
+export declare function info(...message: any[]): void;
+export declare function event(...message: any[]): void;
+export declare function debug(...message: any[]): void;
+export declare function fatal(...message: any[]): void;
+export declare function profile(id: string, ...message: any[]): void;
+export declare function getLatestLogFilePath(): string | null;

package/dist/logger.js

@@ -0,0 +1,180 @@
+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);
+
+// src/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  debug: () => debug,
+  error: () => error,
+  event: () => event,
+  fatal: () => fatal,
+  getLatestLogFilePath: () => getLatestLogFilePath,
+  info: () => info,
+  prefixes: () => prefixes,
+  profile: () => profile,
+  ready: () => ready,
+  wait: () => wait,
+  warn: () => warn
+});
+module.exports = __toCommonJS(logger_exports);
+var import_path = require("path");
+var import_chalk = __toESM(require("../compiled/chalk"));
+var import_fs_extra = __toESM(require("../compiled/fs-extra"));
+var import_pkg_up = require("../compiled/pkg-up");
+var import_importLazy = require("./importLazy");
+var enableFSLogger = process.env.FS_LOGGER !== "none" && !process.versions.webcontainer;
+var profilers = {};
+var loggerDir = findLoggerDir();
+var loggerPath = (0, import_path.join)(loggerDir, "umi.log");
+var prefixes = {
+  wait: import_chalk.default.cyan("wait") + "  -",
+  error: import_chalk.default.red("error") + " -",
+  fatal: import_chalk.default.red("fatal") + " -",
+  warn: import_chalk.default.yellow("warn") + "  -",
+  ready: import_chalk.default.green("ready") + " -",
+  info: import_chalk.default.cyan("info") + "  -",
+  event: import_chalk.default.magenta("event") + " -",
+  debug: import_chalk.default.gray("debug") + " -",
+  profile: import_chalk.default.blue("profile") + " -"
+};
+var pinoModule = (0, import_importLazy.importLazy)(require.resolve("pino"));
+var logger;
+if (enableFSLogger) {
+  const pino = pinoModule.default;
+  import_fs_extra.default.mkdirpSync(loggerDir);
+  const customLevels = {
+    ready: 31,
+    event: 32,
+    wait: 55,
+    // 虽然这里设置了 debug 为 30，但日志中还是 20，符合预期
+    // 这里不加会不生成到 umi.log，transport 的 level 配置没有生效，原因不明
+    debug: 30
+  };
+  logger = pino(
+    {
+      customLevels
+    },
+    pino.transport({
+      targets: [
+        {
+          target: require.resolve("pino/file"),
+          options: {
+            destination: loggerPath
+          },
+          level: "trace"
+        }
+      ]
+    })
+  );
+} else {
+  logger = {};
+  Object.keys(prefixes).forEach((key) => {
+    logger[key] = () => {
+    };
+  });
+}
+function wait(...message) {
+  console.log(prefixes.wait, ...message);
+  logger.wait(message[0]);
+}
+function error(...message) {
+  console.error(prefixes.error, ...message);
+  logger.error(message[0]);
+}
+function warn(...message) {
+  console.warn(prefixes.warn, ...message);
+  logger.warn(message[0]);
+}
+function ready(...message) {
+  console.log(prefixes.ready, ...message);
+  logger.ready(message[0]);
+}
+function info(...message) {
+  console.log(prefixes.info, ...message);
+  logger.info(message[0]);
+}
+function event(...message) {
+  console.log(prefixes.event, ...message);
+  logger.event(message[0]);
+}
+function debug(...message) {
+  if (process.env.DEBUG) {
+    console.log(prefixes.debug, ...message);
+  }
+  logger.debug(message[0]);
+}
+function fatal(...message) {
+  console.error(prefixes.fatal, ...message);
+  logger.fatal(message[0]);
+}
+function profile(id, ...message) {
+  if (process.env.IS_UMI_BUILD_WORKER && !process.env.DEBUG) {
+    return;
+  }
+  if (!profilers[id]) {
+    profilers[id] = {
+      startTime: Date.now()
+    };
+    console.log(prefixes.profile, import_chalk.default.green(id), ...message);
+    return;
+  }
+  const endTime = Date.now();
+  const { startTime } = profilers[id];
+  console.log(
+    prefixes.profile,
+    import_chalk.default.green(id),
+    `Completed in ${import_chalk.default.cyan(`${endTime - startTime}ms`)}`,
+    ...message
+  );
+  delete profilers[id];
+}
+function getLatestLogFilePath() {
+  return enableFSLogger ? loggerPath : null;
+}
+function findLoggerDir() {
+  let baseDir = process.cwd();
+  const pkg = (0, import_pkg_up.pkgUpSync)({ cwd: baseDir });
+  if (pkg) {
+    baseDir = (0, import_path.dirname)(pkg);
+  }
+  return (0, import_path.join)(baseDir, "node_modules/.cache/logger");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debug,
+  error,
+  event,
+  fatal,
+  getLatestLogFilePath,
+  info,
+  prefixes,
+  profile,
+  ready,
+  wait,
+  warn
+});

package/dist/node.d.ts

@@ -0,0 +1,4 @@
+export declare function checkVersion(minVersion: number, message?: string): void;
+export declare function checkLocal(): void;
+export declare function setNodeTitle(name: string): void;
+export declare function catchUnhandledRejection(): void;

package/dist/node.js

@@ -0,0 +1,61 @@
+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);
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  catchUnhandledRejection: () => catchUnhandledRejection,
+  checkLocal: () => checkLocal,
+  checkVersion: () => checkVersion,
+  setNodeTitle: () => setNodeTitle
+});
+module.exports = __toCommonJS(node_exports);
+var import__ = require("./");
+var ver = parseInt(process.version.slice(1));
+function checkVersion(minVersion, message) {
+  if (ver < minVersion || ver === 15 || ver === 17 || ver === 19) {
+    import__.logger.error(
+      message || `Your node version ${ver} is not supported, please upgrade to ${minVersion} or above except 15 or 17.`
+    );
+    process.exit(1);
+  }
+}
+function checkLocal() {
+  if ((0, import__.isLocalDev)()) {
+    import__.logger.info("@local");
+  }
+}
+function setNodeTitle(name) {
+  if (process.title === "node") {
+    process.title = name;
+  }
+}
+function catchUnhandledRejection() {
+  if (ver <= 14) {
+    process.on("unhandledRejection", (err) => {
+      throw err;
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  catchUnhandledRejection,
+  checkLocal,
+  checkVersion,
+  setNodeTitle
+});

package/dist/npmClient.d.ts

@@ -0,0 +1,16 @@
+export declare type NpmClient = 'npm' | 'cnpm' | 'tnpm' | 'yarn' | 'pnpm';
+export declare const npmClients: string[];
+export declare enum NpmClientEnum {
+    pnpm = "pnpm",
+    tnpm = "tnpm",
+    cnpm = "cnpm",
+    yarn = "yarn",
+    npm = "npm"
+}
+export declare const getNpmClient: (opts: {
+    cwd: string;
+}) => NpmClient;
+export declare const installWithNpmClient: ({ npmClient, cwd, }: {
+    npmClient: NpmClient;
+    cwd?: string | undefined;
+}) => void;

package/dist/npmClient.js

@@ -0,0 +1,89 @@
+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);
+
+// src/npmClient.ts
+var npmClient_exports = {};
+__export(npmClient_exports, {
+  NpmClientEnum: () => NpmClientEnum,
+  getNpmClient: () => getNpmClient,
+  installWithNpmClient: () => installWithNpmClient,
+  npmClients: () => npmClients
+});
+module.exports = __toCommonJS(npmClient_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var npmClients = ["pnpm", "tnpm", "cnpm", "yarn", "npm"];
+var NpmClientEnum = /* @__PURE__ */ ((NpmClientEnum2) => {
+  NpmClientEnum2["pnpm"] = "pnpm";
+  NpmClientEnum2["tnpm"] = "tnpm";
+  NpmClientEnum2["cnpm"] = "cnpm";
+  NpmClientEnum2["yarn"] = "yarn";
+  NpmClientEnum2["npm"] = "npm";
+  return NpmClientEnum2;
+})(NpmClientEnum || {});
+var getNpmClient = (opts) => {
+  const tnpmRegistries = [".alibaba-inc.", ".antgroup-inc."];
+  const tcnpmLockPath = (0, import_path.join)(opts.cwd, "node_modules", ".package-lock.json");
+  const chokidarPkg = require("chokidar/package.json");
+  if (chokidarPkg._resolved) {
+    return tnpmRegistries.some((r) => chokidarPkg._resolved.includes(r)) ? "tnpm" : "cnpm";
+  } else if ((0, import_fs.existsSync)(tcnpmLockPath)) {
+    const tcnpmLock = (0, import_fs.readFileSync)(tcnpmLockPath, "utf-8");
+    return tnpmRegistries.some((r) => tcnpmLock.includes(r)) ? "tnpm" : "cnpm";
+  }
+  const chokidarPath = require.resolve("chokidar");
+  if (chokidarPath.includes(".pnpm") || (0, import_fs.existsSync)((0, import_path.join)(opts.cwd, "node_modules", ".pnpm"))) {
+    return "pnpm";
+  }
+  if ((0, import_fs.existsSync)((0, import_path.join)(opts.cwd, "yarn.lock")) || (0, import_fs.existsSync)((0, import_path.join)(opts.cwd, "node_modules", ".yarn-integrity"))) {
+    return "yarn";
+  }
+  return "npm";
+};
+var installWithNpmClient = ({
+  npmClient,
+  cwd
+}) => {
+  const { sync } = require("../compiled/cross-spawn");
+  const { NODE_ENV: _, ...env } = process.env;
+  const npm = sync(npmClient, [npmClient === "yarn" ? "" : "install"], {
+    stdio: "inherit",
+    cwd,
+    env
+  });
+  if (npm.error) {
+    throw npm.error;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NpmClientEnum,
+  getNpmClient,
+  installWithNpmClient,
+  npmClients
+});

package/dist/printHelp.d.ts

@@ -0,0 +1,2 @@
+export declare function exit(): void;
+export declare function runtime(e: Error): void;

package/dist/printHelp.js

@@ -0,0 +1,64 @@
+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);
+
+// src/printHelp.ts
+var printHelp_exports = {};
+__export(printHelp_exports, {
+  exit: () => exit,
+  runtime: () => runtime
+});
+module.exports = __toCommonJS(printHelp_exports);
+var logger = __toESM(require("./logger"));
+var FEEDBACK_MESSAGE = "如果你需要进交流群，请访问 https://fb.umijs.org 。";
+function exit() {
+  const loggerPath = logger.getLatestLogFilePath();
+  if (loggerPath) {
+    logger.fatal("A complete log of this run can be found in:");
+    logger.fatal(loggerPath);
+  }
+  logger.fatal(
+    "Consider reporting a GitHub issue on https://github.com/umijs/umi/issues"
+  );
+  const binFile = process.argv[1];
+  const isUmi = binFile.endsWith("bin/umi.js");
+  const isMax = binFile.endsWith("bin/max.js");
+  if (process.env.FATAL_GUIDE_MESSAGE !== "none" && (isUmi || isMax)) {
+    logger.fatal(FEEDBACK_MESSAGE);
+  }
+  if (process.env.FATAL_GUIDE_MESSAGE && process.env.FATAL_GUIDE_MESSAGE !== "none") {
+    logger.fatal(process.env.FATAL_GUIDE_MESSAGE);
+  }
+}
+function runtime(e) {
+  logger.error(e);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exit,
+  runtime
+});

package/dist/randomColor/randomColor.d.ts

@@ -0,0 +1,6 @@
+import color from '../../compiled/color';
+export declare function randomColor(saturation?: number, value?: number): color<{
+    h: number;
+    s: number;
+    v: number;
+}>;

package/dist/randomColor/randomColor.js

@@ -0,0 +1,50 @@
+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);
+
+// src/randomColor/randomColor.ts
+var randomColor_exports = {};
+__export(randomColor_exports, {
+  randomColor: () => randomColor
+});
+module.exports = __toCommonJS(randomColor_exports);
+var import_color = __toESM(require("../../compiled/color"));
+var ratio = 0.618033988749895;
+var hue = Math.random();
+function randomColor(saturation = 0.5, value = 0.95) {
+  hue += ratio;
+  hue %= 1;
+  return (0, import_color.default)({
+    h: hue * 360,
+    s: saturation * 100,
+    v: value * 100
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomColor
+});

package/dist/readDirFiles.d.ts

@@ -0,0 +1,9 @@
+interface FileItem {
+    filePath: string;
+    name: string;
+}
+export declare const readDirFiles: (opts: {
+    dir: string;
+    exclude?: RegExp[];
+}) => FileItem[];
+export {};

package/dist/readDirFiles.js

@@ -0,0 +1,62 @@
+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);
+
+// src/readDirFiles.ts
+var readDirFiles_exports = {};
+__export(readDirFiles_exports, {
+  readDirFiles: () => readDirFiles
+});
+module.exports = __toCommonJS(readDirFiles_exports);
+var import_path = require("path");
+var import_fs_extra = require("../compiled/fs-extra");
+var readDirFiles = (opts) => {
+  const { dir, exclude = [] } = opts;
+  const list = [];
+  const recursiveReadFiles = (p) => {
+    if (!(0, import_fs_extra.existsSync)(p)) {
+      return;
+    }
+    const isFile = (0, import_fs_extra.statSync)(p).isFile();
+    if (isFile) {
+      const name = (0, import_path.basename)(p);
+      list.push({
+        filePath: p,
+        name
+      });
+      return;
+    }
+    const files = (0, import_fs_extra.readdirSync)(p).filter((name) => {
+      return name !== ".DS_Store";
+    }).map((file) => {
+      const absolutePath = (0, import_path.join)(p, file);
+      return absolutePath;
+    }).filter((file) => {
+      const isExclude = exclude.some((reg) => reg.test(file));
+      return !isExclude;
+    });
+    files.forEach((file) => {
+      recursiveReadFiles(file);
+    });
+  };
+  recursiveReadFiles(dir);
+  return list;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readDirFiles
+});

package/dist/register.d.ts

@@ -0,0 +1,7 @@
+export declare function register(opts: {
+    implementor: any;
+    exts?: string[];
+}): void;
+export declare function getFiles(): string[];
+export declare function clearFiles(): void;
+export declare function restore(): void;