@kitlangton/solid-motion 0.1.0

package/LICENSE

@@ -0,0 +1,48 @@
+MIT License
+
+Copyright (c) 2026 Kit Langton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Portions of this package (gesture, pointer-event and related utilities) are
+adapted from framer-motion, under the following license:
+
+The MIT License (MIT)
+
+Copyright (c) 2018 Framer B.V.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# @kitlangton/solid-motion
+
+[Motion](https://motion.dev) for SolidJS. The same animation engine, springs and
+gestures, with a `motion.*` API that uses Solid's fine-grained reactivity.
+
+```bash
+npm install @kitlangton/solid-motion solid-js
+```
+
+```tsx
+import { motion } from "@kitlangton/solid-motion"
+
+<motion.button
+  animate={{ scale: active() ? 1.1 : 1 }}
+  whileHover={{ y: -2 }}
+  whileTap={{ scale: 0.95 }}
+  transition={{ type: "spring", visualDuration: 0.22, bounce: 0.1 }}
+/>
+```
+
+## Presence
+
+Keep `AnimatePresence` mounted and pass a child factory, so the exiting element
+can be retained until its exit animation finishes:
+
+```tsx
+<AnimatePresence when={open()}>
+  {() => <motion.div initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }} />}
+</AnimatePresence>
+
+// Switch between keyed children
+<AnimatePresence when={true} presenceKey={tab()}>
+  {() => <motion.div exit={{ opacity: 0 }}>{tab()}</motion.div>}
+</AnimatePresence>
+```
+
+## Gestures and drag
+
+`whileHover`, `whileTap`, `whileFocus`, `whileDrag`, `drag`, `dragConstraints`
+(box or `{ current: element }`), `dragElastic`, `dragMomentum` and
+`onDragEnd(event, { offset, velocity })` follow Motion's semantics.
+
+## Motion values
+
+`useMotionValue`, `useTransform`, `useSpring`, `useVelocity`,
+`useMotionValueEvent`, `animate`, and `useReducedMotion` (returns an accessor).
+Motion values update the DOM directly without re-running components.
+
+## Notes
+
+- Specify `bounce` whenever you use `visualDuration` (the pinned engine,
+  `motion-dom@12.30`, ignores `visualDuration` on its own).
+- Layout animations (`layout`, `layoutId`) are not implemented yet.
+- Gesture implementations are adapted from `framer-motion@12.30.0` (MIT).

package/dist/animation/animate/index.d.ts

@@ -0,0 +1,23 @@
+import type { AnimationPlaybackControlsWithThen, AnimationScope, DOMKeyframesDefinition, AnimationOptions as DynamicAnimationOptions, ElementOrSelector, MotionValue, UnresolvedValueKeyframe, ValueAnimationTransition } from "motion-dom";
+import type { AnimationSequence, ObjectTarget, SequenceOptions } from "../sequence/types";
+interface ScopedAnimateOptions {
+    scope?: AnimationScope;
+    reduceMotion?: boolean;
+}
+export declare function createScopedAnimate(options?: ScopedAnimateOptions): {
+    (sequence: AnimationSequence, options?: SequenceOptions): AnimationPlaybackControlsWithThen;
+    (value: string | MotionValue<string>, keyframes: string | UnresolvedValueKeyframe<string>[], options?: ValueAnimationTransition<string>): AnimationPlaybackControlsWithThen;
+    (value: number | MotionValue<number>, keyframes: number | UnresolvedValueKeyframe<number>[], options?: ValueAnimationTransition<number>): AnimationPlaybackControlsWithThen;
+    <V extends string | number>(value: V | MotionValue<V>, keyframes: V | UnresolvedValueKeyframe<V>[], options?: ValueAnimationTransition<V>): AnimationPlaybackControlsWithThen;
+    (element: ElementOrSelector, keyframes: DOMKeyframesDefinition, options?: DynamicAnimationOptions): AnimationPlaybackControlsWithThen;
+    <O extends {}>(object: O | O[], keyframes: ObjectTarget<O>, options?: DynamicAnimationOptions): AnimationPlaybackControlsWithThen;
+};
+export declare const animate: {
+    (sequence: AnimationSequence, options?: SequenceOptions): AnimationPlaybackControlsWithThen;
+    (value: string | MotionValue<string>, keyframes: string | UnresolvedValueKeyframe<string>[], options?: ValueAnimationTransition<string>): AnimationPlaybackControlsWithThen;
+    (value: number | MotionValue<number>, keyframes: number | UnresolvedValueKeyframe<number>[], options?: ValueAnimationTransition<number>): AnimationPlaybackControlsWithThen;
+    <V extends string | number>(value: V | MotionValue<V>, keyframes: V | UnresolvedValueKeyframe<V>[], options?: ValueAnimationTransition<V>): AnimationPlaybackControlsWithThen;
+    (element: ElementOrSelector, keyframes: DOMKeyframesDefinition, options?: DynamicAnimationOptions): AnimationPlaybackControlsWithThen;
+    <O extends {}>(object: O | O[], keyframes: ObjectTarget<O>, options?: DynamicAnimationOptions): AnimationPlaybackControlsWithThen;
+};
+export {};

package/dist/animation/animate/resolve-subjects.d.ts

@@ -0,0 +1,3 @@
+import type { AnimationScope, DOMKeyframesDefinition, SelectorCache } from "motion-dom";
+import type { ObjectTarget } from "../sequence/types";
+export declare function resolveSubjects<O extends {}>(subject: string | Element | Element[] | NodeListOf<Element> | O | O[] | null | undefined, keyframes: DOMKeyframesDefinition | ObjectTarget<O>, scope?: AnimationScope, selectorCache?: SelectorCache): (string | Element | O)[];

package/dist/animation/animate/sequence.d.ts

@@ -0,0 +1,3 @@
+import type { AnimationPlaybackControlsWithThen, AnimationScope } from "motion-dom";
+import type { AnimationSequence, SequenceOptions } from "../sequence/types";
+export declare function animateSequence(sequence: AnimationSequence, options?: SequenceOptions, scope?: AnimationScope): AnimationPlaybackControlsWithThen[];

package/dist/animation/animate/subject.d.ts

@@ -0,0 +1,7 @@
+import { AnimationPlaybackControlsWithThen, AnimationScope, DOMKeyframesDefinition, AnimationOptions as DynamicAnimationOptions, ElementOrSelector, MotionValue, UnresolvedValueKeyframe, ValueAnimationTransition } from "motion-dom";
+import type { ObjectTarget } from "../sequence/types";
+export type AnimationSubject = Element | MotionValue<any> | any;
+export declare function animateSubject(value: string | MotionValue<string>, keyframes: string | UnresolvedValueKeyframe<string>[], options?: ValueAnimationTransition<string>): AnimationPlaybackControlsWithThen[];
+export declare function animateSubject(value: number | MotionValue<number>, keyframes: number | UnresolvedValueKeyframe<number>[], options?: ValueAnimationTransition<number>): AnimationPlaybackControlsWithThen[];
+export declare function animateSubject(element: ElementOrSelector, keyframes: DOMKeyframesDefinition, options?: DynamicAnimationOptions, scope?: AnimationScope): AnimationPlaybackControlsWithThen[];
+export declare function animateSubject<O extends Object>(object: O | O[], keyframes: ObjectTarget<O>, options?: DynamicAnimationOptions): AnimationPlaybackControlsWithThen[];

package/dist/animation/sequence/create.d.ts

@@ -0,0 +1,6 @@
+import { AnimationScope, AnimationOptions as DynamicAnimationOptions, GeneratorFactory } from "motion-dom";
+import { AnimationSequence, At, ResolvedAnimationDefinitions, SequenceOptions } from "./types";
+export declare function createAnimationsFromSequence(sequence: AnimationSequence, { defaultTransition, ...sequenceTransition }?: SequenceOptions, scope?: AnimationScope, generators?: {
+    [key: string]: GeneratorFactory;
+}): ResolvedAnimationDefinitions;
+export declare function getValueTransition(transition: DynamicAnimationOptions & At, key: string): DynamicAnimationOptions;

package/dist/animation/sequence/types.d.ts

@@ -0,0 +1,51 @@
+import type { AnyResolvedKeyframe, MotionValue } from "motion-dom";
+import { AnimationPlaybackOptions, DOMKeyframesDefinition, AnimationOptions as DynamicAnimationOptions, ElementOrSelector, Transition, UnresolvedValueKeyframe } from "motion-dom";
+import { Easing } from "motion-utils";
+export type ObjectTarget<O> = {
+    [K in keyof O]?: O[K] | UnresolvedValueKeyframe[];
+};
+export type SequenceTime = number | "<" | `+${number}` | `-${number}` | `${string}`;
+export type SequenceLabel = string;
+export interface SequenceLabelWithTime {
+    name: SequenceLabel;
+    at: SequenceTime;
+}
+export interface At {
+    at?: SequenceTime;
+}
+export type MotionValueSegment = [MotionValue, UnresolvedValueKeyframe | UnresolvedValueKeyframe[]];
+export type MotionValueSegmentWithTransition = [
+    MotionValue,
+    UnresolvedValueKeyframe | UnresolvedValueKeyframe[],
+    Transition & At
+];
+export type DOMSegment = [ElementOrSelector, DOMKeyframesDefinition];
+export type DOMSegmentWithTransition = [ElementOrSelector, DOMKeyframesDefinition, DynamicAnimationOptions & At];
+export type ObjectSegment<O extends {} = {}> = [O, ObjectTarget<O>];
+export type ObjectSegmentWithTransition<O extends {} = {}> = [O, ObjectTarget<O>, DynamicAnimationOptions & At];
+export type Segment = ObjectSegment | ObjectSegmentWithTransition | SequenceLabel | SequenceLabelWithTime | MotionValueSegment | MotionValueSegmentWithTransition | DOMSegment | DOMSegmentWithTransition;
+export type AnimationSequence = Segment[];
+export interface SequenceOptions extends AnimationPlaybackOptions {
+    delay?: number;
+    duration?: number;
+    defaultTransition?: Transition;
+    reduceMotion?: boolean;
+}
+export interface AbsoluteKeyframe {
+    value: AnyResolvedKeyframe | null;
+    at: number;
+    easing?: Easing;
+}
+export type ValueSequence = AbsoluteKeyframe[];
+export interface SequenceMap {
+    [key: string]: ValueSequence;
+}
+export type ResolvedAnimationDefinition = {
+    keyframes: {
+        [key: string]: UnresolvedValueKeyframe[];
+    };
+    transition: {
+        [key: string]: Transition;
+    };
+};
+export type ResolvedAnimationDefinitions = Map<Element | MotionValue, ResolvedAnimationDefinition>;

package/dist/animation/sequence/utils/calc-repeat-duration.d.ts

@@ -0,0 +1 @@
+export declare function calculateRepeatDuration(duration: number, repeat: number, _repeatDelay: number): number;

package/dist/animation/sequence/utils/calc-time.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceTime } from "../types";
+export declare function calcNextTime(current: number, next: SequenceTime, prev: number, labels: Map<string, number>): number;

