@thi.ng/rstream 8.2.13 → 8.2.14

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/api.js

@@ -1,26 +1,18 @@
-export var State;
-(function (State) {
-    State[State["IDLE"] = 0] = "IDLE";
-    State[State["ACTIVE"] = 1] = "ACTIVE";
-    State[State["DONE"] = 2] = "DONE";
-    State[State["UNSUBSCRIBED"] = 3] = "UNSUBSCRIBED";
-    State[State["ERROR"] = 4] = "ERROR";
-})(State || (State = {}));
-/**
- * Closing behaviors.
- */
-export var CloseMode;
-(function (CloseMode) {
-    /**
-     * Never close, even if no more inputs/outputs.
-     */
-    CloseMode[CloseMode["NEVER"] = 0] = "NEVER";
-    /**
-     * Close when first input/output is done / removed.
-     */
-    CloseMode[CloseMode["FIRST"] = 1] = "FIRST";
-    /**
-     * Close when last input/output is done / removed.
-     */
-    CloseMode[CloseMode["LAST"] = 2] = "LAST";
-})(CloseMode || (CloseMode = {}));
+var State = /* @__PURE__ */ ((State2) => {
+  State2[State2["IDLE"] = 0] = "IDLE";
+  State2[State2["ACTIVE"] = 1] = "ACTIVE";
+  State2[State2["DONE"] = 2] = "DONE";
+  State2[State2["UNSUBSCRIBED"] = 3] = "UNSUBSCRIBED";
+  State2[State2["ERROR"] = 4] = "ERROR";
+  return State2;
+})(State || {});
+var CloseMode = /* @__PURE__ */ ((CloseMode2) => {
+  CloseMode2[CloseMode2["NEVER"] = 0] = "NEVER";
+  CloseMode2[CloseMode2["FIRST"] = 1] = "FIRST";
+  CloseMode2[CloseMode2["LAST"] = 2] = "LAST";
+  return CloseMode2;
+})(CloseMode || {});
+export {
+  CloseMode,
+  State
+};

package/asidechain.js

@@ -1,22 +1,21 @@
 import { Subscription } from "./subscription.js";
