web-doc 0.3.0

package/dist/adapters/csv.d.ts

@@ -0,0 +1,26 @@
+import type { AdapterOpenContext, DocumentAdapter, DocumentInfo, RenderViewport, SpreadsheetSheetInfo, TextRun, ViewerWarning } from "../contracts.js";
+import type { ParsedDelimitedText } from "./csv-parser.js";
+interface CsvHandle {
+    readonly format: "csv" | "tsv";
+    readonly parsed: ParsedDelimitedText;
+    readonly info: SpreadsheetSheetInfo;
+    readonly warnings: readonly ViewerWarning[];
+}
+export interface CsvAdapterOptions {
+    readonly workerUrl?: string | URL;
+    readonly parse?: (data: Uint8Array, format: "csv" | "tsv", maxCells: number, signal: AbortSignal) => Promise<ParsedDelimitedText>;
+    readonly maxCells?: number;
+}
+export declare class CsvDocumentAdapter implements DocumentAdapter<CsvHandle> {
+    #private;
+    readonly id = "delimited-data";
+    readonly formats: readonly ["csv", "tsv"];
+    constructor(options?: CsvAdapterOptions);
+    open(data: Uint8Array, context: AdapterOpenContext): Promise<CsvHandle>;
+    getInfo(handle: CsvHandle): Promise<DocumentInfo>;
+    render(handle: CsvHandle, target: HTMLCanvasElement | OffscreenCanvas, viewport: RenderViewport, signal?: AbortSignal): Promise<void>;
+    getTextMap(handle: CsvHandle, pageIndex: number, signal?: AbortSignal): Promise<readonly TextRun[]>;
+    close(): void;
+}
+export declare function createCsvAdapter(options?: CsvAdapterOptions): CsvDocumentAdapter;
+export {};

package/dist/adapters/csv.js

