@motiadev/stream-client-browser 0.5.2-beta.103 → 0.5.2-beta.104-330172

package/dist/index.d.ts

@@ -1,4 +1,2 @@
 export { Stream } from './src/stream';
-export { StreamItemSubscription } from './src/stream-item';
-export { StreamGroupSubscription } from './src/stream-group';
-export { StreamSubscription } from './src/stream-subscription';
+export { StreamItemSubscription, StreamGroupSubscription, StreamSubscription } from '@motiadev/stream-client';

package/dist/index.js

@@ -1,4 +1,2 @@
 export { Stream } from './src/stream';
-export { StreamItemSubscription } from './src/stream-item';
-export { StreamGroupSubscription } from './src/stream-group';
-export { StreamSubscription } from './src/stream-subscription';
+export { StreamItemSubscription, StreamGroupSubscription, StreamSubscription } from '@motiadev/stream-client';

package/dist/src/stream-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { SocketAdapter } from '@motiadev/stream-client';
+export declare class StreamSocketAdapter implements SocketAdapter {
+    private address;
+    private ws;
+    private onMessageListeners;
+    private onOpenListeners;
+    private onCloseListeners;
+    constructor(address: string);
+    connect(): void;
+    send(message: string): void;
+    onMessage(callback: (message: string) => void): void;
+    onOpen(callback: () => void): void;
+    onClose(callback: () => void): void;
+    close(): void;
+    isOpen(): boolean;
+}

package/dist/src/stream-adapter.js

@@ -0,0 +1,35 @@
+export class StreamSocketAdapter {
+    constructor(address) {
+        this.address = address;
+        this.onMessageListeners = [];
+        this.onOpenListeners = [];
+        this.onCloseListeners = [];
+        this.ws = new WebSocket(this.address);
+    }
+    connect() { }
+    send(message) {
+        this.ws.send(message);
+    }
+    onMessage(callback) {
+        const listener = (message) => callback(message.data);
+        this.ws.addEventListener('message', listener);
+        this.onMessageListeners.push(listener);
+    }
+    onOpen(callback) {
+        this.ws.addEventListener('open', callback);
+        this.onOpenListeners.push(callback);
+    }
+    onClose(callback) {
+        this.ws.addEventListener('close', callback);
+        this.onCloseListeners.push(callback);
+    }
+    close() {
+        this.ws.close();
+        this.onMessageListeners.forEach((listener) => this.ws.removeEventListener('message', listener));
+        this.onOpenListeners.forEach((listener) => this.ws.removeEventListener('open', listener));
+        this.onCloseListeners.forEach((listener) => this.ws.removeEventListener('close', listener));
+    }
+    isOpen() {
+        return this.ws.readyState === WebSocket.OPEN;
+    }
+}

package/dist/src/stream.d.ts

