motion-start 0.0.1 → 0.1.0

package/{src/gestures/drag/utils/constraints.ts → dist/gestures/drag/utils/constraints.js}

@@ -1,157 +1,134 @@
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-import type { Axis, AxisBox2D, BoundingBox2D, Point2D } from "../../../types/geometry";
-import type { DragElastic, ResolvedConstraints } from "../types";
-
-/**
- * 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 type calcProgressWithinConstraints = (layoutBox: AxisBox2D, constraintsBox: AxisBox2D) => Point2D;
-
-
-
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-import { mix } from 'popmotion';
-import { __read } from 'tslib';
-
-/**
- * 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.
- */
-function applyConstraints(point: number, { min, max }: Partial<Axis>, elastic?: Axis) {
-    if (min !== undefined && point < min) {
-        // If we have a min point defined, and this is outside of that, constrain
-        point = elastic ? mix(min, point, elastic.min) : Math.max(point, min);
-    }
-    else if (max !== undefined && point > max) {
-        // If we have a max point defined, and this is outside of that, constrain
-        point = elastic ? mix(max, point, elastic.max) : Math.min(point, max);
-    }
-    return point;
-}
-/**
- * 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.
- */
-function calcConstrainedMinPoint(point: number, length: number, progress: number, constraints?: Partial<Axis>, elastic?: Axis) {
-    // Calculate a min point for this axis and apply it to the current pointer
-    var min = point - length * progress;
-    return constraints ? applyConstraints(min, constraints, elastic) : min;
-}
-/**
- * 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
- */
-function calcRelativeAxisConstraints(axis: Axis, min?: number, max?: number) {
-    return {
-        min: min !== undefined ? axis.min + min : undefined,
-        max: max !== undefined
-            ? axis.max + max - (axis.max - axis.min)
-            : undefined,
-    } as Partial<Axis>;
-}
-/**
- * Calculate constraints in terms of the viewport when
- * defined relatively to the measured bounding box.
- */
-function calcRelativeConstraints(layoutBox: AxisBox2D, { top, left, bottom, right }: Partial<BoundingBox2D>) {
-    return {
-        x: calcRelativeAxisConstraints(layoutBox.x, left, right),
-        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),
-    } as ResolvedConstraints;
-}
-/**
- * Calculate viewport constraints when defined as another viewport-relative axis
- */
-function calcViewportAxisConstraints(layoutAxis: Axis, constraintsAxis: Axis) {
-    var _a;
-    var min = constraintsAxis.min - layoutAxis.min;
-    var max = constraintsAxis.max - layoutAxis.max;
-    // If the constraints axis is actually smaller than the layout axis then we can
-    // flip the constraints
-    if (constraintsAxis.max - constraintsAxis.min <
-        layoutAxis.max - layoutAxis.min) {
-        _a = __read([max, min], 2), min = _a[0], max = _a[1];
-    }
-    return {
-        min: layoutAxis.min + min,
-        max: layoutAxis.min + max,
-    };
-}
-/**
- * Calculate viewport constraints when defined as another viewport-relative box
- */
-function calcViewportConstraints(layoutBox: AxisBox2D, constraintsBox: AxisBox2D) {
-    return {
-        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),
-        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),
-    };
-}
-/**
- * Calculate the an axis position based on two axes and a progress value.
- */
-function calcPositionFromProgress(axis: Axis, constraints: Axis, progress: number) {
-    var axisLength = axis.max - axis.min;
-    var min = mix(constraints.min, constraints.max - axisLength, progress);
-    return { min: min, max: min + axisLength } as Axis;
-}
-/**
- * Rebase the calculated viewport constraints relative to the layout.min point.
- */
-function rebaseAxisConstraints(layout: Axis, constraints: Partial<Axis>) {
-    var relativeConstraints: Partial<Axis> = {};
-    if (constraints.min !== undefined) {
-        relativeConstraints.min = constraints.min - layout.min;
-    }
-    if (constraints.max !== undefined) {
-        relativeConstraints.max = constraints.max - layout.min;
-    }
-    return relativeConstraints;
-}
-const defaultElastic = 0.35;
-/**
- * Accepts a dragElastic prop and returns resolved elastic values for each axis.
- */
-function resolveDragElastic(dragElastic: DragElastic) {
-    if (dragElastic === false) {
-        dragElastic = 0;
-    }
-    else if (dragElastic === true) {
-        dragElastic = defaultElastic;
-    }
-    return {
-        x: resolveAxisElastic(dragElastic, "left", "right"),
-        y: resolveAxisElastic(dragElastic, "top", "bottom"),
-    } as AxisBox2D;
-}
-function resolveAxisElastic(dragElastic: DragElastic, minLabel: string, maxLabel: string) {
-    return {
-        min: resolvePointElastic(dragElastic, minLabel),
-        max: resolvePointElastic(dragElastic, maxLabel),
-    } as Axis;
-}
-function resolvePointElastic(dragElastic: DragElastic, label: string): number {
-    var _a;
-    return typeof dragElastic === "number"
-        ? dragElastic
-        : (_a = (dragElastic as any)[label]) !== null && _a !== void 0 ? _a : 0;
-}
-
-export { applyConstraints, calcConstrainedMinPoint, calcPositionFromProgress, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };
-
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+import { mix } from 'popmotion';
+/**
+ * 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.
+ */
+function applyConstraints(point, { min, max }, elastic) {
+    if (min !== undefined && point < min) {
+        // If we have a min point defined, and this is outside of that, constrain
+        point = elastic ? mix(min, point, elastic.min) : Math.max(point, min);
+    }
+    else if (max !== undefined && point > max) {
+        // If we have a max point defined, and this is outside of that, constrain
+        point = elastic ? mix(max, point, elastic.max) : Math.min(point, max);
+    }
+    return point;
+}
+/**
+ * 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.
+ */
+function calcConstrainedMinPoint(point, length, progress, constraints, elastic) {
+    // Calculate a min point for this axis and apply it to the current pointer
+    var min = point - length * progress;
+    return constraints ? applyConstraints(min, constraints, elastic) : min;
+}
+/**
+ * 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
+ */
+function calcRelativeAxisConstraints(axis, min, max) {
+    return {
+        min: min !== undefined ? axis.min + min : undefined,
+        max: max !== undefined ? axis.max + max - (axis.max - axis.min) : undefined,
+    };
+}
+/**
+ * Calculate constraints in terms of the viewport when
+ * defined relatively to the measured bounding box.
+ */
+function calcRelativeConstraints(layoutBox, { top, left, bottom, right }) {
+    return {
+        x: calcRelativeAxisConstraints(layoutBox.x, left, right),
+        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),
+    };
+}
+/**
+ * Calculate viewport constraints when defined as another viewport-relative axis
+ */
+function calcViewportAxisConstraints(layoutAxis, constraintsAxis) {
+    var _a;
+    var min = constraintsAxis.min - layoutAxis.min;
+    var max = constraintsAxis.max - layoutAxis.max;
+    // If the constraints axis is actually smaller than the layout axis then we can
+    // flip the constraints
+    if (constraintsAxis.max - constraintsAxis.min < layoutAxis.max - layoutAxis.min) {
+        _a = [max, min];
+        [min, max] = _a;
+    }
+    return {
+        min: layoutAxis.min + min,
+        max: layoutAxis.min + max,
+    };
+}
+/**
+ * Calculate viewport constraints when defined as another viewport-relative box
+ */
+function calcViewportConstraints(layoutBox, constraintsBox) {
+    return {
+        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),
+        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),
+    };
+}
+/**
+ * Calculate the an axis position based on two axes and a progress value.
+ */
+function calcPositionFromProgress(axis, constraints, progress) {
+    var axisLength = axis.max - axis.min;
+    var min = mix(constraints.min, constraints.max - axisLength, progress);
+    return { min: min, max: min + axisLength };
+}
+/**
+ * Rebase the calculated viewport constraints relative to the layout.min point.
+ */
+function rebaseAxisConstraints(layout, constraints) {
+    var relativeConstraints = {};
+    if (constraints.min !== undefined) {
+        relativeConstraints.min = constraints.min - layout.min;
+    }
+    if (constraints.max !== undefined) {
+        relativeConstraints.max = constraints.max - layout.min;
+    }
+    return relativeConstraints;
+}
+const defaultElastic = 0.35;
+/**
+ * Accepts a dragElastic prop and returns resolved elastic values for each axis.
+ */
+function resolveDragElastic(dragElastic) {
+    if (dragElastic === false) {
+        dragElastic = 0;
+    }
+    else if (dragElastic === true) {
+        dragElastic = defaultElastic;
+    }
+    return {
+        x: resolveAxisElastic(dragElastic, 'left', 'right'),
+        y: resolveAxisElastic(dragElastic, 'top', 'bottom'),
+    };
+}
+function resolveAxisElastic(dragElastic, minLabel, maxLabel) {
+    return {
+        min: resolvePointElastic(dragElastic, minLabel),
+        max: resolvePointElastic(dragElastic, maxLabel),
+    };
+}
+function resolvePointElastic(dragElastic, label) {
+    var _a;
+    return typeof dragElastic === 'number'
+        ? dragElastic
+        : (_a = dragElastic[label]) !== null && _a !== void 0
+            ? _a
+            : 0;
+}
+export { applyConstraints, calcConstrainedMinPoint, calcPositionFromProgress, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic, };

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

