web-doc 0.3.0

package/dist/limits.d.ts

@@ -0,0 +1,4 @@
+import type { DocumentFormat, ResourceLimits } from "./contracts.js";
+export declare const defaultResourceLimits: Readonly<ResourceLimits>;
+export declare function resolveLimits(base?: Partial<ResourceLimits>, override?: Partial<ResourceLimits>): ResourceLimits;
+export declare function enforceContainerLimits(data: Uint8Array, format: DocumentFormat, limits: ResourceLimits): void;

package/dist/limits.js

@@ -0,0 +1,162 @@
+import { ViewerError } from "./errors.js";
+export const defaultResourceLimits = Object.freeze({
+    maxInputBytes: 100 * 1024 * 1024,
+    maxExpandedOfficeBytes: 512 * 1024 * 1024,
+    maxZipEntryBytes: 64 * 1024 * 1024,
+    maxDecodedPixels: 100_000_000,
+    maxSvgBytes: 16 * 1024 * 1024,
+    maxCsvCells: 1_000_000,
+    maxTextMapBytes: 64 * 1024 * 1024,
+    maxDocumentUnits: 100_000,
+    maxConcurrentRenders: 2,
+    maxOperationMs: 30_000,
+});
+export function resolveLimits(base = {}, override = {}) {
+    const result = { ...defaultResourceLimits, ...base, ...override };
+    for (const [name, value] of Object.entries(result)) {
+        if (!Number.isSafeInteger(value) || value <= 0)
+            throw new ViewerError("resource-limit", `Invalid resource limit ${name}: ${value}`);
+    }
+    return result;
+}
+export function enforceContainerLimits(data, format, limits) {
+    if (data.byteLength > limits.maxInputBytes)
+        throw limitError("Input exceeds maxInputBytes", data.byteLength, limits.maxInputBytes);
+    if (isZipOffice(format))
+        enforceZipLimits(data, limits);
+    if (format === "svg" && data.byteLength > limits.maxSvgBytes)
+        throw limitError("SVG exceeds maxSvgBytes", data.byteLength, limits.maxSvgBytes);
+    const dimensions = imageDimensions(data, format);
+    if (dimensions) {
+        const pixels = dimensions.width * dimensions.height;
+        if (!Number.isSafeInteger(pixels) || pixels > limits.maxDecodedPixels)
+            throw limitError("Decoded image exceeds maxDecodedPixels", pixels, limits.maxDecodedPixels);
+    }
+}
+function enforceZipLimits(data, limits) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let expanded = 0;
+    let entries = 0;
+    for (let offset = 0; offset + 46 <= data.byteLength; offset += 1) {
+        if (view.getUint32(offset, true) !== 0x02014b50)
+            continue;
+        const uncompressed = view.getUint32(offset + 24, true);
+        if (uncompressed === 0xffffffff)
+            throw new ViewerError("resource-limit", "ZIP64 entries require explicit production support");
+        if (uncompressed > limits.maxZipEntryBytes)
+            throw limitError("ZIP entry exceeds maxZipEntryBytes", uncompressed, limits.maxZipEntryBytes);
+        expanded += uncompressed;
+        if (expanded > limits.maxExpandedOfficeBytes)
+            throw limitError("Office package exceeds maxExpandedOfficeBytes", expanded, limits.maxExpandedOfficeBytes);
+        const nameLength = view.getUint16(offset + 28, true);
+        const extraLength = view.getUint16(offset + 30, true);
+        const commentLength = view.getUint16(offset + 32, true);
+        offset += 45 + nameLength + extraLength + commentLength;
+        entries += 1;
+    }
+    if (entries === 0)
+        throw new ViewerError("invalid-file", "OOXML ZIP has no central-directory entries");
+}
+function imageDimensions(data, format) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (format === "png" && data.byteLength >= 24)
+        return { width: view.getUint32(16), height: view.getUint32(20) };
+    if (format === "gif" && data.byteLength >= 10)
+        return { width: view.getUint16(6, true), height: view.getUint16(8, true) };
+    if (format === "bmp" && data.byteLength >= 26)
+        return {
+            width: Math.abs(view.getInt32(18, true)),
+            height: Math.abs(view.getInt32(22, true)),
+        };
+    if (format === "jpeg")
+        return jpegDimensions(data);
+    if (format === "webp")
+        return webpDimensions(data);
+    if (format === "tiff")
+        return tiffDimensions(data);
+    return undefined;
+}
+function webpDimensions(data) {
+    if (data.byteLength < 25)
+        return undefined;
+    const chunk = ascii(data, 12, 16);
+    if (chunk === "VP8X" && data.byteLength >= 30)
+        return {
+            width: 1 + data[24] + (data[25] << 8) + (data[26] << 16),
+            height: 1 + data[27] + (data[28] << 8) + (data[29] << 16),
+        };
+    if (chunk === "VP8 " && data.byteLength >= 30)
+        return {
+            width: (data[26] | (data[27] << 8)) & 0x3fff,
+            height: (data[28] | (data[29] << 8)) & 0x3fff,
+        };
+    if (chunk === "VP8L" && data[20] === 0x2f) {
+        const bits = data[21] | (data[22] << 8) | (data[23] << 16) | (data[24] << 24);
+        return {
+            width: (bits & 0x3fff) + 1,
+            height: ((bits >>> 14) & 0x3fff) + 1,
+        };
+    }
+    return undefined;
+}
+function tiffDimensions(data) {
+    if (data.byteLength < 10)
+        return undefined;
+    const littleEndian = ascii(data, 0, 2) === "II";
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const ifdOffset = view.getUint32(4, littleEndian);
+    if (ifdOffset + 2 > data.byteLength)
+        return undefined;
+    const count = view.getUint16(ifdOffset, littleEndian);
+    let width;
+    let height;
+    for (let index = 0; index < count; index += 1) {
+        const offset = ifdOffset + 2 + index * 12;
+        if (offset + 12 > data.byteLength)
+            return undefined;
+        const tag = view.getUint16(offset, littleEndian);
+        if (tag !== 256 && tag !== 257)
+            continue;
+        const type = view.getUint16(offset + 2, littleEndian);
+        const itemCount = view.getUint32(offset + 4, littleEndian);
+        if (itemCount !== 1 || (type !== 3 && type !== 4))
+            continue;
+        const value = type === 3
+            ? view.getUint16(offset + 8, littleEndian)
+            : view.getUint32(offset + 8, littleEndian);
+        if (tag === 256)
+            width = value;
+        else
+            height = value;
+    }
+    return width && height ? { width, height } : undefined;
+}
+function jpegDimensions(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    for (let offset = 2; offset + 9 < data.byteLength;) {
+        if (data[offset] !== 0xff)
+            return undefined;
+        const marker = data[offset + 1];
+        const length = view.getUint16(offset + 2);
+        if (marker >= 0xc0 && marker <= 0xc3)
+            return {
+                width: view.getUint16(offset + 7),
+                height: view.getUint16(offset + 5),
+            };
+        if (length < 2)
+            return undefined;
+        offset += 2 + length;
+    }
+    return undefined;
+}
+function isZipOffice(format) {
+    return ["docx", "docm", "xlsx", "xlsm", "pptx", "pptm", "ppsx"].includes(format);
+}
+function ascii(data, start, end) {
+    return String.fromCharCode(...data.subarray(start, end));
+}
+function limitError(message, actual, limit) {
+    return new ViewerError("resource-limit", message, {
+        details: { actual, limit },
+    });
+}

