@frybynite/image-cloud 0.4.2 → 0.5.2

package/dist/engines/AnimationEngine.d.ts

@@ -0,0 +1,82 @@
+import { AnimationConfig, TransformParams, ImageLayout, AnimationHandle, AnimationSnapshot } from '../config/types';
+export declare class AnimationEngine {
+    private config;
+    private activeAnimations;
+    private animationIdCounter;
+    constructor(config: AnimationConfig);
+    /**
+     * Build transform string from transform params
+     * Always starts with centering transform to match image positioning system
+     */
+    private buildTransformString;
+    /**
+     * Start a cancellable transform animation using Web Animations API
+     * @param element - The element to animate
+     * @param from - Starting transform state
+     * @param to - Ending transform state
+     * @param duration - Animation duration in ms (optional)
+     * @param easing - CSS easing function (optional)
+     * @returns AnimationHandle that can be used to cancel or query the animation
+     */
+    animateTransformCancellable(element: HTMLElement, from: TransformParams, to: TransformParams, duration?: number | null, easing?: string | null): AnimationHandle;
+    /**
+     * Cancel an active animation
+     * @param handle - The animation handle to cancel
+     * @param commitStyle - If true, keeps current position; if false, no style change
+     * @returns Snapshot of where the animation was when cancelled
+     */
+    cancelAnimation(handle: AnimationHandle, commitStyle?: boolean): AnimationSnapshot;
+    /**
+     * Cancel all animations on an element
+     * Uses Web Animations API to find and cancel ALL animations, not just tracked ones
+     * @param element - The element to cancel animations for
+     */
+    cancelAllAnimations(element: HTMLElement): void;
+    /**
+     * Get current transform state of an element (works mid-animation)
+     * Uses DOMMatrix to parse the computed transform
+     * @param element - The element to query
+     * @returns Current transform snapshot
+     */
+    getCurrentTransform(element: HTMLElement): AnimationSnapshot;
+    /**
+     * Check if an element has an active animation
+     * @param element - The element to check
+     * @returns True if animation is in progress
+     */
+    hasActiveAnimation(element: HTMLElement): boolean;
+    /**
+     * Get animation handle for an element if it exists
+     * @param element - The element to query
+     * @returns AnimationHandle or undefined
+     */
+    getAnimationHandle(element: HTMLElement): AnimationHandle | undefined;
+    /**
+     * Animate element transform with smooth easing (CSS transitions - legacy method)
+     * @param element - The element to animate
+     * @param properties - Transform properties {x, y, rotation, scale}
+     * @param duration - Animation duration in ms (optional)
+     * @param easing - CSS easing function (optional)
+     * @returns Promise that resolves when animation completes
+     */
+    animateTransform(element: HTMLElement, properties: TransformParams, duration?: number | null, easing?: string | null): Promise<void>;
+    /**
+     * Reset element to its original transform
+     * @param element - The element to reset
+     * @param originalState - Original transform state {x, y, rotation, scale}
+     * @returns Promise that resolves when animation completes
+     */
+    resetTransform(element: HTMLElement, originalState: TransformParams | ImageLayout): Promise<void>;
+    /**
+     * Remove transition styles from element
+     * @param element - The element to clear
+     */
+    clearTransition(element: HTMLElement): void;
+    /**
+     * Utility: Wait for a specified duration
+     * @param ms - Milliseconds to wait
+     * @returns Promise that resolves after the specified duration
+     */
+    wait(ms: number): Promise<void>;
+}
+//# sourceMappingURL=AnimationEngine.d.ts.map

