flikkui 0.1.0-beta.9 → 0.2.0-beta.1

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.js

@@ -1,19 +0,0 @@
-import { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.js';
-import { isMotionValue } from '../../../../../../motion-dom/dist/es/value/utils/is-motion-value.js';
-import { transformPropOrder } from '../../../../../../motion-dom/dist/es/render/utils/keys-transform.js';
-
-function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
-    const newValues = scrapeMotionValuesFromProps$1(props, prevProps, visualElement);
-    for (const key in props) {
-        if (isMotionValue(props[key]) ||
-            isMotionValue(prevProps[key])) {
-            const targetKey = transformPropOrder.indexOf(key) !== -1
-                ? "attr" + key.charAt(0).toUpperCase() + key.substring(1)
-                : key;
-            newValues[targetKey] = props[key];
-        }
-    }
-    return newValues;
-}
-
-export { scrapeMotionValuesFromProps };

package/dist/node_modules/framer-motion/dist/es/render/utils/animation-state.js

@@ -1,357 +0,0 @@
-import { animateVisualElement } from '../../animation/interfaces/visual-element.js';
-import { calcChildStagger } from '../../animation/utils/calc-child-stagger.js';
-import { isAnimationControls } from '../../animation/utils/is-animation-controls.js';
-import { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.js';
-import { shallowCompare } from '../../utils/shallow-compare.js';
-import { getVariantContext } from './get-variant-context.js';
-import { isVariantLabel } from './is-variant-label.js';
-import { resolveVariant } from './resolve-dynamic-variants.js';
-import { variantPriorityOrder } from './variant-props.js';
-
-const reversePriorityOrder = [...variantPriorityOrder].reverse();
-const numAnimationTypes = variantPriorityOrder.length;
-function animateList(visualElement) {
-    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));
-}
-function createAnimationState(visualElement) {
-    let animate = animateList(visualElement);
-    let state = createState();
-    let isInitialRender = true;
-    /**
-     * This function will be used to reduce the animation definitions for
-     * each active animation type into an object of resolved values for it.
-     */
-    const buildResolvedTypeValues = (type) => (acc, definition) => {
-        const resolved = resolveVariant(visualElement, definition, type === "exit"
-            ? visualElement.presenceContext?.custom
-            : undefined);
-        if (resolved) {
-            const { transition, transitionEnd, ...target } = resolved;
-            acc = { ...acc, ...target, ...transitionEnd };
-        }
-        return acc;
-    };
-    /**
-     * This just allows us to inject mocked animation functions
-     * @internal
-     */
-    function setAnimateFunction(makeAnimator) {
-        animate = makeAnimator(visualElement);
-    }
-    /**
-     * When we receive new props, we need to:
-     * 1. Create a list of protected keys for each type. This is a directory of
-     *    value keys that are currently being "handled" by types of a higher priority
-     *    so that whenever an animation is played of a given type, these values are
-     *    protected from being animated.
-     * 2. Determine if an animation type needs animating.
-     * 3. Determine if any values have been removed from a type and figure out
-     *    what to animate those to.
-     */
-    function animateChanges(changedActiveType) {
-        const { props } = visualElement;
-        const context = getVariantContext(visualElement.parent) || {};
-        /**
-         * A list of animations that we'll build into as we iterate through the animation
-         * types. This will get executed at the end of the function.
-         */
-        const animations = [];
-        /**
-         * Keep track of which values have been removed. Then, as we hit lower priority
-         * animation types, we can check if they contain removed values and animate to that.
-         */
-        const removedKeys = new Set();
-        /**
-         * A dictionary of all encountered keys. This is an object to let us build into and
-         * copy it without iteration. Each time we hit an animation type we set its protected
-         * keys - the keys its not allowed to animate - to the latest version of this object.
-         */
-        let encounteredKeys = {};
-        /**
-         * If a variant has been removed at a given index, and this component is controlling
-         * variant animations, we want to ensure lower-priority variants are forced to animate.
-         */
-        let removedVariantIndex = Infinity;
-        /**
-         * Iterate through all animation types in reverse priority order. For each, we want to
-         * detect which values it's handling and whether or not they've changed (and therefore
-         * need to be animated). If any values have been removed, we want to detect those in
-         * lower priority props and flag for animation.
-         */
-        for (let i = 0; i < numAnimationTypes; i++) {
-            const type = reversePriorityOrder[i];
-            const typeState = state[type];
-            const prop = props[type] !== undefined
-                ? props[type]
-                : context[type];
-            const propIsVariant = isVariantLabel(prop);
-            /**
-             * If this type has *just* changed isActive status, set activeDelta
-             * to that status. Otherwise set to null.
-             */
-            const activeDelta = type === changedActiveType ? typeState.isActive : null;
-            if (activeDelta === false)
-                removedVariantIndex = i;
-            /**
-             * If this prop is an inherited variant, rather than been set directly on the
-             * component itself, we want to make sure we allow the parent to trigger animations.
-             *
-             * TODO: Can probably change this to a !isControllingVariants check
-             */
-            let isInherited = prop === context[type] &&
-                prop !== props[type] &&
-                propIsVariant;
-            if (isInherited &&
-                isInitialRender &&
-                visualElement.manuallyAnimateOnMount) {
-                isInherited = false;
-            }
-            /**
-             * Set all encountered keys so far as the protected keys for this type. This will
-             * be any key that has been animated or otherwise handled by active, higher-priortiy types.
-             */
-            typeState.protectedKeys = { ...encounteredKeys };
-            // Check if we can skip analysing this prop early
-            if (
-            // If it isn't active and hasn't *just* been set as inactive
-            (!typeState.isActive && activeDelta === null) ||
-                // If we didn't and don't have any defined prop for this animation type
-                (!prop && !typeState.prevProp) ||
-                // Or if the prop doesn't define an animation
-                isAnimationControls(prop) ||
-                typeof prop === "boolean") {
-                continue;
-            }
-            /**
-             * As we go look through the values defined on this type, if we detect
-             * a changed value or a value that was removed in a higher priority, we set
-             * this to true and add this prop to the animation list.
-             */
-            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);
-            let shouldAnimateType = variantDidChange ||
-                // If we're making this variant active, we want to always make it active
-                (type === changedActiveType &&
-                    typeState.isActive &&
-                    !isInherited &&
-                    propIsVariant) ||
-                // If we removed a higher-priority variant (i is in reverse order)
-                (i > removedVariantIndex && propIsVariant);
-            let handledRemovedValues = false;
-            /**
-             * As animations can be set as variant lists, variants or target objects, we
-             * coerce everything to an array if it isn't one already
-             */
-            const definitionList = Array.isArray(prop) ? prop : [prop];
-            /**
-             * Build an object of all the resolved values. We'll use this in the subsequent
-             * animateChanges calls to determine whether a value has changed.
-             */
-            let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});
-            if (activeDelta === false)
-                resolvedValues = {};
-            /**
-             * Now we need to loop through all the keys in the prev prop and this prop,
-             * and decide:
-             * 1. If the value has changed, and needs animating
-             * 2. If it has been removed, and needs adding to the removedKeys set
-             * 3. If it has been removed in a higher priority type and needs animating
-             * 4. If it hasn't been removed in a higher priority but hasn't changed, and
-             *    needs adding to the type's protectedKeys list.
-             */
-            const { prevResolvedValues = {} } = typeState;
-            const allKeys = {
-                ...prevResolvedValues,
-                ...resolvedValues,
-            };
-            const markToAnimate = (key) => {
-                shouldAnimateType = true;
-                if (removedKeys.has(key)) {
-                    handledRemovedValues = true;
-                    removedKeys.delete(key);
-                }
-                typeState.needsAnimating[key] = true;
-                const motionValue = visualElement.getValue(key);
-                if (motionValue)
-                    motionValue.liveStyle = false;
-            };
-            for (const key in allKeys) {
-                const next = resolvedValues[key];
-                const prev = prevResolvedValues[key];
-                // If we've already handled this we can just skip ahead
-                if (encounteredKeys.hasOwnProperty(key))
-                    continue;
-                /**
-                 * If the value has changed, we probably want to animate it.
-                 */
-                let valueHasChanged = false;
-                if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {
-                    valueHasChanged = !shallowCompare(next, prev);
-                }
-                else {
-                    valueHasChanged = next !== prev;
-                }
-                if (valueHasChanged) {
-                    if (next !== undefined && next !== null) {
-                        // If next is defined and doesn't equal prev, it needs animating
-                        markToAnimate(key);
-                    }
-                    else {
-                        // If it's undefined, it's been removed.
-                        removedKeys.add(key);
-                    }
-                }
-                else if (next !== undefined && removedKeys.has(key)) {
-                    /**
-                     * If next hasn't changed and it isn't undefined, we want to check if it's
-                     * been removed by a higher priority
-                     */
-                    markToAnimate(key);
-                }
-                else {
-                    /**
-                     * If it hasn't changed, we add it to the list of protected values
-                     * to ensure it doesn't get animated.
-                     */
-                    typeState.protectedKeys[key] = true;
-                }
-            }
-            /**
-             * Update the typeState so next time animateChanges is called we can compare the
-             * latest prop and resolvedValues to these.
-             */
-            typeState.prevProp = prop;
-            typeState.prevResolvedValues = resolvedValues;
-            if (typeState.isActive) {
-                encounteredKeys = { ...encounteredKeys, ...resolvedValues };
-            }
-            if (isInitialRender && visualElement.blockInitialAnimation) {
-                shouldAnimateType = false;
-            }
-            /**
-             * If this is an inherited prop we want to skip this animation
-             * unless the inherited variants haven't changed on this render.
-             */
-            const willAnimateViaParent = isInherited && variantDidChange;
-            const needsAnimating = !willAnimateViaParent || handledRemovedValues;
-            if (shouldAnimateType && needsAnimating) {
-                animations.push(...definitionList.map((animation) => {
-                    const options = { type };
-                    /**
-                     * If we're performing the initial animation, but we're not
-                     * rendering at the same time as the variant-controlling parent,
-                     * we want to use the parent's transition to calculate the stagger.
-                     */
-                    if (typeof animation === "string" &&
-                        isInitialRender &&
-                        !willAnimateViaParent &&
-                        visualElement.manuallyAnimateOnMount &&
-                        visualElement.parent) {
-                        const { parent } = visualElement;
-                        const parentVariant = resolveVariant(parent, animation);
-                        if (parent.enteringChildren && parentVariant) {
-                            const { delayChildren } = parentVariant.transition || {};
-                            options.delay = calcChildStagger(parent.enteringChildren, visualElement, delayChildren);
-                        }
-                    }
-                    return {
-                        animation: animation,
-                        options,
-                    };
-                }));
-            }
-        }
-        /**
-         * If there are some removed value that haven't been dealt with,
-         * we need to create a new animation that falls back either to the value
-         * defined in the style prop, or the last read value.
-         */
-        if (removedKeys.size) {
-            const fallbackAnimation = {};
-            /**
-             * If the initial prop contains a transition we can use that, otherwise
-             * allow the animation function to use the visual element's default.
-             */
-            if (typeof props.initial !== "boolean") {
-                const initialTransition = resolveVariant(visualElement, Array.isArray(props.initial)
-                    ? props.initial[0]
-                    : props.initial);
-                if (initialTransition && initialTransition.transition) {
-                    fallbackAnimation.transition = initialTransition.transition;
-                }
-            }
-            removedKeys.forEach((key) => {
-                const fallbackTarget = visualElement.getBaseTarget(key);
-                const motionValue = visualElement.getValue(key);
-                if (motionValue)
-                    motionValue.liveStyle = true;
-                // @ts-expect-error - @mattgperry to figure if we should do something here
-                fallbackAnimation[key] = fallbackTarget ?? null;
-            });
-            animations.push({ animation: fallbackAnimation });
-        }
-        let shouldAnimate = Boolean(animations.length);
-        if (isInitialRender &&
-            (props.initial === false || props.initial === props.animate) &&
-            !visualElement.manuallyAnimateOnMount) {
-            shouldAnimate = false;
-        }
-        isInitialRender = false;
-        return shouldAnimate ? animate(animations) : Promise.resolve();
-    }
-    /**
-     * Change whether a certain animation type is active.
-     */
-    function setActive(type, isActive) {
-        // If the active state hasn't changed, we can safely do nothing here
-        if (state[type].isActive === isActive)
-            return Promise.resolve();
-        // Propagate active change to children
-        visualElement.variantChildren?.forEach((child) => child.animationState?.setActive(type, isActive));
-        state[type].isActive = isActive;
-        const animations = animateChanges(type);
-        for (const key in state) {
-            state[key].protectedKeys = {};
-        }
-        return animations;
-    }
-    return {
-        animateChanges,
-        setActive,
-        setAnimateFunction,
-        getState: () => state,
-        reset: () => {
-            state = createState();
-            isInitialRender = true;
-        },
-    };
-}
-function checkVariantsDidChange(prev, next) {
-    if (typeof next === "string") {
-        return next !== prev;
-    }
-    else if (Array.isArray(next)) {
-        return !shallowCompare(next, prev);
-    }
-    return false;
-}
-function createTypeState(isActive = false) {
-    return {
-        isActive,
-        protectedKeys: {},
-        needsAnimating: {},
-        prevResolvedValues: {},
-    };
-}
-function createState() {
-    return {
-        animate: createTypeState(true),
-        whileInView: createTypeState(),
-        whileHover: createTypeState(),
-        whileTap: createTypeState(),
-        whileDrag: createTypeState(),
-        whileFocus: createTypeState(),
-        exit: createTypeState(),
-    };
-}
-
-export { checkVariantsDidChange, createAnimationState };

