@nasti-toolchain/nasti 1.6.3 → 1.6.4

package/dist/cli.js

@@ -900,9 +900,9 @@ function transformMiddleware(ctx) {
 async function transformRequest(url, ctx) {
   const { config, pluginContainer, moduleGraph } = ctx;
   const cleanReqUrl = url.split("?")[0];
-  const cached = moduleGraph.getModuleByUrl(url);
-  if (cached?.transformResult) {
-    return cached.transformResult;
+  const cached2 = moduleGraph.getModuleByUrl(url);
+  if (cached2?.transformResult) {
+    return cached2.transformResult;
   }
   if (cleanReqUrl === "/@react-refresh") {
     return { code: getReactRefreshRuntimeEsm() };
@@ -1141,19 +1141,20 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire4 } = await import("module");
-    const req = createRequire4(entryFile);
+    const { createRequire: createRequire5 } = await import("module");
+    const req = createRequire5(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
       (k) => k !== "__esModule" && k !== "default" && VALID_IDENT.test(k)
     );
-    if (namedKeys.length === 0) return code;
+    const hasEsmInterop = cjsExports.__esModule === true && "default" in cjsExports;
+    if (!hasEsmInterop && namedKeys.length === 0) return code;
     return code.replace(
       /^export default (\w+\(\));?\s*$/m,
       (_, call) => [
         `const __cjsMod = ${call};`,
-        `export default __cjsMod;`,
+        hasEsmInterop ? `export default __cjsMod.default;` : `export default __cjsMod;`,
         ...namedKeys.map((k) => `export const ${k} = __cjsMod[${JSON.stringify(k)}];`)
       ].join("\n")
     );
@@ -1633,8 +1634,61 @@ var init_resolve = __esm({
   }
 });
 
-// src/plugins/css.ts
+// src/plugins/tailwind.ts
 import path7 from "path";
+import { createRequire as createRequire3 } from "module";
+import { pathToFileURL as pathToFileURL3 } from "url";
+function hasTailwindDirectives(css) {
+  const withoutBlockComments = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const withoutLineComments = withoutBlockComments.replace(/\/\/.*$/gm, "");
+  return TAILWIND_DIRECTIVE_RE.test(withoutLineComments);
+}
+async function loadTailwind(projectRoot) {
+  if (cached && cachedRoot === projectRoot) return cached;
+  const req = createRequire3(path7.join(projectRoot, "package.json"));
+  let nodePath;
+  let oxidePath;
+  try {
+    nodePath = req.resolve("@tailwindcss/node");
+    oxidePath = req.resolve("@tailwindcss/oxide");
+  } catch {
+    throw new Error(
+      "[nasti] CSS contains Tailwind v4 directives but `@tailwindcss/node` and/or `@tailwindcss/oxide` are not installed in this project. Install them with:  npm i -D tailwindcss @tailwindcss/node @tailwindcss/oxide"
+    );
+  }
+  const node = await import(pathToFileURL3(nodePath).href);
+  const oxide = await import(pathToFileURL3(oxidePath).href);
+  cached = { node, oxide };
+  cachedRoot = projectRoot;
+  return cached;
+}
+async function compileTailwind(css, fromFile, projectRoot) {
+  const { node, oxide } = await loadTailwind(projectRoot);
+  const dependencies = [];
+  const compiler = await node.compile(css, {
+    base: path7.dirname(fromFile),
+    from: fromFile,
+    onDependency: (p) => dependencies.push(p)
+  });
+  const scanner = new oxide.Scanner({ sources: compiler.sources });
+  const candidates = scanner.scan();
+  return {
+    css: compiler.build(candidates),
+    dependencies: [...dependencies, ...scanner.files]
+  };
+}
+var TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
+var init_tailwind = __esm({
+  "src/plugins/tailwind.ts"() {
+    "use strict";
+    TAILWIND_DIRECTIVE_RE = /@(?:import\s+["']tailwindcss(?:\b|\/)|tailwind\b|theme\b|apply\b|plugin\b|source\b|utility\b|variant\b|custom-variant\b|reference\b)/;
+    cached = null;
+    cachedRoot = null;
+  }
+});
+
+// src/plugins/css.ts
+import path8 from "path";
 function cssPlugin(config) {
   return {
     name: "nasti:css",
@@ -1642,9 +1696,14 @@ function cssPlugin(config) {
       if (source.endsWith(".css")) return null;
       return null;
     },
-    transform(code, id) {
+    async transform(code, id) {
       if (!id.endsWith(".css")) return null;
-      const rewritten = rewriteCssUrls(code, id, config.root);
+      let cssSource = code;
+      if (hasTailwindDirectives(code)) {
+        const compiled = await compileTailwind(code, id, config.root);
+        cssSource = compiled.css;
+      }
+      const rewritten = rewriteCssUrls(cssSource, id, config.root);
       if (config.command === "serve") {
         const escaped = JSON.stringify(rewritten);
         return {
@@ -1679,19 +1738,20 @@ function rewriteCssUrls(css, from, root) {
     if (url.startsWith("/") || url.startsWith("data:") || url.startsWith("http")) {
       return match;
     }
-    const resolved = path7.resolve(path7.dirname(from), url);
-    const relative = "/" + path7.relative(root, resolved);
+    const resolved = path8.resolve(path8.dirname(from), url);
+    const relative = "/" + path8.relative(root, resolved);
     return `url(${relative})`;
   });
 }
 var init_css = __esm({
   "src/plugins/css.ts"() {
     "use strict";
+    init_tailwind();
   }
 });
 
 // src/plugins/assets.ts
-import path8 from "path";
+import path9 from "path";
 import fs7 from "fs";
 import crypto from "crypto";
 function assetsPlugin(config) {
@@ -1704,7 +1764,7 @@ function assetsPlugin(config) {
       return null;
     },
     load(id) {
-      const ext = path8.extname(id.replace(/\?.*$/, ""));
+      const ext = path9.extname(id.replace(/\?.*$/, ""));
       if (id.endsWith("?raw")) {
         const file = id.slice(0, -4);
         if (fs7.existsSync(file)) {
@@ -1716,12 +1776,12 @@ function assetsPlugin(config) {
         const file = id.replace(/\?.*$/, "");
         if (!fs7.existsSync(file)) return null;
         if (config.command === "serve") {
-          const url = "/" + path8.relative(config.root, file);
+          const url = "/" + path9.relative(config.root, file);
           return `export default ${JSON.stringify(url)}`;
         }
         const content = fs7.readFileSync(file);
         const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
-        const basename = path8.basename(file, ext);
+        const basename = path9.basename(file, ext);
         const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
         return `export default ${JSON.stringify(config.base + hashedName)}`;
       }
@@ -1766,7 +1826,7 @@ __export(server_exports, {
   createServer: () => createServer
 });
 import http from "http";
-import path9 from "path";
+import path10 from "path";
 import os from "os";
 import connect from "connect";
 import sirv from "sirv";
@@ -1790,20 +1850,20 @@ async function createServer(inlineConfig = {}) {
     pluginContainer,
     moduleGraph
   }));
-  const publicDir = path9.resolve(config.root, "public");
+  const publicDir = path10.resolve(config.root, "public");
   app.use(sirv(publicDir, { dev: true, etag: true }));
   app.use(sirv(config.root, { dev: true, etag: true }));
   const httpServer = http.createServer(app);
   const ws = createWebSocketServer(httpServer);
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = path9.resolve(config.root, config.build.outDir);
+  const outDirAbs = path10.resolve(config.root, config.build.outDir);
   const watcher = watch(config.root, {
     ignored: (filePath) => {
       if (filePath === config.root) return false;
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path9.sep)) return true;
-      const rel = path9.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || path9.isAbsolute(rel)) return false;
-      for (const seg of rel.split(path9.sep)) {
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path10.sep)) return true;
+      const rel = path10.relative(config.root, filePath);
+      if (!rel || rel.startsWith("..") || path10.isAbsolute(rel)) return false;
+      for (const seg of rel.split(path10.sep)) {
         if (ignoredSegments.has(seg)) return true;
       }
       return false;
@@ -1835,7 +1895,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(pc.cyan("  nasti dev server") + pc.dim(` v${"1.6.3"}`));
+          console.log(pc.cyan("  nasti dev server") + pc.dim(` v${"1.6.4"}`));
           console.log();
           console.log(`  ${pc.green(">")} Local:   ${pc.cyan(localUrl)}`);
           if (networkUrl) {
@@ -1951,17 +2011,17 @@ var build_exports = {};
 __export(build_exports, {
   build: () => build
 });
-import path10 from "path";
+import path11 from "path";
 import fs8 from "fs";
 import { rolldown } from "rolldown";
 import pc2 from "picocolors";
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(pc2.cyan("\n\u{1F528} nasti build") + pc2.dim(` v${"1.6.3"}`));
+  console.log(pc2.cyan("\n\u{1F528} nasti build") + pc2.dim(` v${"1.6.4"}`));
   console.log(pc2.dim(`  root: ${config.root}`));
   console.log(pc2.dim(`  mode: ${config.mode}`));
-  const outDir = path10.resolve(config.root, config.build.outDir);
+  const outDir = path11.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && fs8.existsSync(outDir)) {
     fs8.rmSync(outDir, { recursive: true, force: true });
   }
@@ -1973,14 +2033,14 @@ async function build(inlineConfig = {}) {
     for (const match of scriptMatches) {
       const src = match[1];
       if (src && !src.startsWith("http")) {
-        entryPoints.push(path10.resolve(config.root, src.replace(/^\//, "")));
+        entryPoints.push(path11.resolve(config.root, src.replace(/^\//, "")));
       }
     }
   }
   if (entryPoints.length === 0) {
     const fallbackEntries = ["src/main.ts", "src/main.tsx", "src/main.js", "src/index.ts", "src/index.tsx", "src/index.js"];
     for (const entry of fallbackEntries) {
-      const fullPath = path10.resolve(config.root, entry);
+      const fullPath = path11.resolve(config.root, entry);
       if (fs8.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
@@ -2045,8 +2105,8 @@ async function build(inlineConfig = {}) {
   await bundle.close();
   await pluginContainer.buildEnd();
   for (const ef of pluginContainer.getEmittedFiles()) {
-    const dest = path10.resolve(outDir, ef.fileName);
-    fs8.mkdirSync(path10.dirname(dest), { recursive: true });
+    const dest = path11.resolve(outDir, ef.fileName);
+    fs8.mkdirSync(path11.dirname(dest), { recursive: true });
     fs8.writeFileSync(dest, ef.source);
   }
   if (html) {
@@ -2064,14 +2124,14 @@ async function build(inlineConfig = {}) {
     }
     for (const chunk of output) {
       if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = path10.relative(config.root, chunk.facadeModuleId);
+        const originalEntry = path11.relative(config.root, chunk.facadeModuleId);
         processedHtml = processedHtml.replace(
           new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
           `$1${config.base}${chunk.fileName}$3`
         );
       }
     }
-    fs8.writeFileSync(path10.resolve(outDir, "index.html"), processedHtml);
+    fs8.writeFileSync(path11.resolve(outDir, "index.html"), processedHtml);
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   const totalSize = output.reduce((sum, chunk) => {
@@ -2114,7 +2174,7 @@ __export(electron_exports, {
   detectInstalledElectron: () => detectInstalledElectron,
   normalizePreload: () => normalizePreload
 });
-import path11 from "path";
+import path12 from "path";
 import fs9 from "fs";
 import { rolldown as rolldown2 } from "rolldown";
 import pc3 from "picocolors";
@@ -2122,16 +2182,16 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc3.cyan("\n\u26A1 nasti build (electron)") + pc3.dim(` v${"1.6.3"}`));
+  console.log(pc3.cyan("\n\u26A1 nasti build (electron)") + pc3.dim(` v${"1.6.4"}`));
   console.log(pc3.dim(`  root: ${config.root}`));
   console.log(pc3.dim(`  mode: ${config.mode}`));
   console.log(pc3.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = path11.resolve(config.root, config.build.outDir);
+  const outDir = path12.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && fs9.existsSync(outDir)) {
     fs9.rmSync(outDir, { recursive: true, force: true });
   }
   fs9.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = path11.join(outDir, "renderer");
+  const rendererOutDir = path12.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2({
     ...inlineConfig,
@@ -2142,7 +2202,7 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   });
-  const mainEntry = path11.resolve(config.root, config.electron.main);
+  const mainEntry = path12.resolve(config.root, config.electron.main);
   if (!fs9.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
@@ -2161,7 +2221,7 @@ async function buildElectron(inlineConfig = {}) {
       console.warn(pc3.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = path11.basename(entry).replace(/\.[^.]+$/, "");
+    const base = path12.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -2173,10 +2233,10 @@ async function buildElectron(inlineConfig = {}) {
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   console.log(pc3.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(pc3.dim(`  renderer: ${path11.relative(config.root, rendererOutDir)}/`));
-  console.log(pc3.dim(`  main:     ${path11.relative(config.root, mainFile)}`));
+  console.log(pc3.dim(`  renderer: ${path12.relative(config.root, rendererOutDir)}/`));
+  console.log(pc3.dim(`  main:     ${path12.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(pc3.dim(`  preload:  ${path11.relative(config.root, pf)}`));
+    console.log(pc3.dim(`  preload:  ${path12.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -2207,7 +2267,7 @@ async function bundleNode(config, entry, opts) {
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)],
     ...config.build.rolldownOptions
   });
-  fs9.mkdirSync(path11.dirname(opts.outFile), { recursive: true });
+  fs9.mkdirSync(path12.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2216,16 +2276,16 @@ async function bundleNode(config, entry, opts) {
     codeSplitting: false
   });
   await bundle.close();
-  console.log(pc3.dim(`  \u2713 ${opts.label} \u2192 ${path11.relative(config.root, opts.outFile)}`));
+  console.log(pc3.dim(`  \u2713 ${opts.label} \u2192 ${path12.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return path11.join(outDir, base + ext);
+  return path12.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => path11.resolve(root, p));
+  return list.map((p) => path12.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
@@ -2240,7 +2300,7 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = path11.resolve(root, "node_modules/electron/package.json");
+    const pkgPath = path12.resolve(root, "node_modules/electron/package.json");
     if (!fs9.existsSync(pkgPath)) return null;
     const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
@@ -2265,9 +2325,9 @@ var electron_dev_exports = {};
 __export(electron_dev_exports, {
   startElectronDev: () => startElectronDev
 });
-import path12 from "path";
+import path13 from "path";
 import fs10 from "fs";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire4 } from "module";
 import { spawn } from "child_process";
 import chokidar from "chokidar";
 import pc4 from "picocolors";
@@ -2276,17 +2336,17 @@ 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.3"}`));
+  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.6.4"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({ ...rest, target: "electron" });
   await server.listen();
   const devUrl = `http://localhost:${server.config.server.port}/`;
   console.log(pc4.dim(`  renderer: ${devUrl}`));
-  const stageDir = path12.resolve(config.root, ".nasti");
+  const stageDir = path13.resolve(config.root, ".nasti");
   fs10.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = path12.resolve(config.root, config.electron.main);
+  const mainEntry = path13.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = path12.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = path13.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -2297,8 +2357,8 @@ async function startElectronDev(inlineConfig = {}) {
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
       if (!fs10.existsSync(entry)) continue;
-      const base = path12.basename(entry).replace(/\.[^.]+$/, "");
-      const out = path12.join(stageDir, base + extFor(config.electron.preloadFormat));
+      const base = path13.basename(entry).replace(/\.[^.]+$/, "");
+      const out = path13.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -2413,7 +2473,7 @@ async function compileNode(config, entry, opts) {
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  fs10.mkdirSync(path12.dirname(opts.outFile), { recursive: true });
+  fs10.mkdirSync(path13.dirname(opts.outFile), { recursive: true });
   await bundle.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -2430,7 +2490,7 @@ function resolveElectronBinary(config) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = createRequire3(path12.resolve(config.root, "package.json"));
+    const require2 = createRequire4(path13.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
     if (typeof electronModule === "string" && fs10.existsSync(electronModule)) {
@@ -2578,11 +2638,11 @@ cli.command("electron-build [root]", "Build Electron app for production").option
 cli.command("preview [root]", "Preview production build").option("--port <port>", "Port number", { default: 4173 }).option("--host [host]", "Hostname").option("--outDir <dir>", "Output directory to serve", { default: "dist" }).action(async (root, options) => {
   try {
     const http2 = await import("http");
-    const path13 = await import("path");
+    const path14 = await import("path");
     const sirv2 = (await import("sirv")).default;
     const connect2 = (await import("connect")).default;
-    const resolvedRoot = path13.resolve(root ?? ".");
-    const outDir = path13.resolve(resolvedRoot, options.outDir);
+    const resolvedRoot = path14.resolve(root ?? ".");
+    const outDir = path14.resolve(resolvedRoot, options.outDir);
     const app = connect2();
     app.use(sirv2(outDir, { single: true, etag: true, gzip: true, brotli: true }));
     const port = options.port;
@@ -2603,6 +2663,6 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   }
 });
 cli.help();
-cli.version("1.6.3");
+cli.version("1.6.4");
 cli.parse();
 //# sourceMappingURL=cli.js.map