@teamturing/react-kit 2.51.3 → 2.51.5

package/esm/node_modules/framer-motion/dist/es/gestures/drag/index.js

@@ -1,27 +0,0 @@
-import { Feature } from '../../motion/features/Feature.js';
-import { noop } from '../../utils/noop.js';
-import { VisualElementDragControls } from './VisualElementDragControls.js';
-
-class DragGesture extends Feature {
-    constructor(node) {
-        super(node);
-        this.removeGroupControls = noop;
-        this.removeListeners = noop;
-        this.controls = new VisualElementDragControls(node);
-    }
-    mount() {
-        // If we've been provided a DragControls for manual control over the drag gesture,
-        // subscribe this component to it on mount.
-        const { dragControls } = this.node.getProps();
-        if (dragControls) {
-            this.removeGroupControls = dragControls.subscribe(this.controls);
-        }
-        this.removeListeners = this.controls.addListeners() || noop;
-    }
-    unmount() {
-        this.removeGroupControls();
-        this.removeListeners();
-    }
-}
-
-export { DragGesture };

package/esm/node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.js

@@ -1,125 +0,0 @@
-import { progress } from '../../../utils/progress.js';
-import { calcLength } from '../../../projection/geometry/delta-calc.js';
-import { clamp } from '../../../utils/clamp.js';
-import { mix } from '../../../utils/mix.js';
-
-/**
- * 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;
-}
-/**
- * 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) {
-    let min = constraintsAxis.min - layoutAxis.min;
-    let 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) {
-        [min, max] = [max, min];
-    }
-    return { 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 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.
- */
-function calcOrigin(source, target) {
-    let origin = 0.5;
-    const sourceLength = calcLength(source);
-    const targetLength = calcLength(target);
-    if (targetLength > sourceLength) {
-        origin = progress(target.min, target.max - sourceLength, source.min);
-    }
-    else if (sourceLength > targetLength) {
-        origin = progress(source.min, source.max - targetLength, target.min);
-    }
-    return clamp(0, 1, origin);
-}
-/**
- * Rebase the calculated viewport constraints relative to the layout.min point.
- */
-function rebaseAxisConstraints(layout, constraints) {
-    const 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 = defaultElastic) {
-    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) {
-    return typeof dragElastic === "number"
-        ? dragElastic
-        : dragElastic[label] || 0;
-}
-
-export { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };

package/esm/node_modules/framer-motion/dist/es/gestures/drag/utils/lock.js

@@ -1,53 +0,0 @@
-function createLock(name) {
-    let lock = null;
-    return () => {
-        const openLock = () => {
-            lock = null;
-        };
-        if (lock === null) {
-            lock = name;
-            return openLock;
-        }
-        return false;
-    };
-}
-const globalHorizontalLock = createLock("dragHorizontal");
-const globalVerticalLock = createLock("dragVertical");
-function getGlobalLock(drag) {
-    let lock = false;
-    if (drag === "y") {
-        lock = globalVerticalLock();
-    }
-    else if (drag === "x") {
-        lock = globalHorizontalLock();
-    }
-    else {
-        const openHorizontal = globalHorizontalLock();
-        const openVertical = globalVerticalLock();
-        if (openHorizontal && openVertical) {
-            lock = () => {
-                openHorizontal();
-                openVertical();
-            };
-        }
-        else {
-            // Release the locks because we don't use them
-            if (openHorizontal)
-                openHorizontal();
-            if (openVertical)
-                openVertical();
-        }
-    }
-    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.
-    const openGestureLock = getGlobalLock(true);
-    if (!openGestureLock)
-        return true;
-    openGestureLock();
-    return false;
-}
-
-export { createLock, getGlobalLock, isDragActive };

package/esm/node_modules/framer-motion/dist/es/gestures/focus.js