-/**
- * Abstract base class for sidechained subscription types (e.g.
- * {@link sidechainPartition}, {@link sidechainToggle}).
- */
-export class ASidechain extends Subscription {
-    sideSub;
-    constructor(opts) {
-        super(undefined, opts);
-    }
-    unsubscribe(sub) {
-        const res = super.unsubscribe(sub);
-        if (!sub || !this.subs.length) {
-            this.sideSub.unsubscribe();
-        }
-        return res;
-    }
-    done() {
-        this.sideSub.unsubscribe();
-        super.done();
+class ASidechain extends Subscription {
+  sideSub;
+  constructor(opts) {
+    super(void 0, opts);
+  }
+  unsubscribe(sub) {
+    const res = super.unsubscribe(sub);
+    if (!sub || !this.subs.length) {
+      this.sideSub.unsubscribe();
     }
+    return res;
+  }
+  done() {
+    this.sideSub.unsubscribe();
+    super.done();
+  }
 }
+export {
+  ASidechain
+};

package/atom.js

@@ -1,50 +1,21 @@
 import { __optsWithID } from "./idgen.js";
 import { stream } from "./stream.js";
-/**
- * Yields {@link Stream} of value changes in given [Atom-like state
- * container](https://thi.ng/atom).
- *
- * @remarks
- * [Attaches a
- * watch](https://docs.thi.ng/umbrella/api/interfaces/IWatch.html#addWatch) to
- * the atom and checks for value changes with given `changed` predicate (`!==`
- * by default). If the predicate returns truthy result, the new value is emitted
- * on the stream. If `emitFirst` is true (default), also emits atom's current
- * value when first subscriber attaches to stream.
- *
- * Also see {@link fromView}, {@link fromViewUnsafe}
- *
- * @example
- * ```ts
- * db = new Atom({ a: 23, b: 88 });
- * cursor = new Cursor(db, "a")
- *
- * rs.fromAtom(cursor).subscribe(rs.trace("cursor val:"))
- * // cursor val: 23
- *
- * cursor.reset(42);
- * // cursor val: 42
- *
- * db.reset({a: 66})
- * // cursor val: 66
- * ```
- *
- * @param atom -
- * @param opts -
- */
-export const fromAtom = (atom, opts) => {
-    opts = __optsWithID("atom", {
-        emitFirst: true,
-        changed: (a, b) => a !== b,
-        ...opts,
+const fromAtom = (atom, opts) => {
+  opts = __optsWithID("atom", {
+    emitFirst: true,
+    changed: (a, b) => a !== b,
+    ...opts
+  });
+  return stream((stream2) => {
+    atom.addWatch(stream2.id, (_, prev, curr) => {
+      if (opts.changed(prev, curr)) {
+        stream2.next(curr);
+      }
     });
-    return stream((stream) => {
-        atom.addWatch(stream.id, (_, prev, curr) => {
-            if (opts.changed(prev, curr)) {
-                stream.next(curr);
-            }
-        });
-        opts.emitFirst && stream.next(atom.deref());
-        return () => atom.removeWatch(stream.id);
-    }, opts);
+    opts.emitFirst && stream2.next(atom.deref());
+    return () => atom.removeWatch(stream2.id);
+  }, opts);
+};
+export {
+  fromAtom
 };

package/bisect.js

@@ -1,52 +1,11 @@
 import { __nextID } from "./idgen.js";
 import { PubSub } from "./pubsub.js";
-/**
- * Returns a {@link PubSub} using given predicate `pred` as boolean
- * {@link PubSubOpts.topic | topic function} and `truthy` & `falsey` as
- * subscribers for their respective values.
- *
- * @remarks
- * If `a` or `b` need to be subscribed to directly, then `a` / `b` MUST
- * be first created as `Subscription` (if not already) and a reference
- * kept prior to calling `bisect()`.
- *
- * @example
- * ```ts
- * fromIterable([1, 2, 3, 4]).subscribe(
- *   bisect(
- *     (x) => !!(x & 1),
- *     trace("odd"),
- *     trace("even")
- *   )
- * );
- * // odd 1
- * // even 2
- * // odd 3
- * // even 4
- * // odd done
- * // even done
- * ```
- *
- * @example
- * ```ts
- * const odd = subscription();
- * const even = subscription();
- * odd.subscribe(trace("odd"));
- * odd.subscribe(trace("odd x10"), map((x) => x * 10));
- * even.subscribe(trace("even"));
- *
- * fromIterable([1, 2, 3, 4]).subscribe(
- *     bisect((x) => !!(x & 1), odd, even)
- * );
- * ```
- *
- * @param pred - predicate function
- * @param truthy - subscription for truthy branch
- * @param falsy - subscription for falsy branch
- */
-export const bisect = (pred, truthy, falsy) => {
-    const sub = new PubSub({ topic: pred, id: `bisect-${__nextID()}` });
-    truthy && sub.subscribeTopic(true, truthy);
-    falsy && sub.subscribeTopic(false, falsy);
-    return sub;
+const bisect = (pred, truthy, falsy) => {
+  const sub = new PubSub({ topic: pred, id: `bisect-${__nextID()}` });
+  truthy && sub.subscribeTopic(true, truthy);
+  falsy && sub.subscribeTopic(false, falsy);
+  return sub;
+};
+export {
+  bisect
 };

package/checks.js

@@ -1,9 +1,8 @@
 import { implementsFunction } from "@thi.ng/checks/implements-function";
 import { CloseMode } from "./api.js";
-export const isSubscribable = (x) => implementsFunction(x, "subscribe");
-/**
- * Returns true if mode is FIRST, or if mode is LAST *and* `num = 0`.
- *
- * @internal
- */
-export const isFirstOrLastInput = (mode, num) => mode === CloseMode.FIRST || (mode === CloseMode.LAST && !num);
+const isSubscribable = (x) => implementsFunction(x, "subscribe");
+const isFirstOrLastInput = (mode, num) => mode === CloseMode.FIRST || mode === CloseMode.LAST && !num;
+export {
+  isFirstOrLastInput,
+  isSubscribable
+};

package/debounce.js

@@ -1,21 +1,13 @@
 import { __optsWithID } from "./idgen.js";
 import { fromIterable } from "./iterable.js";
 import { metaStream } from "./metastream.js";
-/**
- * Returns a subscription which buffers any intermediate inputs arriving faster
- * than given `delay` time period, then emits last received value after `delay`
- * milliseconds.
- *
- * @example
- * ```ts
- * const src = fromIterable([1, 2, 3], { delay: 10 })
- * src.subscribe(debounce(20)).subscribe({ next: console.log });
- * // 3
- * ```
- *
- * @param delay -
- */
-export const debounce = (delay, opts) => metaStream((x) => fromIterable([x], { delay }), __optsWithID("debounce", {
+const debounce = (delay, opts) => metaStream(
+  (x) => fromIterable([x], { delay }),
+  __optsWithID("debounce", {
     emitLast: true,
-    ...opts,
-}));
+    ...opts
+  })
+);
+export {
+  debounce
+};

package/defworker.js

@@ -1,7 +1,9 @@
 import { isFunction } from "@thi.ng/checks/is-function";
-export const defInlineWorker = (src) => defWorker(new Blob([src], { type: "text/javascript" }));
-export const defWorker = (worker) => worker instanceof Worker
-    ? worker
-    : isFunction(worker)
-        ? worker()
-        : new Worker(worker instanceof Blob ? URL.createObjectURL(worker) : worker);
+const defInlineWorker = (src) => defWorker(new Blob([src], { type: "text/javascript" }));
+const defWorker = (worker) => worker instanceof Worker ? worker : isFunction(worker) ? worker() : new Worker(
+  worker instanceof Blob ? URL.createObjectURL(worker) : worker
+);
+export {
+  defInlineWorker,
+  defWorker
+};

package/event.js

@@ -1,41 +1,16 @@
 import { __optsWithID } from "./idgen.js";
 import { stream, Stream } from "./stream.js";
-/**
- * Creates a {@link Stream} of events attached to given element / event
- * target and using given event listener options (same as supported by
- * `addEventListener()`, default: false).
- *
- * @param src - event target
- * @param name - event name
- * @param listenerOpts - listener opts
- * @param streamOpts - stream opts
- */
-export const fromEvent = (src, name, listenerOpts = false, streamOpts) => {
-    const result = stream((stream) => {
-        let listener = (e) => stream.next(e);
-        src.addEventListener(name, listener, listenerOpts);
-        return () => src.removeEventListener(name, listener, listenerOpts);
-    }, __optsWithID(`event-${name}`, streamOpts));
-    streamOpts?.init !== undefined && result.next(streamOpts.init);
-    return result;
+const fromEvent = (src, name, listenerOpts = false, streamOpts) => {
+  const result = stream((stream2) => {
+    let listener = (e) => stream2.next(e);
+    src.addEventListener(name, listener, listenerOpts);
+    return () => src.removeEventListener(name, listener, listenerOpts);
+  }, __optsWithID(`event-${name}`, streamOpts));
+  streamOpts?.init !== void 0 && result.next(streamOpts.init);
+  return result;
+};
+const fromDOMEvent = (src, name, listenerOpts = false, streamOpts) => fromEvent(src, name, listenerOpts, streamOpts);
+export {
+  fromDOMEvent,
+  fromEvent
 };
-/**
- * Same as {@link fromEvent}, however only supports well-known DOM event
- * names. Returned stream instance will use corresponding concrete event
- * type in its type signature, whereas {@link fromEvent} will only use the
- * generic `Event`.
- *
- * @example
- * ```ts
- * fromDOMEvent(document.body, "mousemove"); // Stream<MouseEvent>
- * fromEvent(document.body, "mousemove"); // Stream<Event>
- * ```
- *
- * Also see: {@link fromEvent}
- *
- * @param src -
- * @param name -
- * @param listenerOpts -
- * @param streamOpts -
- */
-export const fromDOMEvent = (src, name, listenerOpts = false, streamOpts) => fromEvent(src, name, listenerOpts, streamOpts);

package/forkjoin.js

@@ -6,109 +6,43 @@ import { range } from "@thi.ng/transducers/range";
 import { transduce } from "@thi.ng/transducers/transduce";
 import { sync } from "./sync.js";
 import { tunnel } from "./tunnel.js";
-/**
- * Returns a {@link StreamSync} instance which creates & attaches
- * multiple subscriptions to given `src` input stream, processes each
- * received value in parallel via web workers, then recombines partial
- * results and passes the resulting transformed value downstream.
- *
- * @remarks
- * See {@link ForkJoinOpts} for further details & behavior options and
- * the {@link forkBuffer} and {@link joinBuffer} helpers for array-based
- * value processing (most likely use case).
- *
- * @param src - input stream
- * @param opts -
- */
-export const forkJoin = (opts) => {
-    const numWorkers = opts.numWorkers || navigator.hardwareConcurrency || 4;
-    const workerIDs = range(numWorkers);
-    return sync({
-        src: transduce(map((id) => [
-            String(id),
-            opts.src
-                .transform(map((x) => opts.fork(id, numWorkers, x)))
-                .subscribe(tunnel({
-                src: opts.worker,
-                transferables: opts.transferables,
-                interrupt: opts.interrupt === true,
-                terminate: opts.terminate,
-                id: String(id),
-            })),
-        ]), assocObj(), workerIDs),
-        xform: comp(
-        // form result tuple in original order
-        map((results) => [...map((id) => results[id], workerIDs)]), 
-        // apply user join function
-        map(opts.join)),
-        reset: true,
-        backPressure: opts.backPressure,
-    });
+const forkJoin = (opts) => {
+  const numWorkers = opts.numWorkers || navigator.hardwareConcurrency || 4;
+  const workerIDs = range(numWorkers);
+  return sync({
+    src: transduce(
+      map((id) => [
+        String(id),
+        opts.src.transform(map((x) => opts.fork(id, numWorkers, x))).subscribe(
+          tunnel({
+            src: opts.worker,
+            transferables: opts.transferables,
+            interrupt: opts.interrupt === true,
+            terminate: opts.terminate,
+            id: String(id)
+          })
+        )
+      ]),
+      assocObj(),
+      workerIDs
+    ),
+    xform: comp(
+      // form result tuple in original order
+      map((results) => [...map((id) => results[id], workerIDs)]),
+      // apply user join function
+      map(opts.join)
+    ),
+    reset: true,
+    backPressure: opts.backPressure
+  });
 };
-/**
- * Higher-order fork function for scenarios involving the split-parallel
- * processing of a large buffer.
- *
- * @remarks
- * The returned function is meant to be used as `fork` function in a
- * {@link ForkJoinOpts} config and extracts a workload slice of the
- * original buffer for a single worker. The HOF itself takes a minimum
- * chunk size as optional parameter (default: 1).
- *
- * **Note:** Depending on the configured `minChunkSize` and the size of
- * the input buffer to be partitioned, the returned fork function might
- * produce empty sub-arrays for some workers, iff the configured number
- * of workers exceeds the resulting number of chunks / input values.
- * E.g. If the number of workers = 8, buffer size = 10 and min chunk
- * size = 2, then the last 3 (i.e. 8 - 10 / 2) workers will only receive
- * empty workloads.
- *
- * More generally, if the input buffer size is not equally distributable
- * over the given number of workers, the last worker(s) might receive a
- * larger, smaller or empty chunk.
- *
- * Also see {@link forkJoin} and {@link joinBuffer}.
- *
- * @example
- * ```ts
- * forkJoin<number[], number[], number[], number[]>({
- *     src,
- *     // job definition / split buffer into chunks (min size 256 values)
- *     fork: forkBuffer(256),
- *     // re-join partial results
- *     join: joinBuffer(),
- *     worker: "./worker.js",
- * })
- * ```
- *
- * @param minChunkSize -
- */
-export const forkBuffer = (minChunkSize = 1) => (id, numWorkers, buf) => {
-    const chunkSize = Math.max(minChunkSize, (buf.length / numWorkers) | 0);
-    return id < numWorkers - 1
-        ? buf.slice(id * chunkSize, (id + 1) * chunkSize)
-        : buf.slice(id * chunkSize);
+const forkBuffer = (minChunkSize = 1) => (id, numWorkers, buf) => {
+  const chunkSize = Math.max(minChunkSize, buf.length / numWorkers | 0);
+  return id < numWorkers - 1 ? buf.slice(id * chunkSize, (id + 1) * chunkSize) : buf.slice(id * chunkSize);
+};
+const joinBuffer = (fn) => fn ? (parts) => [...mapcat(fn, parts)] : (parts) => Array.prototype.concat.apply([], parts);
+export {
+  forkBuffer,
+  forkJoin,
+  joinBuffer
 };
-/**
- * Higher-order join function for scenarios involving the split-parallel
- * processing of a large buffer.
- *
- * @remarks
- * The returned function is meant to be used as `join` function in a
- * {@link ForkJoinOpts} config, receives the processed result chunks
- * from all workers (ordered by worker ID) and concatenates them back
- * into a single result array.
- *
- * The optional `fn` arg can be used to pick the actual result chunk
- * from each worker result. This is useful if the worker result type is
- * not an array and includes other data points (e.g. execution metrics
- * etc.). If `fn` is not given, it defaults to the identity function
- * (i.e. each worker's result is assumed to be an array).
- *
- * Also see {@link forkJoin} and {@link forkBuffer}.
- *
- * @param fn -
- */
-export const joinBuffer = (fn) => fn
-    ? (parts) => [...mapcat(fn, parts)]
-    : (parts) => Array.prototype.concat.apply([], parts);

package/idgen.js

@@ -1,9 +1,7 @@
 let NEXT_ID = 0;
-export const __nextID = () => NEXT_ID++;
-/**
- * @param prefix -
- * @param opts -
- *
- * @internal
- */
-export const __optsWithID = (prefix, opts) => ((!opts || !opts.id ? { ...opts, id: prefix + "-" + __nextID() } : opts));
+const __nextID = () => NEXT_ID++;
+const __optsWithID = (prefix, opts) => !opts || !opts.id ? { ...opts, id: prefix + "-" + __nextID() } : opts;
+export {
+  __nextID,
+  __optsWithID
+};

package/internal/remove.js

@@ -1,7 +1,10 @@
-export const __removeAllIDs = (impl, ids) => {
-    let ok = true;
-    for (let id of ids) {
-        ok = impl.removeID(id) && ok;
-    }
-    return ok;
+const __removeAllIDs = (impl, ids) => {
+  let ok = true;
+  for (let id of ids) {
+    ok = impl.removeID(id) && ok;
+  }
+  return ok;
+};
+export {
+  __removeAllIDs
 };

package/interval.js

@@ -1,33 +1,25 @@
 import { CloseMode } from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { stream } from "./stream.js";
-/**
- * Returns a {@link Stream} of monotonically increasing counter values,
- * emitted at given `delay` interval and up to the optionally defined
- * max value (default: ∞), after which the stream is closed.
- *
- * @remarks
- * The stream only starts when the first subscriber becomes available.
- *
- * @param delay -
- * @param opts -
- */
-export const fromInterval = (delay, opts) => {
-    opts = __optsWithID("interval", {
-        num: Infinity,
-        ...opts,
-    });
-    return stream((stream) => {
-        let i = 0;
-        let count = opts.num;
-        stream.next(i++);
-        let id = setInterval(() => {
-            stream.next(i++);
-            if (--count <= 0) {
-                clearInterval(id);
-                stream.closeIn !== CloseMode.NEVER && stream.done();
-            }
-        }, delay);
-        return () => clearInterval(id);
-    }, opts);
+const fromInterval = (delay, opts) => {
+  opts = __optsWithID("interval", {
+    num: Infinity,
+    ...opts
+  });
+  return stream((stream2) => {
+    let i = 0;
+    let count = opts.num;
+    stream2.next(i++);
+    let id = setInterval(() => {
+      stream2.next(i++);
+      if (--count <= 0) {
+        clearInterval(id);
+        stream2.closeIn !== CloseMode.NEVER && stream2.done();
+      }
+    }, delay);
+    return () => clearInterval(id);
+  }, opts);
+};
+export {
+  fromInterval
 };

package/iterable.js

@@ -1,48 +1,26 @@
 import { CloseMode } from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { stream } from "./stream.js";
-/**
- * Returns a {@link Stream} of values from provided iterable, emitted at
- * the given `delay` interval.
- *
- * @remarks
- * Asynchronously starts pulling values from source iterable when the
- * first subscriber becomes available. The values are processed &
- * emitted via `setInterval()`, using the given `delay` value (default:
- * 0). By default, once the iterable is exhausted (if finite), calls
- * {@link ISubscriber.done} to close the stream, but this can be
- * re-configured via provided {@link CommonOpts | options}.
- *
- * @param src -
- * @param opts -
- */
-export const fromIterable = (src, opts = {}) => stream((stream) => {
-    const iter = src[Symbol.iterator]();
-    const id = setInterval(() => {
-        let val;
-        if ((val = iter.next()).done) {
-            clearInterval(id);
-            stream.closeIn !== CloseMode.NEVER && stream.done();
-        }
-        else {
-            stream.next(val.value);
-        }
-    }, opts.delay || 0);
-    return () => clearInterval(id);
-}, __optsWithID("iterable", opts));
-/**
- * Creates a new {@link Stream} of given iterable which synchronously calls
- * {@link ISubscriber.next} for each item of the iterable when the first (and in
- * this case the only one) subscriber becomes available. Once the iterable is
- * exhausted (MUST be finite!), then calls {@link ISubscriber.done} by default,
- * but can be avoided by passing `false` as last argument.
- *
- * @param src -
- * @param opts -
- */
-export const fromIterableSync = (src, opts) => stream((stream) => {
-    for (let s of src) {
-        stream.next(s);
+const fromIterable = (src, opts = {}) => stream((stream2) => {
+  const iter = src[Symbol.iterator]();
+  const id = setInterval(() => {
+    let val;
+    if ((val = iter.next()).done) {
+      clearInterval(id);
+      stream2.closeIn !== CloseMode.NEVER && stream2.done();
+    } else {
+      stream2.next(val.value);
     }
-    stream.closeIn !== CloseMode.NEVER && stream.done();
+  }, opts.delay || 0);
+  return () => clearInterval(id);
+}, __optsWithID("iterable", opts));
+const fromIterableSync = (src, opts) => stream((stream2) => {
+  for (let s of src) {
+    stream2.next(s);
+  }
+  stream2.closeIn !== CloseMode.NEVER && stream2.done();
 }, __optsWithID("iterable-sync", opts));
+export {
+  fromIterable,
+  fromIterableSync
+};