@effectionx/stream-helpers 0.4.0 → 0.5.1

package/README.md

@@ -192,6 +192,53 @@ function* exampleWithCloseValue() {
 }
 ```
 
+### Subject
+
+Subject helper converts any stream into a multicast stream that replays the
+latest value to new subscribers. It's analogous to
+[RxJS BehaviorSubject](https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject).
+
+```typescript
+import { createSubject } from "@effectionx/stream-helpers";
+import { createChannel, spawn } from "effection";
+
+function* example() {
+  const subject = createSubject<number>();
+  const channel = createChannel<number, void>();
+  const downstream = subject(channel);
+
+  // First subscriber
+  const sub1 = yield* downstream;
+
+  yield* channel.send(1);
+  yield* channel.send(2);
+
+  console.log(yield* sub1.next()); // { done: false, value: 1 }
+  console.log(yield* sub1.next()); // { done: false, value: 2 }
+
+  // Late subscriber gets the latest value immediately
+  const sub2 = yield* downstream;
+  console.log(yield* sub2.next()); // { done: false, value: 2 }
+}
+```
+
+Use it with a pipe operator to convert any stream into a behavior subject:
+
+```typescript
+import { createSubject, map } from "@effectionx/stream-helpers";
+import { pipe } from "remeda";
+
+const subject = createSubject<string>();
+
+const stream = pipe(
+  source,
+  map(function* (x) {
+    return x.toString();
+  }),
+  subject,
+);
+```
+
 ### Passthrough Tracker
 
 Passthrough Tracker stream helper provides a way to know if all items that

package/esm/mod.d.ts

@@ -4,4 +4,5 @@ export * from "./map.js";
 export * from "./filter.js";
 export * from "./tracker.js";
 export * from "./for-each.js";
+export * from "./subject.js";
 //# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC"}

package/esm/mod.js

@@ -4,3 +4,4 @@ export * from "./map.js";
 export * from "./filter.js";
 export * from "./tracker.js";
 export * from "./for-each.js";
+export * from "./subject.js";

package/esm/subject.d.ts

@@ -0,0 +1,38 @@
+import type { Stream } from "effection";
+/**
+ * Converts any stream into a multicast stream that produces latest value
+ * to new subscribers. It's designed to be analagous in function to [RxJS
+ * BehaviorSubject](https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject).
+ *
+ * @returns A function that takes a stream and returns a multicast stream
+ *
+ * @example
+ * ```ts
+ * const subject = createSubject<number>();
+ * const downstream = subject(upstream);
+ *
+ * const sub1 = yield* downstream; // subscribes to upstream
+ * yield* upstream.send(1);
+ * yield* sub1.next(); // { done: false, value: 1 }
+ *
+ * const sub2 = yield* downstream; // late subscriber
+ * yield* sub2.next(); // { done: false, value: 1 } - gets latest value
+ * ```
+ *
+ * Use it with a pipe operator to convert any stream into a behavior subject.
+ *
+ * @example
+ * ```
+ * let source = createChannel<string, void>();
+ * let subject = createSubject<string>();
+ *
+ * let pipeline = pipe([
+ *  top,
+ *  transform1,
+ *  transform2,
+ *  subject,
+ * ]);
+ * ```
+ */
+export declare function createSubject<T>(): <TClose>(stream: Stream<T, TClose>) => Stream<T, TClose>;
+//# sourceMappingURL=subject.d.ts.map

package/esm/subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject.d.ts","sourceRoot":"","sources":["../src/subject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,WAAW,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,aAAa,CAAC,CAAC,KAAK,CAAC,MAAM,EACzC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KACtB,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAyBrB"}

package/esm/subject.js

@@ -0,0 +1,58 @@
+/**
+ * Converts any stream into a multicast stream that produces latest value
+ * to new subscribers. It's designed to be analagous in function to [RxJS
+ * BehaviorSubject](https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject).
+ *
+ * @returns A function that takes a stream and returns a multicast stream
+ *
+ * @example
+ * ```ts
+ * const subject = createSubject<number>();
+ * const downstream = subject(upstream);
+ *
+ * const sub1 = yield* downstream; // subscribes to upstream
+ * yield* upstream.send(1);
+ * yield* sub1.next(); // { done: false, value: 1 }
+ *
+ * const sub2 = yield* downstream; // late subscriber
+ * yield* sub2.next(); // { done: false, value: 1 } - gets latest value
+ * ```
+ *
+ * Use it with a pipe operator to convert any stream into a behavior subject.
+ *
+ * @example
+ * ```
+ * let source = createChannel<string, void>();
+ * let subject = createSubject<string>();
+ *
+ * let pipeline = pipe([
+ *  top,
+ *  transform1,
+ *  transform2,
+ *  subject,
+ * ]);
+ * ```
+ */
+export function createSubject() {
+    let current = undefined;
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            let upstream = yield* stream;
+            let iterator = current
+                ? {
+                    *next() {
+                        iterator = upstream;
+                        return current;
+                    },
+                }
+                : {
+                    *next() {
+                        return current = yield* upstream.next();
+                    },
+                };
+            return {
+                next: () => iterator.next(),
+            };
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectionx/stream-helpers",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "author": "engineering@frontside.com",
   "repository": {
     "type": "git",
@@ -28,8 +28,8 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@effectionx/signals": "0.3.0",
-    "@effectionx/timebox": "0.2.0",
+    "@effectionx/signals": "^0.4.0",
+    "@effectionx/timebox": "^0.3.0",
     "effection": "^3 || ^4.0.0-0"
   },
   "_generatedBy": "dnt@dev"

package/script/mod.d.ts

@@ -4,4 +4,5 @@ export * from "./map.js";
 export * from "./filter.js";
 export * from "./tracker.js";
 export * from "./for-each.js";
+export * from "./subject.js";
 //# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC"}

package/script/mod.js

@@ -20,3 +20,4 @@ __exportStar(require("./map.js"), exports);
 __exportStar(require("./filter.js"), exports);
 __exportStar(require("./tracker.js"), exports);
 __exportStar(require("./for-each.js"), exports);
+__exportStar(require("./subject.js"), exports);

package/script/subject.d.ts

@@ -0,0 +1,38 @@
+import type { Stream } from "effection";
+/**
+ * Converts any stream into a multicast stream that produces latest value
+ * to new subscribers. It's designed to be analagous in function to [RxJS
+ * BehaviorSubject](https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject).
+ *
+ * @returns A function that takes a stream and returns a multicast stream
+ *
+ * @example
+ * ```ts
+ * const subject = createSubject<number>();
+ * const downstream = subject(upstream);
+ *
+ * const sub1 = yield* downstream; // subscribes to upstream
+ * yield* upstream.send(1);
+ * yield* sub1.next(); // { done: false, value: 1 }
+ *
+ * const sub2 = yield* downstream; // late subscriber
+ * yield* sub2.next(); // { done: false, value: 1 } - gets latest value
+ * ```
+ *
+ * Use it with a pipe operator to convert any stream into a behavior subject.
+ *
+ * @example
+ * ```
+ * let source = createChannel<string, void>();
+ * let subject = createSubject<string>();
+ *
+ * let pipeline = pipe([
+ *  top,
+ *  transform1,
+ *  transform2,
+ *  subject,
+ * ]);
+ * ```
+ */
+export declare function createSubject<T>(): <TClose>(stream: Stream<T, TClose>) => Stream<T, TClose>;
+//# sourceMappingURL=subject.d.ts.map

package/script/subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject.d.ts","sourceRoot":"","sources":["../src/subject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,WAAW,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,aAAa,CAAC,CAAC,KAAK,CAAC,MAAM,EACzC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KACtB,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAyBrB"}

package/script/subject.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubject = createSubject;
+/**
+ * Converts any stream into a multicast stream that produces latest value
+ * to new subscribers. It's designed to be analagous in function to [RxJS
+ * BehaviorSubject](https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject).
+ *
+ * @returns A function that takes a stream and returns a multicast stream
+ *
+ * @example
+ * ```ts
+ * const subject = createSubject<number>();
+ * const downstream = subject(upstream);
+ *
+ * const sub1 = yield* downstream; // subscribes to upstream
+ * yield* upstream.send(1);
+ * yield* sub1.next(); // { done: false, value: 1 }
+ *
+ * const sub2 = yield* downstream; // late subscriber
+ * yield* sub2.next(); // { done: false, value: 1 } - gets latest value
+ * ```
+ *
+ * Use it with a pipe operator to convert any stream into a behavior subject.
+ *
+ * @example
+ * ```
+ * let source = createChannel<string, void>();
+ * let subject = createSubject<string>();
+ *
+ * let pipeline = pipe([
+ *  top,
+ *  transform1,
+ *  transform2,
+ *  subject,
+ * ]);
+ * ```
+ */
+function createSubject() {
+    let current = undefined;
+    return (stream) => ({
+        *[Symbol.iterator]() {
+            let upstream = yield* stream;
+            let iterator = current
+                ? {
+                    *next() {
+                        iterator = upstream;
+                        return current;
+                    },
+                }
+                : {
+                    *next() {
+                        return current = yield* upstream.next();
+                    },
+                };
+            return {
+                next: () => iterator.next(),
+            };
+        },
+    });
+}