@pluv/client 2.3.1 → 3.1.0

package/src/PluvClient.ts

@@ -1,10 +1,5 @@
-import type {
-    AbstractCrdtDocFactory,
-    CrdtType,
-    InferStorage,
-    NoopCrdtDocFactory,
-} from "@pluv/crdt";
-import type { InputZodLike, IOLike, JsonObject } from "@pluv/types";
+import type { AbstractCrdtDocFactory, InferStorage, NoopCrdtDocFactory } from "@pluv/crdt";
+import type { InferIOCrdtKind, InputZodLike, IOLike, JsonObject } from "@pluv/types";
 import { MAX_PRESENCE_SIZE_BYTES } from "./constants";
 import type { InferCallback } from "./infer";
 import { PluvProcedure } from "./PluvProcedure";
@@ -23,13 +18,12 @@ import { PluvRouter } from "./PluvRouter";
 import type { PluvClientLimits, PublicKey, WithMetadata } from "./types";
 
 export type PluvClientOptions<
-    TIO extends IOLike<any, any>,
+    TIO extends IOLike<any, any, any>,
     TPresence extends Record<string, any>,
-    TCrdt extends AbstractCrdtDocFactory<any, any>,
+    TCrdt extends InferIOCrdtKind<TIO>,
     TMetadata extends JsonObject,
 > = RoomEndpoints<TIO, TMetadata> & {
     debug?: boolean;
-    initialStorage?: TCrdt;
     /**
      * @description Configurable limits defined for client-side validation. You should only set
      * this if you control the server and have changed the limits there.
@@ -39,10 +33,12 @@ export type PluvClientOptions<
     presence?: InputZodLike<TPresence>;
     publicKey?: PublicKey<TMetadata>;
     types: InferCallback<TIO>;
-};
+} & (InferIOCrdtKind<TIO> extends NoopCrdtDocFactory
+        ? { initialStorage?: "[ERROR]: Must provide crdt to createIO to use storage" }
+        : { initialStorage?: TCrdt });
 
 export type CreateRoomOptions<
-    TIO extends IOLike<any, any>,
+    TIO extends IOLike<any, any, any>,
     TPresence extends Record<string, any>,
     TCrdt extends AbstractCrdtDocFactory<any, any>,
     TMetadata extends JsonObject,
@@ -62,9 +58,9 @@ export type EnterRoomParams<TMetadata extends JsonObject = {}> = keyof TMetadata
     : [WithMetadata<TMetadata>];
 
 export class PluvClient<
-    TIO extends IOLike<any, any>,
+    TIO extends IOLike<any, any, any>,
     TPresence extends Record<string, any> = {},
-    TCrdt extends AbstractCrdtDocFactory<any, any> = NoopCrdtDocFactory,
+    TCrdt extends InferIOCrdtKind<TIO> = InferIOCrdtKind<TIO>,
     TMetadata extends JsonObject = {},
 > {
     public readonly metadata?: InputZodLike<TMetadata>;
@@ -104,7 +100,7 @@ export class PluvClient<
 
         this._authEndpoint = authEndpoint as AuthEndpoint<TMetadata>;
         this._debug = debug;
-        this._initialStorage = initialStorage;
+        this._initialStorage = initialStorage as TCrdt;
         this._limits = {
             presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
             ...limits,

package/src/PluvRoom.ts

@@ -134,7 +134,7 @@ export type WsEndpoint<TMetadata extends JsonObject> =
 
 type FetchOptions = { url: string; options?: RequestInit };
 
-export type RoomEndpoints<TIO extends IOLike<any, any>, TMetadata extends JsonObject> = {
+export type RoomEndpoints<TIO extends IOLike<any, any, any>, TMetadata extends JsonObject> = {
     wsEndpoint?: WsEndpoint<TMetadata>;
 } & (InferIOAuthorizeUser<InferIOAuthorize<TIO>> extends BaseUser
     ? { authEndpoint: AuthEndpoint<TMetadata> }
@@ -204,7 +204,7 @@ export type RoomConfig<
 >;
 
 export class PluvRoom<
-    TIO extends IOLike<any, any>,
+    TIO extends IOLike<any, any, any>,
     TMetadata extends JsonObject = {},
     TPresence extends Record<string, any> = {},
     TCrdt extends AbstractCrdtDocFactory<any, any> = NoopCrdtDocFactory,
@@ -311,13 +311,6 @@ export class PluvRoom<
         this._crdtManager = new CrdtManager<TCrdt>({ initialStorage });
     }
 
-    /**
-     * @deprecated To be removed in v3. Use `getStorageLoaded` instead.
-     */
-    public get storageLoaded(): boolean {
-        return this.getStorageLoaded();
-    }
-
     public get webSocket(): WebSocket | null {
         return this._state.webSocket;
     }
@@ -493,23 +486,6 @@ export class PluvRoom<
         this._stateNotifier.subjects["my-presence"].next(null);
     }
 
