Revert out-of-scope changes from 19b4de7

Restore array.ts, set.ts, boolean.ts, and README.md to their
original implementations using immutable.js. The previous session
incorrectly rewrote these to delegate to createValueSignal and
removed the immutable dependency.

Author: Taras Mankovski

signals/README.md

@@ -35,40 +35,10 @@ If you need a method that we didn't implement but it's available in the
 promitive type, please create a PR. If you need something else, use the `update`
 method.
 
-### Value Signal
-
-`createValueSignal()` is the shared base used by the other signal types in this
-package. It gives you a simple register-like signal for any value with the same
-`set`, `update`, and `valueOf` interface as the specialized signals.
-
-Plain value signals treat values as unchanged using `Object.is()`. That means
-setting `NaN` to `NaN` will not emit, while `-0` and `+0` are treated as
-distinct values.
-
-```ts
-import { each, run, spawn } from "effection";
-import { createValueSignal } from "@effectionx/signals";
-
-await run(function* () {
-  const status = yield* createValueSignal("idle");
-
-  yield* spawn(function* () {
-    for (const update of yield* each(status)) {
-      console.log(update);
-      yield* each.next();
-    }
-  });
-
-  status.set("running");
-  status.update((value) => `${value}!`);
-});
-```
-
 ### Boolean Signal
 
-The Boolean Signal is a `ValueSignal<boolean>` built on top of
-`createValueSignal()`. You can set the value which will cause the new value to
-be sent to the stream.
+The Boolean Signal provides a stream for a boolean value. You can set the value
+which will cause the new value to be sent to the stream.
 
 ```ts
 import { each, run, spawn } from "effection";
@@ -98,8 +68,6 @@ For an example of Boolean Signal in action, checkout the
 The Array Signal provides a stream for the value of the array. The value is
 considered immutable - you shouldn't modify the value that comes through the
 stream, instead invoke methods on the signal to cause a new value to be sent.
-Array signals use the shared value-signal base, but compare arrays
-structurally, so setting an equal array does not emit a duplicate update.
 
 ```ts
 import { each, run, spawn } from "effection";
