framer-motion 6.3.10 → 6.3.13

package/types/projection/node/HTMLProjectionNode.d.ts

@@ -1,112 +0,0 @@
-import { IProjectionNode } from "./types";
-export declare const rootProjectionNode: {
-    current: IProjectionNode | undefined;
-};
-export declare const HTMLProjectionNode: {
-    new (id: number | undefined, latestValues?: import("../..").ResolvedValues, parent?: IProjectionNode<unknown> | undefined): {
-        id: number | undefined;
-        instance: HTMLElement;
-        root: IProjectionNode<unknown>;
-        parent?: IProjectionNode<unknown> | undefined;
-        path: IProjectionNode<unknown>[];
-        children: Set<IProjectionNode<unknown>>;
-        options: import("./types").ProjectionNodeOptions;
-        snapshot: import("./types").Snapshot | undefined;
-        layout: import("./types").Layout | undefined;
-        targetLayout?: import("../..").Box | undefined;
-        layoutCorrected: import("../..").Box;
-        targetDelta?: import("../..").Delta | undefined;
-        target?: import("../..").Box | undefined;
-        relativeTarget?: import("../..").Box | undefined;
-        relativeTargetOrigin?: import("../..").Box | undefined;
-        relativeParent?: IProjectionNode<unknown> | undefined;
-        isTreeAnimating: boolean;
-        isAnimationBlocked: boolean;
-        attemptToResolveRelativeTarget?: boolean | undefined;
-        targetWithTransforms?: import("../..").Box | undefined;
-        projectionDelta?: import("../..").Delta | undefined;
-        projectionDeltaWithTransform?: import("../..").Delta | undefined;
-        scroll?: import("../..").Point | undefined;
-        isLayoutDirty: boolean;
-        updateManuallyBlocked: boolean;
-        updateBlockedByResize: boolean;
-        isUpdating: boolean;
-        isSVG: boolean;
-        needsReset: boolean;
-        shouldResetTransform: boolean;
-        treeScale: import("../..").Point;
-        resumeFrom?: IProjectionNode<unknown> | undefined;
-        resumingFrom?: IProjectionNode<unknown> | undefined;
-        latestValues: import("../..").ResolvedValues;
-        eventHandlers: Map<import("./types").LayoutEvents, import("../../utils/subscription-manager").SubscriptionManager<any>>;
-        nodes?: import("../..").FlatTree | undefined;
-        depth: number;
-        projectionTransform: string;
-        prevTransformTemplateValue: string | undefined;
-        preserveOpacity?: boolean | undefined;
-        addEventListener(name: import("./types").LayoutEvents, handler: any): () => void;
-        notifyListeners(name: import("./types").LayoutEvents, ...args: any): void;
-        hasListeners(name: import("./types").LayoutEvents): boolean;
-        potentialNodes: Map<number, IProjectionNode<unknown>>;
-        registerPotentialNode(id: number, node: IProjectionNode<unknown>): void;
-        mount(instance: HTMLElement, isLayoutDirty?: boolean): void;
-        unmount(): void;
-        blockUpdate(): void;
-        unblockUpdate(): void;
-        isUpdateBlocked(): boolean;
-        isTreeAnimationBlocked(): boolean;
-        startUpdate(): void;
-        willUpdate(shouldNotifyListeners?: boolean): void;
-        didUpdate(): void;
-        clearAllSnapshots(): void;
-        scheduleUpdateProjection(): void;
-        scheduleCheckAfterUnmount(): void;
-        checkUpdateFailed: () => void;
-        updateProjection: () => void;
-        updateSnapshot(): void;
-        updateLayout(): void;
-        updateScroll(): void;
-        resetTransform(): void;
-        measure(): import("../..").Box;
-        removeElementScroll(box: import("../..").Box): import("../..").Box;
-        applyTransform(box: import("../..").Box, transformOnly?: boolean): import("../..").Box;
-        removeTransform(box: import("../..").Box): import("../..").Box;
-        setTargetDelta(delta: import("../..").Delta): void;
-        setOptions(options: import("./types").ProjectionNodeOptions): void;
-        clearMeasurements(): void;
-        resolveTargetDelta(): void;
-        getClosestProjectingParent(): IProjectionNode<unknown> | undefined;
-        hasProjected: boolean;
-        calcProjection(): void;
-        isVisible: boolean;
-        hide(): void;
-        show(): void;
-        scheduleRender(notifyAll?: boolean): void;
-        animationValues?: import("../..").ResolvedValues | undefined;
-        pendingAnimation?: import("framesync").Process | undefined;
-        currentAnimation?: import("../..").AnimationPlaybackControls | undefined;
-        mixTargetDelta: (progress: number) => void;
-        animationProgress: number;
-        setAnimationOrigin(delta: import("../..").Delta, hasOnlyRelativeTargetChanged?: boolean): void;
-        startAnimation(options: import("../..").AnimationOptions<number>): void;
-        completeAnimation(): void;
-        finishAnimation(): void;
-        applyTransformsToTarget(): void;
-        sharedNodes: Map<string, import("../shared/stack").NodeStack>;
-        registerSharedNode(layoutId: string, node: IProjectionNode<unknown>): void;
-        isLead(): boolean;
-        getLead(): IProjectionNode<unknown> | any;
-        getPrevLead(): IProjectionNode<unknown> | undefined;
-        getStack(): import("../shared/stack").NodeStack | undefined;
-        promote({ needsReset, transition, preserveFollowOpacity, }?: {
-            needsReset?: boolean | undefined;
-            transition?: import("../..").Transition | undefined;
-            preserveFollowOpacity?: boolean | undefined;
-        }): void;
-        relegate(): boolean;
-        resetRotation(): void;
-        getProjectionStyles(styleProp?: import("../..").MotionStyle): import("../..").ResolvedValues;
-        clearSnapshot(): void;
-        resetTree(): void;
-    };
-};