-    /**
-     * @deprecated To be removed in v3. Use PluvRoom.subscribe.event instead
-     */
-    public event = new Proxy(
-        <TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
-            event: TEvent,
-            callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
-        ): (() => void) => this._eventNotifier.subscribe(event, callback),
-        {
-            get(fn, prop) {
-                return (
-                    callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
-                ): (() => void) => fn(prop as any, callback);
-            },
-        },
-    ) as EventProxy<TIO, TEvents>;
-
     public getConnection = (): WebSocketConnection => {
         // Create a read-only clone of the connection state
         return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
@@ -567,61 +543,10 @@ export class PluvRoom<
         );
     };
 
-    /**
-     * @deprecated To be removed in v3. Use PluvRoom.subscribe.other instead
-     */
-    public other = (
-        connectionId: string,
-        callback: OtherSubscriptionCallback<TIO, TPresence>,
-    ): (() => void) => {
-        const clientId = this._usersManager.getClientId(connectionId);
-
-        if (!clientId) return () => undefined;
-
-        return this._usersNotifier.subscribeOther(clientId, callback);
-    };
-
     public redo = (): void => {
         this._crdtManager.doc.redo();
     };
 
-    /**
-     * @deprecated To be removed in v3. Use PluvRoom.subscribe.storage instead
-     */
-    public storage = new Proxy(
-        <TKey extends keyof InferStorage<TCrdt>>(
-            key: TKey,
-            callback: StorageSubscriptionCallback<InferStorage<TCrdt>, TKey>,
-        ): (() => void) => this._crdtNotifier.subscribe(key, callback),
-        {
-            get: (fn, prop) => {
-                type _Storage = InferStorage<TCrdt>;
-
-                if (!!prop) {
-                    return (callback: StorageRootSubscriptionCallback<_Storage>) => {
-                        return this._crdtNotifier.subcribeRoot(callback);
-                    };
-                }
-
-                return (callback: StorageSubscriptionCallback<_Storage, keyof _Storage>) => {
-                    return fn(prop as keyof InferStorage<TCrdt>, callback);
-                };
-            },
-        },
-    ) as StorageProxy<InferStorage<TCrdt>>;
-
-    /**
-     * @deprecated To be removed in v3. Use PluvRoom.subscribe.storage instead
-     * @description Subscribes to the root storage object (serialized)
-     */
-    public storageRoot = (
-        callback: (value: {
-            [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
-        }) => void,
-    ): (() => void) => {
-        return this._crdtNotifier.subcribeRoot(callback);
-    };
-
     public subscribe = new Proxy(
         <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
             name: TSubject,
@@ -659,9 +584,9 @@ export class PluvRoom<
                     };
                 }
 
-                if (prop === "event") return this.event;
-                if (prop === "other") return this.other;
-                if (prop === "storage") return this.storage;
+                if (prop === "event") return this._event;
+                if (prop === "other") return this._other;
+                if (prop === "storage") return this._storage;
             },
         },
     ) as SubscribeProxy<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
