@pilio/gemini-watermark-remover 1.0.10

package/src/core/workerClient.js

@@ -0,0 +1,114 @@
+export function canUseWatermarkWorker(env = globalThis) {
+    return typeof env.Worker !== 'undefined' && typeof env.Blob !== 'undefined';
+}
+
+function normalizeError(errorLike) {
+    if (!errorLike) return 'Unknown worker error';
+    if (typeof errorLike === 'string') return errorLike;
+    if (typeof errorLike.message === 'string' && errorLike.message.length > 0) {
+        return errorLike.message;
+    }
+    return 'Unknown worker error';
+}
+
+function toError(errorLike) {
+    if (errorLike instanceof Error) return errorLike;
+    return new Error(normalizeError(errorLike));
+}
+
+export class WatermarkWorkerClient {
+    constructor({
+        workerUrl = './workers/watermark-worker.js',
+        WorkerClass = globalThis.Worker
+    } = {}) {
+        if (typeof WorkerClass === 'undefined') {
+            throw new Error('Worker is not supported in this runtime');
+        }
+
+        this.worker = new WorkerClass(workerUrl, { type: 'module' });
+        this.pending = new Map();
+        this.requestId = 0;
+
+        this.onMessage = this.onMessage.bind(this);
+        this.onError = this.onError.bind(this);
+        this.worker.addEventListener('message', this.onMessage);
+        this.worker.addEventListener('error', this.onError);
+    }
+
+    dispose() {
+        this.worker.removeEventListener('message', this.onMessage);
+        this.worker.removeEventListener('error', this.onError);
+        this.worker.terminate();
+        this.rejectAllPending(new Error('Worker disposed'));
+    }
+
+    onMessage(event) {
+        const payload = event?.data;
+        if (!payload || typeof payload.id === 'undefined') return;
+        const pending = this.pending.get(payload.id);
+        if (!pending) return;
+
+        this.pending.delete(payload.id);
+        clearTimeout(pending.timeoutId);
+        if (payload.ok) {
+            pending.resolve(payload.result);
+            return;
+        }
+
+        pending.reject(new Error(normalizeError(payload.error)));
+    }
+
+    onError(event) {
+        const reason = event?.message || 'Worker execution failed';
+        this.rejectAllPending(new Error(reason));
+    }
+
+    rejectAllPending(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timeoutId);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+
+    request(type, payload, transferList = [], timeoutMs = 120000) {
+        const id = ++this.requestId;
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Worker request timed out: ${type}`));
+            }, timeoutMs);
+
+            this.pending.set(id, { resolve, reject, timeoutId });
+            try {
+                this.worker.postMessage({ id, type, ...payload }, transferList);
+            } catch (error) {
+                clearTimeout(timeoutId);
+                this.pending.delete(id);
+                reject(toError(error));
+            }
+        });
+    }
+
+    async ping(timeoutMs = 3000) {
+        await this.request('ping', {}, [], timeoutMs);
+    }
+
+    async processBlob(blob, options = {}) {
+        const inputBuffer = await blob.arrayBuffer();
+        const result = await this.request(
+            'process-image',
+            {
+                inputBuffer,
+                mimeType: blob.type || 'image/png',
+                options
+            },
+            [inputBuffer]
+        );
+
+        return {
+            blob: new Blob([result.processedBuffer], { type: result.mimeType || 'image/png' }),
+            meta: result.meta || null
+        };
+    }
+}

package/src/sdk/browser.d.ts

@@ -0,0 +1,13 @@
+export {
+    WatermarkEngine,
+    WatermarkMeta,
+    WatermarkPosition,
+    WatermarkConfig,
+    RemoveOptions,
+    ImageRemovalResult,
+    createWatermarkEngine,
+    removeWatermarkFromImage,
+    detectWatermarkConfig,
+    calculateWatermarkPosition,
+    removeRepeatedWatermarkLayers
+} from './index.js';

package/src/sdk/browser.js

@@ -0,0 +1,29 @@
+import {
+    WatermarkEngine,
+    calculateWatermarkPosition,
+    detectWatermarkConfig,
+    removeRepeatedWatermarkLayers
+} from '../core/watermarkEngine.js';
+
+export async function createWatermarkEngine() {
+    return WatermarkEngine.create();
+}
+
+export async function removeWatermarkFromImage(image, options = {}) {
+    const engine = options.engine instanceof WatermarkEngine
+        ? options.engine
+        : await createWatermarkEngine();
+    const canvas = await engine.removeWatermarkFromImage(image, options);
+
+    return {
+        canvas,
+        meta: canvas.__watermarkMeta || null
+    };
+}
+
+export {
+    WatermarkEngine,
+    calculateWatermarkPosition,
+    detectWatermarkConfig,
+    removeRepeatedWatermarkLayers
+};

package/src/sdk/image-data.d.ts

@@ -0,0 +1,14 @@
+export {
+    WatermarkEngine,
+    WatermarkMeta,
+    WatermarkPosition,
+    WatermarkConfig,
+    RemoveOptions,
+    ImageDataRemovalResult,
+    createWatermarkEngine,
+    removeWatermarkFromImageData,
+    removeWatermarkFromImageDataSync,
+    detectWatermarkConfig,
+    calculateWatermarkPosition,
+    removeRepeatedWatermarkLayers
+} from './index.js';

package/src/sdk/image-data.js

@@ -0,0 +1,55 @@
+import { interpolateAlphaMap } from '../core/adaptiveDetector.js';
+import { getEmbeddedAlphaMap } from '../core/embeddedAlphaMaps.js';
+import {
+    WatermarkEngine,
+    calculateWatermarkPosition,
+    detectWatermarkConfig,
+    removeRepeatedWatermarkLayers
+} from '../core/watermarkEngine.js';
+import { processWatermarkImageData } from '../core/watermarkProcessor.js';
+
+export async function createWatermarkEngine() {
+    return WatermarkEngine.create();
+}
+
+function buildEmbeddedGetAlphaMap(alpha48, alpha96) {
+    return (size) => {
+        if (size === 48) return alpha48;
+        if (size === 96) return alpha96;
+        return interpolateAlphaMap(alpha96, 96, size);
+    };
+}
+
+export function removeWatermarkFromImageDataSync(imageData, options = {}) {
+    const alpha48 = options.alpha48 || getEmbeddedAlphaMap(48);
+    const alpha96 = options.alpha96 || getEmbeddedAlphaMap(96);
+
+    return processWatermarkImageData(imageData, {
+        ...options,
+        alpha48,
+        alpha96,
+        getAlphaMap: options.getAlphaMap || buildEmbeddedGetAlphaMap(alpha48, alpha96)
+    });
+}
+
+export async function removeWatermarkFromImageData(imageData, options = {}) {
+    const engine = options.engine instanceof WatermarkEngine
+        ? options.engine
+        : await createWatermarkEngine();
+    const alpha48 = await engine.getAlphaMap(48);
+    const alpha96 = await engine.getAlphaMap(96);
+
+    return processWatermarkImageData(imageData, {
+        ...options,
+        alpha48,
+        alpha96,
+        getAlphaMap: options.getAlphaMap || buildEmbeddedGetAlphaMap(alpha48, alpha96)
+    });
+}
+
+export {
+    WatermarkEngine,
+    calculateWatermarkPosition,
+    detectWatermarkConfig,
+    removeRepeatedWatermarkLayers
+};

package/src/sdk/index.d.ts

@@ -0,0 +1,144 @@
+export interface WatermarkPosition {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export interface ImageDataLike {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+}
+
+export interface BrowserImageLike {
+    width: number;
+    height: number;
+}
+
+export interface BrowserCanvasLike extends BrowserImageLike {
+    getContext(contextId: string, options?: unknown): unknown;
+}
+
+type GlobalHtmlImageElementLike = typeof globalThis extends {
+    HTMLImageElement: { prototype: infer TPrototype }
+}
+    ? TPrototype
+    : BrowserImageLike;
+
+type GlobalHtmlCanvasElementLike = typeof globalThis extends {
+    HTMLCanvasElement: { prototype: infer TPrototype }
+}
+    ? TPrototype
+    : BrowserCanvasLike;
+
+type GlobalOffscreenCanvasLike = typeof globalThis extends {
+    OffscreenCanvas: { prototype: infer TPrototype }
+}
+    ? TPrototype
+    : BrowserCanvasLike;
+
+export type BrowserImageInput = GlobalHtmlImageElementLike | GlobalHtmlCanvasElementLike;
+export type BrowserCanvasOutput = GlobalOffscreenCanvasLike | GlobalHtmlCanvasElementLike;
+
+export interface WatermarkConfig {
+    logoSize: number;
+    marginRight: number;
+    marginBottom: number;
+}
+
+export interface WatermarkDetectionMeta {
+    adaptiveConfidence: number | null;
+    originalSpatialScore: number | null;
+    originalGradientScore: number | null;
+    processedSpatialScore: number | null;
+    processedGradientScore: number | null;
+    suppressionGain: number | null;
+}
+
+export interface WatermarkSelectionDebug {
+    candidateSource: string | null;
+    initialConfig: WatermarkConfig | null;
+    initialPosition: WatermarkPosition | null;
+    finalConfig: WatermarkConfig | null;
+    finalPosition: WatermarkPosition | null;
+    texturePenalty: number | null;
+    tooDark: boolean;
+    tooFlat: boolean;
+    hardReject: boolean;
+    usedCatalogVariant: boolean;
+    usedSizeJitter: boolean;
+    usedLocalShift: boolean;
+    usedAdaptive: boolean;
+    usedPreviewAnchor: boolean;
+}
+
+export interface WatermarkMeta {
+    applied: boolean;
+    skipReason: string | null;
+    size: number | null;
+    position: WatermarkPosition | null;
+    config: WatermarkConfig | null;
+    detection: WatermarkDetectionMeta;
+    source: string;
+    decisionTier: string | null;
+    alphaGain: number;
+    passCount: number;
+    attemptedPassCount: number;
+    passStopReason: string | null;
+    selectionDebug?: WatermarkSelectionDebug | null;
+}
+
+export interface RemoveOptions {
+    adaptiveMode?: 'auto' | 'always' | 'never' | 'off';
+    maxPasses?: number;
+    engine?: WatermarkEngine;
+    alpha48?: Float32Array;
+    alpha96?: Float32Array;
+    getAlphaMap?: (size: number) => Float32Array;
+}
+
+export interface ImageDataRemovalResult {
+    imageData: ImageDataLike;
+    meta: WatermarkMeta;
+}
+
+export interface ImageRemovalResult {
+    canvas: BrowserCanvasOutput;
+    meta: WatermarkMeta | null;
+}
+
+export class WatermarkEngine {
+    static create(): Promise<WatermarkEngine>;
+    getAlphaMap(size: number): Promise<Float32Array>;
+    removeWatermarkFromImage(
+        image: BrowserImageInput,
+        options?: Omit<RemoveOptions, 'engine'>
+    ): Promise<BrowserCanvasOutput>;
+    getWatermarkInfo(imageWidth: number, imageHeight: number): {
+        size: number;
+        position: WatermarkPosition;
+        config: WatermarkConfig;
+    };
+}
+
+export function createWatermarkEngine(): Promise<WatermarkEngine>;
+export function removeWatermarkFromImage(
+    image: BrowserImageInput,
+    options?: RemoveOptions
+): Promise<ImageRemovalResult>;
+export function removeWatermarkFromImageData(
+    imageData: ImageDataLike,
+    options?: RemoveOptions
+): Promise<ImageDataRemovalResult>;
+export function removeWatermarkFromImageDataSync(
+    imageData: ImageDataLike,
+    options?: Omit<RemoveOptions, 'engine'>
+): ImageDataRemovalResult;
+export function detectWatermarkConfig(imageWidth: number, imageHeight: number): WatermarkConfig;
+export function calculateWatermarkPosition(
+    imageWidth: number,
+    imageHeight: number,
+    config: WatermarkConfig
+): WatermarkPosition;
+export function removeRepeatedWatermarkLayers(...args: unknown[]): unknown;

package/src/sdk/index.js

@@ -0,0 +1,8 @@
+export { createWatermarkEngine, removeWatermarkFromImage } from './browser.js';
+export { removeWatermarkFromImageData, removeWatermarkFromImageDataSync } from './image-data.js';
+export {
+    WatermarkEngine,
+    calculateWatermarkPosition,
+    detectWatermarkConfig,
+    removeRepeatedWatermarkLayers
+} from './browser.js';

package/src/sdk/node.d.ts

@@ -0,0 +1,42 @@
+import type { ImageDataRemovalResult, RemoveOptions, WatermarkMeta } from './index.js';
+
+export interface NodeCodecContext {
+    mimeType: string;
+    filePath?: string;
+    meta?: WatermarkMeta;
+}
+
+export interface NodeBufferRemovalOptions extends Omit<RemoveOptions, 'engine'> {
+    mimeType?: string;
+    filePath?: string;
+    decodeImageData: (
+        input: Buffer | Uint8Array | ArrayBuffer,
+        context: NodeCodecContext
+    ) => Promise<ImageDataRemovalResult['imageData']> | ImageDataRemovalResult['imageData'];
+    encodeImageData: (
+        imageData: ImageDataRemovalResult['imageData'],
+        context: NodeCodecContext
+    ) => Promise<Buffer | Uint8Array | ArrayBuffer> | Buffer | Uint8Array | ArrayBuffer;
+}
+
+export interface NodeFileRemovalOptions extends NodeBufferRemovalOptions {
+    outputPath?: string | null;
+}
+
+export interface NodeBufferRemovalResult extends ImageDataRemovalResult {
+    buffer: Buffer;
+}
+
+export interface NodeFileRemovalResult extends NodeBufferRemovalResult {
+    outputPath: string | null;
+}
+
+export function inferMimeTypeFromPath(filePath: string): string;
+export function removeWatermarkFromBuffer(
+    inputBuffer: Buffer | Uint8Array | ArrayBuffer,
+    options: NodeBufferRemovalOptions
+): Promise<NodeBufferRemovalResult>;
+export function removeWatermarkFromFile(
+    inputPath: string,
+    options: NodeFileRemovalOptions
+): Promise<NodeFileRemovalResult>;

package/src/sdk/node.js

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { readFile, writeFile } from 'node:fs/promises';
+
+import { removeWatermarkFromImageDataSync } from './image-data.js';
+
+function normalizeBufferLike(value) {
+    if (Buffer.isBuffer(value)) return value;
+    if (value instanceof Uint8Array) return Buffer.from(value);
+    if (value instanceof ArrayBuffer) return Buffer.from(value);
+    throw new TypeError('Expected Buffer, Uint8Array, or ArrayBuffer');
+}
+
+function assertFunction(value, name) {
+    if (typeof value !== 'function') {
+        throw new TypeError(`${name} must be a function`);
+    }
+}
+
+export function inferMimeTypeFromPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg';
+    if (ext === '.webp') return 'image/webp';
+    if (ext === '.png') return 'image/png';
+    return 'application/octet-stream';
+}
+
+export async function removeWatermarkFromBuffer(inputBuffer, options = {}) {
+    const {
+        decodeImageData,
+        encodeImageData,
+        mimeType = 'application/octet-stream',
+        filePath,
+        ...removeOptions
+    } = options;
+
+    assertFunction(decodeImageData, 'decodeImageData');
+    assertFunction(encodeImageData, 'encodeImageData');
+
+    const normalizedInput = normalizeBufferLike(inputBuffer);
+    const imageData = await decodeImageData(normalizedInput, { mimeType, filePath });
+    const result = removeWatermarkFromImageDataSync(imageData, removeOptions);
+    const encoded = await encodeImageData(result.imageData, {
+        mimeType,
+        filePath,
+        meta: result.meta
+    });
+
+    return {
+        buffer: normalizeBufferLike(encoded),
+        imageData: result.imageData,
+        meta: result.meta
+    };
+}
+
+export async function removeWatermarkFromFile(inputPath, options = {}) {
+    const {
+        outputPath = null,
+        mimeType = inferMimeTypeFromPath(inputPath),
+        ...restOptions
+    } = options;
+
+    const inputBuffer = await readFile(inputPath);
+    const result = await removeWatermarkFromBuffer(inputBuffer, {
+        ...restOptions,
+        mimeType,
+        filePath: inputPath
+    });
+
+    if (outputPath) {
+        await writeFile(outputPath, result.buffer);
+    }
+
+    return {
+        ...result,
+        outputPath
+    };
+}