@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

package/dist/browser/modules/archive/compression/worker-pool/types.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Worker Pool Types
+ *
+ * Shared type definitions for the worker pool system.
+ * Used by both the main thread and worker scripts.
+ */
+/**
+ * Task types that workers can handle
+ */
+export type WorkerTaskType = "deflate" | "inflate";
+/**
+ * Worker message types from main thread to worker
+ */
+export type WorkerRequestMessage = {
+    /** Batch task request */
+    type: "task";
+    /** Unique task ID for correlation */
+    taskId: number;
+    /** Task type (deflate or inflate) */
+    taskType: WorkerTaskType;
+    /** Input data to process */
+    data: Uint8Array;
+    /** Compression level (for deflate) */
+    level?: number;
+} | {
+    /** Streaming task start */
+    type: "start";
+    taskId: number;
+    taskType: WorkerTaskType;
+    level?: number;
+} | {
+    /** Streaming data chunk */
+    type: "chunk";
+    taskId: number;
+    data: Uint8Array;
+} | {
+    /** Streaming end (flush + close) */
+    type: "end";
+    taskId: number;
+} | {
+    /** Streaming abort/cancel */
+    type: "abort";
+    taskId: number;
+    error?: string;
+} | {
+    /** Terminate worker */
+    type: "terminate";
+};
+/**
+ * Worker message types from worker to main thread
+ */
+export type WorkerResponseMessage = {
+    /** Worker is ready */
+    type: "ready";
+} | {
+    /** Streaming task started successfully (start handshake) */
+    type: "started";
+    taskId: number;
+} | {
+    /** Batch task result */
+    type: "result";
+    taskId: number;
+    data: Uint8Array;
+    duration?: number;
+} | {
+    /** Streaming output chunk */
+    type: "out";
+    taskId: number;
+    data: Uint8Array;
+} | {
+    /** Acknowledge that an input chunk was consumed */
+    type: "ack";
+    taskId: number;
+} | {
+    /** Streaming task completed */
+    type: "done";
+    taskId: number;
+    duration?: number;
+} | {
+    /** Any task error (batch or streaming) */
+    type: "error";
+    taskId: number;
+    error?: string;
+    duration?: number;
+};
+/**
+ * Worker pool configuration options
+ */
+export interface WorkerPoolOptions {
+    /**
+     * Maximum number of workers in the pool.
+     * Defaults to navigator.hardwareConcurrency or 4.
+     */
+    maxWorkers?: number;
+    /**
+     * Minimum number of workers to keep alive (warm pool).
+     * Workers beyond this count may be terminated when idle.
+     * Defaults to 0.
+     */
+    minWorkers?: number;
+    /**
+     * Time in milliseconds before an idle worker is terminated.
+     * Only applies to workers beyond minWorkers.
+     * Defaults to 30000 (30 seconds).
+     */
+    idleTimeout?: number;
+    /**
+     * Custom worker URL. If provided, uses this instead of inline worker.
+     */
+    workerUrl?: string;
+    /**
+     * Whether to use transferable objects for zero-copy data transfer.
+     * Defaults to true.
+     */
+    useTransferables?: boolean;
+}
+/**
+ * Worker pool statistics
+ */
+export interface WorkerPoolStats {
+    /** Total number of workers (active + idle) */
+    totalWorkers: number;
+    /** Number of busy workers */
+    activeWorkers: number;
+    /** Number of idle workers */
+    idleWorkers: number;
+    /** Number of pending tasks in queue */
+    pendingTasks: number;
+    /** Total tasks completed since pool creation */
+    completedTasks: number;
+    /** Total tasks failed since pool creation */
+    failedTasks: number;
+}
+/**
+ * Task priority levels
+ */
+export type TaskPriority = "high" | "normal" | "low";
+/**
+ * Task configuration options
+ */
+export interface TaskOptions {
+    /**
+     * Task priority. Higher priority tasks are processed first.
+     * Defaults to "normal".
+     */
+    priority?: TaskPriority;
+    /**
+     * Abort signal for task cancellation.
+     */
+    signal?: AbortSignal;
+    /**
+     * Allow transferring the input buffer to the worker (zero-copy).
+     * When true, the input Uint8Array's underlying buffer will be transferred
+     * and become unusable in the main thread.
+     *
+     * Use this for better performance when you don't need the input data after compression.
+     *
+     * Defaults to false (data is copied to preserve the original buffer).
+     */
+    allowTransfer?: boolean;
+}
+/**
+ * Result of a worker task
+ */
+export interface TaskResult {
+    /** Processed output data */
+    data: Uint8Array;
+    /** Processing time in milliseconds */
+    duration: number;
+}

package/dist/browser/modules/archive/compression/worker-pool/types.js

@@ -0,0 +1,7 @@
+/**
+ * Worker Pool Types
+ *
+ * Shared type definitions for the worker pool system.
+ * Used by both the main thread and worker scripts.
+ */
+export {};

