@teamturing/react-kit 2.51.3 → 2.51.4

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

@@ -1,38 +0,0 @@
-import { isAnimationControls } from '../../../animation/utils/is-animation-controls.js';
-import { createAnimationState } from '../../../render/utils/animation-state.js';
-import { Feature } from '../Feature.js';
-
-class AnimationFeature extends Feature {
-    /**
-     * We dynamically generate the AnimationState manager as it contains a reference
-     * to the underlying animation library. We only want to load that if we load this,
-     * so people can optionally code split it out using the `m` component.
-     */
-    constructor(node) {
-        super(node);
-        node.animationState || (node.animationState = createAnimationState(node));
-    }
-    updateAnimationControlsSubscription() {
-        const { animate } = this.node.getProps();
-        this.unmount();
-        if (isAnimationControls(animate)) {
-            this.unmount = animate.subscribe(this.node);
-        }
-    }
-    /**
-     * Subscribe any provided AnimationControls to the component's VisualElement
-     */
-    mount() {
-        this.updateAnimationControlsSubscription();
-    }
-    update() {
-        const { animate } = this.node.getProps();
-        const { animate: prevAnimate } = this.node.prevProps || {};
-        if (animate !== prevAnimate) {
-            this.updateAnimationControlsSubscription();
-        }
-    }
-    unmount() { }
-}
-
-export { AnimationFeature };

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

@@ -1,13 +0,0 @@
-import { AnimationFeature } from './animation/index.js';
-import { ExitAnimationFeature } from './animation/exit.js';
-
-const animations = {
-    animation: {
-        Feature: AnimationFeature,
-    },
-    exit: {
-        Feature: ExitAnimationFeature,
-    },
-};
-
-export { animations };

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

@@ -1,28 +0,0 @@
-const featureProps = {
-    animation: [
-        "animate",
-        "variants",
-        "whileHover",
-        "whileTap",
-        "exit",
-        "whileInView",
-        "whileFocus",
-        "whileDrag",
-    ],
-    exit: ["exit"],
-    drag: ["drag", "dragControls"],
-    focus: ["whileFocus"],
-    hover: ["whileHover", "onHoverStart", "onHoverEnd"],
-    tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
-    pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
-    inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
-    layout: ["layout", "layoutId"],
-};
-const featureDefinitions = {};
-for (const key in featureProps) {
-    featureDefinitions[key] = {
-        isEnabled: (props) => featureProps[key].some((name) => !!props[name]),
-    };
-}
-
-export { featureDefinitions };

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

