@pluv/types 5.0.0 → 5.0.2

package/src/pluv/crdt.ts

@@ -1,82 +0,0 @@
-import type { Json, Maybe } from "../general";
-
-export interface CrdtDocFactory<
-    TDoc extends any,
-    TStorage extends Record<string, CrdtType<any, any>>,
-> {
-    _initialStorage: (builder: any) => TStorage;
-    getEmpty(): CrdtDocLike<TDoc, TStorage>;
-    getFactory(initialStorage?: (builder: any) => TStorage): CrdtDocFactory<TDoc, TStorage>;
-    getInitialized(initialStorage?: (builder: any) => TStorage): CrdtDocLike<TDoc, TStorage>;
-    isEmpty(initialStorage: Maybe<string>): boolean;
-}
-
-export interface CrdtLibraryType<TDoc extends CrdtDocFactory<any, any> = CrdtDocFactory<any, any>> {
-    doc: (value: any) => TDoc;
-    kind: "loro" | "yjs";
-}
-
-export type CrdtType<TValue extends unknown, TJson extends unknown = any> = Omit<
-    TValue,
-    "__pluvType"
-> & {
-    __pluvType: () => TJson;
-};
-
-export type InferCrdtJson<T extends unknown> =
-    T extends CrdtType<any, infer IJson>
-        ? InferCrdtJson<IJson>
-        : T extends Record<string, any>
-          ? { [P in keyof T]: InferCrdtJson<T[P]> }
-          : T extends (infer IJson)[]
-            ? InferCrdtJson<IJson>[]
-            : T extends readonly (infer IJson)[]
-              ? readonly InferCrdtJson<IJson>[]
-              : T extends Json
-                ? T
-                : string;
-
-export interface DocApplyEncodedStateParams {
-    origin?: string;
-    update?: Maybe<string | Uint8Array>;
-}
-
-export interface DocBatchApplyEncodedStateParams {
-    origin?: string;
-    updates?: Maybe<readonly Maybe<string | Uint8Array>[]>;
-}
-
-export interface DocSubscribeCallbackParams<
-    TDoc extends any,
-    TStorage extends Record<string, CrdtType<any, any>>,
-> {
-    doc: CrdtDocLike<TDoc, TStorage>;
-    local: boolean;
-    origin?: string | null;
-    update: string;
-}
-
-export interface CrdtDocLike<
-    TDoc extends any,
-    TStorage extends Record<string, CrdtType<any, any>>,
-> {
-    value: TDoc;
-
-    applyEncodedState(params: DocApplyEncodedStateParams): this;
-    batchApplyEncodedState(params: DocBatchApplyEncodedStateParams): this;
-    canRedo(): boolean;
-    canUndo(): boolean;
-    destroy(): void;
-    get(key?: undefined): TStorage;
-    get<TKey extends keyof TStorage>(key: TKey): TStorage[TKey];
-    getEncodedState(): string;
-    isEmpty(): boolean;
-    rebuildStorage(reference: TStorage): this;
-    redo(): this;
-    subscribe(listener: (params: DocSubscribeCallbackParams<TDoc, TStorage>) => void): () => void;
-    toJson(): InferCrdtJson<TStorage>;
-    toJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]>;
-    track(): this;
-    transact(fn: () => void, origin?: string): this;
-    undo(): this;
-}

package/src/pluv/enums.ts

@@ -1,18 +0,0 @@
-export const ConnectionState = {
-    Closed: "closed",
-    Connecting: "connecting",
-    Open: "open",
-    Unavailable: "unavailable",
-    Untouched: "untouched",
-} as const;
-
-export type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
-
-export const StorageState = {
-    Loading: "loading",
-    Offline: "offline",
-    Synced: "synced",
-    Unavailable: "unavailable",
-};
-
-export type StorageState = (typeof StorageState)[keyof typeof StorageState];

package/src/pluv/index.ts

@@ -1,4 +0,0 @@
-export * from "./crdt";
-export * from "./room";
-export * from "./shared";
-export * from "./enums";

package/src/pluv/room.ts

