@pluv/client 0.8.1 → 0.9.1

package/.turbo/turbo-build.log

@@ -1,17 +1,18 @@
 
-> @pluv/client@0.8.1 build /home/runner/work/pluv/pluv/packages/client
+> @pluv/client@0.9.1 build /home/runner/work/pluv/pluv/packages/client
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
-CLI tsup v6.7.0
+CLI tsup v7.1.0
 CLI Target: es6
 ESM Build start
 CJS Build start
-ESM dist/index.mjs 35.08 KB
-ESM ⚡️ Build success in 90ms
-CJS dist/index.js 36.22 KB
-CJS ⚡️ Build success in 92ms
+ESM dist/index.mjs 39.02 KB
+ESM ⚡️ Build success in 135ms
+CJS dist/index.js 40.23 KB
+CJS ⚡️ Build success in 135ms
 DTS Build start
-DTS ⚡️ Build success in 3816ms
-DTS dist/index.d.ts 11.73 KB
+DTS ⚡️ Build success in 4784ms
+DTS dist/index.d.mts 12.92 KB
+DTS dist/index.d.ts  12.92 KB

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # @pluv/client
 
+## 0.9.1
+
+### Patch Changes
+
+- 8fba48b: fix including incorrect dependency
+- 8997c65: bumped dependencies
+- Updated dependencies [8fba48b]
+- Updated dependencies [8997c65]
+  - @pluv/crdt-yjs@0.4.1
+  - @pluv/types@0.2.2
+
+## 0.9.0
+
+### Minor Changes
+
+- 829d31b: Added support for defining persistant frontend storage for rooms via a new `addons` option on rooms.
+
+  This also introduces the first new addon `@pluv/addon-indexeddb`, which is more-or-less the equivalent to `y-indexeddb` which you can install like so:
+
+  ```
+  npm install @pluv/addon-indexeddb
+  ```
+
+  To use this new addon, simply pass it to options when creating a room:
+
+  ```ts
+  import { addonIndexedDB } from "@pluv/addon-indexeddb";
+  import { createClient } from "@pluv/client";
+
+  const client = createClient({
+    // ...
+  });
+
+  const room = client.createRoom("my-new-room", {
+    addons: [
+      // Define your addons in an array like so
+      addonIndexedDB(),
+    ],
+  });
+  ```
+
+  Or when using `@pluv/react`:
+
+  ```ts
+  const PluvRoom = createRoomBundle({
+    // ...
+    addons: [
+      // Define your addons in an array like so
+      addonIndexedDB(),
+    ],
+  });
+  ```
+
+### Patch Changes
+
+- 8d11672: bumped dependencies to latest
+- Updated dependencies [8d11672]
+- Updated dependencies [829d31b]
+  - @pluv/crdt-yjs@0.4.0
+  - @pluv/types@0.2.1
+
 ## 0.8.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -0,0 +1,273 @@
