motion-start 0.0.1 → 0.0.3

package/dist/utils/shallow-compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shallow-compare.d.ts","sourceRoot":"","sources":["../../../../src/lib/motion-start/utils/shallow-compare.ts"],"names":[],"mappings":"AAAA;;;EAGE;AAEF;;;EAGE;AACF,iBAAS,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,WAWtD;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/{src/utils/shallow-compare.ts → dist/utils/shallow-compare.js}

@@ -1,23 +1,21 @@
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-
-/** 
-based on framer-motion@4.0.3,
-Copyright (c) 2018 Framer B.V.
-*/
-function shallowCompare(next: any[], prev: any[] | null) {
-    if (!Array.isArray(prev))
-        return false;
-    var prevLength = prev.length;
-    if (prevLength !== next.length)
-        return false;
-    for (var i = 0; i < prevLength; i++) {
-        if (prev[i] !== next[i])
-            return false;
-    }
-    return true;
-}
-
-export { shallowCompare };
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+/**
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+function shallowCompare(next, prev) {
+    if (!Array.isArray(prev))
+        return false;
+    var prevLength = prev.length;
+    if (prevLength !== next.length)
+        return false;
+    for (var i = 0; i < prevLength; i++) {
+        if (prev[i] !== next[i])
+            return false;
+    }
+    return true;
+}
+export { shallowCompare };

package/dist/utils/subscription-manager.d.ts

@@ -0,0 +1,14 @@
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+type GenericHandler = (...args: any) => void;
+declare class SubscriptionManager<Handler extends GenericHandler> {
+    private subscriptions;
+    add: (handler: Handler) => () => void;
+    notify: (a?: Parameters<Handler>[0], b?: Parameters<Handler>[1], c?: Parameters<Handler>[2]) => void;
+    getSize: () => number;
+    clear: () => void;
+}
+export { SubscriptionManager };
+//# sourceMappingURL=subscription-manager.d.ts.map

package/dist/utils/subscription-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-manager.d.ts","sourceRoot":"","sources":["../../../../src/lib/motion-start/utils/subscription-manager.ts"],"names":[],"mappings":"AAAA;;;EAGE;AACF,KAAK,cAAc,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;AAC7C,cAAM,mBAAmB,CAAC,OAAO,SAAS,cAAc;IACvD,OAAO,CAAC,aAAa,CAAsB;IAC3C,GAAG,YAAa,OAAO,gBAKrB;IACF,MAAM,OAAQ,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAkB1F;IACF,OAAO,eAEL;IACF,KAAK,aAEH;CACF;AAQD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/utils/subscription-manager.js

@@ -0,0 +1,69 @@
+class SubscriptionManager {
+    constructor() {
+        Object.defineProperty(this, "subscriptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "add", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (handler) => {
+                addUniqueItem(this.subscriptions, handler);
+                return () => {
+                    return removeItem(this.subscriptions, handler);
+                };
+            }
+        });
+        Object.defineProperty(this, "notify", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (a, b, c) => {
+                var numSubscriptions = this.subscriptions.length;
+                if (!numSubscriptions)
+                    return;
+                if (numSubscriptions === 1) {
+                    /**
+                     * If there's only a single handler we can just call it without invoking a loop.
+                     */
+                    this.subscriptions[0](a, b, c);
+                }
+                else {
+                    for (var i = 0; i < numSubscriptions; i++) {
+                        /**
+                         * Check whether the handler exists before firing as it's possible
+                         * the subscriptions were modified during this loop running.
+                         */
+                        var handler = this.subscriptions[i];
+                        handler && handler(a, b, c);
+                    }
+                }
+            }
+        });
+        Object.defineProperty(this, "getSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                return this.subscriptions.length;
+            }
+        });
+        Object.defineProperty(this, "clear", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.subscriptions.length = 0;
+            }
+        });
+    }
+}
+/**
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+import { addUniqueItem, removeItem } from './array.js';
+export { SubscriptionManager };

package/dist/utils/time-conversion.d.ts

@@ -0,0 +1,17 @@
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+/**
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+/**
+ * Converts seconds to milliseconds
+ *
+ * @param seconds - Time in seconds.
+ * @return milliseconds - Converted time in milliseconds.
+ */
+declare var secondsToMilliseconds: (seconds: number) => number;
+export { secondsToMilliseconds };
+//# sourceMappingURL=time-conversion.d.ts.map