package/dist/browser/modules/archive/compression/worker-pool/worker-script.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Inline Worker Script Generator
+ *
+ * Generates the worker script code that handles compression/decompression tasks.
+ * Uses native CompressionStream/DecompressionStream when available,
+ * falls back to a pure JS implementation message protocol.
+ */
+/**
+ * Generate the inline worker script code
+ *
+ * The worker supports:
+ * - deflate: Compress data using deflate-raw
+ * - inflate: Decompress data using deflate-raw
+ *
+ * It uses native Web Streams API when available, which is significantly faster
+ * than any pure JS implementation.
+ */
+export declare function generateWorkerScript(): string;
+/**
+ * Get or create the worker blob URL (increments reference count)
+ */
+export declare function getWorkerBlobUrl(): string;
+/**
+ * Release the cached worker blob URL (decrements reference count)
+ */
+export declare function releaseWorkerBlobUrl(): void;

package/dist/browser/modules/archive/compression/worker-pool/worker-script.js

@@ -0,0 +1,337 @@
+/**
+ * Inline Worker Script Generator
+ *
+ * Generates the worker script code that handles compression/decompression tasks.
+ * Uses native CompressionStream/DecompressionStream when available,
+ * falls back to a pure JS implementation message protocol.
+ */
+/**
+ * Generate the inline worker script code
+ *
+ * The worker supports:
+ * - deflate: Compress data using deflate-raw
+ * - inflate: Decompress data using deflate-raw
+ *
+ * It uses native Web Streams API when available, which is significantly faster
+ * than any pure JS implementation.
+ */
+export function generateWorkerScript() {
+    return `
+'use strict';
+
+// Check deflate-raw support once at startup
+const hasDeflateRaw = (() => {
+  try {
+    new CompressionStream('deflate-raw');
+    new DecompressionStream('deflate-raw');
+    return true;
+  } catch {
+    return false;
+  }
+})();
+
+const EMPTY_UINT8ARRAY = new Uint8Array(0);
+
+/**
+ * Process data through a TransformStream (compress or decompress)
+ */
+async function processWithStream(stream, data) {
+  const writer = stream.writable.getWriter();
+  const reader = stream.readable.getReader();
+
+  // Start reading output
+  let firstChunk = null;
+  let chunks = null;
+  const readPromise = (async () => {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) {
+        continue;
+      }
+      if (firstChunk === null) {
+        firstChunk = value;
+      } else if (chunks === null) {
+        chunks = [firstChunk, value];
+      } else {
+        chunks.push(value);
+      }
+    }
+  })();
+
+  // Write input and close
+  await writer.write(data);
+  await writer.close();
+
+  // Wait for all output
+  await readPromise;
+
+  // Fast path for common cases
+  if (firstChunk === null) return EMPTY_UINT8ARRAY;
+  if (chunks === null) return firstChunk;
+
+  // Pre-calculate total length and allocate once
+  let totalLen = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    totalLen += chunks[i].length;
+  }
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i];
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
+/**
+ * Streaming sessions keyed by taskId.
+ * Each session keeps a transform stream open and produces output chunks as they are available.
+ */
+const streamingSessions = new Map();
+
+function closeSession(taskId) {
+  const session = streamingSessions.get(taskId);
+  if (!session) return;
+  streamingSessions.delete(taskId);
+  try {
+    if (session.reader) {
+      session.reader.cancel();
+    }
+  } catch {
+    // ignore
+  }
+  try {
+    if (session.writer) {
+      session.writer.abort();
+    }
+  } catch {
+    // ignore
+  }
+}
+
+// Signal ready
+self.postMessage({ type: 'ready' });
+
+function postError(taskId, err, startTime) {
+  const error = typeof err === 'string' ? err : err?.message || String(err);
+  const duration = performance.now() - startTime;
+  self.postMessage({
+    type: 'error',
+    taskId,
+    error,
+    duration
+  });
+}
+
+function postResult(taskId, data, startTime) {
+  const duration = performance.now() - startTime;
+  self.postMessage(
+    { type: 'result', taskId, data, duration },
+    [data.buffer]
+  );
+}
+
+/**
+ * Handle incoming messages
+ */
+self.onmessage = async function(event) {
+  const msg = event.data;
+
+  if (!msg || typeof msg.type !== 'string') {
+    return;
+  }
+
+  // Handle termination request
+  if (msg.type === 'terminate') {
+    self.close();
+    return;
+  }
+
+  // Streaming: start
+  if (msg.type === 'start') {
+    const { taskId, taskType, level } = msg;
+    const startTime = performance.now();
+    try {
+      if (!hasDeflateRaw) {
+        throw new Error('deflate-raw not supported in this worker');
+      }
+      if (typeof taskId !== 'number') {
+        throw new Error('Invalid taskId');
+      }
+      if (streamingSessions.has(taskId)) {
+        throw new Error('Streaming task already started');
+      }
+
+      const stream = taskType === 'deflate'
+        ? new CompressionStream('deflate-raw')
+        : taskType === 'inflate'
+          ? new DecompressionStream('deflate-raw')
+          : null;
+      if (!stream) {
+        throw new Error('Unknown task type: ' + taskType);
+      }
+
+      // Note: CompressionStream does not expose compression level.
+      // We keep level for API shape parity (ignored in worker).
+      void level;
+
+      const writer = stream.writable.getWriter();
+      const reader = stream.readable.getReader();
+
+      const session = {
+        writer,
+        reader,
+        startTime,
+        closed: false,
+        startedMessage: { type: 'started', taskId },
+        outMessage: { type: 'out', taskId, data: null },
+        ackMessage: { type: 'ack', taskId },
+        doneMessage: { type: 'done', taskId, duration: 0 },
+        readLoop: null
+      };
+
+      session.readLoop = (async () => {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (value) {
+              session.outMessage.data = value;
+              self.postMessage(session.outMessage, [value.buffer]);
+            }
+          }
+        } catch (err) {
+          // Reader failures will be handled by chunk/end paths too.
+        }
+      })();
+
+      streamingSessions.set(taskId, session);
+      self.postMessage(session.startedMessage);
+      return;
+    } catch (err) {
+      postError(taskId, err, startTime);
+      closeSession(taskId);
+      return;
+    }
+  }
+
+  // Streaming: chunk
+  if (msg.type === 'chunk') {
+    const { taskId, data } = msg;
+    const session = streamingSessions.get(taskId);
+    if (!session || session.closed) {
+      // If the session is gone, ignore.
+      return;
+    }
+    try {
+      await session.writer.write(data);
+      self.postMessage(session.ackMessage);
+    } catch (err) {
+      postError(taskId, err, session.startTime);
+      session.closed = true;
+      closeSession(taskId);
+    }
+    return;
+  }
+
+  // Streaming: end
+  if (msg.type === 'end') {
+    const { taskId } = msg;
+    const session = streamingSessions.get(taskId);
+    if (!session || session.closed) {
+      return;
+    }
+    session.closed = true;
+    try {
+      await session.writer.close();
+      if (session.readLoop) {
+        await session.readLoop;
+      }
+      session.doneMessage.duration = performance.now() - session.startTime;
+      self.postMessage(session.doneMessage);
+    } catch (err) {
+      postError(taskId, err, session.startTime);
+    } finally {
+      closeSession(taskId);
+    }
+    return;
+  }
+
+  // Streaming: abort
+  if (msg.type === 'abort') {
+    const { taskId } = msg;
+    const session = streamingSessions.get(taskId);
+    if (!session) {
+      return;
+    }
+    session.closed = true;
+    closeSession(taskId);
+    postError(taskId, msg.error || 'aborted', session.startTime);
+    return;
+  }
+
+  // Handle task request
+  if (msg.type === 'task') {
+    const { taskId, taskType, data } = msg;
+    const startTime = performance.now();
+
+    try {
+      if (!hasDeflateRaw) {
+        throw new Error('deflate-raw not supported in this worker');
+      }
+
+      let stream;
+      switch (taskType) {
+        case 'deflate':
+          stream = new CompressionStream('deflate-raw');
+          break;
+        case 'inflate':
+          stream = new DecompressionStream('deflate-raw');
+          break;
+        default:
+          throw new Error('Unknown task type: ' + taskType);
+      }
+
+      const result = await processWithStream(stream, data);
+
+      // Transfer the result buffer for zero-copy
+      postResult(taskId, result, startTime);
+    } catch (err) {
+      postError(taskId, err, startTime);
+    }
+  }
+};
+`;
+}
+// Cache the worker URL with reference counting
+let _workerBlobUrl = null;
+let _workerBlobUrlRefCount = 0;
+/**
+ * Get or create the worker blob URL (increments reference count)
+ */
+export function getWorkerBlobUrl() {
+    if (_workerBlobUrl === null) {
+        const script = generateWorkerScript();
+        const blob = new Blob([script], { type: "text/javascript" });
+        _workerBlobUrl = URL.createObjectURL(blob);
+    }
+    _workerBlobUrlRefCount++;
+    return _workerBlobUrl;
+}
+/**
+ * Release the cached worker blob URL (decrements reference count)
+ */
+export function releaseWorkerBlobUrl() {
+    if (_workerBlobUrl !== null && --_workerBlobUrlRefCount <= 0) {
+        try {
+            URL.revokeObjectURL(_workerBlobUrl);
+        }
+        catch {
+            // Ignore errors during cleanup
+        }
+        _workerBlobUrl = null;
+        _workerBlobUrlRefCount = 0;
+    }
+}