@bensitu/image-editor 1.5.2 → 2.1.0

package/dist/types/mask/mask-style.d.ts

@@ -0,0 +1,338 @@
+/**
+ * Hover, selection, and "original style restore" helpers for
+ * mask visual state. Owns the legacy `_getMaskNormalStyle`,
+ * `_withNormalizedMaskStyles`, `_rebindMaskEvents`, and the
+ * selected/unselected stroke logic from `_handleSelectionChanged`
+ * that were inlined on the editor in legacy and are now extracted
+ * into pure(ish) helpers that take a {@link MaskStyleContext}.
+ *
+ * Two callers consume the same backup shape:
+ *
+ * - Export bake-in (`export/export-service.ts`) — temporarily forces every
+ *   mask to `opacity: 1, fill: '#000', strokeWidth: 0, stroke: null,
+ *   selectable: false` so the rendered raster has solid black masks, and
+ *   restores the live values inside a `finally` block whether the export
+ *   succeeded or threw.
+ *
+ * - Crop session (`crop/crop-controller.ts`) — backs up the same fields plus
+ *   `lockRotation` when entering crop mode and restores them on
+ *   `cancelCrop`.
+ *
+ * Centralizing the backup shape, the hover style literals (`#ff5500`,
+ * `strokeWidth: 2`, `opacity = originalAlpha + 0.2`), and the
+ * selected/unselected stroke literals (`#ff0000`, `mask.originalStroke ||
+ * '#ccc'`) here means the legacy visuals stay pixel-identical and any future
+ * tweak happens in one place.
+ *
+ * ## Owned contracts
+ *
+ * - {@link captureMaskStyleBackup} captures the prior
+ *   live values for `opacity`, `fill`, `stroke`, `strokeWidth`, `selectable`,
+ *   `evented`, and `lockRotation` BEFORE any export-only mutation runs. The backup
+ *   shape matches {@link MaskBackup} in `core/public-types.ts`.
+ *
+ * - {@link withMaskStyleBackup} runs the supplied
+ *   mutator → callback inside a `try/finally` so {@link restoreMaskStyleBackup}
+ *   is called regardless of whether the callback resolved or threw.
+ *
+ * - Each restored field is the exact value captured
+ *   at the start of the operation; the restore performs no defaulting and
+ *   no clamping, so an export-only style is never observable on any mask
+ *   after the operation returns.
+ *
+ * - {@link applyCropHideMaskStyle} sets `opacity: 0`
+ *   and `evented: false` on a mask so the user cannot interact with it
+ *   while the crop rectangle is the only interactive object. The caller is
+ *   expected to have captured a backup via {@link captureMaskStyleBackup}
+ *   first.
+ *
+ * - {@link restoreMaskStyleBackup} restores
+ *   `opacity`, `fill`, `strokeWidth`, `stroke`, `selectable`, `evented`,
+ *   and `lockRotation` from the captured {@link MaskBackup}, matching the current
+ *   documented `MaskBackup` interface.
+ *
+ * - **Mirrors legacy hover behavior** — {@link attachMaskHoverHandlers} and
+ *   {@link reattachMaskHoverHandlers} bind the same `mouseover`/`mouseout`
+ *   handlers legacy's `_rebindMaskEvents` used. The handlers read
+ *   `mask.originalAlpha` / `mask.originalStroke` / `mask.originalStrokeWidth`
+ *   on each invocation so they always reflect the current "live" state
+ *   (e.g. after a stroke change from a selection event).
+ *
+ * - **Mirrors legacy selection styling** — {@link applyMaskSelectedStyle} sets
+ *   the selection-highlight stroke (`#ff0000`, `strokeWidth: 1`) and
+ *   {@link applyMaskUnselectedStyle} restores the normal stroke from the
+ *   per-mask `originalStroke` / `originalStrokeWidth`. Both literals match
+ *   legacy's `_handleSelectionChanged`.
+ *
+ * ## Out of scope (handled by sibling modules)
+ *
+ * - Mask creation, falsy-style preservation, polygon placement — see
+ *   `mask/mask-factory.ts`.
+ * - Mask label overlay — see `mask/mask-label-manager.ts`.
+ * - Mask list DOM — see `mask/mask-list.ts`.
+ *
+ * ## Implementation notes
+ *
+ * - The orchestrator (`src/image-editor.ts`) owns the canvas reference and
+ *   the resolved options. The helpers in this module receive those slots
+ *   through a {@link MaskStyleContext} so the module is independent of the
+ *   `ImageEditor` class shape and can be unit tested in isolation against
+ *   a stub Fabric environment.
+ * - Hover handlers do NOT cache the normal/hover style at attach time. They
+ *   read `mask.originalAlpha` / `mask.originalStroke` / `mask.originalStrokeWidth`
+ *   on every event so the visual matches the live "original" values even
+ *   after a stroke or opacity change (matching legacy).
+ * - The handlers are tagged on `mask.imageEditorMaskHandlers` exactly as
+ *   legacy did so {@link reattachMaskHoverHandlers} can drop the old pair before
+ *   binding fresh ones, avoiding duplicate listeners after `loadFromJSON`.
+ *
+ * @module
+ */
+import type * as FabricNS from 'fabric';
+import type { MaskBackup, MaskObject, ResolvedOptions } from '../core/public-types.js';
+/**
+ * State the mask-style helpers read from the `ImageEditor` orchestrator.
+ *
+ * The module does NOT own any of these slots — it only reads them so
+ * ownership of the canvas and resolved options stays on the orchestrator
+ * (where legacy left them).
+ */
+export interface MaskStyleContext {
+    /**
+     * The live Fabric canvas. May be `null` after `dispose` or before
+     * `init` has run; the helpers no-op in that case.
+     */
+    canvas: FabricNS.Canvas | null;
+    /**
+     * Fully resolved editor options. Only consulted by helpers that need
+     * the export-bake-in fill (`#000` matches legacy) or the crop visibility
+     * defaults; most helpers operate on the per-mask `original*` fields
+     * and do not need this slot.
+     */
+    options?: ResolvedOptions;
+}
+/**
+ * The "normal" (non-hover, non-selected) style of a mask, computed from
+ * its persisted `original*` fields. Matches the shape returned by legacy's
+ * `_getMaskNormalStyle`.
+ */
+export interface MaskNormalStyle {
+    stroke: FabricNS.TFiller | string | null;
+    strokeWidth: number;
+    opacity: number;
+}
+/**
+ * Compute the "normal" (non-hover, non-selected) style of `mask` from its
+ * persisted `original*` fields, with legacy-identical fallbacks.
+ *
+ * - `stroke` → `mask.originalStroke`, falling back to `'#ccc'` (legacy).
+ * - `strokeWidth` → `Number(mask.originalStrokeWidth)` if finite, else `1`.
+ * - `opacity` → `Number(mask.originalAlpha)` if finite, else `0.5`.
+ *
+ * The result is used by:
+ * - {@link applyMaskNormalStyle} to restore on `mouseout`,
+ * - {@link applyMaskUnselectedStyle} to restore the un-highlighted stroke,
+ * - export bake-in callers that want a pre-mutation snapshot of the live
+ *   visual when no `MaskBackup` is being captured.
+ *
+ * @param mask - The mask to inspect.
+ * @returns A {@link MaskNormalStyle} ready to pass to `mask.set(...)`.
+ */
+export declare function getMaskNormalStyle(mask: MaskObject): MaskNormalStyle;
+/**
+ * Compute the "hover" style for `mask`, derived from its normal style.
+ *
+ * - `stroke` → `'#ff5500'` (legacy).
+ * - `strokeWidth` → `2` (legacy).
+ * - `opacity` → `min(originalAlpha + 0.2, 1)` (legacy).
+ *
+ * @param mask - The mask to inspect.
+ * @returns A style patch ready to pass to `mask.set(...)`.
+ */
+export declare function getMaskHoverStyle(mask: MaskObject): MaskNormalStyle;
+/**
+ * Apply the selected-mask highlight stroke. Matches legacy's literal
+ * (`stroke: '#ff0000'`, `strokeWidth: 1`).
+ *
+ * Does NOT change opacity — the selection highlight only modifies the
+ * outline so the user can still see the mask's tinted fill.
+ *
+ * @param mask - The mask becoming selected.
+ */
+export declare function applyMaskSelectedStyle(mask: MaskObject): void;
+/**
+ * Restore the un-highlighted stroke on `mask` after selection moves to a
+ * different object. Reads the per-mask `originalStroke`/`originalStrokeWidth`
+ * (matching legacy's `_handleSelectionChanged`) so the value is the one the
+ * mask carried before any selection-time mutation.
+ *
+ * Does NOT touch `opacity` — the un-highlighted state retains the live
+ * opacity (which may differ from `originalAlpha` while a hover is in
+ * progress, etc.).
+ *
+ * @param mask - The mask becoming un-selected.
+ */
+export declare function applyMaskUnselectedStyle(mask: MaskObject): void;
+/**
+ * Bind `mouseover`/`mouseout` handlers on `mask` that toggle the legacy hover
+ * highlight. The handlers re-read `mask.originalAlpha` /
+ * `mask.originalStroke` / `mask.originalStrokeWidth` on each event so they
+ * track any post-attach mutation (matching legacy's `_rebindMaskEvents`).
+ *
+ * Handlers are tagged on `mask.imageEditorMaskHandlers` so
+ * {@link reattachMaskHoverHandlers} can drop them before binding a new
+ * pair, avoiding duplicates after a `loadFromJSON` restore.
+ *
+ * Idempotent — calling twice on the same mask without an intervening
+ * detach simply produces two pairs of listeners. Use
+ * {@link reattachMaskHoverHandlers} to refresh listeners safely.
+ *
+ * @param mask - The mask to bind handlers on.
+ */
+export declare function attachMaskHoverHandlers(mask: MaskObject): void;
+/**
+ * Drop any previously-attached hover handler pair (best-effort) and bind a
+ * fresh pair via {@link attachMaskHoverHandlers}.
+ *
+ * Used after `canvas.loadFromJSON` in `core/state-serializer.ts`'s
+ * `loadFromState` flow, because Fabric never serializes event listeners,
+ * so masks restored from history have lost their hover styling. The
+ * orchestrator re-runs this helper for every restored mask.
+ *
+ * Also re-asserts the persisted `original*` metadata when missing — legacy's
+ * `_rebindMaskEvents` did the same so a snapshot from an older format that
+ * happens to lack `originalStroke`/`originalStrokeWidth` still hovers
+ * correctly. The current Pretty_Printer always serializes
+ * `originalAlpha`, but we defend against partial payloads here too.
+ *
+ * @param mask - The mask to refresh handlers on.
+ */
+export declare function reattachMaskHoverHandlers(mask: MaskObject): void;
+/**
+ * Detach the hover handler pair previously bound by
+ * {@link attachMaskHoverHandlers} (or {@link reattachMaskHoverHandlers}).
+ *
+ * Best-effort — wraps each `off(...)` in `try/catch` so a stale Fabric
+ * reference does not break callers that iterate every mask (e.g. the
+ * `dispose` path or `removeAllMasks`).
+ *
+ * @param mask - The mask to detach handlers from.
+ */
+export declare function detachMaskHoverHandlers(mask: MaskObject): void;
+/**
+ * Snapshot the current live values of the fields that both the export
+ * bake-in path and the crop session need to restore later.
+ *
+ * Captured fields:
+ *
+ * - `opacity` — restored when the export ends or the crop is canceled.
+ * - `fill` — export bake-in temporarily forces `'#000'`; crop never
+ *   changes fill but captures it so a single restore call works for both.
+ * - `strokeWidth` — export bake-in forces `0`.
+ * - `stroke` — export bake-in forces `null`.
+ * - `selectable` — both paths force `false` so the mask is not draggable
+ *   while the operation is in progress.
+ * - `evented` — the crop session forces `false` while the crop rectangle is
+ *   the only interactive object.
+ * - `lockRotation` — the crop session captures this because some integrators
+ *   set `maskRotatable: true` and the rotation lock is part of the
+ *   per-mask state.
+ *
+ * Defaults match legacy: missing `opacity` → `1`, missing `selectable` →
+ * `true`, missing `lockRotation` → `false`. They never override a
+ * caller-supplied value because the snapshot reads from the live mask.
+ *
+ * @param mask - The mask whose live style should be captured.
+ * @returns A {@link MaskBackup} suitable for passing to
+ *          {@link restoreMaskStyleBackup}.
+ */
+export declare function captureMaskStyleBackup(mask: MaskObject): MaskBackup;
+/**
+ * Restore every backed-up field from a {@link MaskBackup} onto the mask
+ * referenced by `backup.object`.
+ *
+ * Wraps the `set(...)` call in `try/catch` so a stale Fabric reference (a
+ * mask removed after the backup was captured but before the restore
+ * finally block ran) does not break callers iterating multiple backups.
+ * After a successful restore, `setCoords` is called to keep Fabric's
+ * cached bounding rect in sync (matching legacy's mergeMasks restore).
+ *
+ * @param backup - The backup produced by {@link captureMaskStyleBackup}.
+ *
+ */
+export declare function restoreMaskStyleBackup(backup: MaskBackup): void;
+/**
+ * Run `callback` with every mask's stroke/strokeWidth/opacity reset to the
+ * persisted "normal" style ({@link getMaskNormalStyle}), then restore each
+ * mutated field inside a `finally` block.
+ *
+ * Mirrors legacy's `_withNormalizedMaskStyles`. The two callers are:
+ *
+ * - The pre-snapshot pass in some history paths that wants the snapshot
+ *   to capture a "clean" un-hovered, un-selected canvas regardless of the
+ *   live UI state.
+ * - The crop-cancel restore path that wants to clear any selection
+ *   highlight before re-rendering.
+ *
+ * Only fields that ACTUALLY changed are captured and restored — if a mask
+ * is already at its normal style, no patch is recorded for it.
+ *
+ * The `finally` block runs whether `callback` returned, threw, or
+ * rejected. The function returns whatever `callback` returns (sync or
+ * Promise), preserving the caller's control flow.
+ *
+ * @param context - Orchestration context — see {@link MaskStyleContext}.
+ * @param callback - Body to execute with normalized mask styles.
+ * @returns        The value returned by `callback` (or the promise it returned).
+ */
+export declare function withNormalizedMaskStyles<T>(context: MaskStyleContext, callback: () => T): T;
+/**
+ * Captures every mask's live style via {@link captureMaskStyleBackup},
+ * runs the supplied async `callback` (which is allowed to mutate masks
+ * freely — typically by forcing the export bake-in style of
+ * `opacity: 1, fill: '#000', strokeWidth: 0, stroke: null,
+ * selectable: false`), then restores every mask's pre-callback state in a
+ * `finally` block — even if `callback` rejected.
+ *
+ * This is the canonical owner of the "export-only style restoration"
+ * contract. Callers in
+ * `export/export-service.ts` use this so they never need to write their
+ * own `try/finally` block — and so a future refactor cannot accidentally
+ * forget the restore step on an early return path.
+ *
+ * The function returns whatever `callback` resolves to.
+ *
+ * @typeParam T - The return type of `callback`.
+ * @param context - Orchestration context — see {@link MaskStyleContext}.
+ * @param mutator - Synchronous function applied to each captured mask
+ *                   BEFORE `callback` runs. Typically applies the export
+ *                   bake-in style. Called once per mask in canvas object
+ *                   order with `(mask, index)`. Backups are captured BEFORE
+ *                   the mutator runs so an exception in the mutator still
+ *                   triggers the `finally` restore for already-mutated
+ *                   masks.
+ * @param callback - The export body to run after every mutator pass
+ *                   completed. Typically `canvas.toDataURL` plus any
+ *                   post-processing.
+ * @returns          The value `callback` resolved to.
+ *
+ */
+export declare function withMaskStyleBackup<T>(context: MaskStyleContext, mutator: (mask: MaskObject, index: number) => void, callback: () => Promise<T> | T): Promise<T>;
+/**
+ * Apply the crop-mode hide style on `mask`: opacity 0 + non-interactive.
+ *
+ * Used by `crop/crop-controller.ts` when entering crop mode with
+ * `options.crop.hideMasksDuringCrop === true`. Callers MUST capture a
+ * {@link MaskBackup} via {@link captureMaskStyleBackup} BEFORE calling
+ * this helper so {@link restoreMaskStyleBackup} can revert the change on
+ * `cancelCrop`.
+ *
+ * Sets `evented: false` and `selectable: false` so the user cannot
+ * interact with the mask while only the crop rectangle should respond to
+ * pointer events. Wraps the `set(...)` in `try/catch` so a removed mask
+ * does not break the loop in the controller.
+ *
+ * @param mask - The mask to hide.
+ */
+export declare function applyCropHideMaskStyle(mask: MaskObject): void;
+//# sourceMappingURL=mask-style.d.ts.map

