@thi.ng/rstream 8.2.13 → 8.2.14

package/sync.js

@@ -1,193 +1,150 @@
 import { comp } from "@thi.ng/transducers/comp";
 import { labeled } from "@thi.ng/transducers/labeled";
 import { mapVals } from "@thi.ng/transducers/map-vals";
-import { partitionSync, } from "@thi.ng/transducers/partition-sync";
+import {
+  partitionSync
+} from "@thi.ng/transducers/partition-sync";
 import { isFirstOrLastInput } from "./checks.js";
 import { __optsWithID } from "./idgen.js";
 import { __removeAllIDs } from "./internal/remove.js";
 import { LOGGER } from "./logger.js";
 import { Subscription } from "./subscription.js";
-/**
- * Similar to {@link StreamMerge}, but with extra synchronization of inputs.
- * Before emitting any new values, {@link StreamSync} collects values until at
- * least one has been received from *all* inputs. Once that's the case, the
- * collected values are sent as labeled tuple object to downstream subscribers.
- *
- * @remarks
- * Each value in the emitted tuple objects is stored under their input stream's
- * ID. Only the last value received from each input is passed on. After the
- * initial tuple has been emitted, you can choose from two possible behaviors:
- *
- * 1) Any future change in any input will produce a new result tuple. These
- *    tuples will retain the most recently read values from other inputs. This
- *    behavior is the default and illustrated in the above schematic.
- * 2) If the `reset` option is `true`, every input will have to provide at least
- *    one new value again until another result tuple is produced.
- *
- * Any done inputs are automatically removed. By default, `StreamSync` calls
- * {@link ISubscriber.done} when the last active input is done, but this
- * behavior can be overridden via the provided options.
- *
- * Input streams can be added and removed dynamically and the emitted tuple size
- * adjusts to the current number of inputs (the next time a value is received
- * from any input). After an input is removed (or done) its last received value
- * can also be removed from the result tuple. This behavior can be configured
- * via the `clean` option given to `sync()` (disabled by default).
- *
- * If the `reset` option is enabled, the last emitted tuple is allowed to be
- * incomplete, by default. To only allow complete tuples, also set the `all`
- * option to `false`.
- *
- * The synchronization is done via the
- * [`partitionSync()`](https://docs.thi.ng/umbrella/transducers/functions/partitionSync-1.html)
- * transducer from the [`thi.ng/transducers`](https://thi.ng/transducers)
- * package. See this function's docs for further details.
- *
- * @example
- * ```ts
- * const a = stream();
- * const b = stream();
- * s = sync({ src: { a, b } }).subscribe(trace("result: "));
- * a.next(1);
- * b.next(2);
- * // result: { a: 1, b: 2 }
- * ```
- *
- * Also see: {@link StreamSyncOpts}
- *
- * @param opts -
- */
-export const sync = (opts) => new StreamSync(opts);
-/**
- * @see {@link sync} for reference & examples.
- */
-export class StreamSync extends Subscription {
-    /**
-     * maps actual inputs to their virtual input subs
-     */
-    sources;
-    /**
-     * maps real source IDs to their actual input
-     */
-    idSources;
-    /**
-     * maps (potentially aliased) input IDs to their actual src.id
-     */
-    realSourceIDs;
-    /**
-     * maps real src.id to (potentially aliased) input IDs
-     */
-    invRealSourceIDs;
-    psync;
-    clean;
-    constructor(opts) {
-        const psync = partitionSync(new Set(), {
-            key: (x) => x[0],
-            mergeOnly: opts.mergeOnly === true,
-            reset: opts.reset === true,
-            all: opts.all !== false,
-            backPressure: opts.backPressure || 0,
-        });
-        const mapv = mapVals((x) => x[1]);
-        super(undefined, __optsWithID("streamsync", {
-            ...opts,
-            xform: opts.xform
-                ? comp(psync, mapv, opts.xform)
-                : comp(psync, mapv),
-        }));
-        this.sources = new Map();
-        this.realSourceIDs = new Map();
-        this.invRealSourceIDs = new Map();
-        this.idSources = new Map();
-        this.psync = psync;
-        this.clean = !!opts.clean;
-        opts.src && this.addAll(opts.src);
-    }
-    add(src, id) {
-        id || (id = src.id);
-        this.ensureState();
-        this.psync.add(id);
-        this.realSourceIDs.set(id, src.id);
-        this.invRealSourceIDs.set(src.id, id);
-        this.idSources.set(src.id, src);
-        this.sources.set(src, src.subscribe({
-            next: (x) => 
+const sync = (opts) => new StreamSync(opts);
+class StreamSync extends Subscription {
+  /**
+   * maps actual inputs to their virtual input subs
+   */
+  sources;
+  /**
+   * maps real source IDs to their actual input
+   */
+  idSources;
+  /**
+   * maps (potentially aliased) input IDs to their actual src.id
+   */
+  realSourceIDs;
+  /**
+   * maps real src.id to (potentially aliased) input IDs
+   */
+  invRealSourceIDs;
+  psync;
+  clean;
+  constructor(opts) {
+    const psync = partitionSync(/* @__PURE__ */ new Set(), {
+      key: (x) => x[0],
+      mergeOnly: opts.mergeOnly === true,
+      reset: opts.reset === true,
+      all: opts.all !== false,
+      backPressure: opts.backPressure || 0
+    });
+    const mapv = mapVals((x) => x[1]);
+    super(
+      void 0,
+      __optsWithID("streamsync", {
+        ...opts,
+        xform: opts.xform ? comp(psync, mapv, opts.xform) : comp(psync, mapv)
+      })
+    );
+    this.sources = /* @__PURE__ */ new Map();
+    this.realSourceIDs = /* @__PURE__ */ new Map();
+    this.invRealSourceIDs = /* @__PURE__ */ new Map();
+    this.idSources = /* @__PURE__ */ new Map();
+    this.psync = psync;
+    this.clean = !!opts.clean;
+    opts.src && this.addAll(opts.src);
+  }
+  add(src, id) {
+    id || (id = src.id);
+    this.ensureState();
+    this.psync.add(id);
+    this.realSourceIDs.set(id, src.id);
+    this.invRealSourceIDs.set(src.id, id);
+    this.idSources.set(src.id, src);
+    this.sources.set(
+      src,
+      src.subscribe(
+        {
+          next: (x) => (
             // if received value is sub, add it as source
-            x[1] instanceof Subscription
-                ? this.add(x[1])
-                : this.next(x),
-            done: () => this.markDone(src),
-            __owner: this,
-        }, { xform: labeled(id), id: `in-${id}` }));
-    }
-    addAll(src) {
-        // pre-add all source ids for partitionSync
-        for (let id in src) {
-            this.psync.add(id);
-        }
-        for (let id in src) {
-            this.add(src[id], id);
-        }
-    }
-    remove(src) {
-        const sub = this.sources.get(src);
-        if (sub) {
-            const id = this.invRealSourceIDs.get(src.id);
-            LOGGER.info(`removing src: ${src.id} (${id})`);
-            this.psync.delete(id, this.clean);
-            this.realSourceIDs.delete(id);
-            this.invRealSourceIDs.delete(src.id);
-            this.idSources.delete(src.id);
-            this.sources.delete(src);
-            sub.unsubscribe();
-            return true;
-        }
-        return false;
-    }
-    removeID(id) {
-        const src = this.getSourceForID(id);
-        return src ? this.remove(src) : false;
+            x[1] instanceof Subscription ? this.add(x[1]) : this.next(x)
+          ),
+          done: () => this.markDone(src),
+          __owner: this
+        },
+        { xform: labeled(id), id: `in-${id}` }
+      )
+    );
+  }
+  addAll(src) {
+    for (let id in src) {
+      this.psync.add(id);
     }
-    removeAll(src) {
-        // pre-remove all source ids for partitionSync
-        for (let s of src) {
-            this.psync.delete(this.invRealSourceIDs.get(s.id));
-        }
-        let ok = true;
-        for (let s of src) {
-            ok = this.remove(s) && ok;
-        }
-        return ok;
+    for (let id in src) {
+      this.add(src[id], id);
     }
-    removeAllIDs(ids) {
-        return __removeAllIDs(this, ids);
+  }
+  remove(src) {
+    const sub = this.sources.get(src);
+    if (sub) {
+      const id = this.invRealSourceIDs.get(src.id);
+      LOGGER.info(`removing src: ${src.id} (${id})`);
+      this.psync.delete(id, this.clean);
+      this.realSourceIDs.delete(id);
+      this.invRealSourceIDs.delete(src.id);
+      this.idSources.delete(src.id);
+      this.sources.delete(src);
+      sub.unsubscribe();
+      return true;
     }
-    getSourceForID(id) {
-        return this.idSources.get(this.realSourceIDs.get(id));
+    return false;
+  }
+  removeID(id) {
+    const src = this.getSourceForID(id);
+    return src ? this.remove(src) : false;
+  }
+  removeAll(src) {
+    for (let s of src) {
+      this.psync.delete(this.invRealSourceIDs.get(s.id));
     }
-    getSources() {
-        const res = {};
-        for (let [id, src] of this.idSources) {
-            res[this.invRealSourceIDs.get(id)] = src;
-        }
-        return res;
+    let ok = true;
+    for (let s of src) {
+      ok = this.remove(s) && ok;
     }
-    unsubscribe(sub) {
-        if (!sub) {
-            LOGGER.debug(this.id, "unsub sources");
-            for (let s of this.sources.values()) {
-                s.unsubscribe();
-            }
-            this.sources.clear();
-            this.psync.clear();
-            this.realSourceIDs.clear();
-            this.invRealSourceIDs.clear();
-            this.idSources.clear();
-        }
-        return super.unsubscribe(sub);
+    return ok;
+  }
+  removeAllIDs(ids) {
+    return __removeAllIDs(this, ids);
+  }
+  getSourceForID(id) {
+    return this.idSources.get(this.realSourceIDs.get(id));
+  }
+  getSources() {
+    const res = {};
+    for (let [id, src] of this.idSources) {
+      res[this.invRealSourceIDs.get(id)] = src;
     }
-    markDone(src) {
-        this.remove(src);
-        isFirstOrLastInput(this.closeIn, this.sources.size) && this.done();
+    return res;
+  }
+  unsubscribe(sub) {
+    if (!sub) {
+      LOGGER.debug(this.id, "unsub sources");
+      for (let s of this.sources.values()) {
+        s.unsubscribe();
+      }
+      this.sources.clear();
+      this.psync.clear();
+      this.realSourceIDs.clear();
+      this.invRealSourceIDs.clear();
+      this.idSources.clear();
     }
+    return super.unsubscribe(sub);
+  }
+  markDone(src) {
+    this.remove(src);
+    isFirstOrLastInput(this.closeIn, this.sources.size) && this.done();
+  }
 }
+export {
+  StreamSync,
+  sync
+};

package/timeout.js

@@ -1,55 +1,44 @@
 import { State } from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { Subscription } from "./subscription.js";
-/**
- * Returns a {@link Subscription} that calls the
- * {@link ISubscriber.error} handlers of all child subscriptions with an
- * arbitrary error object after a given time.
- *
- * @remarks
- * If no `error` is given, uses a new `Error` instance by default. If
- * `resetTimeout` is false (default), the error is emitted regardless of
- * any received values in the meantime. However, if `true`, the timeout
- * resets with each received value and then only triggers once the time
- * interval since the last value has exceeded.
- *
- * @param timeoutMs - timeout period in milliseconds
- * @param opts -
- */
-export const timeout = (timeoutMs, opts) => new Timeout(timeoutMs, opts);
-/**
- * @see {@link timeout} for reference & examples.
- */
+const timeout = (timeoutMs, opts) => new Timeout(timeoutMs, opts);
 class Timeout extends Subscription {
-    timeoutMs;
-    timeoutId;
-    errorObj;
-    resetTimeout;
-    constructor(timeoutMs, opts) {
-        opts = __optsWithID("timeout", opts);
-        super(undefined, opts);
-        this.timeoutMs = timeoutMs;
-        this.errorObj = opts.error;
-        this.resetTimeout = opts.reset === true;
-        this.reset();
-    }
-    next(x) {
-        if (this.resetTimeout) {
-            clearTimeout(this.timeoutId);
-            this.reset();
-        }
-        super.next(x);
-    }
-    reset() {
-        this.timeoutId = setTimeout(() => {
-            if (this.state < State.DONE) {
-                this.dispatchTo("error", this.errorObj ||
-                    new Error(`Timeout '${this.id}' after ${this.timeoutMs} ms`));
-            }
-        }, this.timeoutMs);
-    }
-    release() {
-        clearTimeout(this.timeoutId);
-        super.release();
+  timeoutMs;
+  timeoutId;
+  errorObj;
+  resetTimeout;
+  constructor(timeoutMs, opts) {
+    opts = __optsWithID("timeout", opts);
+    super(void 0, opts);
+    this.timeoutMs = timeoutMs;
+    this.errorObj = opts.error;
+    this.resetTimeout = opts.reset === true;
+    this.reset();
+  }
+  next(x) {
+    if (this.resetTimeout) {
+      clearTimeout(this.timeoutId);
+      this.reset();
     }
+    super.next(x);
+  }
+  reset() {
+    this.timeoutId = setTimeout(() => {
+      if (this.state < State.DONE) {
+        this.dispatchTo(
+          "error",
+          this.errorObj || new Error(
+            `Timeout '${this.id}' after ${this.timeoutMs} ms`
+          )
+        );
+      }
+    }, this.timeoutMs);
+  }
+  release() {
+    clearTimeout(this.timeoutId);
+    super.release();
+  }
 }
+export {
+  timeout
+};

package/toggle.js

@@ -1,32 +1,13 @@
 import { toggle as $toggle } from "@thi.ng/transducers/toggle";
 import { Subscription } from "./subscription.js";
-/**
- * Returns a {@link Subscription} which toggles between true/false for each
- * {@link Subscription.next} call. The sub will be seeded with the given
- * `initial` value.
- *
- * @examples
- * ```ts
- * const mute = toggle(false);
- *
- * mute.subscribe(trace("mute"));
- * // mute false
- *
- * mute.next();
- * // mute true
- *
- * mute.next();
- * // mute false
- * ```
- *
- * @param initial
- * @param opts
- */
-export function toggle(initial, opts) {
-    const sub = new Subscription(undefined, {
-        xform: $toggle(true, false, !initial),
-        ...opts,
-    });
-    sub.next();
-    return sub;
+function toggle(initial, opts) {
+  const sub = new Subscription(void 0, {
+    xform: $toggle(true, false, !initial),
+    ...opts
+  });
+  sub.next();
+  return sub;
 }
+export {
+  toggle
+};

package/trace.js

@@ -1,19 +1,15 @@
-/**
- * Helper {@link ISubscriber} for inspection / debugging purposes.
- * Simply logs received values to console, optionally with given
- * `prefix`.
- *
- * @param prefix -
- */
-export const trace = (prefix) => ({
-    next(x) {
-        prefix ? console.log(prefix, x) : console.log(x);
-    },
-    done() {
-        prefix ? console.log(prefix, "done") : console.log("done");
-    },
-    error(e) {
-        prefix ? console.log(prefix, "error", e) : console.log("error", e);
-        return false;
-    },
+const trace = (prefix) => ({
+  next(x) {
+    prefix ? console.log(prefix, x) : console.log(x);
+  },
+  done() {
+    prefix ? console.log(prefix, "done") : console.log("done");
+  },
+  error(e) {
+    prefix ? console.log(prefix, "error", e) : console.log("error", e);
+    return false;
+  }
 });
+export {
+  trace
+};

package/transduce.js

@@ -1,62 +1,45 @@
 import { isReduced } from "@thi.ng/transducers/reduced";
-/**
- * Returns a promise which subscribes to given input and transforms
- * incoming values using given transducer `xform` and reducer `rfn`.
- *
- * @remarks
- * Once the input or the reducer is done, the promise will resolve with
- * the final reduced result (or fail with error).
- *
- * @example
- * ```ts
- * transduce(
- *   fromIterable(tx.range(10)),
- *   tx.map((x) => x * 10),
- *   tx.add()
- * ).then((x) => console.log("result", x))
- *
- * // result 450
- * ```
- *
- * @param src -
- * @param xform -
- * @param rfn -
- * @param init -
- */
-export const transduce = (src, xform, rfn, init) => {
-    let acc = init !== undefined ? init : rfn[0]();
-    let sub;
-    return new Promise((resolve, reject) => {
-        sub = src.subscribe({
-            next(x) {
-                let _acc;
-                try {
-                    _acc = rfn[2](acc, x);
-                }
-                catch (e) {
-                    reject(e);
-                    return;
-                }
-                if (isReduced(_acc)) {
-                    resolve(_acc.deref());
-                }
-                else {
-                    acc = _acc;
-                }
-            },
-            done() {
-                resolve(acc);
-            },
-            error(e) {
-                reject(e);
-                return false;
-            },
-        }, { xform });
-    }).then((fulfilled) => {
-        sub.unsubscribe();
-        return fulfilled;
-    }, (rejected) => {
-        sub.unsubscribe();
-        throw rejected;
-    });
+const transduce = (src, xform, rfn, init) => {
+  let acc = init !== void 0 ? init : rfn[0]();
+  let sub;
+  return new Promise((resolve, reject) => {
+    sub = src.subscribe(
+      {
+        next(x) {
+          let _acc;
+          try {
+            _acc = rfn[2](acc, x);
+          } catch (e) {
+            reject(e);
+            return;
+          }
+          if (isReduced(_acc)) {
+            resolve(_acc.deref());
+          } else {
+            acc = _acc;
+          }
+        },
+        done() {
+          resolve(acc);
+        },
+        error(e) {
+          reject(e);
+          return false;
+        }
+      },
+      { xform }
+    );
+  }).then(
+    (fulfilled) => {
+      sub.unsubscribe();
+      return fulfilled;
+    },
+    (rejected) => {
+      sub.unsubscribe();
+      throw rejected;
+    }
+  );
+};
+export {
+  transduce
 };

package/trigger.js

@@ -1,5 +1,8 @@
 import { __optsWithID } from "./idgen.js";
 import { fromIterableSync } from "./iterable.js";
-export function trigger(x = true, opts) {
-    return fromIterableSync([x], __optsWithID("trigger", opts));
+function trigger(x = true, opts) {
+  return fromIterableSync([x], __optsWithID("trigger", opts));
 }
+export {
+  trigger
+};