tailwind-styled-v4 5.0.10 → 5.0.11

package/dist/turbopackLoader.mjs

@@ -1,8 +1,8 @@
 import { createRequire } from 'module';
 import * as fs3 from 'fs';
 import fs3__default from 'fs';
-import * as path from 'path';
-import path__default from 'path';
+import * as path3 from 'path';
+import path3__default from 'path';
 import 'crypto';
 import { fileURLToPath } from 'url';
 
@@ -49,28 +49,43 @@ function resolveNativeBinary(runtimeDir) {
       tried.push(`prebuilt:${pkg} (not installed)`);
     }
   }
+  const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
+  const BINARY_NAMES_SELF = ["tailwind-styled-native", "tailwind_styled_parser"];
+  if (runtimeDir) {
+    for (const depth of ["..", path3.join("..", ".."), path3.join("..", "..", "..")]) {
+      const pkgRoot = path3.resolve(runtimeDir, depth);
+      for (const bin of BINARY_NAMES_SELF) {
+        for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
+          const candidate = path3.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          tried.push(`self-bundled:${candidate}`);
+          if (fs3.existsSync(candidate)) {
+            return { path: candidate, source: "prebuilt", platform, tried };
+          }
+        }
+      }
+    }
+  }
   const cwd = process.cwd();
   const base = runtimeDir ?? cwd;
-  const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
-    localCandidates.push(path.resolve(base, `${bin}.node`));
-    localCandidates.push(path.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path.resolve(base, `${bin}.${napiPlatform}.node`));
+    localCandidates.push(path3.resolve(base, `${bin}.node`));
+    localCandidates.push(path3.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path3.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path3.resolve(base, `${bin}.${napiPlatform}.node`));
   }
   for (const startDir of [cwd, base]) {
     let dir = startDir;
     for (let i = 0; i < 6; i++) {
-      const nativeDir = path.resolve(dir, "native");
+      const nativeDir = path3.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path.resolve(nativeDir, "target", "release", `${bin}.node`));
+        localCandidates.push(path3.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path3.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path3.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path3.resolve(nativeDir, "target", "release", `${bin}.node`));
       }
