@effectionx/stream-helpers 0.7.1 → 0.7.2

package/last.test.ts

@@ -0,0 +1,65 @@
+import { describe, it } from "@effectionx/bdd";
+import { expect } from "expect";
+
+import { last } from "./last.ts";
+import { streamOf } from "./stream-of.ts";
+
+describe("last", () => {
+  it("should return the last value from the stream", function* () {
+    const stream = streamOf([1, 2, 3]);
+    const value = yield* last(stream);
+    expect(value).toBe(3);
+  });
+
+  it("should return the only value when stream has one item", function* () {
+    const stream = streamOf([42]);
+    const value = yield* last(stream);
+    expect(value).toBe(42);
+  });
+
+  it("should return undefined if stream closes without yielding any values", function* () {
+    const stream = streamOf([]);
+    const value = yield* last(stream);
+    expect(value).toBe(undefined);
+  });
+
+  it("should work with undefined as a valid value", function* () {
+    const stream = streamOf([1, 2, undefined]);
+    const value = yield* last(stream);
+    expect(value).toBe(undefined);
+  });
+
+  describe("expect", () => {
+    it("should return the last value from the stream", function* () {
+      const stream = streamOf([1, 2, 3]);
+      const value = yield* last.expect(stream);
+      expect(value).toBe(3);
+    });
+
+    it("should return the only value when stream has one item", function* () {
+      const stream = streamOf([42]);
+      const value = yield* last.expect(stream);
+      expect(value).toBe(42);
+    });
+
+    it("should throw if stream closes without yielding any values", function* () {
+      const stream = streamOf([]);
+
+      let error: Error | undefined;
+      try {
+        yield* last.expect(stream);
+      } catch (e) {
+        error = e as Error;
+      }
+
+      expect(error).toBeDefined();
+      expect(error?.message).toBe("Stream closed without yielding any values");
+    });
+
+    it("should work with undefined as a valid value", function* () {
+      const stream = streamOf([1, 2, undefined]);
+      const value = yield* last.expect(stream);
+      expect(value).toBe(undefined);
+    });
+  });
+});

package/last.ts

@@ -0,0 +1,96 @@
+import type { Operation, Stream } from "effection";
+
+/**
+ * Returns the last value yielded by a stream, or `undefined` if the stream
+ * closes without yielding any values.
+ *
+ * Exhausts the entire stream to find the last value.
+ * Use `last.expect()` if you want to throw an error when the stream is empty.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value (unused)
+ * @param stream - The stream to get the last value from
+ * @returns The last value yielded by the stream, or `undefined` if empty
+ *
+ * @example
+ * ```typescript
+ * import { last } from "./last.ts";
+ *
+ * const stream = streamOf([1, 2, 3]);
+ * const value = yield* last(stream); // returns 3
+ *
+ * const empty = streamOf([]);
+ * const value = yield* last(empty); // returns undefined
+ * ```
+ */
+export function last<T, TClose>(
+  stream: Stream<T, TClose>,
+): Operation<T | undefined> {
+  return {
+    *[Symbol.iterator]() {
+      const subscription = yield* stream;
+      const first = yield* subscription.next();
+
+      if (first.done) {
+        return undefined;
+      }
+
+      let lastValue: T = first.value;
+      let result = yield* subscription.next();
+
+      while (!result.done) {
+        lastValue = result.value;
+        result = yield* subscription.next();
+      }
+
+      return lastValue;
+    },
+  };
+}
+
+/**
+ * Returns the last value yielded by a stream.
+ * Exhausts the entire stream to find the last value.
+ * Throws an error if the stream closes without yielding any values.
+ *
+ * @template T - The type of items in the stream
+ * @template TClose - The type of the close value (unused)
+ * @param stream - The stream to get the last value from
+ * @returns The last value yielded by the stream
+ * @throws Error if the stream closes without yielding any values
+ *
+ * @example
+ * ```typescript
+ * import { last } from "./last.ts";
+ *
+ * const stream = streamOf([1, 2, 3]);
+ * const value = yield* last.expect(stream); // returns 3
+ *
+ * const empty = streamOf([]);
+ * const value = yield* last.expect(empty); // throws Error
+ * ```
+ */
+last.expect = function expectLast<T, TClose>(
+  stream: Stream<T, TClose>,
+): Operation<T> {
+  return {
+    *[Symbol.iterator]() {
+      const subscription = yield* stream;
+      const first = yield* subscription.next();
+
+      if (first.done) {
+        throw new Error("Stream closed without yielding any values");
+      }
+
+      let lastValue: T = first.value;
+      let result = yield* subscription.next();
+
+      while (!result.done) {
+        lastValue = result.value;
+        result = yield* subscription.next();
+      }
+
+      return lastValue;
+    },
+  };
+};

package/mod.ts

@@ -8,3 +8,6 @@ export * from "./subject.ts";
 export * from "./lines.ts";
 export * from "./stream-of.ts";
 export * from "./reduce.ts";