@@ -1,36 +1,4 @@
-import { StreamGroupSubscription } from './stream-group';
-import { StreamItemSubscription } from './stream-item';
-export declare class Stream {
-    private address;
-    private ws;
-    private listeners;
+import { Stream as StreamClient } from '@motiadev/stream-client';
+export declare class Stream extends StreamClient {
     constructor(address: string);
-    createSocket(): WebSocket;
-    /**
-     * Subscribe to an item in a stream.
-     *
-     * @argument streamName - The name of the stream to subscribe to.
-     * @argument groupId - The id of the group to subscribe to.
-     * @argument id - The id of the item to subscribe to.
-     */
-    subscribeItem<TData extends {
-        id: string;
-    }>(streamName: string, groupId: string, id: string): StreamItemSubscription<TData>;
-    /**
-     * Subscribe to a group in a stream.
-     *
-     * @argument streamName - The name of the stream to subscribe to.
-     * @argument groupId - The id of the group to subscribe to.
-     */
-    subscribeGroup<TData extends {
-        id: string;
-    }>(streamName: string, groupId: string, sortKey?: keyof TData): StreamGroupSubscription<TData>;
-    close(): void;
-    private onSocketClose;
-    private onSocketOpen;
-    messageListener(event: MessageEvent<string>): void;
-    private subscribe;
-    private join;
-    private leave;
-    private roomName;
 }

package/dist/src/stream.js

@@ -1,101 +1,7 @@
-import { v4 as uuidv4 } from 'uuid';
-import { StreamGroupSubscription } from './stream-group';
-import { StreamItemSubscription } from './stream-item';
-export class Stream {
+import { Stream as StreamClient } from '@motiadev/stream-client';
+import { StreamSocketAdapter } from './stream-adapter';
+export class Stream extends StreamClient {
     constructor(address) {
-        this.address = address;
-        this.listeners = {};
-        this.ws = this.createSocket();
-    }
-    createSocket() {
-        this.ws = new WebSocket(this.address);
-        this.ws.addEventListener('message', (message) => this.messageListener(message));
-        this.ws.addEventListener('open', () => this.onSocketOpen());
-        this.ws.addEventListener('close', () => this.onSocketClose());
-        return this.ws;
-    }
-    /**
-     * Subscribe to an item in a stream.
-     *
-     * @argument streamName - The name of the stream to subscribe to.
-     * @argument groupId - The id of the group to subscribe to.
-     * @argument id - The id of the item to subscribe to.
-     */
-    subscribeItem(streamName, groupId, id) {
-        const subscriptionId = uuidv4();
-        const sub = { streamName, groupId, id, subscriptionId };
-        const subscription = new StreamItemSubscription(sub);
-        this.subscribe(subscription);
-        return subscription;
-    }
-    /**
-     * Subscribe to a group in a stream.
-     *
-     * @argument streamName - The name of the stream to subscribe to.
-     * @argument groupId - The id of the group to subscribe to.
-     */
-    subscribeGroup(streamName, groupId, sortKey) {
-        const subscriptionId = uuidv4();
-        const sub = { streamName, groupId, subscriptionId };
-        const subscription = new StreamGroupSubscription(sub, sortKey);
-        this.subscribe(subscription);
-        return subscription;
-    }
-    close() {
-        this.listeners = {}; // clean up all listeners
-        this.ws.removeEventListener('message', this.messageListener);
-        this.ws.removeEventListener('open', this.onSocketOpen);
-        this.ws.removeEventListener('close', this.onSocketClose);
-        this.ws.close();
-    }
-    onSocketClose() {
-        // retry to connect
-        setTimeout(() => this.createSocket(), 2000);
-    }
-    onSocketOpen() {
-        Object.values(this.listeners).forEach((listeners) => {
-            listeners.forEach((subscription) => this.join(subscription));
-        });
-    }
-    messageListener(event) {
-        const message = JSON.parse(event.data);
-        const room = this.roomName(message);
-        this.listeners[room]?.forEach((listener) => listener.listener(message));
-        // we need to discard sync to group subs when it's an item event
-        if (message.id && message.event.type !== 'sync') {
-            const groupRoom = this.roomName({
-                streamName: message.streamName,
-                groupId: message.groupId,
-            });
-            this.listeners[groupRoom]?.forEach((listener) => listener.listener(message));
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    subscribe(subscription) {
-        const room = this.roomName(subscription.sub);
-        if (!this.listeners[room]) {
-            this.listeners[room] = new Set();
-        }
-        this.listeners[room].add(subscription);
-        this.join(subscription);
-        subscription.onClose(() => {
-            this.listeners[room]?.delete(subscription);
-            this.leave(subscription);
-        });
-    }
-    join(subscription) {
-        if (this.ws.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify({ type: 'join', data: subscription.sub }));
-        }
-    }
-    leave(subscription) {
-        if (this.ws.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify({ type: 'leave', data: subscription.sub }));
-        }
-    }
-    roomName(message) {
-        return message.id
-            ? `${message.streamName}:group:${message.groupId}:item:${message.id}`
-            : `${message.streamName}:group:${message.groupId}`;
+        super(() => new StreamSocketAdapter(address));
     }
 }

package/index.ts

@@ -1,4 +1,2 @@
 export { Stream } from './src/stream'
-export { StreamItemSubscription } from './src/stream-item'
-export { StreamGroupSubscription } from './src/stream-group'
-export { StreamSubscription } from './src/stream-subscription'
+export { StreamItemSubscription, StreamGroupSubscription, StreamSubscription } from '@motiadev/stream-client'

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@motiadev/stream-client-browser",
   "description": "Motia Stream Client Package – Responsible for managing streams of data.",
-  "version": "0.5.2-beta.103",
+  "version": "0.5.2-beta.104-330172",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "uuid": "^11.1.0"
+    "uuid": "^11.1.0",
+    "@motiadev/stream-client": "0.5.2-beta.104-330172"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
@@ -17,7 +18,6 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc",
-    "lint": "eslint --config ../../eslint.config.js",
-    "test": "jest"
+    "lint": "eslint --config ../../eslint.config.js"
   }
 }