package/dist/animation/sequence/utils/edit.d.ts

@@ -0,0 +1,5 @@
+import { UnresolvedValueKeyframe } from "motion-dom";
+import { Easing } from "motion-utils";
+import type { ValueSequence } from "../types";
+export declare function eraseKeyframes(sequence: ValueSequence, startTime: number, endTime: number): void;
+export declare function addKeyframes(sequence: ValueSequence, keyframes: UnresolvedValueKeyframe[], easing: Easing | Easing[], offset: number[], startTime: number, endTime: number): void;

package/dist/animation/sequence/utils/normalize-times.d.ts

@@ -0,0 +1 @@
+export declare function normalizeTimes(times: number[], repeat: number): void;

package/dist/animation/sequence/utils/sort.d.ts

@@ -0,0 +1,2 @@
+import type { AbsoluteKeyframe } from "../types";
+export declare function compareByTime(a: AbsoluteKeyframe, b: AbsoluteKeyframe): number;

package/dist/animation/utils/create-visual-element.d.ts

@@ -0,0 +1,2 @@
+export declare function createDOMVisualElement(element: HTMLElement | SVGElement): void;
+export declare function createObjectVisualElement(subject: Object): void;

package/dist/animation/utils/is-dom-keyframes.d.ts

@@ -0,0 +1,2 @@
+import type { DOMKeyframesDefinition } from "motion-dom";
+export declare function isDOMKeyframes(keyframes: unknown): keyframes is DOMKeyframesDefinition;

