@modern-js/plugin-devtools 0.0.0-next-20240617034812 → 0.0.0-next-20240617090621

package/dist/plugins/http.js

@@ -0,0 +1,151 @@
+"use strict";
+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);
+var http_exports = {};
+__export(http_exports, {
+  pluginHttp: () => pluginHttp
+});
+module.exports = __toCommonJS(http_exports);
+var import_path = __toESM(require("path"));
+var import_assert = __toESM(require("assert"));
+var import_http = __toESM(require("http"));
+var import_url = require("url");
+var import_hono = require("hono");
+var import_utils = require("@modern-js/utils");
+var import_node_server = require("@hono/node-server");
+var import_serve_static = require("@hono/node-server/serve-static");
+var import_node = require("@modern-js/devtools-kit/node");
+const CLIENT_SERVE_DIR = import_path.default.resolve(require.resolve("@modern-js/devtools-client/package.json"), "../dist");
+const app = new import_hono.Hono();
+app.all("/api/cookies", async (c) => {
+  const raw = c.req.header("Cookie");
+  const { parse } = await import("cookie-es");
+  const cookies = raw ? parse(raw) : {};
+  const body = await c.req.json().catch(() => null);
+  if (body === null || body === void 0 ? void 0 : body.setCookies) {
+    const { setCookies } = body;
+    (0, import_assert.default)(typeof setCookies === "object", "setCookies should be object");
+    for (const [k, v] of Object.entries(setCookies)) {
+      (0, import_assert.default)(typeof v === "string");
+      const expires = new Date(Date.now() + 30 * 24 * 36e5).toUTCString();
+      cookies[k] = v;
+      c.header("Set-Cookie", `${k}=${v}; Expires=${expires}; Path=/`, {
+        append: true
+      });
+    }
+  }
+  return c.json({
+    cookies
+  });
+});
+app.use(
+  "/static/*",
+  // Workaround for https://github.com/honojs/node-server/blob/dd0e0cd160b0b8f18abbcb28c5f5c39b72105d98/src/serve-static.ts#L56
+  (0, import_serve_static.serveStatic)({
+    root: import_path.default.relative(process.cwd(), CLIENT_SERVE_DIR)
+  })
+);
+app.get(":filename{.+\\.hot-update\\.\\w+$}", async (c) => {
+  if (process.env.NODE_ENV !== "development") {
+    return c.text("Not found", 404);
+  }
+  const filename = c.req.param("filename");
+  const target = new import_url.URL(filename, "http://127.0.0.1:8780");
+  const { body, headers, status } = await fetch(target.href);
+  const newResp = c.newResponse(body, {
+    headers,
+    status
+  });
+  if (newResp.headers.get("content-encoding") === "gzip") {
+    newResp.headers.delete("content-encoding");
+  }
+  return newResp;
+});
+app.get("*", async (c) => {
+  const filename = import_path.default.resolve(CLIENT_SERVE_DIR, "html/client/index.html");
+  const content = await import_utils.fs.readFile(filename, "utf-8");
+  return c.html(content);
+});
+const pluginHttp = {
+  async setup(api) {
+    if (process.env.NODE_ENV === "production")
+      return;
+    const server = (0, import_node_server.createAdaptorServer)({
+      fetch: app.fetch,
+      hostname: "127.0.0.1",
+      serverOptions: {
+        allowHTTP1: true
+      }
+    });
+    (0, import_assert.default)(server instanceof import_http.default.Server, "instance should be http.Server");
+    api.vars.http = server;
+    api.frameworkHooks.hook("config", async () => {
+      const port = await (0, import_utils.getPort)(8782, {
+        slient: true
+      });
+      server.listen(port);
+      const proxy = {
+        [import_node.ROUTE_BASENAME]: {
+          target: `http://127.0.0.1:${port}`,
+          pathRewrite: {
+            [`^${import_node.ROUTE_BASENAME}`]: ""
+          },
+          ws: true,
+          onProxyReq(proxyReq, req) {
+            const addrInfo = req.socket.address();
+            if ("address" in addrInfo) {
+              const { address } = addrInfo;
+              proxyReq.setHeader("X-Forwarded-For", address);
+            } else {
+              proxyReq.removeHeader("X-Forwarded-For");
+            }
+          }
+        }
+      };
+      return {
+        tools: {
+          devServer: {
+            proxy
+          }
+        }
+      };
+    });
+    let _open = true;
+    const cleanup = () => {
+      _open && server.close();
+      _open = false;
+    };
+    api.frameworkHooks.hook("beforeExit", cleanup);
+    api.frameworkHooks.hook("beforeRestart", cleanup);
+    api.frameworkHooks.hook("afterBuild", cleanup);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginHttp
+});