package/dist/engines/AnimationEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationEngine.d.ts","sourceRoot":"","sources":["../../src/engines/AnimationEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,WAAW,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,gBAAgB,CAAgD;IACxE,OAAO,CAAC,kBAAkB,CAAK;gBAEnB,MAAM,EAAE,eAAe;IAInC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;;;OAQG;IACH,2BAA2B,CACzB,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,eAAe,EACrB,EAAE,EAAE,eAAe,EACnB,QAAQ,GAAE,MAAM,GAAG,IAAW,EAC9B,MAAM,GAAE,MAAM,GAAG,IAAW,GAC3B,eAAe;IAqDlB;;;;;OAKG;IACH,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,WAAW,GAAE,OAAc,GAAG,iBAAiB;IAsBxF;;;;OAIG;IACH,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAc/C;;;;;OAKG;IACH,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,iBAAiB;IA6B5D;;;;OAIG;IACH,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO;IAIjD;;;;OAIG;IACH,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,GAAG,SAAS;IAIrE;;;;;;;OAOG;IACH,gBAAgB,CACd,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,eAAe,EAC3B,QAAQ,GAAE,MAAM,GAAG,IAAW,EAC9B,MAAM,GAAE,MAAM,GAAG,IAAW,GAC3B,OAAO,CAAC,IAAI,CAAC;IAkBhB;;;;;OAKG;IACH,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,eAAe,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjG;;;OAGG;IACH,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAI3C;;;;OAIG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/engines/EntryAnimationEngine.d.ts

@@ -0,0 +1,161 @@
+import { EntryAnimationConfig, ContainerBounds, LayoutAlgorithm, EntryPathConfig, EntryPathType, EntryRotationConfig, EntryRotationMode, EntryScaleConfig, EntryScaleMode } from '../config/types';
+export interface StartPosition {
+    x: number;
+    y: number;
+    useScale?: boolean;
+}
+export interface AnimationParams {
+    startTransform: string;
+    duration: number;
+    delay: number;
+    easing: string;
+}
+export declare class EntryAnimationEngine {
+    private config;
+    private layoutAlgorithm;
+    private resolvedStartPosition;
+    private pathConfig;
+    private rotationConfig;
+    private scaleConfig;
+    constructor(config: EntryAnimationConfig, layoutAlgorithm: LayoutAlgorithm);
+    /**
+     * Get the effective start position, considering layout-aware defaults
+     */
+    private resolveStartPosition;
+    /**
+     * Calculate the starting position for an image's entry animation
+     */
+    calculateStartPosition(finalPosition: {
+        x: number;
+        y: number;
+    }, imageSize: {
+        width: number;
+        height: number;
+    }, containerBounds: ContainerBounds, imageIndex: number, totalImages: number): StartPosition;
+    /**
+     * Calculate start position from the nearest edge (current default behavior)
+     */
+    private calculateNearestEdge;
+    /**
+     * Calculate start position from a specific edge
+     */
+    private calculateEdgePosition;
+    /**
+     * Calculate start position from center with scale animation
+     */
+    private calculateCenterPosition;
+    /**
+     * Calculate start position from a random edge
+     */
+    private calculateRandomEdge;
+    /**
+     * Calculate start position on a circle around the container
+     */
+    private calculateCircularPosition;
+    /**
+     * Get animation parameters for an image
+     */
+    getAnimationParams(_imageIndex: number): AnimationParams;
+    /**
+     * Build a CSS transform string for the start position
+     * Uses pixel-based centering offset for reliable cross-browser behavior
+     */
+    buildStartTransform(startPosition: StartPosition, finalPosition: {
+        x: number;
+        y: number;
+    }, finalRotation: number, finalScale: number, imageWidth?: number, imageHeight?: number, startRotation?: number, startScale?: number): string;
+    /**
+     * Build the final CSS transform string
+     * Uses pixel-based centering offset for reliable cross-browser behavior
+     */
+    buildFinalTransform(rotation: number, scale: number, imageWidth?: number, imageHeight?: number): string;
+    /**
+     * Get the transition CSS for entry animation
+     * For JS-animated paths, only animate opacity (transform handled by JS)
+     */
+    getTransitionCSS(): string;
+    /**
+     * Check if the current path type requires JavaScript animation
+     */
+    requiresJSAnimation(): boolean;
+    /**
+     * Get the path configuration
+     */
+    getPathConfig(): EntryPathConfig;
+    /**
+     * Get the path type
+     */
+    getPathType(): EntryPathType;
+    /**
+     * Get animation timing configuration
+     */
+    getTiming(): {
+        duration: number;
+    };
+    /**
+     * Get the rotation configuration
+     */
+    getRotationConfig(): EntryRotationConfig;
+    /**
+     * Get the rotation mode
+     */
+    getRotationMode(): EntryRotationMode;
+    /**
+     * Calculate the starting rotation for an entry animation
+     * @param finalRotation - The final rotation from the layout
+     * @returns The starting rotation in degrees
+     */
+    calculateStartRotation(finalRotation: number): number;
+    /**
+     * Resolve spin direction based on config
+     * @returns 1 for clockwise, -1 for counterclockwise
+     */
+    private resolveSpinDirection;
+    /**
+     * Check if the current rotation mode requires JavaScript animation
+     * (as opposed to CSS transitions)
+     */
+    requiresJSRotation(): boolean;
+    /**
+     * Calculate wobble rotation for a given animation progress
+     * @param progress - Animation progress from 0 to 1
+     * @param finalRotation - The final rotation in degrees
+     * @returns The current rotation in degrees
+     */
+    calculateWobbleRotation(progress: number, finalRotation: number): number;
+    /**
+     * Get the scale configuration
+     */
+    getScaleConfig(): EntryScaleConfig;
+    /**
+     * Get the scale mode
+     */
+    getScaleMode(): EntryScaleMode;
+    /**
+     * Calculate the starting scale for an entry animation
+     * @param finalScale - The final scale from the layout
+     * @returns The starting scale
+     */
+    calculateStartScale(finalScale: number): number;
+    /**
+     * Check if the current scale mode requires JavaScript animation
+     * (as opposed to CSS transitions)
+     */
+    requiresJSScale(): boolean;
+    /**
+     * Calculate pop scale for a given animation progress
+     * @param progress - Animation progress from 0 to 1
+     * @param finalScale - The final scale value
+     * @returns The current scale value with bounce effect
+     */
+    calculatePopScale(progress: number, finalScale: number): number;
+    /**
+     * Generate keyframes for scale bounce animation
+     */
+    private generateScaleBounceKeyframes;
+    /**
+     * Easing function for smooth transitions
+     */
+    private easeOutQuad;
+}
+//# sourceMappingURL=EntryAnimationEngine.d.ts.map

