tempus/dist/tempus.d.ts

one rAF to rule them all

declare class Clock {
    private _elapsed;
    private _currentTime;
    private _startTime;
    private _lastTime;
    private _isPlaying;
    private _deltaTime;
    play(): void;
    pause(): void;
    reset(): void;
    update(browserTime: number): void;
    get time(): number;
    get isPlaying(): boolean;
    get deltaTime(): number;
}

type TempusState = {
    time: number;
    deltaTime: number;
    frame: number;
    budget: () => number;
};
type TempusCallback = (state: TempusState) => void;
type TempusOptions = {
    order?: number;
    /** @deprecated Use `order` instead. Kept as an alias for backwards compat. */
    priority?: number;
    fps?: number | string;
    label?: string;
};
type UID = number;
type TempusCallbackInfo = {
    label: string;
    samples: number[];
    order: number;
    fps: number | string;
    source: 'add' | 'patch';
};

declare class Framerate {
    callbacks: {
        callback: TempusCallback;
        order: number;
        uid: UID;
        label: string;
        samples: number[];
    }[];
    fps: number | string;
    time: number;
    lastTickDate: number;
    framesCount: number;
    constructor(fps?: number | string);
    get isRelativeFps(): boolean;
    get maxFramesCount(): number;
    get executionTime(): number;
    dispatch(state: TempusState): void;
    raf(state: TempusState): void;
    add({ callback, order, label, }: {
        callback: TempusCallback;
        order: number;
        label: string;
    }): (() => void) | undefined;
    remove(uid: UID): void;
}
declare class TempusImpl {
    framerates: Record<number | string, Framerate>;
    clock: Clock;
    fps?: number;
    usage: number;
    private rafId;
    frameCount: number;
    targetFps: number;
    private frameStartTime;
    get frameBudget(): number;
    private state;
    private patched;
    private rafQueue;
    private rafHandleId;
    private patchedRAF?;
    private patchedCancelRAF?;
    private flushUnsubscribe?;
    private patchMeta;
    private patchEntries;
    private patchAnonCount;
    constructor();
    restart(): void;
    play(): void;
    pause(): void;
    get isPlaying(): boolean;
    add(callback: TempusCallback, { order, priority, fps, label, }?: TempusOptions): (() => void) | undefined;
    private raf;
    patch(): void;
    unpatch(): void;
    private prunePatchEntries;
    inspect(): TempusCallbackInfo[];
}
declare const Tempus: TempusImpl;

export { type TempusCallback, type TempusCallbackInfo, type TempusOptions, type TempusState, type UID, Tempus as default };