+export * from "./drain.ts";
+export * from "./first.ts";
+export * from "./last.ts";

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@effectionx/stream-helpers",
-  "version": "0.7.1",
+  "description": "Type-safe stream operators like filter, map, reduce, and forEach",
+  "version": "0.7.2",
   "type": "module",
   "main": "./dist/mod.js",
   "types": "./dist/mod.d.ts",
@@ -20,8 +21,8 @@
   "dependencies": {
     "immutable": "^5",
     "remeda": "^2",
-    "@effectionx/signals": "0.5.0",
-    "@effectionx/timebox": "0.4.0"
+    "@effectionx/signals": "0.5.1",
+    "@effectionx/timebox": "0.4.1"
   },
   "license": "MIT",
   "author": "engineering@frontside.com",
@@ -37,6 +38,6 @@
   },
   "sideEffects": false,
   "devDependencies": {
-    "@effectionx/bdd": "0.4.1"
+    "@effectionx/bdd": "0.4.2"
   }
 }

package/test-helpers/faucet.test.ts

@@ -19,7 +19,7 @@ describe("useFaucet", () => {
     });
 
     yield* spawn(function* () {
-      yield* sleep(1);
+      yield* sleep(0);
       // Pour an array of items
       yield* faucet.pour([1, 2, 3]);
     });
@@ -71,7 +71,7 @@ describe("useFaucet", () => {
 
     // Pour using a generator function
     yield* spawn(function* () {
-      yield* sleep(1);
+      yield* sleep(0);
       yield* faucet.pour(function* (send) {
         yield* send(1);
         yield* sleep(10);
@@ -100,7 +100,7 @@ describe("useFaucet", () => {
 
     // Start pouring with a generator
     yield* spawn(function* () {
-      yield* sleep(1);
+      yield* sleep(0);
       yield* faucet.pour(function* (send) {
         yield* send(1);
         yield* sleep(10);

package/test-helpers/faucet.ts

@@ -1,5 +1,5 @@
-import { createChannel, type Operation, type Stream } from "effection";
 import { createBooleanSignal, is } from "@effectionx/signals";
+import { type Operation, type Stream, createChannel } from "effection";
 
 /**
  * Interface of the stream returned by `useFaucet`.
@@ -80,30 +80,34 @@ export interface FaucetOptions {
  * @param options.open - Whether the faucet is open.
  * @returns stream of items coming from the faucet
  */
-export function* useFaucet<T>(options: FaucetOptions): Operation<Faucet<T>> {
-  let signal = createChannel<T, never>();
-  let open = yield* createBooleanSignal(options.open);
-
+export function useFaucet<T>(options: FaucetOptions): Operation<Faucet<T>> {
   return {
-    [Symbol.iterator]: signal[Symbol.iterator],
-    *pour(items) {
-      if (Array.isArray(items)) {
-        for (let i of items) {
-          yield* is(open, (open) => open);
-          yield* signal.send(i);
-        }
-      } else {
-        yield* items(function* (item) {
-          yield* is(open, (open) => open);
-          yield* signal.send(item);
-        });
-      }
-    },
-    close() {
-      open.set(false);
-    },
-    open() {
-      open.set(true);
+    *[Symbol.iterator]() {
+      let signal = createChannel<T, never>();
+      let open = yield* createBooleanSignal(options.open);
+
+      return {
+        [Symbol.iterator]: signal[Symbol.iterator],
+        *pour(items) {
+          if (Array.isArray(items)) {
+            for (let i of items) {
+              yield* is(open, (open) => open);
+              yield* signal.send(i);
+            }
+          } else {
+            yield* items(function* (item) {
+              yield* is(open, (open) => open);
+              yield* signal.send(item);
+            });
+          }
+        },
+        close() {
+          open.set(false);
+        },
+        open() {
+          open.set(true);
+        },
+      };
     },
   };
 }

package/tracker.test.ts

@@ -33,13 +33,13 @@ describe("tracker", () => {
       }
     });
 
-    yield* sleep(1);
+    yield* sleep(0);
 
     yield* faucet.pour(function* (send) {
       yield* send(1);
-      yield* sleep(1);
+      yield* sleep(0);
       yield* send(2);
-      yield* sleep(1);
+      yield* sleep(0);
       yield* send(3);
     });
 
@@ -75,7 +75,7 @@ describe("tracker", () => {
       }
     });
 
-    yield* sleep(1);
+    yield* sleep(0);
 
     yield* faucet.pour(function* (send) {
       yield* send(1);

package/valve.test.ts

@@ -33,12 +33,12 @@ describe("valve", () => {
     yield* spawn(function* () {
       for (const value of yield* each(stream(faucet))) {
         values.push(value);
-        yield* sleep(1);
+        yield* sleep(0);
         yield* each.next();
       }
     });
 
-    yield* sleep(1);
+    yield* sleep(0);
 
     yield* faucet.pour([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);