@image-marker/web 0.1.0

package/lib/commonjs/core/web/runtime.d.ts

@@ -0,0 +1,106 @@
+import type { ImageMarkOptions, ImageOptions, MarkOptions, TextMarkOptions } from '../index.js';
+import type { ContentCredentialsVerificationResult, EmbedInvisibleWithCredentialsOptions, EmbedInvisibleWithCredentialsResult, VerifyContentCredentialsOptions } from '../content-credentials.js';
+import type { DetectInvisibleWatermarkOptions, EmbedInvisibleWatermarkOptions, InvisibleWatermarkDetectionResult } from '../invisible-watermark.js';
+import type { MarkerJobOptions } from '../job.js';
+import type { MarkerImageInfo } from '../image-info.js';
+import type { WatermarkBatchOptions, WatermarkBatchResult } from '../batch.js';
+import type { WatermarkBlobRecipeResultOptions, WatermarkRecipe, WatermarkRecipeDocument, WatermarkRecipeOptions, WatermarkRecipeResultOptions } from '../recipe.js';
+import type { MarkerOperation, MarkerResult } from '../result.js';
+import type { WebResourceAdapter } from './browser.js';
+/** Public operations that a host executor can take outside the DOM realm. */
+export type WebMarkerExecutionOperation = MarkerOperation | 'getImageInfo';
+/** The shape of a value returned by an isolated host executor. */
+export type WebMarkerExecutionResultKind = 'marker-result' | 'blob' | 'detection' | 'image-info';
+/** A cooperative or host-enforced stop request for one execution task. */
+export interface WebMarkerExecutionTermination {
+    reason: 'cancel' | 'dispose' | 'signal' | 'timeout';
+    /** The instance-specific id supplied to `start`. */
+    taskId: string;
+}
+/**
+ * A real execution unit returned by a host adapter. `result` must settle only
+ * when the unit has actually stopped or completed. `terminate` is the hook
+ * used by `cancel()`/`dispose()` to ask an isolated Tauri Worker, process, or
+ * other host-owned unit to stop; its fulfilled promise is the acknowledgement.
+ */
+export interface WebMarkerExecutionTask<Result = unknown> {
+    result: Promise<Result>;
+    terminate?: (termination: WebMarkerExecutionTermination) => Promise<void> | void;
+    /** Alias for hosts whose task API calls the real stop operation `cancel`. */
+    cancel?: (termination: WebMarkerExecutionTermination) => Promise<void> | void;
+    /** Releases task-local host resources after a completed or stopped task. */
+    dispose?: () => Promise<void> | void;
+}
+/**
+ * Task request for a host execution boundary. The host owns transport and
+ * isolation: map image resources and observer callbacks to your IPC protocol,
+ * and forward cancellation explicitly. AbortSignal and loaded DOM images are
+ * not directly transferable. The SDK does not pass an executable task closure.
+ */
+export interface WebMarkerExecutionRequest {
+    taskId: string;
+    operation: WebMarkerExecutionOperation;
+    resultKind: WebMarkerExecutionResultKind;
+    options: TextMarkOptions | ImageMarkOptions | MarkOptions | EmbedInvisibleWatermarkOptions | DetectInvisibleWatermarkOptions | ImageOptions['src'];
+    signal: AbortSignal;
+}
+/**
+ * Optional boundary for dispatching whole image operations to a host-owned
+ * execution unit. It is intentionally task based, so a Tauri application can
+ * adapt it to its own IPC rather than relying on a JavaScript closure.
+ */
+export interface WebMarkerExecutionAdapter {
+    start<Result = unknown>(request: WebMarkerExecutionRequest): WebMarkerExecutionTask<Result>;
+}
+export type WebMarkerCancellationMode = 'cooperative' | 'host-termination-required';
+/** Runtime facts a desktop host can use when selecting an execution boundary. */
+export interface WebMarkerCapabilities {
+    visibleRendering: {
+        engine: 'canvas-2d';
+        cancellation: 'host-termination-required';
+    };
+    invisibleEmbedding: {
+        engine: 'canvas-2d-pixels';
+        cancellation: 'host-termination-required';
+    };
+    invisibleDetection: {
+        engine: 'dedicated-worker-when-configured-or-main-thread';
+        workerCancellation: 'cooperative';
+        mainThreadCancellation: 'host-termination-required';
+    };
+    execution: {
+        mode: 'default-dom' | 'host-adapter';
+        supportsTerminationAcknowledgement: boolean;
+    };
+    resources: {
+        localBlobInput: true;
+        blobOutput: true;
+        objectUrlCleanup: true;
+    };
+}
+export interface WebMarkerRuntimeOptions {
+    /** Supplies DOM-adjacent resources such as Image, Canvas, and object URLs. */
+    resources?: WebResourceAdapter;
+    /** Takes complete tasks in a host-owned execution or isolation boundary. */
+    execution?: WebMarkerExecutionAdapter;
+}
+export interface WebMarkerInstance {
+    readonly capabilities: WebMarkerCapabilities;
+    readonly disposed: boolean;
+    getImageInfo(source: ImageOptions['src']): Promise<MarkerImageInfo>;
+    markText(options: TextMarkOptions, control?: MarkerJobOptions): Promise<MarkerResult>;
+    markImage(options: ImageMarkOptions, control?: MarkerJobOptions): Promise<MarkerResult>;
+    mark(options: MarkOptions, control?: MarkerJobOptions): Promise<MarkerResult>;
+    embedInvisible(options: EmbedInvisibleWatermarkOptions, control?: MarkerJobOptions): Promise<MarkerResult>;
+    detectInvisible(options: DetectInvisibleWatermarkOptions, control?: MarkerJobOptions): Promise<InvisibleWatermarkDetectionResult>;
+    embedInvisibleMany(inputs: readonly EmbedInvisibleWatermarkOptions[], options?: WatermarkBatchOptions<MarkerResult>): Promise<Array<WatermarkBatchResult<MarkerResult>>>;
+    detectInvisibleMany(inputs: readonly DetectInvisibleWatermarkOptions[], options?: WatermarkBatchOptions<InvisibleWatermarkDetectionResult>): Promise<Array<WatermarkBatchResult<InvisibleWatermarkDetectionResult>>>;
+    createRecipe<ResultOptions extends WatermarkRecipeResultOptions | undefined = undefined>(options: WatermarkRecipeOptions, resultOptions?: ResultOptions): WatermarkRecipe<ResultOptions extends WatermarkBlobRecipeResultOptions ? Blob : MarkerResult>;
+    importRecipe<ResultOptions extends WatermarkRecipeResultOptions | undefined = undefined>(document: WatermarkRecipeDocument, resultOptions?: ResultOptions): WatermarkRecipe<ResultOptions extends WatermarkBlobRecipeResultOptions ? Blob : MarkerResult>;
+    embedInvisibleWithCredentials(options: EmbedInvisibleWithCredentialsOptions, control?: MarkerJobOptions): Promise<EmbedInvisibleWithCredentialsResult>;
+    verifyContentCredentials(options: VerifyContentCredentialsOptions): Promise<ContentCredentialsVerificationResult>;
+    /** Abort all current instance tasks and await host termination acknowledgements. */
+    cancel(): Promise<void>;
+    /** Cancel current work, release task resources, and reject future operations. */
+    dispose(): Promise<void>;
+}