package/dist/registry.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentAdapter, DocumentFormat } from "./contracts.js";
+export declare class AdapterRegistry {
+    #private;
+    constructor(adapters?: readonly DocumentAdapter[]);
+    register(adapter: DocumentAdapter): () => void;
+    resolve(format: DocumentFormat): DocumentAdapter;
+    destroy(): Promise<void>;
+}

package/dist/registry.js

@@ -0,0 +1,35 @@
+import { ViewerError } from "./errors.js";
+export class AdapterRegistry {
+    #adapters = new Map();
+    constructor(adapters = []) {
+        for (const adapter of adapters)
+            this.register(adapter);
+    }
+    register(adapter) {
+        if (!adapter.id.trim())
+            throw new ViewerError("internal", "Adapter id must not be empty");
+        for (const format of adapter.formats) {
+            if (this.#adapters.has(format))
+                throw new ViewerError("internal", `An adapter is already registered for ${format}`);
+            this.#adapters.set(format, adapter);
+        }
+        return () => {
+            for (const format of adapter.formats)
+                if (this.#adapters.get(format) === adapter)
+                    this.#adapters.delete(format);
+        };
+    }
+    resolve(format) {
+        const adapter = this.#adapters.get(format);
+        if (!adapter)
+            throw new ViewerError("unsupported-format", `No adapter is registered for ${format}`, {
+                details: { format },
+            });
+        return adapter;
+    }
+    async destroy() {
+        const unique = new Set(this.#adapters.values());
+        this.#adapters.clear();
+        await Promise.all([...unique].map(async (adapter) => adapter.destroy?.()));
+    }
+}

package/dist/render-scheduler.d.ts

@@ -0,0 +1,8 @@
+export type RenderPriority = "visible" | "adjacent" | "background";
+export declare class RenderScheduler {
+    #private;
+    constructor(concurrency: number);
+    get active(): number;
+    get queued(): number;
+    run<T>(priority: RenderPriority, signal: AbortSignal, task: () => Promise<T>): Promise<T>;
+}

package/dist/render-scheduler.js

@@ -0,0 +1,63 @@
+import { abortError } from "./errors.js";
+const priorities = {
+    visible: 0,
+    adjacent: 1,
+    background: 2,
+};
+export class RenderScheduler {
+    #concurrency;
+    #queue = [];
+    #active = 0;
+    #sequence = 0;
+    constructor(concurrency) {
+        this.#concurrency = Math.max(1, Math.trunc(concurrency));
+    }
+    get active() {
+        return this.#active;
+    }
+    get queued() {
+        return this.#queue.length;
+    }
+    run(priority, signal, task) {
+        if (signal.aborted)
+            return Promise.reject(abortError());
+        return new Promise((resolve, reject) => {
+            const queued = {
+                priority: priorities[priority],
+                sequence: this.#sequence++,
+                signal,
+                task,
+                resolve,
+                reject,
+            };
+            this.#queue.push(queued);
+            this.#queue.sort((left, right) => left.priority - right.priority || left.sequence - right.sequence);
+            const onAbort = () => {
+                const index = this.#queue.indexOf(queued);
+                if (index < 0)
+                    return;
+                this.#queue.splice(index, 1);
+                reject(abortError());
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            void this.#drain();
+        });
+    }
+    async #drain() {
+        while (this.#active < this.#concurrency && this.#queue.length > 0) {
+            const queued = this.#queue.shift();
+            if (queued.signal.aborted) {
+                queued.reject(abortError());
+                continue;
+            }
+            this.#active += 1;
+            void queued
+                .task()
+                .then(queued.resolve, queued.reject)
+                .finally(() => {
+                this.#active -= 1;
+                void this.#drain();
+            });
+        }
+    }
+}

package/dist/source.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentSource, ViewerFetch, ViewerProgress } from "./contracts.js";
+export interface LoadedSource {
+    readonly bytes: Uint8Array;
+    readonly fileName?: string;
+    readonly contentType?: string;
+}
+export interface SourceLoadOptions {
+    readonly fetch: ViewerFetch;
+    readonly signal: AbortSignal;
+    readonly maxBytes: number;
+    readonly reportProgress: (progress: ViewerProgress) => void;
+}
+export declare function loadDocumentSource(source: DocumentSource, options: SourceLoadOptions): Promise<LoadedSource>;
+export declare function sourceToBytes(source: DocumentSource, signal?: AbortSignal): Promise<Uint8Array>;

package/dist/source.js

@@ -0,0 +1,116 @@
+import { abortError, normalizeError, ViewerError } from "./errors.js";
+export async function loadDocumentSource(source, options) {
+    throwIfAborted(options.signal);
+    if (source instanceof Uint8Array)
+        return binary(source, options.maxBytes);
+    if (source instanceof ArrayBuffer)
+        return binary(new Uint8Array(source), options.maxBytes);
+    if (typeof Blob !== "undefined" && source instanceof Blob) {
+        enforceSize(source.size, options.maxBytes);
+        const bytes = new Uint8Array(await source.arrayBuffer());
+        throwIfAborted(options.signal);
+        return {
+            bytes,
+            ...(source.type ? { contentType: source.type } : {}),
+            ...("name" in source && typeof source.name === "string"
+                ? { fileName: source.name }
+                : {}),
+        };
+    }
+    if (typeof source !== "string" && !(source instanceof URL))
+        throw new ViewerError("invalid-file", "Unsupported document source object");
+    const url = source instanceof URL
+        ? source
+        : new URL(source, globalThis.location?.href ?? "http://localhost/");
+    let response;
+    try {
+        response = await options.fetch(url, { signal: options.signal });
+    }
+    catch (error) {
+        if (options.signal.aborted)
+            throw abortError();
+        throw new ViewerError("network-error", `Failed to fetch ${url.href}`, {
+            cause: error,
+        });
+    }
+    if (!response.ok)
+        throw new ViewerError("network-error", `Failed to fetch document: HTTP ${response.status}`, {
+            details: { status: response.status, url: url.href },
+        });
+    const declaredLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength >= 0)
+        enforceSize(declaredLength, options.maxBytes);
+    const bytes = await readLimitedBody(response, options);
+    const fileName = url.pathname.split("/").at(-1);
+    const contentType = response.headers.get("content-type");
+    return {
+        bytes,
+        ...(fileName ? { fileName } : {}),
+        ...(contentType ? { contentType } : {}),
+    };
+}
+export async function sourceToBytes(source, signal) {
+    const controller = signal ? undefined : new AbortController();
+    const loaded = await loadDocumentSource(source, {
+        fetch: globalThis.fetch.bind(globalThis),
+        signal: signal ?? controller.signal,
+        maxBytes: Number.MAX_SAFE_INTEGER,
+        reportProgress: () => { },
+    });
+    return loaded.bytes;
+}
+async function readLimitedBody(response, options) {
+    if (!response.body) {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        enforceSize(bytes.byteLength, options.maxBytes);
+        return bytes;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let loaded = 0;
+    const total = Number(response.headers.get("content-length")) || undefined;
+    try {
+        while (true) {
+            const result = await reader.read();
+            if (result.done)
+                break;
+            loaded += result.value.byteLength;
+            enforceSize(loaded, options.maxBytes);
+            chunks.push(result.value);
+            options.reportProgress({
+                phase: "loading",
+                loaded,
+                ...(total ? { total, ratio: loaded / total } : {}),
+            });
+        }
+    }
+    catch (error) {
+        if (options.signal.aborted)
+            throw abortError();
+        throw normalizeError(error, "network-error");
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(loaded);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function binary(bytes, maxBytes) {
+    enforceSize(bytes.byteLength, maxBytes);
+    return { bytes };
+}
+function enforceSize(actual, limit) {
+    if (actual > limit)
+        throw new ViewerError("resource-limit", "Input exceeds maxInputBytes", {
+            details: { actual, limit },
+        });
+}
+function throwIfAborted(signal) {
+    if (signal.aborted)
+        throw abortError();
+}

package/dist/spreadsheet-viewport.d.ts

@@ -0,0 +1,34 @@
+import type { DocumentInfo, SearchMatch, TextRun } from "./contracts.js";
+import type { ViewportHost } from "./viewport.js";
+interface CellAddress {
+    readonly row: number;
+    readonly column: number;
+}
+export interface SpreadsheetSearchCell extends CellAddress {
+    readonly active: boolean;
+}
+export declare class AxisGeometry {
+    #private;
+    constructor(count: number, defaultSize: number, overrides?: Readonly<Record<number, number>>);
+    get count(): number;
+    get totalSize(): number;
+    sizeOf(index: number): number;
+    /** Offset of a 1-based band; count + 1 returns the full extent. */
+    offsetOf(index: number): number;
+    /** Band containing an unscaled logical offset. Hidden zero-sized bands skip. */
+    indexAt(offset: number): number;
+}
+export declare class SpreadsheetViewport {
+    #private;
+    constructor(container: HTMLElement, host: ViewportHost);
+    setDocument(info: DocumentInfo | undefined): void;
+    update(): void;
+    panBy(deltaX: number, deltaY: number): void;
+    goToPage(pageIndex: number): void;
+    fitWidth(): number;
+    fitPage(): number;
+    schedule(): void;
+    destroy(): void;
+}
+export declare function spreadsheetSearchCells(runs: readonly TextRun[], matches: readonly SearchMatch[], activeMatch?: SearchMatch): readonly SpreadsheetSearchCell[];
+export {};