visualfries 0.1.0

package/dist/animations/AnimationPresetsRegister.d.ts

@@ -0,0 +1,362 @@
+import type { AnimationPreset } from "..";
+export declare class AnimationPresetsRegister {
+    #private;
+    private presets;
+    constructor();
+    register(preset: AnimationPreset): void;
+    getPresets(): Map<string, {
+        id: string;
+        timeline: {
+            tweens: {
+                method: "set" | "to" | "from" | "fromTo";
+                vars: {
+                    duration?: string | number | boolean | {
+                        fromData: string;
+                        mode: "cycle" | "useFallback" | "clamp";
+                        fallbackValue?: any;
+                    } | {
+                        type: "byIndex";
+                        expression: string;
+                        fallbackValue?: any;
+                    } | null | undefined;
+                    from?: import("zod").objectOutputType<{
+                        opacity: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        x: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        y: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        scale: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        scaleX: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        scaleY: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        rotation: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        width: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        height: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                        color: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                            fromData: import("zod").ZodString;
+                            mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            fromData: string;
+                            mode: "cycle" | "useFallback" | "clamp";
+                            fallbackValue?: any;
+                        }, {
+                            fromData: string;
+                            mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                            fallbackValue?: any;
+                        }>, import("zod").ZodObject<{
+                            type: import("zod").ZodLiteral<"byIndex">;
+                            expression: import("zod").ZodString;
+                            fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }, {
+                            type: "byIndex";
+                            expression: string;
+                            fallbackValue?: any;
+                        }>]>>;
+                    }, import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull, import("zod").ZodObject<{
+                        fromData: import("zod").ZodString;
+                        mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["cycle", "useFallback", "clamp"]>>>;
+                        fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        fromData: string;
+                        mode: "cycle" | "useFallback" | "clamp";
+                        fallbackValue?: any;
+                    }, {
+                        fromData: string;
+                        mode?: "cycle" | "useFallback" | "clamp" | undefined;
+                        fallbackValue?: any;
+                    }>, import("zod").ZodObject<{
+                        type: import("zod").ZodLiteral<"byIndex">;
+                        expression: import("zod").ZodString;
+                        fallbackValue: import("zod").ZodOptional<import("zod").ZodAny>;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        type: "byIndex";
+                        expression: string;
+                        fallbackValue?: any;
+                    }, {
+                        type: "byIndex";
+                        expression: string;
+                        fallbackValue?: any;
+                    }>]>, "strip"> | undefined;
+                    ease?: string | undefined;
+                    delay?: string | number | boolean | {
+                        fromData: string;
+                        mode: "cycle" | "useFallback" | "clamp";
+                        fallbackValue?: any;
+                    } | {
+                        type: "byIndex";
+                        expression: string;
+                        fallbackValue?: any;
+                    } | null | undefined;
+                    stagger?: number | {
+                        type?: "fromData" | undefined;
+                        from?: string | number | undefined;
+                        ease?: string | undefined;
+                        dataKey?: string | undefined;
+                        referencePoint?: "tweenStart" | undefined;
+                        each?: number | undefined;
+                        grid?: [number | "auto", number | "auto"] | undefined;
+                        axis?: "x" | "y" | undefined;
+                        amount?: number | undefined;
+                    } | undefined;
+                } & {
+                    [k: string]: any;
+                };
+                position?: string | number | {
+                    anchor: string;
+                    alignTween: "center" | "start" | "end";
+                    offset: string;
+                    anchorPoint?: "start" | "end" | undefined;
+                } | undefined;
+            }[];
+            id?: string | undefined;
+            position?: string | number | {
+                anchor: string;
+                alignTween: "center" | "start" | "end";
+                offset: string;
+                anchorPoint?: "start" | "end" | undefined;
+            } | undefined;
+            target?: string | undefined;
+        }[];
+        presetId?: string | undefined;
+        version?: string | undefined;
+        description?: string | undefined;
+        duration?: number | undefined;
+        data?: Record<string, any> | undefined;
+        setup?: ({
+            type: "style";
+            properties: {} & {
+                [k: string]: string | number | boolean | {
+                    fromData: string;
+                    mode: "cycle" | "useFallback" | "clamp";
+                    fallbackValue?: any;
+                } | {
+                    type: "byIndex";
+                    expression: string;
+                    fallbackValue?: any;
+                } | null;
+            };
+        } | {
+            type: "splitText";
+            by: "words" | "lines" | "chars";
+        })[] | undefined;
+        revertAfterComplete?: boolean | undefined;
+    }>;
+}

package/dist/animations/AnimationPresetsRegister.js

@@ -0,0 +1,20 @@
+import * as systemPresets from "./presets/index.js";
+export class AnimationPresetsRegister {
+    presets = new Map();
+    constructor() {
+        this.#registerSystemPresets();
+    }
+    #registerSystemPresets() {
+        Object.values(systemPresets).forEach((preset) => {
+            if (preset && typeof preset === 'object' && 'id' in preset) {
+                this.presets.set(preset.id, preset);
+            }
+        });
+    }
+    register(preset) {
+        this.presets.set(preset.id, preset);
+    }
+    getPresets() {
+        return this.presets;
+    }
+}

package/dist/animations/AnimationSetup.d.ts

@@ -0,0 +1,8 @@
+import type { AnimationContext } from './AnimationContext.ts';
+import type { AnimationEngineAdaptor } from './engines/AnimationEngineAdaptor.ts';
+export declare class AnimationSetup {
+    private animationContext;
+    private engineAdaptor;
+    constructor(animationContext: AnimationContext, engineAdaptor: AnimationEngineAdaptor);
+    process(): void;
+}

