@thi.ng/rstream 8.2.13 → 8.2.14

package/subscription.js

@@ -8,283 +8,222 @@ import { comp } from "@thi.ng/transducers/comp";
 import { map } from "@thi.ng/transducers/map";
 import { push } from "@thi.ng/transducers/push";
 import { isReduced, unreduced } from "@thi.ng/transducers/reduced";
-import { CloseMode, State, } from "./api.js";
+import {
+  CloseMode,
+  State
+} from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { LOGGER } from "./logger.js";
-/**
- * Creates a new {@link Subscription} instance, the fundamental datatype and
- * building block provided by this package.
- *
- * @remarks
- * Most other types in rstream, including {@link Stream}s, are `Subscription`s
- * and all can be:
- *
- * - connected into directed graphs (sync or async & not necessarily DAGs)
- * - transformed using transducers (incl. support for early termination)
- * - can have any number of subscribers (optionally each w/ their own
- *   transducers)
- * - recursively unsubscribe themselves from parent after their last subscriber
- *   unsubscribed (configurable)
- * - will go into a non-recoverable error state if none of the subscribers has
- *   an error handler itself
- * - implement the
- *   [`IDeref`](https://docs.thi.ng/umbrella/api/interfaces/IDeref.html)
- *   interface
- *
- * If a transducer is provided (via the `xform` option), all received values
- * will be first processed by the transducer and only its transformed result(s)
- * (if any) will be passed to downstream subscribers. Any uncaught errors
- * *inside* the transducer will cause this subscription's error handler to be
- * called and will stop this subscription from receiving any further values (by
- * default, unless overridden).
- *
- * Subscription behavior can be customized via the additional (optional) options
- * arg. See {@link CommonOpts} and {@link SubscriptionOpts} for further details.
- *
- * @example
- * ```ts
- * // as reactive value mechanism (same as with stream() above)
- * s = subscription();
- * s.subscribe(trace("s1"));
- * s.subscribe(trace("s2"), { xform: tx.filter((x) => x > 25) });
- *
- * // external trigger
- * s.next(23);
- * // s1 23
- * s.next(42);
- * // s1 42
- * // s2 42
- * ```
- *
- * @param sub -
- * @param opts -
- */
-export const subscription = (sub, opts) => new Subscription(sub, opts);
-export class Subscription {
-    wrapped;
-    id;
-    closeIn;
-    closeOut;
-    parent;
-    __owner;
-    xform;
-    cacheLast;
-    last = SEMAPHORE;
-    state = State.IDLE;
-    subs = [];
-    constructor(wrapped, opts) {
-        this.wrapped = wrapped;
-        opts = __optsWithID(`sub`, {
-            closeIn: CloseMode.LAST,
-            closeOut: CloseMode.LAST,
-            cache: true,
-            ...opts,
-        });
-        this.parent = opts.parent;
-        this.id = opts.id;
-        this.closeIn = opts.closeIn;
-        this.closeOut = opts.closeOut;
-        this.cacheLast = opts.cache;
-        opts.xform && (this.xform = opts.xform(push()));
-    }
-    deref() {
-        return this.last !== SEMAPHORE ? this.last : undefined;
-    }
-    getState() {
-        return this.state;
-    }
-    setState(state) {
-        this.state = state;
-    }
-    subscribe(sub, opts = {}) {
-        this.ensureState();
-        let $sub;
-        if (sub instanceof Subscription && !opts.xform) {
-            sub.ensureState();
-            // ensure sub is still unattached
-            assert(!sub.parent, `sub '${sub.id}' already has a parent`);
-            sub.parent = this;
-            $sub = sub;
-        }
-        else {
-            $sub = new Subscription(sub, { ...opts, parent: this });
-        }
-        this.subs.push($sub);
-        this.setState(State.ACTIVE);
-        $sub.setState(State.ACTIVE);
-        this.last != SEMAPHORE && $sub.next(this.last);
-        return $sub;
-    }
-    transform(...args) {
-        let sub;
-        let opts;
-        if (isPlainObject(peek(args))) {
-            opts = args.pop();
-            sub = { error: opts.error };
-        }
-        return this.subscribe(sub, __optsWithID("xform", args.length > 0
-            ? {
-                ...opts,
-                // @ts-ignore
-                xform: comp(...args),
-            }
-            : opts));
-    }
-    /**
-     * Syntax sugar for {@link Subscription.transform} when using a single
-     * [`map()`](https://docs.thi.ng/umbrella/transducers/functions/map.html)
-     * transducer only. The given function `fn` is used as `map`'s
-     * transformation fn.
-     *
-     * @param fn -
-     * @param opts -
-     */
-    map(fn, opts) {
-        return this.transform(map(fn), opts || {});
-    }
-    unsubscribe(sub) {
-        return sub ? this.unsubscribeChild(sub) : this.unsubscribeSelf();
-    }
-    unsubscribeSelf() {
-        LOGGER.debug(this.id, "unsub self");
-        this.parent && this.parent.unsubscribe(this);
-        this.state < State.UNSUBSCRIBED && (this.state = State.UNSUBSCRIBED);
-        this.release();
-        return true;
-    }
-    unsubscribeChild(sub) {
-        LOGGER.debug(this.id, "unsub child", sub.id);
-        const idx = this.subs.indexOf(sub);
-        if (idx >= 0) {
-            this.subs.splice(idx, 1);
-            if (this.closeOut === CloseMode.FIRST ||
-                (!this.subs.length && this.closeOut !== CloseMode.NEVER)) {
-                this.unsubscribe();
-            }
-            return true;
-        }
-        return false;
-    }
-    next(x) {
-        if (this.state >= State.DONE)
-            return;
-        this.xform ? this.dispatchXform(x) : this.dispatch(x);
-    }
-    done() {
-        LOGGER.debug(this.id, "entering done()");
-        if (this.state >= State.DONE)
-            return;
-        if (this.xform) {
-            if (!this.dispatchXformDone())
-                return;
-        }
-        this.state = State.DONE;
-        // attempt to call .done in wrapped sub
-        if (this.dispatchTo("done")) {
-            // disconnect from parent & internal cleanup
-            this.state < State.UNSUBSCRIBED && this.unsubscribe();
-        }
-        LOGGER.debug(this.id, "exiting done()");
-    }
-    error(e) {
-        // only the wrapped sub's error handler gets a chance
-        // to deal with the error
-        const sub = this.wrapped;
-        const hasErrorHandler = sub && sub.error;
-        hasErrorHandler &&
-            LOGGER.debug(this.id, "attempting wrapped error handler");
-        // flag success if error handler returns true
-        // (i.e. it could handle/recover from the error)
-        // else detach this entire sub by going into error state...
-        return (hasErrorHandler && sub.error(e)) || this.unhandledError(e);
-    }
-    unhandledError(e) {
-        // ensure error is at least logged to console
-        // even if default NULL_LOGGER is used...
-        (LOGGER !== NULL_LOGGER ? LOGGER : console).warn(this.id, "unhandled error:", e);
+const subscription = (sub, opts) => new Subscription(sub, opts);
+class Subscription {
+  constructor(wrapped, opts) {
+    this.wrapped = wrapped;
+    opts = __optsWithID(`sub`, {
+      closeIn: CloseMode.LAST,
+      closeOut: CloseMode.LAST,
+      cache: true,
+      ...opts
+    });
+    this.parent = opts.parent;
+    this.id = opts.id;
+    this.closeIn = opts.closeIn;
+    this.closeOut = opts.closeOut;
+    this.cacheLast = opts.cache;
+    opts.xform && (this.xform = opts.xform(push()));
+  }
+  id;
+  closeIn;
+  closeOut;
+  parent;
+  __owner;
+  xform;
+  cacheLast;
+  last = SEMAPHORE;
+  state = State.IDLE;
+  subs = [];
+  deref() {
+    return this.last !== SEMAPHORE ? this.last : void 0;
+  }
+  getState() {
+    return this.state;
+  }
+  setState(state) {
+    this.state = state;
+  }
+  subscribe(sub, opts = {}) {
+    this.ensureState();
+    let $sub;
+    if (sub instanceof Subscription && !opts.xform) {
+      sub.ensureState();
+      assert(!sub.parent, `sub '${sub.id}' already has a parent`);
+      sub.parent = this;
+      $sub = sub;
+    } else {
+      $sub = new Subscription(sub, { ...opts, parent: this });
+    }
+    this.subs.push($sub);
+    this.setState(State.ACTIVE);
+    $sub.setState(State.ACTIVE);
+    this.last != SEMAPHORE && $sub.next(this.last);
+    return $sub;
+  }
+  transform(...args) {
+    let sub;
+    let opts;
+    if (isPlainObject(peek(args))) {
+      opts = args.pop();
+      sub = { error: opts.error };
+    }
+    return this.subscribe(
+      sub,
+      __optsWithID(
+        "xform",
+        args.length > 0 ? {
+          ...opts,
+          // @ts-ignore
+          xform: comp(...args)
+        } : opts
+      )
+    );
+  }
+  /**
+   * Syntax sugar for {@link Subscription.transform} when using a single
+   * [`map()`](https://docs.thi.ng/umbrella/transducers/functions/map.html)
+   * transducer only. The given function `fn` is used as `map`'s
+   * transformation fn.
+   *
+   * @param fn -
+   * @param opts -
+   */
+  map(fn, opts) {
+    return this.transform(map(fn), opts || {});
+  }
+  unsubscribe(sub) {
+    return sub ? this.unsubscribeChild(sub) : this.unsubscribeSelf();
+  }
+  unsubscribeSelf() {
+    LOGGER.debug(this.id, "unsub self");
+    this.parent && this.parent.unsubscribe(this);
+    this.state < State.UNSUBSCRIBED && (this.state = State.UNSUBSCRIBED);
+    this.release();
+    return true;
+  }
+  unsubscribeChild(sub) {
+    LOGGER.debug(this.id, "unsub child", sub.id);
+    const idx = this.subs.indexOf(sub);
+    if (idx >= 0) {
+      this.subs.splice(idx, 1);
+      if (this.closeOut === CloseMode.FIRST || !this.subs.length && this.closeOut !== CloseMode.NEVER) {
         this.unsubscribe();
-        this.state = State.ERROR;
-        return false;
-    }
-    dispatchTo(type, x) {
-        let s = this.wrapped;
-        if (s) {
-            try {
-                s[type] && s[type](x);
-            }
-            catch (e) {
-                // give wrapped sub a chance to handle error
-                // (if that failed then we're already in error state now & terminate)
-                if (!this.error(e))
-                    return false;
-            }
-        }
-        // process other child subs
-        const subs = type === "next" ? this.subs : [...this.subs];
-        for (let i = subs.length; i-- > 0;) {
-            s = subs[i];
-            try {
-                s[type] && s[type](x);
-            }
-            catch (e) {
-                if (type === "error" || !s.error || !s.error(e)) {
-                    // if no or failed handler, go into error state
-                    return this.unhandledError(e);
-                }
-            }
+      }
+      return true;
+    }
+    return false;
+  }
+  next(x) {
+    if (this.state >= State.DONE)
+      return;
+    this.xform ? this.dispatchXform(x) : this.dispatch(x);
+  }
+  done() {
+    LOGGER.debug(this.id, "entering done()");
+    if (this.state >= State.DONE)
+      return;
+    if (this.xform) {
+      if (!this.dispatchXformDone())
+        return;
+    }
+    this.state = State.DONE;
+    if (this.dispatchTo("done")) {
+      this.state < State.UNSUBSCRIBED && this.unsubscribe();
+    }
+    LOGGER.debug(this.id, "exiting done()");
+  }
+  error(e) {
+    const sub = this.wrapped;
+    const hasErrorHandler = sub && sub.error;
+    hasErrorHandler && LOGGER.debug(this.id, "attempting wrapped error handler");
+    return hasErrorHandler && sub.error(e) || this.unhandledError(e);
+  }
+  unhandledError(e) {
+    (LOGGER !== NULL_LOGGER ? LOGGER : console).warn(
+      this.id,
+      "unhandled error:",
+      e
+    );
+    this.unsubscribe();
+    this.state = State.ERROR;
+    return false;
+  }
+  dispatchTo(type, x) {
+    let s = this.wrapped;
+    if (s) {
+      try {
+        s[type] && s[type](x);
+      } catch (e) {
+        if (!this.error(e))
+          return false;
+      }
+    }
+    const subs = type === "next" ? this.subs : [...this.subs];
+    for (let i = subs.length; i-- > 0; ) {
+      s = subs[i];
+      try {
+        s[type] && s[type](x);
+      } catch (e) {
+        if (type === "error" || !s.error || !s.error(e)) {
+          return this.unhandledError(e);
         }
-        return true;
-    }
-    dispatch(x) {
-        LOGGER.debug(this.id, "dispatch", x);
-        this.cacheLast && (this.last = x);
-        this.dispatchTo("next", x);
-    }
-    dispatchXform(x) {
-        let acc;
-        try {
-            acc = this.xform[2]([], x);
-        }
-        catch (e) {
-            // error in transducer can only be handled by the wrapped
-            // subscriber's error handler (if avail)
-            this.error(e);
-            // don't dispatch value(s)
-            return;
-        }
-        if (this.dispatchXformVals(acc)) {
-            isReduced(acc) && this.done();
-        }
-    }
-    dispatchXformDone() {
-        let acc;
-        try {
-            // collect remaining values from transducer
-            acc = this.xform[1]([]);
-        }
-        catch (e) {
-            // error in transducer can only be handled by the wrapped
-            // subscriber's error handler (if avail)
-            return this.error(e);
-        }
-        return this.dispatchXformVals(acc);
-    }
-    dispatchXformVals(acc) {
-        const uacc = unreduced(acc);
-        for (let i = 0, n = uacc.length; i < n && this.state < State.DONE; i++) {
-            this.dispatch(uacc[i]);
-        }
-        return this.state < State.ERROR;
-    }
-    ensureState() {
-        if (this.state >= State.DONE) {
-            illegalState(`operation not allowed in state ${this.state}`);
-        }
-    }
-    release() {
-        this.subs.length = 0;
-        delete this.parent;
-        delete this.xform;
-        delete this.last;
-    }
+      }
+    }
+    return true;
+  }
+  dispatch(x) {
+    LOGGER.debug(this.id, "dispatch", x);
+    this.cacheLast && (this.last = x);
+    this.dispatchTo("next", x);
+  }
+  dispatchXform(x) {
+    let acc;
+    try {
+      acc = this.xform[2]([], x);
+    } catch (e) {
+      this.error(e);
+      return;
+    }
+    if (this.dispatchXformVals(acc)) {
+      isReduced(acc) && this.done();
+    }
+  }
+  dispatchXformDone() {
+    let acc;
+    try {
+      acc = this.xform[1]([]);
+    } catch (e) {
+      return this.error(e);
+    }
+    return this.dispatchXformVals(acc);
+  }
+  dispatchXformVals(acc) {
+    const uacc = unreduced(acc);
+    for (let i = 0, n = uacc.length; i < n && this.state < State.DONE; i++) {
+      this.dispatch(uacc[i]);
+    }
+    return this.state < State.ERROR;
+  }
+  ensureState() {
+    if (this.state >= State.DONE) {
+      illegalState(`operation not allowed in state ${this.state}`);
+    }
+  }
+  release() {
+    this.subs.length = 0;
+    delete this.parent;
+    delete this.xform;
+    delete this.last;
+  }
 }
+export {
+  Subscription,
+  subscription
+};

package/sync-raf.js

@@ -2,73 +2,42 @@ import { isNode } from "@thi.ng/checks/is-node";
 import { State } from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { Subscription } from "./subscription.js";
-/**
- * Similar to (in in effect the same as the **now deprecated**)
- * {@link sidechainPartitionRAF}, however more performant & lightweight.
- * Synchronizes downstream processing w/ `requestAnimationFrame()`. The returned
- * subscription delays & debounces any high frequency intra-frame input values
- * and passes only most recent one downstream during next RAF event processing.
- *
- * This example uses thi.ng/atom as state container. Also see {@link fromAtom}.
- *
- * See {@link sidechainTrigger} from a similar & more general construct.
- *
- * @example
- * ```ts
- * const atom = defAtom("alice");
- *
- * // any changes to the atom will only be received by this subscription
- * // during next RAF update cycle
- * syncRAF(fromAtom(atom)).subscribe({
- *   next({ name }) { document.body.innerText = name; }
- * });
- *
- * // trigger update
- * atom.reset("bob");
- * ```
- *
- * @param src -
- * @param opts -
- */
-export const syncRAF = (src, opts) => src.subscribe(new SyncRAF(__optsWithID(`syncraf-${src.id}`, opts)));
-/**
- * See {@link syncRAF} for details.
- */
-export class SyncRAF extends Subscription {
-    queued;
-    raf;
-    constructor(opts) {
-        super(undefined, opts);
-    }
-    next(x) {
-        if (this.state >= State.DONE)
-            return;
-        this.queued = x;
-        if (!this.raf) {
-            const update = () => {
-                if (this.state < State.DONE)
-                    super.next(this.queued);
-                this._clean();
-            };
-            this.raf = isNode()
-                ? setTimeout(update, 16)
-                : requestAnimationFrame(update);
-        }
-    }
-    done() {
-        this._clean();
-        super.done();
-    }
-    error(e) {
+const syncRAF = (src, opts) => src.subscribe(new SyncRAF(__optsWithID(`syncraf-${src.id}`, opts)));
+class SyncRAF extends Subscription {
+  queued;
+  raf;
+  constructor(opts) {
+    super(void 0, opts);
+  }
+  next(x) {
+    if (this.state >= State.DONE)
+      return;
+    this.queued = x;
+    if (!this.raf) {
+      const update = () => {
+        if (this.state < State.DONE)
+          super.next(this.queued);
         this._clean();
-        return super.error(e);
+      };
+      this.raf = isNode() ? setTimeout(update, 16) : requestAnimationFrame(update);
     }
-    _clean() {
-        if (this.raf) {
-            isNode()
-                ? clearTimeout(this.raf)
-                : cancelAnimationFrame(this.raf);
-        }
-        this.raf = this.queued = undefined;
+  }
+  done() {
+    this._clean();
+    super.done();
+  }
+  error(e) {
+    this._clean();
+    return super.error(e);
+  }
+  _clean() {
+    if (this.raf) {
+      isNode() ? clearTimeout(this.raf) : cancelAnimationFrame(this.raf);
     }
+    this.raf = this.queued = void 0;
+  }
 }
+export {
+  SyncRAF,
+  syncRAF
+};