flikkui 0.1.0-beta.11 → 0.1.0-beta.12

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/motion-value.js

@@ -1,103 +0,0 @@
-import { getFinalKeyframe } from '../animators/waapi/utils/get-final-keyframe.js';
-import { getDefaultTransition } from '../utils/default-transitions.js';
-import { isTransitionDefined } from '../utils/is-transition-defined.js';
-import { getValueTransition } from '../../../../../motion-dom/dist/es/animation/utils/get-value-transition.js';
-import { secondsToMilliseconds } from '../../../../../motion-utils/dist/es/time-conversion.js';
-import { makeAnimationInstant } from '../../../../../motion-dom/dist/es/animation/utils/make-animation-instant.js';
-import { MotionGlobalConfig } from '../../../../../motion-utils/dist/es/global-config.js';
-import { frame } from '../../../../../motion-dom/dist/es/frameloop/frame.js';
-import { JSAnimation } from '../../../../../motion-dom/dist/es/animation/JSAnimation.js';
-import { AsyncMotionValueAnimation } from '../../../../../motion-dom/dist/es/animation/AsyncMotionValueAnimation.js';
-
-const animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
-    const valueTransition = getValueTransition(transition, name) || {};
-    /**
-     * Most transition values are currently completely overwritten by value-specific
-     * transitions. In the future it'd be nicer to blend these transitions. But for now
-     * delay actually does inherit from the root transition if not value-specific.
-     */
-    const delay = valueTransition.delay || transition.delay || 0;
-    /**
-     * Elapsed isn't a public transition option but can be passed through from
-     * optimized appear effects in milliseconds.
-     */
-    let { elapsed = 0 } = transition;
-    elapsed = elapsed - secondsToMilliseconds(delay);
-    const options = {
-        keyframes: Array.isArray(target) ? target : [null, target],
-        ease: "easeOut",
-        velocity: value.getVelocity(),
-        ...valueTransition,
-        delay: -elapsed,
-        onUpdate: (v) => {
-            value.set(v);
-            valueTransition.onUpdate && valueTransition.onUpdate(v);
-        },
-        onComplete: () => {
-            onComplete();
-            valueTransition.onComplete && valueTransition.onComplete();
-        },
-        name,
-        motionValue: value,
-        element: isHandoff ? undefined : element,
-    };
-    /**
-     * If there's no transition defined for this value, we can generate
-     * unique transition settings for this value.
-     */
-    if (!isTransitionDefined(valueTransition)) {
-        Object.assign(options, getDefaultTransition(name, options));
-    }
-    /**
-     * Both WAAPI and our internal animation functions use durations
-     * as defined by milliseconds, while our external API defines them
-     * as seconds.
-     */
-    options.duration && (options.duration = secondsToMilliseconds(options.duration));
-    options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));
-    /**
-     * Support deprecated way to set initial value. Prefer keyframe syntax.
-     */
-    if (options.from !== undefined) {
-        options.keyframes[0] = options.from;
-    }
-    let shouldSkip = false;
-    if (options.type === false ||
-        (options.duration === 0 && !options.repeatDelay)) {
-        makeAnimationInstant(options);
-        if (options.delay === 0) {
-            shouldSkip = true;
-        }
-    }
-    if (MotionGlobalConfig.instantAnimations ||
-        MotionGlobalConfig.skipAnimations) {
-        shouldSkip = true;
-        makeAnimationInstant(options);
-        options.delay = 0;
-    }
-    /**
-     * If the transition type or easing has been explicitly set by the user
-     * then we don't want to allow flattening the animation.
-     */
-    options.allowFlatten = !valueTransition.type && !valueTransition.ease;
-    /**
-     * If we can or must skip creating the animation, and apply only
-     * the final keyframe, do so. We also check once keyframes are resolved but
-     * this early check prevents the need to create an animation at all.
-     */
-    if (shouldSkip && !isHandoff && value.get() !== undefined) {
-        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);
-        if (finalKeyframe !== undefined) {
-            frame.update(() => {
-                options.onUpdate(finalKeyframe);
-                options.onComplete();
-            });
-            return;
-        }
-    }
-    return valueTransition.isSync
-        ? new JSAnimation(options)
-        : new AsyncMotionValueAnimation(options);
-};
-
-export { animateMotionValue };

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.js