@@ -1,41 +0,0 @@
-import { addDomEvent } from '../events/add-dom-event.js';
-import { Feature } from '../motion/features/Feature.js';
-import { pipe } from '../utils/pipe.js';
-
-class FocusGesture extends Feature {
-    constructor() {
-        super(...arguments);
-        this.isActive = false;
-    }
-    onFocus() {
-        let isFocusVisible = false;
-        /**
-         * If this element doesn't match focus-visible then don't
-         * apply whileHover. But, if matches throws that focus-visible
-         * is not a valid selector then in that browser outline styles will be applied
-         * to the element by default and we want to match that behaviour with whileFocus.
-         */
-        try {
-            isFocusVisible = this.node.current.matches(":focus-visible");
-        }
-        catch (e) {
-            isFocusVisible = true;
-        }
-        if (!isFocusVisible || !this.node.animationState)
-            return;
-        this.node.animationState.setActive("whileFocus", true);
-        this.isActive = true;
-    }
-    onBlur() {
-        if (!this.isActive || !this.node.animationState)
-            return;
-        this.node.animationState.setActive("whileFocus", false);
-        this.isActive = false;
-    }
-    mount() {
-        this.unmount = pipe(addDomEvent(this.node.current, "focus", () => this.onFocus()), addDomEvent(this.node.current, "blur", () => this.onBlur()));
-    }
-    unmount() { }
-}
-
-export { FocusGesture };

package/esm/node_modules/framer-motion/dist/es/gestures/hover.js

@@ -1,32 +0,0 @@
-import { addPointerEvent } from '../events/add-pointer-event.js';
-import { pipe } from '../utils/pipe.js';
-import { isDragActive } from './drag/utils/lock.js';
-import { Feature } from '../motion/features/Feature.js';
-import { frame } from '../frameloop/frame.js';
-
-function addHoverEvent(node, isActive) {
-    const eventName = "pointer" + (isActive ? "enter" : "leave");
-    const callbackName = "onHover" + (isActive ? "Start" : "End");
-    const handleEvent = (event, info) => {
-        if (event.type === "touch" || isDragActive())
-            return;
-        const props = node.getProps();
-        if (node.animationState && props.whileHover) {
-            node.animationState.setActive("whileHover", isActive);
-        }
-        if (props[callbackName]) {
-            frame.update(() => props[callbackName](event, info));
-        }
-    };
-    return addPointerEvent(node.current, eventName, handleEvent, {
-        passive: !node.getProps()[callbackName],
-    });
-}
-class HoverGesture extends Feature {
-    mount() {
-        this.unmount = pipe(addHoverEvent(this.node, true), addHoverEvent(this.node, false));
-    }
-    unmount() { }
-}
-
-export { HoverGesture };

package/esm/node_modules/framer-motion/dist/es/gestures/pan/PanSession.js