@@ -0,0 +1,231 @@
+import { abortError, ViewerError } from "../errors.js";
+const ROW_HEIGHT = 24;
+const COLUMN_WIDTH = 120;
+const ROW_HEADER_WIDTH = 48;
+const COLUMN_HEADER_HEIGHT = 28;
+export class CsvDocumentAdapter {
+    id = "delimited-data";
+    formats = ["csv", "tsv"];
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    async open(data, context) {
+        const format = context.format === "tsv" ? "tsv" : "csv";
+        context.reportProgress({ phase: "parsing", loaded: 0, total: 1 });
+        const maxCells = this.#options.maxCells ?? context.limits.maxCsvCells;
+        const parsed = this.#options.parse
+            ? await this.#options.parse(data, format, maxCells, context.signal)
+            : await parseInWorker(data, format, maxCells, this.#options.workerUrl
+                ? new URL(this.#options.workerUrl, context.assetBaseUrl)
+                : context.assetBaseUrl
+                    ? new URL("workers/csv-worker.js", context.assetBaseUrl)
+                    : new URL("../csv-worker.js", import.meta.url), context.signal);
+        if (context.signal.aborted)
+            throw abortError();
+        const maxColumn = parsed.rows.reduce((maximum, row) => Math.max(maximum, row.length), 0);
+        const name = context.fileName?.replace(/\.[^.]+$/, "") || "Data";
+        const warnings = parsed.encoding === "windows-1252"
+            ? [
+                {
+                    code: "fidelity-degraded",
+                    message: "Input was not valid UTF-8 and was decoded as Windows-1252",
+                    details: { encoding: parsed.encoding },
+                },
+            ]
+            : [];
+        context.reportProgress({ phase: "parsing", loaded: 1, total: 1, ratio: 1 });
+        return {
+            format,
+            parsed,
+            warnings,
+            info: {
+                name,
+                frozenRows: 0,
+                frozenColumns: 0,
+                mergedRanges: [],
+                maxRow: parsed.rows.length,
+                maxColumn,
+                defaultColumnWidth: COLUMN_WIDTH,
+                defaultRowHeight: ROW_HEIGHT,
+                columnWidths: {},
+                rowHeights: {},
+                rowHeaderWidth: ROW_HEADER_WIDTH,
+                columnHeaderHeight: COLUMN_HEADER_HEIGHT,
+            },
+        };
+    }
+    async getInfo(handle) {
+        return {
+            format: handle.format,
+            unit: "sheet",
+            pageCount: 1,
+            sheetNames: [handle.info.name],
+            sheets: [handle.info],
+            warnings: handle.warnings,
+        };
+    }
+    async render(handle, target, viewport, signal) {
+        if (signal?.aborted)
+            throw abortError();
+        if (viewport.pageIndex !== 0)
+            throw new ViewerError("render-failed", "CSV sheet index is out of range");
+        const range = viewport.sheetRange ?? {
+            row: 1,
+            column: 1,
+            rowCount: 50,
+            columnCount: 20,
+        };
+        const zoom = Math.max(0.1, viewport.zoom);
+        const width = viewport.width ??
+            ROW_HEADER_WIDTH + range.columnCount * COLUMN_WIDTH * zoom;
+        const height = viewport.height ??
+            COLUMN_HEADER_HEIGHT + range.rowCount * ROW_HEIGHT * zoom;
+        const dpr = Math.max(1, viewport.devicePixelRatio);
+        target.width = Math.max(1, Math.ceil(width * dpr));
+        target.height = Math.max(1, Math.ceil(height * dpr));
+        if ("style" in target) {
+            target.style.width = `${width}px`;
+            target.style.height = `${height}px`;
+        }
+        const context = target.getContext("2d");
+        if (!context)
+            throw new ViewerError("render-failed", "Canvas 2D context is unavailable");
+        context.setTransform(dpr, 0, 0, dpr, 0, 0);
+        drawGrid(context, handle.parsed.rows, range, zoom, width, height, viewport.scrollOffsetX ?? 0, viewport.scrollOffsetY ?? 0, viewport.columnWidths);
+        if (signal?.aborted)
+            throw abortError();
+    }
+    async getTextMap(handle, pageIndex, signal) {
+        if (pageIndex !== 0)
+            throw new ViewerError("render-failed", "CSV sheet index is out of range");
+        const runs = [];
+        for (let rowIndex = 0; rowIndex < handle.parsed.rows.length; rowIndex += 1) {
+            if (signal?.aborted)
+                throw abortError();
+            const row = handle.parsed.rows[rowIndex];
+            for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
+                const text = row[columnIndex];
+                if (!text)
+                    continue;
+                runs.push({
+                    text,
+                    x: ROW_HEADER_WIDTH + columnIndex * COLUMN_WIDTH + 6,
+                    y: COLUMN_HEADER_HEIGHT + rowIndex * ROW_HEIGHT + 4,
+                    width: COLUMN_WIDTH - 12,
+                    height: ROW_HEIGHT - 8,
+                    row: rowIndex + 1,
+                    column: columnIndex + 1,
+                    direction: /[\u0590-\u08ff\ufb1d-\ufefc]/u.test(text) ? "rtl" : "ltr",
+                });
+            }
+        }
+        return runs;
+    }
+    close() { }
+}
+export function createCsvAdapter(options = {}) {
+    return new CsvDocumentAdapter(options);
+}
+function drawGrid(context, rows, range, zoom, width, height, scrollOffsetX, scrollOffsetY, columnWidths) {
+    const rowHeight = ROW_HEIGHT * zoom;
+    context.fillStyle = "#ffffff";
+    context.fillRect(0, 0, width, height);
+    context.fillStyle = "#f2f4f7";
+    context.fillRect(0, 0, width, COLUMN_HEADER_HEIGHT);
+    context.fillRect(0, 0, ROW_HEADER_WIDTH, height);
+    context.strokeStyle = "#d0d5dd";
+    context.lineWidth = 1;
+    context.font = `${Math.max(10, 12 * zoom)}px system-ui, sans-serif`;
+    context.textBaseline = "middle";
+    let columnX = ROW_HEADER_WIDTH - scrollOffsetX * zoom;
+    for (let visibleColumn = 0; visibleColumn < range.columnCount; visibleColumn += 1) {
+        const column = range.column + visibleColumn;
+        const columnWidth = (columnWidths?.[column] ?? COLUMN_WIDTH) * zoom;
+        const x = columnX;
+        context.beginPath();
+        context.moveTo(x, 0);
+        context.lineTo(x, height);
+        context.stroke();
+        context.fillStyle = "#475467";
+        context.fillText(columnLabel(column), x + 6, COLUMN_HEADER_HEIGHT / 2);
+        columnX += columnWidth;
+    }
+    for (let visibleRow = 0; visibleRow < range.rowCount; visibleRow += 1) {
+        const rowNumber = range.row + visibleRow;
+        const y = COLUMN_HEADER_HEIGHT + visibleRow * rowHeight - scrollOffsetY * zoom;
+        context.beginPath();
+        context.moveTo(0, y);
+        context.lineTo(width, y);
+        context.stroke();
+        context.fillStyle = "#475467";
+        context.fillText(String(rowNumber), 6, y + rowHeight / 2);
+        const row = rows[rowNumber - 1];
+        if (!row)
+            continue;
+        let cellX = ROW_HEADER_WIDTH - scrollOffsetX * zoom;
+        for (let visibleColumn = 0; visibleColumn < range.columnCount; visibleColumn += 1) {
+            const column = range.column + visibleColumn;
+            const columnWidth = (columnWidths?.[column] ?? COLUMN_WIDTH) * zoom;
+            const value = row[column - 1];
+            const x = cellX;
+            cellX += columnWidth;
+            if (!value)
+                continue;
+            context.save();
+            context.beginPath();
+            context.rect(x + 3, y + 1, columnWidth - 6, rowHeight - 2);
+            context.clip();
+            context.fillStyle = "#101828";
+            context.direction = /[\u0590-\u08ff\ufb1d-\ufefc]/u.test(value)
+                ? "rtl"
+                : "ltr";
+            context.fillText(value, x + 6, y + rowHeight / 2);
+            context.restore();
+        }
+    }
+}
+function columnLabel(column) {
+    let current = Math.max(1, column);
+    let result = "";
+    while (current > 0) {
+        current -= 1;
+        result = String.fromCharCode(65 + (current % 26)) + result;
+        current = Math.floor(current / 26);
+    }
+    return result;
+}
+function parseInWorker(data, format, maxCells, workerUrl, signal) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(workerUrl, {
+            type: "module",
+            name: "csv-parser",
+        });
+        const finish = () => {
+            signal.removeEventListener("abort", onAbort);
+            worker.terminate();
+        };
+        const onAbort = () => {
+            finish();
+            reject(abortError());
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        worker.onerror = (event) => {
+            finish();
+            reject(new ViewerError("worker-crashed", "CSV parser worker crashed", {
+                details: { message: event.message },
+            }));
+        };
+        worker.onmessage = (event) => {
+            finish();
+            if (event.data.ok)
+                resolve(event.data.result);
+            else
+                reject(new ViewerError(event.data.code === "resource-limit"
+                    ? "resource-limit"
+                    : "invalid-file", event.data.message));
+        };
+        const copy = data.slice().buffer;
+        worker.postMessage({ data: copy, format, maxCells }, [copy]);
+    });
+}