@@ -1,85 +0,0 @@
-import { setTarget } from '../../render/utils/setters.js';
-import { addValueToWillChange } from '../../value/use-will-change/add-will-change.js';
-import { getOptimisedAppearId } from '../optimized-appear/get-appear-id.js';
-import { animateMotionValue } from './motion-value.js';
-import { getValueTransition } from '../../../../../motion-dom/dist/es/animation/utils/get-value-transition.js';
-import { frame } from '../../../../../motion-dom/dist/es/frameloop/frame.js';
-import { positionalKeys } from '../../../../../motion-dom/dist/es/render/utils/keys-position.js';
-
-/**
- * Decide whether we should block this animation. Previously, we achieved this
- * just by checking whether the key was listed in protectedKeys, but this
- * posed problems if an animation was triggered by afterChildren and protectedKeys
- * had been set to true in the meantime.
- */
-function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
-    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
-    needsAnimating[key] = false;
-    return shouldBlock;
-}
-function animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {
-    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;
-    if (transitionOverride)
-        transition = transitionOverride;
-    const animations = [];
-    const animationTypeState = type &&
-        visualElement.animationState &&
-        visualElement.animationState.getState()[type];
-    for (const key in target) {
-        const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);
-        const valueTarget = target[key];
-        if (valueTarget === undefined ||
-            (animationTypeState &&
-                shouldBlockAnimation(animationTypeState, key))) {
-            continue;
-        }
-        const valueTransition = {
-            delay,
-            ...getValueTransition(transition || {}, key),
-        };
-        /**
-         * If the value is already at the defined target, skip the animation.
-         */
-        const currentValue = value.get();
-        if (currentValue !== undefined &&
-            !value.isAnimating &&
-            !Array.isArray(valueTarget) &&
-            valueTarget === currentValue &&
-            !valueTransition.velocity) {
-            continue;
-        }
-        /**
-         * If this is the first time a value is being animated, check
-         * to see if we're handling off from an existing animation.
-         */
-        let isHandoff = false;
-        if (window.MotionHandoffAnimation) {
-            const appearId = getOptimisedAppearId(visualElement);
-            if (appearId) {
-                const startTime = window.MotionHandoffAnimation(appearId, key, frame);
-                if (startTime !== null) {
-                    valueTransition.startTime = startTime;
-                    isHandoff = true;
-                }
-            }
-        }
-        addValueToWillChange(visualElement, key);
-        value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && positionalKeys.has(key)
-            ? { type: false }
-            : valueTransition, visualElement, isHandoff));
-        const animation = value.animation;
-        if (animation) {
-            animations.push(animation);
-        }
-    }
-    if (transitionEnd) {
-        Promise.all(animations).then(() => {
-            frame.update(() => {
-                transitionEnd && setTarget(visualElement, transitionEnd);
-            });
-        });
-    }
-    return animations;
-}
-
-export { animateTarget };

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.js

@@ -1,59 +0,0 @@
-import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.js';
-import { calcChildStagger } from '../utils/calc-child-stagger.js';
-import { animateTarget } from './visual-element-target.js';
-
-function animateVariant(visualElement, variant, options = {}) {
-    const resolved = resolveVariant(visualElement, variant, options.type === "exit"
-        ? visualElement.presenceContext?.custom
-        : undefined);
-    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
-    if (options.transitionOverride) {
-        transition = options.transitionOverride;
-    }
-    /**
-     * If we have a variant, create a callback that runs it as an animation.
-     * Otherwise, we resolve a Promise immediately for a composable no-op.
-     */
-    const getAnimation = resolved
-        ? () => Promise.all(animateTarget(visualElement, resolved, options))
-        : () => Promise.resolve();
-    /**
-     * If we have children, create a callback that runs all their animations.
-     * Otherwise, we resolve a Promise immediately for a composable no-op.
-     */
-    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size
-        ? (forwardDelay = 0) => {
-            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;
-            return animateChildren(visualElement, variant, forwardDelay, delayChildren, staggerChildren, staggerDirection, options);
-        }
-        : () => Promise.resolve();
-    /**
-     * If the transition explicitly defines a "when" option, we need to resolve either
-     * this animation or all children animations before playing the other.
-     */
-    const { when } = transition;
-    if (when) {
-        const [first, last] = when === "beforeChildren"
-            ? [getAnimation, getChildAnimations]
-            : [getChildAnimations, getAnimation];
-        return first().then(() => last());
-    }
-    else {
-        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);
-    }
-}
-function animateChildren(visualElement, variant, delay = 0, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {
-    const animations = [];
-    for (const child of visualElement.variantChildren) {
-        child.notify("AnimationStart", variant);
-        animations.push(animateVariant(child, variant, {
-            ...options,
-            delay: delay +
-                (typeof delayChildren === "function" ? 0 : delayChildren) +
-                calcChildStagger(visualElement.variantChildren, child, delayChildren, staggerChildren, staggerDirection),
-        }).then(() => child.notify("AnimationComplete", variant)));
-    }
-    return Promise.all(animations);
-}
-
-export { animateVariant };

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element.js

@@ -1,26 +0,0 @@
-import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.js';
-import { animateTarget } from './visual-element-target.js';
-import { animateVariant } from './visual-element-variant.js';
-
-function animateVisualElement(visualElement, definition, options = {}) {
-    visualElement.notify("AnimationStart", definition);
-    let animation;
-    if (Array.isArray(definition)) {
-        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));
-        animation = Promise.all(animations);
-    }
-    else if (typeof definition === "string") {
-        animation = animateVariant(visualElement, definition, options);
-    }
-    else {
-        const resolvedDefinition = typeof definition === "function"
-            ? resolveVariant(visualElement, definition, options.custom)
-            : definition;
-        animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));
-    }
-    return animation.then(() => {
-        visualElement.notify("AnimationComplete", definition);
-    });
-}
-
-export { animateVisualElement };

