@teamturing/react-kit 2.51.3 → 2.51.5

package/esm/node_modules/framer-motion/dist/es/render/VisualElement.js

@@ -1,507 +0,0 @@
-import { warning, invariant } from '../utils/errors.js';
-import { createBox } from '../projection/geometry/models.js';
-import { isRefObject } from '../utils/is-ref-object.js';
-import { initPrefersReducedMotion } from '../utils/reduced-motion/index.js';
-import { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.js';
-import { SubscriptionManager } from '../utils/subscription-manager.js';
-import { motionValue } from '../value/index.js';
-import { isWillChangeMotionValue } from '../value/use-will-change/is.js';
-import { isMotionValue } from '../value/utils/is-motion-value.js';
-import { transformProps } from './html/utils/transform.js';
-import { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.js';
-import { isVariantLabel } from './utils/is-variant-label.js';
-import { updateMotionValuesFromProps } from './utils/motion-values.js';
-import { resolveVariantFromProps } from './utils/resolve-variants.js';
-import { warnOnce } from '../utils/warn-once.js';
-import { featureDefinitions } from '../motion/features/definitions.js';
-import { variantProps } from './utils/variant-props.js';
-import { visualElementStore } from './store.js';
-import { frame, cancelFrame } from '../frameloop/frame.js';
-
-const featureNames = Object.keys(featureDefinitions);
-const numFeatures = featureNames.length;
-const propEventHandlers = [
-    "AnimationStart",
-    "AnimationComplete",
-    "Update",
-    "BeforeLayoutMeasure",
-    "LayoutMeasure",
-    "LayoutAnimationStart",
-    "LayoutAnimationComplete",
-];
-const numVariantProps = variantProps.length;
-/**
- * A VisualElement is an imperative abstraction around UI elements such as
- * HTMLElement, SVGElement, Three.Object3D etc.
- */
-class VisualElement {
-    constructor({ parent, props, presenceContext, reducedMotionConfig, visualState, }, options = {}) {
-        /**
-         * A reference to the current underlying Instance, e.g. a HTMLElement
-         * or Three.Mesh etc.
-         */
-        this.current = null;
-        /**
-         * A set containing references to this VisualElement's children.
-         */
-        this.children = new Set();
-        /**
-         * Determine what role this visual element should take in the variant tree.
-         */
-        this.isVariantNode = false;
-        this.isControllingVariants = false;
-        /**
-         * Decides whether this VisualElement should animate in reduced motion
-         * mode.
-         *
-         * TODO: This is currently set on every individual VisualElement but feels
-         * like it could be set globally.
-         */
-        this.shouldReduceMotion = null;
-        /**
-         * A map of all motion values attached to this visual element. Motion
-         * values are source of truth for any given animated value. A motion
-         * value might be provided externally by the component via props.
-         */
-        this.values = new Map();
-        /**
-         * Cleanup functions for active features (hover/tap/exit etc)
-         */
-        this.features = {};
-        /**
-         * A map of every subscription that binds the provided or generated
-         * motion values onChange listeners to this visual element.
-         */
-        this.valueSubscriptions = new Map();
-        /**
-         * A reference to the previously-provided motion values as returned
-         * from scrapeMotionValuesFromProps. We use the keys in here to determine
-         * if any motion values need to be removed after props are updated.
-         */
-        this.prevMotionValues = {};
-        /**
-         * An object containing a SubscriptionManager for each active event.
-         */
-        this.events = {};
-        /**
-         * An object containing an unsubscribe function for each prop event subscription.
-         * For example, every "Update" event can have multiple subscribers via
-         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.
-         */
-        this.propEventSubscriptions = {};
-        this.notifyUpdate = () => this.notify("Update", this.latestValues);
-        this.render = () => {
-            if (!this.current)
-                return;
-            this.triggerBuild();
-            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);
-        };
-        this.scheduleRender = () => frame.render(this.render, false, true);
-        const { latestValues, renderState } = visualState;
-        this.latestValues = latestValues;
-        this.baseTarget = { ...latestValues };
-        this.initialValues = props.initial ? { ...latestValues } : {};
-        this.renderState = renderState;
-        this.parent = parent;
-        this.props = props;
-        this.presenceContext = presenceContext;
-        this.depth = parent ? parent.depth + 1 : 0;
-        this.reducedMotionConfig = reducedMotionConfig;
-        this.options = options;
-        this.isControllingVariants = isControllingVariants(props);
-        this.isVariantNode = isVariantNode(props);
-        if (this.isVariantNode) {
-            this.variantChildren = new Set();
-        }
-        this.manuallyAnimateOnMount = Boolean(parent && parent.current);
-        /**
-         * Any motion values that are provided to the element when created
-         * aren't yet bound to the element, as this would technically be impure.
-         * However, we iterate through the motion values and set them to the
-         * initial values for this component.
-         *
-         * TODO: This is impure and we should look at changing this to run on mount.
-         * Doing so will break some tests but this isn't neccessarily a breaking change,
-         * more a reflection of the test.
-         */
-        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {});
-        for (const key in initialMotionValues) {
-            const value = initialMotionValues[key];
-            if (latestValues[key] !== undefined && isMotionValue(value)) {
-                value.set(latestValues[key], false);
-                if (isWillChangeMotionValue(willChange)) {
-                    willChange.add(key);
-                }
-            }
-        }
-    }
-    /**
-     * This method takes React props and returns found MotionValues. For example, HTML
-     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
-     *
-     * This isn't an abstract method as it needs calling in the constructor, but it is
-     * intended to be one.
-     */
-    scrapeMotionValuesFromProps(_props, _prevProps) {
-        return {};
-    }
-    mount(instance) {
-        this.current = instance;
-        visualElementStore.set(instance, this);
-        if (this.projection && !this.projection.instance) {
-            this.projection.mount(instance);
-        }
-        if (this.parent && this.isVariantNode && !this.isControllingVariants) {
-            this.removeFromVariantTree = this.parent.addVariantChild(this);
-        }
-        this.values.forEach((value, key) => this.bindToMotionValue(key, value));
-        if (!hasReducedMotionListener.current) {
-            initPrefersReducedMotion();
-        }
-        this.shouldReduceMotion =
-            this.reducedMotionConfig === "never"
-                ? false
-                : this.reducedMotionConfig === "always"
-                    ? true
-                    : prefersReducedMotion.current;
-        if (process.env.NODE_ENV !== "production") {
-            warnOnce(this.shouldReduceMotion !== true, "You have Reduced Motion enabled on your device. Animations may not appear as expected.");
-        }
-        if (this.parent)
-            this.parent.children.add(this);
-        this.update(this.props, this.presenceContext);
-    }
-    unmount() {
-        visualElementStore.delete(this.current);
-        this.projection && this.projection.unmount();
-        cancelFrame(this.notifyUpdate);
-        cancelFrame(this.render);
-        this.valueSubscriptions.forEach((remove) => remove());
-        this.removeFromVariantTree && this.removeFromVariantTree();
-        this.parent && this.parent.children.delete(this);
-        for (const key in this.events) {
-            this.events[key].clear();
-        }
-        for (const key in this.features) {
-            this.features[key].unmount();
-        }
-        this.current = null;
-    }
-    bindToMotionValue(key, value) {
-        const valueIsTransform = transformProps.has(key);
-        const removeOnChange = value.on("change", (latestValue) => {
-            this.latestValues[key] = latestValue;
-            this.props.onUpdate &&
-                frame.update(this.notifyUpdate, false, true);
-            if (valueIsTransform && this.projection) {
-                this.projection.isTransformDirty = true;
-            }
-        });
-        const removeOnRenderRequest = value.on("renderRequest", this.scheduleRender);
-        this.valueSubscriptions.set(key, () => {
-            removeOnChange();
-            removeOnRenderRequest();
-        });
-    }
-    sortNodePosition(other) {
-        /**
-         * If these nodes aren't even of the same type we can't compare their depth.
-         */
-        if (!this.current ||
-            !this.sortInstanceNodePosition ||
-            this.type !== other.type) {
-            return 0;
-        }
-        return this.sortInstanceNodePosition(this.current, other.current);
-    }
-    loadFeatures({ children, ...renderedProps }, isStrict, preloadedFeatures, initialLayoutGroupConfig) {
-        let ProjectionNodeConstructor;
-        let MeasureLayout;
-        /**
-         * If we're in development mode, check to make sure we're not rendering a motion component
-         * as a child of LazyMotion, as this will break the file-size benefits of using it.
-         */
-        if (process.env.NODE_ENV !== "production" &&
-            preloadedFeatures &&
-            isStrict) {
-            const strictMessage = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
-            renderedProps.ignoreStrict
-                ? warning(false, strictMessage)
-                : invariant(false, strictMessage);
-        }
-        for (let i = 0; i < numFeatures; i++) {
-            const name = featureNames[i];
-            const { isEnabled, Feature: FeatureConstructor, ProjectionNode, MeasureLayout: MeasureLayoutComponent, } = featureDefinitions[name];
-            if (ProjectionNode)
-                ProjectionNodeConstructor = ProjectionNode;
-            if (isEnabled(renderedProps)) {
-                if (!this.features[name] && FeatureConstructor) {
-                    this.features[name] = new FeatureConstructor(this);
-                }
-                if (MeasureLayoutComponent) {
-                    MeasureLayout = MeasureLayoutComponent;
-                }
-            }
-        }
-        if (!this.projection && ProjectionNodeConstructor) {
-            this.projection = new ProjectionNodeConstructor(this.latestValues, this.parent && this.parent.projection);
-            const { layoutId, layout, drag, dragConstraints, layoutScroll, layoutRoot, } = renderedProps;
-            this.projection.setOptions({
-                layoutId,
-                layout,
-                alwaysMeasureLayout: Boolean(drag) ||
-                    (dragConstraints && isRefObject(dragConstraints)),
-                visualElement: this,
-                scheduleRender: () => this.scheduleRender(),
-                /**
-                 * TODO: Update options in an effect. This could be tricky as it'll be too late
-                 * to update by the time layout animations run.
-                 * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
-                 * ensuring it gets called if there's no potential layout animations.
-                 *
-                 */
-                animationType: typeof layout === "string" ? layout : "both",
-                initialPromotionConfig: initialLayoutGroupConfig,
-                layoutScroll,
-                layoutRoot,
-            });
-        }
-        return MeasureLayout;
-    }
-    updateFeatures() {
-        for (const key in this.features) {
-            const feature = this.features[key];
-            if (feature.isMounted) {
-                feature.update();
-            }
-            else {
-                feature.mount();
-                feature.isMounted = true;
-            }
-        }
-    }
-    triggerBuild() {
-        this.build(this.renderState, this.latestValues, this.options, this.props);
-    }
-    /**
-     * Measure the current viewport box with or without transforms.
-     * Only measures axis-aligned boxes, rotate and skew must be manually
-     * removed with a re-render to work.
-     */
-    measureViewportBox() {
-        return this.current
-            ? this.measureInstanceViewportBox(this.current, this.props)
-            : createBox();
-    }
-    getStaticValue(key) {
-        return this.latestValues[key];
-    }
-    setStaticValue(key, value) {
-        this.latestValues[key] = value;
-    }
-    /**
-     * Make a target animatable by Popmotion. For instance, if we're
-     * trying to animate width from 100px to 100vw we need to measure 100vw
-     * in pixels to determine what we really need to animate to. This is also
-     * pluggable to support Framer's custom value types like Color,
-     * and CSS variables.
-     */
-    makeTargetAnimatable(target, canMutate = true) {
-        return this.makeTargetAnimatableFromInstance(target, this.props, canMutate);
-    }
-    /**
-     * Update the provided props. Ensure any newly-added motion values are
-     * added to our map, old ones removed, and listeners updated.
-     */
-    update(props, presenceContext) {
-        if (props.transformTemplate || this.props.transformTemplate) {
-            this.scheduleRender();
-        }
-        this.prevProps = this.props;
-        this.props = props;
-        this.prevPresenceContext = this.presenceContext;
-        this.presenceContext = presenceContext;
-        /**
-         * Update prop event handlers ie onAnimationStart, onAnimationComplete
-         */
-        for (let i = 0; i < propEventHandlers.length; i++) {
-            const key = propEventHandlers[i];
-            if (this.propEventSubscriptions[key]) {
-                this.propEventSubscriptions[key]();
-                delete this.propEventSubscriptions[key];
-            }
-            const listener = props["on" + key];
-            if (listener) {
-                this.propEventSubscriptions[key] = this.on(key, listener);
-            }
-        }
-        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps), this.prevMotionValues);
-        if (this.handleChildMotionValue) {
-            this.handleChildMotionValue();
-        }
-    }
-    getProps() {
-        return this.props;
-    }
-    /**
-     * Returns the variant definition with a given name.
-     */
-    getVariant(name) {
-        return this.props.variants ? this.props.variants[name] : undefined;
-    }
-    /**
-     * Returns the defined default transition on this component.
-     */
-    getDefaultTransition() {
-        return this.props.transition;
-    }
-    getTransformPagePoint() {
-        return this.props.transformPagePoint;
-    }
-    getClosestVariantNode() {
-        return this.isVariantNode
-            ? this
-            : this.parent
-                ? this.parent.getClosestVariantNode()
-                : undefined;
-    }
-    getVariantContext(startAtParent = false) {
-        if (startAtParent) {
-            return this.parent ? this.parent.getVariantContext() : undefined;
-        }
-        if (!this.isControllingVariants) {
-            const context = this.parent
-                ? this.parent.getVariantContext() || {}
-                : {};
-            if (this.props.initial !== undefined) {
-                context.initial = this.props.initial;
-            }
-            return context;
-        }
-        const context = {};
-        for (let i = 0; i < numVariantProps; i++) {
-            const name = variantProps[i];
-            const prop = this.props[name];
-            if (isVariantLabel(prop) || prop === false) {
-                context[name] = prop;
-            }
-        }
-        return context;
-    }
-    /**
-     * Add a child visual element to our set of children.
-     */
-    addVariantChild(child) {
-        const closestVariantNode = this.getClosestVariantNode();
-        if (closestVariantNode) {
-            closestVariantNode.variantChildren &&
-                closestVariantNode.variantChildren.add(child);
-            return () => closestVariantNode.variantChildren.delete(child);
-        }
-    }
-    /**
-     * Add a motion value and bind it to this visual element.
-     */
-    addValue(key, value) {
-        // Remove existing value if it exists
-        if (value !== this.values.get(key)) {
-            this.removeValue(key);
-            this.bindToMotionValue(key, value);
-        }
-        this.values.set(key, value);
-        this.latestValues[key] = value.get();
-    }
-    /**
-     * Remove a motion value and unbind any active subscriptions.
-     */
-    removeValue(key) {
-        this.values.delete(key);
-        const unsubscribe = this.valueSubscriptions.get(key);
-        if (unsubscribe) {
-            unsubscribe();
-            this.valueSubscriptions.delete(key);
-        }
-        delete this.latestValues[key];
-        this.removeValueFromRenderState(key, this.renderState);
-    }
-    /**
-     * Check whether we have a motion value for this key
-     */
-    hasValue(key) {
-        return this.values.has(key);
-    }
-    getValue(key, defaultValue) {
-        if (this.props.values && this.props.values[key]) {
-            return this.props.values[key];
-        }
-        let value = this.values.get(key);
-        if (value === undefined && defaultValue !== undefined) {
-            value = motionValue(defaultValue, { owner: this });
-            this.addValue(key, value);
-        }
-        return value;
-    }
-    /**
-     * If we're trying to animate to a previously unencountered value,
-     * we need to check for it in our state and as a last resort read it
-     * directly from the instance (which might have performance implications).
-     */
-    readValue(key) {
-        var _a;
-        return this.latestValues[key] !== undefined || !this.current
-            ? this.latestValues[key]
-            : (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);
-    }
-    /**
-     * Set the base target to later animate back to. This is currently
-     * only hydrated on creation and when we first read a value.
-     */
-    setBaseTarget(key, value) {
-        this.baseTarget[key] = value;
-    }
-    /**
-     * Find the base target for a value thats been removed from all animation
-     * props.
-     */
-    getBaseTarget(key) {
-        var _a;
-        const { initial } = this.props;
-        const valueFromInitial = typeof initial === "string" || typeof initial === "object"
-            ? (_a = resolveVariantFromProps(this.props, initial)) === null || _a === void 0 ? void 0 : _a[key]
-            : undefined;
-        /**
-         * If this value still exists in the current initial variant, read that.
-         */
-        if (initial && valueFromInitial !== undefined) {
-            return valueFromInitial;
-        }
-        /**
-         * Alternatively, if this VisualElement config has defined a getBaseTarget
-         * so we can read the value from an alternative source, try that.
-         */
-        const target = this.getBaseTargetFromProps(this.props, key);
-        if (target !== undefined && !isMotionValue(target))
-            return target;
-        /**
-         * If the value was initially defined on initial, but it doesn't any more,
-         * return undefined. Otherwise return the value as initially read from the DOM.
-         */
-        return this.initialValues[key] !== undefined &&
-            valueFromInitial === undefined
-            ? undefined
-            : this.baseTarget[key];
-    }
-    on(eventName, callback) {
-        if (!this.events[eventName]) {
-            this.events[eventName] = new SubscriptionManager();
-        }
-        return this.events[eventName].add(callback);
-    }
-    notify(eventName, ...args) {
-        if (this.events[eventName]) {
-            this.events[eventName].notify(...args);
-        }
-    }
-}
-
-export { VisualElement };

