@teamturing/react-kit 2.51.3 → 2.51.5

package/esm/node_modules/framer-motion/dist/es/motion/utils/use-visual-state.js

@@ -1,81 +0,0 @@
-import { useContext } from 'react';
-import { isAnimationControls } from '../../animation/utils/is-animation-controls.js';
-import { PresenceContext } from '../../context/PresenceContext.js';
-import { resolveVariantFromProps } from '../../render/utils/resolve-variants.js';
-import { useConstant } from '../../utils/use-constant.js';
-import { resolveMotionValue } from '../../value/utils/resolve-motion-value.js';
-import { MotionContext } from '../../context/MotionContext/index.js';
-import { isControllingVariants, isVariantNode } from '../../render/utils/is-controlling-variants.js';
-
-function makeState({ scrapeMotionValuesFromProps, createRenderState, onMount, }, props, context, presenceContext) {
-    const state = {
-        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),
-        renderState: createRenderState(),
-    };
-    if (onMount) {
-        state.mount = (instance) => onMount(props, instance, state);
-    }
-    return state;
-}
-const makeUseVisualState = (config) => (props, isStatic) => {
-    const context = useContext(MotionContext);
-    const presenceContext = useContext(PresenceContext);
-    const make = () => makeState(config, props, context, presenceContext);
-    return isStatic ? make() : useConstant(make);
-};
-function makeLatestValues(props, context, presenceContext, scrapeMotionValues) {
-    const values = {};
-    const motionValues = scrapeMotionValues(props, {});
-    for (const key in motionValues) {
-        values[key] = resolveMotionValue(motionValues[key]);
-    }
-    let { initial, animate } = props;
-    const isControllingVariants$1 = isControllingVariants(props);
-    const isVariantNode$1 = isVariantNode(props);
-    if (context &&
-        isVariantNode$1 &&
-        !isControllingVariants$1 &&
-        props.inherit !== false) {
-        if (initial === undefined)
-            initial = context.initial;
-        if (animate === undefined)
-            animate = context.animate;
-    }
-    let isInitialAnimationBlocked = presenceContext
-        ? presenceContext.initial === false
-        : false;
-    isInitialAnimationBlocked = isInitialAnimationBlocked || initial === false;
-    const variantToSet = isInitialAnimationBlocked ? animate : initial;
-    if (variantToSet &&
-        typeof variantToSet !== "boolean" &&
-        !isAnimationControls(variantToSet)) {
-        const list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];
-        list.forEach((definition) => {
-            const resolved = resolveVariantFromProps(props, definition);
-            if (!resolved)
-                return;
-            const { transitionEnd, transition, ...target } = resolved;
-            for (const key in target) {
-                let valueTarget = target[key];
-                if (Array.isArray(valueTarget)) {
-                    /**
-                     * Take final keyframe if the initial animation is blocked because
-                     * we want to initialise at the end of that blocked animation.
-                     */
-                    const index = isInitialAnimationBlocked
-                        ? valueTarget.length - 1
-                        : 0;
-                    valueTarget = valueTarget[index];
-                }
-                if (valueTarget !== null) {
-                    values[key] = valueTarget;
-                }
-            }
-            for (const key in transitionEnd)
-                values[key] = transitionEnd[key];
-        });
-    }
-    return values;
-}
-
-export { makeUseVisualState };

package/esm/node_modules/framer-motion/dist/es/motion/utils/valid-prop.js

@@ -1,59 +0,0 @@
-/**
- * A list of all valid MotionProps.
- *
- * @privateRemarks
- * This doesn't throw if a `MotionProp` name is missing - it should.
- */
-const validMotionProps = new Set([
-    "animate",
-    "exit",
-    "variants",
-    "initial",
-    "style",
-    "values",
-    "variants",
-    "transition",
-    "transformTemplate",
-    "transformValues",
-    "custom",
-    "inherit",
-    "onLayoutAnimationStart",
-    "onLayoutAnimationComplete",
-    "onLayoutMeasure",
-    "onBeforeLayoutMeasure",
-    "onAnimationStart",
-    "onAnimationComplete",
-    "onUpdate",
-    "onDragStart",
-    "onDrag",
-    "onDragEnd",
-    "onMeasureDragConstraints",
-    "onDirectionLock",
-    "onDragTransitionEnd",
-    "_dragX",
-    "_dragY",
-    "onHoverStart",
-    "onHoverEnd",
-    "onViewportEnter",
-    "onViewportLeave",
-    "ignoreStrict",
-    "viewport",
-]);
-/**
- * Check whether a prop name is a valid `MotionProp` key.
- *
- * @param key - Name of the property to check
- * @returns `true` is key is a valid `MotionProp`.
- *
- * @public
- */
-function isValidMotionProp(key) {
-    return (key.startsWith("while") ||
-        (key.startsWith("drag") && key !== "draggable") ||
-        key.startsWith("layout") ||
-        key.startsWith("onTap") ||
-        key.startsWith("onPan") ||
-        validMotionProps.has(key));
-}
-
-export { isValidMotionProp };

