@thi.ng/rstream 8.2.13 → 8.2.14

package/sidechain-partition.js

@@ -1,97 +1,44 @@
 import { peek } from "@thi.ng/arrays/peek";
 import { map } from "@thi.ng/transducers/map";
-import { State, } from "./api.js";
+import {
+  State
+} from "./api.js";
 import { ASidechain } from "./asidechain.js";
 import { __optsWithID } from "./idgen.js";
 import { fromRAF } from "./raf.js";
-/**
- * Returns a subscription which buffers values from `src` until side chain
- * delivers its next value, then emits buffer (unless empty) and repeats process
- * until either input is done.
- *
- * @remarks
- * By default, the values read from the side chain are ignored (i.e. only their
- * timing is used), however the `pred`icate option can be used to only trigger
- * for specific values / conditions.
- *
- * Also see: {@link sidechainToggle}, {@link sidechainTrigger}, {@link syncRAF}.
- *
- * @example
- * ```t
- * // merge various event streams
- * events = merge([
- *     fromEvent(document,"mousemove"),
- *     fromEvent(document,"mousedown"),
- *     fromEvent(document,"mouseup")
- * ]);
- *
- * // queue event processing to only execute during the
- * // requestAnimationFrame cycle (RAF)
- * sidechainPartition(events, fromRAF()).subscribe(trace())
- * ```
- *
- * @param src -
- * @param side -
- * @param opts -
- */
-export const sidechainPartition = (src, side, opts) => src.subscribe(new SidechainPartition(side, opts));
-/**
- * **Deprecated** syntax sugar for one of most common {@link sidechainPartition}
- * use cases, to synchronize downstream processing w/ `requestAnimationFrame()`.
- * Please use {@link syncRAF} instead.
- *
- * @remarks
- * The returned subscription debounces any high frequency intra-frame input
- * values and (if any present), passes only most recent one downstream during
- * next RAF event processing.
- *
- * This example uses thi.ng/atom as state container. Also see {@link fromAtom}
- * and {@link syncRAF}.
- *
- * @example
- * ```ts
- * const atom = defAtom("alice");
- *
- * // any change to the atom will only be applied during next RAF update
- * sideChainPartitionRAF(fromAtom(atom)).subscribe({
- *   next({ name }) { document.body.innerText = name; }
- * });
- *
- * // trigger update
- * atom.reset("bob");
- * ```
- *
- * @param src -
- *
- * @deprecated
- */
-export const sidechainPartitionRAF = (src) => sidechainPartition(src, fromRAF()).transform(map(peek));
-export class SidechainPartition extends ASidechain {
-    buf;
-    constructor(side, opts) {
-        opts = __optsWithID("sidepart", opts);
-        super(opts);
-        const pred = opts.pred || (() => true);
-        this.buf = [];
-        this.sideSub = side.subscribe({
-            next: (x) => {
-                if (this.buf.length && pred(x)) {
-                    this.dispatch(this.buf);
-                    this.buf = [];
-                }
-            },
-            done: () => {
-                if (this.buf.length) {
-                    this.dispatch(this.buf);
-                }
-                this.done();
-                delete this.buf;
-            },
-        });
-    }
-    next(x) {
-        if (this.state < State.DONE) {
-            this.buf.push(x);
+const sidechainPartition = (src, side, opts) => src.subscribe(new SidechainPartition(side, opts));
+const sidechainPartitionRAF = (src) => sidechainPartition(src, fromRAF()).transform(map(peek));
+class SidechainPartition extends ASidechain {
+  buf;
+  constructor(side, opts) {
+    opts = __optsWithID("sidepart", opts);
+    super(opts);
+    const pred = opts.pred || (() => true);
+    this.buf = [];
+    this.sideSub = side.subscribe({
+      next: (x) => {
+        if (this.buf.length && pred(x)) {
+          this.dispatch(this.buf);
+          this.buf = [];
+        }
+      },
+      done: () => {
+        if (this.buf.length) {
+          this.dispatch(this.buf);
         }
+        this.done();
+        delete this.buf;
+      }
+    });
+  }
+  next(x) {
+    if (this.state < State.DONE) {
+      this.buf.push(x);
     }
+  }
 }
+export {
+  SidechainPartition,
+  sidechainPartition,
+  sidechainPartitionRAF
+};

package/sidechain-toggle.js

@@ -1,53 +1,32 @@
-import { State, } from "./api.js";
+import {
+  State
+} from "./api.js";
 import { ASidechain } from "./asidechain.js";
 import { __optsWithID } from "./idgen.js";
-/**
- * Returns a subscription which filters values from `src` based on control
- * values received from `side` chain.
- *
- * @remarks
- * By default, the values read from the side chain are ignored (i.e. only their
- * timing is used), however the `pred`icate option can be used to only trigger
- * for specific values/conditions. Every time the predicate fn returns true, the
- * filter will be toggled on/off. Whilst switched off, no input values will be
- * forwarded downstream.
- *
- * @example
- * ```ts
- * // use slower interval stream to toggle faster main stream on/off
- * sidechainToggle(fromInterval(500), fromInterval(1000)).subscribe(trace());
- * // 0
- * // 3
- * // 4
- * // 7
- * // 8
- * ...
- * ```
- *
- * @param src -
- * @param side -
- * @param opts -
- */
-export const sidechainToggle = (src, side, opts) => src.subscribe(new SidechainToggle(side, opts));
-export class SidechainToggle extends ASidechain {
-    isActive;
-    constructor(side, opts) {
-        opts = __optsWithID("sidetoggle", opts);
-        super(opts);
-        this.isActive = !!opts.initial;
-        const pred = opts.pred || (() => true);
-        this.sideSub = side.subscribe({
-            next: (x) => {
-                if (pred(x)) {
-                    this.isActive = !this.isActive;
-                }
-            },
-            done: () => this.done(),
-        });
-    }
-    next(x) {
-        if (this.isActive && this.state < State.DONE) {
-            super.next(x);
+const sidechainToggle = (src, side, opts) => src.subscribe(new SidechainToggle(side, opts));
+class SidechainToggle extends ASidechain {
+  isActive;
+  constructor(side, opts) {
+    opts = __optsWithID("sidetoggle", opts);
+    super(opts);
+    this.isActive = !!opts.initial;
+    const pred = opts.pred || (() => true);
+    this.sideSub = side.subscribe({
+      next: (x) => {
+        if (pred(x)) {
+          this.isActive = !this.isActive;
         }
+      },
+      done: () => this.done()
+    });
+  }
+  next(x) {
+    if (this.isActive && this.state < State.DONE) {
+      super.next(x);
     }
+  }
 }
+export {
+  SidechainToggle,
+  sidechainToggle
+};

package/sidechain-trigger.js

@@ -1,66 +1,32 @@
 import { SEMAPHORE } from "@thi.ng/api/api";
-import { State, } from "./api.js";
+import {
+  State
+} from "./api.js";
 import { ASidechain } from "./asidechain.js";
 import { __optsWithID } from "./idgen.js";
-/**
- * Returns a subscription which buffers the most recent value received from
- * `src` and only forwards it downstream whenever a new control value is
- * received from the `side` chain.
- *
- * @remarks
- * By default, the values read from the side chain are ignored (i.e. only their
- * timing is used), however the `pred`icate option can be used to only trigger
- * for specific values/conditions. Every time the predicate fn returns true AND
- * if `src` already has delivered at least one value, it will be forwarded
- * downstream.
- *
- * @example
- * ```ts
- * const src = reactive("payload");
- *
- * const side = stream();
- *
- * sidechainTrigger(src, side).subscribe(trace("data:"));
- *
- * side.next(1);
- * // data: payload
- *
- * side.next(1);
- * // data: payload
- *
- * // only newest value will be buffered
- * src.next("update #1");
- * src.next("update #2");
- *
- * // ...until side chain triggers again
- * side.next(1);
- * // data: update #2
- * ...
- * ```
- *
- * @param src
- * @param side
- * @param opts
- */
-export const sidechainTrigger = (src, side, opts) => src.subscribe(new SidechainTrigger(side, opts));
-export class SidechainTrigger extends ASidechain {
-    buf = SEMAPHORE;
-    constructor(side, opts) {
-        opts = __optsWithID("sidetrigger", opts);
-        super(opts);
-        const pred = opts.pred || (() => true);
-        this.sideSub = side.subscribe({
-            next: (x) => {
-                if (this.buf !== SEMAPHORE && pred(x)) {
-                    this.dispatch(this.buf);
-                }
-            },
-            done: () => this.done(),
-        });
-    }
-    next(x) {
-        if (this.state < State.DONE) {
-            this.buf = x;
+const sidechainTrigger = (src, side, opts) => src.subscribe(new SidechainTrigger(side, opts));
+class SidechainTrigger extends ASidechain {
+  buf = SEMAPHORE;
+  constructor(side, opts) {
+    opts = __optsWithID("sidetrigger", opts);
+    super(opts);
+    const pred = opts.pred || (() => true);
+    this.sideSub = side.subscribe({
+      next: (x) => {
+        if (this.buf !== SEMAPHORE && pred(x)) {
+          this.dispatch(this.buf);
         }
+      },
+      done: () => this.done()
+    });
+  }
+  next(x) {
+    if (this.state < State.DONE) {
+      this.buf = x;
     }
+  }
 }
+export {
+  SidechainTrigger,
+  sidechainTrigger
+};

package/stream.js

@@ -1,85 +1,78 @@
 import { isFunction } from "@thi.ng/checks/is-function";
-import { CloseMode, } from "./api.js";
+import {
+  CloseMode
+} from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { LOGGER } from "./logger.js";
 import { Subscription } from "./subscription.js";
-export function stream(src, opts) {
-    return new Stream(src, opts);
+function stream(src, opts) {
+  return new Stream(src, opts);
 }
-/**
- * Syntax sugar for {@link stream}. Creates new stream which is
- * immediately seeded with initial `val` and configured with optional
- * `opts`.
- *
- * @param val -
- * @param opts -
- */
-export const reactive = (val, opts) => {
-    const res = new Stream(opts);
-    res.next(val);
-    return res;
+const reactive = (val, opts) => {
+  const res = new Stream(opts);
+  res.next(val);
+  return res;
 };
-/**
- * @see {@link stream} & {@link reactive} for reference & examples.
- */
-export class Stream extends Subscription {
-    src;
-    _cancel;
-    _inited;
-    constructor(src, opts) {
-        const [_src, _opts] = isFunction(src)
-            ? [src, opts || {}]
-            : [undefined, src || {}];
-        super(_opts.error ? { error: _opts.error } : undefined, __optsWithID("stream", _opts));
-        this.src = _src;
-        this._inited = false;
-    }
-    subscribe(sub, opts = {}) {
-        const $sub = super.subscribe(sub, opts);
-        if (!this._inited) {
-            if (this.src) {
-                try {
-                    this._cancel = this.src(this) || (() => void 0);
-                }
-                catch (e) {
-                    let s = this.wrapped;
-                    if (!s || !s.error || !s.error(e)) {
-                        this.unhandledError(e);
-                    }
-                }
-            }
-            this._inited = true;
-        }
-        return $sub;
-    }
-    unsubscribe(sub) {
-        const res = super.unsubscribe(sub);
-        if (res &&
-            (!sub ||
-                ((!this.subs || !this.subs.length) &&
-                    this.closeOut !== CloseMode.NEVER))) {
-            this.cancel();
+class Stream extends Subscription {
+  src;
+  _cancel;
+  _inited;
+  constructor(src, opts) {
+    const [_src, _opts] = isFunction(src) ? [src, opts || {}] : [void 0, src || {}];
+    super(
+      _opts.error ? { error: _opts.error } : void 0,
+      __optsWithID("stream", _opts)
+    );
+    this.src = _src;
+    this._inited = false;
+  }
+  subscribe(sub, opts = {}) {
+    const $sub = super.subscribe(sub, opts);
+    if (!this._inited) {
+      if (this.src) {
+        try {
+          this._cancel = this.src(this) || (() => void 0);
+        } catch (e) {
+          let s = this.wrapped;
+          if (!s || !s.error || !s.error(e)) {
+            this.unhandledError(e);
+          }
         }
-        return res;
+      }
+      this._inited = true;
     }
-    done() {
-        this.cancel();
-        super.done();
-        delete this.src;
-        delete this._cancel;
+    return $sub;
+  }
+  unsubscribe(sub) {
+    const res = super.unsubscribe(sub);
+    if (res && (!sub || (!this.subs || !this.subs.length) && this.closeOut !== CloseMode.NEVER)) {
+      this.cancel();
     }
-    error(e) {
-        if (super.error(e))
-            return true;
-        this.cancel();
-        return false;
-    }
-    cancel() {
-        if (this._cancel) {
-            LOGGER.debug(this.id, "cancel");
-            const f = this._cancel;
-            delete this._cancel;
-            f();
-        }
+    return res;
+  }
+  done() {
+    this.cancel();
+    super.done();
+    delete this.src;
+    delete this._cancel;
+  }
+  error(e) {
+    if (super.error(e))
+      return true;
+    this.cancel();
+    return false;
+  }
+  cancel() {
+    if (this._cancel) {
+      LOGGER.debug(this.id, "cancel");
+      const f = this._cancel;
+      delete this._cancel;
+      f();
     }
+  }
 }
+export {
+  Stream,
+  reactive,
+  stream
+};