@modern-js/plugin-devtools 2.52.0 → 2.54.0

package/dist/plugins/http.js

@@ -0,0 +1,155 @@
+"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 cookiesServiceHandler = 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
+  });
+};
+const hotUpdateHandler = 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;
+};
+const fallbackHtmlHandler = 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 app = new import_hono.Hono();
+    app.all("/api/cookies", cookiesServiceHandler);
+    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+$}", hotUpdateHandler);
+    app.get("/manifest", async (c) => {
+      const json = await api.vars.useManifestJson;
+      return c.newResponse(json, 200, {
+        "Content-Type": "application/json"
+      });
+    });
+    app.get("*", fallbackHtmlHandler);
+    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
+          }
+        }
+      };
+    });
+    api.hooks.hook("cleanup", () => {
+      server.close();
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginHttp
+});

package/dist/plugins/manifest.d.ts

@@ -0,0 +1,11 @@
+import { type ServerManifest } from '@modern-js/devtools-kit/node';
+import { Plugin } from '../types';
+declare global {
+    interface DevtoolsPluginVars {
+        manifest?: ServerManifest;
+        manifestJson?: string;
+        useManifest: Promise<ServerManifest>;
+        useManifestJson: Promise<string>;
+    }
+}
+export declare const pluginManifest: Plugin;

package/dist/plugins/manifest.js

@@ -0,0 +1,77 @@
+"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 manifest_exports = {};
+__export(manifest_exports, {
+  pluginManifest: () => pluginManifest
+});
+module.exports = __toCommonJS(manifest_exports);
+var import_path = __toESM(require("path"));
+var import_node = require("@modern-js/devtools-kit/node");
+var import_utils = require("@modern-js/utils");
+var import_p_defer = __toESM(require("p-defer"));
+const pluginManifest = {
+  async setup(api) {
+    const deferredManifest = (0, import_p_defer.default)();
+    const deferredManifestJson = (0, import_p_defer.default)();
+    api.vars.useManifest = deferredManifest.promise;
+    api.vars.useManifestJson = deferredManifestJson.promise;
+    api.hooks.hook("settleState", async () => {
+      const routesManifestName = require.resolve("@modern-js/devtools-client/manifest");
+      const routesManifest = await import_utils.fs.readJSON(routesManifestName);
+      const manifest = {
+        ...api.vars.state,
+        client: "/__devtools",
+        websocket: "/__devtools/rpc",
+        routeAssets: routesManifest.routeAssets
+      };
+      api.vars.manifest = manifest;
+      deferredManifest.resolve(manifest);
+      const stringified = JSON.stringify(manifest, (0, import_node.replacer)());
+      api.vars.manifestJson = stringified;
+      deferredManifestJson.resolve(stringified);
+    });
+    const frameworkApi = await api.setupFramework();
+    const outputManifest = async () => {
+      const { nodeModulesDirectory } = frameworkApi.useAppContext();
+      const name = `.cache/devtools/manifest-${(0, import_utils.nanoid)(6)}.json`;
+      const resolvedName = import_path.default.resolve(nodeModulesDirectory, name);
+      const json = await api.vars.useManifestJson;
+      await import_utils.fs.outputFile(resolvedName, json, "utf-8");
+      if (process.env.NODE_ENV === "production") {
+        import_utils.logger.info(`${api.context.def.name.formalName} DevTools output manifest to node_modules/${name}`);
+      }
+    };
+    api.frameworkHooks.hook("afterDev", outputManifest);
+    api.frameworkHooks.hook("afterBuild", outputManifest);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginManifest
+});

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,182 @@
+"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_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_socket = require("../utils/socket");
+const pluginRpc = {
+  async setup(api) {
+    const httpServer = api.vars.http;
+    if (!httpServer)
+      return;
+    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));
+      });
+    });
+    const frameworkApi = await api.setupFramework();
+    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() {
+        try {
+          return api.vars.state;
+        } catch (e) {
+          console.error(e);
+          throw e;
+        }
+      },
+      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
+      ], (0, import_node.replacer)()),
+      deserialize: (v) => {
+        const msg = flatted.parse(v.toString(), (0, import_node.reviver)())[0];
+        return msg;
+      },
+      onError(error, functionName, args) {
+        const stringifiedArgs = args.map((arg) => JSON.stringify(arg)).join(", ");
+        console.error(new Error(`DevTools failed to execute RPC function: ${functionName}(${stringifiedArgs})`));
+        console.error(error);
+      }
+    };
+    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/settle.d.ts

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

package/dist/plugins/settle.js

@@ -0,0 +1,52 @@
+"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 settle_exports = {};
+__export(settle_exports, {
+  pluginSettleState: () => pluginSettleState
+});
+module.exports = __toCommonJS(settle_exports);
+const pluginSettleState = {
+  async setup(api) {
+    let _pendingCompiler = 0;
+    const handleSettle = async () => {
+      _pendingCompiler -= 1;
+      if (_pendingCompiler === 0) {
+        await api.hooks.callHook("settleState");
+      }
+    };
+    const handleDone = (compiler) => {
+      if ("compilers" in compiler) {
+        compiler.compilers.forEach(handleDone);
+      } else {
+        _pendingCompiler += 1;
+        compiler.hooks.done.tapPromise({
+          name: "@modern-js/plugin-devtools",
+          stage: 4e3
+        }, () => handleSettle());
+      }
+    };
+    api.frameworkHooks.hook("afterCreateCompiler", ({ compiler }) => {
+      compiler && handleDone(compiler);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginSettleState
+});

package/dist/plugins/state.d.ts

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