+import { InferYjsSharedTypeJson, array, map, object, text } from '@pluv/crdt-yjs';
+export { InferYjsSharedTypeJson } from '@pluv/crdt-yjs';
+import * as _pluv_types from '@pluv/types';
+import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, InferIOAuthorizeUser, InferIOAuthorize, InferIOInput, InputZodLike, InferIOAuthorizeRequired } from '@pluv/types';
+export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
+import { AbstractType } from 'yjs';
+export { AbstractType } from 'yjs';
+import { Subject } from 'wonka';
+
+type EventNotifierSubscriptionCallback<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+
+interface AuthorizationState<TIO extends IOLike> {
+    token: string | null;
+    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
+}
+declare enum ConnectionState {
+    Closed = "Closed",
+    Connecting = "Connecting",
+    Open = "Open",
+    Unavailable = "Unavailable",
+    Untouched = "Untouched"
+}
+interface WebSocketConnection {
+    count: number;
+    id: string | null;
+    state: ConnectionState;
+}
+interface WebSocketState<TIO extends IOLike> {
+    authorization: AuthorizationState<TIO>;
+    connection: WebSocketConnection;
+    webSocket: WebSocket | null;
+}
+interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+    connectionId: string;
+    presence: TPresence;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+}
+
+type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (value: Id<UserInfo<TIO>> | null) => void;
+
+interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
+    connection: Subject<Id<WebSocketState<TIO>>>;
+    "my-presence": Subject<TPresence | null>;
+    myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
+    others: Subject<readonly Id<UserInfo<TIO>>[]>;
+}
+type InferSubjectValue<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
+type SubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+
+declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+    readonly id: string;
+    constructor(room: string);
+    abstract broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    abstract event<TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>): () => void;
+    abstract getConnection(): WebSocketConnection;
+    abstract getMyPresence(): TPresence;
+    abstract getMyself(): Id<UserInfo<TIO, TPresence>> | null;
+    abstract getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
+    abstract getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
+    abstract getStorage<TKey extends keyof TStorage>(key: TKey): TStorage[TKey] | null;
+    abstract other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>): () => void;
+    abstract storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void): () => void;
+    abstract subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
+    abstract updateMyPresence(presence: Partial<TPresence>): void;
+}
+
+declare abstract class AbstractStorageStore {
+    room: string;
+    constructor(room: string);
+    abstract addUpdate(update: string): Promise<void>;
+    abstract destroy(): Promise<void>;
+    abstract flatten(encodedState: string): Promise<void>;
+    abstract getShouldFlatten(): Promise<boolean>;
+    abstract getUpdates(start?: number): Promise<readonly string[]>;
+    abstract initialize(): Promise<void>;
+}
+
+interface CrdtManagerOptions<TStorage extends Record<string, AbstractType<any>> = {}> {
+    encodedState?: string | Uint8Array | null;
+    initialStorage?: () => TStorage;
+}
+
+type UsersManagerConfig<TPresence extends JsonObject = {}> = {
+    initialPresence?: TPresence;
+    presence?: InputZodLike<TPresence>;
+};
+
+declare global {
+    var process: {
+        env: {
+            [key: string]: string | undefined;
+        };
+    };
+}
+type AuthEndpoint = string | ((room: string) => string | FetchOptions) | true;
+type WsEndpoint = string | ((room: string) => string);
+type FetchOptions = {
+    url: string;
+    options?: RequestInit;
+};
+type RoomEndpoints<TIO extends IOLike> = {
+    wsEndpoint?: WsEndpoint;
+} & (InferIOAuthorizeRequired<InferIOAuthorize<TIO>> extends true ? {
+    authEndpoint: AuthEndpoint;
+} : {
+    authEndpoint?: undefined;
+});
+type PluvRoomAddon<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
+interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+    room: PluvRoom<TIO, TPresence, TStorage>;
+}
+interface PluvRoomAddonResult {
+    storage: AbstractStorageStore;
+}
+type PluvRoomDebug<TIO extends IOLike> = Id<{
+    output: readonly (keyof InferIOOutput<TIO>)[];
+    input: readonly (keyof InferIOInput<TIO>)[];
+}>;
+type PluvRoomOptions<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = {
+    addons?: readonly PluvRoomAddon<TIO, TPresence, TStorage>[];
+    debug?: boolean | PluvRoomDebug<TIO>;
+    onAuthorizationFail?: (error: Error) => void;
+} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
+type RoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = RoomEndpoints<TIO> & PluvRoomOptions<TIO, TPresence, TStorage>;
+declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+    readonly _endpoints: RoomEndpoints<TIO>;
+    private _crdtManager;
+    private _crdtNotifier;
+    private _debug;
+    private _eventNotifier;
+    private _intervals;
+    private _listeners;
+    private _otherNotifier;
+    private _state;
+    private _stateNotifier;
+    private _storageStore;
+    private _subscriptions;
+    private _timeouts;
+    private _windowListeners;
+    private _wsListeners;
+    private _usersManager;
+    constructor(room: string, options: RoomConfig<TIO, TPresence, TStorage>);
+    get webSocket(): WebSocket | null;
+    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
+    getConnection(): WebSocketConnection;
+    getMyPresence: () => TPresence;
+    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
+    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
+    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
+    getStorage: <TKey extends keyof TStorage>(key: TKey) => TStorage[TKey] | null;
+    other: (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>) => (() => void);
+    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void) => (() => void);
+    subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
+    updateMyPresence: (presence: Partial<TPresence>) => void;
+    private _addToStorageStore;
+    private _applyStorageStore;
+    private _attachWindowListeners;
+    private _attachWsListeners;
+    private _clearInterval;
+    private _clearTimeout;
+    private _closeWs;
+    private _detachWindowListeners;
+    private _detachWsListeners;
+    private _emitSharedTypes;
+    private _flattenStorageStore;
+    private _getAddon;
+    private _getAuthFetchOptions;
+    private _getAuthorization;
+    private _getWsEndpoint;
+    private _handleExit;
+    private _handlePresenceUpdatedMessage;
+    private _handleReceiveOthers;
+    private _handleRegisteredMessage;
+    private _handleStorageReceivedMessage;
+    private _handleStorageUpdatedMessage;
+    private _handleUserJoinedMessage;
+    private _heartbeat;
+    private _logDebug;
+    private _observeCrdt;
+    private _onAuthorizationFail;
+    /**
+     * TODO
+     * @description Determine if ws was closed with a code for closing without retries.
+     * Otherwise, attempt to retry again with incremental backoff
+     * @author leedavidcs
+     * @date August 19, 2022
+     */
+    private _onClose;
+    /**
+     * TODO
+     * @description Handle websocket errors in a meaningful way, should they occur
+     * @author leedavidcs
+     * @date August 19, 2022
+     */
+    private _onError;
+    private _onMessage;
+    private _onOpen;
+    private _onNavigatorOnline;
+    private _onVisibilityChange;
+    private _parseMessage;
+    private _reconnect;
+    private _sendMessage;
+    private _updateState;
+}
+
+type PluvClientOptions<TIO extends IOLike> = RoomEndpoints<TIO> & {
+    debug?: boolean;
+};
+declare class PluvClient<TIO extends IOLike = IOLike> {
+    private _authEndpoint;
+    private _debug;
+    private _wsEndpoint;
+    private _rooms;
+    constructor(options: PluvClientOptions<TIO>);
+    createRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(room: string, options?: PluvRoomOptions<TIO, TPresence, TStorage>) => PluvRoom<TIO, TPresence, TStorage>;
+    enter: (room: string | PluvRoom<TIO, any, any>) => Promise<PluvRoom<TIO, JsonObject, any>>;
+    getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(room: string) => PluvRoom<TIO, TPresence, TStorage> | null;
+    getRooms: () => readonly PluvRoom<TIO, JsonObject, any>[];
+    leave: (room: string | PluvRoom<TIO, any, any>) => Promise<void>;
+    private _logDebug;
+}
+
+declare const createClient: <TIO extends IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}, {}, {}> = IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}, {}, {}>>(options: PluvClientOptions<TIO>) => PluvClient<TIO>;
+
+type MockedRoomEvents<TIO extends IOLike> = Partial<{
+    [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
+}>;
+type MockedRoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = {
+    events?: MockedRoomEvents<TIO>;
+} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
+declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+    private _crdtManager;
+    private _crdtNotifier;
+    private _eventNotifier;
+    private _events?;
+    private _otherNotifier;
+    private _state;
+    private _stateNotifier;
+    private _subscriptions;
+    private _usersManager;
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage>);
+    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
+    getConnection(): WebSocketConnection;
+    getMyPresence: () => TPresence;
+    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
+    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
+    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
+    getStorage: <TKey extends keyof TStorage>(key: TKey) => TStorage[TKey] | null;
+    other: (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>) => (() => void);
+    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void) => (() => void);
+    subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
+    updateMyPresence: (presence: Partial<TPresence>) => void;
+    private _observeCrdt;
+}
+
+declare const y_array: typeof array;
+declare const y_map: typeof map;
+declare const y_object: typeof object;
+declare const y_text: typeof text;
+declare namespace y {
+  export {
+    y_array as array,
+    y_map as map,
+    y_object as object,
+    y_text as text,
+  };
+}
+
+export { AbstractRoom, AbstractStorageStore, ConnectionState, MockedRoom, MockedRoomConfig, MockedRoomEvents, PluvClient, PluvClientOptions, PluvRoom, PluvRoomAddon, PluvRoomAddonInput, PluvRoomAddonResult, PluvRoomDebug, UserInfo, WebSocketConnection, WebSocketState, createClient, y };