package/dist/types/mask/mask-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask-style.d.ts","sourceRoot":"","sources":["../../../src/mask/mask-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AAEH,OAAO,KAAK,KAAK,QAAQ,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAwBvF;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;;OAGG;IACH,MAAM,EAAE,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC;IAC/B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC5B,MAAM,EAAE,QAAQ,CAAC,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACnB;AAoBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,eAAe,CAQpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,eAAe,CAQnE;AAID;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAE7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAM/D;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAe9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAwChE;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAU9D;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAWnE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAiB/D;AAeD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAiC3F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EACvC,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,EAClD,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAC/B,OAAO,CAAC,CAAC,CAAC,CAiBZ;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAM7D"}

package/dist/types/mosaic/mosaic-controller.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Mosaic mode controller.
+ *
+ * Owns the Mosaic session lifecycle, preview objects, Fabric pointer handlers,
+ * and the base-image pixel replacement pipeline. The ImageEditor facade owns
+ * canonical editor state and passes it in through the context callbacks.
+ *
+ * @module
+ */
+import type * as FabricNS from 'fabric';
+import type { FabricModule, ImageEditorCallbackContext, ImageEditorOperation, ImageMimeType, ResolvedMosaicConfig, ResolvedOptions } from '../core/public-types.js';
+import { type HistoryManager } from '../history/history-manager.js';
+import { type MosaicImagePoint } from './mosaic-geometry.js';
+interface MosaicPreviewCircle extends FabricNS.Circle {
+    isMosaicPreview?: boolean;
+}
+interface MosaicPreviewImage extends FabricNS.FabricImage {
+    isMosaicPreview?: boolean;
+}
+export interface MosaicSession {
+    previewCircle: MosaicPreviewCircle | null;
+    previewImage: MosaicPreviewImage | null;
+    prevSelection: boolean;
+    prevDefaultCursor: string | undefined;
+    prevObjectStates: Array<{
+        object: FabricNS.FabricObject;
+        evented: boolean;
+        selectable: boolean;
+    }>;
+    handlers: Array<{
+        eventName: string;
+        callback: (event: unknown) => void;
+    }>;
+    rasterCache: MosaicRasterCache | null;
+    pendingCanvasPoints: Array<{
+        x: number;
+        y: number;
+    }>;
+    isPointerDown: boolean;
+    isApplying: boolean;
+    commitRequested: boolean;
+    hasUncommittedChanges: boolean;
+    lastImagePoint: MosaicImagePoint | null;
+}
+export interface MosaicControllerContext {
+    readonly fabric: FabricModule;
+    readonly canvas: FabricNS.Canvas;
+    readonly options: ResolvedOptions;
+    readonly historyManager: HistoryManager;
+    getMosaicConfig(): ResolvedMosaicConfig;
+    isImageLoaded(): boolean;
+    getOriginalImage(): FabricNS.FabricImage | null;
+    setOriginalImage(image: FabricNS.FabricImage | null): void;
+    getCurrentImageMimeType(): ImageMimeType | null;
+    setCurrentImageMimeType(mimeType: ImageMimeType | null): void;
+    getLastSnapshot(): string | null;
+    setLastSnapshot(snapshot: string | null): void;
+    captureSnapshot(): string;
+    loadFromState(snapshot: string): Promise<void>;
+    updateUi(): void;
+    updateInputs(): void;
+    hideAllMaskLabels(): void;
+    emitImageChanged(context: ImageEditorCallbackContext): void;
+    emitBusyChangeIfChanged(context: ImageEditorCallbackContext): void;
+    buildCallbackContext(operation: ImageEditorOperation, isInternal?: boolean): ImageEditorCallbackContext;
+    getMosaicSession(): MosaicSession | null;
+    setMosaicSession(session: MosaicSession | null): void;
+}
+interface MosaicRasterCache {
+    offscreenCanvas: HTMLCanvasElement;
+    renderingContext: CanvasRenderingContext2D;
+    imageData: ImageData;
+    source: string;
+    width: number;
+    height: number;
+}
+export declare function enterMosaicMode(context: MosaicControllerContext): void;
+export declare function exitMosaicMode(context: MosaicControllerContext): void;
+export declare function updateMosaicPreview(context: MosaicControllerContext): void;
+export declare function isMosaicPreviewObject(object: FabricNS.FabricObject): boolean;
+export {};
+//# sourceMappingURL=mosaic-controller.d.ts.map