package/dist/engines/EntryAnimationEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntryAnimationEngine.d.ts","sourceRoot":"","sources":["../../src/engines/EntryAnimationEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,oBAAoB,EAEpB,eAAe,EACf,eAAe,EACf,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACf,MAAM,iBAAiB,CAAC;AAczB,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,qBAAqB,CAAqB;IAClD,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,WAAW,CAAmB;gBAE1B,MAAM,EAAE,oBAAoB,EAAE,eAAe,EAAE,eAAe;IAiB1E;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,sBAAsB,CACpB,aAAa,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EACvC,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAC5C,eAAe,EAAE,eAAe,EAChC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,aAAa;IAwChB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAqC5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA4B7B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IA4CjC;;OAEG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe;IAYxD;;;OAGG;IACH,mBAAmB,CACjB,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EACvC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,EACtB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM;IA2BT;;;OAGG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM;IAUvG;;;OAGG;IACH,gBAAgB,IAAI,MAAM;IAY1B;;OAEG;IACH,mBAAmB,IAAI,OAAO;IAI9B;;OAEG;IACH,aAAa,IAAI,eAAe;IAIhC;;OAEG;IACH,WAAW,IAAI,aAAa;IAI5B;;OAEG;IACH,SAAS,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE;IAMjC;;OAEG;IACH,iBAAiB,IAAI,mBAAmB;IAIxC;;OAEG;IACH,eAAe,IAAI,iBAAiB;IAIpC;;;;OAIG;IACH,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IA2CrD;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAkB5B;;;OAGG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;;;;OAKG;IACH,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAyBxE;;OAEG;IACH,cAAc,IAAI,gBAAgB;IAIlC;;OAEG;IACH,YAAY,IAAI,cAAc;IAI9B;;;;OAIG;IACH,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAqC/C;;;OAGG;IACH,eAAe,IAAI,OAAO;IAI1B;;;;;OAKG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAiC/D;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAoCpC;;OAEG;IACH,OAAO,CAAC,WAAW;CAGpB"}

package/dist/engines/LayoutEngine.d.ts