package/esm/node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.js

@@ -1,48 +0,0 @@
-import { getOrigin, checkTargetForNewValues } from '../utils/setters.js';
-import { parseDomVariant } from './utils/parse-dom-variant.js';
-import { VisualElement } from '../VisualElement.js';
-
-class DOMVisualElement extends VisualElement {
-    sortInstanceNodePosition(a, b) {
-        /**
-         * compareDocumentPosition returns a bitmask, by using the bitwise &
-         * we're returning true if 2 in that bitmask is set to true. 2 is set
-         * to true if b preceeds a.
-         */
-        return a.compareDocumentPosition(b) & 2 ? 1 : -1;
-    }
-    getBaseTargetFromProps(props, key) {
-        return props.style ? props.style[key] : undefined;
-    }
-    removeValueFromRenderState(key, { vars, style }) {
-        delete vars[key];
-        delete style[key];
-    }
-    makeTargetAnimatableFromInstance({ transition, transitionEnd, ...target }, { transformValues }, isMounted) {
-        let origin = getOrigin(target, transition || {}, this);
-        /**
-         * If Framer has provided a function to convert `Color` etc value types, convert them
-         */
-        if (transformValues) {
-            if (transitionEnd)
-                transitionEnd = transformValues(transitionEnd);
-            if (target)
-                target = transformValues(target);
-            if (origin)
-                origin = transformValues(origin);
-        }
-        if (isMounted) {
-            checkTargetForNewValues(this, target, origin);
-            const parsed = parseDomVariant(this, target, origin, transitionEnd);
-            transitionEnd = parsed.transitionEnd;
-            target = parsed.target;
-        }
-        return {
-            transition,
-            transitionEnd,
-            ...target,
-        };
-    }
-}
-
-export { DOMVisualElement };