package/dist/types/mosaic/mosaic-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mosaic-controller.d.ts","sourceRoot":"","sources":["../../../src/mosaic/mosaic-controller.ts"],"names":[],"mappings":"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"}

package/dist/types/mosaic/mosaic-geometry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Canvas-to-source-image coordinate conversion for Mosaic mode.
+ *
+ * Fabric object bounding boxes are not sufficient for rotated images. These
+ * helpers invert the image transform matrix and convert the pointer into the
+ * image's natural pixel coordinate space.
+ *
+ * @module
+ */
+import type * as FabricNS from 'fabric';
+import type { FabricModule } from '../core/public-types.js';
+export interface MosaicImagePoint {
+    sourceX: number;
+    sourceY: number;
+    sourceRadius: number;
+}
+/**
+ * Convert a Fabric canvas pointer into source-image pixels.
+ *
+ * For non-uniform image scale, `sourceRadius` uses the smaller canvas scale
+ * axis, which yields the larger source-space radius. This conservative
+ * deterministic strategy ensures the circular canvas brush covers the clicked
+ * image area after inverse transformation.
+ */
+export declare function getMosaicImagePoint(fabric: FabricModule, image: FabricNS.FabricImage, canvasPoint: {
+    x: number;
+    y: number;
+}, brushDiameterCanvasPx: number): MosaicImagePoint | null;
+//# sourceMappingURL=mosaic-geometry.d.ts.map