package/dist/utils/time-conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-conversion.d.ts","sourceRoot":"","sources":["../../../../src/lib/motion-start/utils/time-conversion.ts"],"names":[],"mappings":"AAAA;;;EAGE;AAEF;;;EAGE;AACF;;;;;GAKG;AACH,QAAA,IAAI,qBAAqB,YAAsB,MAAM,WAA4B,CAAC;AAElF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/{src/utils/time-conversion.ts → dist/utils/time-conversion.js}

@@ -1,18 +1,16 @@
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-
-/** 
-based on framer-motion@4.0.3,
-Copyright (c) 2018 Framer B.V.
-*/
-/**
- * Converts seconds to milliseconds
- *
- * @param seconds - Time in seconds.
- * @return milliseconds - Converted time in milliseconds.
- */
-var secondsToMilliseconds = function (seconds: number) { return seconds * 1000; };
-
-export { secondsToMilliseconds };
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+/**
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+/**
+ * Converts seconds to milliseconds
+ *
+ * @param seconds - Time in seconds.
+ * @return milliseconds - Converted time in milliseconds.
+ */
+var secondsToMilliseconds = function (seconds) { return seconds * 1000; };
+export { secondsToMilliseconds };

package/{src/utils/transform.ts → dist/utils/transform.d.ts}

