@tamagui/static-worker 2.0.0-rc.4 → 2.0.0-rc.40

package/dist/cjs/index.cjs

@@ -2,33 +2,35 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf,
-  __hasOwnProp = Object.prototype.hasOwnProperty;
+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: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  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;
-  };
+  }
+  return to;
+};
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-    value: mod,
-    enumerable: !0
-  }) : target, mod)),
-  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-    value: !0
-  }), mod);
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
 var index_exports = {};
 __export(index_exports, {
   clearWorkerCache: () => clearWorkerCache,
@@ -42,37 +44,46 @@ __export(index_exports, {
   watchTamaguiConfig: () => watchTamaguiConfig
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_url = require("node:url"),
-  import_piscina = __toESM(require("piscina"), 1);
-const import_meta = {},
-  getPragmaOptions = async props => {
-    const {
-      default: Static
-    } = await import("@tamagui/static");
-    return Static.getPragmaOptions(props);
-  },
-  getWorkerPath = () => typeof import_meta < "u" && import_meta.url ? (0, import_node_url.fileURLToPath)(import_meta.resolve("@tamagui/static/worker")).replace(/\.mjs$/, ".js") : require.resolve("@tamagui/static/worker").replace(/\.mjs$/, ".js"),
-  POOL_KEY = "__tamagui_piscina_pool__",
-  CLOSING_KEY = "__tamagui_piscina_closing__",
-  TASK_COUNT_KEY = "__tamagui_piscina_task_count__",
-  RECYCLING_KEY = "__tamagui_piscina_recycling__",
-  MAX_TASKS_BEFORE_RECYCLE = 200;
+var import_node_url = require("node:url");
+var import_piscina = __toESM(require("piscina"), 1);
+const import_meta = {};
+const getPragmaOptions = async props => {
+  const {
+    default: Static
+  } = await import("@tamagui/static");
+  return Static.getPragmaOptions(props);
+};
+const getWorkerPath = () => {
+  if (typeof import_meta !== "undefined" && import_meta.url) {
+    const workerPath = (0, import_node_url.fileURLToPath)(import_meta.resolve("@tamagui/static/worker"));
+    return workerPath.replace(/\.mjs$/, ".js");
+  }
+  return require.resolve("@tamagui/static/worker").replace(/\.mjs$/, ".js");
+};
+const POOL_KEY = "__tamagui_piscina_pool__";
+const CLOSING_KEY = "__tamagui_piscina_closing__";
+const TASK_COUNT_KEY = "__tamagui_piscina_task_count__";
+const RECYCLING_KEY = "__tamagui_piscina_recycling__";
+const MAX_TASKS_BEFORE_RECYCLE = 1e3;
 function getSharedPool() {
   return globalThis[POOL_KEY] ?? null;
 }
 function setSharedPool(pool) {
+  ;
   globalThis[POOL_KEY] = pool;
 }
 function isClosing() {
-  return globalThis[CLOSING_KEY] === !0;
+  return globalThis[CLOSING_KEY] === true;
 }
 function setClosing(value) {
+  ;
   globalThis[CLOSING_KEY] = value;
 }
 function isRecycling() {
-  return globalThis[RECYCLING_KEY] === !0;
+  return globalThis[RECYCLING_KEY] === true;
 }
 function setRecycling(value) {
+  ;
   globalThis[RECYCLING_KEY] = value;
 }
 function getTaskCount() {
@@ -80,64 +91,87 @@ function getTaskCount() {
 }
 function incrementTaskCount() {
   const count = getTaskCount() + 1;
-  return globalThis[TASK_COUNT_KEY] = count, count;
+  globalThis[TASK_COUNT_KEY] = count;
+  return count;
 }
 function resetTaskCount() {
+  ;
   globalThis[TASK_COUNT_KEY] = 0;
 }
 function createPool() {
   const pool = new import_piscina.default({
     filename: getWorkerPath(),
-    // Single worker for state consistency and simpler caching
-    minThreads: 1,
-    maxThreads: 1,
+    // each worker loads and caches config independently
+    minThreads: 2,
+    maxThreads: 2,
     // Never terminate due to idle - worker stays alive until close() or process exit
     // This prevents "Terminating worker thread" errors from Piscina during idle
     idleTimeout: Number.POSITIVE_INFINITY
     // no resourceLimits - we rely on task-based recycling instead
     // V8 resourceLimits cause "Terminating worker thread" messages when hit
   });
-  return pool.on("error", err => {
-    isClosing() || isRecycling() || (err && typeof err == "object" && "message" in err ? String(err.message) : "").includes("Terminating worker thread") || console.error("[tamagui] Worker pool error:", err);
-  }), pool;
+  pool.on("error", err => {
+    if (isClosing() || isRecycling()) return;
+    const message = err && typeof err === "object" && "message" in err ? String(err.message) : "";
+    if (message.includes("Terminating worker thread")) return;
+    console.error("[tamagui] Worker pool error:", err);
+  });
+  return pool;
 }
 function getPool() {
   let pool = getSharedPool();
-  return pool || (pool = createPool(), setSharedPool(pool)), pool;
+  if (!pool) {
+    pool = createPool();
+    setSharedPool(pool);
+  }
+  return pool;
 }
 async function loadTamagui(options) {
-  const pool = getPool(),
-    task = {
-      type: "extractToClassNames",
-      source: "// dummy",
-      sourcePath: "__dummy__.tsx",
-      options: {
-        components: ["tamagui"],
-        ...options
-      },
-      shouldPrintDebug: !1
-    };
+  const pool = getPool();
+  const task = {
+    type: "extractToClassNames",
+    source: "// dummy",
+    sourcePath: "__dummy__.tsx",
+    options: {
+      components: ["tamagui"],
+      ...options
+    },
+    shouldPrintDebug: false
+  };
   try {
-    return await pool.run(task, {
+    await pool.run(task, {
       name: "runTask"
-    }), {
-      success: !0
+    });
+    return {
+      success: true
     };
   } catch (error) {
-    throw console.error("[static-worker] Error loading Tamagui config:", error), error;
+    console.error("[static-worker] Error loading Tamagui config:", error);
+    throw error;
   }
 }
 async function recyclePool(options) {
   if (isClosing() || isRecycling()) return;
   const oldPool = getSharedPool();
   if (!oldPool) return;
-  setRecycling(!0);
+  setRecycling(true);
   const start = Date.now();
   try {
-    const originalStderr = process.stderr.write.bind(process.stderr),
-      originalStdout = process.stdout.write.bind(process.stdout),
-      filter = (chunk, ...args) => !!(typeof chunk == "string" ? chunk : chunk?.toString?.() || "").includes("Terminating worker thread");
-    process.stderr.write = (chunk, ...args) => filter(chunk) ? !0 : originalStderr(chunk, ...args), process.stdout.write = (chunk, ...args) => filter(chunk) ? !0 : originalStdout(chunk, ...args);
+    const originalStderr = process.stderr.write.bind(process.stderr);
+    const originalStdout = process.stdout.write.bind(process.stdout);
+    const filter = (chunk, ...args) => {
+      const str = typeof chunk === "string" ? chunk : chunk?.toString?.() || "";
+      if (str.includes("Terminating worker thread")) return true;
+      return false;
+    };
+    process.stderr.write = (chunk, ...args) => {
+      if (filter(chunk)) return true;
+      return originalStderr(chunk, ...args);
+    };
+    process.stdout.write = (chunk, ...args) => {
+      if (filter(chunk)) return true;
+      return originalStdout(chunk, ...args);
+    };
     const newPool = createPool();
     setSharedPool(newPool);
     const warmupTask = {
@@ -147,17 +181,22 @@ async function recyclePool(options) {
       options: {
         ...options,
         // skip the "built config" log on warmup since it's a recycle
-        _skipBuildLog: !0
+        _skipBuildLog: true
       },
-      shouldPrintDebug: !1
+      shouldPrintDebug: false
     };
     await newPool.run(warmupTask, {
       name: "runTask"
-    }), oldPool.removeAllListeners(), oldPool.destroy().catch(() => {}), setTimeout(() => {
-      process.stderr.write = originalStderr, process.stdout.write = originalStdout;
-    }), console.log(`  \u267B\uFE0F  [tamagui] recycled worker pool (${Date.now() - start}ms)`);
+    });
+    oldPool.removeAllListeners();
+    oldPool.destroy().catch(() => {});
+    setTimeout(() => {
+      process.stderr.write = originalStderr;
+      process.stdout.write = originalStdout;
+    });
+    console.log(`  \u267B\uFE0F  [tamagui] recycled worker pool (${Date.now() - start}ms)`);
   } finally {
-    setRecycling(!1);
+    setRecycling(false);
   }
 }
 async function loadTamaguiBuildConfig(tamaguiOptions) {
@@ -171,55 +210,72 @@ async function extractToClassNames(params) {
     source,
     sourcePath = "",
     options,
-    shouldPrintDebug = !1
+    shouldPrintDebug = false
   } = params;
-  if (typeof source != "string") throw new Error("`source` must be a string of javascript");
+  if (typeof source !== "string") {
+    throw new Error("`source` must be a string of javascript");
+  }
   const task = {
-      type: "extractToClassNames",
-      source,
-      sourcePath,
-      options,
-      shouldPrintDebug
-    },
-    result = await getPool().run(task, {
-      name: "runTask"
-    });
+    type: "extractToClassNames",
+    source,
+    sourcePath,
+    options,
+    shouldPrintDebug
+  };
+  const pool = getPool();
+  const result = await pool.run(task, {
+    name: "runTask"
+  });
   if (!result.success) {
-    const errorMessage = [`[tamagui-extract] Error processing file: ${sourcePath || "(unknown)"}`, "", result.error, result.stack ? `
-${result.stack}` : ""].filter(Boolean).join(`
-`);
+    const errorMessage = [`[tamagui-extract] Error processing file: ${sourcePath || "(unknown)"}`, ``, result.error, result.stack ? `
+${result.stack}` : ""].filter(Boolean).join("\n");
     throw new Error(errorMessage);
   }
-  return incrementTaskCount() >= MAX_TASKS_BEFORE_RECYCLE && (resetTaskCount(), recyclePool(options).catch(() => {})), result.data;
+  const count = incrementTaskCount();
+  if (count >= MAX_TASKS_BEFORE_RECYCLE) {
+    resetTaskCount();
+    recyclePool(options).catch(() => {});
+  }
+  return result.data;
 }
 async function extractToNative(sourceFileName, sourceCode, options) {
   const task = {
-      type: "extractToNative",
-      sourceFileName,
-      sourceCode,
-      options
-    },
-    result = await getPool().run(task, {
-      name: "runTask"
-    });
+    type: "extractToNative",
+    sourceFileName,
+    sourceCode,
+    options
+  };
+  const pool = getPool();
+  const result = await pool.run(task, {
+    name: "runTask"
+  });
   if (!result.success) {
-    const errorMessage = [`[tamagui-extract] Error processing file: ${sourceFileName || "(unknown)"}`, "", result.error, result.stack ? `
-${result.stack}` : ""].filter(Boolean).join(`
-`);
+    const errorMessage = [`[tamagui-extract] Error processing file: ${sourceFileName || "(unknown)"}`, ``, result.error, result.stack ? `
+${result.stack}` : ""].filter(Boolean).join("\n");
     throw new Error(errorMessage);
   }
-  return incrementTaskCount() >= MAX_TASKS_BEFORE_RECYCLE && (resetTaskCount(), recyclePool(options).catch(() => {})), result.data;
+  const count = incrementTaskCount();
+  if (count >= MAX_TASKS_BEFORE_RECYCLE) {
+    resetTaskCount();
+    recyclePool(options).catch(() => {});
+  }
+  return result.data;
 }
 async function watchTamaguiConfig(options) {
   const {
-      default: Static
-    } = await import("@tamagui/static"),
-    watcher = await Static.watchTamaguiConfig(options);
-  if (!watcher) return;
+    default: Static
+  } = await import("@tamagui/static");
+  const watcher = await Static.watchTamaguiConfig(options);
+  if (!watcher) {
+    return;
+  }
   const originalDispose = watcher.dispose;
   return {
     dispose: () => {
-      originalDispose(), getSharedPool() && clearWorkerCache();
+      originalDispose();
+      if (getSharedPool()) {
+        clearWorkerCache();
+      }
     }
   };
 }
@@ -236,21 +292,25 @@ async function clearWorkerCache() {
 async function destroyPool() {
   const pool = getSharedPool();
   if (pool) {
-    setClosing(!0);
+    setClosing(true);
     try {
       await pool.close();
     } finally {
-      setSharedPool(null), setClosing(!1);
+      setSharedPool(null);
+      setClosing(false);
     }
   }
 }
 function getPoolStats() {
   const pool = getSharedPool();
-  return pool ? {
+  if (!pool) {
+    return null;
+  }
+  return {
     threads: pool.threads.length,
     queueSize: pool.queueSize,
     completed: pool.completed,
     duration: pool.duration,
     utilization: pool.utilization
-  } : null;
+  };
 }