@eleven-am/pondsocket 0.1.55 → 0.1.57

package/src/subjects/subject.test.ts

@@ -0,0 +1,163 @@
+import { Subject, BehaviorSubject, SimpleSubject, SimpleBehaviorSubject } from './subject';
+
+describe('Subject', () => {
+    let testSubject: Subject<number>;
+    let observer1: jest.Mock;
+    let observer2: jest.Mock;
+
+    beforeEach(() => {
+        testSubject = new Subject<number>();
+        observer1 = jest.fn();
+        observer2 = jest.fn();
+        testSubject.subscribeWith('observer1', observer1);
+        testSubject.subscribeWith('observer2', observer2);
+    });
+
+    afterEach(() => {
+        testSubject.unsubscribe('observer1');
+        testSubject.unsubscribe('observer2');
+    });
+
+    it('should notify all subscribers when next is called', () => {
+        const message = 10;
+
+        testSubject.publish(message);
+        expect(observer1).toHaveBeenCalledWith(message);
+        expect(observer2).toHaveBeenCalledWith(message);
+    });
+
+    it('should unsubscribe an observer when unsubscribe is called', () => {
+        const identifier = 'observer1';
+
+        testSubject.unsubscribe(identifier);
+        expect(testSubject.has(identifier)).toBe(false);
+    });
+});
+
+describe('BehaviorSubject', () => {
+    let testSubject: BehaviorSubject<number>;
+    let observer1: jest.Mock;
+    let observer2: jest.Mock;
+
+    beforeEach(() => {
+        testSubject = new BehaviorSubject<number>();
+        observer1 = jest.fn();
+        observer2 = jest.fn();
+        testSubject.subscribeWith('observer1', observer1);
+        testSubject.subscribeWith('observer2', observer2);
+    });
+
+    afterEach(() => {
+        testSubject.unsubscribe('observer1');
+        testSubject.unsubscribe('observer2');
+    });
+
+    it('should notify all subscribers when next is called', () => {
+        const message = 10;
+
+        testSubject.publish(message);
+        expect(observer1).toHaveBeenCalledWith(message);
+        expect(observer2).toHaveBeenCalledWith(message);
+    });
+
+    it('should unsubscribe an observer when unsubscribe is called', () => {
+        const identifier = 'observer1';
+
+        testSubject.unsubscribe(identifier);
+        expect(testSubject.has(identifier)).toBe(false);
+    });
+
+    it('should notify new subscribers with the last message when subscribe is called', () => {
+        const message = 10;
+
+        testSubject.publish(message);
+        const newObserver: jest.Mock = jest.fn();
+
+        testSubject.subscribeWith('newObserver', newObserver);
+        expect(newObserver).toHaveBeenCalledWith(message);
+    });
+});
+
+describe('SimpleSubject', () => {
+    let testSubject: SimpleSubject<number>;
+    let observer1: jest.Mock;
+    let observer2: jest.Mock;
+
+    beforeEach(() => {
+        testSubject = new SimpleSubject<number>();
+        observer1 = jest.fn();
+        observer2 = jest.fn();
+        testSubject.subscribe(observer1);
+        testSubject.subscribe(observer2);
+    });
+
+    afterEach(() => {
+        testSubject.publish(0);
+    });
+
+    it('should notify all subscribers when publish is called', () => {
+        const message = 10;
+
+        testSubject.publish(message);
+        expect(observer1).toHaveBeenCalledWith(message);
+        expect(observer2).toHaveBeenCalledWith(message);
+    });
+
+    it('should unsubscribe an observer when unsubscribe is called', () => {
+        const unsubscribe = testSubject.subscribe(observer1);
+
+        unsubscribe();
+        expect(testSubject.size).toBe(1);
+    });
+});
+
+describe('SimpleBehaviorSubject', () => {
+    let testSubject: SimpleBehaviorSubject<number>;
+    let observer1: jest.Mock;
+    let observer2: jest.Mock;
+
+    beforeEach(() => {
+        testSubject = new SimpleBehaviorSubject<number>(0);
+        observer1 = jest.fn();
+        observer2 = jest.fn();
+        testSubject.subscribe(observer1);
+        testSubject.subscribe(observer2);
+    });
+
+    afterEach(() => {
+        testSubject.publish(0);
+    });
+
+    it('should notify all subscribers when publish is called', () => {
+        const message = 10;
+
+        testSubject.publish(message);
+        expect(observer1).toHaveBeenCalledWith(message);
+        expect(observer2).toHaveBeenCalledWith(message);
+    });
+
+    it('should unsubscribe an observer when unsubscribe is called', () => {
+        const unsubscribe = testSubject.subscribe(observer1);
+
+        unsubscribe();
+        expect(testSubject.size).toBe(1);
+    });
+
+    it('should notify new subscribers with the last message when subscribe is called', () => {
+        const message = 10;
+
+        testSubject.publish(message);
+        const newObserver: jest.Mock = jest.fn();
+
+        testSubject.subscribe(newObserver);
+        expect(newObserver).toHaveBeenCalledWith(message);
+    });
+
+    it('should return the last message when value is called', () => {
+        const message = 10;
+
+        testSubject.publish(message);
+        expect(testSubject.value).toBe(message);
+    });
+});
+

