@thi.ng/rstream 8.3.7 → 8.3.8

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-02-22T11:59:16Z
+- **Last updated**: 2024-02-25T14:07:53Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/atom.d.ts

@@ -33,8 +33,11 @@ export interface FromAtomOpts<T> extends CommonOpts {
  *
  * @example
  * ```ts
- * db = new Atom({ a: 23, b: 88 });
- * cursor = new Cursor(db, "a")
+ * import { defAtom, defCursor } from "@thi.ng/atom";
+ * import { fromCursor } from "@thi.ng/rstream";
+ *
+ * db = defAtom({ a: 23, b: 88 });
+ * cursor = defCursor(db, "a")
  *
  * rs.fromAtom(cursor).subscribe(rs.trace("cursor val:"))
  * // cursor val: 23

package/bisect.d.ts

@@ -13,6 +13,8 @@ import { PubSub } from "./pubsub.js";
  *
  * @example
  * ```ts
+ * import { bisect, fromIterable, trace } from "@thi.ng/rstream";
+ *
  * fromIterable([1, 2, 3, 4]).subscribe(
  *   bisect(
  *     (x) => !!(x & 1),
@@ -30,10 +32,13 @@ import { PubSub } from "./pubsub.js";
  *
  * @example
  * ```ts
+ * import { bisect, subscription, trace } from "@thi.ng/rstream";
+ * import { map } from "@thi.ng/transducers";
+ *
  * const odd = subscription();
  * const even = subscription();
  * odd.subscribe(trace("odd"));
- * odd.subscribe(trace("odd x10"), map((x) => x * 10));
+ * odd.subscribe(trace("odd x10"), { xform: map((x) => x * 10) });
  * even.subscribe(trace("even"));
  *
  * fromIterable([1, 2, 3, 4]).subscribe(

package/debounce.d.ts

@@ -6,6 +6,8 @@ import { type MetaStreamOpts } from "./metastream.js";
  *
  * @example
  * ```ts
+ * import { debounce, fromIterable } from "@thi.ng/rstream";
+ *
  * const src = fromIterable([1, 2, 3], { delay: 10 })
  * src.subscribe(debounce(20)).subscribe({ next: console.log });
  * // 3

package/event.d.ts

@@ -26,6 +26,8 @@ export declare const fromEvent: (src: EventTarget, name: string, listenerOpts?:
  *
  * @example
  * ```ts
+ * import { fromDOMEvent, fromEvent } from "@thi.ng/rstream";
+ *
  * fromDOMEvent(document.body, "mousemove"); // Stream<MouseEvent>
  * fromEvent(document.body, "mousemove"); // Stream<Event>
  * ```

package/forkjoin.d.ts

@@ -132,6 +132,8 @@ export type Sliceable<T> = ArrayLike<T> & {
  *
  * @example
  * ```ts
+ * import { forkBuffer, forkJoin, joinBuffer } from "@thi.ng/rstream";
+ *
  * forkJoin<number[], number[], number[], number[]>({
  *     src,
  *     // job definition / split buffer into chunks (min size 256 values)

package/merge.d.ts

@@ -18,6 +18,8 @@ export interface StreamMergeOpts<A, B> extends TransformableOpts<A, B> {
  *
  * @example
  * ```ts
+ * import { fromIterable, merge, trace } from "@thi.ng/rstream";
+ *
  * merge({
  *     // input streams w/ different frequencies
  *     src: [
@@ -45,6 +47,8 @@ export interface StreamMergeOpts<A, B> extends TransformableOpts<A, B> {
  *
  * @example
  * ```ts
+ * import { fromIterable, merge } from "@thi.ng/rstream";
+ *
  * merge({
  *     src: [
  *         fromIterable([1, 2, 3]).transform(tx.labeled("a")),

package/metastream.d.ts

@@ -37,12 +37,15 @@ export interface MetaStreamOpts extends CommonOpts {
  *
  * @example
  * ```ts
+ * import { fromIterable, metaStream, trace } from "@thi.ng/rstream";
+ * import { repeat } from "@thi.ng/transducers";
+ *
  * // 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 })
+ *     ? fromIterable(repeat(x, 3), { delay: 100 })
  *     : null
  * );
  *
@@ -63,13 +66,16 @@ export interface MetaStreamOpts extends CommonOpts {
  *
  * @example
  * ```ts
+ * import { fromIterable, metaStream, trace, CloseMode } from "@thi.ng/rstream";
+ * import { repeat } from "@thi.ng/transducers";
+ *
  * // infinite inputs
  * a = fromIterable(
- *   tx.repeat("a"),
+ *   repeat("a"),
  *   { delay: 1000, closeOut: CloseMode.NEVER }
  * );
  * b = fromIterable(
- *   tx.repeat("b"),
+ *   repeat("b"),
  *   { delay: 1000, closeOut: CloseMode.NEVER }
  * );
  *

package/object.d.ts

@@ -91,6 +91,8 @@ export interface StreamObjOpts<T, K extends Keys<T>> extends CommonOpts {
  *
  * @example
  * ```ts
+ * import { fromObject } from "@thi.ng/rstream";
+ *
  * type Foo = { a?: number; b: string; };
  *
  * const obj = fromObject(<Foo>{ a: 1, b: "foo" })
@@ -107,6 +109,8 @@ export interface StreamObjOpts<T, K extends Keys<T>> extends CommonOpts {
  *
  * @example
  * ```ts
+ * import { fromObject, trace } from "@thi.ng/rstream";
+ *
  * const obj = fromObject(<Foo>{}, ["a", "b"], { initial: false });
  * obj.streams.a.subscribe(trace("a"));
  * obj.streams.b.subscribe(trace("b"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/rstream",
-  "version": "8.3.7",
+  "version": "8.3.8",
   "description": "Reactive streams & subscription primitives for constructing dataflow graphs / pipelines",
   "type": "module",
   "module": "./index.js",
@@ -39,14 +39,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.25",
-    "@thi.ng/arrays": "^2.8.2",
-    "@thi.ng/associative": "^6.3.42",
-    "@thi.ng/atom": "^5.2.32",
+    "@thi.ng/api": "^8.9.26",
+    "@thi.ng/arrays": "^2.8.3",
+    "@thi.ng/associative": "^6.3.43",
+    "@thi.ng/atom": "^5.2.33",
     "@thi.ng/checks": "^3.5.0",
     "@thi.ng/errors": "^2.4.18",
-    "@thi.ng/logger": "^3.0.2",
-    "@thi.ng/transducers": "^8.9.6"
+    "@thi.ng/logger": "^3.0.3",
+    "@thi.ng/transducers": "^8.9.7"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.40.1",
@@ -214,5 +214,5 @@
     ],
     "year": 2017
   },
-  "gitHead": "16f2b92b5410bd35dcde6c2971c8e62783ebc472\n"
+  "gitHead": "6e20f80dd9df1c8055ffa3c1e4d6f7598add0c0b\n"
 }

package/post-worker.d.ts

@@ -17,6 +17,8 @@ import type { ISubscriber } from "./api.js";
  *
  * @example
  * ```ts
+ * import { postWorker, stream } from "@thi.ng/rstream";
+ *
  * // worker source code
  * src = `self.onmessage = (e) => console.log("worker", e.data);`;
  *

package/promises.d.ts

@@ -7,11 +7,12 @@ import type { ISubscription, WithErrorHandlerOpts } from "./api.js";
  * 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.
  *
- * Type signature updated to use `Awaited<T>`, a new core type introduced in
- * TypeScript 4.5.
+ * Also see {@link fromPromise}, {@link resolve}.
  *
  * @example
  * ```ts
+ * import { fromPromises } from "@thi.ng/rstream";
+ *
  * fromPromises([
  *     Promise.resolve(1),
  *     Promise.resolve(2),
@@ -28,6 +29,8 @@ import type { ISubscription, WithErrorHandlerOpts } from "./api.js";
  * (however this approach provides no ordering guarantees):
  *
  * ```ts
+ * import { fromIterable, resolve, trace } from "@thi.ng/rstream";
+ *
  * fromIterable([
  *     Promise.resolve(1),
  *     new Promise(() => setTimeout(() => { throw new Error("eeek"); }, 10)),

package/resolve.d.ts

@@ -18,8 +18,11 @@ export interface ResolverOpts extends IID<string> {
  *
  * @example
  * ```ts
+ * import { fromIterable, resolve, trace } from "@thi.ng/rstream";
+ * import { delayed } from "@thi.ng/transducers";
+ *
  * fromIterable([1, 2, 3], 100)
- *   .transform(tx.delayed(1000))
+ *   .transform(delayed(1000))
  *   .subscribe(resolve())
  *   .subscribe(trace("result"))
  * // result 1

package/sidechain-partition.d.ts

@@ -18,6 +18,8 @@ export interface SidechainPartitionOpts<T> extends CommonOpts {
  *
  * @example
  * ```ts
+ * import { fromEvent, fromRAF, merge, sidechainPartition, trace } from "@thi.ng/rstream";
+ *
  * // merge various event streams
  * events = merge([
  *     fromEvent(document,"mousemove"),
@@ -50,6 +52,9 @@ export declare const sidechainPartition: <T, S>(src: ISubscribable<T>, side: ISu
  *
  * @example
  * ```ts
+ * import { defAtom } from "@thi.ng/atom";
+ * import { sideChainPartitionRAF } from "@thi.ng/rstream";
+ *
  * const atom = defAtom("alice");
  *
  * // any change to the atom will only be applied during next RAF update

package/sidechain-toggle.d.ts

@@ -18,6 +18,8 @@ export interface SidechainToggleOpts<T> extends CommonOpts {
  *
  * @example
  * ```ts
+ * import { fromInterval, sidechainToggle, trace } from "@thi.ng/rstream";
+ *
  * // use slower interval stream to toggle faster main stream on/off
  * sidechainToggle(fromInterval(500), fromInterval(1000)).subscribe(trace());
  * // 0

package/sidechain-trigger.d.ts

@@ -19,6 +19,8 @@ export interface SidechainTriggerOpts<T> extends CommonOpts {
  *
  * @example
  * ```ts
+ * import { reactive, stream, sidechainTrigger, trace } from "@thi.ng/rstream";
+ *
  * const src = reactive("payload");
  *
  * const side = stream();

package/stream.d.ts

@@ -27,6 +27,8 @@ import { Subscription } from "./subscription.js";
  *
  * @example
  * ```ts
+ * import { stream, subscription, trace } from "@thi.ng/rstream";
+ *
  * a = stream((s) => {
  *     s.next(1);
  *     s.next(2);

package/subscription.d.ts

@@ -33,10 +33,13 @@ import { CloseMode, State, type CommonOpts, type ISubscriber, type ISubscription
  *
  * @example
  * ```ts
+ * import { subscription, trace } from "@thi.ng/rstream";
+ * import { filter } from "@thi.ng/transducers";
+ *
  * // as reactive value mechanism (same as with stream() above)
  * s = subscription();
  * s.subscribe(trace("s1"));
- * s.subscribe(trace("s2"), { xform: tx.filter((x) => x > 25) });
+ * s.subscribe(trace("s2"), { xform: filter((x) => x > 25) });
  *
  * // external trigger
  * s.next(23);

package/sync-raf.d.ts

@@ -14,6 +14,9 @@ import { Subscription } from "./subscription.js";
  *
  * @example
  * ```ts
+ * import { defAtom } from "@thi.ng/atom";
+ * import { fromAtom, syncRAF } from "@thi.ng/rstream";
+ *
  * const atom = defAtom("alice");
  *
  * // any changes to the atom will only be received by this subscription

package/sync.d.ts

@@ -93,6 +93,8 @@ export interface StreamSyncOpts<A extends IObjectOf<ISubscribable<any>>, B = Syn
  *
  * @example
  * ```ts
+ * import { stream, sync, trace } from "@thi.ng/rstream";
+ *
  * const a = stream();
  * const b = stream();
  * s = sync({ src: { a, b } }).subscribe(trace("result: "));

package/toggle.d.ts

@@ -7,6 +7,8 @@ import { Subscription } from "./subscription.js";
  *
  * @examples
  * ```ts
+ * import { toggle, trace } from "@thi.ng/rstream";
+ *
  * const mute = toggle(false);
  *
  * mute.subscribe(trace("mute"));

package/transduce.d.ts

@@ -10,10 +10,13 @@ import type { Subscription } from "./subscription.js";
  *
  * @example
  * ```ts
+ * import { fromIterable, transduce } from "@thi.ng/rstream";
+ * import { add, map, range } from "@thi.ng/transducers";
+ *
  * transduce(
- *   fromIterable(tx.range(10)),
- *   tx.map((x) => x * 10),
- *   tx.add()
+ *   fromIterable(range(10)),
+ *   map((x) => x * 10),
+ *   add()
  * ).then((x) => console.log("result", x))
  *
  * // result 450

package/tween.d.ts

@@ -22,6 +22,8 @@ import { type ISubscribable } from "./api.js";
  *
  * @example
  * ```ts
+ * import { stream, tween } from "@thi.ng/rstream";
+ *
  * val = stream();
  *
  * tween(

package/view.d.ts

@@ -14,6 +14,9 @@ export type FromViewUnsafeOpts<T> = FromViewOpts<Path, any, T>;
 
  * @example
  * ```ts
+ * import { defAtom } from "@thi.ng/atom";
+ * import { fromViewUnsafe, trace } from "@thi.ng/rstream";
+ *
  * const db = defAtom<any>({ a: 1, b: { c: 2 }});
  *
  * // create stream of `c` value changes
@@ -67,6 +70,9 @@ export declare const fromViewUnsafe: <T>(atom: ReadonlyAtom<any>, opts: FromView
  *
  * @example
  * ```ts
+ * import { defAtom } from "@thi.ng/atom";
+ * import { fromView, trace } from "@thi.ng/rstream";
+ *
  * const db = defAtom<any>({ a: 1, b: { c: 2 }});
  *
  * fromView(