@teamturing/react-kit 2.51.3 → 2.51.4

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

@@ -1,19 +0,0 @@
-/**
- * This should only ever be modified on the client otherwise it'll
- * persist through server requests. If we need instanced states we
- * could lazy-init via root.
- */
-const globalProjectionState = {
-    /**
-     * Global flag as to whether the tree has animated since the last time
-     * we resized the window
-     */
-    hasAnimatedSinceResize: true,
-    /**
-     * We set this to true once, on the first update. Any nodes added to the tree beyond that
-     * update will be given a `data-projection-id` attribute.
-     */
-    hasEverUpdated: false,
-};
-
-export { globalProjectionState };

package/esm/node_modules/framer-motion/dist/es/projection/shared/stack.js

@@ -1,112 +0,0 @@
-import { addUniqueItem, removeItem } from '../../utils/array.js';
-
-class NodeStack {
-    constructor() {
-        this.members = [];
-    }
-    add(node) {
-        addUniqueItem(this.members, node);
-        node.scheduleRender();
-    }
-    remove(node) {
-        removeItem(this.members, node);
-        if (node === this.prevLead) {
-            this.prevLead = undefined;
-        }
-        if (node === this.lead) {
-            const prevLead = this.members[this.members.length - 1];
-            if (prevLead) {
-                this.promote(prevLead);
-            }
-        }
-    }
-    relegate(node) {
-        const indexOfNode = this.members.findIndex((member) => node === member);
-        if (indexOfNode === 0)
-            return false;
-        /**
-         * Find the next projection node that is present
-         */
-        let prevLead;
-        for (let i = indexOfNode; i >= 0; i--) {
-            const member = this.members[i];
-            if (member.isPresent !== false) {
-                prevLead = member;
-                break;
-            }
-        }
-        if (prevLead) {
-            this.promote(prevLead);
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    promote(node, preserveFollowOpacity) {
-        const prevLead = this.lead;
-        if (node === prevLead)
-            return;
-        this.prevLead = prevLead;
-        this.lead = node;
-        node.show();
-        if (prevLead) {
-            prevLead.instance && prevLead.scheduleRender();
-            node.scheduleRender();
-            node.resumeFrom = prevLead;
-            if (preserveFollowOpacity) {
-                node.resumeFrom.preserveOpacity = true;
-            }
-            if (prevLead.snapshot) {
-                node.snapshot = prevLead.snapshot;
-                node.snapshot.latestValues =
-                    prevLead.animationValues || prevLead.latestValues;
-            }
-            if (node.root && node.root.isUpdating) {
-                node.isLayoutDirty = true;
-            }
-            const { crossfade } = node.options;
-            if (crossfade === false) {
-                prevLead.hide();
-            }
-            /**
-             * TODO:
-             *   - Test border radius when previous node was deleted
-             *   - boxShadow mixing
-             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)
-             *   - Shared between element A in transformed container and element B (transform stays the same or changes)
-             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)
-             * ---
-             *   - Crossfade opacity of root nodes
-             *   - layoutId changes after animation
-             *   - layoutId changes mid animation
-             */
-        }
-    }
-    exitAnimationComplete() {
-        this.members.forEach((node) => {
-            const { options, resumingFrom } = node;
-            options.onExitComplete && options.onExitComplete();
-            if (resumingFrom) {
-                resumingFrom.options.onExitComplete &&
-                    resumingFrom.options.onExitComplete();
-            }
-        });
-    }
-    scheduleRender() {
-        this.members.forEach((node) => {
-            node.instance && node.scheduleRender(false);
-        });
-    }
-    /**
-     * Clear any leads that have been removed this render to prevent them from being
-     * used in future animations and to prevent memory leaks
-     */
-    removeLeadSnapshot() {
-        if (this.lead && this.lead.snapshot) {
-            this.lead.snapshot = undefined;
-        }
-    }
-}
-
-export { NodeStack };

package/esm/node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.js

@@ -1,41 +0,0 @@
-import { px } from '../../value/types/numbers/units.js';
-
-function pixelsToPercent(pixels, axis) {
-    if (axis.max === axis.min)
-        return 0;
-    return (pixels / (axis.max - axis.min)) * 100;
-}
-/**
- * We always correct borderRadius as a percentage rather than pixels to reduce paints.
- * For example, if you are projecting a box that is 100px wide with a 10px borderRadius
- * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%
- * borderRadius in both states. If we animate between the two in pixels that will trigger
- * a paint each time. If we animate between the two in percentage we'll avoid a paint.
- */
-const correctBorderRadius = {
-    correct: (latest, node) => {
-        if (!node.target)
-            return latest;
-        /**
-         * If latest is a string, if it's a percentage we can return immediately as it's
-         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.
-         */
-        if (typeof latest === "string") {
-            if (px.test(latest)) {
-                latest = parseFloat(latest);
-            }
-            else {
-                return latest;
-            }
-        }
-        /**
-         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that
-         * pixel value as a percentage of each axis
-         */
-        const x = pixelsToPercent(latest, node.target.x);
-        const y = pixelsToPercent(latest, node.target.y);
-        return `${x}% ${y}%`;
-    },
-};
-
-export { correctBorderRadius, pixelsToPercent };

package/esm/node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.js

@@ -1,35 +0,0 @@
-import { mix } from '../../utils/mix.js';
-import { complex } from '../../value/types/complex/index.js';
-
-const correctBoxShadow = {
-    correct: (latest, { treeScale, projectionDelta }) => {
-        const original = latest;
-        const shadow = complex.parse(latest);
-        // TODO: Doesn't support multiple shadows
-        if (shadow.length > 5)
-            return original;
-        const template = complex.createTransformer(latest);
-        const offset = typeof shadow[0] !== "number" ? 1 : 0;
-        // Calculate the overall context scale
-        const xScale = projectionDelta.x.scale * treeScale.x;
-        const yScale = projectionDelta.y.scale * treeScale.y;
-        shadow[0 + offset] /= xScale;
-        shadow[1 + offset] /= yScale;
-        /**
-         * Ideally we'd correct x and y scales individually, but because blur and
-         * spread apply to both we have to take a scale average and apply that instead.
-         * We could potentially improve the outcome of this by incorporating the ratio between
-         * the two scales.
-         */
-        const averageScale = mix(xScale, yScale, 0.5);
-        // Blur
-        if (typeof shadow[2 + offset] === "number")
-            shadow[2 + offset] /= averageScale;
-        // Spread
-        if (typeof shadow[3 + offset] === "number")
-            shadow[3 + offset] /= averageScale;
-        return template(shadow);
-    },
-};
-
-export { correctBoxShadow };

package/esm/node_modules/framer-motion/dist/es/projection/styles/scale-correction.js

@@ -1,6 +0,0 @@
-const scaleCorrectors = {};
-function addScaleCorrector(correctors) {
-    Object.assign(scaleCorrectors, correctors);
-}
-
-export { addScaleCorrector, scaleCorrectors };

package/esm/node_modules/framer-motion/dist/es/projection/styles/transform.js

@@ -1,42 +0,0 @@
-function buildProjectionTransform(delta, treeScale, latestTransform) {
-    let transform = "";
-    /**
-     * The translations we use to calculate are always relative to the viewport coordinate space.
-     * But when we apply scales, we also scale the coordinate space of an element and its children.
-     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need
-     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.
-     */
-    const xTranslate = delta.x.translate / treeScale.x;
-    const yTranslate = delta.y.translate / treeScale.y;
-    if (xTranslate || yTranslate) {
-        transform = `translate3d(${xTranslate}px, ${yTranslate}px, 0) `;
-    }
-    /**
-     * Apply scale correction for the tree transform.
-     * This will apply scale to the screen-orientated axes.
-     */
-    if (treeScale.x !== 1 || treeScale.y !== 1) {
-        transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;
-    }
-    if (latestTransform) {
-        const { rotate, rotateX, rotateY } = latestTransform;
-        if (rotate)
-            transform += `rotate(${rotate}deg) `;
-        if (rotateX)
-            transform += `rotateX(${rotateX}deg) `;
-        if (rotateY)
-            transform += `rotateY(${rotateY}deg) `;
-    }
-    /**
-     * Apply scale to match the size of the element to the size we want it.
-     * This will apply scale to the element-orientated axes.
-     */
-    const elementScaleX = delta.x.scale * treeScale.x;
-    const elementScaleY = delta.y.scale * treeScale.y;
-    if (elementScaleX !== 1 || elementScaleY !== 1) {
-        transform += `scale(${elementScaleX}, ${elementScaleY})`;
-    }
-    return transform || "none";
-}
-
-export { buildProjectionTransform };

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

@@ -1,5 +0,0 @@
-function eachAxis(callback) {
-    return [callback("x"), callback("y")];
-}
-
-export { eachAxis };

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

@@ -1,24 +0,0 @@
-function isIdentityScale(scale) {
-    return scale === undefined || scale === 1;
-}
-function hasScale({ scale, scaleX, scaleY }) {
-    return (!isIdentityScale(scale) ||
-        !isIdentityScale(scaleX) ||
-        !isIdentityScale(scaleY));
-}
-function hasTransform(values) {
-    return (hasScale(values) ||
-        has2DTranslate(values) ||
-        values.z ||
-        values.rotate ||
-        values.rotateX ||
-        values.rotateY);
-}
-function has2DTranslate(values) {
-    return is2DTranslate(values.x) || is2DTranslate(values.y);
-}
-function is2DTranslate(value) {
-    return value && value !== "0%";
-}
-
-export { has2DTranslate, hasScale, hasTransform };

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

@@ -1,17 +0,0 @@
-import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.js';
-import { translateAxis } from '../geometry/delta-apply.js';
-
-function measureViewportBox(instance, transformPoint) {
-    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));
-}
-function measurePageBox(element, rootProjectionNode, transformPagePoint) {
-    const viewportBox = measureViewportBox(element, transformPagePoint);
-    const { scroll } = rootProjectionNode;
-    if (scroll) {
-        translateAxis(viewportBox.x, scroll.offset.x);
-        translateAxis(viewportBox.y, scroll.offset.y);
-    }
-    return viewportBox;
-}
-
-export { measurePageBox, measureViewportBox };