@rendley/sdk 1.14.4 → 1.15.0

package/dist/modules/animation/PropertyAnimator.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { BezierHandle, PropertyKeyframe, PropertyAnimatorSchema, PropertyLink, PropertyRegistration, PropertyTrack, PropertyValue, TrackDefaults } from "./PropertyAnimator.types";
+export declare class PropertyAnimator {
+    private clipId?;
+    private tracks;
+    private properties;
+    /** compound key → PropertyLink */
+    private links;
+    /** component key → compound key (reverse lookup) */
+    private componentToCompound;
+    setClipId(clipId: string): void;
+    getClipId(): string | undefined;
+    private recordUndo;
+    /** Tolerance for matching keyframes: half a frame minus epsilon */
+    private get tolerance();
+    /** Round a time value to the nearest frame boundary */
+    private alignTime;
+    registerProperty(registration: PropertyRegistration): void;
+    unregisterProperty(key: string): void;
+    getRegisteredProperties(): ReadonlyMap<string, PropertyRegistration>;
+    /**
+     * Register a link between a compound vector property and its scalar components.
+     * E.g. linkProperties({ compound: "scale", components: ["scaleX", "scaleY"] })
+     */
+    linkProperties(link: PropertyLink): void;
+    /**
+     * Split a compound track into component tracks.
+     * Decomposes each vector keyframe into individual scalar keyframes, preserving handles and hold.
+     * Removes the compound track.
+     */
+    splitTrack(compound: string): void;
+    /**
+     * Merge component tracks back into a compound vector track.
+     * By default, requires all components to have keyframes at identical times (lossless merge).
+     * With force=true, evaluates missing component values and inherits handles from neighbors (lossy).
+     * Removes component tracks.
+     */
+    mergeTrack(compound: string, force?: boolean): void;
+    /**
+     * Check if component tracks can be losslessly merged back into the compound.
+     * Returns true if all components with keyframes have them at exactly the same times.
+     */
+    canMergeTrack(compound: string): boolean;
+    /** Returns true if the compound property is currently split into components */
+    isSplit(compound: string): boolean;
+    /** Get the link for a property (either compound or component key) */
+    getLink(property: string): PropertyLink | undefined;
+    /**
+     * Check if adding a keyframe to this property would conflict with an active linked track.
+     * Throws if there's a conflict (user must explicitly split/merge first).
+     */
+    private validateLinkConflict;
+    addTrack(property: string, defaults?: TrackDefaults): PropertyTrack;
+    removeTrack(property: string): void;
+    hasTrack(property: string): boolean;
+    getTrack(property: string): PropertyTrack | undefined;
+    getTracks(): ReadonlyMap<string, PropertyTrack>;
+    addKeyframe(property: string, time: number, value: PropertyValue, handleIn?: BezierHandle, handleOut?: BezierHandle, hold?: boolean): PropertyKeyframe;
+    removeKeyframe(property: string, keyframe: PropertyKeyframe): void;
+    removeKeyframeAtTime(property: string, time: number): void;
+    updateKeyframe(property: string, time: number, patch: Partial<Omit<PropertyKeyframe, "time">>): void;
+    moveKeyframe(property: string, oldTime: number, newTime: number, clamped?: boolean): void;
+    getKeyframesAtTime(time: number): Map<string, PropertyKeyframe>;
+    getKeyframeAtTime(property: string, time: number): PropertyKeyframe | undefined;
+    removeKeyframesAtTime(time: number): void;
+    clear(property?: string): void;
+    duplicateKeyframe(property: string, sourceTime: number, targetTime: number): PropertyKeyframe | undefined;
+    hasKeyframeAtTime(property: string, time: number): boolean;
+    getNextKeyframe(property: string, time: number): PropertyKeyframe | undefined;
+    getPrevKeyframe(property: string, time: number): PropertyKeyframe | undefined;
+    getAllKeyframeTimes(): Set<number>;
+    getKeyframesBetween(property: string, startTime: number, endTime: number): PropertyKeyframe[];
+    getAnimatedProperties(): Set<string>;
+    evaluate(time: number): Map<string, PropertyValue>;
+    evaluateProperty(property: string, time: number): PropertyValue | undefined;
+    /** Apply evaluated values to registered properties at the given time */
+    apply(time: number): void;
+    private evaluateTrack;
+    /**
+     * Record the current value of a registered property as a keyframe.
+     * Reads the value from the property's registered getter.
+     * If a keyframe already exists at that time, only the value is updated (handles are preserved).
+     * If no keyframe exists, a new one is inserted with default handles.
+     * If no track exists, one is created automatically.
+     */
+    recordProperty(property: string, currentTime: number): void;
+    serialize(): z.infer<typeof PropertyAnimatorSchema>;
+    deserialize(data: z.infer<typeof PropertyAnimatorSchema>): void;
+    private emitKeyframeChanged;
+    /** Find the single closest keyframe within tolerance using binary search. Returns index or -1. */
+    private findClosestKeyframeIndex;
+    private findInsertIndex;
+}

