@thi.ng/rstream 8.2.13 → 8.2.14

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)));

package/object.js

@@ -1,103 +1,39 @@
 import { dedupe } from "@thi.ng/transducers/dedupe";
 import { __nextID } from "./idgen.js";
 import { subscription } from "./subscription.js";
-/**
- * Takes an arbitrary object `src` and object of options (see
- * {@link StreamObjOpts}). Creates a new object and for each selected
- * key creates a new stream, optionally seeded with the key's value in
- * `src`. Returns new object of streams.
- *
- * @remarks
- * The structure of the returned object is
- * {@link StreamObj | as follows}:
- *
- * ```ts
- * {
- *   streams: { ... },
- *   next(x): void;
- *   done(): void;
- * }
- * ```
- *
- * All streams will be stored under `streams`. The `next()` and `done()`
- * functions/methods allow the object itself to be used as subscriber
- * for an upstream subscribable (see 2nd example below):
- *
- * - `next()` - takes a object of same type as `src` and feeds each
- *   key's new value into its respective stream. If the `defaults`
- *   option is given, `undefined` key values are replaced with their
- *   specified default. If `dedupe` is enabled (default) only changed
- *   values (as per `equiv` predicate option) will be propagated
- *   downstream.
- * - `done()` - calls {@link ISubscriber.done} on all streams
- *
- * The optional `opts` arg is used to customize overall behavior of
- * `fromObject` and specify shared options for *all* created streams.
- *
- * @example
- * ```ts
- * type Foo = { a?: number; b: string; };
- *
- * const obj = fromObject(<Foo>{ a: 1, b: "foo" })
- *
- * obj.streams.a.subscribe(trace("a"))
- * // a 1
- * obj.streams.b.subscribe(trace("b"))
- * // b foo
- *
- * obj.next({ b: "bar" })
- * // a undefined
- * // b bar
- * ```
- *
- * @example
- * ```ts
- * const obj = fromObject(<Foo>{}, ["a", "b"], { initial: false });
- * obj.streams.a.subscribe(trace("a"));
- * obj.streams.b.subscribe(trace("b"));
- *
- * const src = subscription<Foo, Foo>();
- * // use as subscriber
- * src.subscribe(obj);
- *
- * src.next({ a: 1, b: "foo" });
- * // a 1
- * // b foo
- * ```
- *
- * @param src -
- * @param opts -
- */
-export const fromObject = (src, opts = {}) => {
-    const id = opts.id || `obj${__nextID()}`;
-    const keys = opts.keys || Object.keys(src);
-    const _opts = opts.dedupe !== false
-        ? {
-            xform: dedupe(opts.equiv || ((a, b) => a === b)),
-            ...opts,
-        }
-        : opts;
-    const streams = {};
-    for (let k of keys) {
-        streams[k] = subscription(undefined, {
-            ..._opts,
-            id: `${id}-${String(k)}`,
-        });
+const fromObject = (src, opts = {}) => {
+  const id = opts.id || `obj${__nextID()}`;
+  const keys = opts.keys || Object.keys(src);
+  const _opts = opts.dedupe !== false ? {
+    xform: dedupe(opts.equiv || ((a, b) => a === b)),
+    ...opts
+  } : opts;
+  const streams = {};
+  for (let k of keys) {
+    streams[k] = subscription(void 0, {
+      ..._opts,
+      id: `${id}-${String(k)}`
+    });
+  }
+  const res = {
+    streams,
+    next(state) {
+      for (let k of keys) {
+        const val = state[k];
+        streams[k].next(
+          opts.defaults && val === void 0 ? opts.defaults[k] : val
+        );
+      }
+    },
+    done() {
+      for (let k of keys) {
+        streams[k].done();
+      }
     }
-    const res = {
-        streams,
-        next(state) {
-            for (let k of keys) {
-                const val = state[k];
-                streams[k].next(opts.defaults && val === undefined ? opts.defaults[k] : val);
-            }
-        },
-        done() {
-            for (let k of keys) {
-                streams[k].done();
-            }
-        },
-    };
-    opts.initial !== false && res.next(src);
-    return res;
+  };
+  opts.initial !== false && res.next(src);
+  return res;
+};
+export {
+  fromObject
 };