package/dist/plugins/rpc.d.ts

@@ -0,0 +1,9 @@
+import { DevtoolsContext } from '@modern-js/devtools-kit/node';
+import { CliPluginAPI, Plugin } from '../types';
+import { SocketServer } from '../utils/socket';
+export interface SetupClientConnectionOptions {
+    api: CliPluginAPI;
+    server: SocketServer;
+    ctx: DevtoolsContext;
+}
+export declare const pluginRpc: Plugin;

package/dist/plugins/rpc.js

@@ -0,0 +1,333 @@
+"use strict";
+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);
+var rpc_exports = {};
+__export(rpc_exports, {
+  pluginRpc: () => pluginRpc
+});
+module.exports = __toCommonJS(rpc_exports);
+var import_assert = __toESM(require("assert"));
+var import_buffer = require("buffer");
+var import_path = __toESM(require("path"));
+var import_node = require("@modern-js/devtools-kit/node");
+var import_utils = require("@modern-js/utils");
+var import_lodash = __toESM(require("@modern-js/utils/lodash"));
+var import_birpc = require("birpc");
+var flatted = __toESM(require("flatted"));
+var import_valtio = require("valtio");
+var import_module = require("../utils/module");
+var import_socket = require("../utils/socket");
+const resolveDependencies = async (rootPath) => {
+  const ret = {};
+  const resolveExprs = {
+    react: [
+      rootPath,
+      "react/package.json"
+    ],
+    "@modern-js/app-tools": [
+      rootPath,
+      "@modern-js/app-tools/package.json"
+    ],
+    "@edenx/app-tools": [
+      rootPath,
+      "@edenx/app-tools/package.json"
+    ],
+    webpack: [
+      rootPath,
+      "@modern-js/app-tools",
+      "@modern-js/uni-builder",
+      "@rsbuild/webpack",
+      "webpack/package.json"
+    ],
+    "@rspack/core": [
+      rootPath,
+      "@modern-js/uni-builder",
+      "@rsbuild/core",
+      "@rspack/core/package.json"
+    ],
+    "@rsdoctor/rspack-plugin": [
+      rootPath,
+      "@rsdoctor/rspack-plugin/package.json"
+    ],
+    "@rsdoctor/webpack-plugin": [
+      rootPath,
+      "@rsdoctor/webpack-plugin/package.json"
+    ],
+    "@web-doctor/webpack-plugin": [
+      rootPath,
+      "@web-doctor/webpack-plugin/package.json"
+    ],
+    "@web-doctor/rspack-plugin": [
+      rootPath,
+      "@web-doctor/rspack-plugin/package.json"
+    ],
+    "@web-doctor/webpack-plugin(builder)": [
+      rootPath,
+      "@edenx/builder-plugin-web-doctor",
+      "@web-doctor/webpack-plugin/package.json"
+    ],
+    "@web-doctor/rspack-plugin(builder)": [
+      rootPath,
+      "@edenx/builder-plugin-web-doctor",
+      "@web-doctor/rspack-plugin/package.json"
+    ],
+    "@rsdoctor/core": [
+      rootPath,
+      "@rsdoctor/core/package.json"
+    ]
+  };
+  for (const [name, expr] of Object.entries(resolveExprs)) {
+    try {
+      ret[name] = (0, import_module.requireModule)(expr).version;
+    } catch {
+    }
+  }
+  return ret;
+};
+const getDoctorOverview = async (ctx) => {
+  const manifestPath = await (0, import_node.findManifest)(ctx.distDirectory);
+  const json = await (0, import_node.parseManifest)(require(manifestPath));
+  return {
+    numModules: json.data.moduleGraph.modules.length,
+    numChunks: json.data.chunkGraph.chunks.length,
+    numPackages: json.data.packageGraph.packages.length,
+    summary: json.data.summary,
+    errors: json.data.errors
+  };
+};
+const pluginRpc = {
+  async setup(api) {
+    const httpServer = api.vars.http;
+    (0, import_assert.default)(httpServer, "http server is required for rpc plugin");
+    const server = new import_socket.SocketServer({
+      server: httpServer,
+      path: "/rpc"
+    });
+    let handleMessage = null;
+    const onceConnection = new Promise((resolve) => {
+      server.on("connection", (ws) => {
+        resolve();
+        ws.on("message", (data, isBinary) => handleMessage === null || handleMessage === void 0 ? void 0 : handleMessage(data, isBinary));
+      });
+    });
+    if ("resolve" in api.vars.resolver.context) {
+      api.vars.resolver.context.resolve(api.context);
+    }
+    api.vars.state.context = api.context;
+    api.frameworkHooks.hook("modifyFileSystemRoutes", ({ entrypoint, routes }) => {
+      api.vars.state.fileSystemRoutes[entrypoint.entryName] = import_lodash.default.cloneDeep(routes);
+    });
+    const builderApi = await api.setupBuilder();
+    api.vars.resolver.builder.context.resolve(builderApi.context);
+    resolveDependencies(builderApi.context.rootPath).then((deps) => {
+      api.vars.state.dependencies = deps;
+    });
+    api.builderHooks.hook("modifyBundlerChain", () => {
+      api.vars.resolver.builder.config.resolved.resolve(import_lodash.default.cloneDeep(builderApi.getRsbuildConfig()));
+      api.vars.resolver.builder.config.transformed.resolve(import_lodash.default.cloneDeep(builderApi.getNormalizedConfig()));
+    });
+    const expectBundlerNum = import_lodash.default.castArray(builderApi.context.targets).length;
+    const bundlerConfigs = [];
+    const handleBundlerConfig = (config) => {
+      bundlerConfigs.push(config);
+      if (bundlerConfigs.length >= expectBundlerNum) {
+        api.vars.state.bundler.configs.resolved = import_lodash.default.cloneDeep(bundlerConfigs);
+      }
+    };
+    if (builderApi.context.bundlerType === "webpack") {
+      api.builderHooks.hook("modifyWebpackConfig", (config) => {
+        handleBundlerConfig(config);
+      });
+    } else {
+      api.builderHooks.hook("modifyRspackConfig", (config) => {
+        handleBundlerConfig(config);
+      });
+    }
+    api.builderHooks.hook("onBeforeCreateCompiler", ({ bundlerConfigs: bundlerConfigs2 }) => {
+      api.vars.resolver.bundler.configs.transformed.resolve(import_lodash.default.cloneDeep(bundlerConfigs2));
+    });
+    let buildStartedAt = NaN;
+    api.builderHooks.hook("onAfterCreateCompiler", () => {
+      buildStartedAt = Date.now();
+    });
+    api.builderHooks.hook("onDevCompileDone", () => {
+      api.vars.resolver.performance.resolve({
+        compileDuration: Date.now() - buildStartedAt
+      });
+    });
+    api.builderHooks.hook("onAfterBuild", () => {
+      api.vars.resolver.performance.resolve({
+        compileDuration: Date.now() - buildStartedAt
+      });
+    });
+    let _pendingCompiler = 0;
+    const resolveRsdoctorManifest = async () => {
+      _pendingCompiler -= 1;
+      if (_pendingCompiler === 0) {
+        try {
+          const doctor = await getDoctorOverview(await api.vars.state.framework.context);
+          api.vars.resolver.doctor.resolve(doctor);
+        } catch (err) {
+          api.vars.resolver.doctor.resolve(void 0);
+        }
+      }
+    };
+    api.frameworkHooks.hook("afterCreateCompiler", ({ compiler }) => {
+      if (!compiler)
+        return;
+      _pendingCompiler += 1;
+      compiler.hooks.done.tap({
+        name: "@modern-js/plugin-devtools",
+        stage: 4e3
+      }, () => resolveRsdoctorManifest());
+    });
+    const frameworkApi = await api.setupFramework();
+    const frameworkContext = {
+      ...frameworkApi.useAppContext(),
+      builder: null,
+      serverInternalPlugins: null
+    };
+    api.vars.resolver.framework.context.resolve(frameworkContext);
+    api.vars.resolver.framework.config.resolved.resolve(frameworkApi.useConfigContext());
+    api.vars.resolver.framework.config.transformed.resolve(frameworkApi.useResolvedConfigContext());
+    const validateSafeToOpen = (filename) => {
+      const { appDirectory } = frameworkApi.useAppContext();
+      const resolved = import_path.default.resolve(appDirectory, filename);
+      for (const preset of api.context.storagePresets) {
+        if (import_path.default.resolve(appDirectory, preset.filename) === resolved) {
+          return true;
+        }
+      }
+      return false;
+    };
+    const serverFunctions = {
+      echo(content) {
+        return content;
+      },
+      async pullExportedState() {
+        (0, import_node.extractSettledOperations)(api.vars.state).then((ops) => {
+          clientConn.applyStateOperations.asEvent(ops);
+        });
+        return api.vars.state;
+      },
+      async createTemporaryStoragePreset() {
+        var _config;
+        const appCtx = frameworkApi.useAppContext();
+        const basename = `${api.context.def.name.shortName}.runtime.json`;
+        const filename = import_path.default.resolve(appCtx.appDirectory, basename);
+        const id = (0, import_utils.nanoid)();
+        const name = `New Preset ${id.slice(0, 6)}`;
+        const config = {};
+        if (await import_utils.fs.pathExists(filename)) {
+          Object.assign(config, await import_utils.fs.readJSON(filename));
+        }
+        const newPreset = {
+          name,
+          id,
+          cookie: {},
+          localStorage: {},
+          sessionStorage: {}
+        };
+        (_config = config).storagePresets || (_config.storagePresets = []);
+        config.storagePresets.push(newPreset);
+        await import_utils.fs.outputJSON(filename, config, {
+          spaces: 2
+        });
+        return newPreset;
+      },
+      async pasteStoragePreset(target) {
+        var _config;
+        const { default: clipboardy } = await import("clipboardy");
+        const raw = clipboardy.readSync();
+        const HEAD = `data:application/json;base64,`;
+        if (!raw.startsWith(HEAD)) {
+          throw new Error("Failed to parse data URL");
+        }
+        const encoded = raw.slice(HEAD.length);
+        const preset = JSON.parse(import_buffer.Buffer.from(encoded, "base64").toString("utf-8"));
+        if (typeof preset !== "object" || preset === null) {
+          throw new Error("Failed to parse data URL");
+        }
+        if (typeof preset.name !== "string") {
+          throw new Error("Failed to parse data URL");
+        }
+        const appCtx = frameworkApi.useAppContext();
+        const filename = import_path.default.resolve(appCtx.appDirectory, target.filename);
+        const config = {};
+        if (await import_utils.fs.pathExists(filename)) {
+          Object.assign(config, await import_utils.fs.readJSON(filename));
+        }
+        (_config = config).storagePresets || (_config.storagePresets = []);
+        const diff = import_lodash.default.pick(preset, [
+          "cookie",
+          "localStorage",
+          "sessionStorage"
+        ]);
+        const matched = import_lodash.default.find(config.storagePresets, {
+          id: target.id
+        });
+        if (matched) {
+          import_lodash.default.merge(matched, diff);
+        } else {
+          config.storagePresets.push(preset);
+        }
+        await import_utils.fs.outputJSON(filename, config, {
+          spaces: 2
+        });
+      },
+      async open(filename) {
+        const name = import_path.default.resolve(frameworkApi.useAppContext().appDirectory, filename);
+        const validated = validateSafeToOpen(name);
+        if (!validated) {
+          throw new Error("Failed to validate the file.");
+        }
+        const { default: open } = await import("open");
+        await open(name);
+      }
+    };
+    const clientRpcOptions = {
+      post: (data) => onceConnection.then(() => server.clients.forEach((ws) => ws.send(data))),
+      on: (cb) => handleMessage = cb,
+      serialize: (v) => flatted.stringify([
+        v
+      ], import_node.replacer),
+      deserialize: (v) => {
+        const msg = flatted.parse(v.toString(), import_node.reviver)[0];
+        return msg;
+      }
+    };
+    const clientConn = (0, import_birpc.createBirpc)(serverFunctions, clientRpcOptions);
+    (0, import_valtio.subscribe)(api.vars.state, (ops) => {
+      clientConn.applyStateOperations.asEvent(ops);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginRpc
+});

package/dist/plugins/service-worker.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../types';
+export declare const pluginServiceWorker: Plugin;

package/dist/plugins/service-worker.js

@@ -0,0 +1,63 @@
+"use strict";
+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);
+var service_worker_exports = {};
+__export(service_worker_exports, {
+  pluginServiceWorker: () => pluginServiceWorker
+});
+module.exports = __toCommonJS(service_worker_exports);
+const pluginServiceWorker = {
+  async setup(api) {
+    api.frameworkHooks.hook("modifyServerRoutes", ({ routes }) => {
+      routes.push({
+        urlPath: "/sw-proxy.js",
+        isSPA: true,
+        isSSR: false,
+        entryPath: "public/sw-proxy.js"
+      });
+    });
+    api.frameworkHooks.hook("config", async () => {
+      const swProxyEntry = require.resolve("@modern-js/devtools-client/sw-proxy");
+      const config = {
+        output: {
+          copy: [
+            {
+              from: swProxyEntry,
+              to: "public"
+            }
+          ]
+        }
+      };
+      return config;
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginServiceWorker
+});

package/dist/plugins/state.d.ts

@@ -0,0 +1,9 @@
+import { ServerExportedState, ServerExportedStateResolvers } from '@modern-js/devtools-kit/node';
+import { Plugin } from '../types';
+declare global {
+    interface DevtoolsPluginVars {
+        state: ServerExportedState;
+        resolver: ServerExportedStateResolvers;
+    }
+}
+export declare const pluginState: Plugin;

package/dist/{state.js → plugins/state.js}

@@ -18,19 +18,19 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var state_exports = {};
 __export(state_exports, {
-  $resolvers: () => $resolvers,
-  $serverExportedState: () => $serverExportedState,
-  $state: () => $state
+  pluginState: () => pluginState
 });
 module.exports = __toCommonJS(state_exports);
-var import_valtio = require("valtio");
 var import_node = require("@modern-js/devtools-kit/node");
-const $serverExportedState = (0, import_node.createServerExportedState)();
-const $resolvers = $serverExportedState.resolvers;
-const $state = (0, import_valtio.proxy)($serverExportedState.state);
+var import_valtio = require("valtio");
+const pluginState = {
+  async setup(api) {
+    const $serverExportedState = (0, import_node.createServerExportedState)();
+    api.vars.state = (0, import_valtio.proxy)($serverExportedState.state);
+    api.vars.resolver = $serverExportedState.resolvers;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  $resolvers,
-  $serverExportedState,
-  $state
+  pluginState
 });

package/dist/plugins/watcher.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../types';
+export declare const pluginWatcher: Plugin;

package/dist/plugins/watcher.js

@@ -0,0 +1,59 @@
+"use strict";
+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);
+var watcher_exports = {};
+__export(watcher_exports, {
+  pluginWatcher: () => pluginWatcher
+});
+module.exports = __toCommonJS(watcher_exports);
+var import_utils = require("@modern-js/utils");
+var import_config = require("../utils/config");
+var import_options = require("../options");
+const pluginWatcher = {
+  async setup(api) {
+    const basename = `${api.context.def.name.shortName}.runtime.json`;
+    const frameworkApi = await api.setupFramework();
+    const appCtx = frameworkApi.useAppContext();
+    const watcher = import_utils.chokidar.watch((0, import_config.getConfigFilenames)(basename), {
+      cwd: appCtx.appDirectory,
+      ignorePermissionErrors: true
+    });
+    const refreshStoragePreset = async () => {
+      const configs = await (0, import_config.loadConfigFiles)(basename, appCtx.appDirectory);
+      if (!configs)
+        return;
+      api.context.storagePresets = [];
+      (0, import_options.updateContext)(api.context, ...configs);
+    };
+    watcher.on("add", refreshStoragePreset);
+    watcher.on("change", refreshStoragePreset);
+    watcher.on("unlink", refreshStoragePreset);
+    let _open = true;
+    const cleanup = () => {
+      _open && watcher.close();
+      _open = false;
+    };
+    api.frameworkHooks.hook("beforeExit", cleanup);
+    api.frameworkHooks.hook("beforeRestart", cleanup);
+    api.frameworkHooks.hook("afterBuild", cleanup);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginWatcher
+});