@anyknown/axis 0.0.0-stage → 0.2.1

package/dist/coordinator/create-coordinator.js

@@ -0,0 +1,191 @@
+import { composedPathMatches, isScrollKey, pointerSample, VELOCITY_WINDOW, velocityFromSamples, } from "../utils/index.js";
+import { CLICK_SUPPRESS_MS, coordinators, DRAG_THRESHOLD, NO_DRAG } from "./constants.js";
+import { pickOwner } from "./pick-owner.js";
+export function createCoordinator(win) {
+    const clients = new Map();
+    let session = null;
+    let suppressClick = false;
+    let suppressTimer = 0;
+    const capture = { capture: true };
+    const passiveCapture = { capture: true, passive: true };
+    const stillRegistered = (client) => clients.get(client.el) === client;
+    const forgetSuppressedClick = () => {
+        suppressClick = false;
+        win.clearTimeout(suppressTimer);
+    };
+    const detach = () => {
+        win.removeEventListener("pointermove", onPointerMove);
+        win.removeEventListener("pointerup", onPointerUp);
+        win.removeEventListener("pointercancel", onPointerCancel);
+        win.removeEventListener("wheel", releaseHoldsOnUserScroll, passiveCapture);
+        win.removeEventListener("keydown", releaseHoldsOnUserScroll, capture);
+        win.removeEventListener("contextmenu", cancelPress, capture);
+        win.removeEventListener("blur", cancelPress);
+        win.document.removeEventListener("visibilitychange", cancelPressWhenHidden);
+        session = null;
+    };
+    const endSession = (ended, pointerVelocity) => {
+        detach();
+        if (ended.owner && stillRegistered(ended.owner))
+            ended.owner.end(pointerVelocity);
+        for (const client of ended.chain) {
+            if (client !== ended.owner && stillRegistered(client))
+                client.pass();
+        }
+    };
+    const cancelPress = () => {
+        if (session)
+            endSession(session, null);
+    };
+    const cancelPressWhenHidden = () => {
+        if (win.document.visibilityState === "hidden")
+            cancelPress();
+    };
+    const releaseHoldsOnUserScroll = (event) => {
+        if (event.type === "keydown" && !isScrollKey(event))
+            return;
+        if (session)
+            for (const client of session.chain)
+                client.interrupt();
+    };
+    const attach = () => {
+        win.addEventListener("pointermove", onPointerMove);
+        win.addEventListener("pointerup", onPointerUp);
+        win.addEventListener("pointercancel", onPointerCancel);
+        win.addEventListener("wheel", releaseHoldsOnUserScroll, passiveCapture);
+        win.addEventListener("keydown", releaseHoldsOnUserScroll, capture);
+        win.addEventListener("contextmenu", cancelPress, capture);
+        win.addEventListener("blur", cancelPress);
+        win.document.addEventListener("visibilitychange", cancelPressWhenHidden);
+    };
+    const onPointerDown = (event) => {
+        forgetSuppressedClick();
+        if (session)
+            return;
+        const path = event.composedPath();
+        const chain = [];
+        for (const node of path) {
+            const client = clients.get(node);
+            if (client)
+                chain.push(client);
+        }
+        if (chain.length === 0)
+            return;
+        const draggable = event.pointerType === "mouse" &&
+            event.button === 0 &&
+            !composedPathMatches(path, NO_DRAG, chain.at(-1).el) &&
+            !chain.some((client) => client.onScrollbar(event));
+        if (!draggable) {
+            for (const client of chain)
+                client.interrupt();
+            return;
+        }
+        for (const client of chain)
+            client.press();
+        const pressed = chain.filter(stillRegistered);
+        if (pressed.length === 0)
+            return;
+        session = {
+            pointerId: event.pointerId,
+            start: { x: event.clientX, y: event.clientY },
+            chain: pressed,
+            owner: null,
+            samples: [pointerSample(event)],
+        };
+        attach();
+    };
+    const handOver = (current, delta) => {
+        const owner = pickOwner(current.chain, delta);
+        if (!owner) {
+            endSession(current, null);
+            return;
+        }
+        current.owner = owner;
+        for (const client of current.chain)
+            if (client !== owner)
+                client.yield();
+        owner.start(current.pointerId);
+    };
+    const onPointerMove = (event) => {
+        const current = session;
+        if (!current || event.pointerId !== current.pointerId)
+            return;
+        const releasedOutsideWindow = !(event.buttons & 1);
+        if (releasedOutsideWindow) {
+            cancelPress();
+            return;
+        }
+        const { samples } = current;
+        samples.push(pointerSample(event));
+        while (samples.length > 2 && event.timeStamp - samples[0].t > VELOCITY_WINDOW * 2)
+            samples.shift();
+        const delta = { x: event.clientX - current.start.x, y: event.clientY - current.start.y };
+        if (!current.owner) {
+            if (Math.hypot(delta.x, delta.y) <= DRAG_THRESHOLD)
+                return;
+            handOver(current, delta);
+        }
+        const endedByListener = session !== current;
+        if (endedByListener || !current.owner)
+            return;
+        current.owner.move(delta);
+    };
+    const onPointerUp = (event) => {
+        const current = session;
+        if (!current || event.pointerId !== current.pointerId)
+            return;
+        current.samples.push(pointerSample(event));
+        if (current.owner) {
+            suppressClick = true;
+            win.clearTimeout(suppressTimer);
+            suppressTimer = win.setTimeout(() => (suppressClick = false), CLICK_SUPPRESS_MS);
+        }
+        endSession(current, current.owner ? velocityFromSamples(current.samples) : null);
+    };
+    const onPointerCancel = (event) => {
+        if (session && event.pointerId === session.pointerId)
+            cancelPress();
+    };
+    const swallowClickAfterDrag = (event) => {
+        if (!suppressClick)
+            return;
+        forgetSuppressedClick();
+        event.preventDefault();
+        event.stopPropagation();
+    };
+    const preventNativeDragAndDrop = (event) => {
+        if (session)
+            event.preventDefault();
+    };
+    const remove = (client) => {
+        if (clients.get(client.el) !== client)
+            return;
+        clients.delete(client.el);
+        if (session) {
+            const current = session;
+            current.chain = current.chain.filter((other) => other !== client);
+            if (current.owner === client || current.chain.length === 0) {
+                current.owner = null;
+                endSession(current, null);
+            }
+        }
+        if (clients.size === 0) {
+            win.removeEventListener("pointerdown", onPointerDown, capture);
+            win.removeEventListener("click", swallowClickAfterDrag, capture);
+            win.removeEventListener("dragstart", preventNativeDragAndDrop, capture);
+            forgetSuppressedClick();
+            coordinators.delete(win);
+        }
+    };
+    return {
+        add(client) {
+            if (clients.size === 0) {
+                win.addEventListener("pointerdown", onPointerDown, capture);
+                win.addEventListener("click", swallowClickAfterDrag, capture);
+                win.addEventListener("dragstart", preventNativeDragAndDrop, capture);
+            }
+            clients.set(client.el, client);
+            return () => remove(client);
+        },
+    };
+}