package/esm/node_modules/framer-motion/dist/es/projection/animation/mix-values.js

@@ -1,93 +0,0 @@
-import { circOut } from '../../easing/circ.js';
-import { progress } from '../../utils/progress.js';
-import { mix } from '../../utils/mix.js';
-import { noop } from '../../utils/noop.js';
-import { percent, px } from '../../value/types/numbers/units.js';
-
-const borders = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"];
-const numBorders = borders.length;
-const asNumber = (value) => typeof value === "string" ? parseFloat(value) : value;
-const isPx = (value) => typeof value === "number" || px.test(value);
-function mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {
-    if (shouldCrossfadeOpacity) {
-        target.opacity = mix(0, 
-        // TODO Reinstate this if only child
-        lead.opacity !== undefined ? lead.opacity : 1, easeCrossfadeIn(progress));
-        target.opacityExit = mix(follow.opacity !== undefined ? follow.opacity : 1, 0, easeCrossfadeOut(progress));
-    }
-    else if (isOnlyMember) {
-        target.opacity = mix(follow.opacity !== undefined ? follow.opacity : 1, lead.opacity !== undefined ? lead.opacity : 1, progress);
-    }
-    /**
-     * Mix border radius
-     */
-    for (let i = 0; i < numBorders; i++) {
-        const borderLabel = `border${borders[i]}Radius`;
-        let followRadius = getRadius(follow, borderLabel);
-        let leadRadius = getRadius(lead, borderLabel);
-        if (followRadius === undefined && leadRadius === undefined)
-            continue;
-        followRadius || (followRadius = 0);
-        leadRadius || (leadRadius = 0);
-        const canMix = followRadius === 0 ||
-            leadRadius === 0 ||
-            isPx(followRadius) === isPx(leadRadius);
-        if (canMix) {
-            target[borderLabel] = Math.max(mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);
-            if (percent.test(leadRadius) || percent.test(followRadius)) {
-                target[borderLabel] += "%";
-            }
-        }
-        else {
-            target[borderLabel] = leadRadius;
-        }
-    }
-    /**
-     * Mix rotation
-     */
-    if (follow.rotate || lead.rotate) {
-        target.rotate = mix(follow.rotate || 0, lead.rotate || 0, progress);
-    }
-}
-function getRadius(values, radiusName) {
-    return values[radiusName] !== undefined
-        ? values[radiusName]
-        : values.borderRadius;
-}
-// /**
-//  * We only want to mix the background color if there's a follow element
-//  * that we're not crossfading opacity between. For instance with switch
-//  * AnimateSharedLayout animations, this helps the illusion of a continuous
-//  * element being animated but also cuts down on the number of paints triggered
-//  * for elements where opacity is doing that work for us.
-//  */
-// if (
-//     !hasFollowElement &&
-//     latestLeadValues.backgroundColor &&
-//     latestFollowValues.backgroundColor
-// ) {
-//     /**
-//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.
-//      * We could probably create a mixer that runs at the start of the animation but
-//      * the idea behind the crossfader is that it runs dynamically between two potentially
-//      * changing targets (ie opacity or borderRadius may be animating independently via variants)
-//      */
-//     leadState.backgroundColor = followState.backgroundColor = mixColor(
-//         latestFollowValues.backgroundColor as string,
-//         latestLeadValues.backgroundColor as string
-//     )(p)
-// }
-const easeCrossfadeIn = compress(0, 0.5, circOut);
-const easeCrossfadeOut = compress(0.5, 0.95, noop);
-function compress(min, max, easing) {
-    return (p) => {
-        // Could replace ifs with clamp
-        if (p < min)
-            return 0;
-        if (p > max)
-            return 1;
-        return easing(progress(min, max, p));
-    };
-}
-
-export { mixValues };

