@nasti-toolchain/nasti 1.6.1 → 1.6.3

package/dist/index.d.cts

@@ -99,6 +99,12 @@ interface NastiPlugin {
     }) => boolean);
     buildStart?: (this: PluginContext) => void | Promise<void>;
     buildEnd?: (this: PluginContext, error?: Error) => void | Promise<void>;
+    /**
+     * Called once after `bundle.close()` in production builds, mirroring Rollup/Vite semantics.
+     * Plugins use this to emit final-stage artifacts that depend on the bundle being fully written
+     * (PWA manifests, service workers, sitemaps, etc.). Not invoked in dev.
+     */
+    closeBundle?: (this: PluginContext, error?: Error) => void | Promise<void>;
     resolveId?: (this: PluginContext, source: string, importer: string | undefined, options: ResolveIdOptions) => ResolveIdResult | Promise<ResolveIdResult>;
     load?: (this: PluginContext, id: string) => LoadResult | Promise<LoadResult>;
     transform?: (this: PluginContext, code: string, id: string) => TransformResult | Promise<TransformResult>;

package/dist/index.d.ts

@@ -99,6 +99,12 @@ interface NastiPlugin {
     }) => boolean);
     buildStart?: (this: PluginContext) => void | Promise<void>;
     buildEnd?: (this: PluginContext, error?: Error) => void | Promise<void>;
+    /**
+     * Called once after `bundle.close()` in production builds, mirroring Rollup/Vite semantics.
+     * Plugins use this to emit final-stage artifacts that depend on the bundle being fully written
+     * (PWA manifests, service workers, sitemaps, etc.). Not invoked in dev.
+     */
+    closeBundle?: (this: PluginContext, error?: Error) => void | Promise<void>;
     resolveId?: (this: PluginContext, source: string, importer: string | undefined, options: ResolveIdOptions) => ResolveIdResult | Promise<ResolveIdResult>;
     load?: (this: PluginContext, id: string) => LoadResult | Promise<LoadResult>;
     transform?: (this: PluginContext, code: string, id: string) => TransformResult | Promise<TransformResult>;

package/dist/index.js

@@ -793,7 +793,7 @@ import pc from "picocolors";
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.6.1"}`));
+  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.6.3"}`));
   console.log(pc.dim(`  root: ${config.root}`));
   console.log(pc.dim(`  mode: ${config.mode}`));
   const outDir = path7.resolve(config.root, config.build.outDir);
@@ -859,7 +859,11 @@ async function build(inlineConfig = {}) {
         load: p.load,
         transform: p.transform,
         buildStart: p.buildStart,
-        buildEnd: p.buildEnd
+        buildEnd: p.buildEnd,
+        // Forward `closeBundle` to Rolldown — it invokes the hook during
+        // `bundle.close()` below. This is the hook Vite plugins (e.g. PWA
+        // manifest/SW writers) rely on for final-stage artifact emission.
+        closeBundle: p.closeBundle
       }))
     ],
     ...config.build.rolldownOptions
@@ -989,6 +993,19 @@ var init_module_graph = __esm({
         }
         mods.add(mod);
       }
