@l-comedy/core 0.1.0

package/dist/run.js

@@ -0,0 +1,634 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/run.ts
+var import_commander = require("commander");
+
+// src/commands/dev.ts
+var import_path8 = __toESM(require("path"));
+var import_core2 = require("@rspack/core");
+var import_dev_server = require("@rspack/dev-server");
+var import_chokidar = __toESM(require("chokidar"));
+
+// src/setup.ts
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_path7 = __toESM(require("path"));
+
+// src/utils/setup/generateEntryFile.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+function generateEntryFile(modifiers, targetDir, setupConfig) {
+  return __async(this, null, function* () {
+    var _a;
+    const allImports = /* @__PURE__ */ new Set();
+    const allReactImports = /* @__PURE__ */ new Set();
+    modifiers.forEach((m) => {
+      var _a2, _b;
+      (_a2 = m.imports) == null ? void 0 : _a2.forEach((i) => allImports.add(i));
+      (_b = m.reactImports) == null ? void 0 : _b.forEach((i) => allReactImports.add(i));
+    });
+    let appCode = "<div />";
+    let entryCode = `import React${allReactImports.size >= 0 ? `, { ${Array.from(allReactImports).join(", ")} }` : ""} from 'react';
+import { createRoot } from 'react-dom/client';
+`;
+    entryCode += Array.from(allImports).join("\n") + "\n";
+    modifiers.forEach((m) => {
+      if (m.beforeRender) {
+        entryCode += m.beforeRender + "\n";
+      }
+      if (m.app) {
+        appCode = m.app(appCode);
+      }
+    });
+    modifiers.forEach((m) => {
+      if (m.appWrap) {
+        appCode = m.appWrap(appCode);
+      }
+    });
+    appCode = `<React.StrictMode>
+  ${appCode}
+</React.StrictMode>`;
+    let renderCode = `function render() {
+  const rootContainer = document.getElementById('${((_a = setupConfig.userConfig.html) == null ? void 0 : _a.rootId) || "root"}');
+
+  if (rootContainer) {
+    const root = createRoot(rootContainer);
+    root.render(${appCode});
+  }
+}`;
+    let renderRunCode = `render();`;
+    modifiers.forEach((m) => {
+      if (m.render) {
+        renderCode = m.render(renderCode);
+      }
+      if (m.renderRun) {
+        renderRunCode = m.renderRun(renderCode);
+      }
+    });
+    entryCode += renderCode + "\n";
+    entryCode += renderRunCode + "\n";
+    modifiers.forEach((m) => {
+      if (m.afterRender) {
+        entryCode += m.afterRender + "\n";
+      }
+    });
+    yield import_fs_extra.default.outputFile(import_path.default.posix.join(targetDir, "entry.tsx"), entryCode);
+  });
+}
+
+// src/plugins/app-config/createLComedyPluginAppConfig.ts
+var import_path2 = __toESM(require("path"));
+var import_core = require("@rspack/core");
+function createLComedyPluginAppConfig() {
+  return {
+    name: "l-comedy-plugin-app-config",
+    rspackConfig(rspackConfig, setupConfig) {
+      var _a;
+      const publicDir = setupConfig.userConfig.publicDir || "public";
+      const newConfig = __spreadProps(__spreadValues({}, rspackConfig), {
+        entry: import_path2.default.posix.join(setupConfig.workPath, "entry.tsx"),
+        output: {
+          publicPath: "/",
+          path: import_path2.default.posix.join(
+            setupConfig.root,
+            setupConfig.userConfig.output || "dist"
+          ),
+          filename: setupConfig.isProd ? "static/js/[name].[contenthash:8].js" : "static/js/[name].js",
+          clean: true
+        },
+        module: __spreadProps(__spreadValues({}, rspackConfig.module), {
+          rules: [
+            ...((_a = rspackConfig.module) == null ? void 0 : _a.rules) || [],
+            {
+              test: /\.(ts|tsx)$/,
+              exclude: /node_modules/,
+              use: [
+                {
+                  loader: require.resolve("ts-loader"),
+                  options: {
+                    transpileOnly: true,
+                    compilerOptions: {
+                      paths: {
+                        "@/*": ["src/*"]
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              test: /\.(css|less)$/,
+              use: [
+                setupConfig.isProd ? import_core.CssExtractRspackPlugin.loader : require.resolve("style-loader"),
+                {
+                  loader: require.resolve("css-loader"),
+                  options: {
+                    modules: {
+                      mode: "local",
+                      auto: true,
+                      localIdentName: setupConfig.isProd ? "[local]--[hash:base64:8]" : "[path][name]__[local]--[hash:base64:5]",
+                      exportLocalsConvention: "camelCaseOnly",
+                      namedExport: false,
+                      exportOnlyLocals: false
+                    },
+                    esModule: true
+                  }
+                },
+                {
+                  loader: require.resolve("postcss-loader")
+                },
+                {
+                  loader: require.resolve("less-loader"),
+                  options: {
+                    lessOptions: {
+                      javascriptEnabled: true
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }),
+        plugins: [
+          ...rspackConfig.plugins || [],
+          ...setupConfig.isProd ? [
+            new import_core.CssExtractRspackPlugin({
+              filename: "static/css/[name].[contenthash:8].css",
+              chunkFilename: "static/css/[name].[contenthash:8].chunk.css"
+            }),
+            new import_core.CopyRspackPlugin({
+              patterns: [
+                {
+                  from: publicDir,
+                  to: "."
+                }
+              ]
+            })
+          ] : []
+        ]
+      });
+      if (!setupConfig.isProd) {
+        newConfig.devServer = __spreadProps(__spreadValues({}, rspackConfig.devServer), {
+          port: setupConfig.userConfig.port,
+          hot: true,
+          historyApiFallback: true,
+          static: {
+            publicPath: "/",
+            directory: publicDir
+          }
+        });
+      }
+      return newConfig;
+    }
+  };
+}
+
+// src/plugins/html/createLComedyPluginHtml.ts
+var import_path4 = __toESM(require("path"));
+var import_html_webpack_plugin = __toESM(require("html-webpack-plugin"));
+
+// src/plugins/html/createHtmlFile.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
+function createHtmlFile(setupConfig) {
+  var _a, _b, _c;
+  const htmlConfig = setupConfig.userConfig.html || {};
+  import_fs_extra2.default.outputFileSync(
+    import_path3.default.posix.join(setupConfig.workDir, "index.html"),
+    `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title><%= TITLE %></title>
+  ${((_a = htmlConfig.headTags) == null ? void 0 : _a.join("\n")) || ""}
+</head>
+<body>
+  ${((_b = htmlConfig.bodyBeforeTags) == null ? void 0 : _b.join("\n")) || ""}
+  <div id="<%= ROOT_ID %>"></div>
+  ${((_c = htmlConfig.bodyAfterTags) == null ? void 0 : _c.join("\n")) || ""}
+</body>
+</html>`
+  );
+}
+
+// src/plugins/html/createTemplateParameters.ts
+function createTemplateParameters(setupConfig) {
+  var _a, _b;
+  return {
+    BUILD_TIME: (/* @__PURE__ */ new Date()).toISOString(),
+    // BUILD_TIMESTAMP: Date.now(),
+    // IS_PROD: setupConfig.isProd,
+    TITLE: ((_a = setupConfig.userConfig.html) == null ? void 0 : _a.title) || "App",
+    ROOT_ID: ((_b = setupConfig.userConfig.html) == null ? void 0 : _b.rootId) || "root"
+  };
+}
+
+// src/plugins/html/createLComedyPluginHtml.ts
+function createLComedyPluginHtml() {
+  return {
+    name: "l-comedy-plugin-html",
+    rspackConfig(rspackConfig, setupConfig) {
+      var _a2, _b;
+      return __spreadProps(__spreadValues({}, rspackConfig), {
+        plugins: [
+          ...rspackConfig.plugins || [],
+          new import_html_webpack_plugin.default(__spreadProps(__spreadValues({
+            template: import_path4.default.posix.join(setupConfig.workDir, "index.html"),
+            filename: "index.html",
+            minify: setupConfig.isProd ? {
+              collapseWhitespace: true,
+              removeComments: true,
+              removeRedundantAttributes: true
+            } : false,
+            cache: true,
+            inject: true
+          }, (_a2 = setupConfig.userConfig.html) == null ? void 0 : _a2.htmlWebpackOptions), {
+            templateParameters: __spreadValues(__spreadValues({}, (_b = setupConfig.userConfig.html) == null ? void 0 : _b.htmlTemplateParametersData), createTemplateParameters(setupConfig))
+          }))
+        ]
+      });
+    },
+    generateFiles(setupConfig) {
+      return __async(this, null, function* () {
+        createHtmlFile(setupConfig);
+      });
+    }
+  };
+}
+
+// src/plugins/page-loading/createLComedyPluginPageLoading.ts
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_path5 = __toESM(require("path"));
+function createLComedyPluginPageLoading() {
+  return {
+    name: "l-comedy-plugin-page-loading",
+    modifyEntry(setupConfig) {
+      let hasLoading = false;
+      const imports = [];
+      const pageLoadingPath = import_path5.default.posix.join(
+        setupConfig.sourceDir,
+        "layout/PageLoading.tsx"
+      );
+      if (import_fs_extra3.default.existsSync(pageLoadingPath)) {
+        hasLoading = true;
+        imports.push("import PageLoading from '@/layout/PageLoading'");
+      }
+      return {
+        imports,
+        reactImports: ["Suspense"],
+        appWrap(app) {
+          return `<Suspense fallback={${hasLoading ? "<PageLoading />" : "<div />"}}>
+  ${app}
+</Suspense>`;
+        }
+      };
+    }
+  };
+}
+
+// src/plugins/layout/createLComedyPluginLayout.ts
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_path6 = __toESM(require("path"));
+function createLComedyPluginLayout() {
+  return {
+    name: "l-comedy-plugin-layout",
+    modifyEntry(setupConfig) {
+      let hasLayout = false;
+      const imports = [];
+      const layoutPath = import_path6.default.posix.join(
+        setupConfig.sourceDir,
+        "layout/index.tsx"
+      );
+      if (import_fs_extra4.default.existsSync(layoutPath)) {
+        hasLayout = true;
+        imports.push("import Layout from '@/layout/index'");
+      }
+      return {
+        imports,
+        appWrap(app) {
+          if (!hasLayout) {
+            return app;
+          }
+          return `<Layout>
+  ${app}
+</Layout>`;
+        }
+      };
+    }
+  };
+}
+
+// src/setup.ts
+function setup(userConfig, options) {
+  return __async(this, null, function* () {
+    const isProd = options.isProd;
+    const workDir = ".comedy";
+    const sourceDir = userConfig.sourceDir || "src";
+    const baseConfig = {
+      isProd,
+      root: options.root,
+      workDir,
+      workPath: import_path7.default.posix.join(options.root, workDir),
+      sourceDir,
+      sourcePath: import_path7.default.posix.join(options.root, sourceDir),
+      userConfig
+    };
+    const plugins = [
+      createLComedyPluginAppConfig(),
+      createLComedyPluginHtml(),
+      createLComedyPluginLayout(),
+      createLComedyPluginPageLoading()
+    ];
+    for (const plugin of userConfig.plugins || []) {
+      if (typeof plugin === "string") {
+        plugins.push(
+          require(import_path7.default.posix.join(__dirname, `./plugins/${plugin}`)).default()
+        );
+      } else if (typeof plugin === "object") {
+        plugins.push(plugin);
+      }
+    }
+    import_fs_extra5.default.ensureDirSync(baseConfig.workPath);
+    import_fs_extra5.default.emptyDirSync(baseConfig.workPath);
+    const modifiers = [];
+    for (const plugin of plugins) {
+      if (plugin.generateFiles) {
+        yield plugin.generateFiles(baseConfig);
+      }
+      if (plugin.modifyEntry) {
+        const modifier = yield plugin.modifyEntry(baseConfig);
+        modifiers.push(modifier);
+      }
+    }
+    const setupConfig = __spreadProps(__spreadValues({}, baseConfig), {
+      plugins
+    });
+    yield generateEntryFile(
+      modifiers,
+      import_path7.default.posix.join(baseConfig.root, baseConfig.workDir),
+      setupConfig
+    );
+    let rspackConfig = {
+      mode: isProd ? "production" : "development",
+      resolve: {
+        extensions: [".ts", ".tsx", ".js", ".jsx"],
+        alias: {
+          "@": setupConfig.sourcePath
+        }
+      }
+    };
+    for (const plugin of plugins) {
+      if (plugin.rspackConfig) {
+        rspackConfig = yield plugin.rspackConfig(rspackConfig, setupConfig);
+      }
+    }
+    return rspackConfig;
+  });
+}
+
+// src/utils/config/loadUserConfig.ts
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_vm = __toESM(require("vm"));
+var import_module = __toESM(require("module"));
+var import_esbuild = require("esbuild");
+function loadUserConfig(filepath) {
+  try {
+    return runFileConfig(filepath);
+  } catch (e) {
+    console.log(`\u52A0\u8F7D\u914D\u7F6E\u51FA\u9519${filepath}:
+${e}`);
+    return {};
+  }
+}
+function runFileConfig(filepath) {
+  try {
+    const fileContent = import_fs_extra6.default.readFileSync(filepath, "utf-8");
+    const result = (0, import_esbuild.transformSync)(fileContent, {
+      loader: "tsx",
+      format: "cjs"
+    });
+    const m = new import_module.default(`l_comedy_config_${Date.now()}`);
+    const script = new import_vm.default.Script(result.code);
+    const context = import_vm.default.createContext({
+      module: m,
+      exports: m.exports,
+      require,
+      __filename: filepath,
+      __dirname: require("path").dirname(filepath),
+      console,
+      process
+    });
+    script.runInContext(context);
+    return m.exports.default || m.exports || {};
+  } catch (e) {
+    throw e;
+  }
+}
+
+// src/utils/config/getDefaultUserConfigName.ts
+function getDefaultUserConfigName() {
+  return "lcomedy.config.ts";
+}
+
+// src/commands/dev.ts
+function dev(options) {
+  return __async(this, null, function* () {
+    const root = process.cwd().replace(/\\/g, "/");
+    const filePath = import_path8.default.posix.join(
+      root,
+      (options == null ? void 0 : options.config) ? options.config : getDefaultUserConfigName()
+    );
+    let devServer = yield createDevServer(root, filePath);
+    yield devServer.start();
+    const watcher = import_chokidar.default.watch(filePath).on("change", () => __async(null, null, function* () {
+      console.log(`\u914D\u7F6E\u53D8\u66F4: ${filePath}
+\u91CD\u542F\u670D\u52A1...`);
+      devServer.stop();
+      devServer = yield createDevServer(root, filePath);
+      yield devServer.start();
+    }));
+    ["SIGINT", "SIGTERM"].forEach((signal) => {
+      process.on(signal, () => {
+        watcher.close();
+        devServer.stop();
+        process.exit();
+      });
+    });
+  });
+}
+function createDevServer(root, filePath) {
+  return __async(this, null, function* () {
+    const userConfig = loadUserConfig(filePath);
+    const rspackConfig = yield setup(userConfig, { root, isProd: false });
+    const compiler = (0, import_core2.rspack)(rspackConfig);
+    return new import_dev_server.RspackDevServer(rspackConfig.devServer || {}, compiler);
+  });
+}
+
+// src/commands/build.ts
+var import_path9 = __toESM(require("path"));
+var import_core3 = require("@rspack/core");
+function build(options) {
+  return __async(this, null, function* () {
+    const root = process.cwd().replace(/\\/g, "/");
+    const filePath = import_path9.default.posix.join(
+      root,
+      (options == null ? void 0 : options.config) ? options.config : getDefaultUserConfigName()
+    );
+    const userConfig = loadUserConfig(filePath);
+    const rspackConfig = yield setup(userConfig, { root, isProd: true });
+    yield runBuild(rspackConfig);
+  });
+}
+function runBuild(rspackConfig) {
+  return new Promise((resolve, reject) => {
+    const compiler = (0, import_core3.rspack)(rspackConfig);
+    compiler.run((err, stats) => {
+      if (err) {
+        console.error(err);
+        reject(err);
+        return;
+      }
+      if (stats && stats.hasErrors()) {
+        const info = stats.toJson();
+        console.error("Build errors:", info.errors);
+        reject(new Error("Build failed with errors"));
+        return;
+      } else if (stats) {
+        console.log(
+          stats.toString({
+            colors: true,
+            modules: false,
+            chunks: false,
+            chunkModules: false
+          })
+        );
+      }
+      compiler.close((closeErr) => {
+        if (closeErr) {
+          console.error(closeErr);
+          reject(closeErr);
+        } else {
+          console.log("Build completed successfully!");
+          resolve();
+        }
+      });
+    });
+  });
+}
+
+// src/commands/test.ts
+var import_path10 = __toESM(require("path"));
+
+// src/utils/setup/loadOptionalDependency.ts
+function loadOptionalDependency(packageName, importName) {
+  return __async(this, null, function* () {
+    try {
+      const module2 = yield import(packageName);
+      return importName ? module2[importName] : module2.default || module2;
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        console.log(`\u26A0\uFE0F \u672A\u5B89\u88C5 optional dependency: ${packageName}`);
+        return null;
+      }
+      console.error(`\u2717 \u52A0\u8F7D ${packageName} \u65F6\u51FA\u9519:`, error);
+      return null;
+    }
+  });
+}
+
+// src/commands/test.ts
+function test(options) {
+  return __async(this, null, function* () {
+    const jestPreset = yield loadOptionalDependency(
+      "@l-comedy/jest-preset"
+    );
+    if (jestPreset) {
+      const type = (options == null ? void 0 : options.type) || "all";
+      const root = process.cwd().replace(/\\/g, "/");
+      const filePath = import_path10.default.posix.join(
+        root,
+        (options == null ? void 0 : options.config) ? options.config : getDefaultUserConfigName()
+      );
+      const userConfig = loadUserConfig(filePath);
+      const { unit, components } = jestPreset.createJestConfig(userConfig.test);
+      try {
+        if (type === "unit" || type === "all") {
+          console.log("\n\u8FD0\u884C\u5355\u5143\u6D4B\u8BD5...");
+          yield jestPreset.runJest(unit);
+        }
+        if (type === "components" || type === "all") {
+          console.log("\n\u8FD0\u884C\u7EC4\u4EF6\u6D4B\u8BD5...");
+          yield jestPreset.runJest(components);
+        }
+      } catch (e) {
+        console.log(e);
+      }
+    }
+  });
+}
+
+// src/run.ts
+var program = new import_commander.Command();
+program.command("dev").description("Start development server").option("-c, --config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").action(dev);
+program.command("build").description("Build app").option("-c, --config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").action(build);
+program.command("test").description("Run test").option("-c, --config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").option("-t, --type <type>", "\u6307\u5B9A\u6D4B\u8BD5\u7C7B\u578B\uFF08unit/components/all\uFF09", "all").action(test);
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@l-comedy/core",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "lcomedy": "bin/lcomedy.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Lang-lll/l-comedy"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "通过配置快速创建react应用",
+  "keywords": [
+    "l-comedy",
+    "react",
+    "cli",
+    "config",
+    "rspack"
+  ],
+  "author": "lang-lll",
+  "license": "MIT",
+  "scripts": {
+    "build": "pnpm install && pnpm build-index && pnpm build-run && pnpm build-plugins",
+    "build-index": "tsup src/index.ts --format cjs --dts --clean",
+    "build-run": "tsup src/run.ts --format cjs --dts",
+    "build-plugins": "tsup src/plugins --format cjs --dts --outDir dist/plugins"
+  },
+  "dependencies": {
+    "@rspack/cli": "^1.6.6",
+    "@rspack/core": "^1.6.6",
+    "@rspack/dev-server": "^1.1.4",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.2",
+    "css-loader": "7.1.2",
+    "esbuild": "^0.27.1",
+    "fs-extra": "^11.3.2",
+    "html-webpack-plugin": "^5.6.5",
+    "less": "4.4.2",
+    "less-loader": "^10.0.0",
+    "postcss-loader": "8.2.0",
+    "style-loader": "4.0.0",
+    "ts-loader": "^9.5.4"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "optionalDependencies": {
+    "@l-comedy/jest-preset": "^0.1.0",
+    "react-router": "^7.0.0"
+  },
+  "devDependencies": {
+    "@jest/types": "29.6.3",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.19.1",
+    "tsup": "^8.5.1"
+  }
+}