package/src/subjects/subject.ts

@@ -0,0 +1,137 @@
+// eslint-disable-next-line import/no-unresolved
+import { Unsubscribe } from '../types';
+
+type Subscriber<T> = (message: T) => void;
+
+export class SimpleSubject<T> {
+    readonly #observers: Set<Subscriber<T>>;
+
+    constructor () {
+        this.#observers = new Set<Subscriber<T>>();
+    }
+
+    /**
+     * @desc Subscribes to a subject
+     * @param observer - The observer to subscribe
+     */
+    subscribe (observer: Subscriber<T>): Unsubscribe {
+        this.#observers.add(observer);
+
+        return () => this.#observers.delete(observer);
+    }
+
+    /**
+     * @desc Publishes a message to all subscribers
+     * @param message - The message to publish
+     */
+    publish (message: T) {
+        this.#observers.forEach((observer) => observer(message));
+    }
+
+    /**
+     * @desc Returns the number of subscribers
+     */
+    get size () {
+        return this.#observers.size;
+    }
+}
+
+export class SimpleBehaviorSubject<T> extends SimpleSubject<T> {
+    #lastMessage: T | undefined;
+
+    constructor (initialValue?: T) {
+        super();
+
+        this.#lastMessage = initialValue;
+    }
+
+    /**
+     * @desc Returns the last message published
+     */
+    public get value () {
+        return this.#lastMessage;
+    }
+
+    /**
+     * @desc Publishes a message to all subscribers
+     * @param message - The message to publish
+     */
+    publish (message: T) {
+        this.#lastMessage = message;
+        super.publish(message);
+    }
+
+    /**
+     * @desc Subscribes to a subject
+     * @param observer - The observer to subscribe
+     */
+    subscribe (observer: Subscriber<T>): Unsubscribe {
+        if (this.#lastMessage) {
+            observer(this.#lastMessage);
+        }
+
+        return super.subscribe(observer);
+    }
+}
+
+export class Subject<T> extends SimpleSubject<T> {
+    readonly #subscriptions: Record<string, Unsubscribe> = {};
+
+    /**
+     * @desc Subscribes to a subject
+     * @param identifier - The identifier of the subscription
+     * @param observer - The observer to subscribe
+     */
+    subscribeWith (identifier: string, observer: Subscriber<T>): void {
+        this.#subscriptions[identifier] = super.subscribe(observer);
+    }
+
+    /**
+     * @desc Unsubscribes from a subject
+     * @param identifier - The identifier of the subscription
+     */
+    unsubscribe (identifier: string) {
+        this.#subscriptions[identifier]?.();
+        delete this.#subscriptions[identifier];
+    }
+
+    /**
+     * @desc Checks if a subscription exists
+     * @param identifier - The identifier of the subscription
+     */
+    has (identifier: string) {
+        return Boolean(this.#subscriptions[identifier]);
+    }
+}
+
+export class BehaviorSubject<T> extends Subject<T> {
+    #lastMessage: T | undefined;
+
+    constructor (initialValue?: T) {
+        super();
+
+        this.#lastMessage = initialValue;
+    }
+
+    /**
+     * @desc Subscribes to a subject
+     * @param identifier - The identifier of the subscription
+     * @param observer - The observer to subscribe
+     */
+    subscribeWith (identifier: string, observer: Subscriber<T>): void {
+        if (this.#lastMessage) {
+            observer(this.#lastMessage);
+        }
+
+        super.subscribeWith(identifier, observer);
+    }
+
+    /**
+     * @desc Publishes a message to all subscribers
+     * @param message - The message to publish
+     */
+    publish (message: T) {
+        this.#lastMessage = message;
+        super.publish(message);
+    }
+}