package/esm/node_modules/framer-motion/dist/es/projection/geometry/conversion.js

@@ -1,33 +0,0 @@
-/**
- * Bounding boxes tend to be defined as top, left, right, bottom. For various operations
- * it's easier to consider each axis individually. This function returns a bounding box
- * as a map of single-axis min/max values.
- */
-function convertBoundingBoxToBox({ top, left, right, bottom, }) {
-    return {
-        x: { min: left, max: right },
-        y: { min: top, max: bottom },
-    };
-}
-function convertBoxToBoundingBox({ x, y }) {
-    return { top: y.min, right: x.max, bottom: y.max, left: x.min };
-}
-/**
- * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function
- * provided by Framer to allow measured points to be corrected for device scaling. This is used
- * when measuring DOM elements and DOM event points.
- */
-function transformBoxPoints(point, transformPoint) {
-    if (!transformPoint)
-        return point;
-    const topLeft = transformPoint({ x: point.left, y: point.top });
-    const bottomRight = transformPoint({ x: point.right, y: point.bottom });
-    return {
-        top: topLeft.y,
-        left: topLeft.x,
-        bottom: bottomRight.y,
-        right: bottomRight.x,
-    };
-}
-
-export { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };

package/esm/node_modules/framer-motion/dist/es/projection/geometry/copy.js

@@ -1,20 +0,0 @@
-/**
- * Reset an axis to the provided origin box.
- *
- * This is a mutative operation.
- */
-function copyAxisInto(axis, originAxis) {
-    axis.min = originAxis.min;
-    axis.max = originAxis.max;
-}
-/**
- * Reset a box to the provided origin box.
- *
- * This is a mutative operation.
- */
-function copyBoxInto(box, originBox) {
-    copyAxisInto(box.x, originBox.x);
-    copyAxisInto(box.y, originBox.y);
-}
-
-export { copyAxisInto, copyBoxInto };

package/esm/node_modules/framer-motion/dist/es/projection/geometry/delta-apply.js

@@ -1,122 +0,0 @@
-import { mix } from '../../utils/mix.js';
-import { hasTransform } from '../utils/has-transform.js';
-
-/**
- * Scales a point based on a factor and an originPoint
- */
-function scalePoint(point, scale, originPoint) {
-    const distanceFromOrigin = point - originPoint;
-    const scaled = scale * distanceFromOrigin;
-    return originPoint + scaled;
-}
-/**
- * Applies a translate/scale delta to a point
- */
-function applyPointDelta(point, translate, scale, originPoint, boxScale) {
-    if (boxScale !== undefined) {
-        point = scalePoint(point, boxScale, originPoint);
-    }
-    return scalePoint(point, scale, originPoint) + translate;
-}
-/**
- * Applies a translate/scale delta to an axis
- */
-function applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {
-    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);
-    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);
-}
-/**
- * Applies a translate/scale delta to a box
- */
-function applyBoxDelta(box, { x, y }) {
-    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);
-    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);
-}
-/**
- * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms
- * in a tree upon our box before then calculating how to project it into our desired viewport-relative box
- *
- * This is the final nested loop within updateLayoutDelta for future refactoring
- */
-function applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {
-    const treeLength = treePath.length;
-    if (!treeLength)
-        return;
-    // Reset the treeScale
-    treeScale.x = treeScale.y = 1;
-    let node;
-    let delta;
-    for (let i = 0; i < treeLength; i++) {
-        node = treePath[i];
-        delta = node.projectionDelta;
-        /**
-         * TODO: Prefer to remove this, but currently we have motion components with
-         * display: contents in Framer.
-         */
-        const instance = node.instance;
-        if (instance &&
-            instance.style &&
-            instance.style.display === "contents") {
-            continue;
-        }
-        if (isSharedTransition &&
-            node.options.layoutScroll &&
-            node.scroll &&
-            node !== node.root) {
-            transformBox(box, {
-                x: -node.scroll.offset.x,
-                y: -node.scroll.offset.y,
-            });
-        }
-        if (delta) {
-            // Incoporate each ancestor's scale into a culmulative treeScale for this component
-            treeScale.x *= delta.x.scale;
-            treeScale.y *= delta.y.scale;
-            // Apply each ancestor's calculated delta into this component's recorded layout box
-            applyBoxDelta(box, delta);
-        }
-        if (isSharedTransition && hasTransform(node.latestValues)) {
-            transformBox(box, node.latestValues);
-        }
-    }
-    /**
-     * Snap tree scale back to 1 if it's within a non-perceivable threshold.
-     * This will help reduce useless scales getting rendered.
-     */
-    treeScale.x = snapToDefault(treeScale.x);
-    treeScale.y = snapToDefault(treeScale.y);
-}
-function snapToDefault(scale) {
-    if (Number.isInteger(scale))
-        return scale;
-    return scale > 1.0000000000001 || scale < 0.999999999999 ? scale : 1;
-}
-function translateAxis(axis, distance) {
-    axis.min = axis.min + distance;
-    axis.max = axis.max + distance;
-}
-/**
- * Apply a transform to an axis from the latest resolved motion values.
- * This function basically acts as a bridge between a flat motion value map
- * and applyAxisDelta
- */
-function transformAxis(axis, transforms, [key, scaleKey, originKey]) {
-    const axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;
-    const originPoint = mix(axis.min, axis.max, axisOrigin);
-    // Apply the axis delta to the final axis
-    applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);
-}
-/**
- * The names of the motion values we want to apply as translation, scale and origin.
- */
-const xKeys = ["x", "scaleX", "originX"];
-const yKeys = ["y", "scaleY", "originY"];
-/**
- * Apply a transform to a box from the latest resolved motion values.
- */
-function transformBox(box, transform) {
-    transformAxis(box.x, transform, xKeys);
-    transformAxis(box.y, transform, yKeys);
-}
-
-export { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };

