@image-marker/web 0.1.0

package/lib/module/core/web/invisible-worker-client.d.ts

@@ -0,0 +1,13 @@
+import type { DetectInvisibleWatermarkOptions, InvisibleWatermarkDetectionData, InvisibleWatermarkPixelBuffer, InvisibleWatermarkWorkerOptions } from '../invisible-watermark.js';
+interface DedicatedWorkerClient {
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onerror: (() => void) | null;
+    postMessage(message: unknown, transfer?: ArrayBuffer[]): void;
+    terminate(): void;
+}
+type WorkerConstructor = new (scriptURL: string | URL) => DedicatedWorkerClient;
+/** Run detection in a one-time dedicated Worker and transfer a private RGBA copy. */
+export declare function detectInvisibleWatermarkInWorker(pixels: InvisibleWatermarkPixelBuffer, detection: Pick<DetectInvisibleWatermarkOptions, 'key' | 'strength' | 'search'>, options: InvisibleWatermarkWorkerOptions, WorkerClass?: WorkerConstructor | undefined): Promise<InvisibleWatermarkDetectionData>;
+export {};

package/lib/module/core/web/invisible-worker-client.js

@@ -0,0 +1,137 @@
+import { INVISIBLE_WATERMARK_ALGORITHM } from '../invisible-watermark.js';
+const WORKER_PROTOCOL = 1;
+let requestSequence = 0;
+const defaultWorkerConstructor = globalThis.Worker;
+function abortError() {
+    const error = new Error('Invisible watermark worker detection was aborted.');
+    error.name = 'AbortError';
+    return error;
+}
+function report(options, phase) {
+    try {
+        options.onProgress?.({ phase });
+    }
+    catch {
+        // Observers cannot change detection results or Worker cleanup.
+    }
+}
+function isDetectionResult(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const result = value;
+    const validPayload = result.payload === undefined || typeof result.payload === 'string';
+    const validBitErrorRate = result.bitErrorRate === undefined ||
+        (typeof result.bitErrorRate === 'number' &&
+            Number.isFinite(result.bitErrorRate) &&
+            result.bitErrorRate >= 0 &&
+            result.bitErrorRate <= 1);
+    const validScale = result.scale === undefined ||
+        (typeof result.scale === 'number' &&
+            Number.isFinite(result.scale) &&
+            result.scale > 0);
+    return (typeof result.detected === 'boolean' &&
+        typeof result.confidence === 'number' &&
+        Number.isFinite(result.confidence) &&
+        result.confidence >= 0 &&
+        result.confidence <= 1 &&
+        result.algorithm === INVISIBLE_WATERMARK_ALGORITHM &&
+        validPayload &&
+        validBitErrorRate &&
+        validScale &&
+        (!result.detected || typeof result.payload === 'string'));
+}
+/** Run detection in a one-time dedicated Worker and transfer a private RGBA copy. */
+export function detectInvisibleWatermarkInWorker(pixels, detection, options, WorkerClass = defaultWorkerConstructor) {
+    report(options, 'queued');
+    if (options.signal?.aborted)
+        return Promise.reject(abortError());
+    if (typeof WorkerClass !== 'function') {
+        return Promise.reject(new Error('This browser does not support dedicated Web Workers.'));
+    }
+    return new Promise((resolve, reject) => {
+        let worker;
+        try {
+            worker = new WorkerClass(options.scriptUrl);
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        const id = `${Date.now().toString(36)}-${(requestSequence += 1).toString(36)}`;
+        let posted = false;
+        let settled = false;
+        const cleanup = () => {
+            worker.onmessage = null;
+            worker.onerror = null;
+            options.signal?.removeEventListener('abort', handleAbort);
+            worker.terminate();
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        };
+        const handleAbort = () => fail(abortError());
+        worker.onerror = () => {
+            fail(new Error('Invisible watermark Worker script failed to load or run.'));
+        };
+        worker.onmessage = (event) => {
+            const message = event.data;
+            if (message?.protocol !== WORKER_PROTOCOL) {
+                fail(new Error('Invisible watermark Worker protocol mismatch.'));
+                return;
+            }
+            if (message.type === 'ready') {
+                if (posted)
+                    return;
+                posted = true;
+                report(options, 'detecting');
+                const copiedPixels = new Uint8ClampedArray(pixels.data);
+                try {
+                    worker.postMessage({
+                        protocol: WORKER_PROTOCOL,
+                        id,
+                        type: 'detect',
+                        pixels: copiedPixels.buffer,
+                        width: pixels.width,
+                        height: pixels.height,
+                        options: {
+                            key: detection.key,
+                            strength: detection.strength,
+                            search: detection.search,
+                        },
+                    }, [copiedPixels.buffer]);
+                }
+                catch (error) {
+                    fail(error);
+                }
+                return;
+            }
+            if (message.id !== id)
+                return;
+            if (message.type === 'error') {
+                const code = typeof message.code === 'string' ? message.code : 'ERROR';
+                const detail = typeof message.message === 'string'
+                    ? message.message
+                    : 'Worker detection failed.';
+                fail(new Error(`Invisible watermark Worker ${code}: ${detail}`));
+                return;
+            }
+            if (message.type !== 'result' || !isDetectionResult(message.result)) {
+                fail(new Error('Invisible watermark Worker returned invalid data.'));
+                return;
+            }
+            if (settled)
+                return;
+            settled = true;
+            report(options, 'complete');
+            cleanup();
+            resolve(message.result);
+        };
+        options.signal?.addEventListener('abort', handleAbort, { once: true });
+        if (options.signal?.aborted)
+            handleAbort();
+    });
+}

package/lib/module/core/web/renderer.d.ts

@@ -0,0 +1,20 @@
+import type { ImageOptions, MarkOptions, TextOptions, WatermarkImageOptions } from '../index.js';
+import type { WebCanvas, WebResourceAdapter } from './browser.js';
+export type WebRenderLayer = {
+    type: 'text';
+    options: TextOptions;
+} | {
+    type: 'image';
+    options: WatermarkImageOptions;
+};
+/** Per-instance DOM resources and cooperative boundaries for Web rendering. */
+export interface WebRenderRuntime {
+    resources?: WebResourceAdapter;
+    signal?: AbortSignal;
+}
+type OutputOptions = Pick<MarkOptions, 'quality' | 'saveFormat' | 'matteColor' | 'rotationCanvasMode' | 'maxSize'>;
+/** Render a complete composition into a browser canvas. */
+export declare function renderWebCompositionToCanvas(backgroundImage: ImageOptions, layers: WebRenderLayer[], output: OutputOptions, runtime?: WebRenderRuntime): Promise<WebCanvas>;
+/** Render a complete composition into a data URL. */
+export declare function renderWebComposition(backgroundImage: ImageOptions, layers: WebRenderLayer[], output: OutputOptions, runtime?: WebRenderRuntime): Promise<string>;
+export {};