package/dist/adapters/image.d.ts

@@ -0,0 +1,41 @@
+import type { AdapterOpenContext, DocumentAdapter, DocumentInfo, RenderViewport, ViewerWarning } from "../contracts.js";
+type NativeImageFormat = "png" | "jpeg" | "gif" | "webp" | "bmp";
+interface NativeHandle {
+    readonly kind: "native";
+    readonly format: NativeImageFormat;
+    readonly data: Uint8Array;
+    readonly warnings: readonly ViewerWarning[];
+}
+interface TiffHandle {
+    readonly kind: "tiff";
+    readonly format: "tiff";
+    readonly backend: TiffBackend;
+    readonly warnings: readonly ViewerWarning[];
+}
+type ImageHandle = NativeHandle | TiffHandle;
+export interface TiffBackend {
+    readonly pages: readonly {
+        readonly width: number;
+        readonly height: number;
+    }[];
+    renderPagePng(pageIndex: number, signal?: AbortSignal): Promise<Uint8Array>;
+    close(): void;
+}
+export interface ImageAdapterOptions {
+    readonly workerUrl?: string | URL;
+    readonly moduleUrl?: string | URL;
+    readonly openTiff?: (data: Uint8Array, context: AdapterOpenContext) => Promise<TiffBackend>;
+}
+export declare class ImageDocumentAdapter implements DocumentAdapter<ImageHandle> {
+    #private;
+    readonly id = "image";
+    readonly formats: readonly ["png", "jpeg", "gif", "webp", "bmp", "tiff"];
+    constructor(options?: ImageAdapterOptions);
+    open(data: Uint8Array, context: AdapterOpenContext): Promise<ImageHandle>;
+    getInfo(handle: ImageHandle): Promise<DocumentInfo>;
+    render(handle: ImageHandle, target: HTMLCanvasElement | OffscreenCanvas, viewport: RenderViewport, signal?: AbortSignal): Promise<void>;
+    getTextMap(): Promise<readonly []>;
+    close(handle: ImageHandle): void;
+}
+export declare function createImageAdapter(options?: ImageAdapterOptions): ImageDocumentAdapter;
+export {};