package/dist/animations/AnimationSetup.js

@@ -0,0 +1,30 @@
+export class AnimationSetup {
+    animationContext;
+    engineAdaptor;
+    constructor(animationContext, engineAdaptor) {
+        this.animationContext = animationContext;
+        this.engineAdaptor = engineAdaptor;
+    }
+    process() {
+        // TODO: Implement setup processing
+        const setup = this.animationContext.preset.preset.setup;
+        if (!setup)
+            return;
+        for (const step of setup) {
+            if (step.type === 'style') {
+                // if (this.animationContext.rootElement instanceof HTMLElement) {
+                // 	for (const property in step.properties) {
+                // 		this.animationContext.rootElement.style[property] = step.properties[property];
+                // 	}
+                // }
+            }
+            if (step.type === 'splitText' && ['words', 'lines', 'chars'].includes(step.by)) {
+                // prepare cache
+                // this.animationContext.splitTextCache.getSplitText(
+                // 	this.animationContext.rootElement,
+                // 	step.by
+                // );
+            }
+        }
+    }
+}

package/dist/animations/SplitTextCache.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Singleton cache for SplitText instances.
+ * This ensures we only split text once per element and split type,
+ * preventing multiple splits on the same element when accessed from different contexts.
+ */
+export declare class SplitTextCache {
+    private cache;
+    constructor();
+    /**
+     * Get or create a SplitText instance for an element and split type
+     * @param element The HTML element to split
+     * @param splitType The type of split ('words', 'lines', 'chars')
+     * @returns The SplitText result array for the requested split type
+     */
+    getSplitText(element: HTMLElement, splitType: 'words' | 'lines' | 'chars'): any;
+    /**
+     * Clear the entire cache or just entries for a specific element
+     * @param element Optional element to clear cache for just that element
+     */
+    clearCache(element?: HTMLElement): void;
+    /**
+     * Generate a unique ID for an element that doesn't have an ID
+     * Uses a WeakMap to store references to elements without modifying them
+     */
+    private elementMap;
+    private elementCounter;
+    private generateElementId;
+}

package/dist/animations/SplitTextCache.js

@@ -0,0 +1,68 @@
+import { SplitText } from 'gsap/SplitText';
+import gsap from 'gsap';
+/**
+ * Singleton cache for SplitText instances.
+ * This ensures we only split text once per element and split type,
+ * preventing multiple splits on the same element when accessed from different contexts.
+ */
+export class SplitTextCache {
+    cache = new Map();
+    constructor() {
+        gsap.registerPlugin(SplitText);
+    }
+    /**
+     * Get or create a SplitText instance for an element and split type
+     * @param element The HTML element to split
+     * @param splitType The type of split ('words', 'lines', 'chars')
+     * @returns The SplitText result array for the requested split type
+     */
+    getSplitText(element, splitType) {
+        // Generate a unique cache key based on element ID/reference and split type
+        const elementId = element.id || this.generateElementId(element);
+        const cacheKey = `${elementId}_${splitType}`;
+        // Check if we already have this split in the cache
+        if (!this.cache.has(cacheKey)) {
+            // Create and cache a new SplitText instance
+            const splitText = new SplitText(element, {
+                type: splitType,
+                reduceWhiteSpace: false,
+                preserveSpaces: true,
+                autoSplit: true,
+                aria: 'none'
+            });
+            this.cache.set(cacheKey, splitText);
+        }
+        // Return the cached split elements
+        return this.cache.get(cacheKey)[splitType];
+    }
+    /**
+     * Clear the entire cache or just entries for a specific element
+     * @param element Optional element to clear cache for just that element
+     */
+    clearCache(element) {
+        if (element) {
+            const elementId = element.id || this.generateElementId(element);
+            // Remove all entries starting with this element's ID
+            for (const key of this.cache.keys()) {
+                if (key.startsWith(`${elementId}_`)) {
+                    this.cache.delete(key);
+                }
+            }
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    /**
+     * Generate a unique ID for an element that doesn't have an ID
+     * Uses a WeakMap to store references to elements without modifying them
+     */
+    elementMap = new WeakMap();
+    elementCounter = 0;
+    generateElementId(element) {
+        if (!this.elementMap.has(element)) {
+            this.elementMap.set(element, `split-text-el-${this.elementCounter++}`);
+        }
+        return this.elementMap.get(element);
+    }
+}

package/dist/animations/animationBuilder.d.ts

@@ -0,0 +1,31 @@
+import type { AnimationContext } from './AnimationContext.js';
+import type { AnimationEngineAdaptor, EngineTimeline } from './engines/AnimationEngineAdaptor.js';
+export declare class AnimationBuilder {
+    private animationContext;
+    private engineAdaptor;
+    private mainTimeline;
+    private labels;
+    constructor(animationContext: AnimationContext, engineAdaptor: AnimationEngineAdaptor);
+    build(): EngineTimeline;
+    private processSetupSteps;
+    private ensureItemHasId;
+    private buildTimelineItems;
+    private isValidTargets;
+    private addSequenceItemToTimeline;
+    private addItemLabelIfNeeded;
+    private processTweens;
+    private resolveTargets;
+    private resolveTweenVars;
+    private isObject;
+    private resolveValue;
+    private isFromDataValue;
+    private isByIndexValue;
+    private resolveFromDataValue;
+    private createArrayAccessFunction;
+    private resolveByIndexValue;
+    private calculatePosition;
+    private resolveStringPosition;
+    private resolveObjectPosition;
+    private resolveAnchor;
+    private buildPositionString;
+}