@bensitu/image-editor 1.5.2 → 2.1.0

package/dist/types/export/export-service.d.ts

@@ -0,0 +1,333 @@
+/**
+ * Base64, file, and download entry points for the current export
+ * pipeline. The orchestrator (`image-editor.ts`) delegates
+ * `exportImageBase64`, `exportImageFile`, and `downloadImage`
+ * to the helpers in this module so the export logic lives in
+ * a single owner module per the documented module-decomposition
+ * table.
+ *
+ * ## Owned contracts
+ *
+ * - Before computing the export region, every
+ *   export entry point SHALL discard any active Fabric `ActiveSelection`
+ *   so it is not serialized into the output. The discard is performed
+ *   unconditionally; calling `canvas.discardActiveObject` with no active
+ *   selection is a documented no-op.
+ * - `exportImageBase64(options?: Base64ExportOptions)`
+ *   is the only canonical base64 export entry point. It accepts both
+ *   `fileType` and `format` for ergonomic interop and
+ *   returns a `Promise<string>` resolving to a `data:image/...;base64...`
+ *   data URL.
+ * - `exportImageFile(options?: ImageFileExportOptions)`
+ *   resolves to a `File` whose name comes from `options.fileName` or the
+ *   editor's `defaultDownloadFileName`.
+ * - `downloadImage(fileName?: string)` triggers a
+ *   browser download with the resolved filename. The bytes match the same
+ *   pipeline used by `exportImageBase64`.
+ * - When `isImageLoaded` is `false`, the three
+ *   entry points exhibit the documented "no image loaded" shapes:
+ *
+ *   | entry point          | shape on no image                   |
+ *   | -------------------- | ----------------------------------- |
+ *   | `exportImageBase64`  | resolves to `''`                    |
+ *   | `exportImageFile`    | rejects with `ExportNotReadyError`  |
+ *   | `downloadImage`      | no-op (returns synchronously)       |
+ *
+ * Each path emits a single `console.warn` naming the missing image so
+ * the consumer's logs identify which export attempt was skipped.
+ * - When `exportArea` resolves
+ *   to `'image'` and a valid `originalImage` exists, the export region is
+ *   computed from `originalImage.getBoundingRect` and passed directly
+ *   as `left`/`top`/`width`/`height` to Fabric's `toDataURL` options.
+ *   No intermediate `<canvas>` element is created, and sub-pixel
+ *   width/height values are floored to integer pixels through the
+ *   {@link floorRegion} helper before Fabric receives the region.
+ * - When `mergeMask` is
+ *   `true`, every mask's live style (`opacity`, `fill`, `stroke`,
+ *   `strokeWidth`, `selectable`, `lockRotation`) is captured BEFORE the
+ *   mutator forces the bake-in style (`opacity: 1, fill: '#000',
+ *   strokeWidth: 0, stroke: null, selectable: false`) and restored
+ *   inside a `finally` block whether the inner render resolved or
+ *   rejected. The backup/restore bracket is owned by
+ *   {@link withMaskStyleBackup} in `mask/mask-style.ts`; this module
+ *   only contributes the bake-in mutator.
+ * - **mergeMasks pre-export** — Before computing the merged
+ *   bitmap, {@link mergeMasks} discards any active Fabric
+ *   `ActiveSelection`. {@link exportImageBase64} also discards on its
+ *   own entry, so the discard runs at most twice (both calls are
+ *   idempotent no-ops when nothing is selected).
+ * - **mergeMasks atomicity** —
+ *   {@link mergeMasks} is the canonical merge entry point
+ *   (`Promise<void>`). It captures a pre-merge snapshot suitable for
+ *   `loadFromState`, renders the merged bitmap via
+ *   {@link exportImageBase64}, removes every mask without history,
+ *   reloads the merged data URL through the transactional
+ *   `image/image-loader.ts`, and on success pushes exactly one
+ *   {@link Command} whose `undo` restores the pre-merge snapshot and
+ *   whose `execute` re-applies the merged image. On any failure
+ *   between snapshot capture and history push, the pre-merge snapshot
+ *   is restored and the promise rejects with
+ *   {@link MergeMasksError}. Container scroll position is preserved
+ *   across the success path (canonically via
+ *   `loadImage(..., { preserveScroll: true})`, with a defensive
+ *   restore at the tail of the merge).
+ *
+ * ## Why a service-shaped module
+ *
+ * Per the documented "Mapping Contracts to modules" table the export
+ * pipeline owns its own module so the orchestrator stays thin. The
+ * service is a stateless function-collection (matching
+ * `image/image-loader.ts` and `core/state-serializer.ts`) and reads every
+ * editor field through an explicit {@link ExportServiceContext} bundle.
+ * This keeps the orchestrator authoritative for editor state — the export
+ * helpers never store a reference to the canvas or options between
+ * invocations — and makes the module trivially mockable from unit and
+ * property tests.
+ *
+ * The module is intentionally NOT re-exported from `src/index.ts`
+ * (only `ImageEditor`, `isMaskObject`, and the
+ * documented public types are root-exported).
+ *
+ * @module
+ */
+import type * as FabricNS from 'fabric';
+import type { Base64ExportOptions, FabricModule, ImageFileExportOptions, LoadImageOptions, ResolvedOptions } from '../core/public-types.js';
+import { type HistoryManager } from '../history/history-manager.js';
+/**
+ * Dependency bundle passed by the `ImageEditor` facade into every export
+ * entry point. The service has no class state of its own — every editor
+ * field it reads is exposed here as a value or callback so the facade
+ * keeps ownership of the canonical state.
+ *
+ * Mirrors the shape of {@link import('../image/image-loader.js').LoadImageContext}
+ * for consistency across pipeline modules.
+ *
+ * @see image/image-loader.ts (the same context-bundle pattern)
+ */
+export interface ExportServiceContext {
+    /** The Fabric module providing `Canvas` / `FabricImage`. */
+    readonly fabric: FabricModule;
+    /** The live Fabric canvas. Always non-null on a constructed editor. */
+    readonly canvas: FabricNS.Canvas;
+    /** Resolved editor options — supplies `defaultDownloadFileName`,
+     *  `downsampleQuality`, `exportMultiplier`, and
+     *  `exportAreaByDefault`. */
+    readonly options: ResolvedOptions;
+    /**
+     * Predicate matching `ImageEditor.isImageLoaded`. Returns `true`
+     * only when an `originalImage` has been committed and has positive
+     * dimensions (reads through this gate).
+     */
+    isImageLoaded(): boolean;
+    /**
+     * The currently committed `originalImage`, or `null` when no image is
+     * loaded. {@link computeExportRegion} reads it through this callback
+     * to derive the floored bounding box for image-area
+     * exports. When the image has been disposed or
+     * never loaded the seam falls through to a full-canvas export.
+     */
+    getOriginalImage(): FabricNS.FabricImage | null;
+}
+/**
+ * Render the live canvas to a base64 data URL.
+ *
+ * Steps, in order:
+ *
+ * 1. **No-image gate** — when `context.isImageLoaded`
+ *    is `false`, emit a `console.warn` and resolve to `''` without
+ *    touching the canvas.
+ * 2. **Discard ActiveSelection** — call
+ *    `canvas.discardActiveObject` once before computing the export
+ *    region. Subsequent steps render against the post-discard canvas
+ *    state, which never carries a top-level `ActiveSelection`.
+ * 3. **Resolve format/quality**
+ *    via {@link resolveExportFormat}.
+ * 4. **Resolve multiplier** — `options.multiplier || exportMultiplier || 1`.
+ * 5. **Compute region** — see {@link computeExportRegion}. Returns
+ *    `null` for full-canvas exports and a floored {@link IntegerRegion}
+ *    when `exportArea` is `'image'` and an `originalImage` is
+ *    committed.
+ * 6. **Render** through {@link withMaskExportState} so mask styles are
+ *    captured, the export bake-in (`opacity: 1, fill: '#000',
+ *    strokeWidth: 0, stroke: null, selectable: false`) is applied for
+ *    `mergeMask === true` exports, and the live styles are
+ *    restored in a `finally` block whether the render resolved or
+ *    threw. The inner step is a single
+ *    `canvas.toDataURL` call — no intermediate `<canvas>`.
+ *
+ * @param context - Export context bundle.
+ * @param options - Optional {@link Base64ExportOptions}. Both `fileType`
+ *                 and `format` are accepted; when
+ *                 both are supplied, `fileType` wins.
+ * @returns        Resolves to a `data:image/...;base64...` URL on
+ *                 success, or `''` when no image is loaded.
+ *
+ */
+export declare function exportImageBase64(context: ExportServiceContext, options?: Base64ExportOptions): Promise<string>;
+/**
+ * Render the live canvas to a `File`.
+ *
+ * The bytes come from {@link exportImageBase64} so format/quality/
+ * multiplier resolution stays consistent with the base64 path. The
+ * resulting data URL is repainted through an offscreen `<canvas>` only
+ * when its MIME prefix does not match the requested type — some browsers
+ * silently fall back to PNG when the requested format is unsupported,
+ * and the export contract requires the output MIME to match the resolved
+ * `fileType`.
+ *
+ * @param context - Export context bundle.
+ * @param options - Optional {@link ImageFileExportOptions}.
+ * @returns        Resolves with the rendered `File`.
+ * @throws         {@link ExportNotReadyError} when no image is loaded.
+ *
+ */
+export declare function exportImageFile(context: ExportServiceContext, options?: ImageFileExportOptions): Promise<File>;
+/**
+ * Trigger a browser download of the live canvas.
+ *
+ * Mirrors legacy's "anchor with `download` attribute" approach: an `<a>`
+ * element is created, pointed at the data URL, appended to the document
+ * so Firefox dispatches the click, clicked, and removed. The function
+ * returns synchronously; the data URL is rendered
+ * asynchronously and the click is deferred until that promise resolves.
+ *
+ * No-image gate emits the same `console.warn` as the
+ * other entry points and returns without touching the DOM.
+ *
+ * Errors raised by the underlying `exportImageBase64` call are reported
+ * with `console.error` rather than rethrown — `downloadImage` returns
+ * `void` and there is no caller-visible promise to reject.
+ *
+ * @param context - Export context bundle.
+ * @param fileName - Optional filename override. Defaults to
+ *                  `options.defaultDownloadFileName`.
+ *
+ */
+export declare function downloadImage(context: ExportServiceContext, fileName?: string): void;
+/**
+ * Dependency bundle passed by the `ImageEditor` facade into
+ * {@link mergeMasks}. Extends {@link ExportServiceContext} with the
+ * extra slots the merge pipeline needs:
+ *
+ * - the {@link HistoryManager} that records the merge as one undoable
+ *   step;
+ * - the canonical `loadImage` entry point (transactional load with
+ *   rollback) so a failed reload of the merged bitmap propagates back
+ *   to the merge's own rollback path;
+ * - the `saveState` / `loadFromState` callbacks the orchestrator
+ *   already wires for `undo` / `redo`, so the merge can capture and
+ *   restore the pre-merge snapshot through the same
+ *   `core/state-serializer.ts` helpers used by the rest of the editor;
+ * - a `removeAllMasks(saveHistory: false)` callback so the merge's
+ *   single enclosing history entry is the only one pushed for the
+ *   operation (exactly one history entry);
+ * - the live container element so the success path can preserve scroll
+ *   even when the inner `loadImage` did not honor `preserveScroll`.
+ *
+ * Mirrors the shape of `image/image-loader.ts → LoadImageContext` for
+ * consistency across pipeline modules. The `ImageEditor` facade constructs
+ * this bundle from its own state.
+ *
+ */
+export interface MergeMasksContext extends ExportServiceContext {
+    /** History manager that records the single merge command. */
+    readonly historyManager: HistoryManager;
+    /**
+     * Scrollable container wrapping the canvas, or `null`. Read at the
+     * head of `mergeMasks` so the success path can restore the captured
+     * scroll position regardless of the layout
+     * strategy applied by the inner `loadImage`.
+     */
+    readonly containerElement: HTMLElement | null;
+    /**
+     * Transactional image loader. The merge passes
+     * `{ preserveScroll: true}` so the inner load tries to keep scroll
+     * stable; the merge also restores scroll defensively at the tail of
+     * the success path.
+     */
+    loadImage(imageBase64: string, options?: LoadImageOptions): Promise<void>;
+    /**
+     * Capture a snapshot suitable for {@link loadFromStateFn}. Reads the
+     * orchestrator's `lastSnapshot`-producing path so the merge stores
+     * exactly the same wire format used by `undo` / `redo`.
+     */
+    saveState(): string;
+    /**
+     * Restore a snapshot produced by {@link saveStateFn}. Used both as
+     * the `undo` callback of the merge command and
+     * as the rollback step on any merge-pipeline failure.
+     */
+    loadFromState(snapshot: string): Promise<void>;
+    /**
+     * Remove every mask from the canvas WITHOUT pushing a history
+     * entry. The merge owns the single enclosing history entry, so the
+     * inner mask-removal step must opt out
+     * of its own history push.
+     */
+    removeAllMasksNoHistory(): void;
+}
+/**
+ * Flatten every mask into the base image and reload the flattened
+ * image as the new canvas state. Atomic with respect to the editor:
+ * either the merged image is committed and exactly one history entry
+ * is pushed, or the editor is rewound to its pre-merge state and the
+ * returned promise rejects with {@link MergeMasksError}.
+ *
+ * Steps, in order:
+ *
+ * 1. **No-op gates** — return without mutating anything when no image
+ *    is loaded or when the canvas carries no mask objects (matches
+ *    legacy's `if (!this.originalImage) return; … if (!masks.length) return;`).
+ * 2. **Capture pre-merge snapshot** — call
+ *    `context.saveState` so the snapshot is suitable for
+ *    `context.loadFromState(...)`. The snapshot is the one source of
+ *    truth for both the merge command's `undo` and
+ *    the rollback path.
+ * 3. **Discard ActiveSelection** — drop any active
+ *    selection wrapper before computing the merged bitmap.
+ * 4. **Capture container scroll** — read `scrollTop` / `scrollLeft`
+ *    from the editor container so the success path can restore them
+ *    after the inner `loadImage` runs.
+ * 5. **Render the merged bitmap** — delegate to
+ *    {@link exportImageBase64} with `exportArea: 'image'` and
+ *    `multiplier: options.exportMultiplier`. The bake-in/restore
+ *    bracket inside `exportImageBase64` ensures every live mask style
+ *    is captured before the export-only style is applied and restored
+ *    on both success and failure.
+ * 6. **Remove all masks** without pushing history — the merge owns
+ *    the single enclosing history entry, so the
+ *    inner removal step providedOptions out of its own history push.
+ * 7. **Reload the merged image** through the transactional
+ *    `image/image-loader.ts` with `preserveScroll: true`. A failed
+ *    reload propagates here so the rollback path catches it.
+ * 8. **Capture post-merge snapshot** — call `context.saveState` again so
+ *    the merge command's `execute` can replay the merged state on
+ *    redo.
+ * 9. **Restore scroll defensively** — write the
+ *    captured `scrollTop` / `scrollLeft` back to the container even
+ *    though the inner `loadImage` was asked to preserve scroll, so
+ *    the user's view does not jump regardless of the layout strategy
+ *    chosen by the loader.
+ * 10. **Push exactly one history command** whose
+ *    `undo` restores the pre-merge snapshot via `context.loadFromState`
+ *    and whose `execute` re-applies the merged snapshot via
+ *    `context.loadFromState`. The command is pushed via
+ *    {@link HistoryManager.push} (NOT `execute`) because the merged
+ *    state is already on the canvas — the first `redo` call should
+ *    re-run the merged-state restore, but the initial commit should
+ *    not double-render.
+ *
+ * On any failure between step 3 and step 10, the pre-merge snapshot
+ * captured in step 3 is restored via `context.loadFromState` and the
+ * promise rejects with {@link MergeMasksError} wrapping the original
+ * cause. A failure inside the rollback itself is
+ * logged via `console.warn` but does not mask the original error.
+ *
+ * @param context - Editor dependency bundle — see {@link MergeMasksContext}.
+ * @returns   Resolves on success; rejects with
+ *            {@link MergeMasksError} on any pipeline failure (after
+ *            the pre-merge snapshot has been restored).
+ *
+ */
+export declare function mergeMasks(context: MergeMasksContext): Promise<void>;
+//# sourceMappingURL=export-service.d.ts.map