@@ -0,0 +1,68 @@
+import { LayoutConfig, ImageLayout, ContainerBounds, AdaptiveSizingResult, ImageConfig } from '../config/types';
+export interface LayoutEngineConfig {
+    layout: LayoutConfig;
+    image: ImageConfig;
+}
+export declare class LayoutEngine {
+    private config;
+    private imageConfig;
+    private layouts;
+    private placementLayout;
+    constructor(config: LayoutEngineConfig);
+    /**
+     * Initialize the appropriate placement layout based on config type
+     * @returns Initialized placement layout
+     */
+    private initLayout;
+    /**
+     * Generate layout positions for images
+     * @param imageCount - Number of images to layout
+     * @param containerBounds - Container dimensions {width, height}
+     * @param options - Optional overrides for configuration (e.g. fixedHeight)
+     * @returns Array of layout objects with position, rotation, scale
+     */
+    generateLayout(imageCount: number, containerBounds: ContainerBounds, options?: Partial<LayoutConfig>): ImageLayout[];
+    /**
+     * Get the original layout state for an image
+     * @param imageId - The image ID (number or string)
+     * @returns Original layout state or undefined if not found
+     */
+    getOriginalState(imageId: number | string): ImageLayout | undefined;
+    /**
+     * Reset all stored layouts
+     */
+    reset(): void;
+    /**
+     * Update config dynamically (useful for responsive changes)
+     * @param newConfig - Updated configuration
+     */
+    updateConfig(newConfig: Partial<LayoutEngineConfig>): void;
+    /**
+     * Get responsive breakpoints from layout config
+     */
+    private getBreakpoints;
+    /**
+     * Resolve breakpoint name based on viewport width
+     */
+    resolveBreakpoint(viewportWidth: number): 'mobile' | 'tablet' | 'screen';
+    /**
+     * Resolve the effective base height based on image config and current viewport
+     * @param viewportWidth - Current viewport width
+     * @returns Resolved base height or undefined if should auto-calculate (adaptive mode)
+     */
+    resolveBaseHeight(viewportWidth: number): number | undefined;
+    /**
+     * Calculate adaptive image size based on container dimensions and image count
+     * @param containerBounds - Container dimensions {width, height}
+     * @param imageCount - Number of images to display
+     * @param maxHeight - Maximum height constraint (upper bound)
+     * @param viewportWidth - Current viewport width for baseHeight resolution
+     * @returns Calculated sizing result with height
+     */
+    calculateAdaptiveSize(containerBounds: ContainerBounds, imageCount: number, maxHeight: number, viewportWidth: number): AdaptiveSizingResult;
+    /**
+     * Utility: Clamp a value between min and max
+     */
+    private clamp;
+}
+//# sourceMappingURL=LayoutEngine.d.ts.map

package/dist/engines/LayoutEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutEngine.d.ts","sourceRoot":"","sources":["../../src/engines/LayoutEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAmB,oBAAoB,EAAE,WAAW,EAA0C,MAAM,iBAAiB,CAAC;AAQ9K,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,WAAW,CAAC;CACpB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,eAAe,CAAkB;gBAE7B,MAAM,EAAE,kBAAkB;IAUtC;;;OAGG;IACH,OAAO,CAAC,UAAU;IAkBlB;;;;;;OAMG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,EAAE,OAAO,GAAE,OAAO,CAAC,YAAY,CAAM,GAAG,WAAW,EAAE;IAWxH;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS;IAInE;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;OAGG;IACH,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI;IAiB1D;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ;IAYxE;;;;OAIG;IACH,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAkC5D;;;;;;;OAOG;IACH,qBAAqB,CACnB,eAAe,EAAE,eAAe,EAChC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GACpB,oBAAoB;IAgDvB;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}

package/dist/engines/PathAnimator.d.ts

