@dvvebond/core 0.2.12 → 0.2.13

package/dist/parsing-worker-host-CBKQ4mss.cjs

@@ -0,0 +1,652 @@
+
+//#region src/worker/messages.ts
+/**
+* Generate a unique message ID.
+*/
+function generateMessageId() {
+	return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+* Generate a unique task ID.
+*/
+function generateTaskId() {
+	return `task-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+* Check if a message is a response.
+*/
+function isResponse(message) {
+	return typeof message === "object" && message !== null && "type" in message && message.type === "response";
+}
+/**
+* Check if a message is a progress update.
+*/
+function isProgress(message) {
+	return typeof message === "object" && message !== null && "type" in message && message.type === "progress";
+}
+/**
+* Create a request message.
+*/
+function createRequest(requestType, data) {
+	return {
+		type: "request",
+		id: generateMessageId(),
+		requestType,
+		data
+	};
+}
+/**
+* Create a WorkerError from an Error.
+*/
+function createWorkerError(error, code) {
+	return {
+		code: code ?? error.name,
+		message: error.message,
+		stack: error.stack
+	};
+}
+
+//#endregion
+//#region src/worker/parsing-types.ts
+/**
+* Check if a message is a parsing progress message.
+*/
+function isParsingProgress(message) {
+	return typeof message === "object" && message !== null && "type" in message && message.type === "parsingProgress";
+}
+/**
+* Check if a message is a parsing worker response.
+*/
+function isParsingResponse(message) {
+	return typeof message === "object" && message !== null && "type" in message && message.type === "response" && "requestType" in message && [
+		"parseDocument",
+		"extractText",
+		"cancelParsing"
+	].includes(message.requestType);
+}
+/**
+* Create a parsing progress message.
+*/
+function createParsingProgress(taskId, progress) {
+	return {
+		type: "parsingProgress",
+		taskId,
+		progress,
+		timestamp: Date.now()
+	};
+}
+
+//#endregion
+//#region src/worker/parsing-utils.ts
+/**
+* Detect the current runtime environment.
+*/
+function detectEnvironment() {
+	if (typeof globalThis !== "undefined" && "Bun" in globalThis) return "bun";
+	if (typeof globalThis !== "undefined" && "Deno" in globalThis) return "deno";
+	if (typeof globalThis !== "undefined" && typeof globalThis.process?.versions?.node === "string") return "node";
+	if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
+	if (typeof self !== "undefined" && typeof self.importScripts === "function") return "browser";
+	return "unknown";
+}
+/**
+* Check if Web Workers are supported in the current environment.
+*/
+function isWorkerSupported() {
+	switch (detectEnvironment()) {
+		case "browser": return typeof Worker !== "undefined";
+		case "node": return false;
+		case "bun": return typeof Worker !== "undefined";
+		case "deno": return typeof Worker !== "undefined";
+		default: return false;
+	}
+}
+/**
+* Check if we're currently running inside a Web Worker.
+*/
+function isWorkerContext() {
+	return typeof self !== "undefined" && typeof self.importScripts === "function" && typeof window === "undefined";
+}
+/**
+* Create a Worker instance with proper error handling.
+*
+* @throws Error if workers are not supported or creation fails
+*/
+function createWorkerInstance(options) {
+	if (!isWorkerSupported()) throw new Error(`Web Workers are not supported in ${detectEnvironment()} environment. Use the synchronous parsing API instead.`);
+	const { workerUrl, name, module: module$1 = true } = options;
+	if (!workerUrl) throw new Error("Worker URL is required. Provide workerUrl pointing to the bundled parsing worker script.");
+	try {
+		return new Worker(workerUrl, {
+			type: module$1 ? "module" : "classic",
+			name: name ?? `parsing-worker-${Date.now()}`
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to create parsing worker: ${message}`, { cause: error });
+	}
+}
+/**
+* Extract transferable objects from data for efficient worker communication.
+*
+* Identifies ArrayBuffer instances that can be transferred (zero-copy)
+* instead of copied between threads.
+*/
+function extractTransferables(data) {
+	const transferables = [];
+	const seen = /* @__PURE__ */ new WeakSet();
+	function collect(value) {
+		if (value === null || typeof value !== "object") return;
+		if (seen.has(value)) return;
+		seen.add(value);
+		if (value instanceof ArrayBuffer) {
+			transferables.push(value);
+			return;
+		}
+		if (ArrayBuffer.isView(value) && value.buffer instanceof ArrayBuffer) {
+			if (value.byteOffset === 0 && value.byteLength === value.buffer.byteLength) transferables.push(value.buffer);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const item of value) collect(item);
+			return;
+		}
+		for (const key of Object.keys(value)) collect(value[key]);
+	}
+	collect(data);
+	return transferables;
+}
+/**
+* Generate a unique ID for messages.
+*/
+function generateParsingMessageId() {
+	return `parse-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+* Generate a unique task ID for parsing operations.
+*/
+function generateParsingTaskId() {
+	return `parsing-task-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+* Default timeouts for parsing operations (in milliseconds).
+*/
+const DEFAULT_PARSING_TIMEOUTS = {
+	init: 1e4,
+	small: 3e4,
+	medium: 6e4,
+	large: 3e5,
+	textPerPage: 5e3
+};
+/**
+* Calculate appropriate timeout based on document size.
+*/
+function calculateParsingTimeout(sizeBytes) {
+	const sizeMB = sizeBytes / (1024 * 1024);
+	if (sizeMB < 1) return DEFAULT_PARSING_TIMEOUTS.small;
+	if (sizeMB < 10) return DEFAULT_PARSING_TIMEOUTS.medium;
+	return DEFAULT_PARSING_TIMEOUTS.large;
+}
+/**
+* Create a deferred promise for async coordination.
+*/
+function createDeferred() {
+	let resolve;
+	let reject;
+	let isPending = true;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = (value) => {
+				isPending = false;
+				res(value);
+			};
+			reject = (reason) => {
+				isPending = false;
+				rej(reason);
+			};
+		}),
+		resolve,
+		reject,
+		get isPending() {
+			return isPending;
+		}
+	};
+}
+
+//#endregion
+//#region src/worker/parsing-worker-host.ts
+/**
+* Main thread interface for parsing worker communication.
+*
+* ParsingWorkerHost manages the lifecycle of a parsing worker and provides
+* a Promise-based API for document parsing operations. It handles:
+* - Worker creation and initialization
+* - Message passing with request/response correlation
+* - Progress event handling with 500ms throttling
+* - Cancellation support
+* - Graceful shutdown and cleanup
+*/
+/**
+* ParsingWorkerHost manages a Web Worker for PDF parsing operations.
+*
+* @example
+* ```typescript
+* const host = new ParsingWorkerHost({
+*   workerUrl: '/parsing-worker.js',
+*   onProgress: (progress) => console.log(`${progress.percent}%`),
+* });
+*
+* await host.initialize();
+*
+* const result = await host.parse(pdfBytes);
+* console.log(`Parsed ${result.info.pageCount} pages`);
+*
+* const text = await host.extractText(result.documentId);
+* console.log(text.pages[0].text);
+*
+* await host.terminate();
+* ```
+*/
+var ParsingWorkerHost = class {
+	_worker = null;
+	_state = "idle";
+	_options;
+	_pendingRequests = /* @__PURE__ */ new Map();
+	_taskProgressHandlers = /* @__PURE__ */ new Map();
+	_initPromise = null;
+	constructor(options) {
+		this._options = {
+			workerUrl: options.workerUrl,
+			name: options.name ?? `parsing-worker-host-${Date.now()}`,
+			verbose: options.verbose ?? false,
+			initTimeout: options.initTimeout ?? 1e4,
+			defaultTimeout: options.defaultTimeout ?? 6e4,
+			onProgress: options.onProgress,
+			onError: options.onError,
+			onStateChange: options.onStateChange
+		};
+	}
+	/**
+	* Current worker state.
+	*/
+	get state() {
+		return this._state;
+	}
+	/**
+	* Whether the worker is ready to accept requests.
+	*/
+	get isReady() {
+		return this._state === "ready" || this._state === "busy";
+	}
+	/**
+	* Whether the worker has been terminated.
+	*/
+	get isTerminated() {
+		return this._state === "terminated";
+	}
+	/**
+	* Number of pending requests.
+	*/
+	get pendingCount() {
+		return this._pendingRequests.size;
+	}
+	/**
+	* Worker name.
+	*/
+	get name() {
+		return this._options.name;
+	}
+	/**
+	* Initialize the worker.
+	*
+	* Creates the Web Worker instance and waits for it to be ready.
+	* This method is idempotent — calling it multiple times returns the same promise.
+	*
+	* @throws Error if workers are not supported, creation fails, or initialization times out
+	*/
+	async initialize() {
+		if (this._initPromise) return this._initPromise;
+		if (this._state === "terminated") throw new Error("Cannot initialize a terminated worker");
+		this._initPromise = this._doInitialize();
+		return this._initPromise;
+	}
+	async _doInitialize() {
+		this._setState("initializing");
+		try {
+			this._worker = createWorkerInstance({
+				workerUrl: this._options.workerUrl,
+				name: this._options.name,
+				module: true
+			});
+			this._worker.onmessage = this._handleMessage.bind(this);
+			this._worker.onerror = this._handleError.bind(this);
+			await this._sendRequest("init", {
+				verbose: this._options.verbose,
+				name: this._options.name
+			}, this._options.initTimeout);
+			this._setState("ready");
+		} catch (error) {
+			this._setState("error");
+			this._cleanup();
+			throw error;
+		}
+	}
+	/**
+	* Terminate the worker.
+	*
+	* @param graceful - If true, wait for pending operations to complete
+	* @param timeout - Timeout for graceful shutdown in milliseconds
+	*/
+	async terminate(graceful = true, timeout = 5e3) {
+		if (this._state === "terminated") return;
+		if (graceful && this._worker && this.isReady) try {
+			await Promise.race([this._sendRequest("terminate", void 0, timeout), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Terminate timeout")), timeout))]);
+		} catch {}
+		this._forceTerminate();
+	}
+	_forceTerminate() {
+		for (const pending of this._pendingRequests.values()) {
+			if (pending.timeoutId) clearTimeout(pending.timeoutId);
+			pending.deferred.reject(/* @__PURE__ */ new Error("Worker terminated"));
+		}
+		this._pendingRequests.clear();
+		this._taskProgressHandlers.clear();
+		if (this._worker) {
+			this._worker.terminate();
+			this._worker = null;
+		}
+		this._setState("terminated");
+		this._initPromise = null;
+	}
+	_cleanup() {
+		for (const pending of this._pendingRequests.values()) if (pending.timeoutId) clearTimeout(pending.timeoutId);
+		this._pendingRequests.clear();
+		this._taskProgressHandlers.clear();
+	}
+	/**
+	* Parse a PDF document.
+	*
+	* @param bytes - PDF file bytes
+	* @param options - Parse options
+	* @returns Parsed document information
+	*/
+	async parse(bytes, options) {
+		await this._ensureInitialized();
+		const taskId = generateParsingTaskId();
+		const timeout = options?.timeout ?? calculateParsingTimeout(bytes.length);
+		if (options?.onProgress) this._taskProgressHandlers.set(taskId, options.onProgress);
+		try {
+			const response = await this._sendRequest("parseDocument", {
+				bytes,
+				taskId,
+				options: {
+					lenient: options?.lenient,
+					password: options?.password,
+					bruteForceRecovery: options?.bruteForceRecovery,
+					progressInterval: options?.progressInterval
+				}
+			}, timeout, taskId, [bytes.buffer]);
+			if (response.status === "cancelled") throw new Error("Operation cancelled");
+			if (response.status === "error" || !response.data) throw new Error(response.error?.message ?? "Failed to parse document");
+			return response.data;
+		} finally {
+			this._taskProgressHandlers.delete(taskId);
+		}
+	}
+	/**
+	* Parse a PDF document with cancellation support.
+	*/
+	parseCancellable(bytes, options) {
+		const taskId = generateParsingTaskId();
+		return {
+			promise: this.parse(bytes, {
+				...options,
+				taskId
+			}),
+			taskId,
+			cancel: () => this.cancel(taskId)
+		};
+	}
+	/**
+	* Extract text from a parsed document.
+	*
+	* @param documentId - Document ID from parse result
+	* @param options - Extraction options
+	* @returns Extracted text per page
+	*/
+	async extractText(documentId, options) {
+		await this._ensureInitialized();
+		const taskId = generateParsingTaskId();
+		const timeout = options?.timeout ?? this._options.defaultTimeout;
+		if (options?.onProgress) this._taskProgressHandlers.set(taskId, options.onProgress);
+		try {
+			const response = await this._sendRequest("extractText", {
+				documentId,
+				taskId,
+				pageIndices: options?.pages,
+				includePositions: options?.includePositions
+			}, timeout, taskId);
+			if (response.status === "cancelled") throw new Error("Operation cancelled");
+			if (response.status === "error" || !response.data) throw new Error(response.error?.message ?? "Failed to extract text");
+			return response.data;
+		} finally {
+			this._taskProgressHandlers.delete(taskId);
+		}
+	}
+	/**
+	* Cancel an active parsing operation.
+	*
+	* @param taskId - Task ID to cancel
+	* @returns Whether the task was successfully cancelled
+	*/
+	async cancel(taskId) {
+		if (!this.isReady) return false;
+		try {
+			const response = await this._sendRequest("cancelParsing", { taskId }, 5e3);
+			return response.status === "success" && response.data?.wasCancelled;
+		} catch {
+			return false;
+		}
+	}
+	async _ensureInitialized() {
+		if (this._state === "terminated") throw new Error("Worker has been terminated");
+		if (!this.isReady) await this.initialize();
+	}
+	_sendRequest(requestType, data, timeout, taskId, transferables) {
+		if (this._state === "terminated") return Promise.reject(/* @__PURE__ */ new Error("Worker has been terminated"));
+		if (!this._worker) return Promise.reject(/* @__PURE__ */ new Error("Worker not initialized"));
+		const messageId = generateMessageId();
+		const actualTaskId = taskId ?? generateTaskId();
+		const deferred = createDeferred();
+		const timeoutId = setTimeout(() => {
+			const pending$1 = this._pendingRequests.get(messageId);
+			if (pending$1) {
+				this._pendingRequests.delete(messageId);
+				this._updateBusyState();
+				pending$1.deferred.reject(/* @__PURE__ */ new Error(`Request timeout after ${timeout}ms: ${requestType}`));
+			}
+		}, timeout);
+		const pending = {
+			messageId,
+			taskId: actualTaskId,
+			deferred,
+			timeoutId
+		};
+		this._pendingRequests.set(messageId, pending);
+		if (this._state === "ready") this._setState("busy");
+		const request = {
+			type: "request",
+			id: messageId,
+			requestType,
+			data
+		};
+		try {
+			if (transferables && transferables.length > 0) this._worker.postMessage(request, transferables);
+			else this._worker.postMessage(request);
+		} catch (error) {
+			clearTimeout(timeoutId);
+			this._pendingRequests.delete(messageId);
+			this._updateBusyState();
+			return Promise.reject(error);
+		}
+		return deferred.promise;
+	}
+	_handleMessage(event) {
+		const message = event.data;
+		if (isParsingProgress(message)) this._handleProgress(message);
+		else if (isParsingResponse(message)) this._handleResponse(message);
+		else if (typeof message === "object" && message !== null && "type" in message) {
+			if (message.type === "response") this._handleResponse(message);
+		}
+	}
+	_handleResponse(response) {
+		const pending = this._pendingRequests.get(response.id);
+		if (!pending) return;
+		if (pending.timeoutId) clearTimeout(pending.timeoutId);
+		this._pendingRequests.delete(response.id);
+		this._updateBusyState();
+		if (response.status === "error" && response.error) pending.deferred.reject(new Error(response.error.message));
+		else pending.deferred.resolve(response);
+	}
+	_handleProgress(progress) {
+		const taskHandler = this._taskProgressHandlers.get(progress.taskId);
+		if (taskHandler) taskHandler(progress.progress);
+		if (this._options.onProgress) this._options.onProgress(progress.progress);
+	}
+	_handleError(event) {
+		const error = {
+			code: "INTERNAL_ERROR",
+			message: event.message ?? "Unknown worker error",
+			recoverable: false
+		};
+		if (this._options.onError) this._options.onError(error);
+		if (this._state !== "initializing") {
+			for (const pending of this._pendingRequests.values()) {
+				if (pending.timeoutId) clearTimeout(pending.timeoutId);
+				pending.deferred.reject(new Error(error.message));
+			}
+			this._pendingRequests.clear();
+			this._setState("error");
+		}
+	}
+	_updateBusyState() {
+		if (this._state === "busy" && this._pendingRequests.size === 0) this._setState("ready");
+	}
+	_setState(newState) {
+		const previousState = this._state;
+		if (previousState === newState) return;
+		this._state = newState;
+		if (this._options.onStateChange) this._options.onStateChange(newState, previousState);
+	}
+};
+/**
+* Create a new ParsingWorkerHost instance.
+*/
+function createParsingWorkerHost(options) {
+	return new ParsingWorkerHost(options);
+}
+
+//#endregion
+Object.defineProperty(exports, 'DEFAULT_PARSING_TIMEOUTS', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_PARSING_TIMEOUTS;
+  }
+});
+Object.defineProperty(exports, 'ParsingWorkerHost', {
+  enumerable: true,
+  get: function () {
+    return ParsingWorkerHost;
+  }
+});
+Object.defineProperty(exports, 'calculateParsingTimeout', {
+  enumerable: true,
+  get: function () {
+    return calculateParsingTimeout;
+  }
+});
+Object.defineProperty(exports, 'createDeferred', {
+  enumerable: true,
+  get: function () {
+    return createDeferred;
+  }
+});
+Object.defineProperty(exports, 'createParsingProgress', {
+  enumerable: true,
+  get: function () {
+    return createParsingProgress;
+  }
+});
+Object.defineProperty(exports, 'createParsingWorkerHost', {
+  enumerable: true,
+  get: function () {
+    return createParsingWorkerHost;
+  }
+});
+Object.defineProperty(exports, 'createRequest', {
+  enumerable: true,
+  get: function () {
+    return createRequest;
+  }
+});
+Object.defineProperty(exports, 'createWorkerError', {
+  enumerable: true,
+  get: function () {
+    return createWorkerError;
+  }
+});
+Object.defineProperty(exports, 'detectEnvironment', {
+  enumerable: true,
+  get: function () {
+    return detectEnvironment;
+  }
+});
+Object.defineProperty(exports, 'extractTransferables', {
+  enumerable: true,
+  get: function () {
+    return extractTransferables;
+  }
+});
+Object.defineProperty(exports, 'generateParsingMessageId', {
+  enumerable: true,
+  get: function () {
+    return generateParsingMessageId;
+  }
+});
+Object.defineProperty(exports, 'generateParsingTaskId', {
+  enumerable: true,
+  get: function () {
+    return generateParsingTaskId;
+  }
+});
+Object.defineProperty(exports, 'generateTaskId', {
+  enumerable: true,
+  get: function () {
+    return generateTaskId;
+  }
+});
+Object.defineProperty(exports, 'isProgress', {
+  enumerable: true,
+  get: function () {
+    return isProgress;
+  }
+});
+Object.defineProperty(exports, 'isResponse', {
+  enumerable: true,
+  get: function () {
+    return isResponse;
+  }
+});
+Object.defineProperty(exports, 'isWorkerContext', {
+  enumerable: true,
+  get: function () {
+    return isWorkerContext;
+  }
+});
+Object.defineProperty(exports, 'isWorkerSupported', {
+  enumerable: true,
+  get: function () {
+    return isWorkerSupported;
+  }
+});
+//# sourceMappingURL=parsing-worker-host-CBKQ4mss.cjs.map