package/dist/modules/animation/PropertyAnimator.types.d.ts

@@ -0,0 +1,516 @@
+import { z } from "zod";
+import { PropertyDescriptionTypeEnum } from "../library/types/Property.types";
+/** Bezier control point in normalized [0-1] space */
+export interface BezierHandle {
+    time: number;
+    value: number;
+}
+export declare const DEFAULT_HANDLE_IN: BezierHandle;
+export declare const DEFAULT_HANDLE_OUT: BezierHandle;
+export type PropertyValue = number | number[] | string | boolean;
+export interface PropertyKeyframe {
+    time: number;
+    value: PropertyValue;
+    /** Incoming bezier handle (controls curve arriving at this keyframe) */
+    handleIn: BezierHandle;
+    /** Outgoing bezier handle (controls curve leaving this keyframe) */
+    handleOut: BezierHandle;
+    /** If true, holds this value until the next keyframe (no interpolation) */
+    hold?: boolean;
+}
+export interface TrackDefaults {
+    handleIn?: BezierHandle;
+    handleOut?: BezierHandle;
+    hold?: boolean;
+}
+export interface PropertyTrack {
+    property: string;
+    type: PropertyDescriptionTypeEnum;
+    keyframes: PropertyKeyframe[];
+    defaults?: TrackDefaults;
+    customData?: Map<string, unknown>;
+}
+export interface PropertyRegistration {
+    key: string;
+    type: PropertyDescriptionTypeEnum;
+    get: () => PropertyValue;
+    set: (value: PropertyValue) => void;
+}
+/** Links a vector property to its scalar components */
+export interface PropertyLink {
+    /** The compound property key, e.g. "scale" */
+    compound: string;
+    /** The component property keys in order, e.g. ["scaleX", "scaleY"] */
+    components: string[];
+}
+export declare function isContinuousType(type: PropertyDescriptionTypeEnum): boolean;
+export declare const BezierHandleSchema: z.ZodObject<{
+    time: z.ZodNumber;
+    value: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    time: number;
+}, {
+    value: number;
+    time: number;
+}>;
+export declare const PropertyKeyframeSchema: z.ZodObject<{
+    time: z.ZodNumber;
+    value: z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">, z.ZodString, z.ZodBoolean]>;
+    handleIn: z.ZodObject<{
+        time: z.ZodNumber;
+        value: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        time: number;
+    }, {
+        value: number;
+        time: number;
+    }>;
+    handleOut: z.ZodObject<{
+        time: z.ZodNumber;
+        value: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        time: number;
+    }, {
+        value: number;
+        time: number;
+    }>;
+    hold: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+    time: number;
+    handleIn: {
+        value: number;
+        time: number;
+    };
+    handleOut: {
+        value: number;
+        time: number;
+    };
+    hold?: boolean | undefined;
+}, {
+    value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+    time: number;
+    handleIn: {
+        value: number;
+        time: number;
+    };
+    handleOut: {
+        value: number;
+        time: number;
+    };
+    hold?: boolean | undefined;
+}>;
+export declare const TrackDefaultsSchema: z.ZodObject<{
+    handleIn: z.ZodOptional<z.ZodObject<{
+        time: z.ZodNumber;
+        value: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        time: number;
+    }, {
+        value: number;
+        time: number;
+    }>>;
+    handleOut: z.ZodOptional<z.ZodObject<{
+        time: z.ZodNumber;
+        value: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        time: number;
+    }, {
+        value: number;
+        time: number;
+    }>>;
+    hold: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    handleIn?: {
+        value: number;
+        time: number;
+    } | undefined;
+    handleOut?: {
+        value: number;
+        time: number;
+    } | undefined;
+    hold?: boolean | undefined;
+}, {
+    handleIn?: {
+        value: number;
+        time: number;
+    } | undefined;
+    handleOut?: {
+        value: number;
+        time: number;
+    } | undefined;
+    hold?: boolean | undefined;
+}>;
+export declare const PropertyTrackSchema: z.ZodObject<{
+    property: z.ZodString;
+    type: z.ZodNativeEnum<typeof PropertyDescriptionTypeEnum>;
+    keyframes: z.ZodArray<z.ZodObject<{
+        time: z.ZodNumber;
+        value: z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">, z.ZodString, z.ZodBoolean]>;
+        handleIn: z.ZodObject<{
+            time: z.ZodNumber;
+            value: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            time: number;
+        }, {
+            value: number;
+            time: number;
+        }>;
+        handleOut: z.ZodObject<{
+            time: z.ZodNumber;
+            value: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            time: number;
+        }, {
+            value: number;
+            time: number;
+        }>;
+        hold: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+        time: number;
+        handleIn: {
+            value: number;
+            time: number;
+        };
+        handleOut: {
+            value: number;
+            time: number;
+        };
+        hold?: boolean | undefined;
+    }, {
+        value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+        time: number;
+        handleIn: {
+            value: number;
+            time: number;
+        };
+        handleOut: {
+            value: number;
+            time: number;
+        };
+        hold?: boolean | undefined;
+    }>, "many">;
+    defaults: z.ZodOptional<z.ZodObject<{
+        handleIn: z.ZodOptional<z.ZodObject<{
+            time: z.ZodNumber;
+            value: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            time: number;
+        }, {
+            value: number;
+            time: number;
+        }>>;
+        handleOut: z.ZodOptional<z.ZodObject<{
+            time: z.ZodNumber;
+            value: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            time: number;
+        }, {
+            value: number;
+            time: number;
+        }>>;
+        hold: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        handleIn?: {
+            value: number;
+            time: number;
+        } | undefined;
+        handleOut?: {
+            value: number;
+            time: number;
+        } | undefined;
+        hold?: boolean | undefined;
+    }, {
+        handleIn?: {
+            value: number;
+            time: number;
+        } | undefined;
+        handleOut?: {
+            value: number;
+            time: number;
+        } | undefined;
+        hold?: boolean | undefined;
+    }>>;
+    customData: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodUnknown], null>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: PropertyDescriptionTypeEnum;
+    property: string;
+    keyframes: {
+        value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+        time: number;
+        handleIn: {
+            value: number;
+            time: number;
+        };
+        handleOut: {
+            value: number;
+            time: number;
+        };
+        hold?: boolean | undefined;
+    }[];
+    defaults?: {
+        handleIn?: {
+            value: number;
+            time: number;
+        } | undefined;
+        handleOut?: {
+            value: number;
+            time: number;
+        } | undefined;
+        hold?: boolean | undefined;
+    } | undefined;
+    customData?: [string, unknown][] | undefined;
+}, {
+    type: PropertyDescriptionTypeEnum;
+    property: string;
+    keyframes: {
+        value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+        time: number;
+        handleIn: {
+            value: number;
+            time: number;
+        };
+        handleOut: {
+            value: number;
+            time: number;
+        };
+        hold?: boolean | undefined;
+    }[];
+    defaults?: {
+        handleIn?: {
+            value: number;
+            time: number;
+        } | undefined;
+        handleOut?: {
+            value: number;
+            time: number;
+        } | undefined;
+        hold?: boolean | undefined;
+    } | undefined;
+    customData?: [string, unknown][] | undefined;
+}>;
+export declare const PropertyAnimatorSchema: z.ZodObject<{
+    tracks: z.ZodArray<z.ZodObject<{
+        property: z.ZodString;
+        type: z.ZodNativeEnum<typeof PropertyDescriptionTypeEnum>;
+        keyframes: z.ZodArray<z.ZodObject<{
+            time: z.ZodNumber;
+            value: z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">, z.ZodString, z.ZodBoolean]>;
+            handleIn: z.ZodObject<{
+                time: z.ZodNumber;
+                value: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                value: number;
+                time: number;
+            }, {
+                value: number;
+                time: number;
+            }>;
+            handleOut: z.ZodObject<{
+                time: z.ZodNumber;
+                value: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                value: number;
+                time: number;
+            }, {
+                value: number;
+                time: number;
+            }>;
+            hold: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+            time: number;
+            handleIn: {
+                value: number;
+                time: number;
+            };
+            handleOut: {
+                value: number;
+                time: number;
+            };
+            hold?: boolean | undefined;
+        }, {
+            value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+            time: number;
+            handleIn: {
+                value: number;
+                time: number;
+            };
+            handleOut: {
+                value: number;
+                time: number;
+            };
+            hold?: boolean | undefined;
+        }>, "many">;
+        defaults: z.ZodOptional<z.ZodObject<{
+            handleIn: z.ZodOptional<z.ZodObject<{
+                time: z.ZodNumber;
+                value: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                value: number;
+                time: number;
+            }, {
+                value: number;
+                time: number;
+            }>>;
+            handleOut: z.ZodOptional<z.ZodObject<{
+                time: z.ZodNumber;
+                value: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                value: number;
+                time: number;
+            }, {
+                value: number;
+                time: number;
+            }>>;
+            hold: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            handleIn?: {
+                value: number;
+                time: number;
+            } | undefined;
+            handleOut?: {
+                value: number;
+                time: number;
+            } | undefined;
+            hold?: boolean | undefined;
+        }, {
+            handleIn?: {
+                value: number;
+                time: number;
+            } | undefined;
+            handleOut?: {
+                value: number;
+                time: number;
+            } | undefined;
+            hold?: boolean | undefined;
+        }>>;
+        customData: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodUnknown], null>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: PropertyDescriptionTypeEnum;
+        property: string;
+        keyframes: {
+            value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+            time: number;
+            handleIn: {
+                value: number;
+                time: number;
+            };
+            handleOut: {
+                value: number;
+                time: number;
+            };
+            hold?: boolean | undefined;
+        }[];
+        defaults?: {
+            handleIn?: {
+                value: number;
+                time: number;
+            } | undefined;
+            handleOut?: {
+                value: number;
+                time: number;
+            } | undefined;
+            hold?: boolean | undefined;
+        } | undefined;
+        customData?: [string, unknown][] | undefined;
+    }, {
+        type: PropertyDescriptionTypeEnum;
+        property: string;
+        keyframes: {
+            value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+            time: number;
+            handleIn: {
+                value: number;
+                time: number;
+            };
+            handleOut: {
+                value: number;
+                time: number;
+            };
+            hold?: boolean | undefined;
+        }[];
+        defaults?: {
+            handleIn?: {
+                value: number;
+                time: number;
+            } | undefined;
+            handleOut?: {
+                value: number;
+                time: number;
+            } | undefined;
+            hold?: boolean | undefined;
+        } | undefined;
+        customData?: [string, unknown][] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tracks: {
+        type: PropertyDescriptionTypeEnum;
+        property: string;
+        keyframes: {
+            value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+            time: number;
+            handleIn: {
+                value: number;
+                time: number;
+            };
+            handleOut: {
+                value: number;
+                time: number;
+            };
+            hold?: boolean | undefined;
+        }[];
+        defaults?: {
+            handleIn?: {
+                value: number;
+                time: number;
+            } | undefined;
+            handleOut?: {
+                value: number;
+                time: number;
+            } | undefined;
+            hold?: boolean | undefined;
+        } | undefined;
+        customData?: [string, unknown][] | undefined;
+    }[];
+}, {
+    tracks: {
+        type: PropertyDescriptionTypeEnum;
+        property: string;
+        keyframes: {
+            value: (string | number | boolean | number[]) & (string | number | boolean | number[] | undefined);
+            time: number;
+            handleIn: {
+                value: number;
+                time: number;
+            };
+            handleOut: {
+                value: number;
+                time: number;
+            };
+            hold?: boolean | undefined;
+        }[];
+        defaults?: {
+            handleIn?: {
+                value: number;
+                time: number;
+            } | undefined;
+            handleOut?: {
+                value: number;
+                time: number;
+            } | undefined;
+            hold?: boolean | undefined;
+        } | undefined;
+        customData?: [string, unknown][] | undefined;
+    }[];
+}>;

package/dist/modules/animation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./PropertyAnimator";
+export * from "./PropertyAnimator.types";