@@ -0,0 +1,50 @@
+import { BouncePathConfig, ElasticPathConfig, WavePathConfig, EntryPathConfig, EntryPathType, EntryRotationConfig, EntryScaleConfig } from '../config/types';
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface PathAnimationOptions {
+    element: HTMLElement;
+    startPosition: Point;
+    endPosition: Point;
+    pathConfig: EntryPathConfig;
+    duration: number;
+    imageWidth: number;
+    imageHeight: number;
+    rotation: number;
+    scale: number;
+    onComplete?: () => void;
+    rotationConfig?: EntryRotationConfig;
+    startRotation?: number;
+    scaleConfig?: EntryScaleConfig;
+    startScale?: number;
+}
+/**
+ * Calculate position along a bounce path
+ * Overshoot and settle animation
+ */
+export declare function calculateBouncePosition(t: number, start: Point, end: Point, config: BouncePathConfig): Point;
+/**
+ * Calculate position along an elastic path
+ * Spring-like oscillation animation
+ */
+export declare function calculateElasticPosition(t: number, start: Point, end: Point, config: ElasticPathConfig): Point;
+/**
+ * Calculate position along a wave path
+ * Sinusoidal path from start to end
+ */
+export declare function calculateWavePosition(t: number, start: Point, end: Point, config: WavePathConfig): Point;
+/**
+ * Animate an element along a path using requestAnimationFrame
+ */
+export declare function animatePath(options: PathAnimationOptions): void;
+/**
+ * Check if a path type requires JavaScript animation (vs CSS transitions)
+ */
+export declare function requiresJSAnimation(pathType: EntryPathType): boolean;
+/**
+ * Get CSS easing for bounce (approximation for simple bounce)
+ * Note: This is only used as a fallback; full bounce uses JS animation
+ */
+export declare function getBounceCSSEasing(): string;
+//# sourceMappingURL=PathAnimator.d.ts.map

package/dist/engines/PathAnimator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathAnimator.d.ts","sourceRoot":"","sources":["../../src/engines/PathAnimator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,iBAAiB,CAAC;AAOzB,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,WAAW,CAAC;IACrB,aAAa,EAAE,KAAK,CAAC;IACrB,WAAW,EAAE,KAAK,CAAC;IACnB,UAAU,EAAE,eAAe,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IAExB,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AASD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,KAAK,EACV,MAAM,EAAE,gBAAgB,GACvB,KAAK,CAiDP;AAqCD;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,KAAK,EACV,MAAM,EAAE,iBAAiB,GACxB,KAAK,CAmCP;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,KAAK,EACV,MAAM,EAAE,cAAc,GACrB,KAAK,CAyBP;AAwFD;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CA6H/D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAEpE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C"}

package/dist/engines/SwipeEngine.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SwipeEngine.ts
+ * Handles touch swipe gestures for navigating between focused images
+ *
+ * Public API:
+ * - enable() - Start listening for touch events
+ * - disable() - Stop listening (when no image focused)
+ * - destroy() - Clean up all event listeners
+ * - setDragCallback(callback) - Set callback for drag offset updates
+ */
+declare const SNAP_BACK_DURATION_MS = 150;
+interface SwipeCallbacks {
+    onNext: () => void;
+    onPrev: () => void;
+    onDragOffset: (offset: number) => void;
+    onDragEnd: (navigated: boolean) => void;
+}
+export declare class SwipeEngine {
+    private container;
+    private callbacks;
+    private enabled;
+    private touchState;
+    private recentTouchTimestamp;
+    private static readonly TOUCH_CLICK_DELAY;
+    private boundTouchStart;
+    private boundTouchMove;
+    private boundTouchEnd;
+    private boundTouchCancel;
+    constructor(container: HTMLElement, callbacks: SwipeCallbacks);
+    /**
+     * Start listening for touch events
+     */
+    enable(): void;
+    /**
+     * Stop listening for touch events
+     */
+    disable(): void;
+    /**
+     * Clean up all event listeners
+     */
+    destroy(): void;
+    /**
+     * Check if a touch interaction happened recently
+     * Used to prevent click-outside from unfocusing immediately after touch
+     */
+    hadRecentTouch(): boolean;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    private handleTouchCancel;
+}
+export { SNAP_BACK_DURATION_MS };
+//# sourceMappingURL=SwipeEngine.d.ts.map

package/dist/engines/SwipeEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwipeEngine.d.ts","sourceRoot":"","sources":["../../src/engines/SwipeEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,QAAA,MAAM,qBAAqB,MAAM,CAAC;AAGlC,UAAU,cAAc;IACtB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,SAAS,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CACzC;AAWD,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,UAAU,CAA2B;IAG7C,OAAO,CAAC,oBAAoB,CAAa;IACzC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAO;IAGhD,OAAO,CAAC,eAAe,CAA0B;IACjD,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,gBAAgB,CAA0B;gBAEtC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,cAAc;IAW7D;;OAEG;IACH,MAAM,IAAI,IAAI;IAad;;OAEG;IACH,OAAO,IAAI,IAAI;IAmBf;;OAEG;IACH,OAAO,IAAI,IAAI;IAIf;;;OAGG;IACH,cAAc,IAAI,OAAO;IAIzB,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,eAAe;IAmCvB,OAAO,CAAC,cAAc;IAwCtB,OAAO,CAAC,iBAAiB;CAM1B;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/engines/ZoomEngine.d.ts

