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

package/dist/node_modules/framer-motion/dist/es/utils/reduced-motion/index.js

@@ -1,19 +0,0 @@
-import { isBrowser } from '../is-browser.js';
-import { hasReducedMotionListener, prefersReducedMotion } from './state.js';
-
-function initPrefersReducedMotion() {
-    hasReducedMotionListener.current = true;
-    if (!isBrowser)
-        return;
-    if (window.matchMedia) {
-        const motionMediaQuery = window.matchMedia("(prefers-reduced-motion)");
-        const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);
-        motionMediaQuery.addEventListener("change", setReducedMotionPreferences);
-        setReducedMotionPreferences();
-    }
-    else {
-        prefersReducedMotion.current = false;
-    }
-}
-
-export { initPrefersReducedMotion };

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

@@ -1,5 +0,0 @@
-// Does this device prefer reduced motion? Returns `null` server-side.
-const prefersReducedMotion = { current: null };
-const hasReducedMotionListener = { current: false };
-
-export { hasReducedMotionListener, prefersReducedMotion };

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

@@ -1,47 +0,0 @@
-import { useState } from 'react';
-import { initPrefersReducedMotion } from './index.js';
-import { hasReducedMotionListener, prefersReducedMotion } from './state.js';
-import { warnOnce } from '../../../../../motion-utils/dist/es/warn-once.js';
-
-/**
- * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.
- *
- * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing
- * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.
- *
- * It will actively respond to changes and re-render your components with the latest setting.
- *
- * ```jsx
- * export function Sidebar({ isOpen }) {
- *   const shouldReduceMotion = useReducedMotion()
- *   const closedX = shouldReduceMotion ? 0 : "-100%"
- *
- *   return (
- *     <motion.div animate={{
- *       opacity: isOpen ? 1 : 0,
- *       x: isOpen ? 0 : closedX
- *     }} />
- *   )
- * }
- * ```
- *
- * @return boolean
- *
- * @public
- */
-function useReducedMotion() {
-    /**
-     * Lazy initialisation of prefersReducedMotion
-     */
-    !hasReducedMotionListener.current && initPrefersReducedMotion();
-    const [shouldReduceMotion] = useState(prefersReducedMotion.current);
-    if (process.env.NODE_ENV !== "production") {
-        warnOnce(shouldReduceMotion !== true, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled");
-    }
-    /**
-     * TODO See if people miss automatically updating shouldReduceMotion setting
-     */
-    return shouldReduceMotion;
-}
-
-export { useReducedMotion };

package/dist/node_modules/framer-motion/dist/es/utils/shallow-compare.js

@@ -1,14 +0,0 @@
-function shallowCompare(next, prev) {
-    if (!Array.isArray(prev))
-        return false;
-    const prevLength = prev.length;
-    if (prevLength !== next.length)
-        return false;
-    for (let i = 0; i < prevLength; i++) {
-        if (prev[i] !== next[i])
-            return false;
-    }
-    return true;
-}
-
-export { shallowCompare };

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

@@ -1,18 +0,0 @@
-import { useRef } from 'react';
-
-/**
- * Creates a constant value over the lifecycle of a component.
- *
- * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer
- * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`
- * you can ensure that initialisers don't execute twice or more.
- */
-function useConstant(init) {
-    const ref = useRef(null);
-    if (ref.current === null) {
-        ref.current = init();
-    }
-    return ref.current;
-}
-
-export { useConstant };

package/dist/node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.js

@@ -1,6 +0,0 @@
-import { useLayoutEffect, useEffect } from 'react';
-import { isBrowser } from './is-browser.js';
-
-const useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;
-
-export { useIsomorphicLayoutEffect };

package/dist/node_modules/framer-motion/dist/es/value/use-combine-values.js

@@ -1,37 +0,0 @@
-import { useIsomorphicLayoutEffect } from '../utils/use-isomorphic-effect.js';
-import { useMotionValue } from './use-motion-value.js';
-import { frame, cancelFrame } from '../../../../motion-dom/dist/es/frameloop/frame.js';
-
-function useCombineMotionValues(values, combineValues) {
-    /**
-     * Initialise the returned motion value. This remains the same between renders.
-     */
-    const value = useMotionValue(combineValues());
-    /**
-     * Create a function that will update the template motion value with the latest values.
-     * This is pre-bound so whenever a motion value updates it can schedule its
-     * execution in Framesync. If it's already been scheduled it won't be fired twice
-     * in a single frame.
-     */
-    const updateValue = () => value.set(combineValues());
-    /**
-     * Synchronously update the motion value with the latest values during the render.
-     * This ensures that within a React render, the styles applied to the DOM are up-to-date.
-     */
-    updateValue();
-    /**
-     * Subscribe to all motion values found within the template. Whenever any of them change,
-     * schedule an update.
-     */
-    useIsomorphicLayoutEffect(() => {
-        const scheduleUpdate = () => frame.preRender(updateValue, false, true);
-        const subscriptions = values.map((v) => v.on("change", scheduleUpdate));
-        return () => {
-            subscriptions.forEach((unsubscribe) => unsubscribe());
-            cancelFrame(updateValue);
-        };
-    });
-    return value;
-}
-
-export { useCombineMotionValues };

package/dist/node_modules/framer-motion/dist/es/value/use-computed.js

@@ -1,19 +0,0 @@
-import { useCombineMotionValues } from './use-combine-values.js';
-import { collectMotionValues } from '../../../../motion-dom/dist/es/value/index.js';
-
-function useComputed(compute) {
-    /**
-     * Open session of collectMotionValues. Any MotionValue that calls get()
-     * will be saved into this array.
-     */
-    collectMotionValues.current = [];
-    compute();
-    const value = useCombineMotionValues(collectMotionValues.current, compute);
-    /**
-     * Synchronously close session of collectMotionValues.
-     */
-    collectMotionValues.current = undefined;
-    return value;
-}
-
-export { useComputed };

package/dist/node_modules/framer-motion/dist/es/value/use-motion-value.js

@@ -1,38 +0,0 @@
-import { useContext, useState, useEffect } from 'react';
-import { MotionConfigContext } from '../context/MotionConfigContext.js';
-import { useConstant } from '../utils/use-constant.js';
-import { motionValue } from '../../../../motion-dom/dist/es/value/index.js';
-
-/**
- * Creates a `MotionValue` to track the state and velocity of a value.
- *
- * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.
- *
- * ```jsx
- * export const MyComponent = () => {
- *   const scale = useMotionValue(1)
- *
- *   return <motion.div style={{ scale }} />
- * }
- * ```
- *
- * @param initial - The initial state.
- *
- * @public
- */
-function useMotionValue(initial) {
-    const value = useConstant(() => motionValue(initial));
-    /**
-     * If this motion value is being used in static mode, like on
-     * the Framer canvas, force components to rerender when the motion
-     * value is updated.
-     */
-    const { isStatic } = useContext(MotionConfigContext);
-    if (isStatic) {
-        const [, setLatest] = useState(initial);
-        useEffect(() => value.on("change", setLatest), []);
-    }
-    return value;
-}
-
-export { useMotionValue };

package/dist/node_modules/framer-motion/dist/es/value/use-spring.js

@@ -1,22 +0,0 @@
-import { useContext, useInsertionEffect } from 'react';
-import { MotionConfigContext } from '../context/MotionConfigContext.js';
-import { useMotionValue } from './use-motion-value.js';
-import { useTransform } from './use-transform.js';
-import { attachSpring } from '../../../../motion-dom/dist/es/value/spring-value.js';
-import { isMotionValue } from '../../../../motion-dom/dist/es/value/utils/is-motion-value.js';
-
-function useSpring(source, options = {}) {
-    const { isStatic } = useContext(MotionConfigContext);
-    const getFromSource = () => (isMotionValue(source) ? source.get() : source);
-    // isStatic will never change, allowing early hooks return
-    if (isStatic) {
-        return useTransform(getFromSource);
-    }
-    const value = useMotionValue(getFromSource());
-    useInsertionEffect(() => {
-        return attachSpring(value, source, options);
-    }, [value, JSON.stringify(options)]);
-    return value;
-}
-
-export { useSpring };

package/dist/node_modules/framer-motion/dist/es/value/use-transform.js

@@ -1,27 +0,0 @@
-import { useConstant } from '../utils/use-constant.js';
-import { useCombineMotionValues } from './use-combine-values.js';
-import { useComputed } from './use-computed.js';
-import { transform } from '../../../../motion-dom/dist/es/utils/transform.js';
-
-function useTransform(input, inputRangeOrTransformer, outputRange, options) {
-    if (typeof input === "function") {
-        return useComputed(input);
-    }
-    const transformer = transform(inputRangeOrTransformer, outputRange, options);
-    return Array.isArray(input)
-        ? useListTransform(input, transformer)
-        : useListTransform([input], ([latest]) => transformer(latest));
-}
-function useListTransform(values, transformer) {
-    const latest = useConstant(() => []);
-    return useCombineMotionValues(values, () => {
-        latest.length = 0;
-        const numValues = values.length;
-        for (let i = 0; i < numValues; i++) {
-            latest[i] = values[i].get();
-        }
-        return transformer(latest);
-    });
-}
-
-export { useTransform };

package/dist/node_modules/framer-motion/dist/es/value/use-will-change/add-will-change.js

@@ -1,20 +0,0 @@
-import { isWillChangeMotionValue } from './is.js';
-import { MotionGlobalConfig } from '../../../../../motion-utils/dist/es/global-config.js';
-
-function addValueToWillChange(visualElement, key) {
-    const willChange = visualElement.getValue("willChange");
-    /**
-     * It could be that a user has set willChange to a regular MotionValue,
-     * in which case we can't add the value to it.
-     */
-    if (isWillChangeMotionValue(willChange)) {
-        return willChange.add(key);
-    }
-    else if (!willChange && MotionGlobalConfig.WillChange) {
-        const newWillChange = new MotionGlobalConfig.WillChange("auto");
-        visualElement.addValue("willChange", newWillChange);
-        newWillChange.add(key);
-    }
-}
-
-export { addValueToWillChange };

package/dist/node_modules/framer-motion/dist/es/value/use-will-change/is.js

@@ -1,7 +0,0 @@
-import { isMotionValue } from '../../../../../motion-dom/dist/es/value/utils/is-motion-value.js';
-
-function isWillChangeMotionValue(value) {
-    return Boolean(isMotionValue(value) && value.add);
-}
-
-export { isWillChangeMotionValue };

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

@@ -1,12 +0,0 @@
-import { isMotionValue } from '../../../../../motion-dom/dist/es/value/utils/is-motion-value.js';
-
-/**
- * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself
- *
- * TODO: Remove and move to library
- */
-function resolveMotionValue(value) {
-    return isMotionValue(value) ? value.get() : value;
-}
-
-export { resolveMotionValue };

package/dist/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.js

@@ -1,176 +0,0 @@
-import { time } from '../frameloop/sync-time.js';
-import { JSAnimation } from './JSAnimation.js';
-import { getFinalKeyframe } from './keyframes/get-final.js';
-import { KeyframeResolver, flushKeyframeResolvers } from './keyframes/KeyframesResolver.js';
-import { NativeAnimationExtended } from './NativeAnimationExtended.js';
-import { canAnimate } from './utils/can-animate.js';
-import { makeAnimationInstant } from './utils/make-animation-instant.js';
-import { WithPromise } from './utils/WithPromise.js';
-import { supportsBrowserAnimation } from './waapi/supports/waapi.js';
-import { MotionGlobalConfig } from '../../../../motion-utils/dist/es/global-config.js';
-import { noop } from '../../../../motion-utils/dist/es/noop.js';
-
-/**
- * Maximum time allowed between an animation being created and it being
- * resolved for us to use the latter as the start time.
- *
- * This is to ensure that while we prefer to "start" an animation as soon
- * as it's triggered, we also want to avoid a visual jump if there's a big delay
- * between these two moments.
- */
-const MAX_RESOLVE_DELAY = 40;
-class AsyncMotionValueAnimation extends WithPromise {
-    constructor({ autoplay = true, delay = 0, type = "keyframes", repeat = 0, repeatDelay = 0, repeatType = "loop", keyframes, name, motionValue, element, ...options }) {
-        super();
-        /**
-         * Bound to support return animation.stop pattern
-         */
-        this.stop = () => {
-            if (this._animation) {
-                this._animation.stop();
-                this.stopTimeline?.();
-            }
-            this.keyframeResolver?.cancel();
-        };
-        this.createdAt = time.now();
-        const optionsWithDefaults = {
-            autoplay,
-            delay,
-            type,
-            repeat,
-            repeatDelay,
-            repeatType,
-            name,
-            motionValue,
-            element,
-            ...options,
-        };
-        const KeyframeResolver$1 = element?.KeyframeResolver || KeyframeResolver;
-        this.keyframeResolver = new KeyframeResolver$1(keyframes, (resolvedKeyframes, finalKeyframe, forced) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe, optionsWithDefaults, !forced), name, motionValue, element);
-        this.keyframeResolver?.scheduleResolve();
-    }
-    onKeyframesResolved(keyframes, finalKeyframe, options, sync) {
-        this.keyframeResolver = undefined;
-        const { name, type, velocity, delay, isHandoff, onUpdate } = options;
-        this.resolvedAt = time.now();
-        /**
-         * If we can't animate this value with the resolved keyframes
-         * then we should complete it immediately.
-         */
-        if (!canAnimate(keyframes, name, type, velocity)) {
-            if (MotionGlobalConfig.instantAnimations || !delay) {
-                onUpdate?.(getFinalKeyframe(keyframes, options, finalKeyframe));
-            }
-            keyframes[0] = keyframes[keyframes.length - 1];
-            makeAnimationInstant(options);
-            options.repeat = 0;
-        }
-        /**
-         * Resolve startTime for the animation.
-         *
-         * This method uses the createdAt and resolvedAt to calculate the
-         * animation startTime. *Ideally*, we would use the createdAt time as t=0
-         * as the following frame would then be the first frame of the animation in
-         * progress, which would feel snappier.
-         *
-         * However, if there's a delay (main thread work) between the creation of
-         * the animation and the first commited frame, we prefer to use resolvedAt
-         * to avoid a sudden jump into the animation.
-         */
-        const startTime = sync
-            ? !this.resolvedAt
-                ? this.createdAt
-                : this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY
-                    ? this.resolvedAt
-                    : this.createdAt
-            : undefined;
-        const resolvedOptions = {
-            startTime,
-            finalKeyframe,
-            ...options,
-            keyframes,
-        };
-        /**
-         * Animate via WAAPI if possible. If this is a handoff animation, the optimised animation will be running via
-         * WAAPI. Therefore, this animation must be JS to ensure it runs "under" the
-         * optimised animation.
-         */
-        const animation = !isHandoff && supportsBrowserAnimation(resolvedOptions)
-            ? new NativeAnimationExtended({
-                ...resolvedOptions,
-                element: resolvedOptions.motionValue.owner.current,
-            })
-            : new JSAnimation(resolvedOptions);
-        animation.finished.then(() => this.notifyFinished()).catch(noop);
-        if (this.pendingTimeline) {
-            this.stopTimeline = animation.attachTimeline(this.pendingTimeline);
-            this.pendingTimeline = undefined;
-        }
-        this._animation = animation;
-    }
-    get finished() {
-        if (!this._animation) {
-            return this._finished;
-        }
-        else {
-            return this.animation.finished;
-        }
-    }
-    then(onResolve, _onReject) {
-        return this.finished.finally(onResolve).then(() => { });
-    }
-    get animation() {
-        if (!this._animation) {
-            this.keyframeResolver?.resume();
-            flushKeyframeResolvers();
-        }
-        return this._animation;
-    }
-    get duration() {
-        return this.animation.duration;
-    }
-    get time() {
-        return this.animation.time;
-    }
-    set time(newTime) {
-        this.animation.time = newTime;
-    }
-    get speed() {
-        return this.animation.speed;
-    }
-    get state() {
-        return this.animation.state;
-    }
-    set speed(newSpeed) {
-        this.animation.speed = newSpeed;
-    }
-    get startTime() {
-        return this.animation.startTime;
-    }
-    attachTimeline(timeline) {
-        if (this._animation) {
-            this.stopTimeline = this.animation.attachTimeline(timeline);
-        }
-        else {
-            this.pendingTimeline = timeline;
-        }
-        return () => this.stop();
-    }
-    play() {
-        this.animation.play();
-    }
-    pause() {
-        this.animation.pause();
-    }
-    complete() {
-        this.animation.complete();
-    }
-    cancel() {
-        if (this._animation) {
-            this.animation.cancel();
-        }
-        this.keyframeResolver?.cancel();
-    }
-}
-
-export { AsyncMotionValueAnimation };