-      const parent = path.resolve(dir, "..");
+      const parent = path3.resolve(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
@@ -89,18 +104,18 @@ var init_native_resolution = __esm({
     isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
     _require = typeof __require !== "undefined" ? __require : createRequire(import.meta.url);
     PLATFORM_MAP = {
-      "linux-x64": ["@tailwind-styled/native-linux-x64"],
-      "linux-arm64": ["@tailwind-styled/native-linux-arm64"],
+      "linux-x64": ["@tailwind-styled/native-linux-x64-gnu", "@tailwind-styled/native-linux-x64"],
+      "linux-arm64": ["@tailwind-styled/native-linux-arm64-gnu", "@tailwind-styled/native-linux-arm64"],
       "darwin-x64": ["@tailwind-styled/native-darwin-x64"],
       "darwin-arm64": ["@tailwind-styled/native-darwin-arm64"],
-      "win32-x64": ["@tailwind-styled/native-win32-x64"],
-      "win32-arm64": ["@tailwind-styled/native-win32-arm64"]
+      "win32-x64": ["@tailwind-styled/native-win32-x64-msvc", "@tailwind-styled/native-win32-x64"],
+      "win32-arm64": ["@tailwind-styled/native-win32-arm64-msvc", "@tailwind-styled/native-win32-arm64"]
     };
   }
 });
 function resolveRuntimeDir(dir, importMetaUrl) {
   try {
-    return path__default.dirname(fileURLToPath(importMetaUrl));
+    return path3__default.dirname(fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
@@ -234,7 +249,7 @@ var CYCLE_SENTINEL = "_cycle.txt";
 var START_SENTINEL = "_start.txt";
 var _workerCache = /* @__PURE__ */ new Map();
 function getTwClassesDir(safelistPath) {
-  return path__default.join(path__default.dirname(safelistPath), "tw-classes");
+  return path3__default.join(path3__default.dirname(safelistPath), "tw-classes");
 }
 function readSentinel(filePath) {
   try {
@@ -243,35 +258,59 @@ function readSentinel(filePath) {
     return "";
   }
 }
+var _clearLock = false;
 function clearAndMarkCycle(twClassesDir, startId) {
+  if (_clearLock) return;
+  _clearLock = true;
   try {
     if (fs3__default.existsSync(twClassesDir)) {
-      for (const file of fs3__default.readdirSync(twClassesDir)) {
-        if (file === START_SENTINEL || file === "_webpack-merged.css") continue;
-        try {
-          fs3__default.unlinkSync(path__default.join(twClassesDir, file));
-        } catch {
+      const tempDir = `${twClassesDir}_clearing_${Date.now()}`;
+      try {
+        fs3__default.renameSync(twClassesDir, tempDir);
+        fs3__default.mkdirSync(twClassesDir, { recursive: true });
+        const startFile = path3__default.join(tempDir, START_SENTINEL);
+        if (fs3__default.existsSync(startFile)) {
+          fs3__default.copyFileSync(startFile, path3__default.join(twClassesDir, START_SENTINEL));
+        }
+        const mergedFile = path3__default.join(tempDir, "_webpack-merged.css");
+        if (fs3__default.existsSync(mergedFile)) {
+          fs3__default.copyFileSync(mergedFile, path3__default.join(twClassesDir, "_webpack-merged.css"));
         }
+        fs3__default.writeFileSync(path3__default.join(twClassesDir, CYCLE_SENTINEL), startId, "utf-8");
+        _workerCache.set(twClassesDir, startId);
+        fs3__default.rmSync(tempDir, { recursive: true, force: true });
+      } catch {
+        for (const file of fs3__default.readdirSync(twClassesDir)) {
+          if (file === START_SENTINEL || file === "_webpack-merged.css") continue;
+          try {
+            fs3__default.unlinkSync(path3__default.join(twClassesDir, file));
+          } catch {
+          }
+        }
+        fs3__default.writeFileSync(path3__default.join(twClassesDir, CYCLE_SENTINEL), startId, "utf-8");
+        _workerCache.set(twClassesDir, startId);
       }
     } else {
       fs3__default.mkdirSync(twClassesDir, { recursive: true });
+      fs3__default.writeFileSync(path3__default.join(twClassesDir, CYCLE_SENTINEL), startId, "utf-8");
+      _workerCache.set(twClassesDir, startId);
     }
-    fs3__default.writeFileSync(path__default.join(twClassesDir, CYCLE_SENTINEL), startId, "utf-8");
-    _workerCache.set(twClassesDir, startId);
   } catch {
+  } finally {
+    _clearLock = false;
   }
 }
 function getPerFileSafelistPath(safelistDir, resourcePath) {
   const normalized = resourcePath.replace(/\\/g, "/");
   const slug = normalized.replace(/^.*\/src\//, "").replace(/\.[tj]sx?$/, "").replace(/[^a-zA-Z0-9]/g, "_").slice(0, 80);
-  return path__default.join(safelistDir, `${slug}.css`);
+  return path3__default.join(safelistDir, `${slug}.css`);
 }
 function writePerFileSafelist(safelistPath, resourcePath, classes) {
   if (!safelistPath || classes.length === 0) return;
   try {
     const twClassesDir = getTwClassesDir(safelistPath);
-    const startId = readSentinel(path__default.join(twClassesDir, START_SENTINEL));
-    const cachedCycle = _workerCache.get(twClassesDir) ?? readSentinel(path__default.join(twClassesDir, CYCLE_SENTINEL));
+    const startId = readSentinel(path3__default.join(twClassesDir, START_SENTINEL));
+    const cachedCycle = _workerCache.get(twClassesDir) ?? readSentinel(path3__default.join(twClassesDir, CYCLE_SENTINEL));
     if (startId && cachedCycle !== startId) {
       clearAndMarkCycle(twClassesDir, startId);
     } else if (!fs3__default.existsSync(twClassesDir)) {
@@ -280,7 +319,7 @@ function writePerFileSafelist(safelistPath, resourcePath, classes) {
     const outPath = getPerFileSafelistPath(twClassesDir, resourcePath);
     const sorted = [...new Set(classes)].sort();
     const css = [
-      `/* tw-safelist: ${path__default.basename(resourcePath)} \u2014 auto-generated */`,
+      `/* tw-safelist: ${path3__default.basename(resourcePath)} \u2014 auto-generated */`,
       "@layer utilities {",
       sorted.map((cls) => `.${cls.replace(/([^a-zA-Z0-9_-])/g, "\\$1")} {}`).join("\n"),
       "}"
@@ -289,7 +328,17 @@ function writePerFileSafelist(safelistPath, resourcePath, classes) {
       if (fs3__default.readFileSync(outPath, "utf-8") === css) return;
     } catch {
     }
-    fs3__default.writeFileSync(outPath, css, "utf-8");
+    const tmpPath = `${outPath}.tmp`;
+    try {
+      fs3__default.writeFileSync(tmpPath, css, "utf-8");
+      fs3__default.renameSync(tmpPath, outPath);
+    } catch {
+      try {
+        fs3__default.unlinkSync(tmpPath);
+      } catch {
+      }
+      fs3__default.writeFileSync(outPath, css, "utf-8");
+    }
   } catch {
   }
 }
@@ -298,7 +347,7 @@ function turbopackLoader(source, options = {}) {
   const router = detectRouter(this.resourcePath);
   const nextMajor = parseNum(options.nextMajor);
   const debug = parseBool(options.debug);
-  const filename = path__default.basename(this.resourcePath);
+  const filename = path3__default.basename(this.resourcePath);
   const effective = {
     addDataAttr: parseBool(options.addDataAttr),
     // App Router: selalu auto-detect client boundary
@@ -319,7 +368,12 @@ function turbopackLoader(source, options = {}) {
       source: stripped,
       options: effective
     });
-    if (!output.changed) return source;
+    if (!output.changed) {
+      if (output.classes.length > 0) {
+        writePerFileSafelist(options.safelistPath, this.resourcePath, output.classes);
+      }
+      return source;
+    }
     if (output.classes.length > 0) {
       registerFileClasses(this.resourcePath, output.classes);
       writePerFileSafelist(options.safelistPath, this.resourcePath, output.classes);