package/lib/commonjs/core/web/runtime.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonjs/editor/adapter.d.ts

@@ -0,0 +1,26 @@
+import { type EmbedInvisibleWatermarkOptions, type EmbedInvisibleWithCredentialsOptions, type EmbedInvisibleWithCredentialsResult, type MarkerImageInfo, type MarkerJobOptions, type MarkerResult } from './core-contract.js';
+import type { WatermarkRecipeDefinition, WatermarkRecipeInput } from '@image-marker/recipe';
+import type { ImageMarkerEditorRenderAdapter } from './types.js';
+/**
+ * The smallest Core surface needed by the reusable editor renderer.
+ *
+ * It deliberately receives the engine instead of importing a platform Marker
+ * implementation. Legacy `core-adapter` passes the native-aware Core binding;
+ * the standalone Web package passes the Canvas Web binding.
+ */
+export interface EditorMarkerEngine {
+    getImageInfo(source: unknown): Promise<MarkerImageInfo>;
+    createRecipe(recipe: WatermarkRecipeDefinition): {
+        apply(input: WatermarkRecipeInput, control?: MarkerJobOptions): Promise<MarkerResult>;
+    };
+    embedInvisible(options: EmbedInvisibleWatermarkOptions, control?: MarkerJobOptions): Promise<MarkerResult>;
+    embedInvisibleWithCredentials(options: EmbedInvisibleWithCredentialsOptions, control?: MarkerJobOptions): Promise<EmbedInvisibleWithCredentialsResult>;
+}
+/**
+ * Bind editor rendering to a supplied Core-compatible Marker engine.
+ *
+ * No static Marker implementation is imported here, so the same adapter logic
+ * can be used by React Native Core and a browser-only Web Core binding.
+ */
+export declare function createEditorRenderAdapter(engine: EditorMarkerEngine, previewMaxSize?: number): ImageMarkerEditorRenderAdapter;
+export type { EditorExportResult, EditorRenderRequest, ImageMarkerEditorRenderAdapter, } from './types.js';

