@pluv/client 0.0.0

package/src/StateNotifier.ts

@@ -0,0 +1,55 @@
+import type { Id, IOLike, JsonObject } 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>>>;
+    "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;
+
+export type SubscriptionCallback<
+    TIO extends IOLike,
+    TPresence extends JsonObject,
+    TSubject extends keyof StateNotifierSubjects<TIO, TPresence>
+> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+
+export class StateNotifier<
+    TIO extends IOLike,
+    TPresence extends JsonObject = {}
+> {
+    public subjects: StateNotifierSubjects<TIO, TPresence> = {
+        connection: makeSubject<Id<WebSocketState<TIO>>>(),
+        "my-presence": makeSubject<TPresence>(),
+        myself: makeSubject<Readonly<Id<UserInfo<TIO>>> | null>(),
+        others: makeSubject<readonly Id<UserInfo<TIO>>[]>(),
+    };
+
+    public subscribe<
+        TSubject extends keyof StateNotifierSubjects<TIO, TPresence>
+    >(
+        name: TSubject,
+        callback: SubscriptionCallback<TIO, TPresence, TSubject>
+    ): () => void {
+        const source = this.subjects[name]?.source as any;
+
+        if (!source) throw new Error(`Could not subscribe to source: ${name}`);
+
+        return subscribe(callback)(source).unsubscribe;
+    }
+}

package/src/UsersManager.ts

@@ -0,0 +1,128 @@
+import type {
+    Id,
+    InferIOAuthorize,
+    InferIOAuthorizeUser,
+    InputZodLike,
+    IOLike,
+    JsonObject,
+} from "@pluv/types";
+import type { UserInfo } from "./types";
+
+export type Presence = Record<string, unknown>;
+
+export type UsersManagerConfig<TPresence extends JsonObject = {}> = {
+    initialPresence?: TPresence;
+    presence?: InputZodLike<TPresence>;
+};
+
+export class UsersManager<
+    TIO extends IOLike,
+    TPresence extends JsonObject = {}
+> {
+    private _initialPresence: TPresence;
+    private _myself: UserInfo<TIO, TPresence> | null = null;
+    private _others = new Map<string, UserInfo<TIO, TPresence>>();
+    private _presence: InputZodLike<TPresence> | null = null;
+
+    constructor(config: UsersManagerConfig<TPresence>) {
+        const { initialPresence, presence = null } = config;
+
+        this._initialPresence = initialPresence as TPresence;
+        this._presence = presence;
+    }
+
+    public get myself(): UserInfo<TIO, TPresence> | null {
+        return this._myself;
+    }
+
+    public clear(): void {
+        this._others.clear();
+    }
+
+    public getOther(connectionId: string): UserInfo<TIO, TPresence> | null {
+        return this._others.get(connectionId) ?? null;
+    }
+
+    public getOthers(): readonly UserInfo<TIO, TPresence>[] {
+        return Array.from(this._others.values());
+    }
+
+    public patchPresence(
+        connectionId: string,
+        patch: Partial<TPresence>
+    ): void {
+        if (this._myself?.connectionId === connectionId) {
+            this._myself.presence = Object.assign(
+                Object.create(null),
+                this._myself.presence,
+                patch
+            ) as TPresence;
+
+            return;
+        }
+
+        const other = this._others.get(connectionId);
+
+        if (!other) return;
+
+        const presence = Object.assign(
+            Object.create(null),
+            other.presence,
+            patch
+        ) as TPresence;
+
+        this._presence?.parse(presence);
+
+        this._others.set(connectionId, { ...other, presence });
+    }
+
+    public removeMyself(): void {
+        this._myself = null;
+    }
+
+    public removeUser(connectionId: string): void {
+        this._others.delete(connectionId);
+    }
+
+    public setMyself(
+        connectionId: string,
+        user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>
+    ): void {
+        this._myself = {
+            connectionId,
+            presence: this._initialPresence,
+            user,
+        };
+    }
+
+    public setPresence(connectionId: string, presence: TPresence): void {
+        if (this._myself?.connectionId === connectionId) {
+            this._myself.presence = presence;
+
+            return;
+        }
+
+        const other = this._others.get(connectionId);
+
+        if (!other) return;
+
+        this._others.set(connectionId, { ...other, presence });
+    }
+
+    public setUser(
+        connectionId: string,
+        user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>
+    ): void {
+        if (this._myself?.connectionId === connectionId) return;
+
+        const other = this._others.get(connectionId);
+
+        if (other) return;
+
+        this._others.set(connectionId, {
+            connectionId,
+            presence: this._initialPresence,
+            user,
+        });
+    }
+}

package/src/createClient.ts

@@ -0,0 +1,9 @@
+import type { IOLike } from "@pluv/types";
+import type { PluvClientOptions } from "./PluvClient";
+import { PluvClient } from "./PluvClient";
+
+export const createClient = <TIO extends IOLike = IOLike>(
+    options: PluvClientOptions<TIO>
+): PluvClient<TIO> => {
+    return new PluvClient<TIO>(options);
+};

package/src/index.ts

@@ -0,0 +1,16 @@
+export type { InferYjsSharedTypeJson } from "@pluv/crdt-yjs";
+export type {
+    BaseUser,
+    EventMessage,
+    EventRecord,
+    IOEventMessage,
+} from "@pluv/types";
+export type { AbstractType } from "yjs";
+export { createClient } from "./createClient";
+export type { PluvClientOptions } from "./PluvClient";
+export { PluvClient } from "./PluvClient";
+export type { PluvRoomDebug } from "./PluvRoom";
+export { PluvRoom } from "./PluvRoom";
+export type { WebSocketConnection, UserInfo, WebSocketState } from "./types";
+export { ConnectionState } from "./types";
+export * as y from "./y";

package/src/types.ts

@@ -0,0 +1,40 @@
+import type {
+    Id,
+    InferIOAuthorize,
+    InferIOAuthorizeUser,
+    IOLike,
+    JsonObject,
+} from "@pluv/types";
+
+export interface AuthorizationState<TIO extends IOLike> {
+    token: string | null;
+    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
+}
+
+export enum ConnectionState {
+    Closed = "Closed",
+    Connecting = "Connecting",
+    Open = "Open",
+    Unavailable = "Unavailable",
+    Untouched = "Untouched",
+}
+
+export interface WebSocketConnection {
+    id: string | null;
+    state: ConnectionState;
+}
+
+export interface WebSocketState<TIO extends IOLike> {
+    authorization: AuthorizationState<TIO>;
+    connection: WebSocketConnection;
+    webSocket: WebSocket | null;
+}
+
+export interface UserInfo<
+    TIO extends IOLike,
+    TPresence extends JsonObject = {}
+> {
+    connectionId: string;
+    presence: TPresence;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+}

package/src/y.ts

@@ -0,0 +1 @@
+export { array, map, text, unstable__object } from "@pluv/crdt-yjs";

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+	"extends": "@pluv/tsconfig/frontend-generic.json",
+	"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+	"exclude": ["node_modules"]
+}