@pluv/client 0.15.0 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/client",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "@pluv/io frontend client",
   "author": "leedavidcs",
   "license": "MIT",
@@ -18,19 +18,15 @@
   },
   "dependencies": {
     "wonka": "^6.3.4",
-    "@pluv/crdt-yjs": "^0.15.0",
-    "@pluv/types": "^0.15.0"
-  },
-  "peerDependencies": {
-    "yjs": "^13.0.0"
+    "@pluv/crdt": "^0.16.1",
+    "@pluv/types": "^0.16.1"
   },
   "devDependencies": {
     "eslint": "^8.56.0",
-    "tsup": "^8.0.1",
-    "typescript": "^5.2.2",
-    "yjs": "^13.6.10",
-    "@pluv/tsconfig": "^0.15.0",
-    "eslint-config-pluv": "^0.15.0"
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3",
+    "@pluv/tsconfig": "^0.16.1",
+    "eslint-config-pluv": "^0.16.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/AbstractRoom.ts

@@ -1,12 +1,15 @@
-import type { InferYjsSharedTypeJson } from "@pluv/crdt-yjs";
 import type {
+    AbstractCrdtDoc,
+    AbstractCrdtType,
+    InferCrdtStorageJson,
+} from "@pluv/crdt";
+import type {
+    IOLike,
     Id,
     InferIOInput,
     InferIOOutput,
-    IOLike,
     JsonObject,
 } from "@pluv/types";
-import type { AbstractType, Doc } from "yjs";
 import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
 import type { OtherNotifierSubscriptionCallback } from "./OtherNotifier";
 import type {
@@ -18,7 +21,7 @@ import type { UserInfo, WebSocketConnection } from "./types";
 export abstract class AbstractRoom<
     TIO extends IOLike,
     TPresence extends JsonObject = {},
-    TStorage extends Record<string, AbstractType<any>> = {},
+    TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
 > {
     public readonly id: string;
 
@@ -26,6 +29,8 @@ export abstract class AbstractRoom<
         this.id = room;
     }
 
+    public abstract storageLoaded: boolean;
+
     public abstract broadcast<TEvent extends keyof InferIOInput<TIO>>(
         event: TEvent,
         data: Id<InferIOInput<TIO>[TEvent]>,
@@ -35,7 +40,7 @@ export abstract class AbstractRoom<
 
     public abstract canUndo(): boolean;
 
-    public abstract getDoc(): Doc;
+    public abstract getDoc(): AbstractCrdtDoc<TStorage>;
 
     public abstract event<TEvent extends keyof InferIOOutput<TIO>>(
         event: TEvent,
@@ -56,7 +61,7 @@ export abstract class AbstractRoom<
 
     public abstract getStorage<TKey extends keyof TStorage>(
         key: TKey,
-    ): TStorage[TKey];
+    ): TStorage[TKey] | null;
 
     public abstract other(
         connectionId: string,
@@ -67,12 +72,12 @@ export abstract class AbstractRoom<
 
     public abstract storage<TKey extends keyof TStorage>(
         key: TKey,
-        fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void,
+        fn: (value: InferCrdtStorageJson<TStorage[TKey]>) => void,
     ): () => void;
 
     public abstract storageRoot(
         fn: (value: {
-            [P in keyof TStorage]: InferYjsSharedTypeJson<TStorage[P]>;
+            [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>;
         }) => void,
     ): () => void;
 

package/src/CrdtManager.ts

@@ -1,47 +1,44 @@
-import type { TrackOriginOptions, YjsDoc } from "@pluv/crdt-yjs";
-import { doc } from "@pluv/crdt-yjs";
-import type { AbstractType } from "yjs";
+import type {
+    AbstractCrdtDoc,
+    AbstractCrdtDocFactory,
+    AbstractCrdtType,
+} from "@pluv/crdt";
+import { noop } from "@pluv/crdt";
 
 export type CrdtManagerOptions<
-    TStorage extends Record<string, AbstractType<any>> = {},
+    TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
 > = {
     encodedState?: string | Uint8Array | null;
-    initialStorage?: () => TStorage;
-} & TrackOriginOptions;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+};
 
 type CrdtManagerInitializeParams = {
-    onInitialized?: () => void;
+    onInitialized?: (state: string) => void;
     origin?: any;
     update: string | readonly string[];
-} & TrackOriginOptions;
+};
 
-export class CrdtManager<TStorage extends Record<string, AbstractType<any>>> {
-    public doc: YjsDoc<TStorage>;
+export class CrdtManager<
+    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+> {
+    public doc: AbstractCrdtDoc<TStorage>;
     public initialized: boolean = false;
 
-    constructor(options: CrdtManagerOptions<TStorage> = {}) {
+    private readonly _docFactory: AbstractCrdtDocFactory<TStorage>;
+
+    constructor(options: CrdtManagerOptions<TStorage>) {
         const {
-            captureTimeout,
             encodedState,
-            initialStorage,
-            trackedOrigins = [],
+            initialStorage = noop.doc({}) as AbstractCrdtDocFactory<TStorage>,
         } = options;
 
-        const _doc = encodedState
-            ? doc<TStorage>().applyUpdate(encodedState)
-            : null;
-
-        if (_doc && !!Object.keys(_doc.toJSON()).length) {
-            this.doc = _doc;
-            this.trackOrigins({ captureTimeout, trackedOrigins });
-
-            return;
-        }
-
-        _doc?.destroy();
+        this._docFactory = initialStorage;
 
-        this.doc = doc<TStorage>(initialStorage?.());
-        this.trackOrigins({ captureTimeout, trackedOrigins });
+        this.doc = encodedState
+            ? initialStorage
+                  .getFresh()
+                  .applyEncodedState({ update: encodedState })
+            : initialStorage.getFresh();
     }
 
     /**
@@ -70,58 +67,59 @@ export class CrdtManager<TStorage extends Record<string, AbstractType<any>>> {
     }
 
     public initialize(params: CrdtManagerInitializeParams): this {
-        const {
-            captureTimeout,
-            onInitialized,
-            origin,
-            trackedOrigins,
-            update,
-        } = params;
+        const { onInitialized, origin, update } = params;
 
         const updates = typeof update === "string" ? [update] : update;
 
-        this.trackOrigins({ captureTimeout, trackedOrigins });
-
         if (!updates.length) return this;
 
         if (this.initialized) {
-            this._applyDocUpdates(this.doc, updates, origin);
+            this.doc = this._applyDocUpdates(this.doc, updates, origin).track();
 
             return this;
         }
 
-        const _doc = this._applyDocUpdates(doc<TStorage>(), updates, origin);
+        const onEmpty = this._applyDocUpdates(
+            this._docFactory.getEmpty(),
+            updates,
+            origin,
+        );
 
-        this.initialized = true;
+        if (!onEmpty.isEmpty()) {
+            onEmpty.destroy();
 
-        if (!!Object.keys(_doc.toJSON()).length) {
-            this.doc = _doc;
-        } else {
-            _doc.destroy();
-        }
+            this.doc = this._applyDocUpdates(
+                this._docFactory.getFresh(),
+                updates,
+                origin,
+            ).track();
+            this.initialized = true;
 
-        onInitialized?.();
+            onInitialized?.(this.doc.getEncodedState());
 
-        this.trackOrigins({ captureTimeout, trackedOrigins });
+            return this;
+        }
 
-        return this;
-    }
+        onEmpty.destroy();
+        this.doc = this._docFactory.getInitialized().track();
+        this.initialized = true;
 
-    public trackOrigins(options: TrackOriginOptions): void {
-        const { captureTimeout, trackedOrigins } = options;
+        onInitialized?.(this.doc.getEncodedState());
 
-        this.doc.trackOrigins({ captureTimeout, trackedOrigins });
+        return this;
     }
 
     private _applyDocUpdates(
-        yjsDoc: YjsDoc<TStorage>,
+        doc: AbstractCrdtDoc<TStorage>,
         updates: readonly string[],
         origin?: string,
-    ): YjsDoc<TStorage> {
-        yjsDoc.transact(() => {
-            updates.reduce((acc, _update) => acc.applyUpdate(_update), yjsDoc);
+    ): AbstractCrdtDoc<TStorage> {
+        doc.transact(() => {
+            doc.batchApplyEncodedState(
+                updates.map((update) => ({ origin, update })),
+            );
         }, origin);
 
-        return yjsDoc;
+        return doc;
     }
 }

package/src/CrdtNotifier.ts

@@ -1,37 +1,37 @@
-import type { InferYjsSharedTypeJson } from "@pluv/crdt-yjs";
+import type { AbstractCrdtType, InferCrdtStorageJson } from "@pluv/crdt";
 import { makeSubject, Subject, subscribe } from "wonka";
-import type { AbstractType } from "yjs";
 
-export class CrdtNotifier<TStorage extends Record<string, AbstractType<any>>> {
+export class CrdtNotifier<
+    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+> {
     public rootSubject = makeSubject<{
-        [P in keyof TStorage]: InferYjsSharedTypeJson<TStorage[P]>;
+        [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>;
     }>();
 
     public subjects = new Map<
         keyof TStorage,
-        Subject<InferYjsSharedTypeJson<TStorage[keyof TStorage]>> | null
+        Subject<InferCrdtStorageJson<TStorage[keyof TStorage]>> | null
     >();
 
     public subject<TKey extends keyof TStorage>(
         key: TKey,
-    ): Subject<InferYjsSharedTypeJson<TStorage[TKey]>> {
+    ): Subject<InferCrdtStorageJson<TStorage[TKey]>> {
         const subject = this.subjects.get(key);
 
         if (subject) {
-            return subject as Subject<InferYjsSharedTypeJson<TStorage[TKey]>>;
+            return subject as Subject<InferCrdtStorageJson<TStorage[TKey]>>;
         }
 
-        const newSubject =
-            makeSubject<InferYjsSharedTypeJson<TStorage[TKey]>>();
+        const newSubject = makeSubject<InferCrdtStorageJson<TStorage[TKey]>>();
 
         this.subjects.set(key, newSubject);
 
-        return newSubject as Subject<InferYjsSharedTypeJson<TStorage[TKey]>>;
+        return newSubject as Subject<InferCrdtStorageJson<TStorage[TKey]>>;
     }
 
     public subcribeRoot(
         callback: (value: {
-            [P in keyof TStorage]: InferYjsSharedTypeJson<TStorage[P]>;
+            [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>;
         }) => void,
     ): () => void {
         return subscribe(callback)(this.rootSubject.source).unsubscribe;
@@ -39,7 +39,7 @@ export class CrdtNotifier<TStorage extends Record<string, AbstractType<any>>> {
 
     public subscribe<TKey extends keyof TStorage>(
         key: TKey,
-        callback: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void,
+        callback: (value: InferCrdtStorageJson<TStorage[TKey]>) => void,
     ): () => void {
         const subject = this.subject(key);
 

package/src/MockedRoom.ts

@@ -1,14 +1,18 @@
-import type { InferYjsSharedTypeJson } from "@pluv/crdt-yjs";
 import type {
+    AbstractCrdtDoc,
+    AbstractCrdtType,
+    InferCrdtStorageJson,
+} from "@pluv/crdt";
+import type {
+    IOLike,
     Id,
     InferIOInput,
     InferIOOutput,
-    IOLike,
     JsonObject,
 } from "@pluv/types";
-import type { AbstractType, Doc } from "yjs";
 import { AbstractRoom } from "./AbstractRoom";
-import { CrdtManager, CrdtManagerOptions } from "./CrdtManager";
+import type { CrdtManagerOptions } from "./CrdtManager";
+import { CrdtManager } from "./CrdtManager";
 import { CrdtNotifier } from "./CrdtNotifier";
 import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
 import { EventNotifier } from "./EventNotifier";
@@ -19,6 +23,8 @@ import type {
     SubscriptionCallback,
 } from "./StateNotifier";
 import { StateNotifier } from "./StateNotifier";
+import type { UsersManagerConfig } from "./UsersManager";
+import { UsersManager } from "./UsersManager";
 import type {
     InternalSubscriptions,
     UserInfo,
@@ -26,8 +32,6 @@ import type {
     WebSocketState,
 } from "./types";
 import { ConnectionState } from "./types";
-import type { UsersManagerConfig } from "./UsersManager";
-import { UsersManager } from "./UsersManager";
 
 export type MockedRoomEvents<TIO extends IOLike> = Partial<{
     [P in keyof InferIOInput<TIO>]: (
@@ -38,7 +42,7 @@ export type MockedRoomEvents<TIO extends IOLike> = Partial<{
 export type MockedRoomConfig<
     TIO extends IOLike,
     TPresence extends JsonObject = {},
-    TStorage extends Record<string, AbstractType<any>> = {},
+    TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
 > = { events?: MockedRoomEvents<TIO> } & Omit<
     CrdtManagerOptions<TStorage>,
     "encodedState"
@@ -48,7 +52,7 @@ export type MockedRoomConfig<
 export class MockedRoom<
     TIO extends IOLike,
     TPresence extends JsonObject = {},
-    TStorage extends Record<string, AbstractType<any>> = {},
+    TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
 > extends AbstractRoom<TIO, TPresence, TStorage> {
     private _crdtManager: CrdtManager<TStorage>;
     private _crdtNotifier = new CrdtNotifier<TStorage>();
@@ -95,6 +99,10 @@ export class MockedRoom<
         this._observeCrdt();
     }
 
+    public get storageLoaded(): boolean {
+        return true;
+    }
+
     public broadcast<TEvent extends keyof InferIOInput<TIO>>(
         event: TEvent,
         data: Id<InferIOInput<TIO>[TEvent]>,
@@ -139,8 +147,8 @@ export class MockedRoom<
         );
     }
 
-    public getDoc(): Doc {
-        return this._crdtManager.doc.value;
+    public getDoc(): AbstractCrdtDoc<TStorage> {
+        return this._crdtManager.doc;
     }
 
     public getMyPresence = (): TPresence => {
@@ -163,14 +171,12 @@ export class MockedRoom<
 
     public getStorage = <TKey extends keyof TStorage>(
         key: TKey,
-    ): TStorage[TKey] => {
+    ): TStorage[TKey] | null => {
         const sharedType = this._crdtManager.get(key);
 
-        if (typeof sharedType === "undefined") {
-            throw new Error(`Could not find storege: ${key.toString()}`);
-        }
+        if (typeof sharedType === "undefined") return null;
 
-        return sharedType;
+        return sharedType.value;
     };
 
     public other = (
@@ -186,14 +192,14 @@ export class MockedRoom<
 
     public storage = <TKey extends keyof TStorage>(
         key: TKey,
-        fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void,
+        fn: (value: InferCrdtStorageJson<TStorage[TKey]>) => void,
     ): (() => void) => {
         return this._crdtNotifier.subscribe(key, fn);
     };
 
     public storageRoot = (
         fn: (value: {
-            [P in keyof TStorage]: InferYjsSharedTypeJson<TStorage[P]>;
+            [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>;
         }) => void,
     ): (() => void) => {
         return this._crdtNotifier.subcribeRoot(fn);
@@ -226,7 +232,9 @@ export class MockedRoom<
         if (!crdtManager) return;
 
         crdtManager.doc.transact(() => {
-            fn(crdtManager.doc.storage);
+            const storage = crdtManager.doc.get();
+
+            fn(storage);
         }, _origin);
     };
 
@@ -249,35 +257,31 @@ export class MockedRoom<
 
         if (!this._crdtManager) return;
 
-        const unsubscribe = this._crdtManager.doc.subscribe(
-            (update, _origin) => {
-                const origin = _origin ?? null;
+        const unsubscribe = this._crdtManager.doc.subscribe((event) => {
+            const origin = event.origin ?? null;
 
-                if (!this._crdtManager) return;
-                if (origin === "$STORAGE_UPDATED") return;
+            if (!this._crdtManager) return;
+            if (origin === "$STORAGE_UPDATED") return;
 
-                const sharedTypes = this._crdtManager.doc.getSharedTypes();
+            const sharedTypes = this._crdtManager.doc.get();
 
-                const storageRoot = Object.entries(sharedTypes).reduce(
-                    (acc, [prop, sharedType]) => {
-                        if (!this._crdtManager) return acc;
+            const storageRoot = Object.entries(sharedTypes).reduce(
+                (acc, [prop, sharedType]) => {
+                    if (!this._crdtManager) return acc;
 
-                        const serialized = sharedType.toJSON();
+                    const serialized = sharedType.toJson();
 
-                        this._crdtNotifier.subject(prop).next(serialized);
+                    this._crdtNotifier.subject(prop).next(serialized);
 
-                        return { ...acc, [prop]: serialized };
-                    },
-                    {} as {
-                        [P in keyof TStorage]: InferYjsSharedTypeJson<
-                            TStorage[P]
-                        >;
-                    },
-                );
+                    return { ...acc, [prop]: serialized };
+                },
+                {} as {
+                    [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>;
+                },
+            );
 
-                this._crdtNotifier.rootSubject.next(storageRoot);
-            },
-        );
+            this._crdtNotifier.rootSubject.next(storageRoot);
+        });
 
         this._subscriptions.observeCrdt = unsubscribe;
     }

package/src/OtherNotifier.ts

@@ -1,7 +1,7 @@
 import type { Id, IOLike } from "@pluv/types";
 import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
-import { UserInfo } from "./types";
+import type { UserInfo } from "./types";
 
 export type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (
     value: Id<UserInfo<TIO>> | null,

package/src/PluvClient.ts

@@ -1,5 +1,5 @@
+import type { AbstractCrdtType } from "@pluv/crdt";
 import type { IOLike, JsonObject } from "@pluv/types";
-import { AbstractType } from "yjs";
 import {
     AuthEndpoint,
     PluvRoom,
@@ -30,10 +30,10 @@ export class PluvClient<TIO extends IOLike = IOLike> {
 
     public createRoom = <
         TPresence extends JsonObject = {},
-        TStorage extends Record<string, AbstractType<any>> = {},
+        TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
     >(
         room: string,
-        options: PluvRoomOptions<TIO, TPresence, TStorage> = {},
+        options: PluvRoomOptions<TIO, TPresence, TStorage>,
     ): PluvRoom<TIO, TPresence, TStorage> => {
         const oldRoom = this.getRoom<TPresence, TStorage>(room);
 
@@ -76,7 +76,7 @@ export class PluvClient<TIO extends IOLike = IOLike> {
 
     public getRoom = <
         TPresence extends JsonObject = {},
-        TStorage extends Record<string, AbstractType<any>> = {},
+        TStorage extends Record<string, AbstractCrdtType<any, any>> = {},
     >(
         room: string,
     ): PluvRoom<TIO, TPresence, TStorage> | null => {