@@ -0,0 +1,139 @@
+import { FocusInteractionConfig, ContainerBounds, ImageLayout, ImageStylingConfig, ZoomState } from '../config/types';
+import { AnimationEngine } from './AnimationEngine';
+export declare class ZoomEngine {
+    private config;
+    private animationEngine;
+    private state;
+    private currentFocus;
+    private focusData;
+    private outgoing;
+    private incoming;
+    private focusGeneration;
+    private defaultStyles;
+    private focusedStyles;
+    private defaultClassName;
+    private focusedClassName;
+    constructor(config: FocusInteractionConfig, animationEngine: AnimationEngine, styling?: ImageStylingConfig);
+    /**
+     * Get current state machine state
+     */
+    getState(): ZoomState;
+    /**
+     * Check if any animation is in progress
+     */
+    isAnimating(): boolean;
+    /**
+     * Normalize scalePercent value
+     */
+    private normalizeScalePercent;
+    /**
+     * Calculate target dimensions for focused image
+     * Returns actual pixel dimensions instead of scale factor for sharper rendering
+     */
+    private calculateFocusDimensions;
+    /**
+     * Calculate the transform needed to center an image (position only, no scale)
+     * Scale is handled by animating actual dimensions for sharper rendering
+     */
+    private calculateFocusTransform;
+    /**
+     * Build transform string for dimension-based zoom (no scale in transform)
+     */
+    private buildDimensionZoomTransform;
+    /**
+     * Create a Web Animation that animates both transform (position) and dimensions
+     * This provides sharper zoom by re-rendering at target size instead of scaling pixels
+     */
+    private animateWithDimensions;
+    /**
+     * Apply focused styling to an element
+     */
+    private applyFocusedStyling;
+    /**
+     * Remove focused styling from an element
+     */
+    private removeFocusedStyling;
+    /**
+     * Start focus animation for an image using dimension-based zoom
+     * Animates actual width/height for sharper rendering instead of transform scale
+     * @param fromTransform - Optional starting transform (for mid-animation reversals)
+     * @param fromDimensions - Optional starting dimensions (for mid-animation reversals)
+     */
+    private startFocusAnimation;
+    /**
+     * Start unfocus animation for an image using dimension-based zoom
+     * Animates back to original dimensions for consistent behavior
+     * @param fromDimensions - Optional starting dimensions (for mid-animation reversals)
+     */
+    private startUnfocusAnimation;
+    /**
+     * Capture the current visual state of an element mid-animation, BEFORE cancelling.
+     *
+     * The computed matrix.e/f include the -50%/-50% centering offset resolved to pixels.
+     * buildDimensionZoomTransform prepends its own translate(-50%,-50%), so passing raw
+     * matrix.e/f doubles the centering and produces the wrong starting position.
+     *
+     * This method extracts the PURE positional offset (pureX = matrix.e + 0.5*midWidth)
+     * and commits width/height/transform to inline styles before the animation is cancelled,
+     * preventing any visual snap.
+     *
+     * Must be called while the animation is still running (offsetWidth reflects animated size).
+     * Caller is responsible for calling animationEngine.cancelAllAnimations() afterwards.
+     */
+    private captureMidAnimationState;
+    /**
+     * Handle animation completion
+     */
+    private waitForAnimation;
+    /**
+     * Reset an element instantly to its original position and dimensions (no animation)
+     */
+    private resetElementInstantly;
+    /**
+     * Focus (zoom) an image to center of container
+     * Implements cross-animation when swapping focus
+     */
+    focusImage(imageElement: HTMLElement, containerBounds: ContainerBounds, originalState: ImageLayout): Promise<void>;
+    /**
+     * Unfocus current image, returning it to original position
+     */
+    unfocusImage(): Promise<void>;
+    /**
+     * Swap focus from current image to a new one (alias for focusImage with cross-animation)
+     */
+    swapFocus(newImageElement: HTMLElement, containerBounds: ContainerBounds, originalState: ImageLayout): Promise<void>;
+    /**
+     * Get currently focused image element
+     */
+    getCurrentFocus(): HTMLElement | null;
+    /**
+     * Check if an image is currently focused (stable state)
+     */
+    isFocused(imageElement: HTMLElement): boolean;
+    /**
+     * Check if an image is the target of current focus animation
+     */
+    isTargetingFocus(imageElement: HTMLElement): boolean;
+    /**
+     * Check if an image is involved in any focus/animation state
+     * Returns true if the image is focused, animating in, or animating out
+     * Useful for hover state management - don't apply hover to animating images
+     */
+    isInvolved(imageElement: HTMLElement): boolean;
+    /**
+     * Apply a temporary horizontal drag offset to the focused image
+     * Used during swipe gestures for visual feedback
+     */
+    setDragOffset(offset: number): void;
+    /**
+     * Clear the drag offset, optionally animating back to center
+     * @param animate - If true, animate back to center; if false, snap instantly
+     * @param duration - Animation duration in ms (default 150)
+     */
+    clearDragOffset(animate: boolean, duration?: number): void;
+    /**
+     * Reset zoom state (cancels all animations)
+     */
+    reset(): void;
+}
+//# sourceMappingURL=ZoomEngine.d.ts.map

