web-doc 0.3.0

package/dist/worker-adapter.d.ts

@@ -0,0 +1,24 @@
+import type { AdapterOpenContext, DocumentAdapter, DocumentFormat, DocumentInfo, RenderViewport, TextRun } from "./contracts.js";
+import { WorkerRpcClient, type WorkerLike } from "./worker-client.js";
+interface WorkerHandle {
+    readonly rpc: WorkerRpcClient;
+    readonly timeoutMs: number;
+}
+export interface WorkerDocumentAdapterOptions {
+    readonly id: string;
+    readonly formats: readonly DocumentFormat[];
+    readonly createWorker: () => WorkerLike;
+}
+export declare class WorkerDocumentAdapter implements DocumentAdapter<WorkerHandle> {
+    #private;
+    readonly id: string;
+    readonly formats: readonly DocumentFormat[];
+    constructor(options: WorkerDocumentAdapterOptions);
+    open(data: Uint8Array, context: AdapterOpenContext): Promise<WorkerHandle>;
+    getInfo(handle: WorkerHandle): Promise<DocumentInfo>;
+    render(handle: WorkerHandle, target: HTMLCanvasElement | OffscreenCanvas, viewport: RenderViewport, signal?: AbortSignal): Promise<void>;
+    getTextMap(handle: WorkerHandle, pageIndex: number, signal?: AbortSignal): Promise<readonly TextRun[]>;
+    close(handle: WorkerHandle): Promise<void>;
+    destroy(): Promise<void>;
+}
+export {};

package/dist/worker-adapter.js