package/dist/__tests__/stream-group.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/stream-group.spec.js

@@ -1,105 +0,0 @@
-import { StreamGroupSubscription } from '../src/stream-group';
-describe('StreamGroupSubscription', () => {
-    const joinMessage = {
-        streamName: 'test-stream',
-        groupId: 'test-group',
-        subscriptionId: 'sub-1',
-    };
-    function makeMessage(type, data, timestamp = Date.now()) {
-        return {
-            streamName: 'test-stream',
-            groupId: 'test-group',
-            timestamp,
-            event: { type, ...(type === 'event' ? { event: data } : { data }) },
-        };
-    }
-    it('notifies change listeners on state change', () => {
-        const sub = new StreamGroupSubscription(joinMessage);
-        const listener = jest.fn();
-        sub.addChangeListener(listener);
-        const syncData = [
-            { id: '1', name: 'A' },
-            { id: '2', name: 'B' },
-        ];
-        sub.listener(makeMessage('sync', syncData));
-        expect(listener).toHaveBeenCalledWith(syncData);
-    });
-    it('should be able to sort by a key', () => {
-        const sub = new StreamGroupSubscription(joinMessage, 'name');
-        const listener = jest.fn();
-        sub.addChangeListener(listener);
-        const syncData = [
-            { id: '1', name: 'B' },
-            { id: '2', name: 'A' },
-        ];
-        sub.listener(makeMessage('sync', syncData));
-        expect(listener).toHaveBeenCalledWith(syncData);
-        expect(sub.getState()).toEqual([
-            { id: '2', name: 'A' },
-            { id: '1', name: 'B' },
-        ]);
-    });
-    it('should discard old events', () => {
-        const sub = new StreamGroupSubscription(joinMessage);
-        const listener = jest.fn();
-        sub.addChangeListener(listener);
-        const syncData = [
-            { id: '1', name: 'A' },
-            { id: '2', name: 'B' },
-        ];
-        sub.listener(makeMessage('sync', syncData));
-        const oldSyncData = [
-            { id: '3', name: 'C' },
-            { id: '4', name: 'D' },
-        ];
-        sub.listener(makeMessage('sync', oldSyncData, Date.now() - 1000));
-        expect(sub.getState()).toEqual(syncData);
-    });
-    it('should add items', () => {
-        const sub = new StreamGroupSubscription(joinMessage);
-        const syncData = [
-            { id: '1', name: 'A' },
-            { id: '2', name: 'B' },
-        ];
-        sub.listener(makeMessage('sync', syncData));
-        sub.listener(makeMessage('create', { id: '3', name: 'C' }));
-        expect(sub.getState()).toEqual([...syncData, { id: '3', name: 'C' }]);
-    });
-    it('should update items', () => {
-        const sub = new StreamGroupSubscription(joinMessage);
-        const syncData = [
-            { id: '1', name: 'A' },
-            { id: '2', name: 'B' },
-        ];
-        sub.listener(makeMessage('sync', syncData));
-        sub.listener(makeMessage('update', { id: '1', name: 'A1' }));
-        expect(sub.getState()).toEqual([
-            { id: '1', name: 'A1' },
-            { id: '2', name: 'B' },
-        ]);
-    });
-    it('should remove items', () => {
-        const sub = new StreamGroupSubscription(joinMessage);
-        const syncData = [
-            { id: '1', name: 'A' },
-            { id: '2', name: 'B' },
-        ];
-        sub.listener(makeMessage('sync', syncData));
-        sub.listener(makeMessage('delete', { id: '1' }));
-        expect(sub.getState()).toEqual([{ id: '2', name: 'B' }]);
-    });
-    it('should discard old on event on a particular item', () => {
-        const sub = new StreamGroupSubscription(joinMessage);
-        const syncData = [
-            { id: '1', name: 'A' },
-            { id: '2', name: 'B' },
-        ];
-        sub.listener(makeMessage('sync', syncData));
-        sub.listener(makeMessage('update', { id: '1', name: 'A1' }));
-        sub.listener(makeMessage('update', { id: '1', name: 'A2' }, Date.now() - 1000));
-        expect(sub.getState()).toEqual([
-            { id: '1', name: 'A1' },
-            { id: '2', name: 'B' },
-        ]);
-    });
-});

package/dist/__tests__/stream-item.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/stream-item.spec.js