@@ -1,120 +1,93 @@
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-import type { Easing } from "popmotion";
-/**
- * @public
- */
-export interface TransformOptions<T> {
-    /**
-     * Clamp values to within the given range. Defaults to `true`
-     *
-     * @public
-     */
-    clamp?: boolean;
-    /**
-     * Easing functions to use on the interpolations between each value in the input and output ranges.
-     *
-     * If provided as an array, the array must be one item shorter than the input and output ranges, as the easings apply to the transition **between** each.
-     *
-     * @public
-     */
-    ease?: Easing | Easing[];
-    /**
-     * @internal
-     */
-    mixer?: (from: T, to: T) => (v: number) => any;
-}
-/**
- * Transforms numbers into other values by mapping them from an input range to an output range.
- * Returns the type of the input provided.
- *
- * @remarks
- *
- * Given an input range of `[0, 200]` and an output range of
- * `[0, 1]`, this function will return a value between `0` and `1`.
- * The input range must be a linear series of numbers. The output range
- * can be any supported value type, such as numbers, colors, shadows, arrays, objects and more.
- * Every value in the output range must be of the same type and in the same format.
- *
- * @motion
- *
- * ```jsx
- * import { transform } from "svelte-motion"
- *
- * 
- *    const inputRange = [0, 200]
- *    const outputRange = [0, 1]
- *    const output = transform(100, inputRange, outputRange)
- *    
- *    console.log(output) // Returns 0.5
- * ```
- *
- * @param inputValue - A number to transform between the input and output ranges.
- * @param inputRange - A linear series of numbers (either all increasing or decreasing).
- * @param outputRange - A series of numbers, colors, strings, or arrays/objects of those. Must be the same length as `inputRange`.
- * @param options - Clamp: Clamp values to within the given range. Defaults to `true`.
- *
- * @public
- */
-function transform<T>(inputValue: number, inputRange: number[], outputRange: T[], options?: TransformOptions<T>): T;
-/**
- * @motion
- *
- * Transforms numbers into other values by mapping them from an input range to an output range.
- *
- * Given an input range of `[0, 200]` and an output range of
- * `[0, 1]`, this function will return a value between `0` and `1`.
- * The input range must be a linear series of numbers. The output range
- * can be any supported value type, such as numbers, colors, shadows, arrays, objects and more.
- * Every value in the output range must be of the same type and in the same format.
- *
- * ```jsx
-
- * import { transform } from "svelte-motion"
- *
- * const inputRange = [-200, -100, 100, 200]
- * const outputRange = [0, 1, 1, 0]
- * const convertRange = transform(inputRange, outputRange)
- * const output = convertRange(-150)
- *
- * console.log(output) // Returns 0.5
- * ```
- *
- * @param inputRange - A linear series of numbers (either all increasing or decreasing).
- * @param outputRange - A series of numbers, colors or strings. Must be the same length as `inputRange`.
- * @param options - Clamp: clamp values to within the given range. Defaults to `true`.
- *
- * @public
- */
-function transform<T>(inputRange: number[], outputRange: T[], options?: TransformOptions<T>): (inputValue: number) => T;
-
-
-/** 
-based on framer-motion@4.0.3,
-Copyright (c) 2018 Framer B.V.
-*/
-import {fixed} from './fix-process-env';
-import { __assign } from 'tslib';
-import { interpolate } from 'popmotion';
-import type { CustomValueType } from "../types";
-
-var isCustomValueType = function (v: any): v is CustomValueType {
-    return typeof v === "object" && v.mix;
-};
-var getMixer = function (v: any) { return (isCustomValueType(v) ? v.mix : undefined); };
-function transform<T>(...args: [number, number[], T[], TransformOptions<T>?]
-    | [number[], T[], TransformOptions<T>?]
-) {
-    var useImmediate = !Array.isArray(args[0]);
-    var argOffset = useImmediate ? 0 : -1;
-    var inputValue = args[0 + argOffset] as number;
-    var inputRange = args[1 + argOffset] as number[];
-    var outputRange = args[2 + argOffset] as T[];
-    var options = args[3 + argOffset] as TransformOptions<T>;
-    var interpolator = interpolate(inputRange, outputRange, __assign({ mixer: getMixer(outputRange[0]) }, options));
-    return useImmediate ? interpolator(inputValue) : interpolator;
-}
-
-export { transform };
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+import type { Easing } from "popmotion";
+/**
+ * @public
+ */
+export interface TransformOptions<T> {
+    /**
+     * Clamp values to within the given range. Defaults to `true`
+     *
+     * @public
+     */
+    clamp?: boolean;
+    /**
+     * Easing functions to use on the interpolations between each value in the input and output ranges.
+     *
+     * If provided as an array, the array must be one item shorter than the input and output ranges, as the easings apply to the transition **between** each.
+     *
+     * @public
+     */
+    ease?: Easing | Easing[];
+    /**
+     * @internal
+     */
+    mixer?: (from: T, to: T) => (v: number) => any;
+}
+/**
+ * Transforms numbers into other values by mapping them from an input range to an output range.
+ * Returns the type of the input provided.
+ *
+ * @remarks
+ *
+ * Given an input range of `[0, 200]` and an output range of
+ * `[0, 1]`, this function will return a value between `0` and `1`.
+ * The input range must be a linear series of numbers. The output range
+ * can be any supported value type, such as numbers, colors, shadows, arrays, objects and more.
+ * Every value in the output range must be of the same type and in the same format.
+ *
+ * @motion
+ *
+ * ```jsx
+ * import { transform } from "svelte-motion"
+ *
+ *
+ *    const inputRange = [0, 200]
+ *    const outputRange = [0, 1]
+ *    const output = transform(100, inputRange, outputRange)
+ *
+ *    console.log(output) // Returns 0.5
+ * ```
+ *
+ * @param inputValue - A number to transform between the input and output ranges.
+ * @param inputRange - A linear series of numbers (either all increasing or decreasing).
+ * @param outputRange - A series of numbers, colors, strings, or arrays/objects of those. Must be the same length as `inputRange`.
+ * @param options - Clamp: Clamp values to within the given range. Defaults to `true`.
+ *
+ * @public
+ */
+declare function transform<T>(inputValue: number, inputRange: number[], outputRange: T[], options?: TransformOptions<T>): T;
+/**
+ * @motion
+ *
+ * Transforms numbers into other values by mapping them from an input range to an output range.
+ *
+ * Given an input range of `[0, 200]` and an output range of
+ * `[0, 1]`, this function will return a value between `0` and `1`.
+ * The input range must be a linear series of numbers. The output range
+ * can be any supported value type, such as numbers, colors, shadows, arrays, objects and more.
+ * Every value in the output range must be of the same type and in the same format.
+ *
+ * ```jsx
+
+ * import { transform } from "svelte-motion"
+ *
+ * const inputRange = [-200, -100, 100, 200]
+ * const outputRange = [0, 1, 1, 0]
+ * const convertRange = transform(inputRange, outputRange)
+ * const output = convertRange(-150)
+ *
+ * console.log(output) // Returns 0.5
+ * ```
+ *
+ * @param inputRange - A linear series of numbers (either all increasing or decreasing).
+ * @param outputRange - A series of numbers, colors or strings. Must be the same length as `inputRange`.
+ * @param options - Clamp: clamp values to within the given range. Defaults to `true`.
+ *
+ * @public
+ */
+declare function transform<T>(inputRange: number[], outputRange: T[], options?: TransformOptions<T>): (inputValue: number) => T;
+export { transform };
+//# sourceMappingURL=transform.d.ts.map