package/esm/node_modules/framer-motion/dist/es/render/dom/create-visual-element.js

@@ -1,11 +0,0 @@
-import { HTMLVisualElement } from '../html/HTMLVisualElement.js';
-import { SVGVisualElement } from '../svg/SVGVisualElement.js';
-import { isSVGComponent } from './utils/is-svg-component.js';
-
-const createDomVisualElement = (Component, options) => {
-    return isSVGComponent(Component)
-        ? new SVGVisualElement(options, { enableHardwareAcceleration: false })
-        : new HTMLVisualElement(options, { enableHardwareAcceleration: true });
-};
-
-export { createDomVisualElement };

package/esm/node_modules/framer-motion/dist/es/render/dom/motion-proxy.js

@@ -1,47 +0,0 @@
-import { createMotionComponent } from '../../motion/index.js';
-
-/**
- * Convert any React component into a `motion` component. The provided component
- * **must** use `React.forwardRef` to the underlying DOM component you want to animate.
- *
- * ```jsx
- * const Component = React.forwardRef((props, ref) => {
- *   return <div ref={ref} />
- * })
- *
- * const MotionComponent = motion(Component)
- * ```
- *
- * @public
- */
-function createMotionProxy(createConfig) {
-    function custom(Component, customMotionComponentConfig = {}) {
-        return createMotionComponent(createConfig(Component, customMotionComponentConfig));
-    }
-    if (typeof Proxy === "undefined") {
-        return custom;
-    }
-    /**
-     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.
-     * Rather than generating them anew every render.
-     */
-    const componentCache = new Map();
-    return new Proxy(custom, {
-        /**
-         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
-         * The prop name is passed through as `key` and we can use that to generate a `motion`
-         * DOM component with that name.
-         */
-        get: (_target, key) => {
-            /**
-             * If this element doesn't exist in the component cache, create it and cache.
-             */
-            if (!componentCache.has(key)) {
-                componentCache.set(key, custom(key));
-            }
-            return componentCache.get(key);
-        },
-    });
-}
-
-export { createMotionProxy };