package/types/projection/node/create-projection-node.d.ts

@@ -1,301 +0,0 @@
-import { Process } from "framesync";
-import { AnimationOptions, AnimationPlaybackControls } from "../../animation/animate";
-import { ResolvedValues } from "../../render/types";
-import { SubscriptionManager } from "../../utils/subscription-manager";
-import { Axis, AxisDelta, Box, Delta, Point } from "../geometry/types";
-import { NodeStack } from "../shared/stack";
-import { IProjectionNode, Layout, LayoutEvents, ProjectionNodeConfig, ProjectionNodeOptions, Snapshot } from "./types";
-import { FlatTree } from "../../render/utils/flat-tree";
-import { Transition } from "../../types";
-import { MotionStyle } from "../../motion/types";
-/**
- * This should only ever be modified on the client otherwise it'll
- * persist through server requests. If we need instanced states we
- * could lazy-init via root.
- */
-export declare const globalProjectionState: {
-    /**
-     * Global flag as to whether the tree has animated since the last time
-     * we resized the window
-     */
-    hasAnimatedSinceResize: boolean;
-    /**
-     * We set this to true once, on the first update. Any nodes added to the tree beyond that
-     * update will be given a `data-projection-id` attribute.
-     */
-    hasEverUpdated: boolean;
-};
-export declare function createProjectionNode<I>({ attachResizeListener, defaultParent, measureScroll, resetTransform, }: ProjectionNodeConfig<I>): {
-    new (id: number | undefined, latestValues?: ResolvedValues, parent?: IProjectionNode | undefined): {
-        /**
-         * A unique ID generated for every projection node.
-         *
-         * The projection tree's `didUpdate` function will be triggered by the first element
-         * in the tree to run its layout effects. However, if there are elements entering the tree
-         * these might not be mounted yet. When React renders a `motion` component we
-         * give it a unique selector and register it as a potential projection node (not all
-         * rendered components will be committed by React). In `didUpdate`, we search the DOM for
-         * these potential nodes with this id and hydrate the projetion node of the ones that were commited.
-         */
-        id: number | undefined;
-        /**
-         * A reference to the platform-native node (currently this will be a HTMLElement).
-         */
-        instance: I;
-        /**
-         * A reference to the root projection node. There'll only ever be one tree and one root.
-         */
-        root: IProjectionNode;
-        /**
-         * A reference to this node's parent.
-         */
-        parent?: IProjectionNode<unknown> | undefined;
-        /**
-         * A path from this node to the root node. This provides a fast way to iterate
-         * back up the tree.
-         */
-        path: IProjectionNode[];
-        /**
-         * A Set containing all this component's children. This is used to iterate
-         * through the children.
-         *
-         * TODO: This could be faster to iterate as a flat array stored on the root node.
-         */
-        children: Set<IProjectionNode<unknown>>;
-        /**
-         * Options for the node. We use this to configure what kind of layout animations
-         * we should perform (if any).
-         */
-        options: ProjectionNodeOptions;
-        /**
-         * A snapshot of the element's state just before the current update. This is
-         * hydrated when this node's `willUpdate` method is called and scrubbed at the
-         * end of the tree's `didUpdate` method.
-         */
-        snapshot: Snapshot | undefined;
-        /**
-         * A box defining the element's layout relative to the page. This will have been
-         * captured with all parent scrolls and projection transforms unset.
-         */
-        layout: Layout | undefined;
-        /**
-         * The layout used to calculate the previous layout animation. We use this to compare
-         * layouts between renders and decide whether we need to trigger a new layout animation
-         * or just let the current one play out.
-         */
-        targetLayout?: Box | undefined;
-        /**
-         * A mutable data structure we use to apply all parent transforms currently
-         * acting on the element's layout. It's from here we can calculate the projectionDelta
-         * required to get the element from its layout into its calculated target box.
-         */
-        layoutCorrected: Box;
-        /**
-         * An ideal projection transform we want to apply to the element. This is calculated,
-         * usually when an element's layout has changed, and we want the element to look as though
-         * its in its previous layout on the next frame. From there, we animated it down to 0
-         * to animate the element to its new layout.
-         */
-        targetDelta?: Delta | undefined;
-        /**
-         * A mutable structure representing the visual bounding box on the page where we want
-         * and element to appear. This can be set directly but is currently derived once a frame
-         * from apply targetDelta to layout.
-         */
-        target?: Box | undefined;
-        /**
-         * A mutable structure describing a visual bounding box relative to the element's
-         * projected parent. If defined, target will be derived from this rather than targetDelta.
-         * If not defined, we'll attempt to calculate on the first layout animation frame
-         * based on the targets calculated from targetDelta. This will transfer a layout animation
-         * from viewport-relative to parent-relative.
-         */
-        relativeTarget?: Box | undefined;
-        relativeTargetOrigin?: Box | undefined;
-        relativeParent?: IProjectionNode<unknown> | undefined;
-        /**
-         * We use this to detect when its safe to shut down part of a projection tree.
-         * We have to keep projecting children for scale correction and relative projection
-         * until all their parents stop performing layout animations.
-         */
-        isTreeAnimating: boolean;
-        isAnimationBlocked: boolean;
-        /**
-         * If true, attempt to resolve relativeTarget.
-         */
-        attemptToResolveRelativeTarget?: boolean | undefined;
-        /**
-         * A mutable structure that represents the target as transformed by the element's
-         * latest user-set transforms (ie scale, x)
-         */
-        targetWithTransforms?: Box | undefined;
-        /**
-         * A calculated transform that will project an element from its layoutCorrected
-         * into the target. This will be used by children to calculate their own layoutCorrect boxes.
-         */
-        projectionDelta?: Delta | undefined;
-        /**
-         * A calculated transform that will project an element from its layoutCorrected
-         * into the targetWithTransforms.
-         */
-        projectionDeltaWithTransform?: Delta | undefined;
-        /**
-         * If we're tracking the scroll of this element, we store it here.
-         */
-        scroll?: Point | undefined;
-        /**
-         * Flag to true if we think this layout has been changed. We can't always know this,
-         * currently we set it to true every time a component renders, or if it has a layoutDependency
-         * if that has changed between renders. Additionally, components can be grouped by LayoutGroup
-         * and if one node is dirtied, they all are.
-         */
-        isLayoutDirty: boolean;
-        /**
-         * Block layout updates for instant layout transitions throughout the tree.
-         */
-        updateManuallyBlocked: boolean;
-        updateBlockedByResize: boolean;
-        /**
-         * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`
-         * call.
-         */
-        isUpdating: boolean;
-        /**
-         * If this is an SVG element we currently disable projection transforms
-         */
-        isSVG: boolean;
-        /**
-         * Flag to true (during promotion) if a node doing an instant layout transition needs to reset
-         * its projection styles.
-         */
-        needsReset: boolean;
-        /**
-         * Flags whether this node should have its transform reset prior to measuring.
-         */
-        shouldResetTransform: boolean;
-        /**
-         * An object representing the calculated contextual/accumulated/tree scale.
-         * This will be used to scale calculcated projection transforms, as these are
-         * calculated in screen-space but need to be scaled for elements to actually
-         * make it to their calculated destinations.
-         *
-         * TODO: Lazy-init
-         */
-        treeScale: Point;
-        /**
-         * Is hydrated with a projection node if an element is animating from another.
-         */
-        resumeFrom?: IProjectionNode<unknown> | undefined;
-        /**
-         * Is hydrated with a projection node if an element is animating from another.
-         */
-        resumingFrom?: IProjectionNode<unknown> | undefined;
-        /**
-         * A reference to the element's latest animated values. This is a reference shared
-         * between the element's VisualElement and the ProjectionNode.
-         */
-        latestValues: ResolvedValues;
-        /**
-         *
-         */
-        eventHandlers: Map<LayoutEvents, SubscriptionManager<any>>;
-        nodes?: FlatTree | undefined;
-        depth: number;
-        /**
-         * When we update the projection transform, we also build it into a string.
-         * If the string changes between frames, we trigger a render.
-         */
-        projectionTransform: string;
-        /**
-         * If transformTemplate generates a different value before/after the
-         * update, we need to reset the transform.
-         */
-        prevTransformTemplateValue: string | undefined;
-        preserveOpacity?: boolean | undefined;
-        addEventListener(name: LayoutEvents, handler: any): () => void;
-        notifyListeners(name: LayoutEvents, ...args: any): void;
-        hasListeners(name: LayoutEvents): boolean;
-        potentialNodes: Map<number, IProjectionNode<unknown>>;
-        registerPotentialNode(id: number, node: IProjectionNode): void;
-        /**
-         * Lifecycles
-         */
-        mount(instance: I, isLayoutDirty?: boolean): void;
-        unmount(): void;
-        blockUpdate(): void;
-        unblockUpdate(): void;
-        isUpdateBlocked(): boolean;
-        isTreeAnimationBlocked(): boolean;
-        startUpdate(): void;
-        willUpdate(shouldNotifyListeners?: boolean): void;
-        didUpdate(): void;
-        clearAllSnapshots(): void;
-        scheduleUpdateProjection(): void;
-        scheduleCheckAfterUnmount(): void;
-        checkUpdateFailed: () => void;
-        updateProjection: () => void;
-        /**
-         * Update measurements
-         */
-        updateSnapshot(): void;
-        updateLayout(): void;
-        updateScroll(): void;
-        resetTransform(): void;
-        measure(): Box;
-        removeElementScroll(box: Box): Box;
-        applyTransform(box: Box, transformOnly?: boolean): Box;
-        removeTransform(box: Box): Box;
-        /**
-         *
-         */
-        setTargetDelta(delta: Delta): void;
-        setOptions(options: ProjectionNodeOptions): void;
-        clearMeasurements(): void;
-        /**
-         * Frame calculations
-         */
-        resolveTargetDelta(): void;
-        getClosestProjectingParent(): IProjectionNode<unknown> | undefined;
-        hasProjected: boolean;
-        calcProjection(): void;
-        isVisible: boolean;
-        hide(): void;
-        show(): void;
-        scheduleRender(notifyAll?: boolean): void;
-        /**
-         * Animation
-         */
-        animationValues?: ResolvedValues | undefined;
-        pendingAnimation?: Process | undefined;
-        currentAnimation?: AnimationPlaybackControls | undefined;
-        mixTargetDelta: (progress: number) => void;
-        animationProgress: number;
-        setAnimationOrigin(delta: Delta, hasOnlyRelativeTargetChanged?: boolean): void;
-        startAnimation(options: AnimationOptions<number>): void;
-        completeAnimation(): void;
-        finishAnimation(): void;
-        applyTransformsToTarget(): void;
-        /**
-         * Shared layout
-         */
-        sharedNodes: Map<string, NodeStack>;
-        registerSharedNode(layoutId: string, node: IProjectionNode): void;
-        isLead(): boolean;
-        getLead(): IProjectionNode<unknown> | any;
-        getPrevLead(): IProjectionNode<unknown> | undefined;
-        getStack(): NodeStack | undefined;
-        promote({ needsReset, transition, preserveFollowOpacity, }?: {
-            needsReset?: boolean | undefined;
-            transition?: Transition | undefined;
-            preserveFollowOpacity?: boolean | undefined;
-        }): void;
-        relegate(): boolean;
-        resetRotation(): void;
-        getProjectionStyles(styleProp?: MotionStyle): ResolvedValues;
-        clearSnapshot(): void;
-        resetTree(): void;
-    };
-};
-export declare function mixAxisDelta(output: AxisDelta, delta: AxisDelta, p: number): void;
-export declare function mixAxis(output: Axis, from: Axis, to: Axis, p: number): void;
-export declare function mixBox(output: Box, from: Box, to: Box, p: number): void;