package/dist/adapters/image.js

@@ -0,0 +1,198 @@
+import { abortError, ViewerError } from "../errors.js";
+import { drawEncodedImage } from "./bitmap.js";
+export class ImageDocumentAdapter {
+    id = "image";
+    formats = ["png", "jpeg", "gif", "webp", "bmp", "tiff"];
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    async open(data, context) {
+        if (context.format === "tiff") {
+            context.reportProgress({ phase: "parsing", loaded: 0, total: 1 });
+            const backend = this.#options.openTiff
+                ? await this.#options.openTiff(data, context)
+                : await WorkerTiffBackend.open(data, this.#options.workerUrl
+                    ? new URL(this.#options.workerUrl, context.assetBaseUrl)
+                    : context.assetBaseUrl
+                        ? new URL("workers/image-worker.js", context.assetBaseUrl)
+                        : new URL("../image-worker.js", import.meta.url), this.#options.moduleUrl
+                    ? new URL(this.#options.moduleUrl, context.assetBaseUrl)
+                    : context.assetBaseUrl
+                        ? new URL("assets/image/index.js", context.assetBaseUrl)
+                        : new URL("../assets/image/index.js", import.meta.url), context.limits.maxDecodedPixels, context.signal, context.limits.maxOperationMs);
+            if (backend.pages.length === 0) {
+                backend.close();
+                throw new ViewerError("invalid-file", "TIFF contains no pages");
+            }
+            context.reportProgress({
+                phase: "parsing",
+                loaded: 1,
+                total: 1,
+                ratio: 1,
+            });
+            return { kind: "tiff", format: "tiff", backend, warnings: [] };
+        }
+        const format = context.format;
+        const animated = isAnimated(data, format);
+        return {
+            kind: "native",
+            format,
+            data,
+            warnings: animated
+                ? [
+                    {
+                        code: "unsupported-feature",
+                        message: "Animated image frames are preserved in the source; headless canvas rendering captures one browser-decoded frame",
+                        details: { feature: "animation", format },
+                    },
+                ]
+                : [],
+        };
+    }
+    async getInfo(handle) {
+        return {
+            format: handle.format,
+            unit: "image",
+            pageCount: handle.kind === "tiff" ? handle.backend.pages.length : 1,
+            warnings: handle.warnings,
+        };
+    }
+    async render(handle, target, viewport, signal) {
+        if (signal?.aborted)
+            throw abortError();
+        const pageCount = handle.kind === "tiff" ? handle.backend.pages.length : 1;
+        if (!Number.isInteger(viewport.pageIndex) ||
+            viewport.pageIndex < 0 ||
+            viewport.pageIndex >= pageCount)
+            throw new ViewerError("render-failed", "Image page index is out of range");
+        const data = handle.kind === "tiff"
+            ? await handle.backend.renderPagePng(viewport.pageIndex, signal)
+            : handle.data;
+        await drawEncodedImage(data, handle.kind === "tiff" ? "image/png" : mimeType(handle.format), target, {
+            dpr: viewport.devicePixelRatio,
+            scale: viewport.zoom,
+            ...(viewport.width === undefined ? {} : { cssWidth: viewport.width }),
+            ...(viewport.height === undefined
+                ? {}
+                : { cssHeight: viewport.height }),
+        });
+        if (signal?.aborted)
+            throw abortError();
+    }
+    async getTextMap() {
+        return [];
+    }
+    close(handle) {
+        if (handle.kind === "tiff")
+            handle.backend.close();
+    }
+}
+export function createImageAdapter(options = {}) {
+    return new ImageDocumentAdapter(options);
+}
+class WorkerTiffBackend {
+    pages;
+    #worker;
+    #id = 0;
+    #closed = false;
+    #timeoutMs;
+    constructor(worker, pages, timeoutMs) {
+        this.#worker = worker;
+        this.pages = pages;
+        this.#timeoutMs = timeoutMs;
+    }
+    static async open(data, workerUrl, moduleUrl, maxPixels, signal, timeoutMs) {
+        const worker = new Worker(workerUrl, {
+            type: "module",
+            name: "tiff-decoder",
+        });
+        const copy = data.slice().buffer;
+        const response = await requestWorker(worker, {
+            id: 0,
+            type: "open",
+            data: copy,
+            moduleUrl: moduleUrl.href,
+            maxPixels,
+        }, [copy], signal, timeoutMs);
+        if (!response.ok || !response.pages) {
+            worker.terminate();
+            const message = response.ok
+                ? "TIFF worker returned no pages"
+                : response.message;
+            throw new ViewerError(/pixel|limit/i.test(message) ? "resource-limit" : "invalid-file", message);
+        }
+        return new WorkerTiffBackend(worker, response.pages, timeoutMs);
+    }
+    async renderPagePng(pageIndex, signal) {
+        if (this.#closed)
+            throw new ViewerError("lifecycle-error", "TIFF backend is closed");
+        const response = await requestWorker(this.#worker, { id: ++this.#id, type: "render", pageIndex }, [], signal, this.#timeoutMs);
+        if (!response.ok || !response.data)
+            throw new ViewerError("render-failed", response.ok ? "TIFF worker returned no bitmap" : response.message);
+        return new Uint8Array(response.data);
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#worker.postMessage({ id: ++this.#id, type: "close" });
+        this.#worker.terminate();
+    }
+}
+function requestWorker(worker, payload, transfer, signal, timeoutMs = 30_000) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError());
+            return;
+        }
+        const expectedId = payload.id;
+        const finish = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", onAbort);
+            worker.removeEventListener("message", onMessage);
+            worker.removeEventListener("error", onError);
+        };
+        const timeout = setTimeout(() => {
+            finish();
+            worker.terminate();
+            reject(new ViewerError("resource-limit", "TIFF worker operation exceeded maxOperationMs", { details: { timeoutMs } }));
+        }, timeoutMs);
+        const onAbort = () => {
+            finish();
+            reject(abortError());
+        };
+        const onMessage = (event) => {
+            if (event.data.id !== expectedId)
+                return;
+            finish();
+            resolve(event.data);
+        };
+        const onError = (event) => {
+            finish();
+            reject(new ViewerError("worker-crashed", "TIFF worker crashed", {
+                details: { message: event.message },
+            }));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        worker.addEventListener("message", onMessage);
+        worker.addEventListener("error", onError);
+        worker.postMessage(payload, transfer);
+    });
+}
+function mimeType(format) {
+    return format === "jpeg" ? "image/jpeg" : `image/${format}`;
+}
+function isAnimated(data, format) {
+    if (format === "gif") {
+        let frames = 0;
+        for (const byte of data)
+            if (byte === 0x2c && ++frames > 1)
+                return true;
+    }
+    if (format === "webp")
+        return new TextDecoder("latin1")
+            .decode(data.subarray(0, 64))
+            .includes("ANIM");
+    return false;
+}