@thi.ng/rstream 8.2.12 → 8.2.14

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
+};

package/logger.js

@@ -1,3 +1,7 @@
 import { NULL_LOGGER } from "@thi.ng/logger/null";
-export let LOGGER = NULL_LOGGER;
-export const setLogger = (logger) => (LOGGER = logger);
+let LOGGER = NULL_LOGGER;
+const setLogger = (logger) => LOGGER = logger;
+export {
+  LOGGER,
+  setLogger
+};

package/merge.js

@@ -1,127 +1,81 @@
-import { State, } from "./api.js";
+import {
+  State
+} from "./api.js";
 import { isFirstOrLastInput } from "./checks.js";
 import { __optsWithID } from "./idgen.js";
 import { __removeAllIDs } from "./internal/remove.js";
 import { Subscription } from "./subscription.js";
-/**
- * Returns a new {@link StreamMerge} subscription, consuming values from
- * multiple inputs and passing received values on to any subscribers.
- *
- * @remarks
- * Input streams can be added and removed dynamically. By default, `StreamMerge`
- * calls {@link ISubscriber.done} when the last active input is done, but this
- * behavior can be overridden via the provided
- * {@link StreamMergeOpts | options}.
- *
- * @example
- * ```ts
- * merge({
- *     // input streams w/ different frequencies
- *     src: [
- *         fromIterable([1, 2, 3], { delay: 10 }),
- *         fromIterable([10, 20, 30], { delay: 21 }),
- *         fromIterable([100, 200, 300], { delay: 7 })
- *     ]
- * }).subscribe(trace());
- * // 100
- * // 1
- * // 200
- * // 10
- * // 2
- * // 300
- * // 3
- * // 20
- * // 30
- * ```
- *
- * @example
- * Use the
- * [`labeled()`](https://docs.thi.ng/umbrella/transducers/functions/labeled.html)
- * transducer for each input to create a stream of labeled values and
- * track their provenance:
- *
- * @example
- * ```ts
- * merge({
- *     src: [
- *         fromIterable([1, 2, 3]).transform(tx.labeled("a")),
- *         fromIterable([10, 20, 30]).transform(tx.labeled("b")),
- *     ]
- * }).subscribe(trace());
- * // ["a", 1]
- * // ["b", 10]
- * // ["a", 2]
- * // ["b", 20]
- * // ["a", 3]
- * // ["b", 30]
- * ```
- *
- * @param opts -
- */
-export const merge = (opts) => new StreamMerge(opts);
-/**
- * @see {@link merge} for reference & examples.
- */
-export class StreamMerge extends Subscription {
-    sources;
-    constructor(opts) {
-        opts = opts || {};
-        super(undefined, __optsWithID("streammerge", opts));
-        this.sources = new Map();
-        opts.src && this.addAll(opts.src);
+const merge = (opts) => new StreamMerge(opts);
+class StreamMerge extends Subscription {
+  sources;
+  constructor(opts) {
+    opts = opts || {};
+    super(void 0, __optsWithID("streammerge", opts));
+    this.sources = /* @__PURE__ */ new Map();
+    opts.src && this.addAll(opts.src);
+  }
+  add(src) {
+    this.ensureState();
+    this.sources.set(
+      src,
+      src.subscribe(
+        {
+          next: (x) => x instanceof Subscription ? this.add(x) : this.next(x),
+          done: () => this.markDone(src),
+          __owner: this
+        },
+        { id: `in-${src.id}` }
+      )
+    );
+  }
+  addAll(src) {
+    for (let s of src) {
+      this.add(s);
     }
-    add(src) {
-        this.ensureState();
-        this.sources.set(src, src.subscribe({
-            next: (x) => x instanceof Subscription ? this.add(x) : this.next(x),
-            done: () => this.markDone(src),
-            __owner: this,
-        }, { id: `in-${src.id}` }));
+  }
+  remove(src) {
+    const sub = this.sources.get(src);
+    if (sub) {
+      this.sources.delete(src);
+      sub.unsubscribe();
+      return true;
     }
-    addAll(src) {
-        for (let s of src) {
-            this.add(s);
-        }
+    return false;
+  }
+  removeID(id) {
+    for (let s of this.sources) {
+      if (s[0].id === id) {
+        return this.remove(s[0]);
+      }
     }
-    remove(src) {
-        const sub = this.sources.get(src);
-        if (sub) {
-            this.sources.delete(src);
-            sub.unsubscribe();
-            return true;
-        }
-        return false;
+    return false;
+  }
+  removeAll(src) {
+    let ok = true;
+    for (let s of src) {
+      ok = this.remove(s) && ok;
     }
-    removeID(id) {
-        for (let s of this.sources) {
-            if (s[0].id === id) {
-                return this.remove(s[0]);
-            }
-        }
-        return false;
-    }
-    removeAll(src) {
-        let ok = true;
-        for (let s of src) {
-            ok = this.remove(s) && ok;
-        }
-        return ok;
-    }
-    removeAllIDs(ids) {
-        return __removeAllIDs(this, ids);
-    }
-    unsubscribe(sub) {
-        if (!sub) {
-            for (let s of this.sources.values()) {
-                s.unsubscribe();
-            }
-            this.state = State.DONE;
-            this.sources.clear();
-        }
-        return super.unsubscribe(sub);
-    }
-    markDone(src) {
-        this.remove(src);
-        isFirstOrLastInput(this.closeIn, this.sources.size) && this.done();
+    return ok;
+  }
+  removeAllIDs(ids) {
+    return __removeAllIDs(this, ids);
+  }
+  unsubscribe(sub) {
+    if (!sub) {
+      for (let s of this.sources.values()) {
+        s.unsubscribe();
+      }
+      this.state = State.DONE;
+      this.sources.clear();
     }
+    return super.unsubscribe(sub);
+  }
+  markDone(src) {
+    this.remove(src);
+    isFirstOrLastInput(this.closeIn, this.sources.size) && this.done();
+  }
 }
+export {
+  StreamMerge,
+  merge
+};

package/metastream.js

@@ -1,151 +1,75 @@
 import { assert } from "@thi.ng/errors/assert";
-import { CloseMode, State, } from "./api.js";
+import {
+  CloseMode,
+  State
+} from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { Subscription } from "./subscription.js";
-/**
- * Returns a {@link Subscription} which transforms each incoming value into a
- * new {@link ISubscription}, subscribes to it (via an hidden / internal
- * subscription) and then only passes values from that stream to its own
- * subscribers.
- *
- * @remarks
- * If a new value is received, the metastream first unsubscribes from any still
- * active previous stream (if any), before creating and subscribing to the new
- * one. Hence this stream type is useful for cases where streams need to be
- * dynamically created & inserted into an existing dataflow topology.
- *
- * The user supplied `factory` function will be called for each incoming value
- * and is responsible for creating the new stream instances. If the function
- * returns null/undefined, no further action will be taken (acts like a filter
- * transducer).
- *
- * The factory function does NOT need to create *new* streams, but can merely
- * return other existing streams, and so making the meta stream act like a
- * switch with arbitrary criteria. However, if the meta stream itself is the
- * only subscriber to such existing input streams, you'll need to configure the
- * input's {@link CommonOpts.closeOut} option to keep them alive and support
- * dynamic switching between them.
- *
- * @example
- * ```ts
- * // transform each received odd number into a stream
- * // producing 3 copies of that number in the metastream
- * // even numbers are ignored
- * a = metastream(
- *   (x) => (x & 1)
- *     ? fromIterable(tx.repeat(x, 3), { delay: 100 })
- *     : null
- * );
- *
- * a.subscribe(trace())
- * a.next(23)
- *
- * // 23
- * // 23
- * // 23
- *
- * a.next(42) // ignored by factory fn
- *
- * a.next(43)
- * // 43
- * // 43
- * // 43
- * ```
- *
- * @example
- * ```ts
- * // infinite inputs
- * a = fromIterable(
- *   tx.repeat("a"),
- *   { delay: 1000, closeOut: CloseMode.NEVER }
- * );
- * b = fromIterable(
- *   tx.repeat("b"),
- *   { delay: 1000, closeOut: CloseMode.NEVER }
- * );
- *
- * // stream selector / switch
- * m = metaStream((x) => x ? a : b);
- * m.subscribe(trace("meta from: "));
- *
- * m.next(true);
- * // meta from: a
- *
- * m.next(false);
- * // meta from: b
- *
- * m.next(true);
- * // meta from: a
- * ```
- *
- * @param factory -
- * @param id -
- */
-export const metaStream = (factory, opts) => new MetaStream(factory, opts);
-/**
- * @see {@link metaStream} for reference & examples.
- */
-export class MetaStream extends Subscription {
-    factory;
-    stream;
-    sub;
-    emitLast;
-    doneRequested;
-    constructor(factory, opts = {}) {
-        super(undefined, __optsWithID("metastram", opts));
-        this.factory = factory;
-        this.emitLast = opts.emitLast === true;
-        this.doneRequested = false;
-    }
-    next(x) {
-        if (this.state < State.DONE) {
-            if (this.stream) {
-                this.stream.unsubscribe(this.sub);
-            }
-            let stream = this.factory(x);
-            if (stream) {
-                this.stream = stream;
-                this.sub = this.stream.subscribe({
-                    next: (x) => {
-                        stream === this.stream && super.dispatch(x);
-                        this.doneRequested && this.done();
-                    },
-                    done: () => {
-                        this.stream.unsubscribe(this.sub);
-                        if (stream === this.stream) {
-                            this.stream = undefined;
-                            this.sub = undefined;
-                        }
-                    },
-                    error: (e) => super.error(e),
-                    __owner: this,
-                });
+const metaStream = (factory, opts) => new MetaStream(factory, opts);
+class MetaStream extends Subscription {
+  factory;
+  stream;
+  sub;
+  emitLast;
+  doneRequested;
+  constructor(factory, opts = {}) {
+    super(void 0, __optsWithID("metastram", opts));
+    this.factory = factory;
+    this.emitLast = opts.emitLast === true;
+    this.doneRequested = false;
+  }
+  next(x) {
+    if (this.state < State.DONE) {
+      if (this.stream) {
+        this.stream.unsubscribe(this.sub);
+      }
+      let stream = this.factory(x);
+      if (stream) {
+        this.stream = stream;
+        this.sub = this.stream.subscribe({
+          next: (x2) => {
+            stream === this.stream && super.dispatch(x2);
+            this.doneRequested && this.done();
+          },
+          done: () => {
+            this.stream.unsubscribe(this.sub);
+            if (stream === this.stream) {
+              this.stream = void 0;
+              this.sub = void 0;
             }
-        }
+          },
+          error: (e) => super.error(e),
+          __owner: this
+        });
+      }
     }
-    done() {
-        if (this.emitLast && !this.doneRequested) {
-            this.doneRequested = true;
-        }
-        else {
-            if (this.stream) {
-                this.detach(true);
-            }
-            this.closeIn !== CloseMode.NEVER && super.done();
-        }
+  }
+  done() {
+    if (this.emitLast && !this.doneRequested) {
+      this.doneRequested = true;
+    } else {
+      if (this.stream) {
+        this.detach(true);
+      }
+      this.closeIn !== CloseMode.NEVER && super.done();
     }
-    unsubscribe(sub) {
-        if (this.stream && (!sub || this.subs.length === 1)) {
-            this.detach(!sub);
-        }
-        return super.unsubscribe(sub);
+  }
+  unsubscribe(sub) {
+    if (this.stream && (!sub || this.subs.length === 1)) {
+      this.detach(!sub);
     }
-    detach(force) {
-        if (force || this.closeOut !== CloseMode.NEVER) {
-            assert(!!this.stream, "input stream already removed");
-            this.stream.unsubscribe(this.sub);
-            delete this.stream;
-            delete this.sub;
-        }
+    return super.unsubscribe(sub);
+  }
+  detach(force) {
+    if (force || this.closeOut !== CloseMode.NEVER) {
+      assert(!!this.stream, "input stream already removed");
+      this.stream.unsubscribe(this.sub);
+      delete this.stream;
+      delete this.sub;
     }
+  }
 }
+export {
+  MetaStream,
+  metaStream
+};

package/nodejs.js

@@ -1,54 +1,14 @@
 import { rechunk } from "@thi.ng/transducers/rechunk";
 import { stream } from "./stream.js";
-/**
- * Adapter bridge from NodeJS streams. Creates and returns a new {@link stream}
- * of type `T` and pipes in data from `stdout` (also assumed to produce data of
- * type `T`). If given, also connects `stderr` to new rstream's error handler.
- * Unless `close` is false, the new stream closes once `stdout` is closed.
- *
- * @param stdout -
- * @param stderr -
- * @param close -
- */
-export const fromNodeJS = (stdout, stderr, close = true) => {
-    const ingest = stream();
-    stdout.on("data", (data) => ingest.next(data));
-    stderr && stderr.on("data", (data) => ingest.error(data));
-    close && stdout.on("close", () => ingest.done());
-    return ingest;
+const fromNodeJS = (stdout, stderr, close = true) => {
+  const ingest = stream();
+  stdout.on("data", (data) => ingest.next(data));
+  stderr && stderr.on("data", (data) => ingest.error(data));
+  close && stdout.on("close", () => ingest.done());
+  return ingest;
+};
+const linesFromNodeJS = (stdout, stderr, re, close) => fromNodeJS(stdout, stderr, close).transform(rechunk(re));
+export {
+  fromNodeJS,
+  linesFromNodeJS
 };
-/**
- * Specialized version of {@link fromNodeJS} for string inputs and automatic
- * rechunking/splitting of the input using the optionally provided regexp (line
- * breaks by default).
- *
- * @remarks
- * Internally uses https://docs.thi.ng/umbrella/transducers/functions/rechunk.html
- * to rechunk input.
- *
- * @example
- * ```ts
- * import { spawn } from "child_process"
- * import { linesFromNodeJS, trace } from "@thi.ng/rstream";
- *
- * const cmd = spawn("ls", ["-la"]);
- *
- * linesFromNodeJS<string>(cmd.stdout, cmd.stderr).subscribe(trace("output"));
- *
- * // output total 12760
- * // output drwxr-xr-x   37 foo  staff     1184 Nov 15 15:29 .
- * // output drwxr-xr-x  143 foo  staff     4576 Nov 11 21:08 ..
- * // output drwxr-xr-x   17 foo  staff      544 Nov 15 17:39 .git
- * // output -rw-r--r--    1 foo  staff      149 Aug  4 15:32 .gitattributes
- * // output drwxr-xr-x    5 foo  staff      160 Apr 12  2021 .github
- * // output -rw-r--r--    1 foo  staff      659 Sep 10 22:55 .gitignore
- * // ...
- * // output done
- * ```
- *
- * @param stdout -
- * @param stderr -
- * @param re -
- * @param close -
- */
-export const linesFromNodeJS = (stdout, stderr, re, close) => (fromNodeJS(stdout, stderr, close).transform(rechunk(re)));