@@ -1,148 +0,0 @@
-import { extractEventInfo } from '../../events/event-info.js';
-import { secondsToMilliseconds, millisecondsToSeconds } from '../../utils/time-conversion.js';
-import { addPointerEvent } from '../../events/add-pointer-event.js';
-import { pipe } from '../../utils/pipe.js';
-import { distance2D } from '../../utils/distance.js';
-import { isPrimaryPointer } from '../../events/utils/is-primary-pointer.js';
-import { frame, cancelFrame, frameData } from '../../frameloop/frame.js';
-
-/**
- * @internal
- */
-class PanSession {
-    constructor(event, handlers, { transformPagePoint } = {}) {
-        /**
-         * @internal
-         */
-        this.startEvent = null;
-        /**
-         * @internal
-         */
-        this.lastMoveEvent = null;
-        /**
-         * @internal
-         */
-        this.lastMoveEventInfo = null;
-        /**
-         * @internal
-         */
-        this.handlers = {};
-        this.updatePoint = () => {
-            if (!(this.lastMoveEvent && this.lastMoveEventInfo))
-                return;
-            const info = getPanInfo(this.lastMoveEventInfo, this.history);
-            const isPanStarted = this.startEvent !== null;
-            // Only start panning if the offset is larger than 3 pixels. If we make it
-            // any larger than this we'll want to reset the pointer history
-            // on the first update to avoid visual snapping to the cursoe.
-            const isDistancePastThreshold = distance2D(info.offset, { x: 0, y: 0 }) >= 3;
-            if (!isPanStarted && !isDistancePastThreshold)
-                return;
-            const { point } = info;
-            const { timestamp } = frameData;
-            this.history.push({ ...point, timestamp });
-            const { onStart, onMove } = this.handlers;
-            if (!isPanStarted) {
-                onStart && onStart(this.lastMoveEvent, info);
-                this.startEvent = this.lastMoveEvent;
-            }
-            onMove && onMove(this.lastMoveEvent, info);
-        };
-        this.handlePointerMove = (event, info) => {
-            this.lastMoveEvent = event;
-            this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);
-            // Throttle mouse move event to once per frame
-            frame.update(this.updatePoint, true);
-        };
-        this.handlePointerUp = (event, info) => {
-            this.end();
-            if (!(this.lastMoveEvent && this.lastMoveEventInfo))
-                return;
-            const { onEnd, onSessionEnd } = this.handlers;
-            const panInfo = getPanInfo(event.type === "pointercancel"
-                ? this.lastMoveEventInfo
-                : transformPoint(info, this.transformPagePoint), this.history);
-            if (this.startEvent && onEnd) {
-                onEnd(event, panInfo);
-            }
-            onSessionEnd && onSessionEnd(event, panInfo);
-        };
-        // If we have more than one touch, don't start detecting this gesture
-        if (!isPrimaryPointer(event))
-            return;
-        this.handlers = handlers;
-        this.transformPagePoint = transformPagePoint;
-        const info = extractEventInfo(event);
-        const initialInfo = transformPoint(info, this.transformPagePoint);
-        const { point } = initialInfo;
-        const { timestamp } = frameData;
-        this.history = [{ ...point, timestamp }];
-        const { onSessionStart } = handlers;
-        onSessionStart &&
-            onSessionStart(event, getPanInfo(initialInfo, this.history));
-        this.removeListeners = pipe(addPointerEvent(window, "pointermove", this.handlePointerMove), addPointerEvent(window, "pointerup", this.handlePointerUp), addPointerEvent(window, "pointercancel", this.handlePointerUp));
-    }
-    updateHandlers(handlers) {
-        this.handlers = handlers;
-    }
-    end() {
-        this.removeListeners && this.removeListeners();
-        cancelFrame(this.updatePoint);
-    }
-}
-function transformPoint(info, transformPagePoint) {
-    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;
-}
-function subtractPoint(a, b) {
-    return { x: a.x - b.x, y: a.y - b.y };
-}
-function getPanInfo({ point }, history) {
-    return {
-        point,
-        delta: subtractPoint(point, lastDevicePoint(history)),
-        offset: subtractPoint(point, startDevicePoint(history)),
-        velocity: getVelocity(history, 0.1),
-    };
-}
-function startDevicePoint(history) {
-    return history[0];
-}
-function lastDevicePoint(history) {
-    return history[history.length - 1];
-}
-function getVelocity(history, timeDelta) {
-    if (history.length < 2) {
-        return { x: 0, y: 0 };
-    }
-    let i = history.length - 1;
-    let timestampedPoint = null;
-    const lastPoint = lastDevicePoint(history);
-    while (i >= 0) {
-        timestampedPoint = history[i];
-        if (lastPoint.timestamp - timestampedPoint.timestamp >
-            secondsToMilliseconds(timeDelta)) {
-            break;
-        }
-        i--;
-    }
-    if (!timestampedPoint) {
-        return { x: 0, y: 0 };
-    }
-    const time = millisecondsToSeconds(lastPoint.timestamp - timestampedPoint.timestamp);
-    if (time === 0) {
-        return { x: 0, y: 0 };
-    }
-    const currentVelocity = {
-        x: (lastPoint.x - timestampedPoint.x) / time,
-        y: (lastPoint.y - timestampedPoint.y) / time,
-    };
-    if (currentVelocity.x === Infinity) {
-        currentVelocity.x = 0;
-    }
-    if (currentVelocity.y === Infinity) {
-        currentVelocity.y = 0;
-    }
-    return currentVelocity;
-}
-
-export { PanSession };

package/esm/node_modules/framer-motion/dist/es/gestures/pan/index.js