package/dist/coordinator/index.d.ts

@@ -0,0 +1,2 @@
+export { register } from "./register.js";
+export type { DragClient } from "./types.js";

package/dist/coordinator/index.js

@@ -0,0 +1 @@
+export { register } from "./register.js";

package/dist/coordinator/pick-owner.d.ts

@@ -0,0 +1,3 @@
+import { type Vector } from "../utils/index.js";
+import type { DragClient } from "./types.js";
+export declare function pickOwner(innermostFirst: readonly DragClient[], delta: Vector): DragClient | null;

package/dist/coordinator/pick-owner.js

@@ -0,0 +1,7 @@
+import { dominantAxis } from "../utils/index.js";
+export function pickOwner(innermostFirst, delta) {
+    const axis = dominantAxis(delta);
+    const dragsAlongAxis = innermostFirst.filter((client) => client.accepts(axis));
+    const canStillScroll = dragsAlongAxis.find((client) => client.canScroll(delta));
+    return canStillScroll ?? dragsAlongAxis[0] ?? null;
+}

package/dist/coordinator/register.d.ts

@@ -0,0 +1,2 @@
+import type { DragClient } from "./types.js";
+export declare function register(client: DragClient): () => void;

package/dist/coordinator/register.js

@@ -0,0 +1,11 @@
+import { coordinators } from "./constants.js";
+import { createCoordinator } from "./create-coordinator.js";
+export function register(client) {
+    const win = client.el.ownerDocument.defaultView ?? window;
+    let coordinator = coordinators.get(win);
+    if (!coordinator) {
+        coordinator = createCoordinator(win);
+        coordinators.set(win, coordinator);
+    }
+    return coordinator.add(client);
+}

