@thi.ng/rstream 8.2.13 → 8.2.15

package/tunnel.js

@@ -3,68 +3,61 @@ import { __nextID } from "./idgen.js";
 import { LOGGER } from "./logger.js";
 import { Subscription } from "./subscription.js";
 import { defWorker } from "./defworker.js";
-/**
- * Returns a {@link Subscription} which processes received values via
- * the configured worker(s) and then passes values received back from
- * the worker(s) downstream, thereby allowing workers to be used
- * transparently for stream processing.
- *
- * @remarks
- * Multiple worker instances are supported for concurrent processing.
- * See the {@link TunnelOpts} for details.
- *
- * Also see {@link forkJoin} and {@link postWorker}.
- *
- * @param opts -
- */
-export const tunnel = (opts) => new Tunnel(opts);
-/**
- * @see {@link tunnel} for reference & examples.
- */
-export class Tunnel extends Subscription {
-    workers;
-    src;
-    transferables;
-    terminate;
-    interrupt;
-    index;
-    constructor(opts) {
-        super(undefined, { id: opts.id || `tunnel-${__nextID()}` });
-        this.src = opts.src;
-        this.workers = new Array(opts.maxWorkers || 1);
-        this.transferables = opts.transferables;
-        this.terminate = opts.terminate || 1000;
-        this.interrupt = opts.interrupt || false;
-        this.index = 0;
+const tunnel = (opts) => new Tunnel(opts);
+class Tunnel extends Subscription {
+  workers;
+  src;
+  transferables;
+  terminate;
+  interrupt;
+  index;
+  constructor(opts) {
+    super(void 0, { id: opts.id || `tunnel-${__nextID()}` });
+    this.src = opts.src;
+    this.workers = new Array(opts.maxWorkers || 1);
+    this.transferables = opts.transferables;
+    this.terminate = opts.terminate || 1e3;
+    this.interrupt = opts.interrupt || false;
+    this.index = 0;
+  }
+  next(x) {
+    if (this.state < State.DONE) {
+      let tx;
+      if (this.transferables) {
+        tx = this.transferables(x);
+      }
+      let worker = this.workers[this.index];
+      if (this.interrupt && worker) {
+        worker.terminate();
+        worker = null;
+      }
+      if (!worker) {
+        this.workers[this.index++] = worker = defWorker(this.src);
+        this.index %= this.workers.length;
+        worker.addEventListener(
+          "message",
+          (e) => this.dispatch(e.data)
+        );
+        worker.addEventListener(
+          "error",
+          (e) => this.error(e)
+        );
+      }
+      worker.postMessage(x, tx || []);
     }
-    next(x) {
-        if (this.state < State.DONE) {
-            let tx;
-            if (this.transferables) {
-                tx = this.transferables(x);
-            }
-            let worker = this.workers[this.index];
-            if (this.interrupt && worker) {
-                worker.terminate();
-                worker = null;
-            }
-            if (!worker) {
-                this.workers[this.index++] = worker = defWorker(this.src);
-                this.index %= this.workers.length;
-                worker.addEventListener("message", (e) => this.dispatch(e.data));
-                worker.addEventListener("error", (e) => this.error(e));
-            }
-            worker.postMessage(x, tx || []);
-        }
-    }
-    done() {
-        super.done();
-        if (this.terminate > 0) {
-            setTimeout(() => {
-                LOGGER.info("terminating workers...");
-                this.workers.forEach((worker) => worker && worker.terminate());
-                delete this.workers;
-            }, this.terminate);
-        }
+  }
+  done() {
+    super.done();
+    if (this.terminate > 0) {
+      setTimeout(() => {
+        LOGGER.info("terminating workers...");
+        this.workers.forEach((worker) => worker && worker.terminate());
+        delete this.workers;
+      }, this.terminate);
     }
+  }
 }
+export {
+  Tunnel,
+  tunnel
+};

package/tween.js

@@ -6,79 +6,29 @@ import { CloseMode } from "./api.js";
 import { fromInterval } from "./interval.js";
 import { fromRAF } from "./raf.js";
 import { sync } from "./sync.js";
-/**
- * Takes an existing stream/subscription `src` and attaches new
- * subscription which interpolates between incoming values from `src`
- * using the given `mix` function.
- *
- * @remarks
- * The returned construct produces values at a rate controlled by the
- * `clock` stream or frequency. If omitted, `clock` defaults to
- * {@link fromRAF} (~60Hz). If the `clock` is given as number, creates a
- * {@link fromInterval} or else uses the given `clock` stream directly.
- * In general, the frequency of the `clock` should always be higher than
- * that of `src` or else interpolation will have undefined behavior.
- *
- * If `stop` is given as well, no values will be passed downstream if
- * that function returns true. This can be used to limit traffic once
- * the tween target value has been reached.
- *
- * The returned subscription closes automatically when either `src` or
- * `clock` are exhausted.
- *
- * @example
- * ```ts
- * val = stream();
- *
- * tween(
- *   // consume from `val` stream
- *   val,
- *   // initial start value to interpolate from
- *   0,
- *   // interpolation fn (LERP)
- *   (a, b) => a + (b - a) * 0.5,
- *   // stop emitting values if difference to previous result < 0.01
- *   (a, b) => Math.abs(a - b) < 0.01
- * ).subscribe(trace("tweened"))
- *
- * a.next(10)
- * // 5
- * // 7.5
- * // ...
- * // 9.98046875
- *
- * a.next(100)
- * // 55
- * // 77.5
- * // ...
- * // 99.989013671875
- * ```
- *
- * @param src -
- * @param initial -
- * @param mix -
- * @param stop -
- * @param clock -
- */
-export const tween = (src, initial, mix, stop, clock) => sync({
-    src: {
-        src,
-        _: clock == null
-            ? fromRAF()
-            : isNumber(clock)
-                ? fromInterval(clock)
-                : clock,
-    },
-    closeIn: CloseMode.FIRST,
-}).transform(scan(reducer(() => initial, (acc, { src }) => mix(acc, src))), dedupe(stop || (() => false)));
-/**
- * Convenience version of {@link tween} for its most common use case, tweening
- * of numeric streams.
- *
- * @param src -
- * @param init -
- * @param speed -
- * @param eps -
- * @param clock -
- */
-export const tweenNumber = (src, init = 0, speed = 0.05, eps = 1e-3, clock) => tween(src, init, (a, b) => a + (b - a) * speed, (a, b) => Math.abs(a - b) < eps, clock);
+const tween = (src, initial, mix, stop, clock) => sync({
+  src: {
+    src,
+    _: clock == null ? fromRAF() : isNumber(clock) ? fromInterval(clock) : clock
+  },
+  closeIn: CloseMode.FIRST
+}).transform(
+  scan(
+    reducer(
+      () => initial,
+      (acc, { src: src2 }) => mix(acc, src2)
+    )
+  ),
+  dedupe(stop || (() => false))
+);
+const tweenNumber = (src, init = 0, speed = 0.05, eps = 1e-3, clock) => tween(
+  src,
+  init,
+  (a, b) => a + (b - a) * speed,
+  (a, b) => Math.abs(a - b) < eps,
+  clock
+);
+export {
+  tween,
+  tweenNumber
+};

package/view.js

@@ -1,47 +1,26 @@
 import { View } from "@thi.ng/atom/view";
 import { __optsWithID } from "./idgen.js";
 import { Stream } from "./stream.js";
-/**
- * Unchecked version of {@link fromView}. Paths can be given as string
- * or tuple.
-
- * @example
- * ```ts
- * const db = defAtom<any>({ a: 1, b: { c: 2 }});
- *
- * // create stream of `c` value changes
- * fromViewUnsafe(
- *   db,
- *   {
- *     path: "b.c",
- *     tx: (x) => x != null ? String(x) : "n/a"
- *   }
- * ).subscribe(trace("view:"))
- * // view: 2
- *
- * // update `c` in state
- * db.swapInUnsafe("b.c", (x: number) => x + 1);
- * // view: 3
- *
- * db.reset({ a: 10 });
- * // view: n/a
- * ```
- *
- * @param atom -
- * @param opts -
- */
-export const fromViewUnsafe = (atom, opts) => fromView(atom, opts);
-export function fromView(atom, opts) {
-    opts = __optsWithID("view", opts);
-    return new Stream((stream) => {
-        let isActive = true;
-        const tx = opts.tx;
-        const view = new View(atom, opts.path, tx
-            ? (x) => isActive && ((x = tx(x)), stream.next(x), x)
-            : (x) => isActive && (stream.next(x), x), false, opts.equiv);
-        return () => {
-            isActive = false;
-            view.release();
-        };
-    }, opts);
+const fromViewUnsafe = (atom, opts) => fromView(atom, opts);
+function fromView(atom, opts) {
+  opts = __optsWithID("view", opts);
+  return new Stream((stream) => {
+    let isActive = true;
+    const tx = opts.tx;
+    const view = new View(
+      atom,
+      opts.path,
+      tx ? (x) => isActive && (x = tx(x), stream.next(x), x) : (x) => isActive && (stream.next(x), x),
+      false,
+      opts.equiv
+    );
+    return () => {
+      isActive = false;
+      view.release();
+    };
+  }, opts);
 }
+export {
+  fromView,
+  fromViewUnsafe
+};

package/worker.js

@@ -2,48 +2,28 @@ import { defWorker } from "./defworker.js";
 import { __optsWithID } from "./idgen.js";
 import { LOGGER } from "./logger.js";
 import { stream } from "./stream.js";
-/**
- * Returns a {@link Stream} which adds `message` and `error` event
- * listeners to given `worker` and then emits received values.
- *
- * @remarks
- * If `terminate` is true (default), the worker will be terminated when
- * the stream is being closed (either directly or indirectly, i.e. if
- * the user called {@link ISubscriber.done} on the stream or the last
- * child subscription has unsubscribed, depending on
- * {@link CommonOpts | config options}).
- *
- * As with {@link postWorker}, the `worker` can be an existing `Worker`
- * instance, a JS source code `Blob` or an URL string. In the latter two
- * cases, a worker is created automatically.
- *
- * @example
- * ```ts
- *
- * ```
- *
- * @param worker -
- * @param opts -
- */
-export const fromWorker = (worker, opts) => {
-    const _worker = defWorker(worker);
-    opts = __optsWithID("worker", opts);
-    return stream((stream) => {
-        const msgListener = (e) => {
-            stream.next(e.data);
-        };
-        const errListener = (e) => {
-            stream.error(e.data);
-        };
-        _worker.addEventListener("message", msgListener);
-        _worker.addEventListener("error", errListener);
-        return () => {
-            _worker.removeEventListener("message", msgListener);
-            _worker.removeEventListener("error", errListener);
-            if (opts.terminate !== false) {
-                LOGGER.info("terminating worker", _worker);
-                _worker.terminate();
-            }
-        };
-    }, opts);
+const fromWorker = (worker, opts) => {
+  const _worker = defWorker(worker);
+  opts = __optsWithID("worker", opts);
+  return stream((stream2) => {
+    const msgListener = (e) => {
+      stream2.next(e.data);
+    };
+    const errListener = (e) => {
+      stream2.error(e.data);
+    };
+    _worker.addEventListener("message", msgListener);
+    _worker.addEventListener("error", errListener);
+    return () => {
+      _worker.removeEventListener("message", msgListener);
+      _worker.removeEventListener("error", errListener);
+      if (opts.terminate !== false) {
+        LOGGER.info("terminating worker", _worker);
+        _worker.terminate();
+      }
+    };
+  }, opts);
+};
+export {
+  fromWorker
 };