+      /**
+       * Reindex a module under a plugin-provided canonical id (e.g. a `\0virtual:foo`
+       * id returned from `resolveId`). Plugins look up their own virtual modules via
+       * `getModuleById(RESOLVED_ID)` to invalidate them on watcher events; without
+       * this remap they'd never find the node because `ensureEntryFromUrl` keys by
+       * the public URL only.
+       */
+      setModuleId(mod, id) {
+        if (mod.id === id) return;
+        this.idToModuleMap.delete(mod.id);
+        mod.id = id;
+        this.idToModuleMap.set(id, mod);
+      }
       /** 更新模块依赖关系 */
       updateModuleImports(mod, importedIds) {
         for (const imported of mod.importedModules) {
@@ -1104,7 +1121,7 @@ __export(middleware_exports, {
 import path9 from "path";
 import fs8 from "fs";
 import { createRequire as createRequire2 } from "module";
-import { fileURLToPath } from "url";
+import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
 function getReactRefreshRuntimeEsm() {
   if (__refreshRuntimeCache) return __refreshRuntimeCache;
   let cjsPath;
@@ -1259,6 +1276,16 @@ async function transformRequest(url, ctx) {
   if (cleanReqUrl === "/@react-refresh") {
     return { code: getReactRefreshRuntimeEsm() };
   }
+  if (cleanReqUrl.startsWith("/@modules/")) {
+    const spec = cleanReqUrl.slice("/@modules/".length);
+    const virtual = await loadVirtualModule(spec, ctx);
+    if (virtual) {
+      const mod2 = await moduleGraph.ensureEntryFromUrl(url);
+      moduleGraph.setModuleId(mod2, virtual.id);
+      mod2.transformResult = virtual.result;
+      return virtual.result;
+    }
+  }
   const filePath = resolveUrlToFile(url, config.root);
   if (!filePath || !fs8.existsSync(filePath)) return null;
   const mod = await moduleGraph.ensureEntryFromUrl(url);
@@ -1305,6 +1332,28 @@ async function transformRequest(url, ctx) {
   mod.transformResult = transformResult;
   return transformResult;
 }
+async function loadVirtualModule(spec, ctx) {
+  const { config, pluginContainer } = ctx;
+  const resolved = await pluginContainer.resolveId(spec);
+  if (resolved == null) return null;
+  const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
+  const looksVirtual = resolvedId.startsWith("\0") || !fs8.existsSync(resolvedId);
+  if (!looksVirtual) return null;
+  const loadResult = await pluginContainer.load(resolvedId);
+  if (loadResult == null) return null;
+  let code = typeof loadResult === "string" ? loadResult : loadResult.code;
+  const transformed = await pluginContainer.transform(code, resolvedId);
+  if (transformed != null) {
+    code = typeof transformed === "string" ? transformed : transformed.code;
+  }
+  code = replaceEnvInCode(code, ctx.envDefine ?? buildEnvDefine(
+    loadEnv(config.mode, config.root, config.envPrefix),
+    config.mode
+  ));
+  const anchor = path9.join(config.root, "__nasti_virtual__.ts");
+  code = rewriteImports(code, config, anchor);
+  return { id: resolvedId, result: { code } };
+}
 async function bundlePackageAsEsm(entryFile) {
   if (!esmBundleCache.has(entryFile)) {
     esmBundleCache.set(entryFile, doBundlePackage(entryFile));
@@ -1312,6 +1361,8 @@ async function bundlePackageAsEsm(entryFile) {
   return esmBundleCache.get(entryFile);
 }
 async function doBundlePackage(entryFile) {
+  const shim = await tryGenerateSubpathShim(entryFile);
+  if (shim != null) return shim;
   const { rolldown: rolldown4 } = await import("rolldown");
   const bundle = await rolldown4({
     input: entryFile,
@@ -1341,6 +1392,103 @@ async function doBundlePackage(entryFile) {
   }
   return code;
 }
+async function tryGenerateSubpathShim(entryFile) {
+  const NM = `${path9.sep}node_modules${path9.sep}`;
+  if (!entryFile.includes(NM)) return null;
+  let pkgDir = null;
+  let pkgName = null;
+  let dir = path9.dirname(entryFile);
+  while (true) {
+    const pkgJsonPath = path9.join(dir, "package.json");
+    if (fs8.existsSync(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+        if (typeof pkg?.name === "string" && pkg.name) {
+          pkgDir = dir;
+          pkgName = pkg.name;
+          break;
+        }
+      } catch {
+      }
+    }
+    const parent = path9.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+    if (!dir.includes(NM)) return null;
+  }
+  if (!pkgDir || !pkgName) return null;
+  const entryExt = path9.extname(entryFile);
+  const mainEntry = pickMainEntryByExtension(pkgDir, entryExt);
+  if (!mainEntry) return null;
+  if (path9.resolve(mainEntry) === path9.resolve(entryFile)) return null;
+  let mainNs;
+  let subNs;
+  try {
+    mainNs = await import(pathToFileURL2(mainEntry).href);
+    subNs = await import(pathToFileURL2(entryFile).href);
+  } catch {
+    return null;
+  }
+  if (!mainNs || typeof mainNs !== "object") return null;
+  if (!subNs || typeof subNs !== "object") return null;
+  const subKeys = Object.keys(subNs).filter(
+    (k) => k !== "__esModule" && k !== "default" && VALID_IDENT.test(k)
+  );
+  if (subKeys.length === 0) return null;
+  for (const k of subKeys) {
+    if (!(k in mainNs)) return null;
+    if (mainNs[k] !== subNs[k]) return null;
+  }
+  if ("default" in subNs) {
+    if (!("default" in mainNs)) return null;
+    if (mainNs["default"] !== subNs["default"]) return null;
+  }
+  const lines = [
+    `// Nasti subpath shim \u2192 ${pkgName} (avoid duplicate bundling)`,
+    `import * as __pkg from "/@modules/${pkgName}";`
+  ];
+  for (const k of subKeys) {
+    lines.push(`export const ${k} = __pkg[${JSON.stringify(k)}];`);
+  }
+  if ("default" in subNs) {
+    lines.push(`export default ("default" in __pkg ? __pkg["default"] : __pkg);`);
+  }
+  return lines.join("\n") + "\n";
+}
+function pickMainEntryByExtension(pkgDir, preferredExt) {
+  const pkgJsonPath = path9.join(pkgDir, "package.json");
+  let pkg;
+  try {
+    pkg = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  const candidates = [];
+  const collectFromExportObject = (obj) => {
+    if (!obj || typeof obj !== "object") return;
+    for (const cond of ["import", "module", "default", "require", "node"]) {
+      const v = obj[cond];
+      if (typeof v === "string") candidates.push(v);
+      else if (v && typeof v === "object") collectFromExportObject(v);
+    }
+  };
+  const dot = pkg?.exports?.["."];
+  if (typeof dot === "string") candidates.push(dot);
+  else if (dot && typeof dot === "object") collectFromExportObject(dot);
+  if (typeof pkg.module === "string") candidates.push(pkg.module);
+  if (typeof pkg.main === "string") candidates.push(pkg.main);
+  for (const cand of candidates) {
+    if (path9.extname(cand) === preferredExt) {
+      const full = path9.resolve(pkgDir, cand);
+      if (fs8.existsSync(full)) return full;
+    }
+  }
+  for (const cand of candidates) {
+    const full = path9.resolve(pkgDir, cand);
+    if (fs8.existsSync(full)) return full;
+  }
+  return null;
+}
 function rewriteExternalRequires(code) {
   const pkgs = /* @__PURE__ */ new Set();
   const re = /__require\(["']([^"']+)["']\)/g;
@@ -1851,7 +1999,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(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.6.1"}`));
+          console.log(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.6.3"}`));
           console.log();
           console.log(`  ${pc3.green(">")} Local:   ${pc3.cyan(localUrl)}`);
           if (networkUrl) {
@@ -1975,7 +2123,7 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.6.1"}`));
+  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.6.3"}`));
   console.log(pc2.dim(`  root: ${config.root}`));
   console.log(pc2.dim(`  mode: ${config.mode}`));
   console.log(pc2.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
@@ -2122,7 +2270,7 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.6.1"}`));
+  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.6.3"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({ ...rest, target: "electron" });
   await server.listen();