motion-start 0.0.1 → 0.1.0

package/dist/value/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/motion-start/value/index.ts"],"names":[],"mappings":"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"}

package/dist/value/index.js

@@ -0,0 +1,546 @@
+/**
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+import { fixed } from '../utils/fix-process-env.js';
+import sync, { getFrameData } from 'framesync';
+import { velocityPerSecond } from 'popmotion';
+import { SubscriptionManager } from '../utils/subscription-manager.js';
+/**
+ * `MotionValue` is used to track the state and velocity of motion values.
+ *
+ * @public
+ */
+export class MotionValue {
+    /**
+     * Subscribe method to make MotionValue compatible with Svelte store. Returns a unsubscribe function.
+     * Same as onChange.
+     *
+     * @public
+     */
+    subscribe(subscription) {
+        return this.onChange(subscription);
+    }
+    /**
+     * @param init - The initiating value
+     * @param startStopNotifier - a function that is called, once the first subscriber is added to this motion value.
+     *                            The return function is called, when the last subscriber unsubscribes.
+     *
+     * -  `transformer`: A function to transform incoming values with.
+     *
+     * @internal
+     */
+    constructor(init, startStopNotifier) {
+        /**
+         * Update method to make MotionValue compatible with Svelte writable store
+         *
+         * @public
+         */
+        Object.defineProperty(this, "update", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (cb) => {
+                this.set(cb(this.get()));
+            }
+        });
+        /**
+         * The current state of the `MotionValue`.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "current", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The previous state of the `MotionValue`.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "prev", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Duration, in milliseconds, since last updating frame.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "timeDelta", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /**
+         * Timestamp of the last time this `MotionValue` was updated.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "lastUpdated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /**
+         * Functions to notify when the `MotionValue` updates.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "updateSubscribers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new SubscriptionManager()
+        });
+        /**
+         * Functions to notify when the velocity updates.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "velocityUpdateSubscribers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new SubscriptionManager()
+        });
+        /**
+         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "renderSubscribers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new SubscriptionManager()
+        });
+        /**
+         * Add a passive effect to this `MotionValue`.
+         *
+         * A passive effect intercepts calls to `set`. For instance, `useSpring` adds
+         * a passive effect that attaches a `spring` to the latest
+         * set value. Hypothetically there could be a `useSmooth` that attaches an input smoothing effect.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "passiveEffect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * A reference to the currently-controlling Popmotion animation
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "stopAnimation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Tracks whether this value can output a velocity. Currently this is only true
+         * if the value is numerical, but we might be able to widen the scope here and support
+         * other value types.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "canTrackVelocity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "onSubscription", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => { }
+        });
+        Object.defineProperty(this, "onUnsubscription", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => { }
+        });
+        /**
+         * Adds a function that will be notified when the `MotionValue` is updated.
+         *
+         * It returns a function that, when called, will cancel the subscription.
+         *
+         * When calling `onChange` inside a React component, it should be wrapped with the
+         * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+         * from the `useEffect` function to ensure you don't add duplicate subscribers..
+         *
+         
+         * @motion
+         *
+         * ```jsx
+         * <script>
+         *   import { useMotionValue } from 'svelte-motion'
+         *
+         *   const x = useMotionValue(0)
+         *   const y = useMotionValue(0)
+         *   const opacity = useMotionValue(1)
+         *
+         *
+         *   function updateOpacity() {
+         *       const maxXY = Math.max(x.get(), y.get())
+         *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+         *       opacity.set(newOpacity)
+         *   }
+         *
+         *   // framer-motion style:
+         *   const unsubscribeX = x.onChange(updateOpacity)
+         *   onDestroy(()=>{
+         *       unsubscribeX()
+         *   })
+         *   // equivalent Svelte style. Subscription and un-subscription is automatically handled:
+         *   $: updateOpacity($y)
+         * </script>
+         *
+         * <Motion let:motion style={{ x }}><div use:motion/></Motion>
+         * ```
+         *
+         * @param subscriber - A function that receives the latest value.
+         * @returns A function that, when called, will cancel this subscription.
+         *
+         * @public
+         */
+        Object.defineProperty(this, "onChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (subscription) => {
+                this.onSubscription();
+                const unsub = this.updateSubscribers.add(subscription);
+                return () => {
+                    unsub();
+                    this.onUnsubscription();
+                };
+            }
+        });
+        Object.defineProperty(this, "clearListeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.updateSubscribers.clear();
+                this.onUnsubscription();
+            }
+        });
+        /**
+         * Adds a function that will be notified when the `MotionValue` requests a render.
+         *
+         * @param subscriber - A function that's provided the latest value.
+         * @returns A function that, when called, will cancel this subscription.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "onRenderRequest", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (subscription) => {
+                this.onSubscription();
+                // Render immediately
+                subscription(this.get());
+                const unsub = this.renderSubscribers.add(subscription);
+                return () => {
+                    unsub();
+                    this.onUnsubscription();
+                };
+            }
+        });
+        /**
+         * Attaches a passive effect to the `MotionValue`.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "attach", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (passiveEffect) => {
+                this.passiveEffect = passiveEffect;
+            }
+        });
+        /**
+         * Sets the state of the `MotionValue`.
+         *
+         * @remarks
+         *
+         * ```jsx
+         * const x = useMotionValue(0)
+         * x.set(10)
+         * ```
+         *
+         * @param latest - Latest value to set.
+         * @param render - Whether to notify render subscribers. Defaults to `true`
+         *
+         * @public
+         */
+        Object.defineProperty(this, "set", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (v, render) => {
+                if (render === void 0) {
+                    render = true;
+                }
+                if (!render || !this.passiveEffect) {
+                    this.updateAndNotify(v, render);
+                }
+                else {
+                    this.passiveEffect(v, this.updateAndNotify);
+                }
+            }
+        });
+        Object.defineProperty(this, "updateAndNotify", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (v, render) => {
+                if (render === void 0) {
+                    render = true;
+                }
+                this.prev = this.current;
+                this.current = v;
+                // Update timestamp
+                var _a = getFrameData(), delta = _a.delta, timestamp = _a.timestamp;
+                if (this.lastUpdated !== timestamp) {
+                    this.timeDelta = delta;
+                    this.lastUpdated = timestamp;
+                    sync.postRender(this.scheduleVelocityCheck);
+                }
+                // Update update subscribers
+                if (this.prev !== this.current) {
+                    this.updateSubscribers.notify(this.current);
+                }
+                // Update velocity subscribers
+                if (this.velocityUpdateSubscribers.getSize()) {
+                    this.velocityUpdateSubscribers.notify(this.getVelocity());
+                }
+                // Update render subscribers
+                if (render) {
+                    this.renderSubscribers.notify(this.current);
+                }
+            }
+        });
+        /**
+         * Returns the latest state of `MotionValue`
+         *
+         * @returns - The latest state of `MotionValue`
+         *
+         * @public
+         */
+        Object.defineProperty(this, "get", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.onSubscription();
+                const curr = this.current;
+                this.onUnsubscription();
+                return curr;
+            }
+        });
+        /**
+         * @public
+         */
+        Object.defineProperty(this, "getPrevious", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                return this.prev;
+            }
+        });
+        /**
+         * Returns the latest velocity of `MotionValue`
+         *
+         * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+         *
+         * @public
+         */
+        Object.defineProperty(this, "getVelocity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful
+                this.onSubscription();
+                const vel = this.canTrackVelocity
+                    ? // These casts could be avoided if parseFloat would be typed better
+                        velocityPerSecond(Number.parseFloat(String(this.current)) - Number.parseFloat(String(this.prev)), this.timeDelta)
+                    : 0;
+                this.onUnsubscription();
+                return vel;
+            }
+        });
+        /**
+         * Schedule a velocity check for the next frame.
+         *
+         * This is an instanced and bound function to prevent generating a new
+         * function once per frame.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "scheduleVelocityCheck", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                return sync.postRender(this.velocityCheck);
+            }
+        });
+        /**
+         * Updates `prev` with `current` if the value hasn't been updated this frame.
+         * This ensures velocity calculations return `0`.
+         *
+         * This is an instanced and bound function to prevent generating a new
+         * function once per frame.
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "velocityCheck", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (_a) => {
+                var timestamp = _a.timestamp;
+                if (timestamp !== this.lastUpdated) {
+                    this.prev = this.current;
+                    this.velocityUpdateSubscribers.notify(this.getVelocity());
+                }
+            }
+        });
+        Object.defineProperty(this, "hasAnimated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /**
+         * Registers a new animation to control this `MotionValue`. Only one
+         * animation can drive a `MotionValue` at one time.
+         *
+         * ```jsx
+         * value.start()
+         * ```
+         *
+         * @param animation - A function that starts the provided animation
+         *
+         * @internal
+         */
+        Object.defineProperty(this, "start", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (animation) => {
+                this.stop();
+                return new Promise((resolve) => {
+                    this.hasAnimated = true; // @ts-expect-error
+                    this.stopAnimation = animation(resolve);
+                }).then(() => {
+                    return this.clearAnimation();
+                });
+            }
+        });
+        /**
+         * Stop the currently active animation.
+         *
+         * @public
+         */
+        Object.defineProperty(this, "stop", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                if (this.stopAnimation)
+                    this.stopAnimation();
+                this.clearAnimation();
+            }
+        });
+        /**
+         * Returns `true` if this value is currently animating.
+         *
+         * @public
+         */
+        Object.defineProperty(this, "isAnimating", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                return !!this.stopAnimation;
+            }
+        });
+        Object.defineProperty(this, "clearAnimation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.stopAnimation = null;
+            }
+        });
+        /**
+         * Destroy and clean up subscribers to this `MotionValue`.
+         *
+         * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+         * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+         * created a `MotionValue` via the `motionValue` function.
+         *
+         * @public
+         */
+        Object.defineProperty(this, "destroy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.updateSubscribers.clear();
+                this.renderSubscribers.clear();
+                this.stop();
+                this.onUnsubscription();
+            }
+        });
+        this.prev = this.current = init;
+        this.canTrackVelocity = isFloat(this.current);
+        if (startStopNotifier) {
+            this.onSubscription = () => {
+                if (this.updateSubscribers.getSize() +
+                    this.velocityUpdateSubscribers.getSize() +
+                    this.renderSubscribers.getSize() ===
+                    0) {
+                    const unsub = startStopNotifier();
+                    this.onUnsubscription = () => { };
+                    if (unsub) {
+                        this.onUnsubscription = () => {
+                            if (this.updateSubscribers.getSize() +
+                                this.velocityUpdateSubscribers.getSize() +
+                                this.renderSubscribers.getSize() ===
+                                0) {
+                                unsub();
+                            }
+                        };
+                    }
+                }
+            };
+        }
+    }
+}
+var isFloat = (value) => !isNaN(Number.parseFloat(value));
+/**
+ * @internal
+ */
+export function motionValue(init, startStopNotifier) {
+    return new MotionValue(init, startStopNotifier);
+}