package/dist/coordinator/types.d.ts

@@ -0,0 +1,24 @@
+import type { Sample, Vector } from "../utils/index.js";
+export interface DragClient {
+    readonly el: HTMLElement;
+    onScrollbar(event: PointerEvent): boolean;
+    accepts(axis: "x" | "y"): boolean;
+    canScroll(delta: Vector): boolean;
+    press(): void;
+    yield(): void;
+    start(pointerId: number): void;
+    move(delta: Vector): void;
+    pass(): void;
+    end(pointerVelocity: Vector | null): void;
+    interrupt(): void;
+}
+export interface Session {
+    pointerId: number;
+    start: Vector;
+    chain: DragClient[];
+    owner: DragClient | null;
+    samples: Sample[];
+}
+export interface Coordinator {
+    add(client: DragClient): () => void;
+}

package/dist/coordinator/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createAxis } from "./axis/index.js";
+export type { AxisInstance, AxisMode, AxisName, AxisOptions, AxisPosition, AxisScrollState, AxisScrollToOptions, AxisState, } from "./axis/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { createAxis } from "./axis/index.js";

package/dist/react/constants.d.ts

@@ -0,0 +1,3 @@
+import type { AxisScrollState } from "../axis/index.js";
+export declare const EMPTY_STATE: AxisScrollState;
+export declare const NOOP: () => void;

package/dist/react/constants.js

@@ -0,0 +1,8 @@
+const EMPTY_AXIS = { scroll: 0, maxScroll: 0, progress: 0, canScrollPrev: false, canScrollNext: false };
+export const EMPTY_STATE = {
+    x: EMPTY_AXIS,
+    y: EMPTY_AXIS,
+    isDragging: false,
+    isMomentum: false,
+};
+export const NOOP = () => { };

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export type { AxisApi, UseAxisResult } from "./types.js";
+export { useAxis } from "./use-axis.js";
+export type { AxisMode, AxisName, AxisOptions, AxisPosition, AxisScrollState, AxisScrollToOptions, AxisState, } from "../axis/index.js";

package/dist/react/index.js

@@ -0,0 +1 @@
+export { useAxis } from "./use-axis.js";

package/dist/react/types.d.ts

@@ -0,0 +1,12 @@
+import type { AxisInstance, AxisScrollState } from "../axis/index.js";
+/** Imperative scroll controls returned by {@link useAxis}. Safe to call before the element mounts (no-op). */
+export type AxisApi = Pick<AxisInstance, "scrollPrev" | "scrollNext" | "scrollTo" | "refresh">;
+/** What {@link useAxis} returns. */
+export interface UseAxisResult<T extends HTMLElement = HTMLElement, S = AxisScrollState> {
+    /** Callback ref for the scroll container. Stable. */
+    ref: (element: T | null) => void;
+    /** The scroll state of both axes, or what the selector picked from it. Re-renders only when it changes. */
+    state: S;
+    /** Stable scroll controls. */
+    api: AxisApi;
+}

package/dist/react/types.js

@@ -0,0 +1 @@
+export {};

