@pluv/client 0.0.0

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["pluv"],
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+
+> @pluv/client@0.0.0 build /home/runner/work/pluv/pluv/packages/client
+> tsup src/index.ts --format esm,cjs --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v6.5.0
+CLI Target: es6
+ESM Build start
+CJS Build start
+CJS dist/index.js 29.80 KB
+CJS ⚡️ Build success in 129ms
+ESM dist/index.mjs 28.72 KB
+ESM ⚡️ Build success in 136ms
+DTS Build start
+DTS ⚡️ Build success in 3389ms
+DTS dist/index.d.ts 8.01 KB

package/dist/index.d.ts

@@ -0,0 +1,193 @@
+import { InferYjsSharedTypeJson, array, map, text, unstable__object } from '@pluv/crdt-yjs';
+export { InferYjsSharedTypeJson } from '@pluv/crdt-yjs';
+import * as _pluv_types from '@pluv/types';
+import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, InferIOAuthorizeUser, InferIOAuthorize, InputZodLike, InferIOInput, InferEventMessage, InferIOAuthorizeRequired } from '@pluv/types';
+export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
+import { AbstractType } from 'yjs';
+export { AbstractType } from 'yjs';
+import { Subject } from 'wonka';
+
+interface CrdtManagerOptions<TStorage extends Record<string, AbstractType<any>> = {}> {
+    encodedState?: string | Uint8Array;
+    initialStorage?: () => TStorage;
+}
+
+type EventNotifierSubscriptionCallback<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+
+interface AuthorizationState<TIO extends IOLike> {
+    token: string | null;
+    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
+}
+declare enum ConnectionState {
+    Closed = "Closed",
+    Connecting = "Connecting",
+    Open = "Open",
+    Unavailable = "Unavailable",
+    Untouched = "Untouched"
+}
+interface WebSocketConnection {
+    id: string | null;
+    state: ConnectionState;
+}
+interface WebSocketState<TIO extends IOLike> {
+    authorization: AuthorizationState<TIO>;
+    connection: WebSocketConnection;
+    webSocket: WebSocket | null;
+}
+interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+    connectionId: string;
+    presence: TPresence;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+}
+
+type OtherNotifierSubscriptionCallback<TIO extends IOLike> = (value: Id<UserInfo<TIO>> | null) => void;
+
+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;
+type SubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+
+type UsersManagerConfig<TPresence extends JsonObject = {}> = {
+    initialPresence?: TPresence;
+    presence?: InputZodLike<TPresence>;
+};
+
+declare global {
+    var process: {
+        env: {
+            [key: string]: string | undefined;
+        };
+    };
+}
+type AuthEndpoint = string | ((room: string) => FetchOptions);
+type WsEndpoint = string | ((room: string) => string);
+type FetchOptions = string | {
+    url: string;
+    options?: RequestInit;
+};
+type RoomEndpoints<TIO extends IOLike> = {
+    wsEndpoint: WsEndpoint;
+} & (InferIOAuthorizeRequired<InferIOAuthorize<TIO>> extends true ? {
+    authEndpoint: AuthEndpoint;
+} : {
+    authEndpoint?: AuthEndpoint;
+});
+type PluvRoomDebug<TIO extends IOLike> = Id<{
+    output: readonly (keyof InferIOOutput<TIO>)[];
+    input: readonly (keyof InferIOInput<TIO>)[];
+}>;
+type PluvRoomOptions<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = {
+    debug?: boolean | PluvRoomDebug<TIO>;
+    onAuthorizationFail?: (error: Error) => void;
+} & CrdtManagerOptions<TStorage> & UsersManagerConfig<TPresence>;
+type RoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = RoomEndpoints<TIO> & PluvRoomOptions<TIO, TPresence, TStorage>;
+declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+    readonly _endpoints: RoomEndpoints<TIO>;
+    readonly room: string;
+    private _crdtManager;
+    private _crdtNotifier;
+    private _debug;
+    private _eventNotifier;
+    private _initialStorage;
+    private _intervals;
+    private _listeners;
+    private _otherNotifier;
+    private _state;
+    private _stateNotifier;
+    private _subscriptions;
+    private _timeouts;
+    private _windowListeners;
+    private _wsListeners;
+    private _usersManager;
+    constructor(room: string, options: RoomConfig<TIO, TPresence, TStorage>);
+    get webSocket(): WebSocket | null;
+    broadcast(message: InferEventMessage<InferIOInput<TIO>>): void;
+    connect(): Promise<void>;
+    disconnect(): void;
+    event: <TEvent extends keyof InferIOOutput<TIO>>(name: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
+    getConnection(): WebSocketConnection;
+    getMyPresence: () => TPresence | null;
+    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
+    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
+    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
+    getStorage: <TKey extends keyof TStorage>(key: TKey) => TStorage[TKey] | null;
+    other: (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>) => (() => void);
+    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void) => (() => void);
+    subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
+    private _attachWindowListeners;
+    private _attachWsListeners;
+    private _clearInterval;
+    private _clearTimeout;
+    private _closeWs;
+    private _detachWindowListeners;
+    private _detachWsListeners;
+    private _getAuthorization;
+    private _getWsEndpoint;
+    private _handleExit;
+    private _handlePresenceUpdatedMessage;
+    private _handleReceiveOthers;
+    private _handleRegisteredMessage;
+    private _handleStorageReceivedMessage;
+    private _handleStorageUpdatedMessage;
+    private _handleUserJoinedMessage;
+    private _heartbeat;
+    private _logDebug;
+    private _observeCrdt;
+    private _onAuthorizationFail;
+    /**
+     * TODO
+     * @description Determine if ws was closed with a code for closing without retries.
+     * Otherwise, attempt to retry again with incremental backoff
+     * @author leedavidcs
+     * @date August 19, 2022
+     */
+    private _onClose;
+    /**
+     * TODO
+     * @description Handle websocket errors in a meaningful way, should they occur
+     * @author leedavidcs
+     * @date August 19, 2022
+     */
+    private _onError;
+    private _onMessage;
+    private _onOpen;
+    private _onNavigatorOnline;
+    private _onVisibilityChange;
+    private _parseMessage;
+    private _reconnect;
+    private _sendMessage;
+    private _updateState;
+}
+
+type PluvClientOptions<TIO extends IOLike> = RoomEndpoints<TIO>;
+declare class PluvClient<TIO extends IOLike = IOLike> {
+    private _authEndpoint;
+    private _wsEndpoint;
+    private _rooms;
+    constructor(options: PluvClientOptions<TIO>);
+    createRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(room: string, options: PluvRoomOptions<TIO, TPresence, TStorage>) => PluvRoom<TIO, TPresence, TStorage>;
+    enter: (room: string) => Promise<void>;
+    getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(room: string) => PluvRoom<TIO, TPresence, TStorage> | null;
+    leave: (room: string) => void;
+}
+
+declare const createClient: <TIO extends IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}> = IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}>>(options: PluvClientOptions<TIO>) => PluvClient<TIO>;
+
+declare const y_array: typeof array;
+declare const y_map: typeof map;
+declare const y_text: typeof text;
+declare const y_unstable__object: typeof unstable__object;
+declare namespace y {
+  export {
+    y_array as array,
+    y_map as map,
+    y_text as text,
+    y_unstable__object as unstable__object,
+  };
+}
+
+export { ConnectionState, PluvClient, PluvClientOptions, PluvRoom, PluvRoomDebug, UserInfo, WebSocketConnection, WebSocketState, createClient, y };