@@ -1,238 +0,0 @@
-import type { Subject } from "wonka";
-import type { Id } from "../general";
-import type { CrdtDocLike, CrdtType, InferCrdtJson } from "./crdt";
-import type { ConnectionState, StorageState } from "./enums";
-import type {
-    InferIOAuthorize,
-    InferIOAuthorizeUser,
-    InferIOInput,
-    InferIOOutput,
-    IOEventMessage,
-    IOLike,
-    MergeEvents,
-    PluvRouterEventConfig,
-} from "./shared";
-
-export interface AuthorizationState<TIO extends IOLike> {
-    token: string | null;
-    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>> | null;
-}
-
-export type OtherSubscriptionCallback<TIO extends IOLike, TPresence extends Record<string, any>> = (
-    value: Id<UserInfo<TIO, TPresence>> | null,
-) => void;
-
-export type OtherSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (
-    connectionId: string,
-    callback: OtherSubscriptionCallback<TIO, TPresence>,
-) => () => void;
-
-export type OthersSubscriptionEvent<TIO extends IOLike, TPresence extends Record<string, any>> =
-    | { kind: "clear" }
-    | { kind: "enter"; user: Id<UserInfo<TIO, TPresence>> }
-    | { kind: "leave"; user: Id<UserInfo<TIO, TPresence>> }
-    | { kind: "sync"; users: readonly Id<UserInfo<TIO, TPresence>>[] }
-    | { kind: "update"; user: Id<UserInfo<TIO, TPresence>> };
-
-export type OthersSubscriptionCallback<
-    TIO extends IOLike,
-    TPresence extends Record<string, any>,
-> = (
-    value: readonly Id<UserInfo<TIO, TPresence>>[],
-    event: OthersSubscriptionEvent<TIO, TPresence>,
-) => void;
-
-export type OthersSubscriptionFn<TIO extends IOLike, TPresence extends Record<string, any>> = (
-    callback: OthersSubscriptionCallback<TIO, TPresence>,
-) => () => void;
-
-export interface StateNotifierSubjects<TIO extends IOLike, TPresence extends Record<string, any>> {
-    connection: Subject<Id<WebSocketState<TIO>>>;
-    "my-presence": Subject<TPresence | null>;
-    myself: Subject<Readonly<Id<UserInfo<TIO, TPresence>>> | null>;
-    others: Subject<readonly Id<UserInfo<TIO, TPresence>>[]>;
-    "storage-loaded": Subject<boolean>;
-}
-
-type InferSubjectValue<
-    TIO extends IOLike,
-    TPresence extends Record<string, any>,
-    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 Record<string, any>,
-    TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
-> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
-
-export type UpdateMyPresenceAction<TPresence extends Record<string, any>> =
-    | Partial<TPresence>
-    | ((oldPresence: TPresence | null) => Partial<TPresence>);
-
-export interface UserInfo<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
-    connectionId: string;
-    presence: TPresence;
-    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
-}
-
-export interface WebSocketConnection {
-    /**
-     * @description How many times a connection attempt was made. This will increment upon each
-     * unsuccessful attempt, and will reset upon a successful connection.
-     * @date April 13, 2025
-     */
-    attempts: number;
-    id: string | null;
-    state: ConnectionState;
-}
-
-export interface StorageInfo {
-    state: StorageState;
-}
-
-export interface WebSocketState<TIO extends IOLike> {
-    authorization: AuthorizationState<TIO>;
-    connection: WebSocketConnection;
-    storage: StorageInfo;
-    webSocket: WebSocket | null;
-}
-
-export type BroadcastProxy<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = (<
-    TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>,
->(
-    event: TEvent,
-    data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>,
-) => Promise<void>) & {
-    [PEvent in keyof InferIOInput<MergeEvents<TEvents, TIO>>]: (
-        data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[PEvent]>,
-    ) => Promise<void>;
-};
-
-export type EventNotifierSubscriptionCallback<
-    TIO extends IOLike<any, any, any>,
-    TEvent extends keyof InferIOOutput<TIO>,
-> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
-
-export type EventSubscriptionFn<TIO extends IOLike, TEvents extends PluvRouterEventConfig> = <
-    TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>,
->(
-    event: TEvent,
-    callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
-) => () => void;
-
-export type EventProxy<
-    TIO extends IOLike,
-    TEvents extends PluvRouterEventConfig,
-> = EventSubscriptionFn<TIO, TEvents> & {
-    [PEvent in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (
-        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, PEvent>,
-    ) => () => void;
-};
-
-export type StorageSubscriptionCallback<
-    TStorage extends Record<string, CrdtType<any, any>>,
-    TKey extends keyof TStorage,
-> = (value: InferCrdtJson<TStorage[TKey]>) => void;
-
-export type StorageSubscriptionFn<TStorage extends Record<string, CrdtType<any, any>>> = <
-    TKey extends keyof TStorage,
->(
-    key: TKey,
-    fn: StorageSubscriptionCallback<TStorage, TKey>,
-) => () => void;
-
-export type StorageRootSubscriptionCallback<TStorage extends Record<string, CrdtType<any, any>>> =
-    (value: { [P in keyof TStorage]: InferCrdtJson<TStorage[P]> }) => void;
-
-export type StorageRootSubscriptionFn<TStorage extends Record<string, CrdtType<any, any>>> = (
-    callback: StorageRootSubscriptionCallback<TStorage>,
-) => () => void;
-
-export type StorageProxy<TStorage extends Record<string, CrdtType<any, any>>> =
-    StorageSubscriptionFn<TStorage> &
-        StorageRootSubscriptionFn<TStorage> & {
-            [PKey in keyof TStorage]: (
-                callback: StorageSubscriptionCallback<TStorage, PKey>,
-            ) => () => void;
-        };
-
-export type SubscribeFn<TValue extends unknown> = (callback: (value: TValue) => void) => () => void;
-
-export type SubscribeProxy<
-    TIO extends IOLike,
-    TPresence extends Record<string, any>,
-    TStorage extends Record<string, CrdtType<any, any>>,
-    TEvents extends PluvRouterEventConfig,
-> = (<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
-    name: TSubject,
-    callback: SubscriptionCallback<TIO, TPresence, TSubject>,
-) => () => void) & {
-    connection: SubscribeFn<Id<WebSocketState<TIO>>>;
-    event: EventProxy<TIO, TEvents>;
-    myPresence: SubscribeFn<TPresence | null>;
-    myself: SubscribeFn<Id<UserInfo<TIO>> | null>;
-    other: OtherSubscriptionFn<TIO, TPresence>;
-    others: OthersSubscriptionFn<TIO, TPresence>;
-    storage: StorageProxy<TStorage>;
-    storageLoaded: SubscribeFn<boolean>;
-};
-
-export interface RoomEventListenerMap {
-    close: (event: CloseEvent | null) => void;
-    error: (event: Event) => void;
-    message: (event: MessageEvent<any>) => void;
-    open: (event: Event) => void;
-}
-
-export interface RoomLike<
-    TIO extends IOLike,
-    TDoc extends any,
-    TPresence extends Record<string, any> = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig = {},
-> {
-    id: string;
-    broadcast: BroadcastProxy<TIO, TEvents>;
-
-    addEventListener<TKind extends keyof RoomEventListenerMap>(
-        kind: TKind,
-        handler: RoomEventListenerMap[TKind],
-    ): () => void;
-
-    canRedo(): boolean;
-
-    canUndo(): boolean;
-
-    getDoc(): CrdtDocLike<TDoc, TStorage>;
-
-    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>(type: TKey): TStorage[TKey] | null;
-
-    getStorageJson(): InferCrdtJson<TStorage> | null;
-    getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
-
-    getStorageLoaded: () => boolean;
-
-    redo(): void;
-
-    subscribe: SubscribeProxy<TIO, TPresence, TStorage, TEvents>;
-
-    transact(fn: (storage: TStorage) => void, origin?: string): void;
-
-    undo(): void;
-
-    updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
-}