package/dist/react/use-applied-options.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from "react";
+import type { AxisInstance, AxisOptions } from "../axis/index.js";
+export declare function useAppliedOptions(options: AxisOptions, instanceRef: RefObject<AxisInstance | null>): RefObject<AxisOptions>;

package/dist/react/use-applied-options.js

@@ -0,0 +1,11 @@
+import { useRef } from "react";
+import { useIsomorphicLayoutEffect } from "./use-isomorphic-layout-effect.js";
+export function useAppliedOptions(options, instanceRef) {
+    const optionsRef = useRef(options);
+    const { axis, momentum, wheel, cursor } = options;
+    useIsomorphicLayoutEffect(() => {
+        optionsRef.current = { axis, momentum, wheel, cursor };
+        instanceRef.current?.setOptions(optionsRef.current);
+    }, [axis, momentum, wheel, cursor]);
+    return optionsRef;
+}

package/dist/react/use-axis-instance.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from "react";
+import { type AxisInstance, type AxisOptions } from "../axis/index.js";
+export declare function useAxisInstance(element: HTMLElement | null, optionsRef: RefObject<AxisOptions>, instanceRef: RefObject<AxisInstance | null>): AxisInstance | null;

package/dist/react/use-axis-instance.js

@@ -0,0 +1,19 @@
+import { useState } from "react";
+import { createAxis } from "../axis/index.js";
+import { useIsomorphicLayoutEffect } from "./use-isomorphic-layout-effect.js";
+export function useAxisInstance(element, optionsRef, instanceRef) {
+    const [instance, setInstance] = useState(null);
+    useIsomorphicLayoutEffect(() => {
+        if (!element)
+            return;
+        const created = createAxis(element, optionsRef.current);
+        instanceRef.current = created;
+        setInstance(created);
+        return () => {
+            created.destroy();
+            instanceRef.current = null;
+            setInstance(null);
+        };
+    }, [element]);
+    return instance;
+}

package/dist/react/use-axis.d.ts

@@ -0,0 +1,11 @@
+import type { AxisOptions, AxisScrollState } from "../axis/index.js";
+import type { UseAxisResult } from "./types.js";
+/**
+ * Binds axis to an element through a callback ref. The instance is created when the element mounts and
+ * destroyed when it unmounts or changes. Option changes are applied without re-creating the instance.
+ *
+ * With a `selector`, `state` is `selector(state)` and the component re-renders only when that result changes
+ * (compared with `Object.is`).
+ */
+export declare function useAxis<T extends HTMLElement = HTMLElement>(options?: AxisOptions): UseAxisResult<T>;
+export declare function useAxis<S>(options: AxisOptions | undefined, selector: (state: AxisScrollState) => S): UseAxisResult<HTMLElement, S>;

package/dist/react/use-axis.js

@@ -0,0 +1,14 @@
+import { useRef, useState } from "react";
+import { useAppliedOptions } from "./use-applied-options.js";
+import { useAxisInstance } from "./use-axis-instance.js";
+import { useSelectedState } from "./use-selected-state.js";
+import { useStableApi } from "./use-stable-api.js";
+export function useAxis(options = {}, selector) {
+    const [element, setElement] = useState(null);
+    const instanceRef = useRef(null);
+    const optionsRef = useAppliedOptions(options, instanceRef);
+    const instance = useAxisInstance(element, optionsRef, instanceRef);
+    const state = useSelectedState(instance, selector);
+    const api = useStableApi(instanceRef);
+    return { ref: setElement, state, api };
+}

package/dist/react/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from "react";
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/dist/react/use-isomorphic-layout-effect.js

@@ -0,0 +1,2 @@
+import { useEffect, useLayoutEffect } from "react";
+export const useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;

package/dist/react/use-selected-state.d.ts

@@ -0,0 +1,4 @@
+import type { AxisInstance, AxisScrollState } from "../axis/index.js";
+type Selector = ((state: AxisScrollState) => unknown) | undefined;
+export declare function useSelectedState(instance: AxisInstance | null, selector: Selector): unknown;
+export {};