package/types/projection/node/group.d.ts

@@ -1,7 +0,0 @@
-import { IProjectionNode } from "./types";
-export interface NodeGroup {
-    add: (node: IProjectionNode) => void;
-    remove: (node: IProjectionNode) => void;
-    dirty: VoidFunction;
-}
-export declare function nodeGroup(): NodeGroup;

package/types/projection/node/id.d.ts

@@ -1 +0,0 @@
-export declare function useProjectionId(): number | undefined;

package/types/projection/node/types.d.ts

@@ -1,136 +0,0 @@
-import { Transition } from "../../types";
-import { ResolvedValues, VisualElement } from "../../render/types";
-import { Box, Delta, Point } from "../geometry/types";
-import { NodeStack } from "../shared/stack";
-import { AnimationPlaybackControls } from "../../animation/animate";
-import { FlatTree } from "../../render/utils/flat-tree";
-import { InitialPromotionConfig } from "../../context/SwitchLayoutGroupContext";
-import { MotionStyle } from "../../motion/types";
-export interface Snapshot {
-    measured: Box;
-    layout: Box;
-    latestValues: ResolvedValues;
-    isShared?: boolean;
-}
-export interface Layout {
-    measured: Box;
-    actual: Box;
-}
-export declare type LayoutEvents = "willUpdate" | "didUpdate" | "beforeMeasure" | "measure" | "projectionUpdate" | "animationStart" | "animationComplete";
-export interface IProjectionNode<I = unknown> {
-    id: number | undefined;
-    parent?: IProjectionNode;
-    relativeParent?: IProjectionNode;
-    root?: IProjectionNode;
-    children: Set<IProjectionNode>;
-    path: IProjectionNode[];
-    nodes?: FlatTree;
-    depth: number;
-    instance: I;
-    mount: (node: I, isLayoutDirty?: boolean) => void;
-    unmount: () => void;
-    options: ProjectionNodeOptions;
-    setOptions(options: ProjectionNodeOptions): void;
-    layout?: Layout;
-    snapshot?: Snapshot;
-    target?: Box;
-    relativeTarget?: Box;
-    targetDelta?: Delta;
-    targetWithTransforms?: Box;
-    scroll?: Point;
-    treeScale?: Point;
-    projectionDelta?: Delta;
-    latestValues: ResolvedValues;
-    isLayoutDirty: boolean;
-    shouldResetTransform: boolean;
-    prevTransformTemplateValue: string | undefined;
-    isUpdateBlocked(): boolean;
-    updateManuallyBlocked: boolean;
-    updateBlockedByResize: boolean;
-    blockUpdate(): void;
-    unblockUpdate(): void;
-    isUpdating: boolean;
-    needsReset: boolean;
-    startUpdate(): void;
-    willUpdate(notifyListeners?: boolean): void;
-    didUpdate(): void;
-    measure(): Box;
-    updateLayout(): void;
-    updateSnapshot(): void;
-    clearSnapshot(): void;
-    updateScroll(): void;
-    scheduleUpdateProjection(): void;
-    scheduleCheckAfterUnmount(): void;
-    checkUpdateFailed(): void;
-    potentialNodes: Map<number, IProjectionNode>;
-    sharedNodes: Map<string, NodeStack>;
-    registerPotentialNode(id: number, node: IProjectionNode): void;
-    registerSharedNode(id: string, node: IProjectionNode): void;
-    getStack(): NodeStack | undefined;
-    isVisible: boolean;
-    hide(): void;
-    show(): void;
-    scheduleRender(notifyAll?: boolean): void;
-    getClosestProjectingParent(): IProjectionNode | undefined;
-    setTargetDelta(delta: Delta): void;
-    resetTransform(): void;
-    resetRotation(): void;
-    applyTransform(box: Box, transformOnly?: boolean): Box;
-    resolveTargetDelta(): void;
-    calcProjection(): void;
-    getProjectionStyles(styles?: MotionStyle): MotionStyle | undefined;
-    clearMeasurements(): void;
-    resetTree(): void;
-    animationValues?: ResolvedValues;
-    currentAnimation?: AnimationPlaybackControls;
-    isTreeAnimating?: boolean;
-    isAnimationBlocked?: boolean;
-    isTreeAnimationBlocked: () => boolean;
-    setAnimationOrigin(delta: Delta): void;
-    startAnimation(transition: Transition): void;
-    finishAnimation(): void;
-    isLead(): boolean;
-    promote(options?: {
-        needsReset?: boolean;
-        transition?: Transition;
-        preserveFollowOpacity?: boolean;
-    }): void;
-    relegate(): boolean;
-    resumeFrom?: IProjectionNode;
-    resumingFrom?: IProjectionNode;
-    isPresent?: boolean;
-    addEventListener(name: LayoutEvents, handler: any): VoidFunction;
-    notifyListeners(name: LayoutEvents, ...args: any): void;
-    hasListeners(name: LayoutEvents): boolean;
-    preserveOpacity?: boolean;
-}
-export interface LayoutUpdateData {
-    layout: Box;
-    snapshot: Snapshot;
-    delta: Delta;
-    layoutDelta: Delta;
-    hasLayoutChanged: boolean;
-    hasRelativeTargetChanged: boolean;
-}
-export declare type LayoutUpdateHandler = (data: LayoutUpdateData) => void;
-export interface ProjectionNodeConfig<I> {
-    defaultParent?: () => IProjectionNode;
-    attachResizeListener?: (instance: I, notifyResize: VoidFunction) => VoidFunction;
-    measureScroll: (instance: I) => Point;
-    resetTransform?: (instance: I, value?: string) => void;
-}
-export interface ProjectionNodeOptions {
-    animate?: boolean;
-    layoutScroll?: boolean;
-    alwaysMeasureLayout?: boolean;
-    scheduleRender?: VoidFunction;
-    onExitComplete?: VoidFunction;
-    animationType?: "size" | "position" | "both";
-    layoutId?: string;
-    layout?: boolean | string;
-    visualElement?: VisualElement;
-    crossfade?: boolean;
-    transition?: Transition;
-    initialPromotionConfig?: InitialPromotionConfig;
-}
-export declare type ProjectionEventName = "layoutUpdate" | "projectionUpdate";

