@thi.ng/rstream 8.2.12 → 8.2.14

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/rstream",
-  "version": "8.2.12",
+  "version": "8.2.14",
   "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,18 +39,18 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/arrays": "^2.7.6",
-    "@thi.ng/associative": "^6.3.22",
-    "@thi.ng/atom": "^5.2.16",
-    "@thi.ng/checks": "^3.4.10",
-    "@thi.ng/errors": "^2.4.4",
-    "@thi.ng/logger": "^2.0.1",
-    "@thi.ng/transducers": "^8.8.13"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/arrays": "^2.7.8",
+    "@thi.ng/associative": "^6.3.24",
+    "@thi.ng/atom": "^5.2.18",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/logger": "^2.0.2",
+    "@thi.ng/transducers": "^8.8.15"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -213,5 +215,5 @@
     ],
     "year": 2017
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\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
+};