package/dist/react/use-selected-state.js

@@ -0,0 +1,14 @@
+import { useCallback, useRef, useSyncExternalStore } from "react";
+import { EMPTY_STATE, NOOP } from "./constants.js";
+export function useSelectedState(instance, selector) {
+    const subscribe = useCallback((listener) => instance?.subscribe(listener) ?? NOOP, [instance]);
+    const snapshotMemo = useRef(null);
+    const getSnapshot = useCallback(() => {
+        const current = instance?.getState() ?? EMPTY_STATE;
+        if (snapshotMemo.current?.state !== current || snapshotMemo.current.selector !== selector) {
+            snapshotMemo.current = { state: current, selector, selected: selector ? selector(current) : current };
+        }
+        return snapshotMemo.current.selected;
+    }, [instance, selector]);
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}

package/dist/react/use-stable-api.d.ts

@@ -0,0 +1,4 @@
+import { type RefObject } from "react";
+import type { AxisInstance } from "../axis/index.js";
+import type { AxisApi } from "./types.js";
+export declare const useStableApi: (instanceRef: RefObject<AxisInstance | null>) => AxisApi;

package/dist/react/use-stable-api.js

@@ -0,0 +1,7 @@
+import { useMemo } from "react";
+export const useStableApi = (instanceRef) => useMemo(() => ({
+    scrollPrev: (target) => instanceRef.current?.scrollPrev(target),
+    scrollNext: (target) => instanceRef.current?.scrollNext(target),
+    scrollTo: (position, scrollOptions) => instanceRef.current?.scrollTo(position, scrollOptions),
+    refresh: () => instanceRef.current?.refresh(),
+}), [instanceRef]);

package/dist/utils/adjacent-snap.d.ts

@@ -0,0 +1 @@
+export declare function adjacentSnap(positions: readonly number[], current: number, direction: 1 | -1): number | undefined;

package/dist/utils/adjacent-snap.js

@@ -0,0 +1,8 @@
+export function adjacentSnap(positions, current, direction) {
+    if (direction === 1)
+        return positions.find((position) => position > current + 1);
+    for (let i = positions.length - 1; i >= 0; i--)
+        if (positions[i] < current - 1)
+            return positions[i];
+    return undefined;
+}

package/dist/utils/cap-velocity.d.ts

@@ -0,0 +1,2 @@
+/** Scale a release velocity (px/ms) down so its momentum glide travels at most `maxGlide` px. */
+export declare function capVelocity(velocity: number, maxGlide: number): number;

package/dist/utils/cap-velocity.js

@@ -0,0 +1,6 @@
+import { DECAY, FRAME_MS } from "./constants.js";
+/** Scale a release velocity (px/ms) down so its momentum glide travels at most `maxGlide` px. */
+export function capVelocity(velocity, maxGlide) {
+    const limit = (maxGlide * (1 - DECAY)) / FRAME_MS;
+    return Math.sign(velocity) * Math.min(Math.abs(velocity), limit);
+}

package/dist/utils/clamp.d.ts

@@ -0,0 +1 @@
+export declare const clamp: (value: number, min: number, max: number) => number;

package/dist/utils/clamp.js

@@ -0,0 +1 @@
+export const clamp = (value, min, max) => Math.min(max, Math.max(min, value));

package/dist/utils/composed-path-matches.d.ts

@@ -0,0 +1 @@
+export declare function composedPathMatches(path: readonly EventTarget[], selector: string, boundary: EventTarget): boolean;

package/dist/utils/composed-path-matches.js