package/esm/node_modules/framer-motion/dist/es/projection/geometry/delta-calc.js

@@ -1,41 +0,0 @@
-import { mix } from '../../utils/mix.js';
-
-function calcLength(axis) {
-    return axis.max - axis.min;
-}
-function isNear(value, target = 0, maxDistance = 0.01) {
-    return Math.abs(value - target) <= maxDistance;
-}
-function calcAxisDelta(delta, source, target, origin = 0.5) {
-    delta.origin = origin;
-    delta.originPoint = mix(source.min, source.max, delta.origin);
-    delta.scale = calcLength(target) / calcLength(source);
-    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))
-        delta.scale = 1;
-    delta.translate =
-        mix(target.min, target.max, delta.origin) - delta.originPoint;
-    if (isNear(delta.translate) || isNaN(delta.translate))
-        delta.translate = 0;
-}
-function calcBoxDelta(delta, source, target, origin) {
-    calcAxisDelta(delta.x, source.x, target.x, origin ? origin.originX : undefined);
-    calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : undefined);
-}
-function calcRelativeAxis(target, relative, parent) {
-    target.min = parent.min + relative.min;
-    target.max = target.min + calcLength(relative);
-}
-function calcRelativeBox(target, relative, parent) {
-    calcRelativeAxis(target.x, relative.x, parent.x);
-    calcRelativeAxis(target.y, relative.y, parent.y);
-}
-function calcRelativeAxisPosition(target, layout, parent) {
-    target.min = layout.min - parent.min;
-    target.max = target.min + calcLength(layout);
-}
-function calcRelativePosition(target, layout, parent) {
-    calcRelativeAxisPosition(target.x, layout.x, parent.x);
-    calcRelativeAxisPosition(target.y, layout.y, parent.y);
-}
-
-export { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };

package/esm/node_modules/framer-motion/dist/es/projection/geometry/delta-remove.js