package/types/projection/shared/stack.d.ts

@@ -1,17 +0,0 @@
-import { IProjectionNode } from "../node/types";
-export declare class NodeStack {
-    lead?: IProjectionNode;
-    prevLead?: IProjectionNode;
-    members: IProjectionNode[];
-    add(node: IProjectionNode): void;
-    remove(node: IProjectionNode): void;
-    relegate(node: IProjectionNode): boolean;
-    promote(node: IProjectionNode, preserveFollowOpacity?: boolean): void;
-    exitAnimationComplete(): void;
-    scheduleRender(): void;
-    /**
-     * Clear any leads that have been removed this render to prevent them from being
-     * used in future animations and to prevent memory leaks
-     */
-    removeLeadSnapshot(): void;
-}

package/types/projection/styles/scale-border-radius.d.ts

@@ -1,11 +0,0 @@
-import { Axis } from "../geometry/types";
-import { ScaleCorrectorDefinition } from "./types";
-export declare function pixelsToPercent(pixels: number, axis: Axis): number;
-/**
- * We always correct borderRadius as a percentage rather than pixels to reduce paints.
- * For example, if you are projecting a box that is 100px wide with a 10px borderRadius
- * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%
- * borderRadius in both states. If we animate between the two in pixels that will trigger
- * a paint each time. If we animate between the two in percentage we'll avoid a paint.
- */
-export declare const correctBorderRadius: ScaleCorrectorDefinition;