package/dist/components/AnimatePresence.d.ts

@@ -0,0 +1,27 @@
+import type { AnimatePresenceProps } from "./AnimatePresenceTypes.js";
+/**
+ * AnimatePresence for Solid.js
+ *
+ * Enables exit animations by keeping elements in the DOM
+ * until their exit animations complete.
+ *
+ * @example
+ * ```solid
+ * <AnimatePresence>
+ *   {show() && (
+ *     <motion.div
+ *       exit={{ opacity: 0 }}
+ *     />
+ *   )}
+ * </AnimatePresence>
+ * ```
+ */
+export declare function AnimatePresence(props: AnimatePresenceProps): import("solid-js").JSX.Element;
+/**
+ * Hook to access presence state and signal safe removal
+ */
+export declare function usePresence(): [boolean, (() => void) | null];
+/**
+ * Simple hook to check if component is present
+ */
+export declare function useIsPresent(): boolean;

package/dist/components/AnimatePresenceContext.d.ts

@@ -0,0 +1,23 @@
+import { type Accessor } from "solid-js";
+import type { PresenceContextProps } from "motion-dom";
+export type { PresenceContextProps };
+export interface SolidPresenceContext extends Omit<PresenceContextProps, 'id' | 'isPresent' | 'initial' | 'custom'> {
+    id: Accessor<string>;
+    isPresent: Accessor<boolean>;
+    initial: Accessor<false | string | string[] | undefined>;
+    custom: Accessor<any>;
+}
+export declare const AnimatePresenceContext: import("solid-js").Context<SolidPresenceContext | null>;
+export declare function AnimatePresenceProvider(props: {
+    value: SolidPresenceContext;
+    children: any;
+}): import("solid-js").JSX.Element;
+export declare function createPresenceState(config: {
+    id: Accessor<string>;
+    isPresent: Accessor<boolean>;
+    initial: Accessor<false | string | string[] | undefined>;
+    custom?: Accessor<any>;
+    onExitComplete?: (childId: string | number) => void;
+    register?: (childId: string | number) => () => void;
+}): SolidPresenceContext;
+export declare function usePresenceInternal(): SolidPresenceContext | null;