package/dist/value/scroll/use-element-scroll.d.ts

@@ -0,0 +1,9 @@
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+import type { ScrollMotionValues } from './utils';
+export declare const useElementScroll: (ref: {
+    current: HTMLElement | null;
+}) => ScrollMotionValues;
+//# sourceMappingURL=use-element-scroll.d.ts.map

package/dist/value/scroll/use-element-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-element-scroll.d.ts","sourceRoot":"","sources":["../../../../../src/lib/motion-start/value/scroll/use-element-scroll.ts"],"names":[],"mappings":"AAAA;;;EAGE;AACF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AA2BlD,eAAO,MAAM,gBAAgB,QAAS;IAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAAA;CAAE,KA4BnD,kBACjB,CAAC"}

package/dist/value/scroll/use-element-scroll.js

@@ -0,0 +1,39 @@
+/**
+based on framer-motion@4.1.16,
+Copyright (c) 2018 Framer B.V.
+*/
+import { createScrollMotionValues, createScrollUpdater } from './utils';
+import { addDomEvent } from '../../events/use-dom-event';
+const getElementScrollOffsets = (element) => () => {
+    return {
+        xOffset: element.scrollLeft,
+        yOffset: element.scrollTop,
+        xMaxOffset: element.scrollWidth - element.offsetWidth,
+        yMaxOffset: element.scrollHeight - element.offsetHeight,
+    };
+};
+export const useElementScroll = (ref) => {
+    const values = {};
+    const setScroll = async () => {
+        if (typeof window === 'undefined')
+            return () => { };
+        let times = 10;
+        while ((!ref || !ref.current) && !values.ref) {
+            if (times-- < 1) {
+                return () => { };
+            }
+            await new Promise((r) => setTimeout(() => r(), 200));
+        }
+        const element = ref && ref.current ? ref : values.ref;
+        const updateScrollValues = createScrollUpdater(values, getElementScrollOffsets(element));
+        const scrollListener = addDomEvent(element, 'scroll', updateScrollValues, { passive: true });
+        const resizeListener = addDomEvent(element, 'resize', updateScrollValues);
+        return () => {
+            scrollListener && scrollListener();
+            resizeListener && resizeListener();
+        };
+    };
+    Object.assign(values, createScrollMotionValues(setScroll));
+    return values;
+};
+//export { default as UseElementScroll } from './UseElementScroll.svelte';

