@pluv/client 1.0.2 → 2.0.1

package/src/PluvRoom.ts

@@ -1,8 +1,16 @@
-import type { AbstractCrdtDoc, CrdtType, InferCrdtJson } from "@pluv/crdt";
+import type {
+    AbstractCrdtDocFactory,
+    CrdtType,
+    InferCrdtJson,
+    InferStorage,
+    NoopCrdtDocFactory,
+} from "@pluv/crdt";
 import type {
     BaseIOEventRecord,
     BaseUser,
+    CrdtDocLike,
     EventMessage,
+    EventNotifierSubscriptionCallback,
     IOEventMessage,
     IOLike,
     Id,
@@ -12,26 +20,27 @@ import type {
     InferIOOutput,
     InputZodLike,
     JsonObject,
+    MergeEvents,
     OptionalProps,
+    OtherNotifierSubscriptionCallback,
+    RoomLike,
+    UpdateMyPresenceAction,
+    UserInfo,
+    WebSocketState,
 } from "@pluv/types";
-import { AbstractRoom } from "./AbstractRoom";
+import { ConnectionState } from "@pluv/types";
 import type { AbstractStorageStore } from "./AbstractStorageStore";
 import type { CrdtManagerOptions } from "./CrdtManager";
 import { CrdtManager } from "./CrdtManager";
 import { CrdtNotifier } from "./CrdtNotifier";
-import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
 import { EventNotifier } from "./EventNotifier";
-import type { OtherNotifierSubscriptionCallback } from "./OtherNotifier";
 import { OtherNotifier } from "./OtherNotifier";
 import { PluvProcedure } from "./PluvProcedure";
-import type { MergeEvents, PluvRouterEventConfig } from "./PluvRouter";
+import type { PluvRouterEventConfig } from "./PluvRouter";
 import { PluvRouter } from "./PluvRouter";
 import type { StateNotifierSubjects, SubscriptionCallback } from "./StateNotifier";
 import { StateNotifier } from "./StateNotifier";
 import { StorageStore } from "./StorageStore";
-import type { UsersManagerConfig } from "./UsersManager";
-import { UsersManager } from "./UsersManager";
-import { ConnectionState } from "./enums";
 import type {
     AuthorizationState,
     EventResolver,
@@ -39,12 +48,11 @@ import type {
     InternalSubscriptions,
     PluvClientLimits,
     PublicKey,
-    UpdateMyPresenceAction,
-    UserInfo,
     WebSocketConnection,
-    WebSocketState,
     WithMetadata,
 } from "./types";
+import type { UsersManagerConfig } from "./UsersManager";
+import { UsersManager } from "./UsersManager";
 import { debounce } from "./utils";
 
 const ADD_TO_STORAGE_STATE_DEBOUNCE_MS = 1_000;
@@ -68,12 +76,12 @@ declare global {
 }
 
 export const DEFAULT_PLUV_CLIENT_ADDON = <
-    TIO extends IOLike = IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TIO extends IOLike,
+    TMetadata extends JsonObject,
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
 >(
-    input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>,
+    input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TCrdt>,
 ): PluvRoomAddonResult => ({
     storage: new StorageStore(input.room.id),
 });
@@ -126,21 +134,19 @@ interface InternalListeners {
 }
 
 export type PluvRoomAddon<
-    TIO extends IOLike = IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-> = (
-    input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>,
-) => Partial<PluvRoomAddonResult>;
+    TIO extends IOLike,
+    TMetadata extends JsonObject,
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
+> = (input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TCrdt>) => Partial<PluvRoomAddonResult>;
 
 export interface PluvRoomAddonInput<
-    TIO extends IOLike = IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TIO extends IOLike,
+    TMetadata extends JsonObject,
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
 > {
-    room: PluvRoom<TIO, TMetadata, TPresence, TStorage>;
+    room: PluvRoom<TIO, TMetadata, TPresence, TCrdt>;
 }
 
 export interface PluvRoomAddonResult {
@@ -167,22 +173,22 @@ export type ReconnectTimeoutMs = number | ((params: ReconnectTimeoutMsParams) =>
 
 export type RoomConfig<
     TIO extends IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+    TMetadata extends JsonObject,
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
 > = Id<
     {
-        addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
+        addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt>[];
         debug?: boolean | PluvRoomDebug<TIO>;
         limits: PluvClientLimits;
         onAuthorizationFail?: (error: Error) => void;
         metadata?: InputZodLike<TMetadata>;
         publicKey?: PublicKey<TMetadata>;
         reconnectTimeoutMs?: ReconnectTimeoutMs;
-        router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+        router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
     } & RoomEndpoints<TIO, TMetadata> &
-        Pick<CrdtManagerOptions<TStorage>, "initialStorage"> &
+        Pick<CrdtManagerOptions<TCrdt>, "initialStorage"> &
         UsersManagerConfig<TPresence>
 >;
 
@@ -190,15 +196,17 @@ export class PluvRoom<
     TIO extends IOLike<any, any>,
     TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
-> extends AbstractRoom<TIO, TPresence, TStorage> {
+    TCrdt extends AbstractCrdtDocFactory<any> = NoopCrdtDocFactory,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {},
+> implements RoomLike<TIO, TPresence, InferStorage<TCrdt>>
+{
     readonly _endpoints: RoomEndpoints<TIO, TMetadata>;
 
+    public readonly id: string;
     public readonly metadata?: InputZodLike<TMetadata>;
 
-    private readonly _crdtManager: CrdtManager<TStorage>;
-    private readonly _crdtNotifier = new CrdtNotifier<TStorage>();
+    private readonly _crdtManager: CrdtManager<TCrdt>;
+    private readonly _crdtNotifier = new CrdtNotifier<InferStorage<TCrdt>>();
     private readonly _debug: boolean | PluvRoomDebug<TIO>;
     private readonly _eventNotifier = new EventNotifier<MergeEvents<TEvents, TIO>>();
     private readonly _intervals: IntervalIds = {
@@ -209,7 +217,7 @@ export class PluvRoom<
     private readonly _otherNotifier = new OtherNotifier<TIO, TPresence>();
     private readonly _publicKey: PublicKey<TMetadata> | null = null;
     private readonly _reconnectTimeoutMs: ReconnectTimeoutMs;
-    private readonly _router: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+    private readonly _router: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
     private readonly _stateNotifier = new StateNotifier<TIO, TPresence>();
     private readonly _storageStore: AbstractStorageStore;
     private readonly _subscriptions: InternalSubscriptions = {
@@ -238,7 +246,7 @@ export class PluvRoom<
     private _windowListeners: WindowListeners | null = null;
     private _wsListeners: WebSocketListeners | null = null;
 
-    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>) {
+    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TCrdt, TEvents>) {
         const {
             addons = [],
             authEndpoint,
@@ -255,22 +263,20 @@ export class PluvRoom<
             wsEndpoint,
         } = options;
 
-        super(room);
+        this.id = room;
+        this.metadata = metadata;
 
         const addon = this._getAddon(addons);
-
         const { storage } = {
             ...DEFAULT_PLUV_CLIENT_ADDON({ room: this }),
             ...addon({ room: this }),
         };
-
-        this.metadata = metadata;
+        this._storageStore = storage;
 
         this._debug = debug;
         this._endpoints = { authEndpoint, wsEndpoint } as RoomEndpoints<TIO, TMetadata>;
         this._limits = limits;
         this._reconnectTimeoutMs = reconnectTimeoutMs;
-        this._storageStore = storage;
 
         if (!!publicKey) this._publicKey = publicKey;
 
@@ -281,13 +287,14 @@ export class PluvRoom<
         };
 
         this._router =
-            router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
+            router ??
+            (new PluvRouter({}) as PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>);
         this._usersManager = new UsersManager<TIO, TPresence>({
             initialPresence,
             limits: this._limits,
             presence,
         });
-        this._crdtManager = new CrdtManager<TStorage>({ initialStorage });
+        this._crdtManager = new CrdtManager<TCrdt>({ initialStorage });
     }
 
     public get storageLoaded(): boolean {
@@ -313,7 +320,7 @@ export class PluvRoom<
                 any,
                 any,
                 TPresence,
-                TStorage
+                InferStorage<TCrdt>
             > | null;
 
             if (!procedure?.config.broadcast) {
@@ -327,7 +334,7 @@ export class PluvRoom<
             if (!myself) return;
 
             const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
-            const context: EventResolverContext<TIO, TPresence, TStorage> = {
+            const context: EventResolverContext<TIO, TPresence, InferStorage<TCrdt>> = {
                 doc: this._crdtManager.doc,
                 others: this._usersManager.getOthers(),
                 room: this.id,
@@ -335,7 +342,13 @@ export class PluvRoom<
             };
 
             const output = await (
-                procedure.config.broadcast as EventResolver<TIO, any, any, TPresence, TStorage>
+                procedure.config.broadcast as EventResolver<
+                    TIO,
+                    any,
+                    any,
+                    TPresence,
+                    InferStorage<TCrdt>
+                >
             )(parsed, context);
 
             Object.entries(output).forEach(([_type, _data]) => {
@@ -483,7 +496,7 @@ export class PluvRoom<
         return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
     };
 
-    public getDoc = (): AbstractCrdtDoc<TStorage> => {
+    public getDoc = (): CrdtDocLike<InferStorage<TCrdt>> => {
         return this._crdtManager.doc;
     };
 
@@ -503,7 +516,9 @@ export class PluvRoom<
         return this._usersManager.getOthers();
     };
 
-    public getStorage = <TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null => {
+    public getStorage = <TKey extends keyof InferStorage<TCrdt>>(
+        type: TKey,
+    ): InferStorage<TCrdt>[TKey] | null => {
         const sharedType = this._crdtManager.get(type);
 
         if (typeof sharedType === "undefined") return null;
@@ -511,11 +526,11 @@ export class PluvRoom<
         return sharedType;
     };
 
-    public getStorageJson(): InferCrdtJson<TStorage> | null;
-    public getStorageJson<TKey extends keyof TStorage>(
+    public getStorageJson(): InferCrdtJson<InferStorage<TCrdt>> | null;
+    public getStorageJson<TKey extends keyof InferStorage<TCrdt>>(
         type: TKey,
-    ): InferCrdtJson<TStorage[TKey]> | null;
-    public getStorageJson<TKey extends keyof TStorage>(type?: TKey) {
+    ): InferCrdtJson<InferStorage<TCrdt>[TKey]> | null;
+    public getStorageJson<TKey extends keyof InferStorage<TCrdt>>(type?: TKey) {
         if (this._state.connection.id === null) return null;
 
         if (typeof type === "undefined") return this._crdtManager.doc.toJson();
@@ -542,16 +557,16 @@ export class PluvRoom<
         this._crdtManager.doc.redo();
     };
 
-    public storage = <TKey extends keyof TStorage>(
+    public storage = <TKey extends keyof InferStorage<TCrdt>>(
         key: TKey,
-        fn: (value: InferCrdtJson<TStorage[TKey]>) => void,
+        fn: (value: InferCrdtJson<InferStorage<TCrdt>[TKey]>) => void,
     ): (() => void) => {
         return this._crdtNotifier.subscribe(key, fn);
     };
 
     public storageRoot = (
         fn: (value: {
-            [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+            [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
         }) => void,
     ): (() => void) => {
         return this._crdtNotifier.subcribeRoot(fn);
@@ -564,7 +579,7 @@ export class PluvRoom<
         return this._stateNotifier.subscribe(name, callback);
     };
 
-    public transact = (fn: (storage: TStorage) => void, origin?: string): void => {
+    public transact = (fn: (storage: InferStorage<TCrdt>) => void, origin?: string): void => {
         const _origin = origin ?? this._state.connection.id;
 
         /**
@@ -707,7 +722,7 @@ export class PluvRoom<
 
                 return { ...acc, [prop]: serialized };
             },
-            {} as { [P in keyof TStorage]: InferCrdtJson<TStorage[P]> },
+            {} as { [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]> },
         );
 
         this._crdtNotifier.rootSubject.next(storageRoot);
@@ -731,9 +746,9 @@ export class PluvRoom<
     );
 
     private _getAddon = (
-        addons: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[],
-    ): PluvRoomAddon<TIO, TMetadata, TPresence, TStorage> => {
-        return addons.reduce<PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>>(
+        addons: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt>[],
+    ): PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt> => {
+        return addons.reduce<PluvRoomAddon<TIO, TMetadata, TPresence, TCrdt>>(
             (acc, addon) => () => ({
                 ...acc({ room: this }),
                 ...addon({ room: this }),
@@ -1044,7 +1059,7 @@ export class PluvRoom<
                 return { ...acc, [prop]: serialized };
             },
             {} as {
-                [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+                [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
             },
         );
 
@@ -1121,7 +1136,8 @@ export class PluvRoom<
     }
 
     private _logDebug(...data: any[]): void {
-        if ((process as unknown as any)?.env?.NODE_ENV === "production") return;
+        if (typeof process === "undefined") return;
+        if (process.env?.NODE_ENV === "production") return;
         if (this._debug) console.log(...data);
     }
 

package/src/PluvRouter.ts

@@ -1,5 +1,5 @@
 import type { CrdtType } from "@pluv/crdt";
-import type { Id, IOLike, IORouterLike, JsonObject, ProcedureLike } from "@pluv/types";
+import type { IOLike, IORouterLike, JsonObject } from "@pluv/types";
 import type { PluvProcedure } from "./PluvProcedure";
 
 export type PluvRouterEventConfig<
@@ -21,28 +21,6 @@ export type MergedRouter<
     ? MergedRouter<ITail, TIO, TPresence, TStorage, TRoot & IHead["_defs"]["events"]>
     : PluvRouter<TIO, TPresence, TStorage, TRoot>;
 
-export type MergeEvents<
-    TClientEvents extends PluvRouterEventConfig<any, any, any>,
-    TServerIO extends IOLike<any, any>,
-> =
-    TServerIO extends IOLike<infer IAuthorize, infer IServerEvents>
-        ? IOLike<
-              IAuthorize,
-              {
-                  [P in keyof TClientEvents]: TClientEvents[P] extends ProcedureLike<
-                      infer IClientInput,
-                      infer IClientOutput
-                  >
-                      ? {
-                            [K in keyof IClientOutput]: K extends keyof IServerEvents
-                                ? IServerEvents[K]
-                                : ProcedureLike<IClientInput, Id<Pick<IClientOutput, K>>>;
-                        }[keyof IClientOutput]
-                      : never;
-              } & IServerEvents
-          >
-        : never;
-
 export class PluvRouter<
     TIO extends IOLike = IOLike,
     TPresence extends JsonObject = {},

package/src/StateNotifier.ts

@@ -1,7 +1,6 @@
-import type { Id, IOLike, JsonObject } from "@pluv/types";
+import type { Id, IOLike, JsonObject, UserInfo, WebSocketState } from "@pluv/types";
 import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
-import type { UserInfo, WebSocketState } from "./types";
 
 export interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
     connection: Subject<Id<WebSocketState<TIO>>>;

package/src/UsersManager.ts

@@ -1,5 +1,5 @@
-import type { InputZodLike, IOLike, JsonObject, OptionalProps } from "@pluv/types";
-import type { PluvClientLimits, UserInfo } from "./types";
+import type { InputZodLike, IOLike, JsonObject, OptionalProps, UserInfo } from "@pluv/types";
+import type { PluvClientLimits } from "./types";
 import { pickBy } from "./utils";
 
 export type Presence = Record<string, unknown>;

package/src/createClient.ts

@@ -1,4 +1,4 @@
-import type { CrdtType } from "@pluv/crdt";
+import type { AbstractCrdtDocFactory, NoopCrdtDocFactory } from "@pluv/crdt";
 import type { IOLike, JsonObject } from "@pluv/types";
 import type { PluvClientOptions } from "./PluvClient";
 import { PluvClient } from "./PluvClient";
@@ -6,10 +6,10 @@ import { PluvClient } from "./PluvClient";
 export const createClient = <
     TIO extends IOLike<any, any>,
     TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TCrdt extends AbstractCrdtDocFactory<any> = NoopCrdtDocFactory,
     TMetadata extends JsonObject = {},
 >(
-    options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>,
-): PluvClient<TIO, TPresence, TStorage, TMetadata> => {
-    return new PluvClient<TIO, TPresence, TStorage, TMetadata>(options);
+    options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>,
+): PluvClient<TIO, TPresence, TCrdt, TMetadata> => {
+    return new PluvClient<TIO, TPresence, TCrdt, TMetadata>(options);
 };

package/src/index.ts

@@ -1,9 +1,18 @@
 export type { CrdtType, InferCrdtJson } from "@pluv/crdt";
-export type { BaseUser, EventMessage, EventRecord, IOEventMessage } from "@pluv/types";
-export { AbstractRoom } from "./AbstractRoom";
+export { ConnectionState } from "@pluv/types";
+export type {
+    BaseUser,
+    EventMessage,
+    EventNotifierSubscriptionCallback,
+    EventRecord,
+    IOEventMessage,
+    MergeEvents,
+    RoomLike,
+    UserInfo,
+    WebSocketState,
+} from "@pluv/types";
 export { AbstractStorageStore } from "./AbstractStorageStore";
 export { createClient } from "./createClient";
-export { ConnectionState } from "./enums";
 export { infer } from "./infer";
 export type { InferCallback } from "./infer";
 export { MockedRoom } from "./MockedRoom";
@@ -20,14 +29,7 @@ export type {
     RoomConnectParams,
     RoomEndpoints,
 } from "./PluvRoom";
-export type { MergeEvents, PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
+export type { PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
 export { register } from "./register";
 export type { RegisterParams } from "./register";
-export type {
-    InferMetadata,
-    PublicKey,
-    PublicKeyParams,
-    UserInfo,
-    WebSocketConnection,
-    WebSocketState,
-} from "./types";
+export type { InferMetadata, PublicKey, PublicKeyParams, WebSocketConnection } from "./types";

package/src/types.ts

@@ -1,5 +1,7 @@
-import type { AbstractCrdtDoc, CrdtType } from "@pluv/crdt";
+import type { CrdtType } from "@pluv/crdt";
 import type {
+    ConnectionState,
+    CrdtDocLike,
     EventRecord,
     Id,
     InferIOAuthorize,
@@ -7,8 +9,8 @@ import type {
     IOLike,
     JsonObject,
     MaybePromise,
+    UserInfo,
 } from "@pluv/types";
-import type { ConnectionState } from "./enums";
 import type { PluvClient } from "./PluvClient";
 
 export interface AuthorizationState<TIO extends IOLike> {
@@ -32,7 +34,7 @@ export interface EventResolverContext<
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
 > {
-    doc: AbstractCrdtDoc<TStorage>;
+    doc: CrdtDocLike<TStorage>;
     others: readonly UserInfo<TIO, TPresence>[];
     room: string;
     user: UserInfo<TIO, TPresence>;
@@ -74,16 +76,6 @@ export type PublicKey<TMetadata extends JsonObject> =
     | string
     | ((params: PublicKeyParams<TMetadata>) => string);
 
-export type UpdateMyPresenceAction<TPresence extends JsonObject> =
-    | Partial<TPresence>
-    | ((oldPresence: TPresence | null) => Partial<TPresence>);
-
-export interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
-    connectionId: string;
-    presence: TPresence;
-    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
-}
-
 export interface WebSocketConnection {
     /**
      * @description How many times a connection attempt was made. This will increment upon each
@@ -103,12 +95,6 @@ export interface WebSocketConnection {
     state: ConnectionState;
 }
 
-export interface WebSocketState<TIO extends IOLike> {
-    authorization: AuthorizationState<TIO>;
-    connection: WebSocketConnection;
-    webSocket: WebSocket | null;
-}
-
 export type WithMetadata<TMetadata extends JsonObject = {}> = keyof TMetadata extends never
     ? { metadata?: undefined }
     : { metadata: TMetadata };

package/src/AbstractRoom.ts

@@ -1,84 +0,0 @@
-import type { AbstractCrdtDoc, CrdtType, InferCrdtJson } from "@pluv/crdt";
-import type { IOLike, Id, InferIOInput, InferIOOutput, JsonObject } from "@pluv/types";
-import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
-import type { OtherNotifierSubscriptionCallback } from "./OtherNotifier";
-import type { MergeEvents, PluvRouterEventConfig } from "./PluvRouter";
-import type { StateNotifierSubjects, SubscriptionCallback } from "./StateNotifier";
-import type { UpdateMyPresenceAction, UserInfo, WebSocketConnection } from "./types";
-
-export abstract class AbstractRoom<
-    TIO extends IOLike,
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
-> {
-    public readonly id: string;
-
-    constructor(room: string) {
-        this.id = room;
-    }
-
-    public abstract storageLoaded: boolean;
-
-    public abstract broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(
-        event: TEvent,
-        data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>,
-    ): void;
-
-    public abstract canRedo(): boolean;
-
-    public abstract canUndo(): boolean;
-
-    public abstract getDoc(): AbstractCrdtDoc<TStorage>;
-
-    public abstract event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
-        event: TEvent,
-        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
-    ): () => void;
-
-    public abstract getConnection(): WebSocketConnection;
-
-    public abstract getMyPresence(): TPresence;
-
-    public abstract getMyself(): Id<UserInfo<TIO, TPresence>> | null;
-
-    public abstract getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
-
-    public abstract getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
-
-    public abstract getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
-
-    public abstract getStorageJson(): InferCrdtJson<TStorage> | null;
-    public abstract getStorageJson<TKey extends keyof TStorage>(
-        type: TKey,
-    ): InferCrdtJson<TStorage[TKey]> | null;
-
-    public abstract other(
-        connectionId: string,
-        callback: OtherNotifierSubscriptionCallback<TIO, TPresence>,
-    ): () => void;
-
-    public abstract redo(): void;
-
-    public abstract storage<TKey extends keyof TStorage>(
-        key: TKey,
-        fn: (value: InferCrdtJson<TStorage[TKey]>) => void,
-    ): () => void;
-
-    public abstract storageRoot(
-        fn: (value: {
-            [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
-        }) => void,
-    ): () => void;
-
-    public abstract subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
-        name: TSubject,
-        callback: SubscriptionCallback<TIO, TPresence, TSubject>,
-    ): () => void;
-
-    public abstract transact(fn: (storage: TStorage) => void, origin?: string): void;
-
-    public abstract undo(): void;
-
-    public abstract updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
-}

package/src/enums.ts

@@ -1,9 +0,0 @@
-export const ConnectionState = {
-    Closed: "Closed",
-    Connecting: "Connecting",
-    Open: "Open",
-    Unavailable: "Unavailable",
-    Untouched: "Untouched",
-} as const;
-
-export type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];