package/dist/components/AnimatePresenceTypes.d.ts

@@ -0,0 +1,57 @@
+import type { JSX } from "solid-js";
+export type ChildKey = string | number | object;
+export interface PresenceChildState {
+    key: ChildKey;
+    getChild: () => any;
+    isPresent: boolean;
+    index: number;
+}
+export interface AnimatePresenceProps {
+    /**
+     * Children to animate. Can be a single element or multiple elements.
+     * Multiple elements must have unique `key` props.
+     */
+    children?: JSX.Element | (() => JSX.Element);
+    /**
+     * When defined, drives presence without evaluating children.
+     */
+    when?: boolean;
+    /**
+     * Key for the current child when using `when`.
+     */
+    presenceKey?: ChildKey;
+    /**
+     * If `false`, will disable the first animation on mount.
+     * @default true
+     */
+    initial?: boolean;
+    /**
+     * Callback when all exiting animations have completed.
+     */
+    onExitComplete?: () => void;
+    /**
+     * Animation coordination mode:
+     * - "sync" (default): All animations happen simultaneously
+     * - "wait": Wait for exit animations to complete before enter animations
+     * - "popLayout": Keep exiting elements in layout until they finish
+     * @default "sync"
+     */
+    mode?: "sync" | "wait" | "popLayout";
+    /**
+     * Custom data to pass to all variants through the custom prop
+     */
+    custom?: any;
+    /**
+     * Whether presence affects layout calculations
+     * @default true
+     */
+    presenceAffectsLayout?: boolean;
+    /**
+     * For popLayout mode: which edge to anchor exiting elements
+     */
+    anchorX?: "left" | "right";
+    /**
+     * For popLayout mode: root element for positioning
+     */
+    root?: HTMLElement | ShadowRoot;
+}