package/lib/commonjs/editor/adapter.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEditorRenderAdapter = createEditorRenderAdapter;
+const core_contract_js_1 = require("./core-contract.js");
+const projection_js_1 = require("./projection.js");
+function withMaxSize(recipe, maxSize) {
+    return {
+        schemaVersion: 2,
+        layers: recipe.layers,
+        output: {
+            ...recipe.output,
+            maxSize: maxSize ?? recipe.output.maxSize,
+        },
+    };
+}
+function signedResult(watermarked, signedImage) {
+    return {
+        ...watermarked,
+        uri: signedImage,
+        output: signedImage.startsWith('data:') ? 'data-url' : 'file',
+    };
+}
+function toCoreSaveFormat(value) {
+    switch (value) {
+        case 'jpg':
+            return core_contract_js_1.ImageFormat.jpg;
+        case 'png':
+            return core_contract_js_1.ImageFormat.png;
+        case 'webp':
+            return core_contract_js_1.ImageFormat.webp;
+        case 'base64':
+            return core_contract_js_1.ImageFormat.base64;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Bind editor rendering to a supplied Core-compatible Marker engine.
+ *
+ * No static Marker implementation is imported here, so the same adapter logic
+ * can be used by React Native Core and a browser-only Web Core binding.
+ */
+function createEditorRenderAdapter(engine, previewMaxSize = 1024) {
+    const getSourceInfo = (source) => engine.getImageInfo(source);
+    const renderVisible = async (request, maxSize) => {
+        const sourceSize = request.sourceSize ??
+            (await getSourceInfo(request.input.backgroundImage.src));
+        const targetSize = maxSize
+            ? (0, projection_js_1.fitEditorSizeWithinMax)(sourceSize, maxSize)
+            : undefined;
+        const recipe = targetSize &&
+            (targetSize.width !== sourceSize.width ||
+                targetSize.height !== sourceSize.height)
+            ? (0, projection_js_1.projectEditorRecipe)(request.recipe, sourceSize, targetSize)
+            : request.recipe;
+        return engine
+            .createRecipe(withMaxSize(recipe, maxSize))
+            .apply(request.input, request.control);
+    };
+    return {
+        getSourceInfo,
+        renderPreview(request) {
+            return renderVisible(request, request.maxSize ?? previewMaxSize);
+        },
+        async exportOriginal(request) {
+            const visible = await renderVisible(request, request.recipe.output.maxSize);
+            const invisible = request.options?.invisible;
+            const credentials = request.options?.contentCredentials;
+            if (credentials && !invisible) {
+                throw new Error('Content Credentials export requires invisible locator options so the signed claim can reference a stable locator.');
+            }
+            if (invisible && credentials) {
+                const result = await engine.embedInvisibleWithCredentials({
+                    watermark: {
+                        image: { src: visible.uri },
+                        ...invisible,
+                        saveFormat: toCoreSaveFormat(request.recipe.output.saveFormat),
+                        quality: request.recipe.output.quality,
+                        maxSize: request.recipe.output.maxSize,
+                    },
+                    adapter: credentials.adapter,
+                    claim: credentials.claim,
+                }, request.control);
+                return {
+                    visible,
+                    final: signedResult(result.watermarkedImage, result.signedImage),
+                };
+            }
+            if (invisible) {
+                const final = await engine.embedInvisible({
+                    image: { src: visible.uri },
+                    ...invisible,
+                    saveFormat: toCoreSaveFormat(request.recipe.output.saveFormat),
+                    quality: request.recipe.output.quality,
+                    maxSize: request.recipe.output.maxSize,
+                }, request.control);
+                return { visible, final };
+            }
+            return { visible, final: visible };
+        },
+    };
+}

package/lib/commonjs/editor/controller.d.ts

@@ -0,0 +1,106 @@
+import { type WatermarkRecipeDefinition, type WatermarkRecipeDefinitionLayer, type WatermarkRecipeDocument, type WatermarkRecipeLayer } from './core-contract.js';
+import type { EditorAlignment, EditorClipboardDocument, EditorDistribution, EditorExportOptions, EditorKeyCommand, EditorLayerBounds, EditorPoint, EditorSafeArea, EditorSelectionMode, EditorSnapContext, EditorState, EditorTemplate, EditorTextLayerPatch, ImageMarkerEditorControllerOptions } from './types.js';
+type Listener = (state: EditorState) => void;
+/**
+ * Headless state engine shared by native and Web editor surfaces.
+ *
+ * Recipe state, multi-selection, history, clipboard, grouping, alignment,
+ * viewport state, and optional autosave live here. Rendering and application
+ * design-system choices remain injectable.
+ */
+export declare class ImageMarkerEditorController {
+    private recipe;
+    private selectedLayerIds;
+    private safeArea;
+    private exportOptions;
+    private viewport;
+    private snapGuides;
+    private readonly past;
+    private readonly future;
+    private readonly listeners;
+    private readonly historyLimit;
+    private readonly autosave?;
+    private readonly onChange?;
+    private autosaveTimer?;
+    private clipboard?;
+    private idSequence;
+    private groupSequence;
+    private historyGroupActive;
+    private historyGroupCaptured;
+    constructor(document: WatermarkRecipeDocument, historyLimit?: number);
+    constructor(options: ImageMarkerEditorControllerOptions);
+    getState(): EditorState;
+    subscribe(listener: Listener): () => void;
+    dispose(): void;
+    beginHistoryGroup(): void;
+    endHistoryGroup(): void;
+    selectLayer(id: string | undefined, mode?: EditorSelectionMode): void;
+    selectLayers(ids: readonly string[]): void;
+    selectAll(): void;
+    clearSelection(): void;
+    /**
+     * Synchronize a controlled Editor state. History capture is opt-in so parent
+     * renders do not create undo entries.
+     */
+    replaceState(state: EditorState, recordHistory?: boolean): void;
+    importRecipe(document: WatermarkRecipeDocument): void;
+    applyTemplate(template: EditorTemplate): void;
+    exportRecipe(): WatermarkRecipeDefinition;
+    addLayer(layer: WatermarkRecipeLayer, index?: number): string;
+    duplicateLayers(ids?: readonly string[]): string[];
+    removeLayer(id?: string | undefined): boolean;
+    removeLayers(ids?: readonly string[]): number;
+    setLayerVisible(id: string, visible: boolean): void;
+    setLayerLocked(id: string, locked: boolean): void;
+    renameLayer(id: string, name: string | undefined): void;
+    patchLayer(id: string, patch: Partial<WatermarkRecipeDefinitionLayer>): void;
+    updateTextLayer(id: string, patch: EditorTextLayerPatch): void;
+    replaceImage(id: string, source: unknown): void;
+    moveLayer(id: string, point: EditorPoint, snapContext?: EditorSnapContext): EditorPoint;
+    nudgeLayer(id: string, delta: EditorPoint): void;
+    nudgeSelection(delta: EditorPoint): void;
+    scaleLayer(id: string, scale: number): void;
+    rotateLayer(id: string, degrees: number): void;
+    reorderLayer(id: string, targetIndex: number): void;
+    groupLayers(ids?: readonly string[], requestedGroupId?: string): string;
+    ungroupLayers(ids?: readonly string[]): string[];
+    alignLayers(alignment: EditorAlignment, bounds: readonly EditorLayerBounds[], canvas?: {
+        width: number;
+        height: number;
+    }): void;
+    distributeLayers(direction: EditorDistribution, bounds: readonly EditorLayerBounds[]): void;
+    copyLayers(ids?: readonly string[]): string;
+    canPaste(): boolean;
+    pasteLayers(serialized?: string | EditorClipboardDocument, offset?: EditorPoint): string[];
+    setSafeArea(safeArea: Partial<EditorSafeArea>): void;
+    setExportOptions(options: EditorExportOptions): void;
+    setViewportZoom(zoom: number, anchor?: EditorPoint): void;
+    zoomViewportBy(factor: number, anchor?: EditorPoint): void;
+    panViewport(delta: EditorPoint): void;
+    fitViewport(): void;
+    handleKeyCommand(command: EditorKeyCommand): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    serializeState(): string;
+    restoreSerializedState(serialized: string): void;
+    restoreAutosave(): Promise<boolean>;
+    flushAutosave(): Promise<boolean>;
+    clearAutosave(): Promise<boolean>;
+    private updateLayer;
+    private requireEditableLayer;
+    private editableLayers;
+    private layersByIds;
+    private transformLayerIds;
+    private moveLayersBy;
+    private layerIndex;
+    private nextLayerId;
+    private uniqueLayerId;
+    private uniqueGroupId;
+    private commit;
+    private snapshot;
+    private restore;
+    private scheduleAutosave;
+    private reportAutosaveError;
+    private emit;
+}
+export {};