package/dist/node_modules/framer-motion/dist/es/render/utils/compare-by-depth.js

@@ -1,3 +0,0 @@
-const compareByDepth = (a, b) => a.depth - b.depth;
-
-export { compareByDepth };

package/dist/node_modules/framer-motion/dist/es/render/utils/flat-tree.js

@@ -1,24 +0,0 @@
-import { compareByDepth } from './compare-by-depth.js';
-import { addUniqueItem, removeItem } from '../../../../../motion-utils/dist/es/array.js';
-
-class FlatTree {
-    constructor() {
-        this.children = [];
-        this.isDirty = false;
-    }
-    add(child) {
-        addUniqueItem(this.children, child);
-        this.isDirty = true;
-    }
-    remove(child) {
-        removeItem(this.children, child);
-        this.isDirty = true;
-    }
-    forEach(callback) {
-        this.isDirty && this.children.sort(compareByDepth);
-        this.isDirty = false;
-        this.children.forEach(callback);
-    }
-}
-
-export { FlatTree };

package/dist/node_modules/framer-motion/dist/es/render/utils/get-variant-context.js

@@ -1,28 +0,0 @@
-import { isVariantLabel } from './is-variant-label.js';
-import { variantProps } from './variant-props.js';
-
-const numVariantProps = variantProps.length;
-function getVariantContext(visualElement) {
-    if (!visualElement)
-        return undefined;
-    if (!visualElement.isControllingVariants) {
-        const context = visualElement.parent
-            ? getVariantContext(visualElement.parent) || {}
-            : {};
-        if (visualElement.props.initial !== undefined) {
-            context.initial = visualElement.props.initial;
-        }
-        return context;
-    }
-    const context = {};
-    for (let i = 0; i < numVariantProps; i++) {
-        const name = variantProps[i];
-        const prop = visualElement.props[name];
-        if (isVariantLabel(prop) || prop === false) {
-            context[name] = prop;
-        }
-    }
-    return context;
-}
-
-export { getVariantContext };

