@pluv/io 0.6.0 → 0.7.1

package/.eslintrc.js

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

package/.turbo/turbo-build.log

@@ -1,17 +1,18 @@
 
-> @pluv/io@0.6.0 build /home/runner/work/pluv/pluv/packages/io
+> @pluv/io@0.7.1 build /home/runner/work/pluv/pluv/packages/io
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
-CLI tsup v6.7.0
+CLI tsup v7.1.0
 CLI Target: es6
 ESM Build start
 CJS Build start
-ESM dist/index.mjs 28.98 KB
-ESM ⚡️ Build success in 93ms
-CJS dist/index.js 31.04 KB
-CJS ⚡️ Build success in 93ms
+CJS dist/index.js 31.08 KB
+CJS ⚡️ Build success in 133ms
+ESM dist/index.mjs 29.02 KB
+ESM ⚡️ Build success in 134ms
 DTS Build start
-DTS ⚡️ Build success in 3311ms
-DTS dist/index.d.ts 17.03 KB
+DTS ⚡️ Build success in 4386ms
+DTS dist/index.d.mts 17.03 KB
+DTS dist/index.d.ts  17.03 KB

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # @pluv/io
 
+## 0.7.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.7.0
+
+### Minor Changes
+
+- 829d31b: Added support for defining persistant frontend storage for rooms via a new `addons` option on rooms.
+
+  This also introduces the first new addon `@pluv/addon-indexeddb`, which is more-or-less the equivalent to `y-indexeddb` which you can install like so:
+
+  ```
+  npm install @pluv/addon-indexeddb
+  ```
+
+  To use this new addon, simply pass it to options when creating a room:
+
+  ```ts
+  import { addonIndexedDB } from "@pluv/addon-indexeddb";
+  import { createClient } from "@pluv/client";
+
+  const client = createClient({
+    // ...
+  });
+
+  const room = client.createRoom("my-new-room", {
+    addons: [
+      // Define your addons in an array like so
+      addonIndexedDB(),
+    ],
+  });
+  ```
+
+  Or when using `@pluv/react`:
+
+  ```ts
+  const PluvRoom = createRoomBundle({
+    // ...
+    addons: [
+      // Define your addons in an array like so
+      addonIndexedDB(),
+    ],
+  });
+  ```
+
+### Patch Changes
+
+- 8d11672: bumped dependencies to latest
+- Updated dependencies [8d11672]
+- Updated dependencies [829d31b]
+  - @pluv/crdt-yjs@0.4.0
+  - @pluv/types@0.2.1
+
 ## 0.6.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -0,0 +1,287 @@
