@image-marker/web 0.1.0

package/lib/commonjs/headless.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateWatermarkRecipeLayer = exports.ungroupWatermarkRecipeLayers = exports.reorderWatermarkRecipeLayer = exports.removeWatermarkRecipeLayer = exports.groupWatermarkRecipeLayers = exports.duplicateWatermarkRecipeLayer = exports.addWatermarkRecipeLayer = void 0;
+__exportStar(require("./editor/headless.js"), exports);
+var recipe_1 = require("@image-marker/recipe");
+Object.defineProperty(exports, "addWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.addWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "duplicateWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.duplicateWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "groupWatermarkRecipeLayers", { enumerable: true, get: function () { return recipe_1.groupWatermarkRecipeLayers; } });
+Object.defineProperty(exports, "removeWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.removeWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "reorderWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.reorderWatermarkRecipeLayer; } });
+Object.defineProperty(exports, "ungroupWatermarkRecipeLayers", { enumerable: true, get: function () { return recipe_1.ungroupWatermarkRecipeLayers; } });
+Object.defineProperty(exports, "updateWatermarkRecipeLayer", { enumerable: true, get: function () { return recipe_1.updateWatermarkRecipeLayer; } });

package/lib/commonjs/index.d.ts

@@ -0,0 +1,5 @@
+export { default } from './core/index.js';
+export * from './core/index.js';
+export { createWebMarker, Marker, WebMarker } from './core/web/index.js';
+export type * from './core/web/runtime.js';
+export type { WebResourceAdapter } from './core/web/browser.js';

