@dvvebond/core 0.2.12

package/dist/parsing-worker-host-COnJliNW.mjs

@@ -0,0 +1,3 @@
+import { d as isWorkerSupported, n as createParsingWorkerHost, t as ParsingWorkerHost } from "./parsing-worker-host-CcJO1eh7.mjs";
+
+export { createParsingWorkerHost };

package/dist/parsing-worker-host-CcJO1eh7.mjs

@@ -0,0 +1,550 @@
+//#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 = 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 ? "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
+export { isResponse as _, createDeferred as a, generateParsingMessageId as c, isWorkerSupported as d, createParsingProgress as f, isProgress as g, generateTaskId as h, calculateParsingTimeout as i, generateParsingTaskId as l, createWorkerError as m, createParsingWorkerHost as n, detectEnvironment as o, createRequest as p, DEFAULT_PARSING_TIMEOUTS as r, extractTransferables as s, ParsingWorkerHost as t, isWorkerContext as u };
+//# sourceMappingURL=parsing-worker-host-CcJO1eh7.mjs.map