animatry/dist/index.d.ts

Javascript animation library.

type CoreElement = HTMLElement | HTMLElement[] | NodeList | Document | Array<HTMLElement> | string;
type controllerId = string | number;
type ease = Function;
interface ControllerCallbacks {
    onUpdate?: Function;
    onChange?: Function;
    onStart?: Function;
    onComplete?: Function;
    onReverseStart?: Function;
    onReverseComplete?: Function;
    onRepeat?: Function;
}
interface ControllerSettings {
    id?: controllerId;
    delay?: number;
    delayRecharge?: boolean;
    duration?: number;
    repeat?: number;
    iterationDelay?: number;
    alternate?: boolean;
    paused?: boolean;
    ease?: ease;
    alternateEase?: ease;
    playhead?: number;
    iteration?: number;
    reversed?: boolean;
    timeScale?: number;
    at?: number;
    preRender?: boolean;
    stagger?: StaggerOptions | number;
    keyframes?: KeyframeOptions | number;
    backwards?: boolean;
    [key: string]: any;
}
interface ControllerOptions extends ControllerSettings, ControllerCallbacks {
}
interface StaggerOptions extends ControllerCallbacks {
    layout?: [number, number] | 'grid' | 'distance';
    from?: [number, number] | number | 'start' | 'end' | 'left' | 'right' | 'center' | 'top left' | 'top right' | 'bottom left' | 'bottom right' | 'left top' | 'right top' | 'left bottom' | 'right bottom' | 'random';
    invert?: boolean;
    axis?: 'x' | 'y' | 'xy';
    duration?: number;
    each?: number;
    repeat?: number;
    iterationDelay?: number;
    alternate?: boolean;
    ease?: ease;
    alternateEase?: ease;
}
type KeyframeOptions = any;

declare class Controller {
    options: ControllerOptions;
    private delayProgress;
    private iterationDelayProgress;
    private isPaused;
    private isReversed;
    private playhead;
    private frame;
    private tick;
    private initialized;
    private parent;
    constructor(options: ControllerOptions);
    _render(): void;
    play(seek?: number | undefined): void;
    pause(): void;
    reverse(): void;
    continue(): void;
    restart(): void;
    reset(): void;
    seek(elapsed: number): void;
    complete(): void;
    lastPlay(): void;
    getInitialized(): boolean;
    setInitialized(): void;
    getParent(): Controller | undefined;
    setParent(parent: Controller): void;
    getId(): controllerId;
    setId(id: controllerId): void;
    getDuration(): number;
    setDuration(duration: number, keepProgress?: boolean): this;
    getProgress(): number;
    setProgress(progress: number): this;
    getElapsed(): number;
    setElapsed(elapsed: number): this;
    getTotalProgress(): number;
    setTotalProgress(totalProgress: number, events?: boolean): void;
    getTotalElapsed(): number;
    setTotalElapsed(totalElapsed: number): void;
    getDelay(): number;
    setDelay(delay: number, restartDelay?: boolean | undefined): this;
    getDelayProgress(): number;
    setDelayProgress(delayProgress: number): this;
    getDelayElapsed(): number;
    setDelayElapsed(delayElapsed: number): this;
    getReversed(): boolean;
    setReversed(reversed: boolean): void;
    getRepeat(): number;
    setRepeat(repeat: number, keepIterations?: boolean): this;
    getAlternate(): boolean;
    setAlternate(alternate: boolean, smoothJump?: boolean): this;
    getIteration(): number;
    setIteration(iteration: number, smoothJump?: boolean): this;
    getIterationDelay(): number;
    setIterationDelay(iterationDelay: number): this;
    getIterationDelayProgress(): number;
    setIterationDelayProgress(iterationDelayProgress: number): this;
    getTimeScale(): number;
    setTimeScale(timeScale: number): void;
    getTotalDuration(): number;
    getEasedProgress(): number;
    getEasedElapsed(): number;
    isAlternating(): boolean;
    isPlaying(): boolean;
    onChange(callback: Function): void;
    onUpdate(callback: Function): void;
    onStart(callback: Function): void;
    onRepeat(callback: Function): void;
    onComplete(callback: Function): void;
    onReverseStart(callback: Function): void;
    onReverseComplete(callback: Function): void;
    static getProgress(instance: Controller, ph: number): number;
    static getEasedProgress(instance: Controller, ph: number): number;
    static getIteration(instance: Controller, ph: number): number;
    static isAlternating(instance: Controller, ph: number): boolean;
}

declare class Timeline extends Controller {
    private controller;
    private attacheds;
    private labels;
    constructor(options?: ControllerOptions);
    getController(): ControllerOptions;
    setTotalProgress(totalProgress: number, events?: boolean): void;
    _updateDuration(crop?: boolean): void;
    label(name: string, time?: number | undefined): this;
    add(object: Controller, time?: string | number | undefined): this;
    play(seek?: number | undefined): void;
    reverse(): void;
    seek(elapsed: number): void;
    fromTo(el: CoreElement, from: ControllerOptions, to: ControllerOptions, time?: string | number | undefined): Timeline;
    to(el: CoreElement, to: ControllerOptions, time?: string | number | undefined): Timeline;
    from(el: CoreElement, from: ControllerOptions, time?: string | number | undefined): Timeline;
    set(el: CoreElement, options: ControllerOptions, time?: string | number | undefined): this;
}

declare class Tween extends Controller {
    elements: HTMLElement[];
    from: ControllerOptions;
    to: ControllerOptions;
    private timeline;
    private properties;
    private fragment;
    constructor(elements: CoreElement, from: ControllerOptions, to: ControllerOptions);
    render(): void;
    setTotalProgress(totalProgress: number, events?: boolean): void;
    play(): void;
    reverse(): void;
}

declare class Animatry {
    version(): void;
    options(options: ControllerOptions): void;
    fromTo(elements: CoreElement, from?: ControllerOptions, to?: ControllerOptions): Tween;
    to(elements: CoreElement, to?: ControllerOptions): Tween;
    from(elements: CoreElement, from?: ControllerOptions): Tween;
    timeline(options?: ControllerOptions): Timeline;
    set(elements: CoreElement, to?: ControllerOptions): Tween;
    use(plugin: any): void;
    pipeline: (...funcs: Function[]) => (...args: Function[]) => Function[];
    filterObjects: <T extends Record<string, any>>(object: T, filter: Partial<T>) => [Partial<T>, Partial<T>];
    random: (...args: any) => () => any;
    shuffle: (array: Array<any>) => any[];
    clamp: (number: number, min?: number, max?: number) => number;
    round: (value: number, decimalPlaces?: number) => number;
    lerp: (start: number, end: number, progress: number) => number;
    isEven: (n: number) => number;
    isOdd: (n: number) => boolean;
    pageReady: (callback: Function) => void;
    select: (input: CoreElement) => Array<HTMLElement>;
    selectCss: (property: string, value: string, parent: HTMLElement | NodeList, negate?: boolean) => Element[];
    getParent: (el: HTMLElement) => HTMLElement;
    camelToKebab: (s: string) => string;
    _p: string;
    log(m: string): void;
    warn(m: string): void;
}
declare const animatry: Animatry;

declare function splitText(elements: any, options: string): {
    lines: HTMLElement[];
    words: HTMLElement[];
    chars: HTMLElement[];
};

export { animatry, splitText };