package/dist/node_modules/framer-motion/dist/es/render/utils/is-controlling-variants.js

@@ -1,13 +0,0 @@
-import { isAnimationControls } from '../../animation/utils/is-animation-controls.js';
-import { isVariantLabel } from './is-variant-label.js';
-import { variantProps } from './variant-props.js';
-
-function isControllingVariants(props) {
-    return (isAnimationControls(props.animate) ||
-        variantProps.some((name) => isVariantLabel(props[name])));
-}
-function isVariantNode(props) {
-    return Boolean(isControllingVariants(props) || props.variants);
-}
-
-export { isControllingVariants, isVariantNode };

package/dist/node_modules/framer-motion/dist/es/render/utils/is-variant-label.js

@@ -1,8 +0,0 @@
-/**
- * Decides if the supplied variable is variant label
- */
-function isVariantLabel(v) {
-    return typeof v === "string" || Array.isArray(v);
-}
-
-export { isVariantLabel };

package/dist/node_modules/framer-motion/dist/es/render/utils/motion-values.js

@@ -1,51 +0,0 @@
-import { isMotionValue } from '../../../../../motion-dom/dist/es/value/utils/is-motion-value.js';
-import { motionValue } from '../../../../../motion-dom/dist/es/value/index.js';
-
-function updateMotionValuesFromProps(element, next, prev) {
-    for (const key in next) {
-        const nextValue = next[key];
-        const prevValue = prev[key];
-        if (isMotionValue(nextValue)) {
-            /**
-             * If this is a motion value found in props or style, we want to add it
-             * to our visual element's motion value map.
-             */
-            element.addValue(key, nextValue);
-        }
-        else if (isMotionValue(prevValue)) {
-            /**
-             * If we're swapping from a motion value to a static value,
-             * create a new motion value from that
-             */
-            element.addValue(key, motionValue(nextValue, { owner: element }));
-        }
-        else if (prevValue !== nextValue) {
-            /**
-             * If this is a flat value that has changed, update the motion value
-             * or create one if it doesn't exist. We only want to do this if we're
-             * not handling the value with our animation state.
-             */
-            if (element.hasValue(key)) {
-                const existingValue = element.getValue(key);
-                if (existingValue.liveStyle === true) {
-                    existingValue.jump(nextValue);
-                }
-                else if (!existingValue.hasAnimated) {
-                    existingValue.set(nextValue);
-                }
-            }
-            else {
-                const latestValue = element.getStaticValue(key);
-                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));
-            }
-        }
-    }
-    // Handle removed values
-    for (const key in prev) {
-        if (next[key] === undefined)
-            element.removeValue(key);
-    }
-    return next;
-}
-
-export { updateMotionValuesFromProps };

