@hanzogui/static-worker 2.0.0-rc.41-hanzoai.5

package/src/index.ts

@@ -0,0 +1,402 @@
+/**
+ * @hanzogui/static-worker
+ *
+ * Pure worker-based API for Hanzogui static extraction.
+ * All operations run in a worker thread for better performance and isolation.
+ *
+ * This package provides a clean async API that wraps @hanzogui/static's worker
+ * implementation without exposing any sync/legacy APIs.
+ */
+
+import type { HanzoguiOptions } from '@hanzogui/types'
+import { fileURLToPath } from 'node:url'
+import Piscina from 'piscina'
+
+export type { ExtractedResponse, HanzoguiProjectInfo } from '@hanzogui/static'
+export type { HanzoguiOptions } from '@hanzogui/types'
+
+export const getPragmaOptions = async (props: { source: string; path: string }) => {
+  const { default: Static } = await import('@hanzogui/static')
+  return Static.getPragmaOptions(props)
+}
+
+// Resolve worker path - works for both CJS and ESM
+const getWorkerPath = () => {
+  // Piscina needs the actual file path, not the module resolution
+  // Use the CommonJS .js version which works for piscina
+  if (typeof import.meta !== 'undefined' && import.meta.url) {
+    const workerPath = fileURLToPath(import.meta.resolve('@hanzogui/static/worker'))
+    // Replace .mjs with .js for CommonJS compatibility
+    return workerPath.replace(/\.mjs$/, '.js')
+  }
+
+  // Fallback for CJS
+  return require.resolve('@hanzogui/static/worker').replace(/\.mjs$/, '.js')
+}
+
+// Use globalThis to share pool across module instances (Vite environments)
+const POOL_KEY = '__hanzogui_piscina_pool__'
+const CLOSING_KEY = '__hanzogui_piscina_closing__'
+const TASK_COUNT_KEY = '__hanzogui_piscina_task_count__'
+const RECYCLING_KEY = '__hanzogui_piscina_recycling__'
+
+// recycle worker after this many tasks to prevent RSS bloat from V8 memory fragmentation
+// Node.js worker threads don't release memory properly - see https://github.com/nodejs/node/issues/51868
+// set high enough that builds (typically 200-400 files) never trigger a recycle,
+// but long-running dev servers still get memory relief eventually
+const MAX_TASKS_BEFORE_RECYCLE = 1000
+
+function getSharedPool(): Piscina | null {
+  return (globalThis as any)[POOL_KEY] ?? null
+}
+
+function setSharedPool(pool: Piscina | null) {
+  ;(globalThis as any)[POOL_KEY] = pool
+}
+
+function isClosing(): boolean {
+  return (globalThis as any)[CLOSING_KEY] === true
+}
+
+function setClosing(value: boolean) {
+  ;(globalThis as any)[CLOSING_KEY] = value
+}
+
+function isRecycling(): boolean {
+  return (globalThis as any)[RECYCLING_KEY] === true
+}
+
+function setRecycling(value: boolean) {
+  ;(globalThis as any)[RECYCLING_KEY] = value
+}
+
+function getTaskCount(): number {
+  return (globalThis as any)[TASK_COUNT_KEY] ?? 0
+}
+
+function incrementTaskCount(): number {
+  const count = getTaskCount() + 1
+  ;(globalThis as any)[TASK_COUNT_KEY] = count
+  return count
+}
+
+function resetTaskCount() {
+  ;(globalThis as any)[TASK_COUNT_KEY] = 0
+}
+
+/**
+ * Create a new Piscina pool instance
+ */
+function createPool(): Piscina {
+  const pool = new Piscina({
+    filename: getWorkerPath(),
+    // 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
+  })
+
+  // Handle error events to prevent uncaught exceptions during pool destruction
+  pool.on('error', (err) => {
+    if (isClosing() || isRecycling()) return
+    const message =
+      err && typeof err === 'object' && 'message' in err ? String(err.message) : ''
+    // Suppress termination errors (can still occur during explicit close/destroy)
+    if (message.includes('Terminating worker thread')) return
+    console.error('[hanzogui] Worker pool error:', err)
+  })
+
+  return pool
+}
+
+/**
+ * Get or create the Piscina worker pool
+ */
+function getPool(): Piscina {
+  let pool = getSharedPool()
+  if (!pool) {
+    pool = createPool()
+    setSharedPool(pool)
+  }
+  return pool
+}
+
+/**
+ * Load Hanzogui configuration in worker
+ * Sends a warmup task to trigger config loading
+ * bundleConfig auto-detects if files exist and skips rebuild
+ */
+export async function loadHanzogui(options: Partial<HanzoguiOptions>): Promise<any> {
+  const pool = getPool()
+
+  // use extractToClassNames with a dummy request to trigger config loading
+  // the worker will cache the config for subsequent requests
+  const task = {
+    type: 'extractToClassNames',
+    source: '// dummy',
+    sourcePath: '__dummy__.tsx',
+    options: {
+      components: ['hanzogui'],
+      ...options,
+    },
+    shouldPrintDebug: false,
+  }
+
+  try {
+    await pool.run(task, { name: 'runTask' })
+    return { success: true }
+  } catch (error) {
+    console.error('[static-worker] Error loading Hanzogui config:', error)
+    throw error
+  }
+}
+
+/**
+ * Recycle the worker pool to release RSS memory
+ * Creates new pool, swaps immediately, then destroys old pool
+ * V8 doesn't return memory to OS, so we need to restart the worker periodically
+ */
+async function recyclePool(options: HanzoguiOptions): Promise<void> {
+  if (isClosing() || isRecycling()) return
+
+  const oldPool = getSharedPool()
+  if (!oldPool) return
+
+  setRecycling(true)
+
+  const start = Date.now()
+
+  try {
+    // suppress "Terminating worker thread" messages during recycle
+    const originalStderr = process.stderr.write.bind(process.stderr)
+    const originalStdout = process.stdout.write.bind(process.stdout)
+    const filter = (chunk: any, ...args: any[]) => {
+      const str = typeof chunk === 'string' ? chunk : chunk?.toString?.() || ''
+      if (str.includes('Terminating worker thread')) return true
+      return false
+    }
+    process.stderr.write = ((chunk: any, ...args: any[]) => {
+      if (filter(chunk)) return true
+      return originalStderr(chunk, ...args)
+    }) as any
+    process.stdout.write = ((chunk: any, ...args: any[]) => {
+      if (filter(chunk)) return true
+      return originalStdout(chunk, ...args)
+    }) as any
+
+    // create new pool and swap immediately
+    const newPool = createPool()
+    setSharedPool(newPool)
+
+    // warm up new pool with config (this caches it in the new worker)
+    const warmupTask = {
+      type: 'extractToClassNames',
+      source: '// warmup',
+      sourcePath: '__warmup__.tsx',
+      options: {
+        ...options,
+        // skip the "built config" log on warmup since it's a recycle
+        _skipBuildLog: true,
+      },
+      shouldPrintDebug: false,
+    }
+
+    await newPool.run(warmupTask, { name: 'runTask' })
+
+    // destroy old pool - pending tasks will be rejected
+    oldPool.removeAllListeners()
+    oldPool.destroy().catch(() => {})
+
+    // restore stderr/stdout after a delay
+    setTimeout(() => {
+      process.stderr.write = originalStderr
+      process.stdout.write = originalStdout
+    })
+
+    console.log(`  ♻️  [hanzogui] recycled worker pool (${Date.now() - start}ms)`)
+  } finally {
+    setRecycling(false)
+  }
+}
+
+/**
+ * Load Hanzogui build configuration asynchronously
+ * Uses esbuild-wasm to avoid EPIPE errors from native esbuild service lifecycle
+ */
+export async function loadHanzoguiBuildConfig(
+  hanzoguiOptions: Partial<HanzoguiOptions> | undefined
+): Promise<HanzoguiOptions> {
+  const { default: Static } = await import('@hanzogui/static')
+
+  return Static.loadHanzoguiBuildConfigAsync(hanzoguiOptions)
+}
+
+/**
+ * Extract Hanzogui components to className-based CSS for web
+ */
+export async function extractToClassNames(params: {
+  source: string | Buffer
+  sourcePath?: string
+  options: HanzoguiOptions
+  shouldPrintDebug?: boolean | 'verbose'
+}): Promise<any> {
+  const { source, sourcePath = '', options, shouldPrintDebug = false } = params
+
+  if (typeof source !== 'string') {
+    throw new Error('`source` must be a string of javascript')
+  }
+
+  const task = {
+    type: 'extractToClassNames',
+    source,
+    sourcePath,
+    options,
+    shouldPrintDebug,
+  }
+
+  const pool = getPool()
+  const result = (await pool.run(task, { name: 'runTask' })) as any
+
+  if (!result.success) {
+    const errorMessage = [
+      `[hanzogui-extract] Error processing file: ${sourcePath || '(unknown)'}`,
+      ``,
+      result.error,
+      result.stack ? `\n${result.stack}` : '',
+    ]
+      .filter(Boolean)
+      .join('\n')
+
+    throw new Error(errorMessage)
+  }
+
+  // check if we need to recycle the worker to prevent RSS bloat
+  const count = incrementTaskCount()
+  if (count >= MAX_TASKS_BEFORE_RECYCLE) {
+    resetTaskCount()
+    // recycle asynchronously with hot-swap to not block current request
+    recyclePool(options).catch(() => {})
+  }
+
+  return result.data
+}
+
+/**
+ * Extract Hanzogui components to React Native StyleSheet format
+ */
+export async function extractToNative(
+  sourceFileName: string,
+  sourceCode: string,
+  options: HanzoguiOptions
+): Promise<any> {
+  const task = {
+    type: 'extractToNative',
+    sourceFileName,
+    sourceCode,
+    options,
+  }
+
+  const pool = getPool()
+  const result = (await pool.run(task, { name: 'runTask' })) as any
+
+  if (!result.success) {
+    const errorMessage = [
+      `[hanzogui-extract] Error processing file: ${sourceFileName || '(unknown)'}`,
+      ``,
+      result.error,
+      result.stack ? `\n${result.stack}` : '',
+    ]
+      .filter(Boolean)
+      .join('\n')
+
+    throw new Error(errorMessage)
+  }
+
+  // check if we need to recycle the worker to prevent RSS bloat
+  const count = incrementTaskCount()
+  if (count >= MAX_TASKS_BEFORE_RECYCLE) {
+    resetTaskCount()
+    // recycle asynchronously with hot-swap to not block current request
+    recyclePool(options).catch(() => {})
+  }
+
+  return result.data
+}
+
+/**
+ * Watch Hanzogui config for changes and reload when it changes
+ */
+export async function watchHanzoguiConfig(
+  options: HanzoguiOptions
+): Promise<{ dispose: () => void } | undefined> {
+  // For now, we'll use the static package's watcher directly
+  // This could be improved to use worker-based watching
+  const { default: Static } = await import('@hanzogui/static')
+  const watcher = await Static.watchHanzoguiConfig(options)
+
+  if (!watcher) {
+    return
+  }
+
+  // Wrap the dispose to also clear worker cache
+  const originalDispose = watcher.dispose
+  return {
+    dispose: () => {
+      originalDispose()
+      if (getSharedPool()) {
+        // Fire and forget - errors are handled internally
+        clearWorkerCache()
+      }
+    },
+  }
+}
+
+/**
+ * Clear the worker's config cache
+ * Call this when config files change
+ */
+export async function clearWorkerCache(): Promise<void> {
+  const pool = getSharedPool()
+  if (!pool || isClosing()) return
+
+  const task = { type: 'clearCache' }
+  await pool.run(task, { name: 'runTask' })
+}
+
+/**
+ * Clean up the worker pool on exit
+ * Should be called when the build process completes
+ */
+export async function destroyPool(): Promise<void> {
+  const pool = getSharedPool()
+  if (pool) {
+    setClosing(true)
+    try {
+      await pool.close()
+    } finally {
+      setSharedPool(null)
+      setClosing(false)
+    }
+  }
+}
+
+/**
+ * Get pool statistics for debugging
+ */
+export function getPoolStats() {
+  const pool = getSharedPool()
+  if (!pool) {
+    return null
+  }
+  return {
+    threads: pool.threads.length,
+    queueSize: pool.queueSize,
+    completed: pool.completed,
+    duration: pool.duration,
+    utilization: pool.utilization,
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @hanzogui/static-worker
+ *
+ * Pure worker-based API for Hanzogui static extraction.
+ * All operations run in a worker thread for better performance and isolation.
+ *
+ * This package provides a clean async API that wraps @hanzogui/static's worker
+ * implementation without exposing any sync/legacy APIs.
+ */
+import type { HanzoguiOptions } from '@hanzogui/types';
+export type { ExtractedResponse, HanzoguiProjectInfo } from '@hanzogui/static';
+export type { HanzoguiOptions } from '@hanzogui/types';
+export declare const getPragmaOptions: (props: {
+    source: string;
+    path: string;
+}) => Promise<{
+    shouldPrintDebug: boolean | "verbose";
+    shouldDisable: boolean;
+}>;
+/**
+ * Load Hanzogui configuration in worker
+ * Sends a warmup task to trigger config loading
+ * bundleConfig auto-detects if files exist and skips rebuild
+ */
+export declare function loadHanzogui(options: Partial<HanzoguiOptions>): Promise<any>;
+/**
+ * Load Hanzogui build configuration asynchronously
+ * Uses esbuild-wasm to avoid EPIPE errors from native esbuild service lifecycle
+ */
+export declare function loadHanzoguiBuildConfig(hanzoguiOptions: Partial<HanzoguiOptions> | undefined): Promise<HanzoguiOptions>;
+/**
+ * Extract Hanzogui components to className-based CSS for web
+ */
+export declare function extractToClassNames(params: {
+    source: string | Buffer;
+    sourcePath?: string;
+    options: HanzoguiOptions;
+    shouldPrintDebug?: boolean | 'verbose';
+}): Promise<any>;
+/**
+ * Extract Hanzogui components to React Native StyleSheet format
+ */
+export declare function extractToNative(sourceFileName: string, sourceCode: string, options: HanzoguiOptions): Promise<any>;
+/**
+ * Watch Hanzogui config for changes and reload when it changes
+ */
+export declare function watchHanzoguiConfig(options: HanzoguiOptions): Promise<{
+    dispose: () => void;
+} | undefined>;
+/**
+ * Clear the worker's config cache
+ * Call this when config files change
+ */
+export declare function clearWorkerCache(): Promise<void>;
+/**
+ * Clean up the worker pool on exit
+ * Should be called when the build process completes
+ */
+export declare function destroyPool(): Promise<void>;
+/**
+ * Get pool statistics for debugging
+ */
+export declare function getPoolStats(): {
+    threads: number;
+    queueSize: number;
+    completed: number;
+    duration: number;
+    utilization: number;
+} | null;
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAItD,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAC9E,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,gBAAgB,GAAU,OAAO;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;;;EAG7E,CAAA;AA2GD;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAuBlF;AAsED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,eAAe,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,SAAS,GACpD,OAAO,CAAC,eAAe,CAAC,CAI1B;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAChD,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,eAAe,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CACvC,GAAG,OAAO,CAAC,GAAG,CAAC,CAwCf;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,GAAG,CAAC,CAiCd;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,GAAG,SAAS,CAAC,CAqB9C;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMtD;AAED;;;GAGG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAWjD;AAED;;GAEG;AACH,wBAAgB,YAAY;;;;;;SAY3B"}