framer-motion 6.3.11 → 6.3.12

package/types/render/types.d.ts

@@ -1,113 +0,0 @@
-import * as React from "react";
-import { startAnimation } from "../animation/utils/transitions";
-import { MotionProps, MotionStyle } from "../motion/types";
-import { VisualState } from "../motion/utils/use-visual-state";
-import { TargetAndTransition, Transition, Variant } from "../types";
-import { MotionValue } from "../value";
-import { AnimationState } from "./utils/animation-state";
-import { LifecycleManager } from "./utils/lifecycles";
-import { Box, Point, TransformPoint } from "../projection/geometry/types";
-import { IProjectionNode } from "../projection/node/types";
-import { MotionConfigProps } from "../components/MotionConfig";
-export interface MotionPoint {
-    x: MotionValue<number>;
-    y: MotionValue<number>;
-}
-export interface VisualElement<Instance = any, RenderState = any> extends LifecycleManager {
-    treeType: string;
-    depth: number;
-    parent?: VisualElement;
-    children: Set<VisualElement>;
-    variantChildren?: Set<VisualElement>;
-    current: Instance | null;
-    manuallyAnimateOnMount: boolean;
-    blockInitialAnimation?: boolean;
-    presenceId: number | undefined;
-    isMounted(): boolean;
-    mount(instance: Instance): void;
-    unmount(): void;
-    isStatic?: boolean;
-    getInstance(): Instance | null;
-    sortNodePosition(element: VisualElement): number;
-    measureViewportBox(withTransform?: boolean): Box;
-    addVariantChild(child: VisualElement): undefined | (() => void);
-    getClosestVariantNode(): VisualElement | undefined;
-    shouldReduceMotion?: boolean | null;
-    animateMotionValue?: typeof startAnimation;
-    projection?: IProjectionNode;
-    /**
-     * Visibility
-     */
-    isVisible?: boolean;
-    setVisibility(visibility: boolean): void;
-    hasValue(key: string): boolean;
-    addValue(key: string, value: MotionValue<any>): void;
-    removeValue(key: string): void;
-    getValue(key: string): undefined | MotionValue;
-    getValue(key: string, defaultValue: string | number): MotionValue;
-    getValue(key: string, defaultValue?: string | number): undefined | MotionValue;
-    forEachValue(callback: (value: MotionValue, key: string) => void): void;
-    readValue(key: string): string | number | undefined | null;
-    setBaseTarget(key: string, value: string | number | null): void;
-    getBaseTarget(key: string): number | string | undefined | null;
-    getStaticValue(key: string): number | string | undefined;
-    setStaticValue(key: string, value: number | string): void;
-    getLatestValues(): ResolvedValues;
-    scheduleRender(): void;
-    makeTargetAnimatable(target: TargetAndTransition, isLive?: boolean): TargetAndTransition;
-    setProps(props: MotionProps): void;
-    getProps(): MotionProps;
-    getVariant(name: string): Variant | undefined;
-    getDefaultTransition(): Transition | undefined;
-    getVariantContext(startAtParent?: boolean): undefined | {
-        initial?: string | string[];
-        animate?: string | string[];
-        exit?: string | string[];
-        whileHover?: string | string[];
-        whileDrag?: string | string[];
-        whileFocus?: string | string[];
-        whileTap?: string | string[];
-    };
-    getTransformPagePoint: () => TransformPoint | undefined;
-    build(): RenderState;
-    syncRender(): void;
-    isPresenceRoot?: boolean;
-    isPresent?: boolean;
-    prevDragCursor?: Point;
-    getLayoutId(): string | undefined;
-    animationState?: AnimationState;
-}
-export interface VisualElementConfig<Instance, RenderState, Options> {
-    treeType?: string;
-    getBaseTarget?(props: MotionProps, key: string): string | number | undefined | MotionValue;
-    build(visualElement: VisualElement<Instance>, renderState: RenderState, latestValues: ResolvedValues, options: Options, props: MotionProps): void;
-    sortNodePosition?: (a: Instance, b: Instance) => number;
-    makeTargetAnimatable(element: VisualElement<Instance>, target: TargetAndTransition, props: MotionProps, isLive: boolean): TargetAndTransition;
-    measureViewportBox(instance: Instance, props: MotionProps & MotionConfigProps): Box;
-    readValueFromInstance(instance: Instance, key: string, options: Options): string | number | null | undefined;
-    resetTransform(element: VisualElement<Instance>, instance: Instance, props: MotionProps): void;
-    restoreTransform(instance: Instance, renderState: RenderState): void;
-    render(instance: Instance, renderState: RenderState, styleProp?: MotionStyle, projection?: IProjectionNode): void;
-    removeValueFromRenderState(key: string, renderState: RenderState): void;
-    scrapeMotionValuesFromProps: ScrapeMotionValuesFromProps;
-}
-export declare type ScrapeMotionValuesFromProps = (props: MotionProps) => {
-    [key: string]: MotionValue | string | number;
-};
-export declare type UseRenderState<RenderState = any> = () => RenderState;
-export declare type VisualElementOptions<Instance, RenderState = any> = {
-    visualState: VisualState<Instance, RenderState>;
-    parent?: VisualElement<unknown>;
-    variantParent?: VisualElement<unknown>;
-    presenceId?: number | undefined;
-    props: MotionProps;
-    blockInitialAnimation?: boolean;
-    shouldReduceMotion?: boolean | null;
-};
-export declare type CreateVisualElement<Instance> = (Component: string | React.ComponentType, options: VisualElementOptions<Instance>) => VisualElement<Instance>;
-/**
- * A generic set of string/number values
- */
-export interface ResolvedValues {
-    [key: string]: string | number;
-}