package/dist/types/export/export-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-service.d.ts","sourceRoot":"","sources":["../../../src/export/export-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AAEH,OAAO,KAAK,KAAK,QAAQ,MAAM,QAAQ,CAAC;AAIxC,OAAO,KAAK,EACR,mBAAmB,EAEnB,YAAY,EACZ,sBAAsB,EACtB,gBAAgB,EAGhB,eAAe,EAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAsC7E;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACjC,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;IACjC;;iCAE6B;IAC7B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAElC;;;;OAIG;IACH,aAAa,IAAI,OAAO,CAAC;IAEzB;;;;;;OAMG;IACH,gBAAgB,IAAI,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC;CACnD;AAsqBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAiDjB;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CACjC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,CAAC,EAAE,sBAAsB,GACjC,OAAO,CAAC,IAAI,CAAC,CAsCf;AAID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAmCpF;AAID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC3D,6DAA6D;IAC7D,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,EAAE,WAAW,GAAG,IAAI,CAAC;IAE9C;;;;;OAKG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1E;;;;OAIG;IACH,SAAS,IAAI,MAAM,CAAC;IAEpB;;;;OAIG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/C;;;;;OAKG;IACH,uBAAuB,IAAI,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyH1E"}

package/dist/types/fabric/fabric-adapter.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Detects the Fabric.js v7 module from the constructor's
+ * first argument or from `globalThis.fabric`, and reports
+ * whether a usable module was found.
+ *
+ * Two delivery channels share the same source tree:
+ *
+ *  1. **ESM consumers** pass the imported Fabric module explicitly:
+ *   `new ImageEditor(fabric, options)`. Detected by `Canvas` being a
+ *   function on the first argument.
+ *
+ *  2. **UMD / CDN consumers** rely on `<script>` tags exposing
+ *   `window.fabric`, and call `new ImageEditor(options)` with no module
+ *   argument. The adapter reads `globalScope.fabric` and treats the
+ *   first argument as options.
+ *
+ * If neither channel produces a Fabric module with a `Canvas` constructor,
+ * the adapter returns `{ fabric: null, isFabricLoaded: false}`. The caller
+ * (the {@link ImageEditor} constructor) is then expected to make `init`
+ * and `loadImage` no-ops that resolve to `undefined`.
+ *
+ * Wrapping policy: this adapter does NOT proxy or normalize Fabric APIs.
+ * Callers MUST only invoke Fabric v7-compatible APIs directly:
+ * - `FabricImage.fromURL(...)` returning a Promise
+ * - `canvas.loadFromJSON(...)` returning a Promise
+ * - `canvas.setDimensions({ width, height})`
+ * - `canvas.bringObjectToFront(object)` / `canvas.sendObjectToBack(object)`
+ * - `canvas.backgroundColor` as a plain property (no setter callback)
+ * - `object.animate(...)` returning `Animation[]` (wrap with a Promise)
+ *   (Fabric v7 surface only.)
+ *
+ * @module
+ */
+import type { FabricModule, ImageEditorOptions } from '../core/public-types.js';
+/**
+ * Result of {@link detectFabric}. The caller should:
+ *   - assign `fabric` and `isFabricLoaded` to private fields on the editor,
+ *   - use `options` as the ImageEditorOptions partial to feed into
+ *     `core/default-options.ts`.
+ *
+ * `isFabricLoaded === false` means no usable Fabric module was found and
+ * `fabric` is `null`. The constructor SHALL guard `init` and
+ * `loadImage` accordingly.
+ */
+export interface FabricDetectionResult {
+    /** The detected Fabric module, or `null` when no module is available. */
+    fabric: FabricModule | null;
+    /** `true` iff `fabric` is non-null and `fabric.Canvas` is a function. */
+    isFabricLoaded: boolean;
+    /** The options partial extracted from the constructor arguments. */
+    options: ImageEditorOptions;
+}
+/**
+ * Detects whether the constructor's first argument is the Fabric module or
+ * an `ImageEditorOptions` object, and finds Fabric in the appropriate place.
+ *
+ * Behavior matrix:
+ *
+ * | First arg                                         | Result                                                       |
+ * | ------------------------------------------------- | ------------------------------------------------------------ |
+ * | Has `Canvas` function property                    | `{ fabric: arg, isFabricLoaded: true, options: maybeOptions}` |
+ * | Lacks `Canvas`, `globalScope.fabric.Canvas` is callback | `{ fabric: globalScope.fabric, isFabricLoaded: true, options: arg}` |
+ * | Lacks `Canvas`, no usable global                  | `{ fabric: null, isFabricLoaded: false, options: arg}` + single `console.error` |
+ *
+ * `null` / `undefined` first argument is normalized to an empty options
+ * object before being returned.
+ *
+ * @param fabricOrOptions - Constructor's first argument: either a Fabric module or an options partial.
+ * @param maybeOptions - Constructor's second argument, only consulted in the explicit-module form.
+ * @param globalScope - Global scope to consult for the UMD fallback. Defaults to `globalThis`; a custom scope is accepted to keep the adapter unit-testable.
+ *
+ */
+export declare function detectFabric(fabricOrOptions: FabricModule | ImageEditorOptions | null | undefined, maybeOptions: ImageEditorOptions | undefined, globalScope?: typeof globalThis): FabricDetectionResult;
+//# sourceMappingURL=fabric-adapter.d.ts.map