package/dist/engines/ZoomEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZoomEngine.d.ts","sourceRoot":"","sources":["../../src/engines/ZoomEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,eAAe,EACf,WAAW,EAEX,kBAAkB,EAGnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAsBpD,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,eAAe,CAAkB;IAGzC,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,SAAS,CAA0B;IAG3C,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,QAAQ,CAA+B;IAG/C,OAAO,CAAC,eAAe,CAAa;IAGpC,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,gBAAgB,CAAgC;gBAE5C,MAAM,EAAE,sBAAsB,EAAE,eAAe,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,kBAAkB;IAW1G;;OAEG;IACH,QAAQ,IAAI,SAAS;IAIrB;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAiBhC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAkB/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkBnC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAwC7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IA+E3B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA8D7B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,wBAAwB;IA2BhC;;OAEG;YACW,gBAAgB;IAQ9B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA6B7B;;;OAGG;IACG,UAAU,CACd,YAAY,EAAE,WAAW,EACzB,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,WAAW,GACzB,OAAO,CAAC,IAAI,CAAC;IAyPhB;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IA+FnC;;OAEG;IACG,SAAS,CACb,eAAe,EAAE,WAAW,EAC5B,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,WAAW,GACzB,OAAO,CAAC,IAAI,CAAC;IAIhB;;OAEG;IACH,eAAe,IAAI,WAAW,GAAG,IAAI;IAIrC;;OAEG;IACH,SAAS,CAAC,YAAY,EAAE,WAAW,GAAG,OAAO;IAI7C;;OAEG;IACH,gBAAgB,CAAC,YAAY,EAAE,WAAW,GAAG,OAAO;IAIpD;;;;OAIG;IACH,UAAU,CAAC,YAAY,EAAE,WAAW,GAAG,OAAO;IAQ9C;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAmBnC;;;;OAIG;IACH,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,GAAE,MAAY,GAAG,IAAI;IA+B/D;;OAEG;IACH,KAAK,IAAI,IAAI;CAwCd"}

package/dist/image-cloud-auto-init.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Image Cloud Library - Auto-Initialization Entry Point
+ *
+ * Automatically initializes galleries from HTML data attributes
+ * Usage: Include this script and add data-image-cloud attribute to containers
+ */
+/**
+ * Auto-initialize galleries from data attributes
+ */
+declare function autoInitialize(): void;
+export { autoInitialize };
+export { ImageCloud } from './ImageCloud';
+export { ImageCloud as ImageGallery } from './ImageCloud';
+//# sourceMappingURL=image-cloud-auto-init.d.ts.map

package/dist/image-cloud-auto-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-cloud-auto-init.d.ts","sourceRoot":"","sources":["../src/image-cloud-auto-init.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoBH;;GAEG;AACH,iBAAS,cAAc,IAAI,IAAI,CA6D9B;AAMD,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,UAAU,IAAI,YAAY,EAAE,MAAM,cAAc,CAAC"}