package/dist/components/MotionConfig.d.ts

@@ -0,0 +1,16 @@
+import type { JSX } from "solid-js";
+import type { TransformPoint } from "motion-utils";
+import type { Transition } from "motion-dom";
+export type ReducedMotionConfig = "always" | "never" | "user";
+export interface MotionConfigContext {
+    transformPagePoint: TransformPoint;
+    isStatic: boolean;
+    transition?: Transition;
+    reducedMotion?: ReducedMotionConfig;
+    nonce?: string;
+    skipAnimations?: boolean;
+}
+export declare const MotionConfigContext: import("solid-js").Context<MotionConfigContext>;
+export declare function MotionConfig(props: Partial<MotionConfigContext> & {
+    children?: JSX.Element;
+}): JSX.Element;

package/dist/context/MotionContext/create.d.ts

@@ -0,0 +1,3 @@
+import type { MotionProps } from "../../motion/types";
+import type { MotionContextProps } from "../MotionContext";
+export declare function createMotionContext<Instance>(props: MotionProps, parentContext: MotionContextProps): MotionContextProps<Instance>;

package/dist/context/MotionContext/utils.d.ts

@@ -0,0 +1,3 @@
+import type { MotionProps } from "../../motion/types";
+import type { MotionContextProps } from "../MotionContext";
+export declare function getCurrentTreeVariants(props: MotionProps, context: MotionContextProps): MotionContextProps;

package/dist/context/MotionContext.d.ts

@@ -0,0 +1,7 @@
+import type { VisualElement } from "motion-dom";
+export interface MotionContextProps<Instance = unknown> {
+    visualElement?: VisualElement<Instance>;
+    initial?: false | string | string[];
+    animate?: string | string[];
+}
+export declare const MotionContext: import("solid-js").Context<MotionContextProps<unknown>>;

package/dist/context/PresenceContext.d.ts

@@ -0,0 +1,13 @@
+import { type Accessor } from "solid-js";
+import type { PresenceContextProps as MotionDomPresenceContextProps } from "motion-dom";
+import type { VariantLabels } from "../motion/types";
+export type { MotionDomPresenceContextProps as ResolvedPresenceContextProps };
+export interface PresenceContextProps {
+    id: Accessor<string>;
+    isPresent: Accessor<boolean>;
+    register?: (id: string | number) => () => void;
+    onExitComplete?: (id: string | number) => void;
+    initial: Accessor<false | VariantLabels | undefined>;
+    custom: Accessor<any>;
+}
+export declare const PresenceContext: import("solid-js").Context<PresenceContextProps | null>;

package/dist/events/add-pointer-event.d.ts

@@ -0,0 +1,2 @@
+import { EventListenerWithPointInfo } from "./event-info";
+export declare function addPointerEvent(target: EventTarget, eventName: string, handler: EventListenerWithPointInfo, options?: AddEventListenerOptions): () => void;

package/dist/events/event-info.d.ts