package/dist/node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.js

@@ -1,6 +0,0 @@
-import { camelToDash } from '../../render/dom/utils/camel-to-dash.js';
-
-const optimizedAppearDataId = "framerAppearId";
-const optimizedAppearDataAttribute = "data-" + camelToDash(optimizedAppearDataId);
-
-export { optimizedAppearDataAttribute, optimizedAppearDataId };

package/dist/node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.js

@@ -1,7 +0,0 @@
-import { optimizedAppearDataAttribute } from './data-id.js';
-
-function getOptimisedAppearId(visualElement) {
-    return visualElement.props[optimizedAppearDataAttribute];
-}
-
-export { getOptimisedAppearId };

package/dist/node_modules/framer-motion/dist/es/animation/utils/calc-child-stagger.js

@@ -1,15 +0,0 @@
-function calcChildStagger(children, child, delayChildren, staggerChildren = 0, staggerDirection = 1) {
-    const index = Array.from(children)
-        .sort((a, b) => a.sortNodePosition(b))
-        .indexOf(child);
-    const numChildren = children.size;
-    const maxStaggerDuration = (numChildren - 1) * staggerChildren;
-    const delayIsFunction = typeof delayChildren === "function";
-    return delayIsFunction
-        ? delayChildren(index, numChildren)
-        : staggerDirection === 1
-            ? index * staggerChildren
-            : maxStaggerDuration - index * staggerChildren;
-}
-
-export { calcChildStagger };

package/dist/node_modules/framer-motion/dist/es/animation/utils/default-transitions.js

@@ -1,40 +0,0 @@
-import { transformProps } from '../../../../../motion-dom/dist/es/render/utils/keys-transform.js';
-
-const underDampedSpring = {
-    type: "spring",
-    stiffness: 500,
-    damping: 25,
-    restSpeed: 10,
-};
-const criticallyDampedSpring = (target) => ({
-    type: "spring",
-    stiffness: 550,
-    damping: target === 0 ? 2 * Math.sqrt(550) : 30,
-    restSpeed: 10,
-});
-const keyframesTransition = {
-    type: "keyframes",
-    duration: 0.8,
-};
-/**
- * Default easing curve is a slightly shallower version of
- * the default browser easing curve.
- */
-const ease = {
-    type: "keyframes",
-    ease: [0.25, 0.1, 0.35, 1],
-    duration: 0.3,
-};
-const getDefaultTransition = (valueKey, { keyframes }) => {
-    if (keyframes.length > 2) {
-        return keyframesTransition;
-    }
-    else if (transformProps.has(valueKey)) {
-        return valueKey.startsWith("scale")
-            ? criticallyDampedSpring(keyframes[1])
-            : underDampedSpring;
-    }
-    return ease;
-};
-
-export { getDefaultTransition };

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

@@ -1,7 +0,0 @@
-function isAnimationControls(v) {
-    return (v !== null &&
-        typeof v === "object" &&
-        typeof v.start === "function");
-}
-
-export { isAnimationControls };

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.js

@@ -1,5 +0,0 @@
-const isKeyframesTarget = (v) => {
-    return Array.isArray(v);
-};
-
-export { isKeyframesTarget };

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-transition-defined.js

@@ -1,10 +0,0 @@
-/**
- * Decide whether a transition is defined on a given Transition.
- * This filters out orchestration options and returns true
- * if any options are left.
- */
-function isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {
-    return !!Object.keys(transition).length;
-}
-
-export { isTransitionDefined };

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.js

