@pluv/client 0.9.0 → 0.9.1

package/.turbo/turbo-build.log

@@ -1,17 +1,18 @@
 
-> @pluv/client@0.9.0 build /home/runner/work/pluv/pluv/packages/client
+> @pluv/client@0.9.1 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 v7.0.0
+CLI tsup v7.1.0
 CLI Target: es6
 ESM Build start
 CJS Build start
-CJS dist/index.js 40.23 KB
-CJS ⚡️ Build success in 98ms
 ESM dist/index.mjs 39.02 KB
-ESM ⚡️ Build success in 100ms
+ESM ⚡️ Build success in 135ms
+CJS dist/index.js 40.23 KB
+CJS ⚡️ Build success in 135ms
 DTS Build start
-DTS ⚡️ Build success in 4765ms
-DTS dist/index.d.ts 12.92 KB
+DTS ⚡️ Build success in 4784ms
+DTS dist/index.d.mts 12.92 KB
+DTS dist/index.d.ts  12.92 KB

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @pluv/client
 
+## 0.9.1
+
+### Patch Changes
+
+- 8fba48b: fix including incorrect dependency
+- 8997c65: bumped dependencies
+- Updated dependencies [8fba48b]
+- Updated dependencies [8997c65]
+  - @pluv/crdt-yjs@0.4.1
+  - @pluv/types@0.2.2
+
 ## 0.9.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -0,0 +1,273 @@