package/dist/types/fabric/fabric-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fabric-adapter.d.ts","sourceRoot":"","sources":["../../../src/fabric/fabric-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAIhF;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IAClC,yEAAyE;IACzE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,yEAAyE;IACzE,cAAc,EAAE,OAAO,CAAC;IACxB,oEAAoE;IACpE,OAAO,EAAE,kBAAkB,CAAC;CAC/B;AAkCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CACxB,eAAe,EAAE,YAAY,GAAG,kBAAkB,GAAG,IAAI,GAAG,SAAS,EACrE,YAAY,EAAE,kBAAkB,GAAG,SAAS,EAC5C,WAAW,GAAE,OAAO,UAAuB,GAC5C,qBAAqB,CAyCvB"}

package/dist/types/fabric/fabric-animation.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Promise-shaped wrapper around Fabric.js v7's
+ * {@link FabricNS.FabricObject.animate} for the current transform
+ * pipeline. v7's `animate(props, providedOptions)` returns an
+ * `Animation[]`-like map of contexts (one per animated
+ * property) and signals completion through the `onComplete`
+ * callback rather than a Promise. To plug it into the
+ * `AnimationQueue`, we wrap
+ * the call into a single Promise that resolves only after
+ * every property animation has fired its callback.
+ *
+ * ## Owned contracts
+ *
+ * - Wrap only Fabric v7-compatible APIs. v7's
+ *   `object.animate` returns `Animation[]` (a map of per-property contexts)
+ *   and reports completion via `onComplete`; multi-property tweens fire
+ *   the callback once per property. {@link animateProps} hides that shape
+ *   behind a single Promise so callers do not encode v7-specific shapes.
+ * - `scaleImage(factor)` animates the original
+ *   image over `options.animationDuration`. `scaleX` and `scaleY` are
+ *   tweened together, so the resolution count is two — see
+ *   {@link animateProps}.
+ * - `rotateImage(degrees)` animates `angle` over
+ *   `options.animationDuration`. The single-property case still flows
+ *   through the same wrapper and resolves on the first `onComplete`.
+ * - In-flight animation callbacks check
+ *   `isDisposed` (via `OperationGuard.isDisposed()`)
+ *   before touching the canvas. {@link animateProps} short-circuits the
+ *   `onChange` invocation when the editor has been disposed and still
+ *   settles its Promise so queued callers never hang
+ *   (the `AnimationQueue` contract).
+ * - Rotation animations temporarily set the image
+ *   origin to `'center'/'center'` so Fabric tweens around the visual
+ *   centroid. If dispose interrupts the animation between begin and the
+ *   post-animation origin restore in `image/transform-controller.ts`,
+ *   {@link restoreOrigin} replays the origin restore on the original
+ *   image so it is not left in the temporary center-origin state.
+ *
+ * The wrapper does not call `saveState`, mark the queue, or set
+ * `isAnimating` — those live in the orchestrator and {@link OperationGuard}.
+ * This file is intentionally
+ * tiny: it owns one Fabric v7 quirk (the `Animation[]` return shape) and
+ * one dispose-safety detail (origin restore on interrupt). Per the
+ * Module Responsibilities table, it is NOT re-exported from
+ * `src/index.ts`.
+ *
+ * @module
+ */
+import type * as FabricNS from 'fabric';
+import type { OperationGuard } from '../core/operation-guard.js';
+/**
+ * Options accepted by {@link animateProps}.
+ *
+ * Mirrors the subset of Fabric's `AnimationOptions` that the current transform
+ * pipeline uses. Additional fields (easing, duration jitter, etc.) are
+ * intentionally omitted so the wrapper has a single observable shape per
+ */
+export interface AnimateOptions {
+    /** Animation duration in milliseconds (matches `options.animationDuration`). */
+    duration: number;
+    /**
+     * Per-frame hook. Called on every Fabric animation tick while the
+     * editor is not disposed. Typically used to call
+     * `canvas.requestRenderAll`.
+     *
+     * The wrapper guards this call with {@link OperationGuard.isDisposed}
+     * so post-dispose ticks become no-ops.
+     */
+    onChange?: () => void;
+}
+/**
+ * Animate one or more numeric properties on a Fabric object and resolve
+ * a single Promise once **all** property animations have completed.
+ *
+ * In Fabric v7, `object.animate(props, providedOptions)` returns a per-property
+ * `Animation[]`-like map and signals completion via the `onComplete`
+ * callback. For multi-property tweens (e.g. `scale` requires both
+ * `scaleX` and `scaleY`), `onComplete` fires once per property — so we
+ * count completions before resolving.
+ *
+ * Dispose safety:
+ *
+ * - When the editor is disposed mid-animation, {@link AnimateOptions.onChange}
+ *   becomes a no-op so canvas references that may already be torn down
+ *   are not touched.
+ * - The Promise still settles (resolves) so the
+ *   `AnimationQueue` can drain queued
+ *   callers without hanging.
+ *
+ * Caller responsibilities:
+ *
+ * - The caller (transform controller) is responsible for the post-animation
+ *   `object.set({...}); object.setCoords;` snap so the final value is exact even
+ *   if Fabric rounds the last tick. The wrapper does not commit values.
+ * - The caller is responsible for `OperationGuard.runAnimation` bracketing
+ *   so `isAnimating` is `false` before the returned Promise resolves.
+ *
+ * @typeParam T - Concrete Fabric object subtype (FabricImage, Rect, etc.).
+ * @param object - Fabric object to animate.
+ * @param props - Map of property names to target numeric values (e.g.
+ *                 `{ scaleX: 1.5, scaleY: 1.5}` or `{ angle: 90}`).
+ * @param options - Duration and per-tick hook.
+ * @param guard - Operation guard providing the `isDisposed` flag that
+ *                 inner callbacks consult before touching the canvas.
+ * @returns        Resolves once every animated property has signalled
+ *                 completion. Rejects only if `object.animate` itself throws
+ *                 synchronously (an empty `props` map resolves immediately).
+ *
+ */
+export declare function animateProps<T extends FabricNS.FabricObject>(object: T, props: Record<string, number>, options: AnimateOptions, guard: OperationGuard): Promise<void>;
+/**
+ * Restore the `originX` / `originY` pair on a Fabric object after a
+ * rotation animation has been interrupted by dispose.
+ *
+ * `image/transform-controller.ts.rotateImage` temporarily sets the image
+ * origin to `'center'/'center'` so Fabric tweens the angle around the
+ * visual centroid (Fabric v7 defaults `originX`/`originY` to `'center'`,
+ * but the compatibility path uses `'left'/'top'` for placement math). The
+ * controller restores the original origin after the animation resolves.
+ * If dispose runs between begin and the post-animation restore, the
+ * controller's restore branch is skipped — leaving the image in the
+ * temporary center-origin state. This helper replays the restore so a
+ * post-dispose inspector (or a re-init that reuses the image reference)
+ * sees the documented top-left origin.
+ *
+ * The helper is intentionally side-effect-tolerant:
+ *
+ * - Errors are swallowed because the canvas may already have been
+ *   disposed and `setCoords` could throw on a torn-down object. The
+ *   point of the helper is best-effort cleanup, not a hard guarantee.
+ * - It does NOT request a render. The canvas is, by contract, on its way
+ *   out (this is only called from the dispose path).
+ *
+ * @param object - Fabric object whose origin pair needs restoring.
+ *                 In practice this is the editor's `originalImage`.
+ * @param originX - Origin to restore on the X axis (typically `'left'`).
+ * @param originY - Origin to restore on the Y axis (typically `'top'`).
+ *
+ */
+export declare function restoreOrigin(object: FabricNS.FabricObject, originX: FabricNS.TOriginX, originY: FabricNS.TOriginY): void;
+//# sourceMappingURL=fabric-animation.d.ts.map