@@ -1,87 +0,0 @@
-import { j as jsxRuntimeExports } from '../../../../../../_virtual/jsx-runtime.js';
-import * as React from 'react';
-import { useId, useRef, useContext, useInsertionEffect } from 'react';
-import { MotionConfigContext } from '../../context/MotionConfigContext.js';
-import { isHTMLElement } from '../../../../../motion-dom/dist/es/utils/is-html-element.js';
-
-/**
- * Measurement functionality has to be within a separate component
- * to leverage snapshot lifecycle.
- */
-class PopChildMeasure extends React.Component {
-    getSnapshotBeforeUpdate(prevProps) {
-        const element = this.props.childRef.current;
-        if (element && prevProps.isPresent && !this.props.isPresent) {
-            const parent = element.offsetParent;
-            const parentWidth = isHTMLElement(parent)
-                ? parent.offsetWidth || 0
-                : 0;
-            const size = this.props.sizeRef.current;
-            size.height = element.offsetHeight || 0;
-            size.width = element.offsetWidth || 0;
-            size.top = element.offsetTop;
-            size.left = element.offsetLeft;
-            size.right = parentWidth - size.width - size.left;
-        }
-        return null;
-    }
-    /**
-     * Required with getSnapshotBeforeUpdate to stop React complaining.
-     */
-    componentDidUpdate() { }
-    render() {
-        return this.props.children;
-    }
-}
-function PopChild({ children, isPresent, anchorX, root }) {
-    const id = useId();
-    const ref = useRef(null);
-    const size = useRef({
-        width: 0,
-        height: 0,
-        top: 0,
-        left: 0,
-        right: 0,
-    });
-    const { nonce } = useContext(MotionConfigContext);
-    /**
-     * We create and inject a style block so we can apply this explicit
-     * sizing in a non-destructive manner by just deleting the style block.
-     *
-     * We can't apply size via render as the measurement happens
-     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the
-     * styles directly on the DOM node, we might be overwriting
-     * styles set via the style prop.
-     */
-    useInsertionEffect(() => {
-        const { width, height, top, left, right } = size.current;
-        if (isPresent || !ref.current || !width || !height)
-            return;
-        const x = anchorX === "left" ? `left: ${left}` : `right: ${right}`;
-        ref.current.dataset.motionPopId = id;
-        const style = document.createElement("style");
-        if (nonce)
-            style.nonce = nonce;
-        const parent = root ?? document.head;
-        parent.appendChild(style);
-        if (style.sheet) {
-            style.sheet.insertRule(`
-          [data-motion-pop-id="${id}"] {
-            position: absolute !important;
-            width: ${width}px !important;
-            height: ${height}px !important;
-            ${x}px !important;
-            top: ${top}px !important;
-          }
-        `);
-        }
-        return () => {
-            if (parent.contains(style)) {
-                parent.removeChild(style);
-            }
-        };
-    }, [isPresent]);
-    return (jsxRuntimeExports.jsx(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: React.cloneElement(children, { ref }) }));
-}
-
-export { PopChild };

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.js

@@ -1,63 +0,0 @@
-import { j as jsxRuntimeExports } from '../../../../../../_virtual/jsx-runtime.js';
-import * as React from 'react';
-import { useId, useMemo } from 'react';
-import { PresenceContext } from '../../context/PresenceContext.js';
-import { useConstant } from '../../utils/use-constant.js';
-import { PopChild } from './PopChild.js';
-
-const PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, anchorX, root }) => {
-    const presenceChildren = useConstant(newChildrenMap);
-    const id = useId();
-    let isReusedContext = true;
-    let context = useMemo(() => {
-        isReusedContext = false;
-        return {
-            id,
-            initial,
-            isPresent,
-            custom,
-            onExitComplete: (childId) => {
-                presenceChildren.set(childId, true);
-                for (const isComplete of presenceChildren.values()) {
-                    if (!isComplete)
-                        return; // can stop searching when any is incomplete
-                }
-                onExitComplete && onExitComplete();
-            },
-            register: (childId) => {
-                presenceChildren.set(childId, false);
-                return () => presenceChildren.delete(childId);
-            },
-        };
-    }, [isPresent, presenceChildren, onExitComplete]);
-    /**
-     * If the presence of a child affects the layout of the components around it,
-     * we want to make a new context value to ensure they get re-rendered
-     * so they can detect that layout change.
-     */
-    if (presenceAffectsLayout && isReusedContext) {
-        context = { ...context };
-    }
-    useMemo(() => {
-        presenceChildren.forEach((_, key) => presenceChildren.set(key, false));
-    }, [isPresent]);
-    /**
-     * If there's no `motion` components to fire exit animations, we want to remove this
-     * component immediately.
-     */
-    React.useEffect(() => {
-        !isPresent &&
-            !presenceChildren.size &&
-            onExitComplete &&
-            onExitComplete();
-    }, [isPresent]);
-    if (mode === "popLayout") {
-        children = (jsxRuntimeExports.jsx(PopChild, { isPresent: isPresent, anchorX: anchorX, root: root, children: children }));
-    }
-    return (jsxRuntimeExports.jsx(PresenceContext.Provider, { value: context, children: children }));
-};
-function newChildrenMap() {
-    return new Map();
-}
-
-export { PresenceChild };