@@ -0,0 +1,14 @@
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+export type Lock = (() => void) | false;
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+declare function createLock(name: string): () => Lock;
+declare function getGlobalLock(drag: boolean | "x" | "y" | "lockDirection"): Lock;
+declare function isDragActive(): boolean;
+export { createLock, getGlobalLock, isDragActive };
+//# sourceMappingURL=lock.d.ts.map

package/dist/gestures/drag/utils/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/motion-start/gestures/drag/utils/lock.ts"],"names":[],"mappings":"AAAA;;;EAGE;AACF,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,KAAK,CAAC;AAGxC;;;EAGE;AAEF,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,SAER,IAAI,CAW3B;AAGD,iBAAS,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,GAAG,GAAG,GAAG,GAAG,eAAe,QA4BjE;AACD,iBAAS,YAAY,YAQpB;AAED,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC"}

package/{src/gestures/drag/utils/lock.ts → dist/gestures/drag/utils/lock.js}

@@ -1,69 +1,56 @@
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-export type Lock = (() => void) | false;
-
-
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-
-function createLock(name: string) {
-    var lock: string | null = null;
-    return function (): Lock {
-        var openLock = function () {
-            lock = null;
-        };
-        
-        if (lock === null) {
-            lock = name;
-            return openLock;
-        }
-        return false;
-    };
-}
-var globalHorizontalLock = createLock("dragHorizontal");
-var globalVerticalLock = createLock("dragVertical");
-function getGlobalLock(drag: boolean | "x" | "y" | "lockDirection") {
-    var lock: Lock = false;
-    if (drag === "y") {
-        
-        lock = globalVerticalLock();
-    }
-    else if (drag === "x") {
-        
-        lock = globalHorizontalLock();
-    }
-    else {
-        var openHorizontal_1 = globalHorizontalLock();
-        var openVertical_1 = globalVerticalLock();
-        if (openHorizontal_1 && openVertical_1) {
-            lock = function () {
-                openHorizontal_1();
-                openVertical_1();
-            };
-        }
-        else {
-            // Release the locks because we don't use them
-            if (openHorizontal_1)
-                openHorizontal_1();
-            if (openVertical_1)
-                openVertical_1();
-        }
-    }
-    return lock;
-}
-function isDragActive() {
-    // Check the gesture lock - if we get it, it means no drag gesture is active
-    // and we can safely fire the tap gesture.
-    var openGestureLock = getGlobalLock(true);
-    if (!openGestureLock)
-        return true;
-    openGestureLock();
-    return false;
-}
-
-export { createLock, getGlobalLock, isDragActive };
-
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+function createLock(name) {
+    var lock = null;
+    return function () {
+        var openLock = function () {
+            lock = null;
+        };
+        if (lock === null) {
+            lock = name;
+            return openLock;
+        }
+        return false;
+    };
+}
+var globalHorizontalLock = createLock("dragHorizontal");
+var globalVerticalLock = createLock("dragVertical");
+function getGlobalLock(drag) {
+    var lock = false;
+    if (drag === "y") {
+        lock = globalVerticalLock();
+    }
+    else if (drag === "x") {
+        lock = globalHorizontalLock();
+    }
+    else {
+        var openHorizontal_1 = globalHorizontalLock();
+        var openVertical_1 = globalVerticalLock();
+        if (openHorizontal_1 && openVertical_1) {
+            lock = function () {
+                openHorizontal_1(); // @ts-expect-error
+                openVertical_1();
+            };
+        }
+        else {
+            // Release the locks because we don't use them
+            if (openHorizontal_1)
+                openHorizontal_1();
+            if (openVertical_1)
+                openVertical_1();
+        }
+    }
+    return lock;
+}
+function isDragActive() {
+    // Check the gesture lock - if we get it, it means no drag gesture is active
+    // and we can safely fire the tap gesture.
+    var openGestureLock = getGlobalLock(true);
+    if (!openGestureLock)
+        return true;
+    openGestureLock();
+    return false;
+}
+export { createLock, getGlobalLock, isDragActive };