+import { JsonObject, MaybePromise, IOEventMessage, EventRecord, InputZodLike, Id, IOLike, InferIOOutput, IOAuthorize, BaseIOAuthorize, InferIOInput, BaseUser, InferIOAuthorizeUser, InferIOAuthorize, Spread, InferIOOutputBroadcast, InferIOOutputSelf, InferIOOutputSync, Maybe, BaseClientEventRecord, BaseIOEventRecord } from '@pluv/types';
+export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
+import { YjsDoc } from '@pluv/crdt-yjs';
+
+declare abstract class AbstractPersistance {
+    abstract addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void>;
+    abstract deleteStorageState(room: string): Promise<void>;
+    abstract deleteUser(room: string, connectionId: string): Promise<void>;
+    abstract deleteUsers(room: string): Promise<void>;
+    abstract getSize(room: string): Promise<number>;
+    abstract getStorageState(room: string): Promise<string | null>;
+    abstract getUser(room: string, connectionId: string): Promise<JsonObject | null>;
+    abstract getUsers(room: string): Promise<readonly (JsonObject | null)[]>;
+    abstract setStorageState(room: string, state: string): Promise<void>;
+}
+
+type AbstractEvent = {};
+type AbstractCloseEvent = AbstractEvent & {
+    readonly code: number;
+    readonly reason: string;
+};
+type AbstractMessageEvent<T = any> = AbstractEvent & {
+    readonly data: T;
+};
+type AbstractErrorEvent = AbstractEvent & {
+    error: unknown;
+    message: string;
+};
+interface AbstractEventMap {
+    close: AbstractCloseEvent;
+    message: AbstractMessageEvent;
+    error: AbstractErrorEvent;
+}
+type EventType = keyof AbstractEventMap;
+interface AbstractWebSocketHandleErrorParams {
+    error: unknown;
+    message?: string;
+    session?: WebSocketSession;
+}
+type AbstractListener<TType extends keyof AbstractEventMap> = (event: AbstractEventMap[TType]) => MaybePromise<void>;
+interface AbstractWebSocketConfig {
+    pubSub?: AbstractPubSub;
+    room: string;
+}
+declare abstract class AbstractWebSocket {
+    /** The connection is not yet open. */
+    readonly CONNECTING = 0;
+    /** The connection is open and ready to communicate. */
+    readonly OPEN = 1;
+    /** The connection is in the process of closing. */
+    readonly CLOSING = 2;
+    /** The connection is closed. */
+    readonly CLOSED = 3;
+    pubSub?: AbstractPubSub;
+    room: string;
+    abstract get readyState(): 0 | 1 | 2 | 3;
+    constructor(config: AbstractWebSocketConfig);
+    /**
+     * TODO
+     * @description Return an unsubscribe method to remove the event-listener.
+     * This is preferred over adding an explicit abstract removeEventListener
+     * method, because the implementing class might have to transform the
+     * listener, and removing the same listener might be complicated as a
+     * result.
+     * @author leedavidcs
+     * @date August 28, 2022
+     */
+    abstract addEventListener<TType extends EventType>(type: TType, handler: AbstractListener<TType>): void;
+    abstract close(code?: number | undefined, reason?: string | undefined): void;
+    abstract initialize(): Promise<() => void>;
+    abstract send(message: ArrayBuffer | ArrayBufferView | string): void;
+    abstract terminate(): void;
+    handleError(params: AbstractWebSocketHandleErrorParams): void;
+    sendMessage<TMessage extends IOEventMessage<any> = IOEventMessage<any>>(data: TMessage): void;
+}
+
+declare global {
+    var console: {
+        log: (...data: any[]) => void;
+    };
+}
+interface EventConfig<TPlatform extends AbstractPlatform = AbstractPlatform, TContext extends Record<string, any> = {}, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}, TResultSelf extends EventRecord<string, any> = {}, TResultSync extends EventRecord<string, any> = {}> {
+    input?: InputZodLike<TData>;
+    resolver: EventResolver<TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>, TData, TResultBroadcast> | EventResolverObject<TPlatform, TContext, TData, TResultBroadcast, TResultSelf, TResultSync>;
+}
+type SyncEventResolver<TContext extends Record<string, any> = {}, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}> = (data: TData, context: EventResolverContext<TContext>) => MaybePromise<TResultBroadcast | void>;
+type EventResolver<TContext extends Record<string, any> = {}, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}> = (data: TData, context: EventResolverContext<TContext>) => MaybePromise<TResultBroadcast | void>;
+interface EventResolverContext<TContext extends Record<string, any> = {}> {
+    context: TContext;
+    doc: YjsDoc<any>;
+    room: string;
+    /**
+     * !HACK
+     * @description Session should only not exist when invoking the event as a
+     * "sync" event on another machine where the session doesn't exist. There must
+     * be a better way to handle this, but going to make this nullable for ease
+     * for now.
+     *
+     * `session` should not be referenced most of the time anyhow (outside of
+     * internal to this library).
+     * @author leedavidcs
+     * @date December 25, 2022
+     */
+    session: WebSocketSession | null;
+    sessions: Map<string, WebSocketSession>;
+}
+type EventResolverObject<TPlatform extends AbstractPlatform = AbstractPlatform, TContext extends Record<string, any> = {}, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}, TResultSelf extends EventRecord<string, any> = {}, TResultSync extends EventRecord<string, any> = {}> = {
+    broadcast?: EventResolver<TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>, TData, TResultBroadcast>;
+    self?: EventResolver<TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>, TData, TResultSelf>;
+    sync?: SyncEventResolver<TContext, TData, TResultSync>;
+};
+type InferEventConfig<TPlatform extends AbstractPlatform = AbstractPlatform, TContext extends Record<string, any> = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> = {
+    [P in keyof TInput]: P extends string ? Id<EventConfig<TPlatform, TContext, TInput[P], TOutputBroadcast, TOutputSelf, TOutputSync>> : never;
+};
+type SendMessageOptions = {
+    type?: "broadcast";
+    sessionIds?: readonly string[];
+} | {
+    type: "self";
+} | {
+    type: "sync";
+};
+interface WebSocketSessionTimers {
+    ping: number;
+}
+interface WebSocketSession {
+    id: string;
+    presence: JsonObject | null;
+    quit: boolean;
+    room: string;
+    timers: WebSocketSessionTimers;
+    webSocket: AbstractWebSocket;
+    user: JsonObject | null;
+}
+
+type IOPubSubEventMessage<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = IOEventMessage<TIO, TEvent> & {
+    options?: SendMessageOptions;
+};
+declare abstract class AbstractPubSub {
+    abstract publish(roomName: string, payload: IOPubSubEventMessage<any>): Promise<void>;
+    abstract subscribe(roomName: string, onMessage: (message: IOPubSubEventMessage<any>) => void): Promise<number>;
+    abstract unsubscribe(subscriptionId: number): void;
+}
+
+type InferPlatformWebSocketType<TPlatform extends AbstractPlatform> = TPlatform extends AbstractPlatform<infer IWebSocket> ? IWebSocket : never;
+type InferPlatformRoomContextType<TPlatform extends AbstractPlatform> = TPlatform extends AbstractPlatform<any, infer IIOContext> ? IIOContext : never;
+type InferPlatformEventContextType<TPlatform extends AbstractPlatform> = TPlatform extends AbstractPlatform<any, any, infer IRoomContext> ? IRoomContext : never;
+type AbstractPlatformConfig = {
+    persistance?: undefined;
+    pubSub?: undefined;
+} | {
+    persistance: AbstractPersistance;
+    pubSub: AbstractPubSub;
+};
+interface ConvertWebSocketConfig {
+    room: string;
+}
+declare abstract class AbstractPlatform<TWebSocket = any, TIOContext extends Record<string, any> = {}, TRoomContext extends Record<string, any> = {}> {
+    readonly _ioContext: TIOContext | undefined;
+    readonly _roomContext: TRoomContext | undefined;
+    persistance: AbstractPersistance;
+    pubSub: AbstractPubSub;
+    constructor(config?: AbstractPlatformConfig);
+    abstract convertWebSocket(webSocket: TWebSocket, config: ConvertWebSocketConfig): AbstractWebSocket;
+    abstract parseData(data: string | ArrayBuffer): Record<string, any>;
+    abstract randomUUID(): string;
+}
+
+type IORoomListenerEvent<TPlatform extends AbstractPlatform> = {
+    room: string;
+    encodedState: string;
+} & InferPlatformRoomContextType<TPlatform>;
+interface IORoomListeners<TPlatform extends AbstractPlatform> {
+    onDestroy: (event: IORoomListenerEvent<TPlatform>) => void;
+}
+type IORoomConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> = Partial<IORoomListeners<TPlatform>> & {
+    authorize?: TAuthorize;
+    context: TContext & InferPlatformRoomContextType<TPlatform>;
+    debug: boolean;
+    events: InferEventConfig<TPlatform, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
+    platform: TPlatform;
+};
+type WebsocketRegisterOptions<TPlatform extends AbstractPlatform> = {
+    token?: string | null;
+} & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>;
+declare class IORoom<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends Record<string, any> = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> implements IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync> {
+    private readonly _context;
+    private readonly _debug;
+    private readonly _platform;
+    private _doc;
+    private _listeners;
+    private _sessions;
+    private _uninitialize;
+    readonly _authorize: TAuthorize | null;
+    readonly _events: InferEventConfig<TPlatform, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
+    readonly id: string;
+    constructor(id: string, config: IORoomConfig<TPlatform, TAuthorize, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>);
+    broadcast<TEvent extends keyof InferIOInput<this>>(event: TEvent, data: Id<InferIOInput<this>[TEvent]>): Promise<void>;
+    getSize(): number;
+    register(webSocket: InferPlatformWebSocketType<TPlatform>, options: WebsocketRegisterOptions<TPlatform>): Promise<void>;
+    private _broadcast;
+    private _emitQuitters;
+    private _emitRegistered;
+    private _getAuthorizedUser;
+    private _getEventConfig;
+    private _getEventInputs;
+    private _getEventResolverObject;
+    private _initialize;
+    private _logDebug;
+    private _onClose;
+    private _onMessage;
+    private _parseMessage;
+    private _sendMessage;
+    private _sendBroadcastMessage;
+    private _sendSelfMessage;
+    private _sendSyncMessage;
+}
+
+interface JWT<TUser extends BaseUser> {
+    room: string;
+    sub: string;
+    user: TUser;
+}
+interface JWTEncodeParams<TUser extends BaseUser> {
+    maxAge?: number;
+    room: string;
+    user: TUser;
+}
+interface AuthorizeParams {
+    platform: AbstractPlatform;
+    secret: string;
+}
+interface AuthorizeModule {
+    decode: <TUser extends BaseUser>(jwt: string) => Promise<TUser | null>;
+    encode: <TUser extends BaseUser>(params: JWTEncodeParams<TUser>) => Promise<string>;
+}
+
+type InferIOContext<TIO extends PluvIO<any, any, any, any, any, any, any>> = TIO extends PluvIO<any, any, infer IContext, any, any, any, any> ? IContext : never;
+type InferIOPlatform<TIO extends PluvIO<any, any, any, any, any, any, any>> = TIO extends PluvIO<infer IPlatform, any, any, any, any, any, any> ? IPlatform : never;
+type InferIORoom<TIO extends PluvIO<any, any, any, any, any, any, any>> = TIO extends PluvIO<infer IPlatform, infer IAuthorize, infer IContext, infer IInput, infer IOutputBroadcast, infer IOutputSelf, infer IOutputSync> ? IORoom<IPlatform, IAuthorize, IContext, IInput, IOutputBroadcast, IOutputSelf, IOutputSync> : never;
+type GetInitialStorageEvent<TPlatform extends AbstractPlatform> = {
+    room: string;
+} & InferPlatformRoomContextType<TPlatform>;
+type GetInitialStorageFn<TPlatform extends AbstractPlatform> = (event: GetInitialStorageEvent<TPlatform>) => MaybePromise<Maybe<string>>;
+interface PluvIOListeners<TPlatform extends AbstractPlatform> {
+    onRoomDeleted: (event: IORoomListenerEvent<TPlatform>) => void;
+    onStorageUpdated: (event: IORoomListenerEvent<TPlatform>) => void;
+}
+type PluvIOConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> | null = null, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> = Partial<PluvIOListeners<TPlatform>> & {
+    authorize?: TAuthorize;
+    context?: TContext;
+    debug?: boolean;
+    events?: InferEventConfig<TPlatform, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
+    getInitialStorage?: GetInitialStorageFn<TPlatform>;
+    platform: TPlatform;
+};
+type GetRoomOptions<TPlatform extends AbstractPlatform> = {
+    debug?: boolean;
+} & InferPlatformRoomContextType<TPlatform>;
+declare class PluvIO<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutputBroadcast extends EventRecord<string, any> = {}, TOutputSelf extends EventRecord<string, any> = {}, TOutputSync extends EventRecord<string, any> = {}> implements IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync> {
+    private _context;
+    private _getInitialStorage;
+    private _rooms;
+    readonly _authorize: TAuthorize | null;
+    readonly _debug: boolean;
+    readonly _events: InferEventConfig<TPlatform, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
+    readonly _listeners: PluvIOListeners<TPlatform>;
+    readonly _platform: TPlatform;
+    constructor(options: PluvIOConfig<TPlatform, TAuthorize, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>);
+    createToken(params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>>): Promise<string>;
+    event<TEvent extends string, TData extends JsonObject = {}, TResultBroadcast extends EventRecord<string, any> = {}, TResultSelf extends EventRecord<string, any> = {}, TResultSync extends EventRecord<string, any> = {}>(event: TEvent, config: EventConfig<TPlatform, TContext, TData, TResultBroadcast, TResultSelf, TResultSync>): PluvIO<TPlatform, TAuthorize, TContext, Spread<[TInput, EventRecord<TEvent, TData>]>, Spread<[TOutputBroadcast, TResultBroadcast]>, Spread<[TOutputSelf, TResultSelf]>, Spread<[TOutputSync, TResultSync]>>;
+    getRoom(room: string, options: GetRoomOptions<TPlatform>): IORoom<TPlatform, TAuthorize, TContext, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>;
+    static merge<TIO1 extends PluvIO, TIO2 extends PluvIO>(first: TIO1, second: TIO2): PluvIO<InferIOPlatform<TIO1>, InferIOAuthorize<TIO1>, InferIOContext<TIO1>, Spread<[InferIOInput<TIO1>, InferIOInput<TIO2>]>, Spread<[InferIOOutputBroadcast<TIO1>, InferIOOutputBroadcast<TIO2>]>, Spread<[InferIOOutputSelf<TIO1>, InferIOOutputSelf<TIO2>]>, Spread<[InferIOOutputSync<TIO1>, InferIOOutputSync<TIO2>]>>;
+    private _logDebug;
+    private _purgeEmptyRooms;
+}
+
+type CreateIOParams<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TContext extends JsonObject = {}, TAuthorizeUser extends BaseUser = BaseUser, TAuthorizeRequired extends boolean = false> = Partial<PluvIOListeners<TPlatform>> & {
+    authorize?: IOAuthorize<TAuthorizeUser, TAuthorizeRequired>;
+    context?: TContext;
+    debug?: boolean;
+    getInitialStorage?: GetInitialStorageFn<TPlatform>;
+    platform: TPlatform;
+};
+declare const createIO: <TPlatform extends AbstractPlatform<any, {}, {}> = AbstractPlatform<any, {}, {}>, TContext extends JsonObject = {}, TAuthorizeUser extends BaseUser = BaseUser, TAuthorizeRequired extends boolean = false>(params: CreateIOParams<TPlatform, TContext, TAuthorizeUser, TAuthorizeRequired>) => PluvIO<TPlatform, IOAuthorize<TAuthorizeUser, TAuthorizeRequired>, TContext, BaseClientEventRecord, BaseIOEventRecord<IOAuthorize<TAuthorizeUser, TAuthorizeRequired>>, {}, {}>;
+
+export { AbstractCloseEvent, AbstractErrorEvent, AbstractEvent, AbstractEventMap, AbstractListener, AbstractMessageEvent, AbstractPersistance, AbstractPlatform, AbstractPubSub, AbstractWebSocket, AbstractWebSocketConfig, AbstractWebSocketHandleErrorParams, AuthorizeModule, AuthorizeParams, ConvertWebSocketConfig, CreateIOParams, GetRoomOptions, IOPubSubEventMessage, IORoom, InferIORoom, InferPlatformEventContextType, InferPlatformRoomContextType, InferPlatformWebSocketType, JWT, JWTEncodeParams, PluvIO, PluvIOConfig, createIO };