package/dist/utils/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../../src/lib/motion-start/utils/transform.ts"],"names":[],"mappings":"AAAA;;;EAGE;AACF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAC/B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB;;OAEG;IACH,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,KAAK,GAAG,CAAC;CAClD;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,iBAAS,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,iBAAS,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,CAAC,CAAC;AA6BxH,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/utils/transform.js

@@ -0,0 +1,22 @@
+/**
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+import { fixed } from './fix-process-env';
+import { __assign } from 'tslib';
+import { interpolate } from 'popmotion';
+var isCustomValueType = function (v) {
+    return typeof v === "object" && v.mix;
+};
+var getMixer = function (v) { return (isCustomValueType(v) ? v.mix : undefined); };
+function transform(...args) {
+    var useImmediate = !Array.isArray(args[0]);
+    var argOffset = useImmediate ? 0 : -1;
+    var inputValue = args[0 + argOffset];
+    var inputRange = args[1 + argOffset];
+    var outputRange = args[2 + argOffset];
+    var options = args[3 + argOffset];
+    var interpolator = interpolate(inputRange, outputRange, __assign({ mixer: getMixer(outputRange[0]) }, options));
+    return useImmediate ? interpolator(inputValue) : interpolator;
+}
+export { transform };

package/{src/utils/use-constant.ts → dist/utils/use-constant.d.ts}

@@ -1,23 +1,22 @@
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-type Init<T> = () => T;
-/**
- * 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.
- */
-export function useConstant<T>(init: Init<T>): T;
-
-/**
- * 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.
- */
-
-// export { default as UseConstant } from './UseConstant.svelte';
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+type Init<T> = () => T;
+/**
+ * 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.
+ */
+export declare function useConstant<T>(init: Init<T>): T;
+export {};
+/**
+ * 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.
+ */
+//# sourceMappingURL=use-constant.d.ts.map

package/dist/utils/use-constant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-constant.d.ts","sourceRoot":"","sources":["../../../../src/lib/motion-start/utils/use-constant.ts"],"names":[],"mappings":"AAAA;;;EAGE;AACF,KAAK,IAAI,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;AACvB;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;;AAEjD;;;;;;GAMG"}

package/dist/utils/use-constant.js

@@ -0,0 +1,9 @@
+export {};
+/**
+ * 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.
+ */
+// export { default as UseConstant } from './UseConstant.svelte';

package/dist/utils/use-cycle.d.ts

@@ -0,0 +1,2 @@
+export declare const useCycle: <T>(...items: T[]) => any;
+//# sourceMappingURL=use-cycle.d.ts.map

package/dist/utils/use-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-cycle.d.ts","sourceRoot":"","sources":["../../../../src/lib/motion-start/utils/use-cycle.ts"],"names":[],"mappings":"AA+DA,eAAO,MAAM,QAAQ,GAAI,CAAC,YAAY,CAAC,EAAE,QAcxC,CAAA"}