@@ -1,46 +0,0 @@
-import { StreamItemSubscription } from '../src/stream-item';
-describe('StreamItemSubscription', () => {
-    const joinMessage = {
-        streamName: 'test-stream',
-        groupId: 'test-group',
-        subscriptionId: 'sub-1',
-    };
-    function makeMessage(type, data, timestamp = Date.now()) {
-        return {
-            streamName: 'test-stream',
-            groupId: 'test-group',
-            timestamp,
-            event: { type, ...(type === 'event' ? { event: data } : { data }) },
-        };
-    }
-    it('notifies change listeners on state change', () => {
-        const sub = new StreamItemSubscription(joinMessage);
-        const listener = jest.fn();
-        sub.addChangeListener(listener);
-        const syncData = { id: '1', name: 'A', value: 1 };
-        sub.listener(makeMessage('sync', syncData));
-        expect(listener).toHaveBeenCalledWith(syncData);
-    });
-    it('should discard old events', () => {
-        const sub = new StreamItemSubscription(joinMessage);
-        const syncData = { id: '1', name: 'A', value: 1 };
-        const oldSyncData = { id: '1', name: 'B', value: 3 };
-        sub.listener(makeMessage('sync', syncData));
-        sub.listener(makeMessage('sync', oldSyncData, Date.now() - 1000));
-        expect(sub.getState()).toEqual(syncData);
-    });
-    it('should update item', () => {
-        const sub = new StreamItemSubscription(joinMessage);
-        const syncData = { id: '1', name: 'A', value: 1 };
-        sub.listener(makeMessage('sync', syncData));
-        sub.listener(makeMessage('update', { id: '1', name: 'A1', value: 2 }, Date.now() + 1000));
-        expect(sub.getState()).toEqual({ id: '1', name: 'A1', value: 2 });
-    });
-    it('should remove item', () => {
-        const sub = new StreamItemSubscription(joinMessage);
-        const syncData = { id: '1', name: 'A', value: 1 };
-        sub.listener(makeMessage('sync', syncData));
-        sub.listener(makeMessage('delete', { id: '1' }, Date.now() + 1000));
-        expect(sub.getState()).toEqual(null);
-    });
-});

package/dist/__tests__/stream.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/stream.spec.js

@@ -1,68 +0,0 @@
-import { Stream } from '../src/stream';
-class MockSocket {
-    constructor() {
-        this.listeners = {};
-    }
-    addEventListener(event, cb) {
-        if (!this.listeners[event])
-            this.listeners[event] = [];
-        this.listeners[event].push(cb);
-    }
-    send(data) {
-        this.listeners['message']?.forEach((cb) => cb({ data: JSON.stringify(data) }));
-    }
-    close() {
-        this.listeners = {};
-    }
-}
-function getSocket(stream) {
-    return stream.ws;
-}
-function makeGroupMessage(type, data, timestamp = Date.now()) {
-    return {
-        streamName: 'test-stream',
-        groupId: 'test-group',
-        timestamp,
-        event: { type, ...(type === 'event' ? { event: data } : { data }) },
-    };
-}
-function makeItemMessage(type, data, timestamp = Date.now()) {
-    return {
-        streamName: 'test-stream',
-        groupId: 'test-group',
-        id: '1',
-        timestamp,
-        event: { type, ...(type === 'event' ? { event: data } : { data }) },
-    };
-}
-describe('Stream', () => {
-    beforeEach(() => {
-        global.WebSocket = MockSocket;
-    });
-    afterEach(() => {
-        delete global.WebSocket;
-    });
-    it('should sync group events', () => {
-        const stream = new Stream('ws://localhost:3000');
-        const socket = getSocket(stream);
-        const sub = stream.subscribeGroup('test-stream', 'test-group');
-        const syncData = [
-            { id: '1', name: 'A' },
-            { id: '2', name: 'B' },
-        ];
-        socket.send(makeGroupMessage('sync', syncData));
-        expect(sub.getState()).toEqual(syncData);
-    });
-    it('should not sync item events in group subscriptions', () => {
-        const stream = new Stream('ws://localhost:3000');
-        const socket = getSocket(stream);
-        const sub = stream.subscribeGroup('test-stream', 'test-group');
-        const syncData = [
-            { id: '1', name: 'A' },
-            { id: '2', name: 'B' },
-        ];
-        socket.send(makeGroupMessage('sync', syncData));
-        socket.send(makeItemMessage('sync', syncData[0]));
-        expect(sub.getState()).toEqual(syncData);
-    });
-});

package/dist/src/stream-group.d.ts