package/dist/types/fabric/fabric-animation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fabric-animation.d.ts","sourceRoot":"","sources":["../../../src/fabric/fabric-animation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,KAAK,KAAK,QAAQ,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAQjE;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC3B,gFAAgF;IAChF,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,QAAQ,CAAC,YAAY,EACxD,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC,CAiFf;AAeD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CACzB,MAAM,EAAE,QAAQ,CAAC,YAAY,EAC7B,OAAO,EAAE,QAAQ,CAAC,QAAQ,EAC1B,OAAO,EAAE,QAAQ,CAAC,QAAQ,GAC3B,IAAI,CASN"}

package/dist/types/history/command.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Re-export shim for the {@link Command} class.
+ *
+ * The class itself is defined alongside {@link HistoryManager} in
+ * `./history-manager.ts` so the history module can be loaded directly
+ * from source by property tests running under Node's type-stripping
+ * mode without needing to resolve a sibling `.js` specifier at runtime.
+ *
+ * Module-layout consumers — and the canonical Module Responsibilities
+ * table — continue to see `command.ts` as the named home of the
+ * `Command` primitive.
+ *
+ * @module
+ */
+export { Command } from './history-manager.js';
+//# sourceMappingURL=command.d.ts.map

package/dist/types/history/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../src/history/command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC"}