package/types/render/utils/animation-state.d.ts

@@ -1,31 +0,0 @@
-import { VariantLabels } from "../../motion/types";
-import { TargetAndTransition } from "../../types";
-import { VisualElement } from "../types";
-import { AnimationOptions } from "./animation";
-import { AnimationType } from "./types";
-export interface AnimationState {
-    animateChanges: (options?: AnimationOptions, type?: AnimationType) => Promise<any>;
-    setActive: (type: AnimationType, isActive: boolean, options?: AnimationOptions) => Promise<any>;
-    setAnimateFunction: (fn: any) => void;
-    isAnimated(key: string): boolean;
-    getState: () => {
-        [key: string]: AnimationTypeState;
-    };
-}
-export declare type AnimationList = string[] | TargetAndTransition[];
-export declare const variantPriorityOrder: AnimationType[];
-export declare function createAnimationState(visualElement: VisualElement): AnimationState;
-export declare function checkVariantsDidChange(prev: any, next: any): boolean;
-export interface AnimationTypeState {
-    isActive: boolean;
-    protectedKeys: {
-        [key: string]: true;
-    };
-    needsAnimating: {
-        [key: string]: boolean;
-    };
-    prevResolvedValues: {
-        [key: string]: any;
-    };
-    prevProp?: VariantLabels | TargetAndTransition;
-}

package/types/render/utils/animation.d.ts

@@ -1,21 +0,0 @@
-import { VariantLabels } from "../../motion/types";
-import { Target, TargetAndTransition, TargetResolver, TargetWithKeyframes, Transition } from "../../types";
-import { VisualElement } from "../types";
-import { AnimationType } from "./types";
-export declare type AnimationDefinition = VariantLabels | TargetAndTransition | TargetResolver;
-export declare type AnimationOptions = {
-    delay?: number;
-    transitionOverride?: Transition;
-    custom?: any;
-    type?: AnimationType;
-};
-export declare type MakeTargetAnimatable = (visualElement: VisualElement, target: TargetWithKeyframes, origin?: Target, transitionEnd?: Target) => {
-    target: TargetWithKeyframes;
-    transitionEnd?: Target;
-};
-/**
- * @internal
- */
-export declare function animateVisualElement(visualElement: VisualElement, definition: AnimationDefinition, options?: AnimationOptions): Promise<void>;
-export declare function stopAnimation(visualElement: VisualElement): void;
-export declare function sortByTreeOrder(a: VisualElement, b: VisualElement): number;

package/types/render/utils/compare-by-depth.d.ts

@@ -1,5 +0,0 @@
-import { VisualElement } from "../types";
-export interface WithDepth {
-    depth: number;
-}
-export declare const compareByDepth: (a: VisualElement, b: VisualElement) => number;

package/types/render/utils/flat-tree.d.ts

@@ -1,8 +0,0 @@
-import { WithDepth } from "./compare-by-depth";
-export declare class FlatTree {
-    private children;
-    private isDirty;
-    add(child: WithDepth): void;
-    remove(child: WithDepth): void;
-    forEach(callback: (child: WithDepth) => void): void;
-}

package/types/render/utils/is-draggable.d.ts

@@ -1,2 +0,0 @@
-import { VisualElement } from "../types";
-export declare function isDraggable(visualElement: VisualElement): boolean | undefined;

package/types/render/utils/lifecycles.d.ts

