@modern-js/plugin-devtools 2.33.1 → 2.35.0

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import { ClientDefinition, SetupClientOptions } from '@modern-js/devtools-kit';
+import { PartialDeep } from 'type-fest';
+export interface Options extends SetupClientOptions {
+  rpcPath?: string;
+  def?: PartialDeep<ClientDefinition>;
+}
+export declare const devtoolsPlugin: (options?: Options) => CliPlugin<AppTools>;
+export default devtoolsPlugin;

package/dist/cli.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  devtoolsPlugin: function() {
+    return devtoolsPlugin;
+  },
+  default: function() {
+    return _default;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _lodash = /* @__PURE__ */ _interop_require_default._(require("@modern-js/utils/lodash"));
+const _devtoolskit = require("@modern-js/devtools-kit");
+const _rpc = require("./rpc");
+const getDefaultOptions = () => ({
+  rpcPath: "/_modern_js/devtools/rpc",
+  def: new _devtoolskit.ClientDefinition()
+});
+const devtoolsPlugin = (options) => ({
+  name: "@modern-js/plugin-devtools",
+  usePlugins: [],
+  setup: async (api) => {
+    const opts = _lodash.default.defaultsDeep(_lodash.default.cloneDeep(options), getDefaultOptions());
+    const mountOpts = _lodash.default.pick(opts, [
+      "endpoint",
+      "version",
+      "dataSource"
+    ]);
+    const { hooks, builderPlugin, url } = await (0, _rpc.setupClientConnection)({
+      api,
+      def: opts.def
+    });
+    return {
+      prepare: hooks.prepare,
+      modifyFileSystemRoutes: hooks.modifyFileSystemRoutes,
+      validateSchema() {
+        return [
+          {
+            target: "tools.devtools",
+            schema: {
+              typeof: [
+                "boolean"
+              ]
+            }
+          }
+        ];
+      },
+      config() {
+        return {
+          builderPlugins: [
+            builderPlugin
+          ],
+          source: {
+            preEntry: [
+              require.resolve("@modern-js/plugin-devtools/runtime")
+            ],
+            globalVars: {
+              "process.env.__MODERN_DEVTOOLS_MOUNT_OPTIONS": mountOpts
+            }
+          },
+          tools: {
+            devServer: {
+              proxy: {
+                [opts.rpcPath]: {
+                  target: url.href,
+                  autoRewrite: true,
+                  ws: true
+                }
+              }
+            }
+          }
+        };
+      }
+    };
+  }
+});
+const _default = devtoolsPlugin;

package/dist/rpc/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { URL } from 'url';
+import { type ClientDefinition, type ClientFunctions, type ServerFunctions } from '@modern-js/devtools-kit';
+import type { PartialDeep } from 'type-fest';
+import type { BuilderPlugin } from '@modern-js/builder-shared';
+import { CliPluginAPI, BuilderPluginAPI, InjectedHooks } from '../types';
+export interface SetupClientConnectionOptions {
+  api: CliPluginAPI;
+  def?: PartialDeep<ClientDefinition>;
+}
+export declare const setupClientConnection: (options: SetupClientConnectionOptions) => Promise<{
+  client: import("birpc").BirpcReturn<ClientFunctions, ServerFunctions>;
+  hooks: InjectedHooks;
+  builderPlugin: BuilderPlugin<BuilderPluginAPI>;
+  url: URL;
+}>;

package/dist/rpc/index.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "setupClientConnection", {
+  enumerable: true,
+  get: function() {
+    return setupClientConnection;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _url = require("url");
+const _lodash = /* @__PURE__ */ _interop_require_default._(require("@modern-js/utils/lodash"));
+const _devtoolskit = require("@modern-js/devtools-kit");
+const _birpc = require("birpc");
+const _pdefer = /* @__PURE__ */ _interop_require_default._(require("p-defer"));
+const _utils = require("@modern-js/utils");
+const _socket = require("../utils/socket");
+const _module = require("../utils/module");
+const setupClientConnection = async (options) => {
+  const { api, def = {} } = options;
+  const port = await (0, _utils.getPort)(8782);
+  const server = new _socket.SocketServer({
+    port
+  });
+  const url = new _url.URL(`ws://localhost:${port}`);
+  const _fileSystemRoutesMap = {};
+  let handleMessage = null;
+  const onceConnection = new Promise((resolve) => {
+    server.on("connection", (ws) => {
+      resolve();
+      ws.on("message", (data, isBinary) => {
+        var _handleMessage;
+        return (_handleMessage = handleMessage) === null || _handleMessage === void 0 ? void 0 : _handleMessage(data, isBinary);
+      });
+    });
+  });
+  const deferred = {
+    prepare: (0, _pdefer.default)(),
+    builder: {
+      context: (0, _pdefer.default)(),
+      config: {
+        resolved: (0, _pdefer.default)(),
+        transformed: (0, _pdefer.default)()
+      }
+    },
+    bundler: {
+      config: {
+        resolved: (0, _pdefer.default)(),
+        transformed: (0, _pdefer.default)()
+      }
+    },
+    compileTimeCost: (0, _pdefer.default)()
+  };
+  const serverFunctions = {
+    async getFrameworkConfig() {
+      await deferred.prepare.promise;
+      return api.useConfigContext();
+    },
+    async getTransformedFrameworkConfig() {
+      await deferred.prepare.promise;
+      return api.useResolvedConfigContext();
+    },
+    async getBuilderConfig() {
+      return deferred.builder.config.resolved.promise;
+    },
+    async getTransformedBuilderConfig() {
+      return deferred.builder.config.transformed.promise;
+    },
+    async getBundlerConfigs() {
+      return deferred.bundler.config.resolved.promise;
+    },
+    async getTransformedBundlerConfigs() {
+      return deferred.bundler.config.transformed.promise;
+    },
+    async getAppContext() {
+      await deferred.prepare.promise;
+      const ctx = {
+        ...api.useAppContext()
+      };
+      return _lodash.default.omit(ctx, [
+        "builder",
+        "serverInternalPlugins"
+      ]);
+    },
+    async getFileSystemRoutes(entryName) {
+      var _fileSystemRoutesMap_entryName;
+      return (_fileSystemRoutesMap_entryName = _fileSystemRoutesMap[entryName]) !== null && _fileSystemRoutesMap_entryName !== void 0 ? _fileSystemRoutesMap_entryName : [];
+    },
+    async getBuilderContext() {
+      const ctx = await deferred.builder.context.promise;
+      return ctx;
+    },
+    async getDependencies() {
+      const ctx = await deferred.builder.context.promise;
+      const ret = {};
+      const resolveExprs = {
+        react: [
+          ctx.rootPath,
+          "react/package.json"
+        ],
+        "@modern-js/app-tools": [
+          ctx.rootPath,
+          "@modern-js/app-tools/package.json"
+        ],
+        "@edenx/app-tools": [
+          ctx.rootPath,
+          "@edenx/app-tools/package.json"
+        ],
+        webpack: [
+          ctx.rootPath,
+          "@modern-js/app-tools",
+          "@modern-js/builder-webpack-provider",
+          "webpack/package.json"
+        ],
+        "@rspack/core": [
+          ctx.rootPath,
+          "@modern-js/builder-rspack-provider",
+          "@rspack/core/package.json"
+        ]
+      };
+      for (const [name, expr] of Object.entries(resolveExprs)) {
+        try {
+          ret[name] = (0, _module.requireModule)(expr).version;
+        } catch {
+        }
+      }
+      return ret;
+    },
+    async getCompileTimeCost() {
+      return deferred.compileTimeCost.promise;
+    },
+    async getClientDefinition() {
+      const ret = {
+        name: new _devtoolskit.NameDefinition(),
+        packages: new _devtoolskit.PackageDefinition(),
+        assets: new _devtoolskit.AssetDefinition()
+      };
+      Object.assign(ret.name, def.name);
+      Object.assign(ret.packages, def.packages);
+      Object.assign(ret.assets, def.assets);
+      return ret;
+    },
+    echo(content) {
+      return content;
+    }
+  };
+  const clientRpcOptions = {
+    post: (data) => onceConnection.then(() => server.clients.forEach((ws) => ws.send(data))),
+    on: (cb) => handleMessage = cb,
+    serialize: (v) => JSON.stringify(v),
+    deserialize: (v) => JSON.parse(v.toString())
+  };
+  const clientConn = (0, _birpc.createBirpc)(serverFunctions, clientRpcOptions);
+  const hooks = {
+    prepare() {
+      deferred.prepare.resolve();
+    },
+    modifyFileSystemRoutes({ entrypoint, routes }) {
+      _fileSystemRoutesMap[entrypoint.entryName] = _lodash.default.cloneDeep(routes);
+      return {
+        entrypoint,
+        routes
+      };
+    }
+  };
+  const builderPlugin = {
+    name: "builder-plugin-devtools",
+    setup(api2) {
+      deferred.builder.context.resolve(_lodash.default.cloneDeep(api2.context));
+      api2.modifyBundlerChain(() => {
+        deferred.builder.config.resolved.resolve(_lodash.default.cloneDeep(api2.getBuilderConfig()));
+        deferred.builder.config.transformed.resolve(_lodash.default.cloneDeep(api2.getNormalizedConfig()));
+      });
+      const modifyBundlerConfig = "modifyWebpackConfig" in api2 ? api2.modifyWebpackConfig : api2.modifyRspackConfig;
+      const expectBundlerNum = _lodash.default.castArray(api2.context.target).length;
+      const bundlerConfigs = [];
+      modifyBundlerConfig((config) => {
+        bundlerConfigs.push(config);
+        if (bundlerConfigs.length >= expectBundlerNum) {
+          deferred.bundler.config.resolved.resolve(_lodash.default.cloneDeep(bundlerConfigs));
+        }
+      });
+      api2.onBeforeCreateCompiler(({ bundlerConfigs: bundlerConfigs2 }) => {
+        deferred.bundler.config.transformed.resolve(_lodash.default.cloneDeep(bundlerConfigs2));
+      });
+      let buildStartedAt = NaN;
+      api2.onAfterCreateCompiler(() => {
+        buildStartedAt = Date.now();
+      });
+      api2.onDevCompileDone(() => {
+        deferred.compileTimeCost.resolve(Date.now() - buildStartedAt);
+      });
+      api2.onAfterBuild(() => {
+        deferred.compileTimeCost.resolve(Date.now() - buildStartedAt);
+      });
+    }
+  };
+  return {
+    client: clientConn,
+    hooks,
+    builderPlugin,
+    url
+  };
+};

package/dist/runtime.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const _devtoolsmount = require("@modern-js/devtools-mount");
+const opts = process.env.__MODERN_DEVTOOLS_MOUNT_OPTIONS;
+(0, _devtoolsmount.mountDevTools)(opts);

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { BaseHooks } from '@modern-js/core';
+import type { BuilderPluginAPI as WebpackBuilderAPI } from '@modern-js/builder-webpack-provider';
+import type { BuilderPluginAPI as RspackBuilderAPI } from '@modern-js/builder-rspack-provider';
+import type { AppTools, AppToolsHooks, CliPlugin } from '@modern-js/app-tools';
+import type { ServerPlugin, ToThreads } from '@modern-js/server-core';
+export type CliPluginAPI = Parameters<NonNullable<CliPlugin<AppTools>['setup']>>[0];
+export type ServerPluginAPI = Parameters<NonNullable<ServerPlugin['setup']>>[0];
+export type BuilderPluginAPI = WebpackBuilderAPI | RspackBuilderAPI;
+export type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | ReadonlyArray<any> | ReadonlyArray<number> | {
+  valueOf: () => ArrayBuffer;
+} | {
+  valueOf: () => SharedArrayBuffer;
+} | {
+  valueOf: () => Uint8Array;
+} | {
+  valueOf: () => ReadonlyArray<number>;
+} | {
+  valueOf: () => string;
+} | {
+  [Symbol.toPrimitive]: (hint: string) => string;
+};
+export type Hooks = BaseHooks<any> & AppToolsHooks<any>;
+export type InjectedHooks = Pick<ToThreads<Hooks>, 'prepare' | 'modifyFileSystemRoutes'>;

package/dist/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/utils/module.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare const getRequire: () => NodeRequire;
+export declare const resolveModule: (id: string[] | string) => string | null;
+export declare const requireModule: (id: string[] | string) => any;

package/dist/utils/module.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  getRequire: function() {
+    return getRequire;
+  },
+  resolveModule: function() {
+    return resolveModule;
+  },
+  requireModule: function() {
+    return requireModule;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _assert = /* @__PURE__ */ _interop_require_default._(require("assert"));
+const _module = /* @__PURE__ */ _interop_require_default._(require("module"));
+const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
+const getRequire = () => {
+  var _stack_split__match, _stack;
+  try {
+    return require;
+  } catch {
+  }
+  const issuer = (_stack = new Error().stack) === null || _stack === void 0 ? void 0 : (_stack_split__match = _stack.split("\n")[2].match(/\s*at .+? \((.*)\)$/)) === null || _stack_split__match === void 0 ? void 0 : _stack_split__match[1];
+  console.log("issuer: ", issuer);
+  if (issuer && _path.default.isAbsolute(issuer)) {
+    return _module.default.createRequire(issuer);
+  } else {
+    return _module.default.createRequire(process.cwd());
+  }
+};
+const resolveModule = (id) => {
+  const exprs = typeof id === "string" ? id.split(">") : id;
+  if (!exprs.length)
+    return null;
+  const _require = getRequire();
+  let resolved = process.cwd();
+  for (const id2 of exprs) {
+    if (_path.default.isAbsolute(id2)) {
+      resolved = id2;
+      continue;
+    }
+    try {
+      resolved = _require.resolve(id2, {
+        paths: [
+          resolved
+        ]
+      });
+    } catch (e) {
+      if (e.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
+        const expr = id2.replace(/.+\/node_modules\//, "");
+        const pkgName = expr.startsWith("@") ? expr.split("/").slice(0, 2).join("/") : expr.split("/")[0];
+        const resolvedMain = resolveModule([
+          resolved,
+          pkgName
+        ]);
+        (0, _assert.default)(resolvedMain);
+        const resolveDir = `${resolvedMain.slice(0, resolvedMain.lastIndexOf(`/node_modules/${pkgName}`) + 1)}/node_modules/${pkgName}`;
+        const subpath = expr.replace(pkgName, ".");
+        return resolveModule(_path.default.resolve(resolveDir, subpath));
+      }
+      const stackText = JSON.stringify(exprs, null, 2);
+      const err = new Error(`Failed to resolve "${id2}" from "${resolved}": ${stackText}`);
+      err.cause = e;
+      throw err;
+    }
+  }
+  return resolved;
+};
+const requireModule = (id) => {
+  const resolved = resolveModule(id);
+  if (!resolved) {
+    throw new Error(`Can't resolve package ${id}.`);
+  }
+  const _require = getRequire();
+  return _require(resolved);
+};

package/dist/utils/socket.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import WebSocket from 'ws';
+import { BufferLike } from '../types';
+export interface SendMessageOptions {
+  mask?: boolean | undefined;
+  binary?: boolean | undefined;
+  compress?: boolean | undefined;
+  fin?: boolean | undefined;
+}
+export type ServerOptions<U extends typeof WebSocket.WebSocket = typeof WebSocket.WebSocket, V extends typeof IncomingMessage = typeof IncomingMessage> = WebSocket.Server<U, V>['options'];
+export declare class SocketServer<T extends typeof WebSocket.WebSocket = typeof WebSocket.WebSocket, U extends typeof IncomingMessage = typeof IncomingMessage> extends WebSocket.Server<T, U> {
+  constructor(options?: ServerOptions<T, U>, callback?: () => void);
+  handleHeartbeat(timeout?: number): void;
+  broadcast(data: BufferLike, cb?: (err?: Error) => void): void;
+  broadcast(data: BufferLike, options: SendMessageOptions, cb?: (err?: Error) => void): void;
+}

package/dist/utils/socket.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SocketServer", {
+  enumerable: true,
+  get: function() {
+    return SocketServer;
+  }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _ws = /* @__PURE__ */ _interop_require_default._(require("ws"));
+class SocketServer extends _ws.default.Server {
+  handleHeartbeat(timeout = 3e4) {
+    const aliveMapping = /* @__PURE__ */ new WeakMap();
+    function heartbeat() {
+      aliveMapping.set(this, true);
+    }
+    this.on("connection", (ws) => {
+      aliveMapping.delete(ws);
+      ws.on("error", console.error);
+      ws.on("pong", heartbeat);
+    });
+    const interval = setInterval(() => {
+      this.clients.forEach((ws) => {
+        const mark = aliveMapping.get(ws);
+        if (mark) {
+          aliveMapping.delete(ws);
+          ws.ping();
+        } else {
+          ws.terminate();
+        }
+      });
+    }, timeout);
+    this.on("close", () => {
+      clearInterval(interval);
+    });
+  }
+  broadcast(data, optsOrCb, cbOrNone) {
+    const opts = typeof optsOrCb === "function" ? {} : optsOrCb;
+    const cb = typeof optsOrCb === "function" ? optsOrCb : cbOrNone;
+    this.clients.forEach((client) => client.readyState === _ws.default.OPEN && client.send(data, opts !== null && opts !== void 0 ? opts : {}, cb));
+  }
+  constructor(options, callback) {
+    super(options, callback);
+    this.handleHeartbeat();
+  }
+}

package/package.json

@@ -15,43 +15,54 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.33.1",
+  "version": "2.35.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
   "exports": {
     ".": {
       "node": {
         "jsnext:source": "./src/index.ts",
-        "require": "./dist/cjs/index.js"
+        "require": "./dist/index.js"
       },
-      "default": "./dist/cjs/index.js"
+      "default": "./dist/index.js"
     },
     "./cli": {
       "jsnext:source": "./src/cli.ts",
-      "default": "./dist/cjs/cli.js"
+      "default": "./dist/cli.js"
+    },
+    "./runtime": {
+      "jsnext:source": "./src/runtime.ts",
+      "default": "./dist/runtime.js"
     }
   },
   "dependencies": {
-    "@modern-js/devtools-client": "2.33.1",
-    "@modern-js/devtools-mount": "2.33.1",
-    "@modern-js/utils": "2.33.1"
+    "birpc": "0.2.13",
+    "p-defer": "^3.0.0",
+    "ws": "8.13.0",
+    "@modern-js/devtools-kit": "2.35.0",
+    "@modern-js/devtools-mount": "2.35.0",
+    "@modern-js/utils": "2.35.0"
   },
   "devDependencies": {
     "@swc/helpers": "0.5.1",
     "@types/node": "^14",
+    "@types/ws": "^8.5.5",
     "type-fest": "^4.1.0",
     "typescript": "^5",
-    "@modern-js/app-tools": "2.33.1",
-    "@modern-js/core": "2.33.1",
-    "@modern-js/module-tools": "2.33.1",
-    "@modern-js/runtime": "2.33.1",
-    "@modern-js/types": "2.33.1",
-    "@scripts/build": "2.33.1"
+    "@modern-js/app-tools": "2.35.0",
+    "@modern-js/core": "2.35.0",
+    "@modern-js/module-tools": "2.35.0",
+    "@modern-js/runtime": "2.35.0",
+    "@modern-js/server-core": "2.35.0",
+    "@modern-js/types": "2.35.0",
+    "@modern-js/builder-webpack-provider": "2.35.0",
+    "@modern-js/builder-rspack-provider": "2.35.0",
+    "@modern-js/builder-shared": "2.35.0",
+    "@scripts/build": "2.35.0"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "^2.33.1"
+    "@modern-js/runtime": "^2.35.0"
   },
   "peerDependenciesMeta": {
     "@modern-js/runtime": {

package/dist/cjs/cli.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
-  for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  devtoolsPlugin: function() {
-    return devtoolsPlugin;
-  },
-  default: function() {
-    return _default;
-  }
-});
-const devtoolsPlugin = () => ({
-  name: "@modern-js/plugin-devtools",
-  usePlugins: [],
-  setup: async (_api) => {
-    return {
-      // prepare() {},
-      validateSchema() {
-        return [
-          {
-            target: "tools.devtools",
-            schema: {
-              typeof: [
-                "boolean"
-              ]
-            }
-          }
-        ];
-      },
-      config() {
-        const setupDevtoolsScript = require.resolve("@modern-js/devtools-mount");
-        return {
-          source: {
-            preEntry: [
-              `data:application/javascript,
-                import { mountDevTools } from "${setupDevtoolsScript}";
-                mountDevTools();
-              `.replace(/\n */g, "")
-            ]
-          }
-        };
-      }
-    };
-  }
-});
-const _default = devtoolsPlugin;

package/dist/esm/cli.js

@@ -1,46 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-export var devtoolsPlugin = function() {
-  return {
-    name: "@modern-js/plugin-devtools",
-    usePlugins: [],
-    setup: function() {
-      var _ref = _async_to_generator(function(_api) {
-        return _ts_generator(this, function(_state) {
-          return [
-            2,
-            {
-              // prepare() {},
-              validateSchema: function validateSchema() {
-                return [
-                  {
-                    target: "tools.devtools",
-                    schema: {
-                      typeof: [
-                        "boolean"
-                      ]
-                    }
-                  }
-                ];
-              },
-              config: function config() {
-                var setupDevtoolsScript = require.resolve("@modern-js/devtools-mount");
-                return {
-                  source: {
-                    preEntry: [
-                      'data:application/javascript,\n                import { mountDevTools } from "'.concat(setupDevtoolsScript, '";\n                mountDevTools();\n              ').replace(/\n */g, "")
-                    ]
-                  }
-                };
-              }
-            }
-          ];
-        });
-      });
-      return function(_api) {
-        return _ref.apply(this, arguments);
-      };
-    }()
-  };
-};
-export default devtoolsPlugin;

package/dist/esm/index.js

@@ -1,3 +0,0 @@
-import { devtoolsPlugin } from "./cli";
-export { devtoolsPlugin };
-export default devtoolsPlugin;

package/dist/esm-node/cli.js

@@ -1,35 +0,0 @@
-export const devtoolsPlugin = () => ({
-  name: "@modern-js/plugin-devtools",
-  usePlugins: [],
-  setup: async (_api) => {
-    return {
-      // prepare() {},
-      validateSchema() {
-        return [
-          {
-            target: "tools.devtools",
-            schema: {
-              typeof: [
-                "boolean"
-              ]
-            }
-          }
-        ];
-      },
-      config() {
-        const setupDevtoolsScript = require.resolve("@modern-js/devtools-mount");
-        return {
-          source: {
-            preEntry: [
-              `data:application/javascript,
-                import { mountDevTools } from "${setupDevtoolsScript}";
-                mountDevTools();
-              `.replace(/\n */g, "")
-            ]
-          }
-        };
-      }
-    };
-  }
-});
-export default devtoolsPlugin;

package/dist/esm-node/index.js

@@ -1,3 +0,0 @@
-import { devtoolsPlugin } from "./cli";
-export { devtoolsPlugin };
-export default devtoolsPlugin;

package/dist/types/cli.d.ts

@@ -1,7 +0,0 @@
-import type { AppTools, CliPlugin } from '@modern-js/app-tools';
-export interface Options {
-  dataSource?: string;
-  version?: string;
-}
-export declare const devtoolsPlugin: () => CliPlugin<AppTools>;
-export default devtoolsPlugin;