@float.js/core 2.0.1

package/dist/realtime/index.d.ts

@@ -0,0 +1,198 @@
+import { WebSocket } from 'ws';
+import { IncomingMessage } from 'http';
+import { EventEmitter } from 'events';
+
+/**
+ * Float.js Real-time Module
+ * Built-in WebSocket support with rooms, presence, and broadcasting
+ *
+ * NO plugins needed - real-time is native to Float.js!
+ */
+
+interface RealtimeClient {
+    id: string;
+    socket: WebSocket;
+    rooms: Set<string>;
+    data: Record<string, unknown>;
+    isAlive: boolean;
+    connectedAt: Date;
+}
+interface RealtimeMessage<T = unknown> {
+    type: string;
+    payload: T;
+    from?: string;
+    room?: string;
+    timestamp: number;
+}
+interface RealtimeRoom {
+    name: string;
+    clients: Set<string>;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+interface PresenceState {
+    clientId: string;
+    data: Record<string, unknown>;
+    joinedAt: Date;
+    lastSeen: Date;
+}
+interface RealtimeOptions {
+    /** Port for WebSocket server (default: 3001) */
+    port?: number;
+    /** Path for WebSocket endpoint (default: '/ws') */
+    path?: string;
+    /** Ping interval in ms (default: 30000) */
+    pingInterval?: number;
+    /** Max message size in bytes (default: 1MB) */
+    maxPayload?: number;
+    /** Enable presence tracking (default: true) */
+    presence?: boolean;
+    /** Custom authentication handler */
+    authenticate?: (request: IncomingMessage) => Promise<{
+        id: string;
+        data?: Record<string, unknown>;
+    } | null>;
+}
+type EventHandler<T = unknown> = (message: RealtimeMessage<T>, client: RealtimeClient) => void | Promise<void>;
+type ConnectionHandler = (client: RealtimeClient) => void | Promise<void>;
+type DisconnectHandler = (client: RealtimeClient, code: number, reason: string) => void | Promise<void>;
+declare class FloatRealtime extends EventEmitter {
+    private wss;
+    private httpServer;
+    private clients;
+    private rooms;
+    private eventHandlers;
+    private connectionHandlers;
+    private disconnectHandlers;
+    private pingInterval;
+    private options;
+    constructor(options?: RealtimeOptions);
+    /**
+     * Start the WebSocket server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the WebSocket server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle new WebSocket connection
+     */
+    private handleConnection;
+    /**
+     * Handle incoming message
+     */
+    private handleMessage;
+    /**
+     * Handle client disconnect
+     */
+    private handleDisconnect;
+    /**
+     * Handle room join
+     */
+    private handleJoin;
+    /**
+     * Handle room leave
+     */
+    private handleLeave;
+    /**
+     * Handle broadcast message
+     */
+    private handleBroadcast;
+    /**
+     * Handle presence update
+     */
+    private handlePresenceUpdate;
+    /**
+     * Ping all clients to check if they're alive
+     */
+    private pingClients;
+    /**
+     * Register a handler for connection events
+     */
+    onConnection(handler: ConnectionHandler): this;
+    /**
+     * Register a handler for disconnect events
+     */
+    onDisconnect(handler: DisconnectHandler): this;
+    /**
+     * Register a handler for a specific event type
+     */
+    onEvent<T = unknown>(eventType: string, handler: EventHandler<T>): this;
+    /**
+     * Send a message to a specific client
+     */
+    sendToClient(client: RealtimeClient, message: RealtimeMessage): boolean;
+    /**
+     * Send a message to a client by ID
+     */
+    sendToId(clientId: string, message: RealtimeMessage): boolean;
+    /**
+     * Broadcast to all clients in a room
+     */
+    broadcastToRoom(roomName: string, message: RealtimeMessage, excludeId?: string): void;
+    /**
+     * Broadcast to all connected clients
+     */
+    broadcastToAll(message: RealtimeMessage, excludeId?: string): void;
+    /**
+     * Get all clients in a room
+     */
+    getRoom(roomName: string): RealtimeRoom | undefined;
+    /**
+     * Get client by ID
+     */
+    getClient(clientId: string): RealtimeClient | undefined;
+    /**
+     * Get presence data for a room
+     */
+    getRoomPresence(roomName: string): PresenceState[];
+    /**
+     * Get all connected clients count
+     */
+    get clientCount(): number;
+    /**
+     * Get all rooms count
+     */
+    get roomCount(): number;
+    /**
+     * Generate a unique client ID
+     */
+    private generateId;
+}
+interface RealtimeClientOptions {
+    url: string;
+    autoReconnect?: boolean;
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+}
+/**
+ * Create a client-side realtime connection
+ * This code is isomorphic and can run in the browser
+ */
+declare function createRealtimeClient(options: RealtimeClientOptions): {
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    join: (room: string, data?: Record<string, unknown>) => void;
+    leave: (room: string) => void;
+    broadcast: (room: string, type: string, data: unknown) => void;
+    emit: (type: string, data: unknown) => void;
+    on: <T = unknown>(eventType: string, handler: (payload: T) => void) => () => void;
+    updatePresence: (data: Record<string, unknown>) => void;
+    readonly id: string | null;
+    readonly connected: boolean;
+};
+/**
+ * Get or create the realtime server instance
+ */
+declare function getRealtimeServer(options?: RealtimeOptions): FloatRealtime;
+/**
+ * Shorthand export for easy usage
+ */
+declare const realtime: {
+    create: (options?: RealtimeOptions) => FloatRealtime;
+    server: typeof getRealtimeServer;
+    client: typeof createRealtimeClient;
+};
+
+export { FloatRealtime, type PresenceState, type RealtimeClient, type RealtimeClientOptions, type RealtimeMessage, type RealtimeOptions, type RealtimeRoom, createRealtimeClient, getRealtimeServer, realtime };