package/lib/commonjs/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebMarker = exports.Marker = exports.createWebMarker = exports.default = void 0;
+var index_js_1 = require("./core/index.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_js_1).default; } });
+__exportStar(require("./core/index.js"), exports);
+var index_js_2 = require("./core/web/index.js");
+Object.defineProperty(exports, "createWebMarker", { enumerable: true, get: function () { return index_js_2.createWebMarker; } });
+Object.defineProperty(exports, "Marker", { enumerable: true, get: function () { return index_js_2.Marker; } });
+Object.defineProperty(exports, "WebMarker", { enumerable: true, get: function () { return index_js_2.WebMarker; } });

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/module/core/batch.d.ts

@@ -0,0 +1,32 @@
+export interface WatermarkBatchFulfilledResult<Result> {
+    status: 'fulfilled';
+    value: Result;
+}
+export interface WatermarkBatchRejectedResult {
+    status: 'rejected';
+    reason: unknown;
+}
+export interface WatermarkBatchAbortedResult {
+    status: 'aborted';
+    reason: Error;
+}
+export type WatermarkBatchResult<Result> = WatermarkBatchFulfilledResult<Result> | WatermarkBatchRejectedResult | WatermarkBatchAbortedResult;
+export interface WatermarkBatchProgress<Result> {
+    total: number;
+    settled: number;
+    succeeded: number;
+    failed: number;
+    aborted: number;
+    /** Index of the item that produced this progress update. */
+    index: number;
+    result: WatermarkBatchResult<Result>;
+}
+export interface WatermarkBatchOptions<Result> {
+    /** Requested worker count. Web is capped at 4 and native targets at 1. */
+    concurrency?: number;
+    /** Stops new items from starting. Already-running items are allowed to finish. */
+    signal?: AbortSignal;
+    /** Called once when each item is fulfilled, rejected, or skipped after abort. */
+    onProgress?: (progress: WatermarkBatchProgress<Result>) => void;
+}
+export declare function runWatermarkBatch<Input, Result>(inputs: readonly Input[], task: (input: Input, index: number) => Promise<Result>, batchOptions?: WatermarkBatchOptions<Result>, maximumConcurrency?: number, inputLabel?: string): Promise<Array<WatermarkBatchResult<Result>>>;

package/lib/module/core/batch.js

@@ -0,0 +1,82 @@
+function abortResult() {
+    const reason = new Error('Batch item was not started because the operation was aborted.');
+    reason.name = 'AbortError';
+    return { status: 'aborted', reason };
+}
+export async function runWatermarkBatch(inputs, task, batchOptions = {}, maximumConcurrency = 1, inputLabel = 'batch') {
+    if (!Array.isArray(inputs)) {
+        throw new Error(`${inputLabel} inputs must be an array.`);
+    }
+    const requestedConcurrency = batchOptions.concurrency ?? 1;
+    if (!Number.isFinite(requestedConcurrency) ||
+        !Number.isInteger(requestedConcurrency) ||
+        requestedConcurrency <= 0) {
+        throw new Error('concurrency must be a positive finite integer.');
+    }
+    if (inputs.length === 0) {
+        return [];
+    }
+    const concurrency = Math.min(requestedConcurrency, maximumConcurrency, inputs.length);
+    const results = new Array(inputs.length);
+    let cursor = 0;
+    let settled = 0;
+    let succeeded = 0;
+    let failed = 0;
+    let aborted = 0;
+    const report = (index, result) => {
+        settled += 1;
+        if (result.status === 'fulfilled')
+            succeeded += 1;
+        else if (result.status === 'rejected')
+            failed += 1;
+        else
+            aborted += 1;
+        try {
+            batchOptions.onProgress?.({
+                total: inputs.length,
+                settled,
+                succeeded,
+                failed,
+                aborted,
+                index,
+                result,
+            });
+        }
+        catch {
+            // Progress observers must not interrupt the batch or change results.
+        }
+    };
+    const worker = async () => {
+        while (!batchOptions.signal?.aborted) {
+            const index = cursor;
+            cursor += 1;
+            if (index >= inputs.length) {
+                return;
+            }
+            if (batchOptions.signal?.aborted) {
+                return;
+            }
+            let result;
+            try {
+                result = {
+                    status: 'fulfilled',
+                    value: await task(inputs[index], index),
+                };
+            }
+            catch (reason) {
+                result = { status: 'rejected', reason };
+            }
+            results[index] = result;
+            report(index, result);
+        }
+    };
+    await Promise.all(Array.from({ length: concurrency }, worker));
+    for (let index = 0; index < inputs.length; index += 1) {
+        if (!results[index]) {
+            const result = abortResult();
+            results[index] = result;
+            report(index, result);
+        }
+    }
+    return results;
+}

package/lib/module/core/content-credentials.d.ts

@@ -0,0 +1,53 @@
+import type { EmbedInvisibleWatermarkOptions } from './invisible-watermark.js';
+import { INVISIBLE_WATERMARK_ALGORITHM } from './invisible-watermark.js';
+import type { MarkerResult } from './result.js';
+export interface ContentCredentialsClaim {
+    /** Human-readable asset title included in the signed manifest. */
+    title: string;
+    /** Encoded image type. WebP is supported when the selected adapter accepts it. */
+    format?: 'image/jpeg' | 'image/png' | 'image/webp';
+    /** Claim generator name shown by Content Credentials readers. */
+    generator?: string;
+    /** Adapter-specific public metadata. Never include signing secrets. */
+    metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ContentCredentialsSignRequest {
+    /** Image already containing the invisible locator. */
+    image: string;
+    /** Locator used to correlate the signed record. */
+    locator: string;
+    /** Pixel algorithm that wrote the locator. */
+    algorithm: typeof INVISIBLE_WATERMARK_ALGORITHM;
+    claim: ContentCredentialsClaim;
+}
+export interface ContentCredentialsSignResult {
+    /** Image containing the signed Content Credential. */
+    image: string;
+    manifestId?: string;
+}
+export interface ContentCredentialsVerificationResult {
+    valid: boolean;
+    manifestId?: string;
+    validationStatus?: readonly string[];
+    manifest?: unknown;
+}
+export interface ContentCredentialsAdapter {
+    sign(request: ContentCredentialsSignRequest): Promise<ContentCredentialsSignResult>;
+    verify(image: string): Promise<ContentCredentialsVerificationResult>;
+}
+export interface EmbedInvisibleWithCredentialsOptions {
+    watermark: EmbedInvisibleWatermarkOptions;
+    adapter: ContentCredentialsAdapter;
+    claim: ContentCredentialsClaim;
+}
+export interface EmbedInvisibleWithCredentialsResult {
+    watermarkedImage: MarkerResult;
+    signedImage: string;
+    manifestId?: string;
+}
+export interface VerifyContentCredentialsOptions {
+    image: string;
+    adapter: ContentCredentialsAdapter;
+}
+export declare function embedInvisibleWithCredentials(embed: (options: EmbedInvisibleWatermarkOptions) => Promise<MarkerResult>, options: EmbedInvisibleWithCredentialsOptions): Promise<EmbedInvisibleWithCredentialsResult>;
+export declare function verifyContentCredentials(options: VerifyContentCredentialsOptions): Promise<ContentCredentialsVerificationResult>;

package/lib/module/core/content-credentials.js

@@ -0,0 +1,92 @@
+import { INVISIBLE_WATERMARK_ALGORITHM } from './invisible-watermark.js';
+function validateAdapter(adapter) {
+    if (!adapter ||
+        typeof adapter.sign !== 'function' ||
+        typeof adapter.verify !== 'function') {
+        throw new Error('Content Credentials adapter must provide sign() and verify() functions.');
+    }
+    return adapter;
+}
+function snapshotClaim(claim) {
+    if (!claim || typeof claim.title !== 'string' || !claim.title.trim()) {
+        throw new Error('Content Credentials claim title must not be empty.');
+    }
+    if (claim.format !== undefined &&
+        claim.format !== 'image/jpeg' &&
+        claim.format !== 'image/png' &&
+        claim.format !== 'image/webp') {
+        throw new Error('Content Credentials claim format must be image/jpeg, image/png, or image/webp.');
+    }
+    if (claim.generator !== undefined &&
+        (typeof claim.generator !== 'string' || !claim.generator.trim())) {
+        throw new Error('Content Credentials claim generator must be a non-empty string.');
+    }
+    if (claim.metadata !== undefined &&
+        (!claim.metadata ||
+            typeof claim.metadata !== 'object' ||
+            Array.isArray(claim.metadata))) {
+        throw new Error('Content Credentials claim metadata must be an object.');
+    }
+    return {
+        title: claim.title.trim(),
+        format: claim.format,
+        generator: claim.generator?.trim(),
+        metadata: claim.metadata ? { ...claim.metadata } : undefined,
+    };
+}
+function validateSignResult(result) {
+    if (!result || typeof result.image !== 'string' || !result.image) {
+        throw new Error('Content Credentials adapter returned an invalid signed image.');
+    }
+    if (result.manifestId !== undefined &&
+        typeof result.manifestId !== 'string') {
+        throw new Error('Content Credentials adapter returned an invalid manifest ID.');
+    }
+    return result;
+}
+function validateVerificationResult(result) {
+    if (!result || typeof result.valid !== 'boolean') {
+        throw new Error('Content Credentials adapter returned an invalid verification result.');
+    }
+    if (result.manifestId !== undefined &&
+        typeof result.manifestId !== 'string') {
+        throw new Error('Content Credentials adapter returned an invalid manifest ID.');
+    }
+    if (result.validationStatus !== undefined &&
+        (!Array.isArray(result.validationStatus) ||
+            result.validationStatus.some((status) => typeof status !== 'string'))) {
+        throw new Error('Content Credentials adapter returned invalid validation status data.');
+    }
+    return result;
+}
+export async function embedInvisibleWithCredentials(embed, options) {
+    const adapter = validateAdapter(options?.adapter);
+    const claim = snapshotClaim(options?.claim);
+    const watermark = {
+        ...options.watermark,
+        image: { ...options.watermark?.image },
+    };
+    const locator = watermark.payload;
+    const watermarkedImage = await embed(watermark);
+    const signed = validateSignResult(await adapter.sign({
+        image: watermarkedImage.uri,
+        locator,
+        algorithm: INVISIBLE_WATERMARK_ALGORITHM,
+        claim,
+    }));
+    const result = {
+        watermarkedImage,
+        signedImage: signed.image,
+    };
+    if (signed.manifestId !== undefined) {
+        result.manifestId = signed.manifestId;
+    }
+    return result;
+}
+export async function verifyContentCredentials(options) {
+    const adapter = validateAdapter(options?.adapter);
+    if (typeof options?.image !== 'string' || !options.image) {
+        throw new Error('Content Credentials image must not be empty.');
+    }
+    return validateVerificationResult(await adapter.verify(options.image));
+}

package/lib/module/core/image-info.d.ts

@@ -0,0 +1,30 @@
+export type ImageOrientation = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export type MarkerImageFormat = 'jpeg' | 'png' | 'webp' | 'gif' | 'heif' | 'bmp' | 'unknown';
+export interface MarkerImageInfo {
+    /** Display width after applying the encoded orientation. */
+    width: number;
+    /** Display height after applying the encoded orientation. */
+    height: number;
+    /** Width stored in the encoded pixel data before orientation is applied. */
+    encodedWidth: number;
+    /** Height stored in the encoded pixel data before orientation is applied. */
+    encodedHeight: number;
+    format: MarkerImageFormat;
+    mimeType?: string;
+    orientation: ImageOrientation;
+    rotationDegrees: 0 | 90 | 180 | 270;
+    mirrored: boolean;
+    requiresNormalization: boolean;
+}
+interface EncodedImageMetadata {
+    width: number;
+    height: number;
+    format: MarkerImageFormat;
+    mimeType?: string;
+    orientation?: ImageOrientation;
+}
+export declare function createMarkerImageInfo(metadata: EncodedImageMetadata): MarkerImageInfo;
+/** Parse encoded metadata without decoding the image pixels. */
+export declare function parseEncodedImageInfo(input: ArrayBuffer | ArrayBufferView): MarkerImageInfo;
+export declare function parseNativeImageInfo(serialized: string): MarkerImageInfo;
+export {};