@@ -1,54 +0,0 @@
-import { mix } from '../../utils/mix.js';
-import { percent } from '../../value/types/numbers/units.js';
-import { scalePoint } from './delta-apply.js';
-
-/**
- * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse
- */
-function removePointDelta(point, translate, scale, originPoint, boxScale) {
-    point -= translate;
-    point = scalePoint(point, 1 / scale, originPoint);
-    if (boxScale !== undefined) {
-        point = scalePoint(point, 1 / boxScale, originPoint);
-    }
-    return point;
-}
-/**
- * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse
- */
-function removeAxisDelta(axis, translate = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {
-    if (percent.test(translate)) {
-        translate = parseFloat(translate);
-        const relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);
-        translate = relativeProgress - sourceAxis.min;
-    }
-    if (typeof translate !== "number")
-        return;
-    let originPoint = mix(originAxis.min, originAxis.max, origin);
-    if (axis === originAxis)
-        originPoint -= translate;
-    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);
-    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);
-}
-/**
- * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse
- * and acts as a bridge between motion values and removeAxisDelta
- */
-function removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {
-    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);
-}
-/**
- * The names of the motion values we want to apply as translation, scale and origin.
- */
-const xKeys = ["x", "scaleX", "originX"];
-const yKeys = ["y", "scaleY", "originY"];
-/**
- * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse
- * and acts as a bridge between motion values and removeAxisDelta
- */
-function removeBoxTransforms(box, transforms, originBox, sourceBox) {
-    removeAxisTransforms(box.x, transforms, xKeys, originBox ? originBox.x : undefined, sourceBox ? sourceBox.x : undefined);
-    removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : undefined, sourceBox ? sourceBox.y : undefined);
-}
-
-export { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };

package/esm/node_modules/framer-motion/dist/es/projection/geometry/models.js

@@ -1,17 +0,0 @@
-const createAxisDelta = () => ({
-    translate: 0,
-    scale: 1,
-    origin: 0,
-    originPoint: 0,
-});
-const createDelta = () => ({
-    x: createAxisDelta(),
-    y: createAxisDelta(),
-});
-const createAxis = () => ({ min: 0, max: 0 });
-const createBox = () => ({
-    x: createAxis(),
-    y: createAxis(),
-});
-
-export { createAxis, createAxisDelta, createBox, createDelta };

package/esm/node_modules/framer-motion/dist/es/projection/geometry/utils.js

@@ -1,25 +0,0 @@
-import { calcLength } from './delta-calc.js';
-
-function isAxisDeltaZero(delta) {
-    return delta.translate === 0 && delta.scale === 1;
-}
-function isDeltaZero(delta) {
-    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);
-}
-function boxEquals(a, b) {
-    return (a.x.min === b.x.min &&
-        a.x.max === b.x.max &&
-        a.y.min === b.y.min &&
-        a.y.max === b.y.max);
-}
-function boxEqualsRounded(a, b) {
-    return (Math.round(a.x.min) === Math.round(b.x.min) &&
-        Math.round(a.x.max) === Math.round(b.x.max) &&
-        Math.round(a.y.min) === Math.round(b.y.min) &&
-        Math.round(a.y.max) === Math.round(b.y.max));
-}
-function aspectRatio(box) {
-    return calcLength(box.x) / calcLength(box.y);
-}
-
-export { aspectRatio, boxEquals, boxEqualsRounded, isDeltaZero };

package/esm/node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.js

@@ -1,13 +0,0 @@
-import { createProjectionNode } from './create-projection-node.js';
-import { addDomEvent } from '../../events/add-dom-event.js';
-
-const DocumentProjectionNode = createProjectionNode({
-    attachResizeListener: (ref, notify) => addDomEvent(ref, "resize", notify),
-    measureScroll: () => ({
-        x: document.documentElement.scrollLeft || document.body.scrollLeft,
-        y: document.documentElement.scrollTop || document.body.scrollTop,
-    }),
-    checkIsScrollRoot: () => true,
-});
-
-export { DocumentProjectionNode };

package/esm/node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.js

@@ -1,27 +0,0 @@
-import { createProjectionNode } from './create-projection-node.js';
-import { DocumentProjectionNode } from './DocumentProjectionNode.js';
-
-const rootProjectionNode = {
-    current: undefined,
-};
-const HTMLProjectionNode = createProjectionNode({
-    measureScroll: (instance) => ({
-        x: instance.scrollLeft,
-        y: instance.scrollTop,
-    }),
-    defaultParent: () => {
-        if (!rootProjectionNode.current) {
-            const documentNode = new DocumentProjectionNode({});
-            documentNode.mount(window);
-            documentNode.setOptions({ layoutScroll: true });
-            rootProjectionNode.current = documentNode;
-        }
-        return rootProjectionNode.current;
-    },
-    resetTransform: (instance, value) => {
-        instance.style.transform = value !== undefined ? value : "none";
-    },
-    checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === "fixed"),
-});
-
-export { HTMLProjectionNode, rootProjectionNode };