@nasti-toolchain/nasti 1.4.0 → 1.5.0

package/dist/index.cjs

@@ -723,7 +723,7 @@ __export(build_exports, {
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(import_picocolors.default.cyan("\n\u{1F528} nasti build") + import_picocolors.default.dim(` v${"1.4.0"}`));
+  console.log(import_picocolors.default.cyan("\n\u{1F528} nasti build") + import_picocolors.default.dim(` v${"1.5.0"}`));
   console.log(import_picocolors.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors.default.dim(`  mode: ${config.mode}`));
   const outDir = import_node_path7.default.resolve(config.root, config.build.outDir);
@@ -1207,8 +1207,8 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire3 } = await import("module");
-    const req = createRequire3(entryFile);
+    const { createRequire: createRequire4 } = await import("module");
+    const req = createRequire4(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -1599,15 +1599,6 @@ async function createServer(inlineConfig = {}) {
   watcher.on("add", (file) => {
     handleFileChange(file, server);
   });
-  const postMiddlewares = [];
-  for (const plugin of allPlugins) {
-    if (plugin.configureServer) {
-      const result = await plugin.configureServer(server);
-      if (typeof result === "function") {
-        postMiddlewares.push(result);
-      }
-    }
-  }
   server = {
     config: configWithPlugins,
     middlewares: app,
@@ -1626,7 +1617,7 @@ async function createServer(inlineConfig = {}) {
           const localUrl = `http://localhost:${actualPort}`;
           const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}` : null;
           console.log();
-          console.log(import_picocolors3.default.cyan("  nasti dev server") + import_picocolors3.default.dim(` v${"1.4.0"}`));
+          console.log(import_picocolors3.default.cyan("  nasti dev server") + import_picocolors3.default.dim(` v${"1.5.0"}`));
           console.log();
           console.log(`  ${import_picocolors3.default.green(">")} Local:   ${import_picocolors3.default.cyan(localUrl)}`);
           if (networkUrl) {
@@ -1659,6 +1650,16 @@ async function createServer(inlineConfig = {}) {
       httpServer.close();
     }
   };
+  const postMiddlewares = [];
+  for (const plugin of allPlugins) {
+    if (plugin.configureServer) {
+      const result = await plugin.configureServer(server);
+      if (typeof result === "function") {
+        postMiddlewares.push(result);
+      }
+    }
+  }
+  for (const run of postMiddlewares) run();
   return server;
 }
 function getNetworkAddress() {
@@ -1704,6 +1705,7 @@ __export(src_exports, {
   createServer: () => createServer,
   defineConfig: () => defineConfig,
   electronPlugin: () => electronPlugin,
+  monacoEditorPlugin: () => monacoEditorPlugin,
   resolveConfig: () => resolveConfig,
   startElectronDev: () => startElectronDev
 });
@@ -1759,7 +1761,7 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(import_picocolors2.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors2.default.dim(` v${"1.4.0"}`));
+  console.log(import_picocolors2.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors2.default.dim(` v${"1.5.0"}`));
   console.log(import_picocolors2.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors2.default.dim(`  mode: ${config.mode}`));
   console.log(import_picocolors2.default.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
@@ -1906,7 +1908,7 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(import_picocolors4.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors4.default.dim(` v${"1.4.0"}`));
+  console.log(import_picocolors4.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors4.default.dim(` v${"1.5.0"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({ ...rest, target: "electron" });
   await server.listen();
@@ -2069,6 +2071,215 @@ function warnElectronVersion(config) {
     );
   }
 }
+
+// src/plugins/monaco-editor.ts
+var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_crypto2 = __toESM(require("crypto"), 1);
+var import_node_module4 = require("module");
+var DEFAULT_WORKERS = {
+  editorWorkerService: "monaco-editor/esm/vs/editor/editor.worker",
+  css: "monaco-editor/esm/vs/language/css/css.worker",
+  html: "monaco-editor/esm/vs/language/html/html.worker",
+  json: "monaco-editor/esm/vs/language/json/json.worker",
+  typescript: "monaco-editor/esm/vs/language/typescript/ts.worker"
+};
+var DEFAULT_PUBLIC_PATH = "monacoeditorwork";
+function isCDN(p) {
+  return /^((https?:)?\/\/|file:)/.test(p);
+}
+function normalizePublicPath(p) {
+  if (isCDN(p)) return p.replace(/\/+$/, "");
+  const withLead = p.startsWith("/") ? p : "/" + p;
+  return withLead.replace(/\/+$/, "") || "/";
+}
+function readMonacoVersion(root) {
+  try {
+    const require2 = (0, import_node_module4.createRequire)(import_node_path13.default.resolve(root, "package.json"));
+    const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
+    const pkg = JSON.parse(import_node_fs11.default.readFileSync(pkgJsonPath, "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function monacoEditorPlugin(options = {}) {
+  const languageWorkers = options.languageWorkers ?? Object.keys(DEFAULT_WORKERS);
+  const customWorkers = options.customWorkers ?? [];
+  const publicPath = normalizePublicPath(options.publicPath ?? DEFAULT_PUBLIC_PATH);
+  const globalAPI = !!options.globalAPI;
+  const forceBuildCDN = !!options.forceBuildCDN;
+  const workers = [
+    ...languageWorkers.map((label) => ({ label, entry: DEFAULT_WORKERS[label] })),
+    ...customWorkers
+  ];
+  let resolvedConfig;
+  let cacheDir = "";
+  const building = /* @__PURE__ */ new Map();
+  async function buildWorker(worker) {
+    const cacheFile = import_node_path13.default.join(cacheDir, `${worker.label}.worker.js`);
+    if (import_node_fs11.default.existsSync(cacheFile)) return cacheFile;
+    const existing = building.get(worker.label);
+    if (existing) return existing;
+    const task = (async () => {
+      const { rolldown: rolldown4 } = await import("rolldown");
+      const require2 = (0, import_node_module4.createRequire)(import_node_path13.default.resolve(resolvedConfig.root, "package.json"));
+      let entry;
+      try {
+        entry = require2.resolve(worker.entry, { paths: [resolvedConfig.root] });
+      } catch {
+        entry = require2.resolve(worker.entry + ".js", { paths: [resolvedConfig.root] });
+      }
+      import_node_fs11.default.mkdirSync(cacheDir, { recursive: true });
+      const bundle = await rolldown4({
+        input: entry,
+        platform: "browser"
+      });
+      await bundle.write({
+        file: cacheFile,
+        format: "iife",
+        sourcemap: false,
+        minify: true,
+        inlineDynamicImports: true
+      });
+      await bundle.close();
+      return cacheFile;
+    })();
+    building.set(worker.label, task);
+    try {
+      return await task;
+    } finally {
+      building.delete(worker.label);
+    }
+  }
+  function runtimeInitScript() {
+    let normalizedPrefix = publicPath;
+    if (!isCDN(publicPath)) {
+      const base = resolvedConfig.base.replace(/\/+$/, "") || "";
+      const pub = publicPath.replace(/^\/+/, "");
+      normalizedPrefix = base ? `${base}/${pub}` : `/${pub}`;
+    }
+    const map = {};
+    for (const w of workers) {
+      map[w.label] = `${normalizedPrefix}/${w.label}.worker.js`;
+    }
+    return `;(function () {
+  var map = ${JSON.stringify(map)};
+  function getWorkerUrl(_moduleId, label) {
+    var url = map[label] || map['editorWorkerService'];
+    if (/^(https?:)?\\/\\//.test(url)) {
+      // \u8DE8\u57DF Worker \u9700\u7528 Blob + importScripts \u7ED5\u8FC7\u540C\u6E90\u9650\u5236
+      var blob = new Blob(
+        ['importScripts(' + JSON.stringify(url) + ');'],
+        { type: 'application/javascript' }
+      );
+      return URL.createObjectURL(blob);
+    }
+    return url;
+  }
+  self.MonacoEnvironment = self.MonacoEnvironment || {};
+  if (!self.MonacoEnvironment.getWorker && !self.MonacoEnvironment.getWorkerUrl) {
+    self.MonacoEnvironment.getWorkerUrl = getWorkerUrl;
+  }
+})();`;
+  }
+  return {
+    name: "nasti:monaco-editor",
+    enforce: "pre",
+    configResolved(config) {
+      resolvedConfig = config;
+      const version = readMonacoVersion(config.root);
+      const key = import_node_crypto2.default.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
+      cacheDir = import_node_path13.default.resolve(config.root, "node_modules/.nasti/monaco", key);
+    },
+    async configureServer(server) {
+      const shouldBuild = !isCDN(publicPath) || forceBuildCDN;
+      const watcher = server.watcher;
+      const monacoDir = import_node_path13.default.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      try {
+        watcher?.unwatch?.(monacoDir);
+      } catch {
+      }
+      if (!shouldBuild) return;
+      void Promise.all(
+        workers.map(
+          (w) => buildWorker(w).catch((e) => {
+            console.warn(
+              `[nasti:monaco-editor] worker build failed for "${w.label}": ${e.message}`
+            );
+          })
+        )
+      );
+      const base = resolvedConfig.base.replace(/\/+$/, "") || "";
+      const pub = publicPath.replace(/^\/+/, "");
+      const prefix = (base ? `${base}/${pub}` : `/${pub}`) + "/";
+      server.middlewares.use(
+        async (req, res, next) => {
+          if (req.method !== "GET") return next();
+          const url = (req.url ?? "").split("?")[0];
+          if (!url.startsWith(prefix)) return next();
+          const name = url.slice(prefix.length).replace(/\.worker\.js$/, "");
+          const worker = workers.find((w) => w.label === name);
+          if (!worker) return next();
+          try {
+            const file = await buildWorker(worker);
+            res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+            res.setHeader("Cache-Control", "public, max-age=604800, immutable");
+            import_node_fs11.default.createReadStream(file).pipe(res);
+          } catch (e) {
+            res.statusCode = 500;
+            res.end(`Monaco worker build failed: ${e.message}`);
+          }
+        }
+      );
+    },
+    transformIndexHtml(html) {
+      const tags = [
+        {
+          tag: "script",
+          children: runtimeInitScript(),
+          injectTo: "head-prepend"
+        }
+      ];
+      if (globalAPI) {
+        tags.push({
+          tag: "script",
+          attrs: { type: "module" },
+          children: `import * as monaco from 'monaco-editor';
+self.monaco = monaco;`,
+          injectTo: "head"
+        });
+      }
+      return { html, tags };
+    },
+    // 生产构建：把所有 Worker 预打包并拷到 outDir/<publicPath>/ 下
+    async buildStart() {
+      if (resolvedConfig.command !== "build") return;
+      if (isCDN(publicPath) && !forceBuildCDN) return;
+      const outDir = options.customDistPath ? options.customDistPath(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir,
+        resolvedConfig.base
+      ) : isCDN(publicPath) ? import_node_path13.default.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : import_node_path13.default.resolve(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir,
+        publicPath.replace(/^\//, "")
+      );
+      import_node_fs11.default.mkdirSync(outDir, { recursive: true });
+      for (const worker of workers) {
+        try {
+          const cacheFile = await buildWorker(worker);
+          import_node_fs11.default.copyFileSync(cacheFile, import_node_path13.default.join(outDir, `${worker.label}.worker.js`));
+        } catch (e) {
+          throw new Error(
+            `[nasti:monaco-editor] worker build failed for "${worker.label}": ${e.message}
+${e.stack || ""}`
+          );
+        }
+      }
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
@@ -2076,6 +2287,7 @@ function warnElectronVersion(config) {
   createServer,
   defineConfig,
   electronPlugin,
+  monacoEditorPlugin,
   resolveConfig,
   startElectronDev
 });