package/{src/utils/use-cycle.ts → dist/utils/use-cycle.js}

@@ -1,78 +1,65 @@
-/** 
-based on framer-motion@4.1.17,
-Copyright (c) 2018 Framer B.V.
-*/
-import type { Writable } from 'svelte/store';
-type Cycle = (i?: number) => void;
-type CycleState<T> = [T, Cycle];
-
-
-/** 
-based on framer-motion@4.0.3,
-Copyright (c) 2018 Framer B.V.
-*/
-/**
- * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.
- *
- * @library
- *
- * ```jsx
- * import * as React from "react"
- * import { Frame, useCycle } from "framer"
- *
- * export function MyComponent() {
- *   const [x, cycleX] = useCycle(0, 50, 100)
- *
- *   return (
- *     <Frame
- *       animate={{ x: x }}
- *       onTap={() => cycleX()}
- *      />
- *    )
- * }
- * ```
- *
- * @motion
- *
- * An index value can be passed to the returned `cycle` function to cycle to a specific index.
- *
- * ```jsx
- * import * as React from "react"
- * import { motion, useCycle } from "framer-motion"
- *
- * export const MyComponent = () => {
- *   const [x, cycleX] = useCycle(0, 50, 100)
- *
- *   return (
- *     <MotionDiv
- *       animate={{ x: x }}
- *       onTap={() => cycleX()}
- *      />
- *    )
- * }
- * ```
- *
- * @param items - items to cycle through
- * @returns [currentState, cycleState]
- *
- * @public
- */
-// export { default as UseCycle } from './UseCycle.svelte';
-import { wrap } from "popmotion";
-import { writable } from 'svelte/store';
-
-export const useCycle = <T>(...items: T[]) => {
-    let index = 0;
-    const x = writable(items[index]) as Writable<T> & {
-        /** Cycle through to next value or set the next value by index. */
-        next: ( index?: number ) => void
-    }
-    const next = (i?: number) => {
-        index = typeof i !== "number" ?
-            wrap(0, items.length, index + 1) :
-            i;
-        x.set(items[index])
-    }
-    x.next=next;
-    return x;
-}
+/**
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+/**
+ * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.
+ *
+ * @library
+ *
+ * ```jsx
+ * import * as React from "react"
+ * import { Frame, useCycle } from "framer"
+ *
+ * export function MyComponent() {
+ *   const [x, cycleX] = useCycle(0, 50, 100)
+ *
+ *   return (
+ *     <Frame
+ *       animate={{ x: x }}
+ *       onTap={() => cycleX()}
+ *      />
+ *    )
+ * }
+ * ```
+ *
+ * @motion
+ *
+ * An index value can be passed to the returned `cycle` function to cycle to a specific index.
+ *
+ * ```jsx
+ * import * as React from "react"
+ * import { motion, useCycle } from "framer-motion"
+ *
+ * export const MyComponent = () => {
+ *   const [x, cycleX] = useCycle(0, 50, 100)
+ *
+ *   return (
+ *     <MotionDiv
+ *       animate={{ x: x }}
+ *       onTap={() => cycleX()}
+ *      />
+ *    )
+ * }
+ * ```
+ *
+ * @param items - items to cycle through
+ * @returns [currentState, cycleState]
+ *
+ * @public
+ */
+// export { default as UseCycle } from './UseCycle.svelte';
+import { wrap } from "popmotion";
+import { writable } from 'svelte/store';
+export const useCycle = (...items) => {
+    let index = 0;
+    const x = writable(items[index]);
+    const next = (i) => {
+        index = typeof i !== "number" ?
+            wrap(0, items.length, index + 1) :
+            i;
+        x.set(items[index]);
+    };
+    x.next = next;
+    return x;
+};

package/dist/utils/use-force-update.d.ts

@@ -0,0 +1,6 @@
+/**
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+export declare function useForceUpdate(): () => void;
+//# sourceMappingURL=use-force-update.d.ts.map