@@ -816,6 +741,20 @@ export class PluvRoom<
         this._crdtNotifier.rootSubject.next(storageRoot);
     }
 
+    private _event = new Proxy(
+        <TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
+            event: TEvent,
+            callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
+        ): (() => void) => this._eventNotifier.subscribe(event, callback),
+        {
+            get(fn, prop) {
+                return (
+                    callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
+                ): (() => void) => fn(prop as any, callback);
+            },
+        },
+    ) as EventProxy<TIO, TEvents>;
+
     private _flattenStorageStore = debounce(
         async (): Promise<void> => {
             const shouldFlatten = await this._storageStore.getShouldFlatten();
@@ -1497,6 +1436,17 @@ export class PluvRoom<
         return await this._onVisibilityChange();
     }
 
+    private _other = (
+        connectionId: string,
+        callback: OtherSubscriptionCallback<TIO, TPresence>,
+    ): (() => void) => {
+        const clientId = this._usersManager.getClientId(connectionId);
+
+        if (!clientId) return () => undefined;
+
+        return this._usersNotifier.subscribeOther(clientId, callback);
+    };
+
     private _parseMessage(message: { data: string | ArrayBuffer }): IOEventMessage<TIO> | null {
         /**
          * !HACK
@@ -1597,6 +1547,28 @@ export class PluvRoom<
         return parsed;
     }
 
+    private _storage = new Proxy(
+        <TKey extends keyof InferStorage<TCrdt>>(
+            key: TKey,
+            callback: StorageSubscriptionCallback<InferStorage<TCrdt>, TKey>,
+        ): (() => void) => this._crdtNotifier.subscribe(key, callback),
+        {
+            get: (fn, prop) => {
+                type _Storage = InferStorage<TCrdt>;
+
+                if (!!prop) {
+                    return (callback: StorageRootSubscriptionCallback<_Storage>) => {
+                        return this._crdtNotifier.subcribeRoot(callback);
+                    };
+                }
+
+                return (callback: StorageSubscriptionCallback<_Storage, keyof _Storage>) => {
+                    return fn(prop as keyof InferStorage<TCrdt>, callback);
+                };
+            },
+        },
+    ) as StorageProxy<InferStorage<TCrdt>>;
+
     private _updateState(
         updater: (oldState: WebSocketState<TIO>) => WebSocketState<TIO>,
     ): WebSocketState<TIO> {

package/src/createClient.ts

@@ -1,12 +1,11 @@
-import type { AbstractCrdtDocFactory, NoopCrdtDocFactory } from "@pluv/crdt";
-import type { IOLike, JsonObject } from "@pluv/types";
+import type { InferIOCrdtKind, IOLike, JsonObject } from "@pluv/types";
 import type { PluvClientOptions } from "./PluvClient";
 import { PluvClient } from "./PluvClient";
 
 export const createClient = <
-    TIO extends IOLike<any, any>,
+    TIO extends IOLike<any, any, any>,
     TPresence extends Record<string, any> = {},
-    TCrdt extends AbstractCrdtDocFactory<any, any> = NoopCrdtDocFactory,
+    TCrdt extends InferIOCrdtKind<TIO> = InferIOCrdtKind<TIO>,
     TMetadata extends JsonObject = {},
 >(
     options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>,

package/src/infer.ts

@@ -1,10 +1,10 @@
 import type { IOLike } from "@pluv/types";
 import type { identity } from "./utils";
 
-export type InferCallback<TIO extends IOLike<any, any>> = (i: typeof identity) => {
+export type InferCallback<TIO extends IOLike<any, any, any>> = (i: typeof identity) => {
     io: (io: TIO) => TIO;
 };
 
-export const infer = <TIO extends IOLike<any, any>>(
+export const infer = <TIO extends IOLike<any, any, any>>(
     callback: InferCallback<TIO>,
 ): InferCallback<TIO> => callback;