@@ -1,46 +0,0 @@
-import { PanSession } from './PanSession.js';
-import { addPointerEvent } from '../../events/add-pointer-event.js';
-import { Feature } from '../../motion/features/Feature.js';
-import { noop } from '../../utils/noop.js';
-import { frame } from '../../frameloop/frame.js';
-
-const asyncHandler = (handler) => (event, info) => {
-    if (handler) {
-        frame.update(() => handler(event, info));
-    }
-};
-class PanGesture extends Feature {
-    constructor() {
-        super(...arguments);
-        this.removePointerDownListener = noop;
-    }
-    onPointerDown(pointerDownEvent) {
-        this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), { transformPagePoint: this.node.getTransformPagePoint() });
-    }
-    createPanHandlers() {
-        const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();
-        return {
-            onSessionStart: asyncHandler(onPanSessionStart),
-            onStart: asyncHandler(onPanStart),
-            onMove: onPan,
-            onEnd: (event, info) => {
-                delete this.session;
-                if (onPanEnd) {
-                    frame.update(() => onPanEnd(event, info));
-                }
-            },
-        };
-    }
-    mount() {
-        this.removePointerDownListener = addPointerEvent(this.node.current, "pointerdown", (event) => this.onPointerDown(event));
-    }
-    update() {
-        this.session && this.session.updateHandlers(this.createPanHandlers());
-    }
-    unmount() {
-        this.removePointerDownListener();
-        this.session && this.session.end();
-    }
-}
-
-export { PanGesture };

package/esm/node_modules/framer-motion/dist/es/gestures/press.js

@@ -1,120 +0,0 @@
-import { extractEventInfo } from '../events/event-info.js';
-import { addDomEvent } from '../events/add-dom-event.js';
-import { addPointerEvent } from '../events/add-pointer-event.js';
-import { Feature } from '../motion/features/Feature.js';
-import { pipe } from '../utils/pipe.js';
-import { isDragActive } from './drag/utils/lock.js';
-import { isNodeOrChild } from './utils/is-node-or-child.js';
-import { noop } from '../utils/noop.js';
-import { frame } from '../frameloop/frame.js';
-
-function fireSyntheticPointerEvent(name, handler) {
-    if (!handler)
-        return;
-    const syntheticPointerEvent = new PointerEvent("pointer" + name);
-    handler(syntheticPointerEvent, extractEventInfo(syntheticPointerEvent));
-}
-class PressGesture extends Feature {
-    constructor() {
-        super(...arguments);
-        this.removeStartListeners = noop;
-        this.removeEndListeners = noop;
-        this.removeAccessibleListeners = noop;
-        this.startPointerPress = (startEvent, startInfo) => {
-            this.removeEndListeners();
-            if (this.isPressing)
-                return;
-            const props = this.node.getProps();
-            const endPointerPress = (endEvent, endInfo) => {
-                if (!this.checkPressEnd())
-                    return;
-                const { onTap, onTapCancel } = this.node.getProps();
-                frame.update(() => {
-                    /**
-                     * We only count this as a tap gesture if the event.target is the same
-                     * as, or a child of, this component's element
-                     */
-                    !isNodeOrChild(this.node.current, endEvent.target)
-                        ? onTapCancel && onTapCancel(endEvent, endInfo)
-                        : onTap && onTap(endEvent, endInfo);
-                });
-            };
-            const removePointerUpListener = addPointerEvent(window, "pointerup", endPointerPress, { passive: !(props.onTap || props["onPointerUp"]) });
-            const removePointerCancelListener = addPointerEvent(window, "pointercancel", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo), { passive: !(props.onTapCancel || props["onPointerCancel"]) });
-            this.removeEndListeners = pipe(removePointerUpListener, removePointerCancelListener);
-            this.startPress(startEvent, startInfo);
-        };
-        this.startAccessiblePress = () => {
-            const handleKeydown = (keydownEvent) => {
-                if (keydownEvent.key !== "Enter" || this.isPressing)
-                    return;
-                const handleKeyup = (keyupEvent) => {
-                    if (keyupEvent.key !== "Enter" || !this.checkPressEnd())
-                        return;
-                    fireSyntheticPointerEvent("up", (event, info) => {
-                        const { onTap } = this.node.getProps();
-                        if (onTap) {
-                            frame.update(() => onTap(event, info));
-                        }
-                    });
-                };
-                this.removeEndListeners();
-                this.removeEndListeners = addDomEvent(this.node.current, "keyup", handleKeyup);
-                fireSyntheticPointerEvent("down", (event, info) => {
-                    this.startPress(event, info);
-                });
-            };
-            const removeKeydownListener = addDomEvent(this.node.current, "keydown", handleKeydown);
-            const handleBlur = () => {
-                if (!this.isPressing)
-                    return;
-                fireSyntheticPointerEvent("cancel", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo));
-            };
-            const removeBlurListener = addDomEvent(this.node.current, "blur", handleBlur);
-            this.removeAccessibleListeners = pipe(removeKeydownListener, removeBlurListener);
-        };
-    }
-    startPress(event, info) {
-        this.isPressing = true;
-        const { onTapStart, whileTap } = this.node.getProps();
-        /**
-         * Ensure we trigger animations before firing event callback
-         */
-        if (whileTap && this.node.animationState) {
-            this.node.animationState.setActive("whileTap", true);
-        }
-        if (onTapStart) {
-            frame.update(() => onTapStart(event, info));
-        }
-    }
-    checkPressEnd() {
-        this.removeEndListeners();
-        this.isPressing = false;
-        const props = this.node.getProps();
-        if (props.whileTap && this.node.animationState) {
-            this.node.animationState.setActive("whileTap", false);
-        }
-        return !isDragActive();
-    }
-    cancelPress(event, info) {
-        if (!this.checkPressEnd())
-            return;
-        const { onTapCancel } = this.node.getProps();
-        if (onTapCancel) {
-            frame.update(() => onTapCancel(event, info));
-        }
-    }
-    mount() {
-        const props = this.node.getProps();
-        const removePointerListener = addPointerEvent(this.node.current, "pointerdown", this.startPointerPress, { passive: !(props.onTapStart || props["onPointerStart"]) });
-        const removeFocusListener = addDomEvent(this.node.current, "focus", this.startAccessiblePress);
-        this.removeStartListeners = pipe(removePointerListener, removeFocusListener);
-    }
-    unmount() {
-        this.removeStartListeners();
-        this.removeEndListeners();
-        this.removeAccessibleListeners();
-    }
-}
-
-export { PressGesture };