package/dist/index.d.ts

@@ -64,6 +64,17 @@ declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonOb
     abstract updateMyPresence(presence: Partial<TPresence>): void;
 }
 
+declare abstract class AbstractStorageStore {
+    room: string;
+    constructor(room: string);
+    abstract addUpdate(update: string): Promise<void>;
+    abstract destroy(): Promise<void>;
+    abstract flatten(encodedState: string): Promise<void>;
+    abstract getShouldFlatten(): Promise<boolean>;
+    abstract getUpdates(start?: number): Promise<readonly string[]>;
+    abstract initialize(): Promise<void>;
+}
+
 interface CrdtManagerOptions<TStorage extends Record<string, AbstractType<any>> = {}> {
     encodedState?: string | Uint8Array | null;
     initialStorage?: () => TStorage;
@@ -94,11 +105,19 @@ type RoomEndpoints<TIO extends IOLike> = {
 } : {
     authEndpoint?: undefined;
 });
+type PluvRoomAddon<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
+interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+    room: PluvRoom<TIO, TPresence, TStorage>;
+}
+interface PluvRoomAddonResult {
+    storage: AbstractStorageStore;
+}
 type PluvRoomDebug<TIO extends IOLike> = Id<{
     output: readonly (keyof InferIOOutput<TIO>)[];
     input: readonly (keyof InferIOInput<TIO>)[];
 }>;
 type PluvRoomOptions<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = {
+    addons?: readonly PluvRoomAddon<TIO, TPresence, TStorage>[];
     debug?: boolean | PluvRoomDebug<TIO>;
     onAuthorizationFail?: (error: Error) => void;
 } & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