+import { InferYjsSharedTypeJson, array, map, object, text } 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, InferIOInput, InputZodLike, InferIOAuthorizeRequired } from '@pluv/types';
+export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
+import { AbstractType } from 'yjs';
+export { AbstractType } from 'yjs';
+import { Subject } from 'wonka';
+
+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 {
+    count: number;
+    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;
+
+declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+    readonly id: string;
+    constructor(room: string);
+    abstract broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    abstract event<TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>): () => void;
+    abstract getConnection(): WebSocketConnection;
+    abstract getMyPresence(): TPresence;
+    abstract getMyself(): Id<UserInfo<TIO, TPresence>> | null;
+    abstract getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
+    abstract getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
+    abstract getStorage<TKey extends keyof TStorage>(key: TKey): TStorage[TKey] | null;
+    abstract other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>): () => void;
+    abstract storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void): () => void;
+    abstract subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
+    abstract updateMyPresence(presence: Partial<TPresence>): void;
+}
+
+declare abstract class AbstractStorageStore {
+    room: string;
+    constructor(room: string);
+    abstract addUpdate(update: string): Promise<void>;
+    abstract destroy(): Promise<void>;
+    abstract flatten(encodedState: string): Promise<void>;
+    abstract getShouldFlatten(): Promise<boolean>;
+    abstract getUpdates(start?: number): Promise<readonly string[]>;
+    abstract initialize(): Promise<void>;
+}
+
+interface CrdtManagerOptions<TStorage extends Record<string, AbstractType<any>> = {}> {
+    encodedState?: string | Uint8Array | null;
+    initialStorage?: () => TStorage;
+}
+
+type UsersManagerConfig<TPresence extends JsonObject = {}> = {
+    initialPresence?: TPresence;
+    presence?: InputZodLike<TPresence>;
+};
+
+declare global {
+    var process: {
+        env: {
+            [key: string]: string | undefined;
+        };
+    };
+}
+type AuthEndpoint = string | ((room: string) => string | FetchOptions) | true;
+type WsEndpoint = string | ((room: string) => string);
+type FetchOptions = {
+    url: string;
+    options?: RequestInit;
+};
+type RoomEndpoints<TIO extends IOLike> = {
+    wsEndpoint?: WsEndpoint;
+} & (InferIOAuthorizeRequired<InferIOAuthorize<TIO>> extends true ? {
+    authEndpoint: AuthEndpoint;
+} : {
+    authEndpoint?: undefined;
+});
+type PluvRoomAddon<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
+interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+    room: PluvRoom<TIO, TPresence, TStorage>;
+}
+interface PluvRoomAddonResult {
+    storage: AbstractStorageStore;
+}
+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>> = {}> = {
+    addons?: readonly PluvRoomAddon<TIO, TPresence, TStorage>[];
+    debug?: boolean | PluvRoomDebug<TIO>;
+    onAuthorizationFail?: (error: Error) => void;
+} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & 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>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+    readonly _endpoints: RoomEndpoints<TIO>;
+    private _crdtManager;
+    private _crdtNotifier;
+    private _debug;
+    private _eventNotifier;
+    private _intervals;
+    private _listeners;
+    private _otherNotifier;
+    private _state;
+    private _stateNotifier;
+    private _storageStore;
+    private _subscriptions;
+    private _timeouts;
+    private _windowListeners;
+    private _wsListeners;
+    private _usersManager;
+    constructor(room: string, options: RoomConfig<TIO, TPresence, TStorage>);
+    get webSocket(): WebSocket | null;
+    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
+    getConnection(): WebSocketConnection;
+    getMyPresence: () => TPresence;
+    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);
+    updateMyPresence: (presence: Partial<TPresence>) => void;
+    private _addToStorageStore;
+    private _applyStorageStore;
+    private _attachWindowListeners;
+    private _attachWsListeners;
+    private _clearInterval;
+    private _clearTimeout;
+    private _closeWs;
+    private _detachWindowListeners;
+    private _detachWsListeners;
+    private _emitSharedTypes;
+    private _flattenStorageStore;
+    private _getAddon;
+    private _getAuthFetchOptions;
+    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> & {
+    debug?: boolean;
+};
+declare class PluvClient<TIO extends IOLike = IOLike> {
+    private _authEndpoint;
+    private _debug;
+    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 | PluvRoom<TIO, any, any>) => Promise<PluvRoom<TIO, JsonObject, any>>;
+    getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(room: string) => PluvRoom<TIO, TPresence, TStorage> | null;
+    getRooms: () => readonly PluvRoom<TIO, JsonObject, any>[];
+    leave: (room: string | PluvRoom<TIO, any, any>) => Promise<void>;
+    private _logDebug;
+}
+
+declare const createClient: <TIO extends IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}, {}, {}> = IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}, {}, {}>>(options: PluvClientOptions<TIO>) => PluvClient<TIO>;
+
+type MockedRoomEvents<TIO extends IOLike> = Partial<{
+    [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
+}>;
+type MockedRoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = {
+    events?: MockedRoomEvents<TIO>;
+} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
+declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+    private _crdtManager;
+    private _crdtNotifier;
+    private _eventNotifier;
+    private _events?;
+    private _otherNotifier;
+    private _state;
+    private _stateNotifier;
+    private _subscriptions;
+    private _usersManager;
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage>);
+    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
+    getConnection(): WebSocketConnection;
+    getMyPresence: () => TPresence;
+    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);
+    updateMyPresence: (presence: Partial<TPresence>) => void;
+    private _observeCrdt;
+}
+
+declare const y_array: typeof array;
+declare const y_map: typeof map;
+declare const y_object: typeof object;
+declare const y_text: typeof text;
+declare namespace y {
+  export {
+    y_array as array,
+    y_map as map,
+    y_object as object,
+    y_text as text,
+  };
+}
+
+export { AbstractRoom, AbstractStorageStore, ConnectionState, MockedRoom, MockedRoomConfig, MockedRoomEvents, PluvClient, PluvClientOptions, PluvRoom, PluvRoomAddon, PluvRoomAddonInput, PluvRoomAddonResult, PluvRoomDebug, UserInfo, WebSocketConnection, WebSocketState, createClient, y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/client",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "@pluv/io frontend client",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,21 +17,20 @@
     "access": "public"
   },
   "dependencies": {
-    "@playwright/test": "^1.35.1",
-    "@types/react": "^18.2.13",
+    "@types/react": "^18.2.15",
     "wonka": "^6.3.2",
-    "@pluv/crdt-yjs": "^0.4.0",
-    "@pluv/types": "^0.2.1"
+    "@pluv/crdt-yjs": "^0.4.1",
+    "@pluv/types": "^0.2.2"
   },
   "peerDependencies": {
     "yjs": "^13.0.0"
   },
   "devDependencies": {
-    "tsup": "^7.0.0",
-    "typescript": "^5.1.3",
-    "yjs": "^13.6.4",
-    "@pluv/tsconfig": "^0.1.7",
-    "eslint-config-pluv": "^0.1.13"
+    "tsup": "^7.1.0",
+    "typescript": "^5.1.6",
+    "yjs": "^13.6.6",
+    "@pluv/tsconfig": "^0.1.8",
+    "eslint-config-pluv": "^0.1.14"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/utils/debounce.ts

@@ -1,6 +1,6 @@
 export const debounce = <TFunc extends (...args: any[]) => any>(
     fn: TFunc,
-    options?: { wait: number; immediate?: boolean }
+    options?: { wait: number; immediate?: boolean },
 ): ((...args: Parameters<TFunc>) => void) => {
     const { wait, immediate = false } = options ?? {};