@xtia/timeline 1.0.0 → 1.0.1

package/README.md

@@ -93,6 +93,7 @@ eased.listen(
 const frames = eased
     .tween(0, 30)
     .map(Math.floor)
+    .noRepeat()
     .map(n => `animation-frame-${n}.png`)
     .listen(filename => img.src = filename);
 ```
@@ -210,7 +211,7 @@ const wrappingTimeline = new Timeline(true, "wrap");
 const foreverTimeline = new Timeline(true, "continue");
 
 // "pause" is the default behaviour: stop at the end
-const puasingTimeline = new Timeline(true, "pause");
+const pausingTimeline = new Timeline(true, "pause");
 
 // "restart" and "wrap" strategies can designate a position
 // to loop back to
@@ -266,6 +267,12 @@ resourceUrls.forEach(url => {
 });
 ```
 
+We can pass a second argument to `seek()` to perform a 'smooth seek' over the given duration. A third argument can provide an easing function for the smooth seek process:
+
+```ts
+timeline.seek(timeline.end, 400, "overshootIn");
+```
+
 ## Backward-compatibility
 
 Despite the massive overhaul, the previous API is present and expanded  and upgrading to 1.0.0 should be frictionless in the vast majority of cases.

package/index.d.ts

@@ -103,7 +103,7 @@ export declare class Timeline {
      * @param easer Optional easing function for the smooth-seek process
      * @returns A promise, resolved when the smooth-seek process finishes
      */
-    seek(toPosition: number | TimelinePoint, duration: number, easer?: Easer): Promise<void>;
+    seek(toPosition: number | TimelinePoint, duration: number, easer?: Easer | keyof typeof easers): Promise<void>;
     private seekDirect;
     private seekPoints;
     private seekRanges;
@@ -202,6 +202,16 @@ interface Emitter<T> {
      */
     listen(handler: Handler<T>): Disposer;
     map<R>(mapFunc: (value: T) => R): Emitter<R>;
+    /**
+     * Selectively forwards emissions along the chain
+     * @param check Function that takes an emitted value and returns true if the emission should be forwarded along the chain
+     */
+    filter(check: (value: T) => boolean): Emitter<T>;
+    /**
+     * Discards emitted values that are the same as the last emitted value
+     * @param compare Function that takes the previous and next values and returns true if they should be considered equal
+     */
+    noRepeat(compare?: (a: T, b: T) => boolean): Emitter<T>;
 }
 export interface TweenEmitter<T extends Tweenable> extends Emitter<T> {
 }

package/index.js

@@ -553,6 +553,31 @@ function createEmitter(onListen, api) {
                 });
             }
         },
+        filter: {
+            value: (filterFunc) => {
+                return createEmitter(handler => {
+                    const filteredHandler = (value) => {
+                        if (filterFunc(value))
+                            handler(value);
+                    };
+                    return onListen(filteredHandler);
+                });
+            }
+        },
+        noRepeat: {
+            value: (compare) => {
+                let previous = null;
+                return createEmitter(handler => {
+                    const filteredHandler = (value) => {
+                        if (!previous || (compare ? !compare(previous.value, value) : (previous.value !== value))) {
+                            handler(value);
+                            previous = { value };
+                        }
+                    };
+                    return onListen(filteredHandler);
+                });
+            }
+        }
     });
     return emitter;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtia/timeline",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "repository": {
     "url": "https://github.com/tiadrop/timeline",
     "type": "github"