@@ -1,13 +0,0 @@
-import { StreamSubscription } from './stream-subscription';
-import { GroupEventMessage, JoinMessage } from './stream.types';
-export declare class StreamGroupSubscription<TData extends {
-    id: string;
-}> extends StreamSubscription<TData[], GroupEventMessage<TData>> {
-    private sortKey?;
-    private lastTimestamp;
-    private lastTimestampMap;
-    constructor(sub: JoinMessage, sortKey?: keyof TData | undefined);
-    private sort;
-    protected setState(state: TData[]): void;
-    listener(message: GroupEventMessage<TData>): void;
-}

package/dist/src/stream-group.js

@@ -1,65 +0,0 @@
-import { StreamSubscription } from './stream-subscription';
-export class StreamGroupSubscription extends StreamSubscription {
-    constructor(sub, sortKey) {
-        super(sub, []);
-        this.sortKey = sortKey;
-        this.lastTimestamp = 0;
-        this.lastTimestampMap = new Map();
-    }
-    sort(state) {
-        const sortKey = this.sortKey;
-        if (sortKey) {
-            return state.sort((a, b) => {
-                const aValue = a[sortKey];
-                const bValue = b[sortKey];
-                if (aValue && bValue) {
-                    return aValue.toString().localeCompare(bValue.toString());
-                }
-                return 0;
-            });
-        }
-        return state;
-    }
-    setState(state) {
-        super.setState(this.sort(state));
-    }
-    listener(message) {
-        if (message.event.type === 'sync') {
-            if (message.timestamp < this.lastTimestamp) {
-                return;
-            }
-            this.lastTimestampMap = new Map();
-            this.lastTimestamp = message.timestamp;
-            this.setState(message.event.data);
-        }
-        else if (message.event.type === 'create') {
-            const id = message.event.data.id;
-            const state = this.getState();
-            if (!state.find((item) => item.id === id)) {
-                this.setState([...state, message.event.data]);
-            }
-        }
-        else if (message.event.type === 'update') {
-            const messageData = message.event.data;
-            const messageDataId = messageData.id;
-            const state = this.getState();
-            const currentItemTimestamp = this.lastTimestampMap.get(messageDataId);
-            if (currentItemTimestamp && currentItemTimestamp >= message.timestamp) {
-                return;
-            }
-            this.lastTimestamp = message.timestamp;
-            this.lastTimestampMap.set(messageDataId, message.timestamp);
-            this.setState(state.map((item) => (item.id === messageDataId ? messageData : item)));
-        }
-        else if (message.event.type === 'delete') {
-            const messageDataId = message.event.data.id;
-            const state = this.getState();
-            this.lastTimestamp = message.timestamp;
-            this.lastTimestampMap.set(messageDataId, message.timestamp);
-            this.setState(state.filter((item) => item.id !== messageDataId));
-        }
-        else if (message.event.type === 'event') {
-            this.onEventReceived(message.event.event);
-        }
-    }
-}

package/dist/src/stream-item.d.ts

@@ -1,9 +0,0 @@
-import { StreamSubscription } from './stream-subscription';
-import { ItemEventMessage, JoinMessage } from './stream.types';
-export declare class StreamItemSubscription<TData extends {
-    id: string;
-}> extends StreamSubscription<TData | null, ItemEventMessage<TData>> {
-    private lastEventTimestamp;
-    constructor(sub: JoinMessage);
-    listener(message: ItemEventMessage<TData>): void;
-}

package/dist/src/stream-item.js

@@ -1,22 +0,0 @@
-import { StreamSubscription } from './stream-subscription';
-export class StreamItemSubscription extends StreamSubscription {
-    constructor(sub) {
-        super(sub, null);
-        this.lastEventTimestamp = 0;
-    }
-    listener(message) {
-        if (message.timestamp <= this.lastEventTimestamp) {
-            return;
-        }
-        this.lastEventTimestamp = message.timestamp;
-        if (message.event.type === 'sync' || message.event.type === 'create' || message.event.type === 'update') {
-            this.setState(message.event.data);
-        }
-        else if (message.event.type === 'delete') {
-            this.setState(null);
-        }
-        else if (message.event.type === 'event') {
-            this.onEventReceived(message.event.event);
-        }
-    }
-}

package/dist/src/stream-subscription.d.ts

