@xtia/jel 0.6.0 → 0.6.1

package/index.d.ts

@@ -1,4 +1,4 @@
 export { DomEntity, ElementClassDescriptor, ElementDescriptor, DOMContent, DomHelper, StyleAccessor, JelEntity } from "./internal/types";
 export { $ } from "./internal/element";
 export { createEntity } from "./internal/util";
-export { createEventSource } from "./internal/emitter";
+export { createEventSource, interval } from "./internal/emitter";

package/index.js

@@ -1,3 +1,3 @@
 export { $ } from "./internal/element";
 export { createEntity } from "./internal/util";
-export { createEventSource } from "./internal/emitter";
+export { createEventSource, interval } from "./internal/emitter";

package/internal/emitter.d.ts

@@ -73,7 +73,6 @@ export declare class EventEmitter<T> extends Emitter<T> {
     debounce(ms: number): EventEmitter<T>;
     throttle(ms: number): EventEmitter<T>;
     batch(ms: number): Emitter<T[]>;
-    filter(check: (value: T) => boolean): EventEmitter<T>;
     /**
      * **Experimental**: May change in future revisions
      * Note: potential leak - This link will remain subscribed to the parent
@@ -92,7 +91,6 @@ export declare class EventEmitter<T> extends Emitter<T> {
      * @returns
      */
     take(limit: number): EventEmitter<T>;
-    tap(cb: Handler<T>): EventEmitter<T>;
     /**
      * **Experimental**: May change in future revisions
      * Note: potential leak - This link will remain subscribed to the notifier
@@ -101,6 +99,46 @@ export declare class EventEmitter<T> extends Emitter<T> {
      * @returns
      */
     takeUntil(notifier: Emitter<any>): Emitter<T>;
+    /**
+     * Creates a chainable emitter that immediately emits a value to every new subscriber,
+     * then forwards parent emissions
+     * @param value
+     * @returns A new emitter that emits a value to new subscribers and forwards all values from the parent
+     */
+    immediate(value: T): EventEmitter<T>;
+    cached(): EventEmitter<T>;
+    /**
+     * Creates a chainable emitter that applies arbitrary transformation to values emitted by its parent
+     * @param mapFunc
+     * @returns Listenable: emits transformed values
+     */
+    map<R>(mapFunc: (value: T) => R): EventEmitter<R>;
+    /**
+     * Creates a chainable emitter that 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
+     * @returns Listenable: emits values that pass the filter
+     */
+    filter(check: (value: T) => boolean): EventEmitter<T>;
+    /**
+     * Creates a chainable emitter that discards emitted values that are the same as the last value emitted by the new emitter
+     * @param compare Optional function that takes the previous and next values and returns true if they should be considered equal
+     *
+     * If no `compare` function is provided, values will be compared via `===`
+     * @returns Listenable: emits non-repeating values
+     */
+    dedupe(compare?: (a: T, b: T) => boolean): EventEmitter<T>;
+    /**
+     * Creates a chainable emitter that mirrors emissions from the parent emitter, invoking the provided callback `cb` as a side effect for each emission.
+     *
+     * The callback `cb` is called exactly once per parent emission, regardless of how many listeners are attached to the returned emitter.
+     * All listeners attached to the returned emitter receive the same values as the parent emitter.
+     *
+     * *Note*, the side effect `cb` is only invoked when there is at least one listener attached to the returned emitter
+     *
+     * @param cb A function to be called as a side effect for each value emitted by the parent emitter.
+     * @returns A new emitter that forwards all values from the parent, invoking `cb` as a side effect.
+     */
+    tap(cb: Handler<T>): EventEmitter<T>;
 }
 /**
  * Creates a linked Emitter and emit() pair
@@ -141,4 +179,7 @@ export declare function createListenable<T>(onAddFirst?: () => void, onRemoveLas
     listen: (fn: (v: T) => void) => UnsubscribeFunc;
     emit: (value: T) => void;
 };
+export declare function interval(t: number | {
+    asMilliseconds: number;
+}): EventEmitter<number>;
 export {};

package/internal/emitter.js

@@ -152,10 +152,6 @@ export class EventEmitter extends Emitter {
         });
         return new EventEmitter(listen);
     }
-    filter(check) {
-        const listen = this.transform((value, emit) => check(value) && emit(value));
-        return new EventEmitter(listen);
-    }
     /**
      * **Experimental**: May change in future revisions
      * Note: potential leak - This link will remain subscribed to the parent
@@ -211,13 +207,6 @@ export class EventEmitter extends Emitter {
         });
         return new EventEmitter(listen);
     }
-    tap(cb) {
-        const listen = this.transform((value, emit) => {
-            cb(value);
-            emit(value);
-        });
-        return new EventEmitter(listen);
-    }
     /**
      * **Experimental**: May change in future revisions
      * Note: potential leak - This link will remain subscribed to the notifier
@@ -236,6 +225,90 @@ export class EventEmitter extends Emitter {
         });
         return new EventEmitter(listen);
     }
+    /**
+     * Creates a chainable emitter that immediately emits a value to every new subscriber,
+     * then forwards parent emissions
+     * @param value
+     * @returns A new emitter that emits a value to new subscribers and forwards all values from the parent
+     */
+    immediate(value) {
+        return new EventEmitter(handle => {
+            handle(value);
+            return this.onListen(handle);
+        });
+    }
+    cached() {
+        let cache = null;
+        let unsub = null;
+        const { listen, emit } = createListenable(() => {
+            unsub = this.onListen((value => {
+                cache = { value };
+                emit(value);
+            }));
+        }, () => {
+            unsub();
+        });
+        return new EventEmitter(handler => {
+            if (cache)
+                handler(cache.value);
+            return listen(handler);
+        });
+    }
+    /**
+     * Creates a chainable emitter that applies arbitrary transformation to values emitted by its parent
+     * @param mapFunc
+     * @returns Listenable: emits transformed values
+     */
+    map(mapFunc) {
+        const listen = this.transform((value, emit) => emit(mapFunc(value)));
+        return new EventEmitter(listen);
+    }
+    /**
+     * Creates a chainable emitter that 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
+     * @returns Listenable: emits values that pass the filter
+     */
+    filter(check) {
+        const listen = this.transform((value, emit) => check(value) && emit(value));
+        return new EventEmitter(listen);
+    }
+    /**
+     * Creates a chainable emitter that discards emitted values that are the same as the last value emitted by the new emitter
+     * @param compare Optional function that takes the previous and next values and returns true if they should be considered equal
+     *
+     * If no `compare` function is provided, values will be compared via `===`
+     * @returns Listenable: emits non-repeating values
+     */
+    dedupe(compare) {
+        let previous = null;
+        const listen = this.transform((value, emit) => {
+            if (!previous || (compare
+                ? !compare(previous.value, value)
+                : (previous.value !== value))) {
+                emit(value);
+                previous = { value };
+            }
+        });
+        return new EventEmitter(listen);
+    }
+    /**
+     * Creates a chainable emitter that mirrors emissions from the parent emitter, invoking the provided callback `cb` as a side effect for each emission.
+     *
+     * The callback `cb` is called exactly once per parent emission, regardless of how many listeners are attached to the returned emitter.
+     * All listeners attached to the returned emitter receive the same values as the parent emitter.
+     *
+     * *Note*, the side effect `cb` is only invoked when there is at least one listener attached to the returned emitter
+     *
+     * @param cb A function to be called as a side effect for each value emitted by the parent emitter.
+     * @returns A new emitter that forwards all values from the parent, invoking `cb` as a side effect.
+     */
+    tap(cb) {
+        const listen = this.transform((value, emit) => {
+            cb(value);
+            emit(value);
+        });
+        return new EventEmitter(listen);
+    }
 }
 /**
  * Creates a linked Emitter and emit() pair
@@ -298,3 +371,13 @@ export function createListenable(onAddFirst, onRemoveLast) {
         emit: (value) => handlers.forEach(h => h.fn(value)),
     };
 }
+export function interval(t) {
+    let intervalId = null;
+    let idx = 0;
+    const { emit, listen } = createListenable(() => {
+        intervalId = setInterval(() => {
+            emit(idx++);
+        }, typeof t == "number" ? t : t.asMilliseconds);
+    }, () => clearInterval(intervalId));
+    return new EventEmitter(listen);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtia/jel",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "repository": {
     "url": "https://github.com/tiadrop/jel-ts",
     "type": "github"