package/dist/node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.js

@@ -1,8 +0,0 @@
-import { resolveVariantFromProps } from './resolve-variants.js';
-
-function resolveVariant(visualElement, definition, custom) {
-    const props = visualElement.getProps();
-    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, visualElement);
-}
-
-export { resolveVariant };

package/dist/node_modules/framer-motion/dist/es/render/utils/resolve-variants.js

@@ -1,36 +0,0 @@
-function getValueState(visualElement) {
-    const state = [{}, {}];
-    visualElement?.values.forEach((value, key) => {
-        state[0][key] = value.get();
-        state[1][key] = value.getVelocity();
-    });
-    return state;
-}
-function resolveVariantFromProps(props, definition, custom, visualElement) {
-    /**
-     * If the variant definition is a function, resolve.
-     */
-    if (typeof definition === "function") {
-        const [current, velocity] = getValueState(visualElement);
-        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);
-    }
-    /**
-     * If the variant definition is a variant label, or
-     * the function returned a variant label, resolve.
-     */
-    if (typeof definition === "string") {
-        definition = props.variants && props.variants[definition];
-    }
-    /**
-     * At this point we've resolved both functions and variant labels,
-     * but the resolved variant label might itself have been a function.
-     * If so, resolve. This can only have returned a valid target object.
-     */
-    if (typeof definition === "function") {
-        const [current, velocity] = getValueState(visualElement);
-        definition = definition(custom !== undefined ? custom : props.custom, current, velocity);
-    }
-    return definition;
-}
-
-export { resolveVariantFromProps };