package/dist/value/scroll/use-viewport-scroll.d.ts

@@ -0,0 +1,29 @@
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+import type { ScrollMotionValues } from "./utils";
+/**
+ * Returns MotionValues that update when the viewport scrolls:
+ *
+ * - `scrollX` — Horizontal scroll distance in pixels.
+ * - `scrollY` — Vertical scroll distance in pixels.
+ * - `scrollXProgress` — Horizontal scroll progress between `0` and `1`.
+ * - `scrollYProgress` — Vertical scroll progress between `0` and `1`.
+ *
+ * **Warning:** Setting `body` or `html` to `height: 100%` or similar will break the `Progress`
+ * values as this breaks the browser's capability to accurately measure the page length.
+ *
+ * @motion
+ *
+ * ```jsx
+ * export const MyComponent = () => {
+ *   const { scrollYProgress } = useViewportScroll()
+ *   return <MotionDiv style={{ scaleX: scrollYProgress }} />
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function useViewportScroll(): ScrollMotionValues;
+//# sourceMappingURL=use-viewport-scroll.d.ts.map

package/dist/value/scroll/use-viewport-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-viewport-scroll.d.ts","sourceRoot":"","sources":["../../../../../src/lib/motion-start/value/scroll/use-viewport-scroll.ts"],"names":[],"mappings":"AAAA;;;EAGE;AACF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAyClD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,IAYE,kBAAkB,CACpD"}