@@ -1,17 +0,0 @@
-import { DragGesture } from '../../gestures/drag/index.js';
-import { PanGesture } from '../../gestures/pan/index.js';
-import { MeasureLayout } from './layout/MeasureLayout.js';
-import { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.js';
-
-const drag = {
-    pan: {
-        Feature: PanGesture,
-    },
-    drag: {
-        Feature: DragGesture,
-        ProjectionNode: HTMLProjectionNode,
-        MeasureLayout,
-    },
-};
-
-export { drag };

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

@@ -1,21 +0,0 @@
-import { HoverGesture } from '../../gestures/hover.js';
-import { FocusGesture } from '../../gestures/focus.js';
-import { PressGesture } from '../../gestures/press.js';
-import { InViewFeature } from './viewport/index.js';
-
-const gestureAnimations = {
-    inView: {
-        Feature: InViewFeature,
-    },
-    tap: {
-        Feature: PressGesture,
-    },
-    focus: {
-        Feature: FocusGesture,
-    },
-    hover: {
-        Feature: HoverGesture,
-    },
-};
-
-export { gestureAnimations };

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

@@ -1,131 +0,0 @@
-import React__default, { useContext } from 'react';
-import { usePresence } from '../../../components/AnimatePresence/use-presence.js';
-import { LayoutGroupContext } from '../../../context/LayoutGroupContext.js';
-import { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.js';
-import { globalProjectionState } from '../../../projection/node/state.js';
-import { correctBorderRadius } from '../../../projection/styles/scale-border-radius.js';
-import { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.js';
-import { addScaleCorrector } from '../../../projection/styles/scale-correction.js';
-import { frame } from '../../../frameloop/frame.js';
-
-class MeasureLayoutWithContext extends React__default.Component {
-    /**
-     * This only mounts projection nodes for components that
-     * need measuring, we might want to do it for all components
-     * in order to incorporate transforms
-     */
-    componentDidMount() {
-        const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;
-        const { projection } = visualElement;
-        addScaleCorrector(defaultScaleCorrectors);
-        if (projection) {
-            if (layoutGroup.group)
-                layoutGroup.group.add(projection);
-            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {
-                switchLayoutGroup.register(projection);
-            }
-            projection.root.didUpdate();
-            projection.addEventListener("animationComplete", () => {
-                this.safeToRemove();
-            });
-            projection.setOptions({
-                ...projection.options,
-                onExitComplete: () => this.safeToRemove(),
-            });
-        }
-        globalProjectionState.hasEverUpdated = true;
-    }
-    getSnapshotBeforeUpdate(prevProps) {
-        const { layoutDependency, visualElement, drag, isPresent } = this.props;
-        const projection = visualElement.projection;
-        if (!projection)
-            return null;
-        /**
-         * TODO: We use this data in relegate to determine whether to
-         * promote a previous element. There's no guarantee its presence data
-         * will have updated by this point - if a bug like this arises it will
-         * have to be that we markForRelegation and then find a new lead some other way,
-         * perhaps in didUpdate
-         */
-        projection.isPresent = isPresent;
-        if (drag ||
-            prevProps.layoutDependency !== layoutDependency ||
-            layoutDependency === undefined) {
-            projection.willUpdate();
-        }
-        else {
-            this.safeToRemove();
-        }
-        if (prevProps.isPresent !== isPresent) {
-            if (isPresent) {
-                projection.promote();
-            }
-            else if (!projection.relegate()) {
-                /**
-                 * If there's another stack member taking over from this one,
-                 * it's in charge of the exit animation and therefore should
-                 * be in charge of the safe to remove. Otherwise we call it here.
-                 */
-                frame.postRender(() => {
-                    const stack = projection.getStack();
-                    if (!stack || !stack.members.length) {
-                        this.safeToRemove();
-                    }
-                });
-            }
-        }
-        return null;
-    }
-    componentDidUpdate() {
-        const { projection } = this.props.visualElement;
-        if (projection) {
-            projection.root.didUpdate();
-            queueMicrotask(() => {
-                if (!projection.currentAnimation && projection.isLead()) {
-                    this.safeToRemove();
-                }
-            });
-        }
-    }
-    componentWillUnmount() {
-        const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;
-        const { projection } = visualElement;
-        if (projection) {
-            projection.scheduleCheckAfterUnmount();
-            if (layoutGroup && layoutGroup.group)
-                layoutGroup.group.remove(projection);
-            if (promoteContext && promoteContext.deregister)
-                promoteContext.deregister(projection);
-        }
-    }
-    safeToRemove() {
-        const { safeToRemove } = this.props;
-        safeToRemove && safeToRemove();
-    }
-    render() {
-        return null;
-    }
-}
-function MeasureLayout(props) {
-    const [isPresent, safeToRemove] = usePresence();
-    const layoutGroup = useContext(LayoutGroupContext);
-    return (React__default.createElement(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));
-}
-const defaultScaleCorrectors = {
-    borderRadius: {
-        ...correctBorderRadius,
-        applyTo: [
-            "borderTopLeftRadius",
-            "borderTopRightRadius",
-            "borderBottomLeftRadius",
-            "borderBottomRightRadius",
-        ],
-    },
-    borderTopLeftRadius: correctBorderRadius,
-    borderTopRightRadius: correctBorderRadius,
-    borderBottomLeftRadius: correctBorderRadius,
-    borderBottomRightRadius: correctBorderRadius,
-    boxShadow: correctBoxShadow,
-};
-
-export { MeasureLayout };

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

@@ -1,11 +0,0 @@
-import { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.js';
-import { MeasureLayout } from './layout/MeasureLayout.js';
-
-const layout = {
-    layout: {
-        ProjectionNode: HTMLProjectionNode,
-        MeasureLayout,
-    },
-};
-
-export { layout };

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

@@ -1,12 +0,0 @@
-import { featureDefinitions } from './definitions.js';
-
-function loadFeatures(features) {
-    for (const key in features) {
-        featureDefinitions[key] = {
-            ...featureDefinitions[key],
-            ...features[key],
-        };
-    }
-}
-
-export { loadFeatures };

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

@@ -1,72 +0,0 @@
-import { Feature } from '../Feature.js';
-import { observeIntersection } from './observers.js';
-
-const thresholdNames = {
-    some: 0,
-    all: 1,
-};
-class InViewFeature extends Feature {
-    constructor() {
-        super(...arguments);
-        this.hasEnteredView = false;
-        this.isInView = false;
-    }
-    startObserver() {
-        this.unmount();
-        const { viewport = {} } = this.node.getProps();
-        const { root, margin: rootMargin, amount = "some", once } = viewport;
-        const options = {
-            root: root ? root.current : undefined,
-            rootMargin,
-            threshold: typeof amount === "number" ? amount : thresholdNames[amount],
-        };
-        const onIntersectionUpdate = (entry) => {
-            const { isIntersecting } = entry;
-            /**
-             * If there's been no change in the viewport state, early return.
-             */
-            if (this.isInView === isIntersecting)
-                return;
-            this.isInView = isIntersecting;
-            /**
-             * Handle hasEnteredView. If this is only meant to run once, and
-             * element isn't visible, early return. Otherwise set hasEnteredView to true.
-             */
-            if (once && !isIntersecting && this.hasEnteredView) {
-                return;
-            }
-            else if (isIntersecting) {
-                this.hasEnteredView = true;
-            }
-            if (this.node.animationState) {
-                this.node.animationState.setActive("whileInView", isIntersecting);
-            }
-            /**
-             * Use the latest committed props rather than the ones in scope
-             * when this observer is created
-             */
-            const { onViewportEnter, onViewportLeave } = this.node.getProps();
-            const callback = isIntersecting ? onViewportEnter : onViewportLeave;
-            callback && callback(entry);
-        };
-        return observeIntersection(this.node.current, options, onIntersectionUpdate);
-    }
-    mount() {
-        this.startObserver();
-    }
-    update() {
-        if (typeof IntersectionObserver === "undefined")
-            return;
-        const { props, prevProps } = this.node;
-        const hasOptionsChanged = ["amount", "margin", "root"].some(hasViewportOptionChanged(props, prevProps));
-        if (hasOptionsChanged) {
-            this.startObserver();
-        }
-    }
-    unmount() { }
-}
-function hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {
-    return (name) => viewport[name] !== prevViewport[name];
-}
-
-export { InViewFeature };

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

@@ -1,49 +0,0 @@
-/**
- * Map an IntersectionHandler callback to an element. We only ever make one handler for one
- * element, so even though these handlers might all be triggered by different
- * observers, we can keep them in the same map.
- */
-const observerCallbacks = new WeakMap();
-/**
- * Multiple observers can be created for multiple element/document roots. Each with
- * different settings. So here we store dictionaries of observers to each root,
- * using serialised settings (threshold/margin) as lookup keys.
- */
-const observers = new WeakMap();
-const fireObserverCallback = (entry) => {
-    const callback = observerCallbacks.get(entry.target);
-    callback && callback(entry);
-};
-const fireAllObserverCallbacks = (entries) => {
-    entries.forEach(fireObserverCallback);
-};
-function initIntersectionObserver({ root, ...options }) {
-    const lookupRoot = root || document;
-    /**
-     * If we don't have an observer lookup map for this root, create one.
-     */
-    if (!observers.has(lookupRoot)) {
-        observers.set(lookupRoot, {});
-    }
-    const rootObservers = observers.get(lookupRoot);
-    const key = JSON.stringify(options);
-    /**
-     * If we don't have an observer for this combination of root and settings,
-     * create one.
-     */
-    if (!rootObservers[key]) {
-        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });
-    }
-    return rootObservers[key];
-}
-function observeIntersection(element, options, callback) {
-    const rootInteresectionObserver = initIntersectionObserver(options);
-    observerCallbacks.set(element, callback);
-    rootInteresectionObserver.observe(element);
-    return () => {
-        observerCallbacks.delete(element);
-        rootInteresectionObserver.unobserve(element);
-    };
-}
-
-export { observeIntersection };

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

@@ -1,79 +0,0 @@
-import * as React from 'react';
-import { forwardRef, useContext } from 'react';
-import { MotionConfigContext } from '../context/MotionConfigContext.js';
-import { MotionContext } from '../context/MotionContext/index.js';
-import { useVisualElement } from './utils/use-visual-element.js';
-import { useMotionRef } from './utils/use-motion-ref.js';
-import { useCreateMotionContext } from '../context/MotionContext/create.js';
-import { loadFeatures } from './features/load-features.js';
-import { isBrowser } from '../utils/is-browser.js';
-import { LayoutGroupContext } from '../context/LayoutGroupContext.js';
-import { LazyContext } from '../context/LazyContext.js';
-import { SwitchLayoutGroupContext } from '../context/SwitchLayoutGroupContext.js';
-import { motionComponentSymbol } from './utils/symbol.js';
-
-/**
- * Create a `motion` component.
- *
- * This function accepts a Component argument, which can be either a string (ie "div"
- * for `motion.div`), or an actual React component.
- *
- * Alongside this is a config option which provides a way of rendering the provided
- * component "offline", or outside the React render cycle.
- */
-function createMotionComponent({ preloadedFeatures, createVisualElement, useRender, useVisualState, Component, }) {
-    preloadedFeatures && loadFeatures(preloadedFeatures);
-    function MotionComponent(props, externalRef) {
-        /**
-         * If we need to measure the element we load this functionality in a
-         * separate class component in order to gain access to getSnapshotBeforeUpdate.
-         */
-        let MeasureLayout;
-        const configAndProps = {
-            ...useContext(MotionConfigContext),
-            ...props,
-            layoutId: useLayoutId(props),
-        };
-        const { isStatic } = configAndProps;
-        const context = useCreateMotionContext(props);
-        const visualState = useVisualState(props, isStatic);
-        if (!isStatic && isBrowser) {
-            /**
-             * Create a VisualElement for this component. A VisualElement provides a common
-             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as
-             * providing a way of rendering to these APIs outside of the React render loop
-             * for more performant animations and interactions
-             */
-            context.visualElement = useVisualElement(Component, visualState, configAndProps, createVisualElement);
-            /**
-             * Load Motion gesture and animation features. These are rendered as renderless
-             * components so each feature can optionally make use of React lifecycle methods.
-             */
-            const initialLayoutGroupConfig = useContext(SwitchLayoutGroupContext);
-            const isStrict = useContext(LazyContext).strict;
-            if (context.visualElement) {
-                MeasureLayout = context.visualElement.loadFeatures(
-                // Note: Pass the full new combined props to correctly re-render dynamic feature components.
-                configAndProps, isStrict, preloadedFeatures, initialLayoutGroupConfig);
-            }
-        }
-        /**
-         * The mount order and hierarchy is specific to ensure our element ref
-         * is hydrated by the time features fire their effects.
-         */
-        return (React.createElement(MotionContext.Provider, { value: context },
-            MeasureLayout && context.visualElement ? (React.createElement(MeasureLayout, { visualElement: context.visualElement, ...configAndProps })) : null,
-            useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, context.visualElement)));
-    }
-    const ForwardRefComponent = forwardRef(MotionComponent);
-    ForwardRefComponent[motionComponentSymbol] = Component;
-    return ForwardRefComponent;
-}
-function useLayoutId({ layoutId }) {
-    const layoutGroupId = useContext(LayoutGroupContext).id;
-    return layoutGroupId && layoutId !== undefined
-        ? layoutGroupId + "-" + layoutId
-        : layoutId;
-}
-
-export { createMotionComponent };

package/esm/node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.js

@@ -1,11 +0,0 @@
-import { scaleCorrectors } from '../../projection/styles/scale-correction.js';
-import { transformProps } from '../../render/html/utils/transform.js';
-
-function isForcedMotionValue(key, { layout, layoutId }) {
-    return (transformProps.has(key) ||
-        key.startsWith("origin") ||
-        ((layout || layoutId !== undefined) &&
-            (!!scaleCorrectors[key] || key === "opacity")));
-}
-
-export { isForcedMotionValue };

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

@@ -1,3 +0,0 @@
-const motionComponentSymbol = Symbol.for("motionComponentSymbol");
-
-export { motionComponentSymbol };

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

@@ -1,33 +0,0 @@
-import { useCallback } from 'react';
-import { isRefObject } from '../../utils/is-ref-object.js';
-
-/**
- * Creates a ref function that, when called, hydrates the provided
- * external ref and VisualElement.
- */
-function useMotionRef(visualState, visualElement, externalRef) {
-    return useCallback((instance) => {
-        instance && visualState.mount && visualState.mount(instance);
-        if (visualElement) {
-            instance
-                ? visualElement.mount(instance)
-                : visualElement.unmount();
-        }
-        if (externalRef) {
-            if (typeof externalRef === "function") {
-                externalRef(instance);
-            }
-            else if (isRefObject(externalRef)) {
-                externalRef.current = instance;
-            }
-        }
-    }, 
-    /**
-     * Only pass a new ref callback to React if we've received a visual element
-     * factory. Otherwise we'll be mounting/remounting every time externalRef
-     * or other dependencies change.
-     */
-    [visualElement]);
-}
-
-export { useMotionRef };

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

@@ -1,75 +0,0 @@
-import { useContext, useRef, useInsertionEffect, useEffect } from 'react';
-import { PresenceContext } from '../../context/PresenceContext.js';
-import { MotionContext } from '../../context/MotionContext/index.js';
-import { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.js';
-import { LazyContext } from '../../context/LazyContext.js';
-import { MotionConfigContext } from '../../context/MotionConfigContext.js';
-
-function useVisualElement(Component, visualState, props, createVisualElement) {
-    const { visualElement: parent } = useContext(MotionContext);
-    const lazyContext = useContext(LazyContext);
-    const presenceContext = useContext(PresenceContext);
-    const reducedMotionConfig = useContext(MotionConfigContext).reducedMotion;
-    const visualElementRef = useRef();
-    /**
-     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded
-     */
-    createVisualElement = createVisualElement || lazyContext.renderer;
-    if (!visualElementRef.current && createVisualElement) {
-        visualElementRef.current = createVisualElement(Component, {
-            visualState,
-            parent,
-            props,
-            presenceContext,
-            blockInitialAnimation: presenceContext
-                ? presenceContext.initial === false
-                : false,
-            reducedMotionConfig,
-        });
-    }
-    const visualElement = visualElementRef.current;
-    useInsertionEffect(() => {
-        visualElement && visualElement.update(props, presenceContext);
-    });
-    /**
-     * Cache this value as we want to know whether HandoffAppearAnimations
-     * was present on initial render - it will be deleted after this.
-     */
-    const canHandoff = useRef(Boolean(window.HandoffAppearAnimations));
-    useIsomorphicLayoutEffect(() => {
-        if (!visualElement)
-            return;
-        visualElement.render();
-        /**
-         * Ideally this function would always run in a useEffect.
-         *
-         * However, if we have optimised appear animations to handoff from,
-         * it needs to happen synchronously to ensure there's no flash of
-         * incorrect styles in the event of a hydration error.
-         *
-         * So if we detect a situtation where optimised appear animations
-         * are running, we use useLayoutEffect to trigger animations.
-         */
-        if (canHandoff.current && visualElement.animationState) {
-            visualElement.animationState.animateChanges();
-        }
-    });
-    useEffect(() => {
-        if (!visualElement)
-            return;
-        visualElement.updateFeatures();
-        if (!canHandoff.current && visualElement.animationState) {
-            visualElement.animationState.animateChanges();
-        }
-        /**
-         * Once we've handed off animations we can delete HandoffAppearAnimations
-         * so components added after the initial render can animate changes
-         * in useEffect vs useLayoutEffect.
-         */
-        window.HandoffAppearAnimations = undefined;
-        canHandoff.current = false;
-    });
-    return visualElement;
-}
-
-export { useVisualElement };