@@ -109,12 +128,12 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     private _crdtNotifier;
     private _debug;
     private _eventNotifier;
-    private _initialStorage;
     private _intervals;
     private _listeners;
     private _otherNotifier;
     private _state;
     private _stateNotifier;
+    private _storageStore;
     private _subscriptions;
     private _timeouts;
     private _windowListeners;
@@ -124,7 +143,7 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     get webSocket(): WebSocket | null;
     broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
     connect(): Promise<void>;
-    disconnect(): void;
+    disconnect(): Promise<void>;
     event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
     getConnection(): WebSocketConnection;
     getMyPresence: () => TPresence;
@@ -136,6 +155,8 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void) => (() => void);
     subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
     updateMyPresence: (presence: Partial<TPresence>) => void;
+    private _addToStorageStore;
+    private _applyStorageStore;
     private _attachWindowListeners;
     private _attachWsListeners;
     private _clearInterval;
@@ -143,8 +164,11 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     private _closeWs;
     private _detachWindowListeners;
     private _detachWsListeners;
-    private _getAuthorization;
+    private _emitSharedTypes;
+    private _flattenStorageStore;
+    private _getAddon;
     private _getAuthFetchOptions;
+    private _getAuthorization;
     private _getWsEndpoint;
     private _handleExit;
     private _handlePresenceUpdatedMessage;
@@ -195,7 +219,7 @@ declare class PluvClient<TIO extends IOLike = IOLike> {
     enter: (room: string | PluvRoom<TIO, any, any>) => Promise<PluvRoom<TIO, JsonObject, any>>;
     getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(room: string) => PluvRoom<TIO, TPresence, TStorage> | null;
     getRooms: () => readonly PluvRoom<TIO, JsonObject, any>[];
-    leave: (room: string | PluvRoom<TIO, any, any>) => void;
+    leave: (room: string | PluvRoom<TIO, any, any>) => Promise<void>;
     private _logDebug;
 }
 
@@ -246,4 +270,4 @@ declare namespace y {
   };
 }
 
-export { AbstractRoom, ConnectionState, MockedRoom, MockedRoomConfig, MockedRoomEvents, PluvClient, PluvClientOptions, PluvRoom, PluvRoomDebug, UserInfo, WebSocketConnection, WebSocketState, createClient, y };
+export { AbstractRoom, AbstractStorageStore, ConnectionState, MockedRoom, MockedRoomConfig, MockedRoomEvents, PluvClient, PluvClientOptions, PluvRoom, PluvRoomAddon, PluvRoomAddonInput, PluvRoomAddonResult, PluvRoomDebug, UserInfo, WebSocketConnection, WebSocketState, createClient, y };