Initial commit

node_modules/motion-dom/dist/cjs/index.js

@@ -0,0 +1,105 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function resolveElements(elementOrSelector, scope, selectorCache) {
+    var _a;
+    if (elementOrSelector instanceof Element) {
+        return [elementOrSelector];
+    }
+    else if (typeof elementOrSelector === "string") {
+        let root = document;
+        if (scope) {
+            // TODO: Refactor to utils package
+            // invariant(
+            //     Boolean(scope.current),
+            //     "Scope provided, but no element detected."
+            // )
+            root = scope.current;
+        }
+        const elements = (_a = selectorCache === null || selectorCache === void 0 ? void 0 : selectorCache[elementOrSelector]) !== null && _a !== void 0 ? _a : root.querySelectorAll(elementOrSelector);
+        return elements ? Array.from(elements) : [];
+    }
+    return Array.from(elementOrSelector);
+}
+
+const isDragging = {
+    x: false,
+    y: false,
+};
+function isDragActive() {
+    return isDragging.x || isDragging.y;
+}
+
+/**
+ * Filter out events that are not pointer events, or are triggering
+ * while a Motion gesture is active.
+ */
+function filterEvents(callback) {
+    return (event) => {
+        if (event.pointerType === "touch" || isDragActive())
+            return;
+        callback(event);
+    };
+}
+/**
+ * Create a hover gesture. hover() is different to .addEventListener("pointerenter")
+ * in that it has an easier syntax, filters out polyfilled touch events, interoperates
+ * with drag gestures, and automatically removes the "pointerennd" event listener when the hover ends.
+ *
+ * @public
+ */
+function hover(elementOrSelector, onHoverStart, options = {}) {
+    const gestureAbortController = new AbortController();
+    const eventOptions = {
+        passive: true,
+        ...options,
+        signal: gestureAbortController.signal,
+    };
+    const onPointerEnter = filterEvents((enterEvent) => {
+        const { target } = enterEvent;
+        const onHoverEnd = onHoverStart(enterEvent);
+        if (!onHoverEnd || !target)
+            return;
+        const onPointerLeave = filterEvents((leaveEvent) => {
+            onHoverEnd(leaveEvent);
+            target.removeEventListener("pointerleave", onPointerLeave);
+        });
+        target.addEventListener("pointerleave", onPointerLeave, eventOptions);
+    });
+    resolveElements(elementOrSelector).forEach((element) => {
+        element.addEventListener("pointerenter", onPointerEnter, eventOptions);
+    });
+    return () => gestureAbortController.abort();
+}
+
+function setDragLock(axis) {
+    if (axis === "x" || axis === "y") {
+        if (isDragging[axis]) {
+            return null;
+        }
+        else {
+            isDragging[axis] = true;
+            return () => {
+                isDragging[axis] = false;
+            };
+        }
+    }
+    else {
+        if (isDragging.x || isDragging.y) {
+            return null;
+        }
+        else {
+            isDragging.x = isDragging.y = true;
+            return () => {
+                isDragging.x = isDragging.y = false;
+            };
+        }
+    }
+}
+
+exports.hover = hover;
+exports.isDragActive = isDragActive;
+exports.isDragging = isDragging;
+exports.resolveElements = resolveElements;
+exports.setDragLock = setDragLock;

node_modules/motion-dom/dist/es/gestures/drag/state/is-active.mjs

@@ -0,0 +1,9 @@
+const isDragging = {
+    x: false,
+    y: false,
+};
+function isDragActive() {
+    return isDragging.x || isDragging.y;
+}
+
+export { isDragActive, isDragging };

node_modules/motion-dom/dist/es/gestures/drag/state/set-active.mjs

@@ -0,0 +1,28 @@
+import { isDragging } from './is-active.mjs';
+
+function setDragLock(axis) {
+    if (axis === "x" || axis === "y") {
+        if (isDragging[axis]) {
+            return null;
+        }
+        else {
+            isDragging[axis] = true;
+            return () => {
+                isDragging[axis] = false;
+            };
+        }
+    }
+    else {
+        if (isDragging.x || isDragging.y) {
+            return null;
+        }
+        else {
+            isDragging.x = isDragging.y = true;
+            return () => {
+                isDragging.x = isDragging.y = false;
+            };
+        }
+    }
+}
+
+export { setDragLock };

node_modules/motion-dom/dist/es/gestures/hover.mjs