package/dist/types/mosaic/mosaic-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mosaic-geometry.d.ts","sourceRoot":"","sources":["../../../src/mosaic/mosaic-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,KAAK,QAAQ,MAAM,QAAQ,CAAC;AAExC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACxB;AAwED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,QAAQ,CAAC,WAAW,EAC3B,WAAW,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EACrC,qBAAqB,EAAE,MAAM,GAC9B,gBAAgB,GAAG,IAAI,CAmCzB"}

package/dist/types/mosaic/mosaic-pixelate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure pixelation helpers for Mosaic mode.
+ *
+ * The helpers mutate caller-supplied ImageData in place and do not touch DOM
+ * or Fabric state, which keeps the algorithm deterministic and directly
+ * testable.
+ *
+ * @module
+ */
+export interface MosaicPixelateOptions {
+    imageData: ImageData;
+    centerX: number;
+    centerY: number;
+    radius: number;
+    blockSize: number;
+}
+/**
+ * Applies blocky pixelation inside a circular brush region.
+ *
+ * @returns `true` when at least one pixel was processed, otherwise `false`.
+ */
+export declare function applyCircularMosaicToImageData(options: MosaicPixelateOptions): boolean;
+//# sourceMappingURL=mosaic-pixelate.d.ts.map

package/dist/types/mosaic/mosaic-pixelate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mosaic-pixelate.d.ts","sourceRoot":"","sources":["../../../src/mosaic/mosaic-pixelate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,qBAAqB;IAClC,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACrB;AAsBD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAiEtF"}