package/types/projection/styles/scale-box-shadow.d.ts

@@ -1,2 +0,0 @@
-import { ScaleCorrectorDefinition } from "./types";
-export declare const correctBoxShadow: ScaleCorrectorDefinition;

package/types/projection/styles/scale-correction.d.ts

@@ -1,3 +0,0 @@
-import { ScaleCorrectorMap } from "./types";
-export declare const scaleCorrectors: {};
-export declare function addScaleCorrector(correctors: ScaleCorrectorMap): void;

package/types/projection/styles/transform.d.ts

@@ -1,4 +0,0 @@
-import { ResolvedValues } from "../../render/types";
-import { Delta, Point } from "../geometry/types";
-export declare const identityProjection = "translate3d(0px, 0px, 0) scale(1, 1)";
-export declare function buildProjectionTransform(delta: Delta, treeScale: Point, latestTransform?: ResolvedValues): string;

package/types/projection/styles/types.d.ts

@@ -1,9 +0,0 @@
-import { IProjectionNode } from "../node/types";
-export declare type ScaleCorrector = (latest: string | number, node: IProjectionNode) => string | number;
-export interface ScaleCorrectorDefinition {
-    correct: ScaleCorrector;
-    applyTo?: string[];
-}
-export interface ScaleCorrectorMap {
-    [key: string]: ScaleCorrectorDefinition;
-}