package/esm/node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.js

@@ -1,20 +0,0 @@
-/**
- * Recursively traverse up the tree to check whether the provided child node
- * is the parent or a descendant of it.
- *
- * @param parent - Element to find
- * @param child - Element to test against parent
- */
-const isNodeOrChild = (parent, child) => {
-    if (!child) {
-        return false;
-    }
-    else if (parent === child) {
-        return true;
-    }
-    else {
-        return isNodeOrChild(parent, child.parentElement);
-    }
-};
-
-export { isNodeOrChild };

package/esm/node_modules/framer-motion/dist/es/motion/features/Feature.js

@@ -1,9 +0,0 @@
-class Feature {
-    constructor(node) {
-        this.isMounted = false;
-        this.node = node;
-    }
-    update() { }
-}
-
-export { Feature };

package/esm/node_modules/framer-motion/dist/es/motion/features/animation/exit.js

@@ -1,31 +0,0 @@
-import { Feature } from '../Feature.js';
-
-let id = 0;
-class ExitAnimationFeature extends Feature {
-    constructor() {
-        super(...arguments);
-        this.id = id++;
-    }
-    update() {
-        if (!this.node.presenceContext)
-            return;
-        const { isPresent, onExitComplete, custom } = this.node.presenceContext;
-        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};
-        if (!this.node.animationState || isPresent === prevIsPresent) {
-            return;
-        }
-        const exitAnimation = this.node.animationState.setActive("exit", !isPresent, { custom: custom !== null && custom !== void 0 ? custom : this.node.getProps().custom });
-        if (onExitComplete && !isPresent) {
-            exitAnimation.then(() => onExitComplete(this.id));
-        }
-    }
-    mount() {
-        const { register } = this.node.presenceContext || {};
-        if (register) {
-            this.unmount = register(this.id);
-        }
-    }
-    unmount() { }
-}
-
-export { ExitAnimationFeature };