package/dist/types/ui/dom-bindings.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Managed registry of DOM event listeners owned by the
+ * {@link ImageEditor} facade. Records every listener it adds so
+ * `dispose` can detach them all idempotently.
+ *
+ * ## Owned contracts
+ *
+ * - `bindIfExists(key, event, handler)` records the
+ *   `{ elementKey, eventType, handler}` triple in an internal registry as
+ *   the listener is attached.
+ * - `removeAll` iterates the registry, calls
+ *   `removeEventListener` for every recorded entry, and clears the registry
+ *   afterwards.
+ * - Every `removeEventListener` call is wrapped in
+ *   `try/catch` so a second `dispose` (or a listener that has already been
+ *   detached by other means) never throws. `removeAll` is idempotent.
+ * - Every bound handler is wrapped so it consults the
+ *   editor's `isDisposed` flag (via the `isDisposed` callback supplied to the
+ *   constructor) and exits early without touching the canvas while disposed.
+ *
+ * ## Why this lives in its own module
+ *
+ * The orchestrator's `dispose` path needs to detach DOM listeners without
+ * caring about which logical key originally owned each one. Co-locating the
+ * registry here keeps the orchestrator free of bookkeeping and lets unit
+ * tests exercise the bindings registry without instantiating a full editor.
+ * This module is imported by `image-editor.ts` only and is intentionally not
+ * re-exported from `src/index.ts`.
+ *
+ * @module
+ */
+import type { ElementIdMap } from '../core/public-types.js';
+/**
+ * Logical element-name keys understood by the editor's `idMap`. Mirrors the
+ * `ElementKey` alias used internally by `image-editor.ts` so callers can
+ * speak the same vocabulary without crossing the public-types boundary.
+ */
+export type ElementKey = keyof Required<ElementIdMap>;
+/**
+ * Lightweight registry of DOM event listeners owned by an editor instance.
+ *
+ * The class is intentionally small: it does not know about Fabric, the
+ * animation queue, or the operation guard — it only knows how to look up an
+ * element ID for a key and how to add/remove a listener. Disposed-state
+ * awareness comes in via the `isDisposed` callback so the guard can stay the
+ * single source of truth for the `isDisposed` flag (see
+ * `core/operation-guard.ts`).
+ *
+ * Usage:
+ *
+ * ```ts
+ * const bindings = new DomBindings(
+ *   (key) => this.elements[key],
+ *   () => this.guard.isDisposed(),
+ * );
+ * bindings.bindIfExists('zoomInButton', 'click', () =>
+ *   this.scaleImage(s + step),
+ * );
+ * // ...
+ * bindings.removeAll(); // called from dispose
+ * ```
+ */
+export declare class DomBindings {
+    private registry;
+    private readonly resolveElementId;
+    private readonly isDisposed;
+    private readonly resolveDocument;
+    /**
+     * @param resolveElementId - Returns the resolved DOM element ID for a given logical key, or a
+     *   falsy value when the integrator omitted that key from the `idMap`.
+     *   The orchestrator's `elements` table fills this role.
+     * @param isDisposed - Returns the editor's current `isDisposed` flag. Bound handlers
+     *   consult this on every dispatch and exit early when it returns
+     *   `true`.
+     * @param resolveDocument - Returns the document that owns the bound controls.
+     */
+    constructor(resolveElementId: (key: ElementKey) => string | null | undefined, isDisposed: () => boolean, resolveDocument?: () => Document);
+    /**
+     * Look up the element registered under `key`. If it exists, attach
+     * `handler` for `eventType` and record the binding so `removeAll` can
+     * detach it later. The handler is wrapped to short-circuit when the
+     * editor has been disposed.
+     *
+     * Missing keys and missing elements are silently ignored — the editor
+     * tolerates partial DOM as documented under {@link ElementIdMap}.
+     *
+     * @returns `true` if the listener was attached, `false` if the element
+     *          could not be resolved.
+     */
+    bindIfExists(key: ElementKey, eventType: string, handler: EventListener): boolean;
+    /**
+     * Detach every recorded listener and clear the registry. Each
+     * `removeEventListener` call is wrapped in `try/catch` so an
+     * already-detached listener (for example because the host page swapped
+     * out the DOM node) does not abort the cleanup loop. Calling `removeAll`
+     * a second time is a no-op.
+     */
+    removeAll(): void;
+    /**
+     * Number of currently-registered listeners. Exposed for diagnostics and
+     * for the unit tests under `tests/units/dom-bindings.test.mjs`.
+     */
+    size(): number;
+}
+//# sourceMappingURL=dom-bindings.d.ts.map

package/dist/types/ui/dom-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-bindings.d.ts","sourceRoot":"","sources":["../../../src/ui/dom-bindings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC,YAAY,CAAC,CAAC;AActD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAiD;IAClF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiB;IAEjD;;;;;;;;OAQG;gBAEC,gBAAgB,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,EAChE,UAAU,EAAE,MAAM,OAAO,EACzB,eAAe,GAAE,MAAM,QAAyB;IAOpD;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO;IAmBjF;;;;;;OAMG;IACH,SAAS,IAAI,IAAI;IAgBjB;;;OAGG;IACH,IAAI,IAAI,MAAM;CAGjB"}