package/dist/node_modules/framer-motion/dist/es/render/utils/setters.js

@@ -1,31 +0,0 @@
-import { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.js';
-import { resolveVariant } from './resolve-dynamic-variants.js';
-import { motionValue } from '../../../../../motion-dom/dist/es/value/index.js';
-
-/**
- * Set VisualElement's MotionValue, creating a new MotionValue for it if
- * it doesn't exist.
- */
-function setMotionValue(visualElement, key, value) {
-    if (visualElement.hasValue(key)) {
-        visualElement.getValue(key).set(value);
-    }
-    else {
-        visualElement.addValue(key, motionValue(value));
-    }
-}
-function resolveFinalValueInKeyframes(v) {
-    // TODO maybe throw if v.length - 1 is placeholder token?
-    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
-}
-function setTarget(visualElement, definition) {
-    const resolved = resolveVariant(visualElement, definition);
-    let { transitionEnd = {}, transition = {}, ...target } = resolved || {};
-    target = { ...target, ...transitionEnd };
-    for (const key in target) {
-        const value = resolveFinalValueInKeyframes(target[key]);
-        setMotionValue(visualElement, key, value);
-    }
-}
-
-export { setTarget };

package/dist/node_modules/framer-motion/dist/es/render/utils/variant-props.js

@@ -1,12 +0,0 @@
-const variantPriorityOrder = [
-    "animate",
-    "whileInView",
-    "whileFocus",
-    "whileHover",
-    "whileTap",
-    "whileDrag",
-    "exit",
-];
-const variantProps = ["initial", ...variantPriorityOrder];
-
-export { variantPriorityOrder, variantProps };

package/dist/node_modules/framer-motion/dist/es/utils/delay.js

@@ -1,20 +0,0 @@
-import { time } from '../../../../motion-dom/dist/es/frameloop/sync-time.js';
-import { frame, cancelFrame } from '../../../../motion-dom/dist/es/frameloop/frame.js';
-
-/**
- * Timeout defined in ms
- */
-function delay(callback, timeout) {
-    const start = time.now();
-    const checkElapsed = ({ timestamp }) => {
-        const elapsed = timestamp - start;
-        if (elapsed >= timeout) {
-            cancelFrame(checkElapsed);
-            callback(elapsed - timeout);
-        }
-    };
-    frame.setup(checkElapsed, true);
-    return () => cancelFrame(checkElapsed);
-}
-
-export { delay };

package/dist/node_modules/framer-motion/dist/es/utils/distance.js

@@ -1,9 +0,0 @@
-const distance = (a, b) => Math.abs(a - b);
-function distance2D(a, b) {
-    // Multi-dimensional
-    const xDelta = distance(a.x, b.x);
-    const yDelta = distance(a.y, b.y);
-    return Math.sqrt(xDelta ** 2 + yDelta ** 2);
-}
-
-export { distance, distance2D };

package/dist/node_modules/framer-motion/dist/es/utils/get-context-window.js

@@ -1,6 +0,0 @@
-// Fixes https://github.com/motiondivision/motion/issues/2270
-const getContextWindow = ({ current }) => {
-    return current ? current.ownerDocument.defaultView : null;
-};
-
-export { getContextWindow };

package/dist/node_modules/framer-motion/dist/es/utils/is-browser.js

@@ -1,3 +0,0 @@
-const isBrowser = typeof window !== "undefined";
-
-export { isBrowser };

package/dist/node_modules/framer-motion/dist/es/utils/is-ref-object.js

@@ -1,7 +0,0 @@
-function isRefObject(ref) {
-    return (ref &&
-        typeof ref === "object" &&
-        Object.prototype.hasOwnProperty.call(ref, "current"));
-}
-
-export { isRefObject };