@@ -0,0 +1,9 @@
+export function composedPathMatches(path, selector, boundary) {
+    for (const node of path) {
+        if (node === boundary)
+            return false;
+        if (node.nodeType === 1 && node.matches(selector))
+            return true;
+    }
+    return false;
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const VELOCITY_WINDOW = 100;
+export declare const MAX_VELOCITY = 5;
+export declare const DECAY = 0.95;
+export declare const FRAME_MS: number;
+export declare const MIN_VELOCITY = 0.02;
+export declare const EDITABLE = "input, textarea, select, [contenteditable]:not([contenteditable='false'])";
+export declare const SCROLL_KEYS: Set<string>;
+export declare const EASE_OUT_CUBIC_START_SPEED = 3;
+export declare const LINE_HEIGHT = 16;

package/dist/utils/constants.js

@@ -0,0 +1,19 @@
+export const VELOCITY_WINDOW = 100;
+export const MAX_VELOCITY = 5;
+export const DECAY = 0.95;
+export const FRAME_MS = 1000 / 60;
+export const MIN_VELOCITY = 0.02;
+export const EDITABLE = "input, textarea, select, [contenteditable]:not([contenteditable='false'])";
+export const SCROLL_KEYS = new Set([
+    "ArrowUp",
+    "ArrowDown",
+    "ArrowLeft",
+    "ArrowRight",
+    "PageUp",
+    "PageDown",
+    "Home",
+    "End",
+    " ",
+]);
+export const EASE_OUT_CUBIC_START_SPEED = 3;
+export const LINE_HEIGHT = 16;

package/dist/utils/css-length-to-px.d.ts

@@ -0,0 +1 @@
+export declare function cssLengthToPx(value: string, percentBasis: number): number;

package/dist/utils/css-length-to-px.js

@@ -0,0 +1,6 @@
+export function cssLengthToPx(value, percentBasis) {
+    const number = Number.parseFloat(value);
+    if (Number.isNaN(number))
+        return 0;
+    return value.endsWith("%") ? (percentBasis * number) / 100 : number;
+}

package/dist/utils/dominant-axis.d.ts

@@ -0,0 +1,2 @@
+import type { Vector } from "./types.js";
+export declare function dominantAxis(delta: Vector): "x" | "y";

package/dist/utils/dominant-axis.js

@@ -0,0 +1,3 @@
+export function dominantAxis(delta) {
+    return Math.abs(delta.x) >= Math.abs(delta.y) ? "x" : "y";
+}

package/dist/utils/ease-out-cubic.d.ts

@@ -0,0 +1 @@
+export declare const easeOutCubic: (t: number) => number;

package/dist/utils/ease-out-cubic.js

@@ -0,0 +1 @@
+export const easeOutCubic = (t) => 1 - (1 - t) ** 3;

package/dist/utils/glide-duration.d.ts

@@ -0,0 +1 @@
+export declare function glideDuration(distance: number, velocity?: number): number;

package/dist/utils/glide-duration.js

@@ -0,0 +1,9 @@
+import { clamp } from "./clamp.js";
+import { EASE_OUT_CUBIC_START_SPEED } from "./constants.js";
+export function glideDuration(distance, velocity = 0) {
+    const d = Math.abs(distance);
+    const continuesRelease = velocity !== 0 && Math.sign(velocity) === Math.sign(distance);
+    if (continuesRelease)
+        return clamp((EASE_OUT_CUBIC_START_SPEED * d) / Math.abs(velocity), 180, 900);
+    return clamp(200 + d * 0.5, 200, 600);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,28 @@
+export { adjacentSnap } from "./adjacent-snap.js";
+export { capVelocity } from "./cap-velocity.js";
+export { clamp } from "./clamp.js";
+export { composedPathMatches } from "./composed-path-matches.js";
+export { dominantAxis } from "./dominant-axis.js";
+export { easeOutCubic } from "./ease-out-cubic.js";
+export { glideDuration } from "./glide-duration.js";
+export { isOnScrollbar } from "./is-on-scrollbar.js";
+export { isRtl } from "./is-rtl.js";
+export { isScrollKey } from "./is-scroll-key.js";
+export { maxScroll } from "./max-scroll.js";
+export { measureSnaps } from "./measure-snaps.js";
+export { momentumDistance } from "./momentum-distance.js";
+export { momentumStep } from "./momentum-step.js";
+export { nearestSnap } from "./nearest-snap.js";
+export { parseSnapType } from "./parse-snap-type.js";
+export { pointerSample } from "./pointer-sample.js";
+export { prefersReducedMotion } from "./prefers-reduced-motion.js";
+export { readScroll } from "./read-scroll.js";
+export { supportedUserSelect } from "./supported-user-select.js";
+export { toLogical } from "./to-logical.js";
+export { tryCapturePointer } from "./try-capture-pointer.js";
+export { tryReleasePointer } from "./try-release-pointer.js";
+export { velocityFromSamples } from "./velocity-from-samples.js";
+export { wheelDeltaYPx } from "./wheel-delta-y-px.js";
+export { writeScroll } from "./write-scroll.js";
+export { EDITABLE, MIN_VELOCITY, VELOCITY_WINDOW } from "./constants.js";
+export type { Sample, Vector } from "./types.js";

package/dist/utils/index.js

@@ -0,0 +1,27 @@
+export { adjacentSnap } from "./adjacent-snap.js";
+export { capVelocity } from "./cap-velocity.js";
+export { clamp } from "./clamp.js";
+export { composedPathMatches } from "./composed-path-matches.js";
+export { dominantAxis } from "./dominant-axis.js";
+export { easeOutCubic } from "./ease-out-cubic.js";
+export { glideDuration } from "./glide-duration.js";
+export { isOnScrollbar } from "./is-on-scrollbar.js";
+export { isRtl } from "./is-rtl.js";
+export { isScrollKey } from "./is-scroll-key.js";
+export { maxScroll } from "./max-scroll.js";
+export { measureSnaps } from "./measure-snaps.js";
+export { momentumDistance } from "./momentum-distance.js";
+export { momentumStep } from "./momentum-step.js";
+export { nearestSnap } from "./nearest-snap.js";
+export { parseSnapType } from "./parse-snap-type.js";
+export { pointerSample } from "./pointer-sample.js";
+export { prefersReducedMotion } from "./prefers-reduced-motion.js";
+export { readScroll } from "./read-scroll.js";
+export { supportedUserSelect } from "./supported-user-select.js";
+export { toLogical } from "./to-logical.js";
+export { tryCapturePointer } from "./try-capture-pointer.js";
+export { tryReleasePointer } from "./try-release-pointer.js";
+export { velocityFromSamples } from "./velocity-from-samples.js";
+export { wheelDeltaYPx } from "./wheel-delta-y-px.js";
+export { writeScroll } from "./write-scroll.js";
+export { EDITABLE, MIN_VELOCITY, VELOCITY_WINDOW } from "./constants.js";

package/dist/utils/is-inside-editable.d.ts

@@ -0,0 +1 @@
+export declare const isInsideEditable: (target: EventTarget | null) => boolean;

package/dist/utils/is-inside-editable.js

@@ -0,0 +1,2 @@
+import { EDITABLE } from "./constants.js";
+export const isInsideEditable = (target) => !!target?.closest?.(EDITABLE);

package/dist/utils/is-on-scrollbar.d.ts

@@ -0,0 +1 @@
+export declare function isOnScrollbar(el: Element, event: MouseEvent): boolean;

package/dist/utils/is-on-scrollbar.js

@@ -0,0 +1,6 @@
+export function isOnScrollbar(el, event) {
+    const rect = el.getBoundingClientRect();
+    const x = event.clientX - rect.left - el.clientLeft;
+    const y = event.clientY - rect.top - el.clientTop;
+    return x < 0 || y < 0 || x >= el.clientWidth || y >= el.clientHeight;
+}

package/dist/utils/is-rtl.d.ts

@@ -0,0 +1 @@
+export declare const isRtl: (win: Window, el: Element) => boolean;

package/dist/utils/is-rtl.js

@@ -0,0 +1 @@
+export const isRtl = (win, el) => win.getComputedStyle(el).direction === "rtl";

package/dist/utils/is-scroll-key.d.ts

@@ -0,0 +1 @@
+export declare function isScrollKey(event: KeyboardEvent): boolean;