@@ -0,0 +1,46 @@
+import { resolveElements } from '../utils/resolve-elements.mjs';
+import { isDragActive } from './drag/state/is-active.mjs';
+
+/**
+ * Filter out events that are not pointer events, or are triggering
+ * while a Motion gesture is active.
+ */
+function filterEvents(callback) {
+    return (event) => {
+        if (event.pointerType === "touch" || isDragActive())
+            return;
+        callback(event);
+    };
+}
+/**
+ * Create a hover gesture. hover() is different to .addEventListener("pointerenter")
+ * in that it has an easier syntax, filters out polyfilled touch events, interoperates
+ * with drag gestures, and automatically removes the "pointerennd" event listener when the hover ends.
+ *
+ * @public
+ */
+function hover(elementOrSelector, onHoverStart, options = {}) {
+    const gestureAbortController = new AbortController();
+    const eventOptions = {
+        passive: true,
+        ...options,
+        signal: gestureAbortController.signal,
+    };
+    const onPointerEnter = filterEvents((enterEvent) => {
+        const { target } = enterEvent;
+        const onHoverEnd = onHoverStart(enterEvent);
+        if (!onHoverEnd || !target)
+            return;
+        const onPointerLeave = filterEvents((leaveEvent) => {
+            onHoverEnd(leaveEvent);
+            target.removeEventListener("pointerleave", onPointerLeave);
+        });
+        target.addEventListener("pointerleave", onPointerLeave, eventOptions);
+    });
+    resolveElements(elementOrSelector).forEach((element) => {
+        element.addEventListener("pointerenter", onPointerEnter, eventOptions);
+    });
+    return () => gestureAbortController.abort();
+}
+
+export { hover };

node_modules/motion-dom/dist/es/index.mjs

@@ -0,0 +1,4 @@
+export { hover } from './gestures/hover.mjs';
+export { resolveElements } from './utils/resolve-elements.mjs';
+export { isDragActive, isDragging } from './gestures/drag/state/is-active.mjs';
+export { setDragLock } from './gestures/drag/state/set-active.mjs';

node_modules/motion-dom/dist/es/utils/resolve-elements.mjs

@@ -0,0 +1,22 @@
+function resolveElements(elementOrSelector, scope, selectorCache) {
+    var _a;
+    if (elementOrSelector instanceof Element) {
+        return [elementOrSelector];
+    }
+    else if (typeof elementOrSelector === "string") {
+        let root = document;
+        if (scope) {
+            // TODO: Refactor to utils package
+            // invariant(
+            //     Boolean(scope.current),
+            //     "Scope provided, but no element detected."
+            // )
+            root = scope.current;
+        }
+        const elements = (_a = selectorCache === null || selectorCache === void 0 ? void 0 : selectorCache[elementOrSelector]) !== null && _a !== void 0 ? _a : root.querySelectorAll(elementOrSelector);
+        return elements ? Array.from(elements) : [];
+    }
+    return Array.from(elementOrSelector);
+}
+
+export { resolveElements };

node_modules/motion-dom/dist/index.d.ts

@@ -0,0 +1,66 @@
+type ElementOrSelector = Element | Element[] | NodeListOf<Element> | string;
+interface WithQuerySelectorAll {
+    querySelectorAll: Element["querySelectorAll"];
+}
+interface AnimationScope<T = any> {
+    readonly current: T;
+    animations: any[];
+}
+interface SelectorCache {
+    [key: string]: NodeListOf<Element>;
+}
+declare function resolveElements(elementOrSelector: ElementOrSelector, scope?: AnimationScope, selectorCache?: SelectorCache): Element[];
+
+/**
+ * Options for the hover gesture.
+ *
+ * @public
+ */
+interface HoverOptions {
+    /**
+     * Use passive event listeners. Doing so allows the browser to optimize
+     * scrolling performance by not allowing the use of `preventDefault()`.
+     *
+     * @default true
+     */
+    passive?: boolean;
+    /**
+     * Remove the event listener after the first event.
+     *
+     * @default false
+     */
+    once?: boolean;
+}
+/**
+ * A function to be called when a hover gesture starts.
+ *
+ * This function can optionally return a function that will be called
+ * when the hover gesture ends.
+ *
+ * @public
+ */
+type OnHoverStartEvent = (event: PointerEvent) => void | OnHoverEndEvent;
+/**
+ * A function to be called when a hover gesture ends.
+ *
+ * @public
+ */
+type OnHoverEndEvent = (event: PointerEvent) => void;
+/**
+ * Create a hover gesture. hover() is different to .addEventListener("pointerenter")
+ * in that it has an easier syntax, filters out polyfilled touch events, interoperates
+ * with drag gestures, and automatically removes the "pointerennd" event listener when the hover ends.
+ *
+ * @public
+ */
+declare function hover(elementOrSelector: ElementOrSelector, onHoverStart: OnHoverStartEvent, options?: HoverOptions): () => void;
+
+declare const isDragging: {
+    x: boolean;
+    y: boolean;
+};
+declare function isDragActive(): boolean;
+
+declare function setDragLock(axis: boolean | "x" | "y" | "lockDirection"): (() => void) | null;
+
+export { type AnimationScope, type ElementOrSelector, type HoverOptions, type OnHoverEndEvent, type OnHoverStartEvent, type SelectorCache, type WithQuerySelectorAll, hover, isDragActive, isDragging, resolveElements, setDragLock };