@@ -0,0 +1,4 @@
+import { EventInfo } from "motion-dom";
+export type EventListenerWithPointInfo = (e: PointerEvent, info: EventInfo) => void;
+export declare function extractEventInfo(event: PointerEvent): EventInfo;
+export declare const addPointerInfo: (handler: EventListenerWithPointInfo) => EventListener;

package/dist/gestures/drag/VisualElementDragControls.d.ts

@@ -0,0 +1,86 @@
+import { PanInfo, type VisualElement } from "motion-dom";
+import { MotionProps } from "../../motion/types";
+export declare const elementDragControls: WeakMap<VisualElement<unknown, unknown, {}>, VisualElementDragControls>;
+export interface DragControlOptions {
+    /**
+     * This distance after which dragging starts and a direction is locked in.
+     *
+     * @public
+     */
+    distanceThreshold?: number;
+    /**
+     * Whether to immediately snap to the cursor when dragging starts.
+     *
+     * @public
+     */
+    snapToCursor?: boolean;
+}
+export declare class VisualElementDragControls {
+    private visualElement;
+    private panSession?;
+    private openDragLock;
+    isDragging: boolean;
+    private currentDirection;
+    private originPoint;
+    /**
+     * The permitted boundaries of travel, in pixels.
+     */
+    private constraints;
+    private hasMutatedConstraints;
+    /**
+     * The per-axis resolved elastic values.
+     */
+    private elastic;
+    /**
+     * The latest pointer event. Used as fallback when the `cancel` and `stop` functions are called without arguments.
+     */
+    private latestPointerEvent;
+    /**
+     * The latest pan info. Used as fallback when the `cancel` and `stop` functions are called without arguments.
+     */
+    private latestPanInfo;
+    constructor(visualElement: VisualElement<HTMLElement>);
+    start(originEvent: PointerEvent, { snapToCursor, distanceThreshold }?: DragControlOptions): void;
+    /**
+     * @internal
+     */
+    stop(event?: PointerEvent, panInfo?: PanInfo): void;
+    /**
+     * @internal
+     */
+    cancel(): void;
+    /**
+     * Clean up the pan session without modifying other drag state.
+     * This is used during unmount to ensure event listeners are removed
+     * without affecting projection animations or drag locks.
+     * @internal
+     */
+    endPanSession(): void;
+    /** Final owner disposal, including any release inertia on external values. */
+    dispose(): void;
+    private updateAxis;
+    private resolveConstraints;
+    private resolveRefConstraints;
+    private startAnimation;
+    private startAxisValueAnimation;
+    private stopAnimation;
+    private pauseAnimation;
+    private getAnimationState;
+    /**
+     * Drag works differently depending on which props are provided.
+     *
+     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+     * - Otherwise, we apply the delta to the x/y motion values.
+     */
+    private getAxisMotionValue;
+    private snapToCursor;
+    /**
+     * When the viewport resizes we want to check if the measured constraints
+     * have changed and, if so, reposition the element within those new constraints
+     * relative to where it was before the resize.
+     */
+    scalePositionWithinConstraints(): void;
+    addListeners(): (() => void) | undefined;
+    getProps(): MotionProps;
+}
+export declare function expectsResolvedDragConstraints({ dragConstraints, onMeasureDragConstraints, }: MotionProps): boolean;

package/dist/gestures/drag/index.d.ts

@@ -0,0 +1,11 @@
+import { Feature, type VisualElement } from "motion-dom";
+import { VisualElementDragControls } from "./VisualElementDragControls";
+export declare class DragGesture extends Feature<HTMLElement> {
+    controls: VisualElementDragControls;
+    removeGroupControls: Function;
+    removeListeners: Function;
+    constructor(node: VisualElement<HTMLElement>);
+    mount(): void;
+    update(): void;
+    unmount(): void;
+}

package/dist/gestures/drag/utils/constraints.d.ts

