@infinityfx/lively 4.0.11 → 5.0.0-alpha.0

package/dist/types/core/clip.d.ts

@@ -1,52 +1,49 @@
-import { Link } from "./link";
-import type Track from "./track";
+import { AnimationOptions } from "./animator";
+import AnimationLink from "./animation-link";
+export type BlendMode = 'none' | 'override' | 'combine';
 export type Easing = 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'step-start' | 'step-end' | (string & {});
-export type AnimatableKey = keyof React.CSSProperties | 'strokeLength';
-export type AnimatableKeyframe = string | number | null | {
-    value?: string | number;
-    after?: string | number;
-    offset?: number;
-};
-type AnimatableProperties = {
-    [key in AnimatableKey]?: Link<any> | ((progress: number, index: number) => any) | AnimatableKeyframe | AnimatableKeyframe[];
-};
-export type AnimatableInitials = React.CSSProperties & {
-    strokeLength?: number | string;
-};
-export type CompositeType = 'none' | 'override' | 'combine';
 export type ClipConfig = {
     duration?: number;
     delay?: number;
     repeat?: number;
     alternate?: boolean;
-    easing?: Easing;
     reverse?: boolean;
-    composite?: CompositeType;
+    easing?: Easing;
+    composite?: BlendMode;
 };
-export type ClipProperties = ClipConfig & AnimatableProperties;
-export type DynamicProperties = {
-    [key in AnimatableKey]?: (progress: number, index: number) => any;
+export type ClipKey = keyof React.CSSProperties | 'strokeLength';
+export type ClipKeyframe = null | string | number | {
+    to?: string | number;
+    after?: string | number;
+    offset?: number;
+};
+export type ClipKeyframes = {
+    [key in ClipKey]?: ClipKeyframe | ClipKeyframe[] | AnimationLink<any>;
+};
+export type ClipOptions = ClipConfig & ClipKeyframes;
+export type ClipInitials = React.CSSProperties & {
+    strokeLength?: number;
 };
 export default class Clip {
+    isEmpty: boolean;
     keyframes: Keyframe[];
-    initial: React.CSSProperties;
-    dynamic: DynamicProperties;
     duration: number;
     delay: number;
     repeat: number;
     alternate: boolean;
-    easing: string;
     reverse: boolean;
-    composite: CompositeType;
-    isEmpty: boolean;
-    constructor({ duration, delay, repeat, alternate, easing, reverse, composite, ...properties }: ClipProperties, initial?: AnimatableInitials);
-    static from(data?: ClipProperties | Clip, initial?: AnimatableInitials): Clip;
-    unique(config: ClipConfig): Clip;
-    play(track: Track, { composite, reverse, commit, delay }: {
-        composite?: CompositeType;
-        reverse?: boolean;
-        delay?: number;
-        commit?: boolean;
-    }): void;
+    easing: Easing;
+    composite: BlendMode;
+    constructor({ duration, delay, repeat, alternate, reverse, easing, composite, ...keyframes }: ClipOptions, initial?: ClipInitials);
+    getConfig({ delay, repeat, alternate, reverse, composite, commit }: AnimationOptions): {
+        duration: number;
+        delay: number;
+        iterations: number;
+        directions: "normal" | "alternate" | "alternate-reverse" | "reverse";
+        easing: Easing;
+        composite: "accumulate" | "replace";
+        blendmode: BlendMode;
+        commit: boolean;
+    };
+    static mergeInitialStyles(clips: Clip[], styles: ClipInitials): ClipInitials;
 }
-export {};

package/dist/types/core/state.d.ts

@@ -0,0 +1,16 @@
+import Animator from "./animator";
+export declare function getParentAnimator(id: string, stepsRemoved: number): Animator<any> | null;
+export declare function isRegistered(id: string): boolean;
+export declare function registerAnimator(id: string, animator: Animator<any>): void;
+export declare function unregisterAnimator(id: string): void;
+export declare function registerLayoutGroup(id: string, skipInitialMount: boolean): {
+    animators: Set<string>;
+    skipInitialMount: boolean;
+};
+export declare function unregisterLayoutGroup(id: string): void;
+export declare function registerToLayoutGroup(layoutId: string, id: string): boolean;
+export declare function unregisterFromLayoutGroup(layoutId: string, id: string): void;
+export declare function forEachAnimator(ids: Set<string>, callback: (animator: Animator<any>) => void): void;
+export declare function registerAsMorph(morphId: string, animator: Animator<any>): void;
+export declare function getMorphTarget(morphId: string, receiverId: string): Animator<any> | null;
+export declare function deleteMorphTarget(morphId: string, animator: Animator<any>, delay?: number): number;

package/dist/types/core/track.d.ts

@@ -1,32 +1,40 @@
-import type Action from "./action";
-import { CachableKey, StyleCache } from "./cache";
-import type { Easing } from "./clip";
-export type TransitionOptions = {
-    duration?: number;
-    easing?: Easing;
-    reverse?: boolean;
+import { TransitionOptions } from "./animation-link";
+import { AnimationOptions } from "./animator";
+import Clip, { BlendMode, ClipKey } from "./clip";
+import { ScaleTuple } from "./utils";
+export type CacheKey = Exclude<ClipKey, 'scale' | 'translate'> | 'x' | 'y' | 'sx' | 'sy';
+export type StyleCache = {
+    [key in Exclude<CacheKey, 'x' | 'y' | 'sx' | 'sy'>]?: string;
+} & {
+    x: number;
+    y: number;
+    sx: number;
+    sy: number;
+};
+export type TrackAnimation = Animation & {
+    name?: string;
+    blendmode: BlendMode;
 };
 export default class Track {
     element: HTMLElement | SVGElement;
-    deform: boolean;
-    playing: number;
-    active: Action[];
-    queue: Action[];
+    shouldCache: CacheKey[];
+    styles: CSSStyleDeclaration;
     cache: StyleCache;
-    paused: boolean;
-    scale: [number, number];
+    scale: ScaleTuple;
     corrected: {
         borderRadius: string;
         boxShadow: string;
     };
-    constructor(element: HTMLElement | SVGElement, deform: boolean, cachable?: CachableKey[]);
-    push(action: Action): void;
-    next(): void;
-    clear(partial?: boolean): void;
-    pause(value: boolean): void;
-    step(index: number): void;
-    transition(previous: Track | undefined, options: TransitionOptions): void;
-    apply(prop: string, val: any): void;
-    decomposeScale(): [number, number];
+    correctionAnimation: Animation | null;
+    queue: TrackAnimation[];
+    animations: TrackAnimation[];
+    active: number;
+    constructor(element: HTMLElement | SVGElement, shouldCache: CacheKey[]);
+    snapshot(): StyleCache;
+    push(clip: Clip, options?: AnimationOptions, onEnded?: () => void): number;
+    advance(): void;
+    transition(from?: StyleCache, options?: TransitionOptions): void;
+    clear(animation?: string): void;
+    toggle(paused: boolean): void;
     correct(): void;
 }