package/types/projection/use-instant-layout-transition.d.ts

@@ -1 +0,0 @@
-export declare function useInstantLayoutTransition(): (cb?: (() => void) | undefined) => void;

package/types/projection/use-reset-projection.d.ts

@@ -1 +0,0 @@
-export declare function useResetProjection(): () => void;

package/types/projection/utils/each-axis.d.ts

@@ -1,3 +0,0 @@
-declare type Callback = (axis: "x" | "y") => void;
-export declare function eachAxis(callback: Callback): void[];
-export {};

package/types/projection/utils/has-transform.d.ts

@@ -1,3 +0,0 @@
-import { ResolvedValues } from "../../render/types";
-export declare function hasScale({ scale, scaleX, scaleY }: ResolvedValues): boolean;
-export declare function hasTransform(values: ResolvedValues): string | number | true;

package/types/projection/utils/measure.d.ts

@@ -1,4 +0,0 @@
-import { TransformPoint } from "../geometry/types";
-import { IProjectionNode } from "../node/types";
-export declare function measureViewportBox(instance: HTMLElement, transformPoint?: TransformPoint): import("../geometry/types").Box;
-export declare function measurePageBox(element: HTMLElement, rootProjectionNode: IProjectionNode, transformPagePoint?: TransformPoint): import("../geometry/types").Box;

package/types/render/dom/create-visual-element.d.ts

@@ -1,2 +0,0 @@
-import { CreateVisualElement } from "../types";
-export declare const createDomVisualElement: CreateVisualElement<HTMLElement | SVGElement>;

package/types/render/dom/features-animation.d.ts

@@ -1,5 +0,0 @@
-import { FeatureBundle } from "../../motion/features/types";
-/**
- * @public
- */
-export declare const domAnimation: FeatureBundle;

package/types/render/dom/features-max.d.ts

@@ -1,5 +0,0 @@
-import { FeatureBundle } from "../../motion/features/types";
-/**
- * @public
- */
-export declare const domMax: FeatureBundle;

package/types/render/dom/motion-minimal.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="react" />
-/**
- * @public
- */
-export declare const m: (<Props>(Component: string | import("react").ComponentType<Props>, customMotionComponentConfig?: import("./motion-proxy").CustomMotionComponentConfig) => import("./motion-proxy").CustomDomComponent<Props>) & import("../html/types").HTMLMotionComponents & import("../svg/types").SVGMotionComponents;