refactor: update tests

Author: crimx

src/compute.ts

@@ -1,5 +1,5 @@
 import { ReadableImpl } from "./readable";
-import { type Get, type Readable, type Config, type OwnedReadable } from "./typings";
+import { type Config, type Get, type OwnedReadable, type Readable } from "./typings";
 import { isReadable } from "./utils";
 
 export interface ComputeFn<TValue> {
@@ -9,8 +9,6 @@ export interface ComputeFn<TValue> {
 export const compute = <TValue>(fn: ComputeFn<TValue>, config?: Config<TValue>): OwnedReadable<TValue> => {
   let running: boolean | undefined;
 
-  let self: ReadableImpl<TValue>;
-
   const get = <T = any>($?: Readable<T> | T | { $: Readable<T> }): T | undefined => {
     if (!isReadable($)) {
       return $ as T | undefined;
@@ -21,9 +19,7 @@ export const compute = <TValue>(fn: ComputeFn<TValue>, config?: Config<TValue>):
     return $.get();
   };
 
-  return new ReadableImpl(v => {
-    self = v;
-
+  const self = new ReadableImpl(self => {
     const isFirst = !running;
     running = true;
 
@@ -41,4 +37,6 @@ export const compute = <TValue>(fn: ComputeFn<TValue>, config?: Config<TValue>):
       }
     }
   }, config);
+
+  return self;
 };

src/event.ts

@@ -26,7 +26,7 @@ export const on = (eventObject: EventObject, listener: Listener): RemoveListener
   eventObject.single_ || eventObject.multi_
     ? (eventObject.multi_ ??= new Set<Listener>().add(eventObject.single_!)).add(listener)
     : (eventObject.single_ = listener),
-  off.bind(null, eventObject, listener)
+  () => off(eventObject, listener)
 );
 
 export const off = (eventObject: EventObject, listener: Listener): boolean =>

src/readable.ts

@@ -270,7 +270,7 @@ export class ReadableImpl<TValue = any> implements BatchTask {
 
   public reaction(subscriber: Subscriber<TValue>): Disposer {
     this.onReaction_(subscriber);
-    return this.unsubscribe.bind(this, subscriber);
+    return () => this.unsubscribe(subscriber);
   }
 
   public removeDep_(dep: ReadableImpl): void {
@@ -313,12 +313,8 @@ export class ReadableImpl<TValue = any> implements BatchTask {
     return "" + this.toJSON();
   }
 
-  public unsubscribe(subscriber: (...args: any[]) => any): void {
-    this._subs_?.delete(subscriber);
-  }
-
-  public unsubscribeAll(): void {
-    this._subs_?.clear();
+  public unsubscribe(subscriber?: (...args: any[]) => any): void {
+    subscriber ? this._subs_?.delete(subscriber) : this._subs_?.clear();
   }
 
   public valueOf(): TValue {

src/typings.ts

@@ -71,21 +71,18 @@ export interface Readable<TValue = any> {
    */
   subscribe(subscriber: Subscriber<TValue>): Disposer;
   /**
-   * Remove the given subscriber.
-   * @param subscriber
+   * Remove the given subscriber or all subscribers if no subscriber is provided.
+   * @param subscriber Optional subscriber function to remove.
+   * If not provided, all subscribers will be removed.
    */
-  unsubscribe(subscriber: (...args: any[]) => any): void;
+  unsubscribe(subscriber?: (...args: any[]) => any): void;
 }
 
 export interface OwnedReadable<TValue = any> extends Readable<TValue> {
   /**
    * Remove all subscribers and lock.
    */
   dispose(): void;
-  /**
-   * Remove all subscribers.
-   */
-  unsubscribeAll(): void;
 }
 
 export type SetValue<TValue = any> = (value: TValue) => void;
@@ -111,8 +108,4 @@ export interface OwnedWritable<TValue = any> extends Writable<TValue> {
    * Remove all subscribers and lock.
    */
   dispose(): void;
-  /**
-   * Remove all subscribers.
-   */
-  unsubscribeAll(): void;
 }

src/utils.ts

@@ -1,4 +1,4 @@
-import { type $sValueTuple, type Readable, type Version } from "./typings";
+import { type $sValueTuple, type Readable } from "./typings";
 
 export const BRAND = /* @__PURE__ */ Symbol.for("@embra/reactivity");
 export type BRAND = typeof BRAND;
@@ -15,7 +15,7 @@ export type UNIQUE_VALUE = typeof UNIQUE_VALUE;
  */
 export const unsubscribe = (
   $: Iterable<Readable> | Readable | null | undefined,
-  subscriber: (...args: any[]) => any,
+  subscriber?: (...args: any[]) => any,
 ): void => {
   if ($) {
     if (isReadable($)) {
@@ -69,8 +69,6 @@ const getValue = <TValue>($: Readable<TValue>): TValue => $.value;
 export const getValues = <T extends readonly Readable[]>($s: T): [...$sValueTuple<T>] =>
   $s.map(getValue) as [...$sValueTuple<T>];
 
-export const getVersion = ($: Readable): Version => $.$version;
-
 interface IsReadable {
   <T extends Readable>($: T): $ is T;
   ($: unknown): $ is Readable;

src/watch.ts

@@ -48,10 +48,6 @@ export const watch = (effect: WatchEffect): Disposer => {
   };
 
   const runner = () => {
-    if (disposed) {
-      return;
-    }
-
     if (cleanupEffect) {
       const cleanup = cleanupEffect;
       cleanupEffect = null;

test/collections/reactiveMap.test.ts

@@ -496,4 +496,76 @@ describe("ReactiveMap", () => {
       consoleErrorMock.mockRestore();
     });
   });
+
+  describe("onChanged", () => {
+    it("should notify multiple listeners on change", () => {
+      const map = reactiveMap<string, number>();
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+
+      map.onChanged(listener1);
+      const dispose = map.onChanged(listener2);
+
+      map.set("foo", 1);
+      expect(listener1).toHaveBeenCalledWith({ upsert: [["foo", 1]], delete: [] });
+      expect(listener2).toHaveBeenCalledWith({ upsert: [["foo", 1]], delete: [] });
+
+      listener1.mockClear();
+      listener2.mockClear();
+
+      dispose();
+
+      map.set("bar", 2);
+      expect(listener1).toHaveBeenCalledWith({ upsert: [["bar", 2]], delete: [] });
+      expect(listener2).toHaveBeenCalledTimes(0);
+    });
+
+    it("should not notify listeners after dispose", () => {
+      const map = reactiveMap<string, number>();
+      const listener = vi.fn();
+
+      map.onChanged(listener);
+      map.dispose();
+
+      map.set("foo", 1);
+      expect(listener).toHaveBeenCalledTimes(0);
+    });
+
+    it("should not notify disposed listeners", () => {
+      const map = reactiveMap<string, number>();
+      const listener = vi.fn();
+
+      const dispose = map.onChanged(listener);
+      dispose();
+
+      map.set("foo", 1);
+      expect(listener).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  describe("onDisposeValue", () => {
+    it("should notify listeners when a value should be disposed", () => {
+      const map = reactiveMap<string, number>();
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+
+      map.onDisposeValue(listener1);
+      const dispose = map.onDisposeValue(listener2);
+
+      map.set("foo", 1);
+      map.delete("foo");
+      expect(listener1).toHaveBeenCalledWith(1);
+      expect(listener2).toHaveBeenCalledWith(1);
+
+      listener1.mockClear();
+      listener2.mockClear();
+
+      dispose();
+
+      map.set("bar", 2);
+      map.delete("bar");
+      expect(listener1).toHaveBeenCalledWith(2);
+      expect(listener2).toHaveBeenCalledTimes(0);
+    });
+  });
 });

test/event.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { on, send, off, size } from "../src/event";
+
+describe("event", () => {
+  it("should send data to single listener", () => {
+    const eventObject = {};
+    const listener = vi.fn();
+
+    on(eventObject, listener);
+    send(eventObject, "test data");
+
+    expect(listener).toBeCalledTimes(1);
+    expect(listener).toBeCalledWith("test data");
+  });
+
+  it("should send data to multiple listeners", () => {
+    const eventObject = {};
+    const listener1 = vi.fn();
+    const listener2 = vi.fn();
+
+    on(eventObject, listener1);
+    on(eventObject, listener2);
+    send(eventObject, "test data");
+
+    expect(listener1).toBeCalledTimes(1);
+    expect(listener1).toBeCalledWith("test data");
+    expect(listener2).toBeCalledTimes(1);
+    expect(listener2).toBeCalledWith("test data");
+  });
+
+  it("should return the correct size of listeners", () => {
+    const eventObject: any = {};
+    const listener1 = vi.fn();
+    const listener2 = vi.fn();
+
+    expect(size(eventObject)).toBe(0);
+
+    on(eventObject, listener1);
+    expect(size(eventObject)).toBe(1);
+
+    on(eventObject, listener2);
+    expect(size(eventObject)).toBe(2);
+
+    off(eventObject, listener1);
+    expect(size(eventObject)).toBe(1);
+
+    off(eventObject, listener2);
+    expect(size(eventObject)).toBe(0);
+  });
+
+  it("should remove a single listener", () => {
+    const eventObject: any = {};
+    const listener = vi.fn();
+
+    on(eventObject, listener);
+    expect(off(eventObject, listener)).toBe(true);
+    expect(size(eventObject)).toBe(0);
+
+    // Trying to remove the same listener again should return false
+    expect(off(eventObject, listener)).toBe(false);
+  });
+
+  it("should notify all listeners when some of them throw", () => {
+    const eventObject: any = {};
+    const listener1 = vi.fn(() => {
+      throw new Error("Listener 1 error");
+    });
+    const listener2 = vi.fn();
+
+    on(eventObject, listener1);
+    on(eventObject, listener2);
+
+    expect(() => send(eventObject, "test data")).toThrow("Listener 1 error");
+
+    expect(listener1).toBeCalledTimes(1);
+    expect(listener1).toBeCalledWith("test data");
+    expect(listener2).toBeCalledTimes(1);
+    expect(listener2).toBeCalledWith("test data");
+  });
+});