@pluv/client 0.0.0

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@pluv/client",
+  "version": "0.0.0",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pluv/crdt-yjs": "^0.0.0",
+    "@pluv/types": "^0.0.0",
+    "wonka": "^6.1.2"
+  },
+  "peerDependencies": {
+    "yjs": "^13.0.0"
+  },
+  "devDependencies": {
+    "@pluv/tsconfig": "^0.0.0",
+    "eslint-config-pluv": "^0.0.0",
+    "tsup": "^6.5.0",
+    "typescript": "^4.9.4",
+    "yjs": "^13.5.44"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/CrdtManager.ts

@@ -0,0 +1,40 @@
+import type { YjsDoc } from "@pluv/crdt-yjs";
+import { doc } from "@pluv/crdt-yjs";
+import type { AbstractType } from "yjs";
+
+export interface CrdtManagerOptions<
+    TStorage extends Record<string, AbstractType<any>> = {}
+> {
+    encodedState?: string | Uint8Array;
+    initialStorage?: () => TStorage;
+}
+
+export class CrdtManager<TStorage extends Record<string, AbstractType<any>>> {
+    public doc: YjsDoc<TStorage>;
+
+    constructor(options: CrdtManagerOptions<TStorage> = {}) {
+        const { encodedState, initialStorage } = options;
+
+        const doc1 = encodedState
+            ? doc<TStorage>().applyUpdate(encodedState)
+            : null;
+
+        if (doc1 && !!Object.keys(doc1.toJSON()).length) {
+            this.doc = doc1;
+
+            return;
+        }
+
+        doc1?.destroy();
+
+        this.doc = doc<TStorage>(initialStorage?.());
+    }
+
+    public destroy(): void {
+        this.doc.destroy();
+    }
+
+    public get<TKey extends keyof TStorage>(key: TKey): TStorage[TKey] {
+        return this.doc.get(key);
+    }
+}

package/src/CrdtNotifier.ts

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

package/src/EventNotifier.ts

@@ -0,0 +1,38 @@
+import type { Id, InferIOOutput, IOEventMessage, IOLike } from "@pluv/types";
+import type { Subject } from "wonka";
+import { makeSubject, subscribe } from "wonka";
+
+export type EventNotifierSubscriptionCallback<
+    TIO extends IOLike,
+    TEvent extends keyof InferIOOutput<TIO>
+> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+
+export class EventNotifier<TIO extends IOLike> {
+    public subjects = new Map<
+        keyof InferIOOutput<TIO>,
+        Subject<Id<IOEventMessage<TIO, keyof InferIOOutput<TIO>>>>
+    >();
+
+    public subject<TEvent extends keyof InferIOOutput<TIO>>(
+        name: TEvent
+    ): Subject<Id<IOEventMessage<TIO, TEvent>>> {
+        const subject = this.subjects.get(name);
+
+        if (subject) return subject;
+
+        const newSubject = makeSubject<Id<IOEventMessage<TIO, TEvent>>>();
+
+        this.subjects.set(name, newSubject);
+
+        return newSubject;
+    }
+
+    public subscribe<TEvent extends keyof InferIOOutput<TIO>>(
+        name: TEvent,
+        callback: EventNotifierSubscriptionCallback<TIO, TEvent>
+    ): () => void {
+        const subject = this.subject(name);
+
+        return subscribe(callback)(subject.source).unsubscribe;
+    }
+}

package/src/OtherNotifier.ts

@@ -0,0 +1,35 @@
+import type { Id, IOLike } from "@pluv/types";
+import type { Subject } from "wonka";
+import { makeSubject, subscribe } from "wonka";
+import { UserInfo } from "./types";
+
+export type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (
+    value: Id<UserInfo<TIO>> | null
+) => void;
+
+export class OtherNotifier<TIO extends IOLike> {
+    public subjects = new Map<string, Subject<Id<UserInfo<TIO>> | null>>();
+
+    public subject<TEvent extends string>(
+        name: TEvent
+    ): Subject<Id<UserInfo<TIO>> | null> {
+        const subject = this.subjects.get(name);
+
+        if (subject) return subject;
+
+        const newSubject = makeSubject<Id<UserInfo<TIO>>>();
+
+        this.subjects.set(name, newSubject);
+
+        return newSubject;
+    }
+
+    public subscribe<TEvent extends string>(
+        name: TEvent,
+        callback: OtherNotifierSubscriptionCallback<TIO>
+    ): () => void {
+        const source = this.subject(name).source;
+
+        return subscribe(callback)(source).unsubscribe;
+    }
+}

package/src/PluvClient.ts

@@ -0,0 +1,81 @@
+import type { IOLike, JsonObject } from "@pluv/types";
+import { AbstractType } from "yjs";
+import type {
+    AuthEndpoint,
+    RoomEndpoints,
+    PluvRoomOptions,
+    WsEndpoint,
+} from "./PluvRoom";
+import { PluvRoom } from "./PluvRoom";
+
+export type PluvClientOptions<TIO extends IOLike> = RoomEndpoints<TIO>;
+
+export class PluvClient<TIO extends IOLike = IOLike> {
+    private _authEndpoint: AuthEndpoint;
+    private _wsEndpoint: WsEndpoint;
+
+    private _rooms = new Map<string, PluvRoom<TIO, JsonObject, any>>();
+
+    constructor(options: PluvClientOptions<TIO>) {
+        this._authEndpoint = options.authEndpoint as AuthEndpoint;
+        this._wsEndpoint = options.wsEndpoint;
+    }
+
+    public createRoom = <
+        TPresence extends JsonObject = {},
+        TStorage extends Record<string, AbstractType<any>> = {}
+    >(
+        room: string,
+        options: PluvRoomOptions<TIO, TPresence, TStorage>
+    ): PluvRoom<TIO, TPresence, TStorage> => {
+        const oldRoom = this.getRoom<TPresence, TStorage>(room);
+
+        if (oldRoom) return oldRoom;
+
+        const newRoom = new PluvRoom<TIO, TPresence, TStorage>(room, {
+            authEndpoint: this._authEndpoint,
+            debug: options.debug,
+            initialPresence: options.initialPresence,
+            initialStorage: options.initialStorage,
+            onAuthorizationFail: options.onAuthorizationFail,
+            wsEndpoint: this._wsEndpoint,
+        });
+
+        this._rooms.set(room, newRoom);
+
+        return newRoom;
+    };
+
+    public enter = async (room: string): Promise<void> => {
+        const toEnter = this.getRoom(room);
+
+        if (!toEnter) {
+            throw new Error(`Could not find room: ${room}.`);
+        }
+
+        await toEnter.connect();
+    };
+
+    public getRoom = <
+        TPresence extends JsonObject = {},
+        TStorage extends Record<string, AbstractType<any>> = {}
+    >(
+        room: string
+    ): PluvRoom<TIO, TPresence, TStorage> | null => {
+        const found = this._rooms.get(room) as
+            | PluvRoom<TIO, TPresence, TStorage>
+            | undefined;
+
+        return found ?? null;
+    };
+
+    public leave = (room: string): void => {
+        const toLeave = this.getRoom(room);
+
+        if (!toLeave) return;
+
+        toLeave.disconnect();
+
+        this._rooms.delete(room);
+    };
+}