@@ -0,0 +1,97 @@
+import { ViewerError } from "./errors.js";
+import { WorkerRpcClient } from "./worker-client.js";
+export class WorkerDocumentAdapter {
+    id;
+    formats;
+    #createWorker;
+    #handles = new Set();
+    constructor(options) {
+        this.id = options.id;
+        this.formats = options.formats;
+        this.#createWorker = options.createWorker;
+    }
+    async open(data, context) {
+        const rpc = new WorkerRpcClient(this.#createWorker());
+        const handle = { rpc, timeoutMs: context.limits.maxOperationMs };
+        const transferable = data.slice().buffer;
+        const payload = {
+            data: transferable,
+            format: context.format,
+            limits: context.limits,
+            ...(context.fileName ? { fileName: context.fileName } : {}),
+            ...(context.contentType ? { contentType: context.contentType } : {}),
+        };
+        try {
+            await rpc.request("init", undefined, {
+                signal: context.signal,
+                timeoutMs: context.limits.maxOperationMs,
+            });
+            await rpc.request("open", payload, {
+                signal: context.signal,
+                transfer: [transferable],
+                onProgress: context.reportProgress,
+                onWarning: context.reportWarning,
+                timeoutMs: context.limits.maxOperationMs,
+            });
+            this.#handles.add(handle);
+            return handle;
+        }
+        catch (error) {
+            rpc.destroy();
+            throw error;
+        }
+    }
+    getInfo(handle) {
+        return handle.rpc.request("get-info", undefined, {
+            timeoutMs: handle.timeoutMs,
+        });
+    }
+    async render(handle, target, viewport, signal) {
+        const payload = viewport;
+        const bitmap = await handle.rpc.request("render", payload, {
+            ...(signal ? { signal } : {}),
+            timeoutMs: handle.timeoutMs,
+        });
+        const bitmapContext = target.getContext("bitmaprenderer");
+        if (bitmapContext) {
+            bitmapContext.transferFromImageBitmap(bitmap);
+            return;
+        }
+        const context = target.getContext("2d");
+        if (!context) {
+            bitmap.close();
+            throw new ViewerError("render-failed", "Canvas has no 2D or bitmaprenderer context");
+        }
+        context.drawImage(bitmap, 0, 0);
+        bitmap.close();
+    }
+    getTextMap(handle, pageIndex, signal) {
+        return handle.rpc.request("get-text-map", { pageIndex }, { ...(signal ? { signal } : {}), timeoutMs: handle.timeoutMs });
+    }
+    async close(handle) {
+        if (!this.#handles.delete(handle))
+            return;
+        try {
+            await handle.rpc.request("close", undefined, {
+                timeoutMs: handle.timeoutMs,
+            });
+        }
+        finally {
+            handle.rpc.destroy();
+        }
+    }
+    async destroy() {
+        const handles = [...this.#handles];
+        this.#handles.clear();
+        await Promise.all(handles.map(async (handle) => {
+            try {
+                await handle.rpc.request("destroy", undefined, {
+                    timeoutMs: handle.timeoutMs,
+                });
+            }
+            finally {
+                handle.rpc.destroy();
+            }
+        }));
+    }
+}

package/dist/worker-client.d.ts

@@ -0,0 +1,23 @@
+import type { ViewerProgress, ViewerWarning } from "./contracts.js";
+import type { WorkerInboundMessage, WorkerOperation, WorkerOutboundMessage } from "./worker-protocol.js";
+export interface WorkerLike {
+    postMessage(message: WorkerInboundMessage, transfer?: Transferable[]): void;
+    addEventListener(type: "message", listener: (event: MessageEvent<WorkerOutboundMessage>) => void): void;
+    addEventListener(type: "error" | "messageerror", listener: (event: Event) => void): void;
+    removeEventListener(type: "message", listener: (event: MessageEvent<WorkerOutboundMessage>) => void): void;
+    removeEventListener(type: "error" | "messageerror", listener: (event: Event) => void): void;
+    terminate(): void;
+}
+export interface WorkerRequestOptions {
+    readonly signal?: AbortSignal;
+    readonly onProgress?: (progress: ViewerProgress) => void;
+    readonly onWarning?: (warning: ViewerWarning) => void;
+    readonly transfer?: Transferable[];
+    readonly timeoutMs?: number;
+}
+export declare class WorkerRpcClient {
+    #private;
+    constructor(worker: WorkerLike);
+    request<T>(operation: WorkerOperation, payload?: unknown, options?: WorkerRequestOptions): Promise<T>;
+    destroy(): void;
+}

package/dist/worker-client.js

@@ -0,0 +1,105 @@
+import { abortError, errorFromData, ViewerError } from "./errors.js";
+import { transferablesFor } from "./worker-protocol.js";
+export class WorkerRpcClient {
+    #worker;
+    #pending = new Map();
+    #nextId = 1;
+    #destroyed = false;
+    constructor(worker) {
+        this.#worker = worker;
+        worker.addEventListener("message", this.#onMessage);
+        worker.addEventListener("error", this.#onCrash);
+        worker.addEventListener("messageerror", this.#onCrash);
+    }
+    request(operation, payload, options = {}) {
+        if (this.#destroyed)
+            return Promise.reject(new ViewerError("lifecycle-error", "Worker client is destroyed"));
+        if (options.signal?.aborted)
+            return Promise.reject(abortError());
+        const id = this.#nextId++;
+        const message = {
+            kind: "request",
+            id,
+            operation,
+            ...(payload === undefined ? {} : { payload }),
+        };
+        return new Promise((resolve, reject) => {
+            const abort = options.signal
+                ? () => {
+                    this.#worker.postMessage({ kind: "cancel", id });
+                    this.#finish(id, abortError());
+                }
+                : undefined;
+            const pending = {
+                resolve: resolve,
+                reject,
+                ...(options.onProgress ? { onProgress: options.onProgress } : {}),
+                ...(options.onWarning ? { onWarning: options.onWarning } : {}),
+                ...(options.signal ? { signal: options.signal } : {}),
+                ...(abort ? { abort } : {}),
+                ...(options.timeoutMs
+                    ? {
+                        timeout: setTimeout(() => {
+                            const error = operationTimeout(operation, options.timeoutMs);
+                            this.#worker.postMessage({ kind: "cancel", id });
+                            this.#terminate(error);
+                        }, options.timeoutMs),
+                    }
+                    : {}),
+            };
+            this.#pending.set(id, pending);
+            options.signal?.addEventListener("abort", abort, { once: true });
+            this.#worker.postMessage(message, options.transfer ?? transferablesFor(payload));
+        });
+    }
+    destroy() {
+        this.#terminate(new ViewerError("worker-crashed", "Worker terminated"));
+    }
+    #terminate(error) {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        this.#worker.removeEventListener("message", this.#onMessage);
+        this.#worker.removeEventListener("error", this.#onCrash);
+        this.#worker.removeEventListener("messageerror", this.#onCrash);
+        this.#worker.terminate();
+        for (const id of this.#pending.keys())
+            this.#finish(id, error);
+    }
+    #onMessage = (event) => {
+        const message = event.data;
+        const pending = this.#pending.get(message.id);
+        if (!pending)
+            return;
+        if (message.kind === "progress")
+            pending.onProgress?.(message.progress);
+        else if (message.kind === "warning")
+            pending.onWarning?.(message.warning);
+        else if (message.kind === "success")
+            this.#finish(message.id, undefined, message.result);
+        else
+            this.#finish(message.id, errorFromData(message.error));
+    };
+    #onCrash = () => {
+        const error = new ViewerError("worker-crashed", "Document worker crashed");
+        for (const id of this.#pending.keys())
+            this.#finish(id, error);
+    };
+    #finish(id, error, value) {
+        const pending = this.#pending.get(id);
+        if (!pending)
+            return;
+        this.#pending.delete(id);
+        if (pending.abort && pending.signal)
+            pending.signal.removeEventListener("abort", pending.abort);
+        if (pending.timeout)
+            clearTimeout(pending.timeout);
+        if (error)
+            pending.reject(error);
+        else
+            pending.resolve(value);
+    }
+}
+function operationTimeout(operation, timeoutMs) {
+    return new ViewerError("resource-limit", `Worker operation ${operation} exceeded maxOperationMs`, { details: { operation, timeoutMs } });
+}

package/dist/worker-endpoint.d.ts

@@ -0,0 +1,13 @@
+import type { ViewerProgress, ViewerWarning } from "./contracts.js";
+import type { WorkerInboundMessage, WorkerOperation, WorkerOutboundMessage } from "./worker-protocol.js";
+export interface WorkerScopeLike {
+    postMessage(message: WorkerOutboundMessage, transfer?: Transferable[]): void;
+    addEventListener(type: "message", listener: (event: MessageEvent<WorkerInboundMessage>) => void): void;
+    removeEventListener(type: "message", listener: (event: MessageEvent<WorkerInboundMessage>) => void): void;
+}
+export type WorkerOperationHandler = (operation: WorkerOperation, payload: unknown, context: {
+    signal: AbortSignal;
+    reportProgress: (progress: ViewerProgress) => void;
+    reportWarning: (warning: ViewerWarning) => void;
+}) => Promise<unknown>;
+export declare function attachWorkerEndpoint(scope: WorkerScopeLike, handler: WorkerOperationHandler): () => void;

package/dist/worker-endpoint.js

@@ -0,0 +1,57 @@
+import { normalizeError } from "./errors.js";
+import { transferablesFor } from "./worker-protocol.js";
+export function attachWorkerEndpoint(scope, handler) {
+    const operations = new Map();
+    const onMessage = (event) => {
+        const message = event.data;
+        if (message.kind === "cancel") {
+            cancel(operations, message);
+            return;
+        }
+        void run(scope, handler, operations, message);
+    };
+    scope.addEventListener("message", onMessage);
+    return () => {
+        scope.removeEventListener("message", onMessage);
+        for (const controller of operations.values())
+            controller.abort();
+        operations.clear();
+    };
+}
+async function run(scope, handler, operations, request) {
+    const controller = new AbortController();
+    operations.set(request.id, controller);
+    try {
+        const result = await handler(request.operation, request.payload, {
+            signal: controller.signal,
+            reportProgress: (progress) => scope.postMessage({
+                kind: "progress",
+                id: request.id,
+                progress,
+            }),
+            reportWarning: (warning) => scope.postMessage({
+                kind: "warning",
+                id: request.id,
+                warning,
+            }),
+        });
+        scope.postMessage({
+            kind: "success",
+            id: request.id,
+            ...(result === undefined ? {} : { result }),
+        }, transferablesFor(result));
+    }
+    catch (error) {
+        scope.postMessage({
+            kind: "failure",
+            id: request.id,
+            error: normalizeError(error).toJSON(),
+        });
+    }
+    finally {
+        operations.delete(request.id);
+    }
+}
+function cancel(operations, message) {
+    operations.get(message.id)?.abort();
+}

package/dist/worker-protocol.d.ts

@@ -0,0 +1,48 @@
+import type { DocumentFormat, DocumentInfo, ResourceLimits, TextRun, ViewerErrorData, ViewerProgress, ViewerWarning } from "./contracts.js";
+export type WorkerOperation = "init" | "open" | "get-info" | "render" | "get-text-map" | "close" | "destroy";
+export interface WorkerRequest {
+    readonly kind: "request";
+    readonly id: number;
+    readonly operation: WorkerOperation;
+    readonly payload?: unknown;
+}
+export interface WorkerCancel {
+    readonly kind: "cancel";
+    readonly id: number;
+}
+export interface WorkerSuccess {
+    readonly kind: "success";
+    readonly id: number;
+    readonly result?: unknown;
+}
+export interface WorkerFailure {
+    readonly kind: "failure";
+    readonly id: number;
+    readonly error: ViewerErrorData;
+}
+export interface WorkerProgressMessage {
+    readonly kind: "progress";
+    readonly id: number;
+    readonly progress: ViewerProgress;
+}
+export interface WorkerWarningMessage {
+    readonly kind: "warning";
+    readonly id: number;
+    readonly warning: ViewerWarning;
+}
+export type WorkerInboundMessage = WorkerRequest | WorkerCancel;
+export type WorkerOutboundMessage = WorkerSuccess | WorkerFailure | WorkerProgressMessage | WorkerWarningMessage;
+export interface WorkerOpenPayload {
+    readonly data: ArrayBuffer;
+    readonly format: DocumentFormat;
+    readonly limits: ResourceLimits;
+    readonly fileName?: string;
+    readonly contentType?: string;
+}
+export interface WorkerRenderPayload {
+    readonly pageIndex: number;
+    readonly zoom: number;
+    readonly devicePixelRatio: number;
+}
+export type WorkerOperationResult = DocumentInfo | readonly TextRun[] | ImageBitmap | ArrayBuffer | undefined;
+export declare function transferablesFor(value: unknown): Transferable[];

package/dist/worker-protocol.js

@@ -0,0 +1,14 @@
+export function transferablesFor(value) {
+    if (value instanceof ArrayBuffer)
+        return [value];
+    if (typeof ImageBitmap !== "undefined" && value instanceof ImageBitmap)
+        return [value];
+    if (ArrayBuffer.isView(value))
+        return [value.buffer];
+    if (value && typeof value === "object") {
+        const data = value.data;
+        if (data instanceof ArrayBuffer)
+            return [data];
+    }
+    return [];
+}

package/dist/worker.d.ts

@@ -0,0 +1,4 @@
+export * from "./worker-client.js";
+export * from "./worker-adapter.js";
+export * from "./worker-endpoint.js";
+export * from "./worker-protocol.js";

package/dist/worker.js

@@ -0,0 +1,4 @@
+export * from "./worker-client.js";
+export * from "./worker-adapter.js";
+export * from "./worker-endpoint.js";
+export * from "./worker-protocol.js";

package/dist/workers/csv-worker.js

@@ -0,0 +1,160 @@
+// src/errors.ts
+var ViewerError = class extends Error {
+  name = "ViewerError";
+  code;
+  details;
+  constructor(code, message, options = {}) {
+    super(
+      message,
+      options.cause === void 0 ? void 0 : { cause: options.cause }
+    );
+    this.code = code;
+    if (options.details) this.details = options.details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      ...this.details ? { details: this.details } : {}
+    };
+  }
+};
+
+// src/adapters/csv-parser.ts
+function parseDelimitedBytes(data, format, maxCells = 1e6) {
+  const decoded = decodeDelimitedBytes(data);
+  const delimiter = format === "tsv" ? "	" : detectDelimiter(decoded.text, [",", "	", ";"]);
+  return {
+    delimiter,
+    encoding: decoded.encoding,
+    rows: parseDelimitedText(decoded.text, delimiter, maxCells)
+  };
+}
+function parseDelimitedText(text, delimiter, maxCells = 1e6) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  let cells = 0;
+  const pushField = () => {
+    cells += 1;
+    if (cells > maxCells)
+      throw new ViewerError(
+        "resource-limit",
+        "Delimited data exceeds cell limit",
+        {
+          details: { maxCells }
+        }
+      );
+    row.push(field);
+    field = "";
+  };
+  const pushRow = () => {
+    pushField();
+    rows.push(row);
+    row = [];
+  };
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (quoted) {
+      if (character === '"') {
+        if (text[index + 1] === '"') {
+          field += '"';
+          index += 1;
+        } else quoted = false;
+      } else field += character;
+      continue;
+    }
+    if (character === '"' && field.length === 0) quoted = true;
+    else if (character === delimiter) pushField();
+    else if (character === "\n") pushRow();
+    else if (character !== "\r") field += character;
+  }
+  if (quoted)
+    throw new ViewerError(
+      "invalid-file",
+      "Unterminated quoted field in delimited data"
+    );
+  if (field.length > 0 || row.length > 0) pushRow();
+  return rows;
+}
+function decodeDelimitedBytes(data) {
+  if (data[0] === 239 && data[1] === 187 && data[2] === 191)
+    return {
+      text: new TextDecoder("utf-8", { fatal: true }).decode(data.subarray(3)),
+      encoding: "utf-8"
+    };
+  if (data[0] === 255 && data[1] === 254)
+    return {
+      text: new TextDecoder("utf-16le", { fatal: true }).decode(
+        data.subarray(2)
+      ),
+      encoding: "utf-16le"
+    };
+  if (data[0] === 254 && data[1] === 255) {
+    const swapped = data.subarray(2).slice();
+    for (let index = 0; index + 1 < swapped.length; index += 2)
+      [swapped[index], swapped[index + 1]] = [
+        swapped[index + 1],
+        swapped[index]
+      ];
+    return {
+      text: new TextDecoder("utf-16le", { fatal: true }).decode(swapped),
+      encoding: "utf-16be"
+    };
+  }
+  try {
+    return {
+      text: new TextDecoder("utf-8", { fatal: true }).decode(data),
+      encoding: "utf-8"
+    };
+  } catch {
+    return {
+      text: new TextDecoder("windows-1252").decode(data),
+      encoding: "windows-1252"
+    };
+  }
+}
+function detectDelimiter(text, candidates) {
+  const sample = text.slice(0, 64 * 1024);
+  let best = ",";
+  let bestScore = -1;
+  for (const candidate of candidates) {
+    let quoted = false;
+    let count = 0;
+    let lines = 0;
+    for (let index = 0; index < sample.length && lines < 20; index += 1) {
+      const character = sample[index];
+      if (character === '"') {
+        if (quoted && sample[index + 1] === '"') index += 1;
+        else quoted = !quoted;
+      } else if (!quoted && character === candidate) count += 1;
+      else if (!quoted && character === "\n") lines += 1;
+    }
+    if (count > bestScore) {
+      best = candidate;
+      bestScore = count;
+    }
+  }
+  return best;
+}
+
+// src/csv-worker.ts
+var workerScope = self;
+workerScope.onmessage = (event) => {
+  try {
+    const result = parseDelimitedBytes(
+      new Uint8Array(event.data.data),
+      event.data.format,
+      event.data.maxCells
+    );
+    workerScope.postMessage({ ok: true, result });
+  } catch (error) {
+    workerScope.postMessage({
+      ok: false,
+      message: error instanceof Error ? error.message : String(error),
+      code: typeof error === "object" && error !== null && "code" in error ? String(error.code) : "invalid-file"
+    });
+  }
+};

package/dist/workers/image-worker.js

@@ -0,0 +1,41 @@
+const workerScope = self;
+let document;
+workerScope.onmessage = async (event) => {
+    const request = event.data;
+    try {
+        if (request.type === "open") {
+            if (!request.moduleUrl || !request.data || !request.maxPixels)
+                throw new Error("Invalid TIFF open request");
+            const module = (await import(
+            /* @vite-ignore */ request.moduleUrl));
+            await module.default();
+            document?.free();
+            document = new module.TiffViewerDocument(new Uint8Array(request.data), request.maxPixels);
+            const pages = Array.from({ length: document.pageCount() }, (_, pageIndex) => ({
+                width: document.pageWidth(pageIndex),
+                height: document.pageHeight(pageIndex),
+            }));
+            workerScope.postMessage({ id: request.id, ok: true, pages });
+        }
+        else if (request.type === "render") {
+            if (!document || request.pageIndex === undefined)
+                throw new Error("TIFF is not open");
+            const png = document.renderPagePng(request.pageIndex);
+            const data = png.slice().buffer;
+            workerScope.postMessage({ id: request.id, ok: true, data }, [data]);
+        }
+        else {
+            document?.free();
+            document = undefined;
+            workerScope.postMessage({ id: request.id, ok: true });
+        }
+    }
+    catch (error) {
+        workerScope.postMessage({
+            id: request.id,
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+};
+export {};

package/dist/workers/legacy-converter-worker.js

@@ -0,0 +1,19 @@
+const workerScope = self;
+workerScope.onmessage = async (event) => {
+    try {
+        const module = (await import(
+        /* @vite-ignore */ event.data.moduleUrl));
+        await module.default();
+        const output = module.convertLegacyToOoxml(new Uint8Array(event.data.data), event.data.format);
+        const data = output.slice().buffer;
+        workerScope.postMessage({ ok: true, data }, [data]);
+    }
+    catch (error) {
+        workerScope.postMessage({
+            ok: false,
+            data: new ArrayBuffer(0),
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+};
+export {};