package/dist/index.js

@@ -727,7 +727,7 @@ var IORoom = class {
 };
 
 // src/PluvIO.ts
-var PluvIO = class {
+var PluvIO = class _PluvIO {
   constructor(options) {
     this._context = {};
     this._getInitialStorage = null;
@@ -818,7 +818,7 @@ var PluvIO = class {
       },
       $UPDATE_STORAGE: {
         resolver: ({ origin, update }, { context, doc: doc2, room }) => {
-          if (origin === "$STORAGE_RECEIVED" && Object.keys(doc2.toJSON()).length) {
+          if (origin === "$INITIALIZED" && Object.keys(doc2.toJSON()).length) {
             return;
           }
           const updated = doc2.applyUpdate(update);
@@ -878,9 +878,9 @@ var PluvIO = class {
     const newEvent = {
       [event]: config
     };
-    return PluvIO.merge(
+    return _PluvIO.merge(
       this,
-      new PluvIO({
+      new _PluvIO({
         events: newEvent,
         platform: this._platform
       })
@@ -917,7 +917,9 @@ var PluvIO = class {
           const rooms = Array.from(this._rooms.keys());
           this._logDebug(`${import_kleur2.default.blue("Deleted room:")} ${room2}`);
           this._logDebug(
-            `${import_kleur2.default.blue("Rooms available:")} ${rooms.join(", ")}`
+            `${import_kleur2.default.blue("Rooms available:")} ${rooms.join(
+              ", "
+            )}`
           );
         }
       },
@@ -942,7 +944,7 @@ var PluvIO = class {
     const events2 = second._events;
     const { onRoomDeleted, onStorageUpdated } = first._listeners;
     const events = Object.assign(/* @__PURE__ */ Object.create(null), events1, events2);
-    return new PluvIO({
+    return new _PluvIO({
       authorize: authorize2,
       debug,
       events,

package/dist/index.mjs

@@ -690,7 +690,7 @@ var IORoom = class {
 };
 
 // src/PluvIO.ts
-var PluvIO = class {
+var PluvIO = class _PluvIO {
   constructor(options) {
     this._context = {};
     this._getInitialStorage = null;
@@ -781,7 +781,7 @@ var PluvIO = class {
       },
       $UPDATE_STORAGE: {
         resolver: ({ origin, update }, { context, doc: doc2, room }) => {
-          if (origin === "$STORAGE_RECEIVED" && Object.keys(doc2.toJSON()).length) {
+          if (origin === "$INITIALIZED" && Object.keys(doc2.toJSON()).length) {
             return;
           }
           const updated = doc2.applyUpdate(update);
@@ -841,9 +841,9 @@ var PluvIO = class {
     const newEvent = {
       [event]: config
     };
-    return PluvIO.merge(
+    return _PluvIO.merge(
       this,
-      new PluvIO({
+      new _PluvIO({
         events: newEvent,
         platform: this._platform
       })
@@ -880,7 +880,9 @@ var PluvIO = class {
           const rooms = Array.from(this._rooms.keys());
           this._logDebug(`${colors2.blue("Deleted room:")} ${room2}`);
           this._logDebug(
-            `${colors2.blue("Rooms available:")} ${rooms.join(", ")}`
+            `${colors2.blue("Rooms available:")} ${rooms.join(
+              ", "
+            )}`
           );
         }
       },
@@ -905,7 +907,7 @@ var PluvIO = class {
     const events2 = second._events;
     const { onRoomDeleted, onStorageUpdated } = first._listeners;
     const events = Object.assign(/* @__PURE__ */ Object.create(null), events1, events2);
-    return new PluvIO({
+    return new _PluvIO({
       authorize: authorize2,
       debug,
       events,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/io",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "@pluv/io server-side websocket manager",
   "author": "leedavidcs",
   "license": "MIT",
@@ -18,21 +18,22 @@
   },
   "dependencies": {
     "@panva/hkdf": "^1.1.1",
+    "@types/react": "^18.2.15",
     "jose": "^4.14.4",
     "kleur": "^4.1.5",
     "wonka": "^6.3.2",
-    "@pluv/crdt-yjs": "^0.3.8",
-    "@pluv/types": "^0.2.0"
+    "@pluv/crdt-yjs": "^0.4.1",
+    "@pluv/types": "^0.2.2"
   },
   "peerDependencies": {
     "yjs": "^13.0.0"
   },
   "devDependencies": {
-    "tsup": "^6.7.0",
-    "typescript": "^5.0.4",
-    "yjs": "^13.6.1",
-    "@pluv/tsconfig": "^0.1.6",
-    "eslint-config-pluv": "^0.1.12"
+    "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/AbstractPersistance.ts

@@ -4,14 +4,14 @@ export abstract class AbstractPersistance {
     public abstract addUser(
         room: string,
         connectionId: string,
-        user: JsonObject | null
+        user: JsonObject | null,
     ): Promise<void>;
 
     public abstract deleteStorageState(room: string): Promise<void>;
 
     public abstract deleteUser(
         room: string,
-        connectionId: string
+        connectionId: string,
     ): Promise<void>;
 
     public abstract deleteUsers(room: string): Promise<void>;
@@ -22,11 +22,11 @@ export abstract class AbstractPersistance {
 
     public abstract getUser(
         room: string,
-        connectionId: string
+        connectionId: string,
     ): Promise<JsonObject | null>;
 
     public abstract getUsers(
-        room: string
+        room: string,
     ): Promise<readonly (JsonObject | null)[]>;
 
     public abstract setStorageState(room: string, state: string): Promise<void>;

package/src/AbstractPlatform.ts

@@ -31,7 +31,7 @@ export interface ConvertWebSocketConfig {
 export abstract class AbstractPlatform<
     TWebSocket = any,
     TIOContext extends Record<string, any> = {},
-    TRoomContext extends Record<string, any> = {}
+    TRoomContext extends Record<string, any> = {},
 > {
     readonly _ioContext: TIOContext | undefined;
     readonly _roomContext: TRoomContext | undefined;
@@ -48,7 +48,7 @@ export abstract class AbstractPlatform<
 
     public abstract convertWebSocket(
         webSocket: TWebSocket,
-        config: ConvertWebSocketConfig
+        config: ConvertWebSocketConfig,
     ): AbstractWebSocket;
 
     public abstract parseData(data: string | ArrayBuffer): Record<string, any>;

package/src/AbstractPubSub.ts

@@ -3,7 +3,7 @@ import type { SendMessageOptions } from "./types";
 
 export type IOPubSubEventMessage<
     TIO extends IOLike,
-    TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>
+    TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>,
 > = IOEventMessage<TIO, TEvent> & {
     options?: SendMessageOptions;
 };
@@ -11,12 +11,12 @@ export type IOPubSubEventMessage<
 export abstract class AbstractPubSub {
     public abstract publish(
         roomName: string,
-        payload: IOPubSubEventMessage<any>
+        payload: IOPubSubEventMessage<any>,
     ): Promise<void>;
 
     public abstract subscribe(
         roomName: string,
-        onMessage: (message: IOPubSubEventMessage<any>) => void
+        onMessage: (message: IOPubSubEventMessage<any>) => void,
     ): Promise<number>;
 
     public abstract unsubscribe(subscriptionId: number): void;

package/src/AbstractWebSocket.ts

@@ -33,7 +33,7 @@ export interface AbstractWebSocketHandleErrorParams {
 }
 
 export type AbstractListener<TType extends keyof AbstractEventMap> = (
-    event: AbstractEventMap[TType]
+    event: AbstractEventMap[TType],
 ) => MaybePromise<void>;
 
 export interface AbstractWebSocketConfig {
@@ -74,12 +74,12 @@ export abstract class AbstractWebSocket {
      */
     public abstract addEventListener<TType extends EventType>(
         type: TType,
-        handler: AbstractListener<TType>
+        handler: AbstractListener<TType>,
     ): void;
 
     public abstract close(
         code?: number | undefined,
-        reason?: string | undefined
+        reason?: string | undefined,
     ): void;
 
     public abstract initialize(): Promise<() => void>;
@@ -110,7 +110,7 @@ export abstract class AbstractWebSocket {
     }
 
     public sendMessage<
-        TMessage extends IOEventMessage<any> = IOEventMessage<any>
+        TMessage extends IOEventMessage<any> = IOEventMessage<any>,
     >(data: TMessage): void {
         return this.send(JSON.stringify(data));
     }

package/src/IORoom.ts

@@ -60,7 +60,7 @@ export type IORoomConfig<
     TInput extends EventRecord<string, any> = {},
     TOutputBroadcast extends EventRecord<string, any> = {},
     TOutputSelf extends EventRecord<string, any> = {},
-    TOutputSync extends EventRecord<string, any> = {}
+    TOutputSync extends EventRecord<string, any> = {},
 > = Partial<IORoomListeners<TPlatform>> & {
     authorize?: TAuthorize;
     context: TContext & InferPlatformRoomContextType<TPlatform>;
@@ -93,7 +93,7 @@ export class IORoom<
     TInput extends EventRecord<string, any> = {},
     TOutputBroadcast extends EventRecord<string, any> = {},
     TOutputSelf extends EventRecord<string, any> = {},
-    TOutputSync extends EventRecord<string, any> = {}
+    TOutputSync extends EventRecord<string, any> = {},
 > implements
         IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>
 {
@@ -129,7 +129,7 @@ export class IORoom<
             TOutputBroadcast,
             TOutputSelf,
             TOutputSync
-        >
+        >,
     ) {
         const { authorize, context, debug, events, onDestroy, platform } =
             config;
@@ -150,7 +150,7 @@ export class IORoom<
 
     public broadcast<TEvent extends keyof InferIOInput<this>>(
         event: TEvent,
-        data: Id<InferIOInput<this>[TEvent]>
+        data: Id<InferIOInput<this>[TEvent]>,
     ): Promise<void> {
         const message = { type: event, data } as BroadcastMessage<this>;
 
@@ -177,7 +177,7 @@ export class IORoom<
 
     public async register(
         webSocket: InferPlatformWebSocketType<TPlatform>,
-        options: WebsocketRegisterOptions<TPlatform>
+        options: WebsocketRegisterOptions<TPlatform>,
     ): Promise<void> {
         const { token, ..._platformEventContext } = options;
         const platformEventContext =
@@ -193,8 +193,8 @@ export class IORoom<
 
         this._logDebug(
             `${colors.blue(
-                `Registering connection for room ${this.id}:`
-            )} ${sessionId}`
+                `Registering connection for room ${this.id}:`,
+            )} ${sessionId}`,
         );
 
         const uninitializeWs = await pluvWs.initialize();
@@ -206,14 +206,14 @@ export class IORoom<
         const isTokenInUse =
             !!user &&
             Array.from(this._sessions.values()).some(
-                (session) => session.user?.id === user.id
+                (session) => session.user?.id === user.id,
             );
 
         if (isUnauthorized || isTokenInUse) {
             this._logDebug(
                 `${colors.blue(
-                    "Authorization failed for connection:"
-                )} ${sessionId}`
+                    "Authorization failed for connection:",
+                )} ${sessionId}`,
             );
 
             pluvWs.handleError({ error: new Error("Not authorized") });
@@ -240,12 +240,12 @@ export class IORoom<
         await this._platform.persistance.addUser(
             this.id,
             sessionId,
-            user ?? {}
+            user ?? {},
         );
 
         const onClose = this._onClose(session, uninitializeWs).bind(this);
         const onMessage = this._onMessage(session, platformEventContext).bind(
-            this
+            this,
         );
 
         pluvWs.addEventListener("close", onClose);
@@ -256,8 +256,8 @@ export class IORoom<
 
         this._logDebug(
             `${colors.blue(
-                `Registered connection for room ${this.id}:`
-            )} ${sessionId}`
+                `Registered connection for room ${this.id}:`,
+            )} ${sessionId}`,
         );
 
         const size = this.getSize();
@@ -274,7 +274,7 @@ export class IORoom<
         const quitters = Array.from(this._sessions.values()).filter(
             (session) =>
                 session.quit ||
-                currentTime - session.timers.ping > PING_TIMEOUT_MS
+                currentTime - session.timers.ping > PING_TIMEOUT_MS,
         );
 
         quitters.forEach((session) => {
@@ -309,12 +309,12 @@ export class IORoom<
                 type: "$REGISTERED",
                 data: { sessionId: session.id },
             },
-            session
+            session,
         );
     }
 
     private async _getAuthorizedUser(
-        token: Maybe<string>
+        token: Maybe<string>,
     ): Promise<InferIOAuthorizeUser<InferIOAuthorize<this>> | null> {
         if (!this._authorize) return null;
         if (!token) return null;
@@ -333,7 +333,7 @@ export class IORoom<
 
         if (payload.room !== this.id) {
             this._logDebug(
-                colors.blue(`Token is not authorized for room ${this.id}:`)
+                colors.blue(`Token is not authorized for room ${this.id}:`),
             );
             this._logDebug(colors.blue("Received:"), payload.room);
             this._logDebug(token);
@@ -345,7 +345,7 @@ export class IORoom<
             return this._authorize.user.parse(payload.user) ?? null;
         } catch {
             this._logDebug(
-                `${colors.blue("Token fails validation:")} ${token}`
+                `${colors.blue("Token fails validation:")} ${token}`,
             );
 
             return null;
@@ -353,7 +353,7 @@ export class IORoom<
     }
 
     private _getEventConfig(
-        message: EventMessage<string, any>
+        message: EventMessage<string, any>,
     ):
         | InferEventConfig<
               TPlatform,
@@ -368,7 +368,7 @@ export class IORoom<
     }
 
     private _getEventInputs(
-        message: EventMessage<string, any>
+        message: EventMessage<string, any>,
     ): TInput[string] {
         const eventConfig = this._getEventConfig(message);
 
@@ -388,7 +388,7 @@ export class IORoom<
     }
 
     private _getEventResolverObject(
-        message: EventMessage<string, any>
+        message: EventMessage<string, any>,
     ): EventResolverObject<
         TPlatform,
         TContext,
@@ -441,7 +441,7 @@ export class IORoom<
                 };
 
                 this._sendMessage(message, session, options);
-            }
+            },
         );
 
         this._uninitialize = async () => {
@@ -468,7 +468,7 @@ export class IORoom<
 
     private _onClose(
         session: WebSocketSession,
-        callback?: () => void
+        callback?: () => void,
     ): () => void {
         return (): void => {
             if (!this._uninitialize) return;
@@ -477,8 +477,8 @@ export class IORoom<
 
             this._logDebug(
                 `${colors.blue(
-                    `(Unregistering connection for room ${this.id}:`
-                )} ${session.id}`
+                    `(Unregistering connection for room ${this.id}:`,
+                )} ${session.id}`,
             );
             this._sessions.delete(session.id);
 
@@ -499,11 +499,11 @@ export class IORoom<
 
                     this._logDebug(
                         `${colors.blue(
-                            `Unregistered connection for room ${this.id}:`
-                        )} ${session.id}`
+                            `Unregistered connection for room ${this.id}:`,
+                        )} ${session.id}`,
                     );
                     this._logDebug(
-                        `${colors.blue(`Room ${this.id} size:`)} ${size}`
+                        `${colors.blue(`Room ${this.id} size:`)} ${size}`,
                     );
 
                     if (size) return;
@@ -515,7 +515,7 @@ export class IORoom<
 
     private _onMessage(
         session: WebSocketSession,
-        platformEventContext: InferPlatformEventContextType<TPlatform>
+        platformEventContext: InferPlatformEventContextType<TPlatform>,
     ): (event: AbstractMessageEvent) => void {
         return (event: AbstractMessageEvent): void => {
             const baseContext: EventResolverContext<TContext> = {
@@ -619,7 +619,7 @@ export class IORoom<
     private _sendMessage(
         message: EventMessage<string, any>,
         sender: SendMessageSender | null,
-        options: SendMessageOptions = {}
+        options: SendMessageOptions = {},
     ): void {
         switch (options.type) {
             case "self": {
@@ -644,7 +644,7 @@ export class IORoom<
     private _sendBroadcastMessage(
         message: EventMessage<string, any>,
         sender: SendMessageSender | null,
-        sessionIds?: readonly string[]
+        sessionIds?: readonly string[],
     ): void {
         const senderId = sender?.id ?? null;
 
@@ -667,7 +667,7 @@ export class IORoom<
 
     private _sendSelfMessage(
         message: EventMessage<string, any>,
-        sender: SendMessageSender | null
+        sender: SendMessageSender | null,
     ): void {
         const senderId = sender?.id;
 
@@ -687,7 +687,7 @@ export class IORoom<
 
     private _sendSyncMessage(
         message: EventMessage<string, any>,
-        sender: SendMessageSender | null
+        sender: SendMessageSender | null,
     ): void {
         const senderId = sender?.id;
 

package/src/Persistance.ts

@@ -8,7 +8,7 @@ export class Persistance extends AbstractPersistance {
     public addUser(
         room: string,
         connectionId: string,
-        user: JsonObject | null
+        user: JsonObject | null,
     ): Promise<void> {
         const users =
             this._users.get(room) ?? new Map<string, JsonObject | null>();
@@ -58,7 +58,7 @@ export class Persistance extends AbstractPersistance {
 
     public getUser(
         room: string,
-        connectionId: string
+        connectionId: string,
     ): Promise<JsonObject | null> {
         const user = this._users.get(room)?.get(connectionId);
 

package/src/PluvIO.ts

@@ -60,7 +60,7 @@ type GetInitialStorageEvent<TPlatform extends AbstractPlatform> = {
 } & InferPlatformRoomContextType<TPlatform>;
 
 export type GetInitialStorageFn<TPlatform extends AbstractPlatform> = (
-    event: GetInitialStorageEvent<TPlatform>
+    event: GetInitialStorageEvent<TPlatform>,
 ) => MaybePromise<Maybe<string>>;
 
 export interface PluvIOListeners<TPlatform extends AbstractPlatform> {
@@ -75,7 +75,7 @@ export type PluvIOConfig<
     TInput extends EventRecord<string, any> = {},
     TOutputBroadcast extends EventRecord<string, any> = {},
     TOutputSelf extends EventRecord<string, any> = {},
-    TOutputSync extends EventRecord<string, any> = {}
+    TOutputSync extends EventRecord<string, any> = {},
 > = Partial<PluvIOListeners<TPlatform>> & {
     authorize?: TAuthorize;
     context?: TContext;
@@ -103,7 +103,7 @@ export class PluvIO<
     TInput extends EventRecord<string, any> = {},
     TOutputBroadcast extends EventRecord<string, any> = {},
     TOutputSelf extends EventRecord<string, any> = {},
-    TOutputSync extends EventRecord<string, any> = {}
+    TOutputSync extends EventRecord<string, any> = {},
 > implements
         IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>
 {
@@ -153,7 +153,7 @@ export class PluvIO<
                                     user: user as InferIOAuthorizeUser<TAuthorize>,
                                 },
                             }),
-                            {}
+                            {},
                         );
 
                     return { $OTHERS_RECEIVED: { others } };
@@ -196,7 +196,7 @@ export class PluvIO<
 
                         await this._platform.persistance.setStorageState(
                             room,
-                            encodedState
+                            encodedState,
                         );
 
                         this._listeners.onStorageUpdated({
@@ -208,7 +208,7 @@ export class PluvIO<
 
                     const state =
                         (await this._platform.persistance.getStorageState(
-                            room
+                            room,
                         )) ?? doc.encodeStateAsUpdate();
 
                     return { $STORAGE_RECEIVED: { state } };
@@ -235,7 +235,7 @@ export class PluvIO<
                 session.presence = Object.assign(
                     Object.create(null),
                     session.presence,
-                    presence
+                    presence,
                 );
 
                 return { $PRESENCE_UPDATED: { presence } };
@@ -244,7 +244,7 @@ export class PluvIO<
         $UPDATE_STORAGE: {
             resolver: ({ origin, update }, { context, doc, room }) => {
                 if (
-                    origin === "$STORAGE_RECEIVED" &&
+                    origin === "$INITIALIZED" &&
                     Object.keys(doc.toJSON()).length
                 ) {
                     return;
@@ -286,7 +286,7 @@ export class PluvIO<
             TOutputBroadcast,
             TOutputSelf,
             TOutputSync
-        >
+        >,
     ) {
         const {
             authorize,
@@ -314,11 +314,11 @@ export class PluvIO<
     }
 
     public async createToken(
-        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>>
+        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>>,
     ): Promise<string> {
         if (!this._authorize) {
             throw new Error(
-                "IO does not specify authorize during initialization."
+                "IO does not specify authorize during initialization.",
             );
         }
 
@@ -333,7 +333,7 @@ export class PluvIO<
         TData extends JsonObject = {},
         TResultBroadcast extends EventRecord<string, any> = {},
         TResultSelf extends EventRecord<string, any> = {},
-        TResultSync extends EventRecord<string, any> = {}
+        TResultSync extends EventRecord<string, any> = {},
     >(
         event: TEvent,
         config: EventConfig<
@@ -343,7 +343,7 @@ export class PluvIO<
             TResultBroadcast,
             TResultSelf,
             TResultSync
-        >
+        >,
     ): PluvIO<
         TPlatform,
         TAuthorize,
@@ -388,13 +388,13 @@ export class PluvIO<
             new PluvIO({
                 events: newEvent as any,
                 platform: this._platform,
-            })
+            }),
         ) as any;
     }
 
     public getRoom(
         room: string,
-        options: GetRoomOptions<TPlatform>
+        options: GetRoomOptions<TPlatform>,
     ): IORoom<
         TPlatform,
         TAuthorize,
@@ -437,7 +437,7 @@ export class PluvIO<
             events: this._events,
             onDestroy: ({ encodedState, room }) => {
                 this._logDebug(
-                    `${colors.blue("Deleting empty room:")} ${room}`
+                    `${colors.blue("Deleting empty room:")} ${room}`,
                 );
 
                 const roomContext = {
@@ -455,7 +455,9 @@ export class PluvIO<
 
                     this._logDebug(`${colors.blue("Deleted room:")} ${room}`);
                     this._logDebug(
-                        `${colors.blue("Rooms available:")} ${rooms.join(", ")}`
+                        `${colors.blue("Rooms available:")} ${rooms.join(
+                            ", ",
+                        )}`,
                     );
                 }
             },
@@ -469,7 +471,7 @@ export class PluvIO<
 
             this._logDebug(`${colors.blue("Created room:")} ${room}`);
             this._logDebug(
-                `${colors.blue("Rooms available:")} ${rooms.join(", ")}`
+                `${colors.blue("Rooms available:")} ${rooms.join(", ")}`,
             );
         }
 
@@ -478,7 +480,7 @@ export class PluvIO<
 
     public static merge<TIO1 extends PluvIO, TIO2 extends PluvIO>(
         first: TIO1,
-        second: TIO2
+        second: TIO2,
     ): PluvIO<
         InferIOPlatform<TIO1>,
         InferIOAuthorize<TIO1>,

package/src/PubSub.ts

@@ -17,7 +17,7 @@ export class PubSub extends AbstractPubSub {
 
     public async publish(
         roomName: string,
-        payload: IOPubSubEventMessage<any>
+        payload: IOPubSubEventMessage<any>,
     ): Promise<void> {
         const subject = this._subjects.get(roomName);
 
@@ -28,7 +28,7 @@ export class PubSub extends AbstractPubSub {
 
     public subscribe(
         roomName: string,
-        onMessage: (message: IOPubSubEventMessage<any>) => void
+        onMessage: (message: IOPubSubEventMessage<any>) => void,
     ): Promise<number> {
         const id = this._currentSubscriptionId++;
         const refs = this._subscriptionsRefs.get(roomName) ?? [];
@@ -69,7 +69,7 @@ export class PubSub extends AbstractPubSub {
             roomName,
             index === -1
                 ? refs
-                : [...refs.slice(0, index), ...refs.slice(index + 1)]
+                : [...refs.slice(0, index), ...refs.slice(index + 1)],
         );
 
         unsubscribe();

package/src/authorize.ts

@@ -11,7 +11,7 @@ export const getEncryptionKey = async (secret: string): Promise<Uint8Array> => {
         secret,
         "",
         "Pluv.io Generated Encryption Key",
-        32
+        32,
     );
 };
 
@@ -35,7 +35,7 @@ export interface AuthorizeParams {
 export interface AuthorizeModule {
     decode: <TUser extends BaseUser>(jwt: string) => Promise<TUser | null>;
     encode: <TUser extends BaseUser>(
-        params: JWTEncodeParams<TUser>
+        params: JWTEncodeParams<TUser>,
     ) => Promise<string>;
 }
 
@@ -45,7 +45,7 @@ export const authorize = (params: AuthorizeParams) => {
     const { platform, secret } = params;
 
     const encode = async <TUser extends BaseUser>(
-        encodeParams: JWTEncodeParams<TUser>
+        encodeParams: JWTEncodeParams<TUser>,
     ): Promise<string> => {
         const { maxAge = DEFAULT_MAX_AGE_MS, room, user } = encodeParams;
 
@@ -66,7 +66,7 @@ export const authorize = (params: AuthorizeParams) => {
     };
 
     const decode = async <TUser extends BaseUser>(
-        jwt: string
+        jwt: string,
     ): Promise<JWT<TUser> | null> => {
         const encryptionSecret = await getEncryptionKey(secret);
 

package/src/createIO.ts

@@ -15,7 +15,7 @@ export type CreateIOParams<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TContext extends JsonObject = {},
     TAuthorizeUser extends BaseUser = BaseUser,
-    TAuthorizeRequired extends boolean = false
+    TAuthorizeRequired extends boolean = false,
 > = Partial<PluvIOListeners<TPlatform>> & {
     authorize?: IOAuthorize<TAuthorizeUser, TAuthorizeRequired>;
     context?: TContext;
@@ -28,14 +28,14 @@ export const createIO = <
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TContext extends JsonObject = {},
     TAuthorizeUser extends BaseUser = BaseUser,
-    TAuthorizeRequired extends boolean = false
+    TAuthorizeRequired extends boolean = false,
 >(
     params: CreateIOParams<
         TPlatform,
         TContext,
         TAuthorizeUser,
         TAuthorizeRequired
-    >
+    >,
 ): PluvIO<
     TPlatform,
     IOAuthorize<TAuthorizeUser, TAuthorizeRequired>,

package/src/types.ts

@@ -33,7 +33,7 @@ export interface EventConfig<
     TData extends JsonObject = {},
     TResultBroadcast extends EventRecord<string, any> = {},
     TResultSelf extends EventRecord<string, any> = {},
-    TResultSync extends EventRecord<string, any> = {}
+    TResultSync extends EventRecord<string, any> = {},
 > {
     input?: InputZodLike<TData>;
     resolver:
@@ -59,23 +59,23 @@ export type EventConfigType = "broadcast" | "self" | "sync";
 export type SyncEventResolver<
     TContext extends Record<string, any> = {},
     TData extends JsonObject = {},
-    TResultBroadcast extends EventRecord<string, any> = {}
+    TResultBroadcast extends EventRecord<string, any> = {},
 > = (
     data: TData,
-    context: EventResolverContext<TContext>
+    context: EventResolverContext<TContext>,
 ) => MaybePromise<TResultBroadcast | void>;
 
 export type EventResolver<
     TContext extends Record<string, any> = {},
     TData extends JsonObject = {},
-    TResultBroadcast extends EventRecord<string, any> = {}
+    TResultBroadcast extends EventRecord<string, any> = {},
 > = (
     data: TData,
-    context: EventResolverContext<TContext>
+    context: EventResolverContext<TContext>,
 ) => MaybePromise<TResultBroadcast | void>;
 
 export interface EventResolverContext<
-    TContext extends Record<string, any> = {}
+    TContext extends Record<string, any> = {},
 > {
     context: TContext;
     doc: YjsDoc<any>;
@@ -102,7 +102,7 @@ export type EventResolverObject<
     TData extends JsonObject = {},
     TResultBroadcast extends EventRecord<string, any> = {},
     TResultSelf extends EventRecord<string, any> = {},
-    TResultSync extends EventRecord<string, any> = {}
+    TResultSync extends EventRecord<string, any> = {},
 > = {
     broadcast?: EventResolver<
         TContext &
@@ -127,7 +127,7 @@ export type InferEventConfig<
     TInput extends EventRecord<string, any> = {},
     TOutputBroadcast extends EventRecord<string, any> = {},
     TOutputSelf extends EventRecord<string, any> = {},
-    TOutputSync extends EventRecord<string, any> = {}
+    TOutputSync extends EventRecord<string, any> = {},
 > = {
     [P in keyof TInput]: P extends string
         ? Id<