@@ -1,114 +0,0 @@
-import { MotionProps } from "../../motion/types";
-import { Axis, Box, Delta } from "../../projection/geometry/types";
-import { ResolvedValues } from "../types";
-import { AnimationDefinition } from "./animation";
-export declare type LayoutMeasureListener = (layout: Box, prevLayout?: Box) => void;
-export declare type BeforeLayoutMeasureListener = () => void;
-export declare type LayoutUpdateListener = (layout: Axis, prevLayout: Axis) => void;
-export declare type UpdateListener = (latest: ResolvedValues) => void;
-export declare type AnimationStartListener = (definition: AnimationDefinition) => void;
-export declare type AnimationCompleteListener = (definition: AnimationDefinition) => void;
-export declare type LayoutAnimationStartListener = () => void;
-export declare type LayoutAnimationCompleteListener = () => void;
-export declare type SetAxisTargetListener = () => void;
-export declare type RenderListener = () => void;
-export declare type OnViewportBoxUpdate = (box: Axis, delta: Delta) => void;
-export interface LayoutLifecycles {
-    onBeforeLayoutMeasure?(box: Box): void;
-    onLayoutMeasure?(box: Box, prevBox: Box): void;
-    /**
-     * @internal
-     */
-    onLayoutAnimationStart?(): void;
-    /**
-     * @internal
-     */
-    onLayoutAnimationComplete?(): void;
-}
-export interface AnimationLifecycles {
-    /**
-     * Callback with latest motion values, fired max once per frame.
-     *
-     * ```jsx
-     * function onUpdate(latest) {
-     *   console.log(latest.x, latest.opacity)
-     * }
-     *
-     * <motion.div animate={{ x: 100, opacity: 0 }} onUpdate={onUpdate} />
-     * ```
-     */
-    onUpdate?(latest: ResolvedValues): void;
-    /**
-     * Callback when animation defined in `animate` begins.
-     *
-     * The provided callback will be called with the triggering animation definition.
-     * If this is a variant, it'll be the variant name, and if a target object
-     * then it'll be the target object.
-     *
-     * This way, it's possible to figure out which animation has started.
-     *
-     * ```jsx
-     * function onStart() {
-     *   console.log("Animation started")
-     * }
-     *
-     * <motion.div animate={{ x: 100 }} onAnimationStart={onStart} />
-     * ```
-     */
-    onAnimationStart?(definition: AnimationDefinition): void;
-    /**
-     * Callback when animation defined in `animate` is complete.
-     *
-     * The provided callback will be called with the triggering animation definition.
-     * If this is a variant, it'll be the variant name, and if a target object
-     * then it'll be the target object.
-     *
-     * This way, it's possible to figure out which animation has completed.
-     *
-     * ```jsx
-     * function onComplete() {
-     *   console.log("Animation completed")
-     * }
-     *
-     * <motion.div
-     *   animate={{ x: 100 }}
-     *   onAnimationComplete={definition => {
-     *     console.log('Completed animating', definition)
-     *   }}
-     * />
-     * ```
-     */
-    onAnimationComplete?(definition: AnimationDefinition): void;
-    /**
-     * @internal
-     */
-    onUnmount?(): void;
-}
-export declare type VisualElementLifecycles = LayoutLifecycles & AnimationLifecycles;
-export interface LifecycleManager {
-    onLayoutMeasure: (callback: LayoutMeasureListener) => () => void;
-    notifyLayoutMeasure: LayoutMeasureListener;
-    onBeforeLayoutMeasure: (callback: BeforeLayoutMeasureListener) => () => void;
-    notifyBeforeLayoutMeasure: BeforeLayoutMeasureListener;
-    onLayoutUpdate: (callback: LayoutUpdateListener) => () => void;
-    notifyLayoutUpdate: LayoutUpdateListener;
-    onUpdate: (callback: UpdateListener) => () => void;
-    notifyUpdate: UpdateListener;
-    onAnimationStart: (callback: AnimationStartListener) => () => void;
-    notifyAnimationStart: AnimationStartListener;
-    onAnimationComplete: (callback: AnimationCompleteListener) => () => void;
-    notifyAnimationComplete: AnimationCompleteListener;
-    onLayoutAnimationStart: (callback: LayoutAnimationStartListener) => () => void;
-    notifyLayoutAnimationStart: LayoutAnimationStartListener;
-    onLayoutAnimationComplete: (callback: LayoutAnimationCompleteListener) => () => void;
-    notifyLayoutAnimationComplete: LayoutAnimationCompleteListener;
-    onSetAxisTarget: (callback: SetAxisTargetListener) => () => void;
-    notifySetAxisTarget: SetAxisTargetListener;
-    onRender: (callback: RenderListener) => () => void;
-    notifyRender: RenderListener;
-    onUnmount: (callback: () => void) => () => void;
-    notifyUnmount: () => void;
-    clearAllListeners: () => void;
-    updatePropListeners: (props: MotionProps) => void;
-}
-export declare function createLifecycles(): LifecycleManager;

package/types/render/utils/motion-values.d.ts

@@ -1,3 +0,0 @@
-import { MotionStyle } from "../../motion/types";
-import { VisualElement } from "../types";
-export declare function updateMotionValuesFromProps(element: VisualElement, next: MotionStyle, prev: MotionStyle): MotionStyle;