package/esm/node_modules/framer-motion/dist/es/render/dom/motion.js

@@ -1,23 +0,0 @@
-import { createMotionProxy } from './motion-proxy.js';
-import { createDomMotionConfig } from './utils/create-config.js';
-import { gestureAnimations } from '../../motion/features/gestures.js';
-import { animations } from '../../motion/features/animations.js';
-import { drag } from '../../motion/features/drag.js';
-import { createDomVisualElement } from './create-visual-element.js';
-import { layout } from '../../motion/features/layout.js';
-
-const preloadedFeatures = {
-    ...animations,
-    ...gestureAnimations,
-    ...drag,
-    ...layout,
-};
-/**
- * HTML & SVG components, optimised for use with gestures and animation. These can be used as
- * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.
- *
- * @public
- */
-const motion = /*@__PURE__*/ createMotionProxy((Component, config) => createDomMotionConfig(Component, config, preloadedFeatures, createDomVisualElement));
-
-export { motion };

package/esm/node_modules/framer-motion/dist/es/render/dom/use-render.js

@@ -1,35 +0,0 @@
-import { useMemo, createElement } from 'react';
-import { useHTMLProps } from '../html/use-props.js';
-import { filterProps } from './utils/filter-props.js';
-import { isSVGComponent } from './utils/is-svg-component.js';
-import { useSVGProps } from '../svg/use-props.js';
-import { isMotionValue } from '../../value/utils/is-motion-value.js';
-
-function createUseRender(forwardMotionProps = false) {
-    const useRender = (Component, props, ref, { latestValues }, isStatic) => {
-        const useVisualProps = isSVGComponent(Component)
-            ? useSVGProps
-            : useHTMLProps;
-        const visualProps = useVisualProps(props, latestValues, isStatic, Component);
-        const filteredProps = filterProps(props, typeof Component === "string", forwardMotionProps);
-        const elementProps = {
-            ...filteredProps,
-            ...visualProps,
-            ref,
-        };
-        /**
-         * If component has been handed a motion value as its child,
-         * memoise its initial value and render that. Subsequent updates
-         * will be handled by the onChange handler
-         */
-        const { children } = props;
-        const renderedChildren = useMemo(() => (isMotionValue(children) ? children.get() : children), [children]);
-        return createElement(Component, {
-            ...elementProps,
-            children: renderedChildren,
-        });
-    };
-    return useRender;
-}
-
-export { createUseRender };

package/esm/node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.js

@@ -1,6 +0,0 @@
-/**
- * Convert camelCase to dash-case properties.
- */
-const camelToDash = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-
-export { camelToDash };