@modern-js/plugin-worker 0.0.0-next-20230206081248

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @modern-js/plugin-worker
+
+## 0.0.0-next-20230206081248
+
+### Patch Changes
+
+- Updated dependencies [98a2733ac]
+- Updated dependencies [8c2db5f82]
+  - @modern-js/utils@0.0.0-next-20230206081248
+  - @modern-js/server-utils@0.0.0-next-20230206081248

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+<p align="center">
+现代 Web 工程体系
+  <br/>
+  <a href="https://modernjs.dev" target="blank">
+    modernjs.dev
+  </a>
+</p>
+<p align="center">
+  The meta-framework suite designed from scratch for frontend-focused modern web development
+</p>
+
+# Introduction
+
+> The doc site ([modernjs.dev](https://modernjs.dev)) and articles are only available in Chinese for now, we are planning to add English versions soon.
+
+- [Modern.js: Hello, World!](https://zhuanlan.zhihu.com/p/426707646)
+
+## Getting Started
+
+- [Quick Start](https://modernjs.dev/docs/start)
+- [Guides](https://modernjs.dev/docs/guides)
+- [API References](https://modernjs.dev/docs/apis)
+
+## Contributing
+
+- [Contributing Guide](https://github.com/modern-js-dev/modern.js/blob/main/CONTRIBUTING.md)

package/dist/js/modern/code.js

@@ -0,0 +1,22 @@
+const worker = () => `
+// work entry code
+import { createHandler, handleUrl } from "@modern-js/prod-server/worker";
+import { manifest } from "./manifest";
+async function handleRequest(request) {
+  const context = {
+    request,
+    url: handleUrl(request.url),
+    body: null,
+  };
+  const handler = createHandler(manifest);
+  await handler(context);
+  return new Response(context.body);
+}
+
+addEventListener("fetch", (event) => {
+  event.respondWith(handleRequest(event.request));
+});
+`;
+export {
+  worker
+};

package/dist/js/modern/constants.js

@@ -0,0 +1,18 @@
+const WORKER_SERVER = "worker-server";
+const WORKER_SERVER_ENTRY = "index.js";
+const MANIFEST_FILE = "manifest.js";
+const PKG_FILE = "package.json";
+const LOCK_FILE = {
+  yarn: "yarn.lock",
+  npm: "package-lock.json",
+  pnpm: "pnpm-lock.yaml"
+};
+const WRANGLER_FILE = "wrangler.toml";
+export {
+  LOCK_FILE,
+  MANIFEST_FILE,
+  PKG_FILE,
+  WORKER_SERVER,
+  WORKER_SERVER_ENTRY,
+  WRANGLER_FILE
+};

package/dist/js/modern/index.js

@@ -0,0 +1,120 @@
+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());
+  });
+};
+import path from "path";
+import {
+  fs,
+  getPackageManager,
+  isWorker,
+  ROUTE_SPEC_FILE
+} from "@modern-js/utils";
+import {
+  LOCK_FILE,
+  MANIFEST_FILE,
+  PKG_FILE,
+  WORKER_SERVER,
+  WORKER_SERVER_ENTRY,
+  WRANGLER_FILE
+} from "./constants";
+import { worker } from "./code";
+import { copyfile } from "./utils";
+var src_default = () => ({
+  name: "@modern-js/plugin-worker",
+  setup: (ctx) => {
+    return {
+      beforeDeploy() {
+        return __async(this, null, function* () {
+          const { appDirectory, distDirectory } = ctx.useAppContext();
+          const configContext = ctx.useResolvedConfigContext();
+          if (!isWorker(configContext)) {
+            return;
+          }
+          const workServerDir = path.join(distDirectory, WORKER_SERVER);
+          fs.removeSync(workServerDir);
+          fs.mkdirSync(workServerDir);
+          fs.writeFileSync(
+            path.join(workServerDir, WORKER_SERVER_ENTRY),
+            worker()
+          );
+          const routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
+          const { routes } = fs.readJSONSync(routeJSON);
+          let importStr = ``;
+          let pageStr = ``;
+          const routeArr = [];
+          routes.forEach(
+            (route) => {
+              importStr += `import { serverRender as ${route.entryName}ServerRender } from "../${route.bundle}";
+`;
+              pageStr += `"${route.urlPath}": {
+      entryName: "${route.entryName}",
+      template: "${route.entryPath}",
+      serverRender: ${route.entryName}ServerRender,
+    },`;
+              routeArr.push({
+                entryName: route.entryName,
+                isSSR: route.isSSR,
+                urlPath: route.urlPath
+              });
+            }
+          );
+          const manifest = `
+${importStr}
+
+export const manifest = {
+  pages: {
+    ${pageStr}
+  },
+  routes: ${JSON.stringify(routeArr, null, "   ")}
+}
+        `;
+          fs.writeFileSync(path.join(workServerDir, MANIFEST_FILE), manifest);
+          const pkg = fs.readJSONSync(path.join(appDirectory, PKG_FILE));
+          yield fs.writeJSON(
+            path.join(distDirectory, PKG_FILE),
+            {
+              name: pkg.name,
+              version: pkg.version,
+              dependencies: {
+                "@modern-js/prod-server": "0.0.0-next-20230203070739",
+                wrangler: "^2.9.0"
+              },
+              resolutions: pkg.resolutions || {},
+              pnpm: pkg.pnpm || {}
+            },
+            { spaces: 2 }
+          );
+          const manager = yield getPackageManager(appDirectory);
+          const lockfile = LOCK_FILE[manager];
+          copyfile(distDirectory, appDirectory, [lockfile]);
+          fs.writeFileSync(
+            path.join(distDirectory, WRANGLER_FILE),
+            `name = "${pkg.name}"
+main = "${path.join(WORKER_SERVER, WORKER_SERVER_ENTRY)}"
+compatibility_date = "${new Date()}"
+        `
+          );
+        });
+      }
+    };
+  }
+});
+export {
+  src_default as default
+};

package/dist/js/modern/utils.js

@@ -0,0 +1,30 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+const copyfile = (target, source, fl) => {
+  fl.forEach((ff) => {
+    if (!ff) {
+      return;
+    }
+    if (typeof ff === "string") {
+      cpfile(target, source, ff);
+      return;
+    }
+    const sourceIncludeFiles = fs.readdirSync(source);
+    for (const filename of sourceIncludeFiles) {
+      if (ff.test(filename)) {
+        cpfile(target, source, filename);
+      }
+    }
+  });
+  function cpfile(target2, source2, filename) {
+    const filepath = path.join(source2, filename);
+    if (!fs.existsSync(filepath)) {
+      return;
+    }
+    const targetPath = path.join(target2, filename);
+    fs.copySync(filepath, targetPath);
+  }
+};
+export {
+  copyfile
+};

package/dist/js/node/code.js

@@ -0,0 +1,45 @@
+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 code_exports = {};
+__export(code_exports, {
+  worker: () => worker
+});
+module.exports = __toCommonJS(code_exports);
+const worker = () => `
+// work entry code
+import { createHandler, handleUrl } from "@modern-js/prod-server/worker";
+import { manifest } from "./manifest";
+async function handleRequest(request) {
+  const context = {
+    request,
+    url: handleUrl(request.url),
+    body: null,
+  };
+  const handler = createHandler(manifest);
+  await handler(context);
+  return new Response(context.body);
+}
+
+addEventListener("fetch", (event) => {
+  event.respondWith(handleRequest(event.request));
+});
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  worker
+});

package/dist/js/node/constants.js

@@ -0,0 +1,46 @@
+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 constants_exports = {};
+__export(constants_exports, {
+  LOCK_FILE: () => LOCK_FILE,
+  MANIFEST_FILE: () => MANIFEST_FILE,
+  PKG_FILE: () => PKG_FILE,
+  WORKER_SERVER: () => WORKER_SERVER,
+  WORKER_SERVER_ENTRY: () => WORKER_SERVER_ENTRY,
+  WRANGLER_FILE: () => WRANGLER_FILE
+});
+module.exports = __toCommonJS(constants_exports);
+const WORKER_SERVER = "worker-server";
+const WORKER_SERVER_ENTRY = "index.js";
+const MANIFEST_FILE = "manifest.js";
+const PKG_FILE = "package.json";
+const LOCK_FILE = {
+  yarn: "yarn.lock",
+  npm: "package-lock.json",
+  pnpm: "pnpm-lock.yaml"
+};
+const WRANGLER_FILE = "wrangler.toml";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOCK_FILE,
+  MANIFEST_FILE,
+  PKG_FILE,
+  WORKER_SERVER,
+  WORKER_SERVER_ENTRY,
+  WRANGLER_FILE
+});

package/dist/js/node/index.js

@@ -0,0 +1,135 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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());
+  });
+};
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+var import_code = require("./code");
+var import_utils2 = require("./utils");
+var src_default = () => ({
+  name: "@modern-js/plugin-worker",
+  setup: (ctx) => {
+    return {
+      beforeDeploy() {
+        return __async(this, null, function* () {
+          const { appDirectory, distDirectory } = ctx.useAppContext();
+          const configContext = ctx.useResolvedConfigContext();
+          if (!(0, import_utils.isWorker)(configContext)) {
+            return;
+          }
+          const workServerDir = import_path.default.join(distDirectory, import_constants.WORKER_SERVER);
+          import_utils.fs.removeSync(workServerDir);
+          import_utils.fs.mkdirSync(workServerDir);
+          import_utils.fs.writeFileSync(
+            import_path.default.join(workServerDir, import_constants.WORKER_SERVER_ENTRY),
+            (0, import_code.worker)()
+          );
+          const routeJSON = import_path.default.join(distDirectory, import_utils.ROUTE_SPEC_FILE);
+          const { routes } = import_utils.fs.readJSONSync(routeJSON);
+          let importStr = ``;
+          let pageStr = ``;
+          const routeArr = [];
+          routes.forEach(
+            (route) => {
+              importStr += `import { serverRender as ${route.entryName}ServerRender } from "../${route.bundle}";
+`;
+              pageStr += `"${route.urlPath}": {
+      entryName: "${route.entryName}",
+      template: "${route.entryPath}",
+      serverRender: ${route.entryName}ServerRender,
+    },`;
+              routeArr.push({
+                entryName: route.entryName,
+                isSSR: route.isSSR,
+                urlPath: route.urlPath
+              });
+            }
+          );
+          const manifest = `
+${importStr}
+
+export const manifest = {
+  pages: {
+    ${pageStr}
+  },
+  routes: ${JSON.stringify(routeArr, null, "   ")}
+}
+        `;
+          import_utils.fs.writeFileSync(import_path.default.join(workServerDir, import_constants.MANIFEST_FILE), manifest);
+          const pkg = import_utils.fs.readJSONSync(import_path.default.join(appDirectory, import_constants.PKG_FILE));
+          yield import_utils.fs.writeJSON(
+            import_path.default.join(distDirectory, import_constants.PKG_FILE),
+            {
+              name: pkg.name,
+              version: pkg.version,
+              dependencies: {
+                "@modern-js/prod-server": "0.0.0-next-20230203070739",
+                wrangler: "^2.9.0"
+              },
+              resolutions: pkg.resolutions || {},
+              pnpm: pkg.pnpm || {}
+            },
+            { spaces: 2 }
+          );
+          const manager = yield (0, import_utils.getPackageManager)(appDirectory);
+          const lockfile = import_constants.LOCK_FILE[manager];
+          (0, import_utils2.copyfile)(distDirectory, appDirectory, [lockfile]);
+          import_utils.fs.writeFileSync(
+            import_path.default.join(distDirectory, import_constants.WRANGLER_FILE),
+            `name = "${pkg.name}"
+main = "${import_path.default.join(import_constants.WORKER_SERVER, import_constants.WORKER_SERVER_ENTRY)}"
+compatibility_date = "${new Date()}"
+        `
+          );
+        });
+      }
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/js/node/utils.js

@@ -0,0 +1,59 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  copyfile: () => copyfile
+});
+module.exports = __toCommonJS(utils_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const copyfile = (target, source, fl) => {
+  fl.forEach((ff) => {
+    if (!ff) {
+      return;
+    }
+    if (typeof ff === "string") {
+      cpfile(target, source, ff);
+      return;
+    }
+    const sourceIncludeFiles = import_utils.fs.readdirSync(source);
+    for (const filename of sourceIncludeFiles) {
+      if (ff.test(filename)) {
+        cpfile(target, source, filename);
+      }
+    }
+  });
+  function cpfile(target2, source2, filename) {
+    const filepath = import_path.default.join(source2, filename);
+    if (!import_utils.fs.existsSync(filepath)) {
+      return;
+    }
+    const targetPath = import_path.default.join(target2, filename);
+    import_utils.fs.copySync(filepath, targetPath);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyfile
+});

package/dist/js/treeshaking/code.js

@@ -0,0 +1,4 @@
+var worker = function() {
+    return '\n// work entry code\nimport { createHandler, handleUrl } from "@modern-js/prod-server/worker";\nimport { manifest } from "./manifest";\nasync function handleRequest(request) {\n  const context = {\n    request,\n    url: handleUrl(request.url),\n    body: null,\n  };\n  const handler = createHandler(manifest);\n  await handler(context);\n  return new Response(context.body);\n}\n\naddEventListener("fetch", (event) => {\n  event.respondWith(handleRequest(event.request));\n});\n';
+};
+export { worker };

package/dist/js/treeshaking/constants.js

@@ -0,0 +1,11 @@
+var WORKER_SERVER = "worker-server";
+var WORKER_SERVER_ENTRY = "index.js";
+var MANIFEST_FILE = "manifest.js";
+var PKG_FILE = "package.json";
+var LOCK_FILE = {
+    yarn: "yarn.lock",
+    npm: "package-lock.json",
+    pnpm: "pnpm-lock.yaml"
+};
+var WRANGLER_FILE = "wrangler.toml";
+export { LOCK_FILE, MANIFEST_FILE, PKG_FILE, WORKER_SERVER, WORKER_SERVER_ENTRY, WRANGLER_FILE };

package/dist/js/treeshaking/index.js

@@ -0,0 +1,208 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+import path from "path";
+import { fs, getPackageManager, isWorker, ROUTE_SPEC_FILE } from "@modern-js/utils";
+import { LOCK_FILE, MANIFEST_FILE, PKG_FILE, WORKER_SERVER, WORKER_SERVER_ENTRY, WRANGLER_FILE } from "./constants";
+import { worker } from "./code";
+import { copyfile } from "./utils";
+var src_default = function() {
+    return {
+        name: "@modern-js/plugin-worker",
+        setup: function(ctx) {
+            return {
+                beforeDeploy: function beforeDeploy() {
+                    return _asyncToGenerator(function() {
+                        var _ctx_useAppContext, appDirectory, distDirectory, configContext, workServerDir, routeJSON, routes, importStr, pageStr, routeArr, manifest, pkg, manager, lockfile;
+                        return __generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _ctx_useAppContext = ctx.useAppContext(), appDirectory = _ctx_useAppContext.appDirectory, distDirectory = _ctx_useAppContext.distDirectory;
+                                    configContext = ctx.useResolvedConfigContext();
+                                    if (!isWorker(configContext)) {
+                                        return [
+                                            2
+                                        ];
+                                    }
+                                    workServerDir = path.join(distDirectory, WORKER_SERVER);
+                                    fs.removeSync(workServerDir);
+                                    fs.mkdirSync(workServerDir);
+                                    fs.writeFileSync(path.join(workServerDir, WORKER_SERVER_ENTRY), worker());
+                                    routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
+                                    routes = fs.readJSONSync(routeJSON).routes;
+                                    importStr = "";
+                                    pageStr = "";
+                                    routeArr = [];
+                                    routes.forEach(function(route) {
+                                        importStr += "import { serverRender as ".concat(route.entryName, 'ServerRender } from "../').concat(route.bundle, '";\n');
+                                        pageStr += '"'.concat(route.urlPath, '": {\n      entryName: "').concat(route.entryName, '",\n      template: "').concat(route.entryPath, '",\n      serverRender: ').concat(route.entryName, "ServerRender,\n    },");
+                                        routeArr.push({
+                                            entryName: route.entryName,
+                                            isSSR: route.isSSR,
+                                            urlPath: route.urlPath
+                                        });
+                                    });
+                                    manifest = "\n".concat(importStr, "\n\nexport const manifest = {\n  pages: {\n    ").concat(pageStr, "\n  },\n  routes: ").concat(JSON.stringify(routeArr, null, "   "), "\n}\n        ");
+                                    fs.writeFileSync(path.join(workServerDir, MANIFEST_FILE), manifest);
+                                    pkg = fs.readJSONSync(path.join(appDirectory, PKG_FILE));
+                                    return [
+                                        4,
+                                        fs.writeJSON(path.join(distDirectory, PKG_FILE), {
+                                            name: pkg.name,
+                                            version: pkg.version,
+                                            dependencies: {
+                                                "@modern-js/prod-server": "0.0.0-next-20230203070739",
+                                                wrangler: "^2.9.0"
+                                            },
+                                            resolutions: pkg.resolutions || {},
+                                            pnpm: pkg.pnpm || {}
+                                        }, {
+                                            spaces: 2
+                                        })
+                                    ];
+                                case 1:
+                                    _state.sent();
+                                    return [
+                                        4,
+                                        getPackageManager(appDirectory)
+                                    ];
+                                case 2:
+                                    manager = _state.sent();
+                                    lockfile = LOCK_FILE[manager];
+                                    copyfile(distDirectory, appDirectory, [
+                                        lockfile
+                                    ]);
+                                    fs.writeFileSync(path.join(distDirectory, WRANGLER_FILE), 'name = "'.concat(pkg.name, '"\nmain = "').concat(path.join(WORKER_SERVER, WORKER_SERVER_ENTRY), '"\ncompatibility_date = "').concat(new Date(), '"\n        '));
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
+                }
+            };
+        }
+    };
+};
+export { src_default as default };

package/dist/js/treeshaking/utils.js

@@ -0,0 +1,45 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+var copyfile = function(target, source, fl) {
+    var cpfile = function cpfile(target2, source2, filename) {
+        var filepath = path.join(source2, filename);
+        if (!fs.existsSync(filepath)) {
+            return;
+        }
+        var targetPath = path.join(target2, filename);
+        fs.copySync(filepath, targetPath);
+    };
+    fl.forEach(function(ff) {
+        if (!ff) {
+            return;
+        }
+        if (typeof ff === "string") {
+            cpfile(target, source, ff);
+            return;
+        }
+        var sourceIncludeFiles = fs.readdirSync(source);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = sourceIncludeFiles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var filename = _step.value;
+                if (ff.test(filename)) {
+                    cpfile(target, source, filename);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    });
+};
+export { copyfile };

package/dist/types/code.d.ts

@@ -0,0 +1 @@
+export declare const worker: () => string;

package/dist/types/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const WORKER_SERVER = "worker-server";
+export declare const WORKER_SERVER_ENTRY = "index.js";
+export declare const MANIFEST_FILE = "manifest.js";
+export declare const PKG_FILE = "package.json";
+export declare const LOCK_FILE: Record<string, string>;
+export declare const WRANGLER_FILE = "wrangler.toml";

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+
+declare const _default: () => CliPlugin<AppTools>;
+
+export default _default;

package/dist/types/utils.d.ts

@@ -0,0 +1 @@
+export declare const copyfile: (target: string, source: string, fl: (string | RegExp)[]) => void;

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@modern-js/plugin-worker",
+  "description": "The meta-framework suite designed from scratch for frontend-focused modern web development.",
+  "homepage": "https://modernjs.dev",
+  "bugs": "https://github.com/modern-js-dev/modern.js/issues",
+  "repository": "modern-js-dev/modern.js",
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "0.0.0-next-20230206081248",
+  "types": "./dist/types/cli.d.ts",
+  "jsnext:source": "./src/index.ts",
+  "main": "./dist/js/node/index.js",
+  "exports": {
+    ".": {
+      "jsnext:source": "./src/index.ts",
+      "default": "./dist/js/node/index.js"
+    },
+    "./cli": {
+      "jsnext:source": "./src/index.ts",
+      "default": "./dist/js/node/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/index.d.ts"
+      ],
+      "cli": [
+        "./dist/types/index.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.18.0",
+    "@modern-js/server-utils": "0.0.0-next-20230206081248",
+    "@modern-js/utils": "0.0.0-next-20230206081248"
+  },
+  "devDependencies": {
+    "typescript": "^4",
+    "@types/jest": "^27",
+    "@types/node": "^14",
+    "jest": "^27",
+    "@modern-js/app-tools": "0.0.0-next-20230206081248",
+    "@modern-js/core": "0.0.0-next-20230206081248",
+    "@scripts/build": "0.0.0-next-20230206081248",
+    "@modern-js/types": "0.0.0-next-20230206081248",
+    "@scripts/jest-config": "0.0.0-next-20230206081248"
+  },
+  "sideEffects": [
+    "*.css",
+    "*.less",
+    "*.sass",
+    "*.scss"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "dev": "modern-lib build --watch",
+    "build": "modern-lib build",
+    "new": "modern-lib new",
+    "test": "jest --passWithNoTests"
+  }
+}