@thi.ng/rstream 8.2.13 → 8.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/rstream",
-  "version": "8.2.13",
+  "version": "8.2.15",
   "description": "Reactive streams & subscription primitives for constructing dataflow graphs / pipelines",
   "type": "module",
   "module": "./index.js",
@@ -28,7 +28,9 @@
   ],
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc internal",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -37,17 +39,18 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/arrays": "^2.7.7",
-    "@thi.ng/associative": "^6.3.23",
-    "@thi.ng/atom": "^5.2.17",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/logger": "^2.0.1",
-    "@thi.ng/transducers": "^8.8.14"
+    "@thi.ng/api": "^8.9.13",
+    "@thi.ng/arrays": "^2.7.9",
+    "@thi.ng/associative": "^6.3.25",
+    "@thi.ng/atom": "^5.2.19",
+    "@thi.ng/checks": "^3.4.13",
+    "@thi.ng/errors": "^2.4.7",
+    "@thi.ng/logger": "^2.1.0",
+    "@thi.ng/transducers": "^8.8.16"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -74,7 +77,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=12.7"
+    "node": ">=18"
   },
   "files": [
     "./*.js",
@@ -212,5 +215,5 @@
     ],
     "year": 2017
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "25a42a81fac8603a1e440a7aa8bc343276211ff4\n"
 }

package/post-worker.js

@@ -2,64 +2,33 @@ import { isTransferable } from "@thi.ng/checks/is-transferable";
 import { isTypedArray } from "@thi.ng/checks/is-typedarray";
 import { LOGGER } from "./logger.js";
 import { defWorker } from "./defworker.js";