package/src/pluv/shared.ts

@@ -1,243 +0,0 @@
-import type { Id, JsonObject, MaybePromise, UnionToIntersection } from "../general";
-import { CrdtLibraryType } from "./crdt";
-
-export type BaseUser = {
-    id: string;
-};
-
-export interface BaseClientEventRecord {
-    $getOthers: {};
-    $initializeSession: {
-        presence: JsonObject;
-        update: string | null;
-    };
-    $ping: {};
-    $updatePresence: {
-        presence: JsonObject;
-    };
-    $updateStorage: {
-        origin: string | null;
-        update: string;
-    };
-}
-
-export type BaseClientMessage = InferEventMessage<BaseClientEventRecord>;
-
-export type BaseIOEventRecord<TAuthorize extends IOAuthorize<any, any>> = {
-    $error: {
-        message: string;
-        stack?: string | null;
-    };
-    $exit: {
-        sessionId: string;
-    };
-    $othersReceived: {
-        others: {
-            [connectionId: string]: {
-                connectionId: string;
-                presence: JsonObject | null;
-                room: string | null;
-                timers: { presence: number | null };
-                user: Id<InferIOAuthorizeUser<TAuthorize>>;
-            };
-        };
-    };
-    $pong: {};
-    $presenceUpdated: {
-        presence: JsonObject;
-        timers: { presence: number | null };
-    };
-    $registered: {
-        presence: JsonObject | null;
-        sessionId: string;
-        state: string | null;
-        timers: { presence: number | null };
-    };
-    $storageReceived: {
-        changeKind: "empty" | "initialized" | "unchanged";
-        state: string;
-    };
-    $storageUpdated: {
-        state: string;
-    };
-    $syncStateReceived: {
-        connectionIds: readonly string[];
-    };
-    $userJoined: {
-        connectionId: string;
-        presence: JsonObject;
-        timers: { presence: number | null };
-        user: NonNullable<Id<InferIOAuthorizeUser<TAuthorize>>>;
-    };
-};
-
-export interface EventMessage<TEvent extends string, TData extends JsonObject = {}> {
-    data: TData;
-    type: TEvent;
-}
-
-export type EventRecord<TEvent extends string, TData extends JsonObject> = {
-    [key in `${TEvent}`]: TData;
-};
-
-export type GetEventMessage<
-    T extends EventRecord<string, any>,
-    TEvent extends keyof T,
-> = TEvent extends string ? EventMessage<TEvent, T[TEvent]> : never;
-
-export type InferIOAuthorize<TIO extends IOLike<any, any, any>> =
-    TIO extends IOLike<infer IAuthorize, any, any>
-        ? InferIOAuthorizeUser<IAuthorize> extends BaseUser
-            ? { user: InputZodLike<InferIOAuthorizeUser<IAuthorize>> }
-            : null
-        : never;
-
-export type InferIOAuthorizeUser<TAuthorize extends IOAuthorize<any, any> | null> =
-    TAuthorize extends IOAuthorize<infer IUser, any> ? IUser : null;
-
-export type InputZodLike<TData extends JsonObject> = {
-    parse: (data: unknown) => TData;
-} & ({ _input: TData } | { _zod: { input: TData } });
-
-export type IOAuthorize<
-    TUser extends BaseUser | null = any,
-    TContext extends Record<string, unknown> = {},
-> =
-    | (TUser extends BaseUser
-          ? {
-                secret?: string;
-                user: InputZodLike<TUser>;
-            }
-          : null)
-    | ((context: TContext) => TUser extends BaseUser
-          ? {
-                secret?: string;
-                user: InputZodLike<TUser>;
-            }
-          : null);
-
-export type IOAuthorizeEventMessage<TIO extends IOLike> = {
-    connectionId: string;
-    user: InferIOAuthorizeUser<InferIOAuthorize<TIO>>;
-};
-
-export type ProcedureLike<
-    TInput extends Record<string, any> = {},
-    TOutput extends EventRecord<string, any> = {},
-> = {
-    config: {
-        broadcast?:
-            | ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>)
-            | null;
-        input?: InputZodLike<TInput> | null;
-        resolver: (data: TInput, ...args: any[]) => MaybePromise<TOutput>;
-        self?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
-        sync?: ((data: TInput, ...args: any[]) => MaybePromise<Partial<TOutput> | void>) | null;
-    };
-};
-
-export interface IORouterLike<TEvents extends Record<string, ProcedureLike<any, any>> = {}> {
-    _defs: {
-        events: TEvents;
-    };
-}
-
-export interface IOLike<
-    TAuthorize extends IOAuthorize<any, any> | null = null,
-    TCrdt extends CrdtLibraryType<any> = CrdtLibraryType<any>,
-    TEvents extends Record<string, ProcedureLike<any, any>> = {},
-> extends IORouterLike<TEvents> {
-    _defs: {
-        authorize: TAuthorize;
-        crdt: TCrdt;
-        events: TEvents;
-    };
-}
-
-export type InferIOCrdtKind<TIO extends IOLike<any, any, any>> =
-    TIO extends IOLike<any, infer ICrdt, any>
-        ? ICrdt extends CrdtLibraryType<infer IDoc>
-            ? IDoc
-            : never
-        : never;
-
-export type InferIOCrdt<TIO extends IOLike<any, any, any>> =
-    TIO extends IOLike<any, infer ICrdt, any> ? ICrdt : never;
-
-export type InferIOEvents<TIO extends IOLike<any, any, any>> =
-    TIO extends IOLike<any, any, infer IEvents>
-        ? {
-              [P in keyof IEvents]: ProcedureLike<
-                  InferIOProcedureInput<IEvents[P]>,
-                  InferIOProcedureOutput<IEvents[P]>
-              >;
-          }
-        : never;
-
-export type InferIOProcedureInput<TProcedure extends ProcedureLike<any, any>> =
-    TProcedure extends ProcedureLike<infer IInput, any> ? Id<IInput> : never;
-
-export type InferIOProcedureOutput<TProcedure extends ProcedureLike<any, any>> =
-    TProcedure extends ProcedureLike<any, infer IOutput> ? Id<IOutput> : never;
-
-export type InferEventsInput<TEvents extends Record<string, ProcedureLike<any, any>>> = {
-    [P in keyof TEvents]: TEvents[P] extends ProcedureLike<infer IInput, any> ? Id<IInput> : never;
-};
-
-export type InferEventsOutput<TEvents extends Record<string, ProcedureLike<any, any>>> =
-    UnionToIntersection<
-        {
-            [P in keyof TEvents]: TEvents[P] extends ProcedureLike<any, infer IOutput>
-                ? Id<IOutput>
-                : never;
-        }[keyof TEvents]
-    >;
-
-export type InferIOInput<TRouter extends IORouterLike<any>> =
-    TRouter extends IORouterLike<infer IEvents> ? InferEventsInput<IEvents> : never;
-
-export type InferIOOutput<TRouter extends IORouterLike<any>> =
-    TRouter extends IORouterLike<infer IEvents> ? InferEventsOutput<IEvents> : never;
-
-export type InferEventMessage<
-    TEvents = EventRecord<string, any>,
-    TEvent extends keyof TEvents = keyof TEvents,
-> =
-    TEvents extends EventRecord<string, any>
-        ? { [P in TEvent]: P extends string ? Id<EventMessage<P, TEvents[P]>> : never }[TEvent]
-        : never;
-
-export type IOEventMessage<
-    TIO extends IOLike<any, any, any>,
-    TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>,
-> = Id<
-    { room: string } & InferEventMessage<InferIOOutput<TIO>, TEvent> &
-        (InferEventMessage<InferIOOutput<TIO>, TEvent>["type"] extends "$error"
-            ? Partial<IOAuthorizeEventMessage<TIO>>
-            : IOAuthorizeEventMessage<TIO>)
->;
-
-export type PluvRouterEventConfig = { [P: string]: Pick<ProcedureLike<any, any>, "config"> };
-
-export type MergeEvents<
-    TClientEvents extends PluvRouterEventConfig,
-    TServerIO extends IOLike<any, any, any>,
-> =
-    TServerIO extends IOLike<infer IAuthorize, infer ICrdt, infer IServerEvents>
-        ? IOLike<
-              IAuthorize,
-              ICrdt,
-              {
-                  [P in keyof TClientEvents]: TClientEvents[P] extends ProcedureLike<
-                      infer IClientInput,
-                      infer IClientOutput
-                  >
-                      ? {
-                            [K in keyof IClientOutput]: K extends keyof IServerEvents
-                                ? IServerEvents[K]
-                                : ProcedureLike<IClientInput, Id<Pick<IClientOutput, K>>>;
-                        }[keyof IClientOutput]
-                      : never;
-              } & IServerEvents
-          >
-        : never;

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-	"extends": "@pluv/tsconfig/library.json",
-	"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
-	"exclude": ["node_modules"],
-	"compilerOptions": {
-		"lib": ["dom", "esnext"],
-		"module": "esnext",
-		"target": "es6"
-	}
-}

package/tsdown.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-    format: ["esm"],
-    dts: true,
-    outDir: "dist",
-    entry: "src/index.ts",
-    target: "esnext",
-    sourcemap: true,
-    clean: true,
-    exports: {
-        all: true,
-    },
-});