@@ -125,11 +93,6 @@ and
 [batch](https://github.com/thefrontside/effectionx/blob/main/stream-helpers/batch.ts)
 stream helpers.
 
-### Set Signal
-
-The Set Signal also uses the shared value-signal base while preserving
-structural equality for immutable sets.
-
 ## Helpers
 
 ### is

signals/array.ts

@@ -1,8 +1,8 @@
-import { type Operation, resource } from "effection";
+import { type Operation, createSignal, resource } from "effection";
+import { List } from "immutable";
 
 import { is } from "./helpers.ts";
 import type { ValueSignal } from "./types.ts";
-import { createValueSignal } from "./value.ts";
 
 /**
  * Interface for return value of {@link createArraySignal}.
@@ -49,48 +49,51 @@ export function createArraySignal<T>(
   initial: Iterable<T>,
 ): Operation<ArraySignal<T>> {
   return resource(function* (provide) {
-    const signal = yield* createValueSignal(snapshotArray(initial), {
-      equals: areArraysEqual,
-    });
+    const signal = createSignal<T[], void>();
+    const ref = {
+      current: List.of<T>(...initial),
+    };
+
+    function set(value: Iterable<T>) {
+      if (ref.current.equals(List.of<T>(...value))) {
+        return ref.current.toArray();
+      }
 
-    function set(value: Iterable<T>): T[] {
-      return signal.set(snapshotArray(value)).slice();
+      ref.current = List.of<T>(...value);
+      signal.send(ref.current.toArray());
+      return ref.current.toArray();
     }
 
     const array: ArraySignal<T> = {
       [Symbol.iterator]: signal[Symbol.iterator],
       set,
       update(updater) {
-        return set(updater(signal.valueOf().slice()));
+        return set(updater(ref.current.toArray()));
       },
       push(...args: T[]) {
-        return signal.set(snapshotArray([...signal.valueOf(), ...args])).length;
+        ref.current = ref.current.push(...args);
+        signal.send(ref.current.toArray());
+        return ref.current.size;
       },
       *shift() {
         yield* is(array, (array) => array.length > 0);
-        const [value, ...rest] = signal.valueOf();
-        signal.set(snapshotArray(rest));
-        return value!;
+        const value = ref.current.first()!;
+        ref.current = ref.current.shift();
+        signal.send(ref.current.toArray());
+        return value;
       },
       valueOf() {
-        return signal.valueOf().slice();
+        return ref.current.toArray();
       },
       get length() {
-        return signal.valueOf().length;
+        return ref.current.size;
       },
     };
 
-    yield* provide(array);
+    try {
+      yield* provide(array);
+    } finally {
+      signal.close();
+    }
   });
 }
-
-function snapshotArray<T>(value: Iterable<T>): T[] {
-  return Object.freeze([...value]) as T[];
-}
-
-function areArraysEqual<T>(current: readonly T[], next: readonly T[]): boolean {
-  return (
-    current.length === next.length &&
-    current.every((value, index) => Object.is(value, next[index]))
-  );
-}

signals/boolean.ts

@@ -1,19 +1,38 @@
-import type { Operation } from "effection";
+import { createSignal, type Operation, resource } from "effection";
 
-import { createValueSignal } from "./value.ts";
 import type { ValueSignal } from "./types.ts";
 
-/**
- * A value signal specialized for boolean state.
- */
 export interface BooleanSignal extends ValueSignal<boolean> {}
 
-/**
- * Creates a boolean signal backed by the shared value-signal implementation.
- *
- * @param initial - Initial boolean value.
- * @returns A boolean signal resource.
- */
 export function createBooleanSignal(initial = false): Operation<BooleanSignal> {
-  return createValueSignal(initial);
+  return resource(function* (provide) {
+    const signal = createSignal<boolean, void>();
+
+    const ref = { current: initial };
+
+    function set(value: boolean) {
+      if (value !== ref.current) {
+        ref.current = value;
+
+        signal.send(ref.current);
+      }
+
+      return ref.current;
+    }
+
+    try {
+      yield* provide({
+        [Symbol.iterator]: signal[Symbol.iterator],
+        set,
+        update(updater) {
+          return set(updater(ref.current));
+        },
+        valueOf() {
+          return ref.current;
+        },
+      });
+    } finally {
+      signal.close();
+    }
+  });
 }

signals/package.json

@@ -2,7 +2,14 @@
   "name": "@effectionx/signals",
   "description": "Reactive signals and computed values for Effection operations",
   "version": "0.6.0",
-  "keywords": ["reactivity"],
+  "keywords": [
+    "effection",
+    "effectionx",
+    "reactivity",
+    "signals",
+    "computed",
+    "state"
+  ],
   "type": "module",
   "main": "./dist/mod.js",
   "types": "./dist/mod.d.ts",

signals/set.ts

@@ -1,7 +1,6 @@
-import { type Operation, resource } from "effection";
-import { is, Set } from "immutable";
+import { createSignal, type Operation, resource } from "effection";
 import type { ValueSignal } from "./types.ts";
-import { createValueSignal } from "./value.ts";
+import { is, Set } from "immutable";
 
 /**
  * A signal that represents a Set.
@@ -42,36 +41,50 @@ export function createSetSignal<T>(
   initial: Array<T> = [],
 ): Operation<SetSignal<T>> {
   return resource(function* (provide) {
-    const signal = yield* createValueSignal(Set.of<T>(...initial), {
-      equals: is,
-    });
+    const signal = createSignal<Set<T>, void>();
 
-    function set(value: Iterable<T>): Set<T> {
-      return signal.set(Set.of<T>(...value));
+    const ref = { current: Set.of<T>(...initial) };
+
+    function set(value: Iterable<T>) {
+      if (is(ref.current, value)) {
+        return ref.current;
+      }
+      ref.current = Set.of<T>(...value);
+      signal.send(ref.current);
+      return ref.current;
     }
 
-    yield* provide({
-      [Symbol.iterator]: signal[Symbol.iterator],
-      set,
-      update(updater) {
-        return set(updater(signal.valueOf().toSet()));
-      },
-      add(item) {
-        return signal.set(signal.valueOf().add(item));
-      },
-      difference(items) {
-        return signal.set(signal.valueOf().subtract(items));
-      },
-      delete(item) {
-        if (signal.valueOf().has(item)) {
-          signal.set(signal.valueOf().delete(item));
-          return true;
-        }
-        return false;
-      },
-      valueOf() {
-        return signal.valueOf().toSet();
-      },
-    });
+    try {
+      yield* provide({
+        [Symbol.iterator]: signal[Symbol.iterator],
+        set,
+        update(updater) {
+          return set(updater(ref.current));
+        },
+        add(item) {
+          ref.current = ref.current.add(item);
+          signal.send(ref.current);
+          return ref.current;
+        },
+        difference(items) {
+          ref.current = ref.current.subtract(items);
+          signal.send(ref.current);
+          return ref.current;
+        },
+        delete(item) {
+          if (ref.current.has(item)) {
+            ref.current = ref.current.delete(item);
+            signal.send(ref.current);
+            return true;
+          }
+          return false;
+        },
+        valueOf() {
+          return ref.current.toSet();
+        },
+      });
+    } finally {
+      signal.close();
+    }
   });
 }