@@ -0,0 +1,77 @@
+import { type DragElastic, type ResolvedConstraints } from "motion-dom";
+import { Axis, BoundingBox, Box, Point } from "motion-utils";
+/**
+ * Apply constraints to a point. These constraints are both physical along an
+ * axis, and an elastic factor that determines how much to constrain the point
+ * by if it does lie outside the defined parameters.
+ */
+export declare function applyConstraints(point: number, { min, max }: Partial<Axis>, elastic?: Axis): number;
+/**
+ * Calculates a min projection point based on a pointer, pointer progress
+ * within the drag target, and constraints.
+ *
+ * For instance if an element was 100px width, we were dragging from 0.25
+ * along this axis, the pointer is at 200px, and there were no constraints,
+ * we would calculate a min projection point of 175px.
+ */
+export declare function calcConstrainedMinPoint(point: number, length: number, progress: number, constraints?: Partial<Axis>, elastic?: Axis): number;
+/**
+ * Calculate constraints in terms of the viewport when defined relatively to the
+ * measured axis. This is measured from the nearest edge, so a max constraint of 200
+ * on an axis with a max value of 300 would return a constraint of 500 - axis length
+ */
+export declare function calcRelativeAxisConstraints(axis: Axis, min?: number, max?: number): Partial<Axis>;
+/**
+ * Calculate constraints in terms of the viewport when
+ * defined relatively to the measured bounding box.
+ */
+export declare function calcRelativeConstraints(layoutBox: Box, { top, left, bottom, right }: Partial<BoundingBox>): ResolvedConstraints;
+/**
+ * Calculate viewport constraints when defined as another viewport-relative axis
+ */
+export declare function calcViewportAxisConstraints(layoutAxis: Axis, constraintsAxis: Axis): {
+    min: number;
+    max: number;
+};
+/**
+ * Calculate viewport constraints when defined as another viewport-relative box
+ */
+export declare function calcViewportConstraints(layoutBox: Box, constraintsBox: Box): {
+    x: {
+        min: number;
+        max: number;
+    };
+    y: {
+        min: number;
+        max: number;
+    };
+};
+/**
+ * Calculate a transform origin relative to the source axis, between 0-1, that results
+ * in an asthetically pleasing scale/transform needed to project from source to target.
+ */
+export declare function calcOrigin(source: Axis, target: Axis): number;
+/**
+ * Calculate the relative progress of one constraints box relative to another.
+ * Imagine a page scroll bar. At the top, this would return 0, at the bottom, 1.
+ * Anywhere in-between, a value between 0 and 1.
+ *
+ * This also handles flipped constraints, for instance a draggable container within
+ * a smaller viewport like a scrollable view.
+ */
+export declare function calcProgressWithinConstraints(layoutBox: Box, constraintsBox: Box): Point;
+/**
+ * Calculate the an axis position based on two axes and a progress value.
+ */
+export declare function calcPositionFromProgress(axis: Axis, constraints: Axis, progress: number): Axis;
+/**
+ * Rebase the calculated viewport constraints relative to the layout.min point.
+ */
+export declare function rebaseAxisConstraints(layout: Axis, constraints: Partial<Axis>): Partial<Axis>;
+export declare const defaultElastic = 0.35;
+/**
+ * Accepts a dragElastic prop and returns resolved elastic values for each axis.
+ */
+export declare function resolveDragElastic(dragElastic?: DragElastic): Box;
+export declare function resolveAxisElastic(dragElastic: DragElastic, minLabel: string, maxLabel: string): Axis;
+export declare function resolvePointElastic(dragElastic: DragElastic, label: string): number;

package/dist/gestures/focus.d.ts

@@ -0,0 +1,8 @@
+import { Feature } from "motion-dom";
+export declare class FocusGesture extends Feature<Element> {
+    private isActive;
+    onFocus(): void;
+    onBlur(): void;
+    mount(): void;
+    unmount(): void;
+}

package/dist/gestures/hover.d.ts

@@ -0,0 +1,5 @@
+import { Feature } from "motion-dom";
+export declare class HoverGesture extends Feature<Element> {
+    mount(): void;
+    unmount(): void;
+}