-/**
- * Creates a {@link ISubscriber | subscriber} which forwards received
- * values to given worker.
- *
- * @remarks
- * 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. If `transfer` is true, the received values will be
- * marked as *transferrable* and the host app loses all access
- * permissions to these marked values. See `Worker.postMessage()` for
- * details.
- *
- * If `terminate` is set to a positive number, then the worker will be
- * automatically terminated after the stated number of milliseconds
- * since the parent subscription is {@link ISubscriber.done}.
- *
- * @example
- * ```ts
- * // worker source code
- * src = `self.onmessage = (e) => console.log("worker", e.data);`;
- *
- * a = stream();
- * a.subscribe(
- *   postWorker(src, { type: "application/javascript" }))
- * );
- *
- * a.next(42)
- * // worker 42
- * ```
- *
- * @param worker -
- * @param transfer -
- * @param terminate - worker termination delay (ms)
- */
-export const postWorker = (worker, transfer = false, terminate = 0) => {
-    const _worker = defWorker(worker);
-    return {
-        next(x) {
-            if (x instanceof Promise) {
-                x.then((y) => this.next(y));
-                return;
-            }
-            let tx;
-            if (transfer) {
-                const ta = isTypedArray(x);
-                if (ta || isTransferable(x)) {
-                    tx = [ta ? x.buffer : x];
-                }
-            }
-            _worker.postMessage(x, tx || []);
-        },
-        done() {
-            if (terminate > 0) {
-                setTimeout(() => {
-                    LOGGER.info("terminating worker...");
-                    _worker.terminate();
-                }, terminate);
-            }
-        },
-    };
+const postWorker = (worker, transfer = false, terminate = 0) => {
+  const _worker = defWorker(worker);
+  return {
+    next(x) {
+      if (x instanceof Promise) {
+        x.then((y) => this.next(y));
+        return;
+      }
+      let tx;
+      if (transfer) {
+        const ta = isTypedArray(x);
+        if (ta || isTransferable(x)) {
+          tx = [ta ? x.buffer : x];
+        }
+      }
+      _worker.postMessage(x, tx || []);
+    },
+    done() {
+      if (terminate > 0) {
+        setTimeout(() => {
+          LOGGER.info("terminating worker...");
+          _worker.terminate();
+        }, terminate);
+      }
+    }
+  };
+};
+export {
+  postWorker
 };

package/promise.js

@@ -1,40 +1,34 @@
 import { CloseMode, State } from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { stream } from "./stream.js";
-/**
- * Yields a single-value {@link Stream} of the resolved promise and then
- * automatically marks itself done.
- *
- * @remarks
- * It doesn't matter if the promise resolves before the first subscriber
- * has attached.
- *
- * @param src -
- * @param opts -
- */
-export const fromPromise = (src, opts) => {
-    let canceled = false;
-    let isError = false;
-    let err = {};
-    src.catch((e) => {
-        err = e;
-        isError = true;
-    });
-    return stream((stream) => {
-        src.then((x) => {
-            if (!canceled && stream.getState() < State.DONE) {
-                if (isError) {
-                    stream.error(err);
-                    err = null;
-                }
-                else {
-                    stream.next(x);
-                    stream.closeIn !== CloseMode.NEVER && stream.done();
-                }
-            }
-        }, (e) => stream.error(e));
-        return () => {
-            canceled = true;
-        };
-    }, __optsWithID("promise", opts));
+const fromPromise = (src, opts) => {
+  let canceled = false;
+  let isError = false;
+  let err = {};
+  src.catch((e) => {
+    err = e;
+    isError = true;
+  });
+  return stream((stream2) => {
+    src.then(
+      (x) => {
+        if (!canceled && stream2.getState() < State.DONE) {
+          if (isError) {
+            stream2.error(err);
+            err = null;
+          } else {
+            stream2.next(x);
+            stream2.closeIn !== CloseMode.NEVER && stream2.done();
+          }
+        }
+      },
+      (e) => stream2.error(e)
+    );
+    return () => {
+      canceled = true;
+    };
+  }, __optsWithID("promise", opts));
+};
+export {
+  fromPromise
 };

package/promises.js

@@ -1,44 +1,10 @@
 import { mapcat } from "@thi.ng/transducers/mapcat";
 import { __optsWithID } from "./idgen.js";
 import { fromPromise } from "./promise.js";
-/**
- * Wraps given iterable in `Promise.all()` to yield {@link Stream} of results in
- * same order as arguments, then closes.
- *
- * @remarks
- * If any of the promises rejects, all others will do so too. In this case the
- * stream calls {@link ISubscriber.error} in all of its subscribers.
- *
- * @remarks
- * Type signature updated to use `Awaited<T>`, a new core type introduced in
- * TypeScript 4.5.
- *
- * @example
- * ```ts
- * fromPromises([
- *     Promise.resolve(1),
- *     Promise.resolve(2),
- *     Promise.resolve(3)
- * ]).subscribe(trace())
- * // 1
- * // 2
- * // 3
- * // done
- * ```
- *
- * @example
- * If individual error handling is required, an alternative is below
- * (however this approach provides no ordering guarantees):
- *
- * ```ts
- * fromIterable([
- *     Promise.resolve(1),
- *     new Promise(() => setTimeout(() => { throw new Error("eeek"); }, 10)),
- *     Promise.resolve(3)
- * ]).subscribe(resolve()).subscribe(trace())
- * ```
- *
- * @param promises -
- * @param opts -
- */
-export const fromPromises = (promises, opts) => fromPromise(Promise.all(promises), __optsWithID("promises", opts)).transform(mapcat((x) => x));
+const fromPromises = (promises, opts) => fromPromise(
+  Promise.all(promises),
+  __optsWithID("promises", opts)
+).transform(mapcat((x) => x));
+export {
+  fromPromises
+};

package/pubsub.js

@@ -1,115 +1,101 @@
 import { EquivMap } from "@thi.ng/associative/equiv-map";
 import { unsupported } from "@thi.ng/errors/unsupported";
-import { CloseMode, } from "./api.js";
+import {
+  CloseMode
+} from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { LOGGER } from "./logger.js";
 import { Subscription, subscription } from "./subscription.js";
-/**
- * Topic based stream splitter. Applies `topic` function to each received value
- * and only forwards it to the child subscriptions of the returned topic.
- *
- * @remarks
- * The actual topic (return value from `topic` fn) can be of any type `T`, or
- * `undefined`. If the latter is returned, the incoming value will not be
- * processed further. Complex topics (e.g objects / arrays) are allowed and
- * they're matched against registered topics using
- * [`equiv()`](https://docs.thi.ng/umbrella/equiv/functions/equiv.html) by
- * default (but customizable via `equiv` option). Each topic can have any number
- * of subscribers.
- *
- * If a `xform` transducer is given, it is always applied prior to passing the
- * input to the topic function. I.e. in this case the topic function will
- * receive the transformed inputs.
- *
- * {@link PubSub} supports dynamic topic subscriptions and unsubscriptions via
- * {@link PubSub.(subscribeTopic:1)} and {@link PubSub.unsubscribeTopic}.
- * However, the standard {@link ISubscribable.(subscribe:1)} /
- * {@link ISubscribable.unsubscribe} methods are NOT supported (since
- * meaningless) and will throw an error! `unsubscribe()` can only be called
- * WITHOUT argument to unsubscribe the entire `PubSub` instance (incl. all topic
- * subscriptions) from the parent stream.
- *
- * @param opts -
- */
-export const pubsub = (opts) => new PubSub(opts);
-/**
- * @see {@link pubsub} for reference & examples.
- */
-export class PubSub extends Subscription {
-    topicfn;
-    topics;
-    constructor(opts) {
-        super(undefined, __optsWithID("pubsub", {
-            xform: opts.xform,
-        }));
-        this.topicfn = opts.topic;
-        this.topics = new EquivMap(undefined, {
-            equiv: opts.equiv,
-        });
+const pubsub = (opts) => new PubSub(opts);
+class PubSub extends Subscription {
+  topicfn;
+  topics;
+  constructor(opts) {
+    super(
+      void 0,
+      __optsWithID("pubsub", {
+        xform: opts.xform
+      })
+    );
+    this.topicfn = opts.topic;
+    this.topics = new EquivMap(void 0, {
+      equiv: opts.equiv
+    });
+  }
+  /**
+   * Unsupported. Use {@link PubSub.(subscribeTopic:1)} instead.
+   */
+  subscribe() {
+    return unsupported(`use subscribeTopic() instead`);
+  }
+  /**
+   * Unsupported. Use {@link PubSub.(subscribeTopic:1)} instead.
+   */
+  transform() {
+    return unsupported(`use subscribeTopic() instead`);
+  }
+  subscribeTopic(topicID, sub, opts) {
+    let t = this.topics.get(topicID);
+    !t && this.topics.set(
+      topicID,
+      t = subscription(
+        void 0,
+        __optsWithID("topic", {
+          closeOut: CloseMode.NEVER
+        })
+      )
+    );
+    return t.subscribe(sub, opts);
+  }
+  transformTopic(topicID, xform, opts = {}) {
+    return this.subscribeTopic(
+      topicID,
+      { error: opts.error },
+      {
+        ...opts,
+        xform
+      }
+    );
+  }
+  unsubscribeTopic(topicID, sub) {
+    const t = this.topics.get(topicID);
+    return t ? t.unsubscribe(sub) : false;
+  }
+  unsubscribe(sub) {
+    if (!sub) {
+      for (let t of this.topics.values()) {
+        t.unsubscribe();
+      }
+      this.topics.clear();
+      return super.unsubscribe();
     }
-    /**
-     * Unsupported. Use {@link PubSub.(subscribeTopic:1)} instead.
-     */
-    subscribe() {
-        return unsupported(`use subscribeTopic() instead`);
+    return unsupported();
+  }
+  done() {
+    for (let t of this.topics.values()) {
+      t.done();
     }
-    /**
-     * Unsupported. Use {@link PubSub.(subscribeTopic:1)} instead.
-     */
-    transform() {
-        return unsupported(`use subscribeTopic() instead`);
-    }
-    subscribeTopic(topicID, sub, opts) {
-        let t = this.topics.get(topicID);
-        !t &&
-            this.topics.set(topicID, (t = subscription(undefined, __optsWithID("topic", {
-                closeOut: CloseMode.NEVER,
-            }))));
-        return t.subscribe(sub, opts);
-    }
-    transformTopic(topicID, xform, opts = {}) {
-        return this.subscribeTopic(topicID, { error: opts.error }, {
-            ...opts,
-            xform,
-        });
-    }
-    unsubscribeTopic(topicID, sub) {
-        const t = this.topics.get(topicID);
-        return t ? t.unsubscribe(sub) : false;
-    }
-    unsubscribe(sub) {
-        if (!sub) {
-            for (let t of this.topics.values()) {
-                t.unsubscribe();
-            }
-            this.topics.clear();
-            return super.unsubscribe();
-        }
-        // only the PubSub itself can be unsubscribed
-        return unsupported();
-    }
-    done() {
-        for (let t of this.topics.values()) {
-            t.done();
-        }
-        super.done();
-    }
-    dispatch(x) {
-        LOGGER.debug(this.id, "dispatch", x);
-        this.cacheLast && (this.last = x);
-        const t = this.topicfn(x);
-        if (t !== undefined) {
-            const sub = this.topics.get(t);
-            if (sub) {
-                try {
-                    sub.next && sub.next(x);
-                }
-                catch (e) {
-                    if (!sub.error || !sub.error(e)) {
-                        return this.unhandledError(e);
-                    }
-                }
-            }
+    super.done();
+  }
+  dispatch(x) {
+    LOGGER.debug(this.id, "dispatch", x);
+    this.cacheLast && (this.last = x);
+    const t = this.topicfn(x);
+    if (t !== void 0) {
+      const sub = this.topics.get(t);
+      if (sub) {
+        try {
+          sub.next && sub.next(x);
+        } catch (e) {
+          if (!sub.error || !sub.error(e)) {
+            return this.unhandledError(e);
+          }
         }
+      }
     }
+  }
 }
+export {
+  PubSub,
+  pubsub
+};

package/raf.js

@@ -2,31 +2,19 @@ import { isNode } from "@thi.ng/checks/is-node";
 import { __optsWithID } from "./idgen.js";
 import { fromInterval } from "./interval.js";
 import { stream } from "./stream.js";
-/**
- * Yields {@link Stream} of a monotonically increasing counter (or timestamps),
- * triggered by a `requestAnimationFrame()` loop (only available in browser
- * environments).
- *
- * @remarks
- * In NodeJS, this function falls back to {@link fromInterval}, yielding a
- * similar (approx. 60Hz) stream (the {@link FromRAFOpts.timestamp} option will
- * be ignored).
- *
- * All subscribers to this stream will be processed during that same RAF loop
- * iteration.
- */
-export const fromRAF = (opts = {}) => isNode()
-    ? fromInterval(16, opts)
-    : stream((stream) => {
-        let i = 0;
-        let isActive = true;
-        const loop = (time) => {
-            isActive && stream.next(opts.timestamp ? time : i++);
-            isActive && (id = requestAnimationFrame(loop));
-        };
-        let id = requestAnimationFrame(loop);
-        return () => {
-            isActive = false;
-            cancelAnimationFrame(id);
-        };
-    }, __optsWithID("raf", opts));
+const fromRAF = (opts = {}) => isNode() ? fromInterval(16, opts) : stream((stream2) => {
+  let i = 0;
+  let isActive = true;
+  const loop = (time) => {
+    isActive && stream2.next(opts.timestamp ? time : i++);
+    isActive && (id = requestAnimationFrame(loop));
+  };
+  let id = requestAnimationFrame(loop);
+  return () => {
+    isActive = false;
+    cancelAnimationFrame(id);
+  };
+}, __optsWithID("raf", opts));
+export {
+  fromRAF
+};

package/resolve.js

@@ -2,64 +2,43 @@ import { State } from "./api.js";
 import { __optsWithID } from "./idgen.js";
 import { LOGGER } from "./logger.js";
 import { Subscription } from "./subscription.js";
-/**
- * Creates a {@link Subscription} which receives promises, buffers them
- * and then passes their resolved values downstream.
- *
- * @remarks
- * If the optional `fail` handler is provided, it'll be called with the
- * error of each failed promise. If none is provided, the sub's
- * {@link ISubscriber.error} handler is called, which then stops the sub
- * from receiving further values.
- *
- * @example
- * ```ts
- * fromIterable([1, 2, 3], 100)
- *   .transform(tx.delayed(1000))
- *   .subscribe(resolve())
- *   .subscribe(trace("result"))
- * // result 1
- * // result 2
- * // result 3
- * // result done
- * ```
- *
- * @param opts -
- */
-export const resolve = (opts) => new Resolver(opts);
-export class Resolver extends Subscription {
-    outstanding = 0;
-    fail;
-    constructor(opts = {}) {
-        super(undefined, __optsWithID("resolve"));
-        this.fail = opts.fail;
-    }
-    next(x) {
-        this.outstanding++;
-        x.then((y) => {
-            if (this.state < State.DONE) {
-                this.dispatch(y);
-                if (--this.outstanding === 0) {
-                    this.done();
-                }
-            }
-            else {
-                LOGGER.warn(`resolved value in state ${this.state} (${x})`);
-            }
-        }, (e) => {
-            if (this.fail) {
-                this.fail(e);
-            }
-            else {
-                this.error(e);
-            }
-        });
-    }
-    done() {
-        if (this.parent &&
-            this.parent.getState() === State.DONE &&
-            this.outstanding === 0) {
-            super.done();
+const resolve = (opts) => new Resolver(opts);
+class Resolver extends Subscription {
+  outstanding = 0;
+  fail;
+  constructor(opts = {}) {
+    super(void 0, __optsWithID("resolve"));
+    this.fail = opts.fail;
+  }
+  next(x) {
+    this.outstanding++;
+    x.then(
+      (y) => {
+        if (this.state < State.DONE) {
+          this.dispatch(y);
+          if (--this.outstanding === 0) {
+            this.done();
+          }
+        } else {
+          LOGGER.warn(`resolved value in state ${this.state} (${x})`);
+        }
+      },
+      (e) => {
+        if (this.fail) {
+          this.fail(e);
+        } else {
+          this.error(e);
         }
+      }
+    );
+  }
+  done() {
+    if (this.parent && this.parent.getState() === State.DONE && this.outstanding === 0) {
+      super.done();
     }
+  }
 }
+export {
+  Resolver,
+  resolve
+};