@@ -1,36 +0,0 @@
-import { CustomEvent, JoinMessage, Listener } from './stream.types';
-type CustomEventListener = (event: any) => void;
-export declare abstract class StreamSubscription<TData = unknown, TEventData = unknown> {
-    private customEventListeners;
-    private closeListeners;
-    private onChangeListeners;
-    private state;
-    readonly sub: JoinMessage;
-    constructor(sub: JoinMessage, state: TData);
-    abstract listener(message: TEventData): void;
-    protected onEventReceived(event: CustomEvent): void;
-    /**
-     * Add a custom event listener. This listener will be called whenever the custom event is received.
-     */
-    onEvent(type: string, listener: CustomEventListener): void;
-    /**
-     * Remove a custom event listener.
-     */
-    offEvent(type: string, listener: CustomEventListener): void;
-    onClose(listener: () => void): void;
-    close(): void;
-    /**
-     * Add a change listener. This listener will be called whenever the state of the group changes.
-     */
-    addChangeListener(listener: Listener<TData>): void;
-    /**
-     * Remove a change listener.
-     */
-    removeChangeListener(listener: Listener<TData>): void;
-    /**
-     * Get the current state of the group.
-     */
-    getState(): TData;
-    protected setState(state: TData): void;
-}
-export {};

package/dist/src/stream-subscription.js

@@ -1,59 +0,0 @@
-export class StreamSubscription {
-    constructor(sub, state) {
-        this.customEventListeners = new Map();
-        this.closeListeners = new Set();
-        this.onChangeListeners = new Set();
-        this.sub = sub;
-        this.state = state;
-    }
-    onEventReceived(event) {
-        const customEventListeners = this.customEventListeners.get(event.type);
-        if (customEventListeners) {
-            const eventData = event.data;
-            customEventListeners.forEach((listener) => listener(eventData));
-        }
-    }
-    /**
-     * Add a custom event listener. This listener will be called whenever the custom event is received.
-     */
-    onEvent(type, listener) {
-        const listeners = this.customEventListeners.get(type) || [];
-        this.customEventListeners.set(type, [...listeners, listener]);
-    }
-    /**
-     * Remove a custom event listener.
-     */
-    offEvent(type, listener) {
-        const listeners = this.customEventListeners.get(type) || [];
-        this.customEventListeners.set(type, listeners.filter((l) => l !== listener));
-    }
-    onClose(listener) {
-        this.closeListeners.add(listener);
-    }
-    close() {
-        this.closeListeners.forEach((listener) => listener());
-        this.closeListeners.clear();
-    }
-    /**
-     * Add a change listener. This listener will be called whenever the state of the group changes.
-     */
-    addChangeListener(listener) {
-        this.onChangeListeners.add(listener);
-    }
-    /**
-     * Remove a change listener.
-     */
-    removeChangeListener(listener) {
-        this.onChangeListeners.delete(listener);
-    }
-    /**
-     * Get the current state of the group.
-     */
-    getState() {
-        return this.state;
-    }
-    setState(state) {
-        this.state = state;
-        this.onChangeListeners.forEach((listener) => listener(state));
-    }
-}

package/dist/src/stream.types.d.ts

@@ -1,56 +0,0 @@
-export type BaseMessage = {
-    streamName: string;
-    groupId: string;
-    id?: string;
-    timestamp: number;
-};
-export type JoinMessage = Omit<BaseMessage, 'timestamp'> & {
-    subscriptionId: string;
-};
-export type CustomEvent = {
-    type: string;
-    data: any;
-};
-export type StreamEvent<TData extends {
-    id: string;
-}> = {
-    type: 'create';
-    data: TData;
-} | {
-    type: 'update';
-    data: TData;
-} | {
-    type: 'delete';
-    data: TData;
-} | {
-    type: 'event';
-    event: CustomEvent;
-};
-export type ItemStreamEvent<TData extends {
-    id: string;
-}> = StreamEvent<TData> | {
-    type: 'sync';
-    data: TData;
-};
-export type GroupStreamEvent<TData extends {
-    id: string;
-}> = StreamEvent<TData> | {
-    type: 'sync';
-    data: TData[];
-};
-export type ItemEventMessage<TData extends {
-    id: string;
-}> = BaseMessage & {
-    event: ItemStreamEvent<TData>;
-};
-export type GroupEventMessage<TData extends {
-    id: string;
-}> = BaseMessage & {
-    event: GroupStreamEvent<TData>;
-};
-export type Message = {
-    type: 'join' | 'leave';
-    data: JoinMessage;
-};
-export type Listener<TData> = (state: TData | null) => void;
-export type CustomEventListener<TData> = (event: TData) => void;

package/dist/src/stream.types.js

@@ -1 +0,0 @@
-export {};