@hocuspocus/extension-s3 3.2.4

package/dist/packages/provider/src/OutgoingMessages/UpdateMessage.d.ts

@@ -0,0 +1,8 @@
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
+export declare class UpdateMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
+}

package/dist/packages/provider/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./HocuspocusProvider.ts";
+export * from "./HocuspocusProviderWebsocket.ts";
+export * from "./types.ts";

package/dist/packages/provider/src/types.d.ts

@@ -0,0 +1,92 @@
+import type { Encoder } from "lib0/encoding";
+import type { Event, MessageEvent } from "ws";
+import type { Awareness } from "y-protocols/awareness";
+import type * as Y from "yjs";
+import type { CloseEvent } from "@hocuspocus/common";
+import type { IncomingMessage } from "./IncomingMessage.ts";
+import type { OutgoingMessage } from "./OutgoingMessage.ts";
+import type { AuthenticationMessage } from "./OutgoingMessages/AuthenticationMessage.ts";
+import type { AwarenessMessage } from "./OutgoingMessages/AwarenessMessage.ts";
+import type { QueryAwarenessMessage } from "./OutgoingMessages/QueryAwarenessMessage.ts";
+import type { SyncStepOneMessage } from "./OutgoingMessages/SyncStepOneMessage.ts";
+import type { SyncStepTwoMessage } from "./OutgoingMessages/SyncStepTwoMessage.ts";
+import type { UpdateMessage } from "./OutgoingMessages/UpdateMessage.ts";
+export declare enum MessageType {
+    Sync = 0,
+    Awareness = 1,
+    Auth = 2,
+    QueryAwareness = 3,
+    Stateless = 5,
+    CLOSE = 7,
+    SyncStatus = 8
+}
+export declare enum WebSocketStatus {
+    Connecting = "connecting",
+    Connected = "connected",
+    Disconnected = "disconnected"
+}
+export interface OutgoingMessageInterface {
+    encoder: Encoder;
+    type?: MessageType;
+}
+export interface OutgoingMessageArguments {
+    documentName: string;
+    token: string;
+    document: Y.Doc;
+    awareness: Awareness;
+    clients: number[];
+    states: Map<number, {
+        [key: string]: any;
+    }>;
+    update: any;
+    payload: string;
+    encoder: Encoder;
+}
+export interface Constructable<T> {
+    new (...args: any): T;
+}
+export type ConstructableOutgoingMessage = Constructable<AuthenticationMessage> | Constructable<AwarenessMessage> | Constructable<QueryAwarenessMessage> | Constructable<SyncStepOneMessage> | Constructable<SyncStepTwoMessage> | Constructable<UpdateMessage>;
+export type onAuthenticationFailedParameters = {
+    reason: string;
+};
+export type onAuthenticatedParameters = {
+    scope: "read-write" | "readonly";
+};
+export type onOpenParameters = {
+    event: Event;
+};
+export type onMessageParameters = {
+    event: MessageEvent;
+    message: IncomingMessage;
+};
+export type onOutgoingMessageParameters = {
+    message: OutgoingMessage;
+};
+export type onStatusParameters = {
+    status: WebSocketStatus;
+};
+export type onSyncedParameters = {
+    state: boolean;
+};
+export type onUnsyncedChangesParameters = {
+    number: number;
+};
+export type onDisconnectParameters = {
+    event: CloseEvent;
+};
+export type onCloseParameters = {
+    event: CloseEvent;
+};
+export type onAwarenessUpdateParameters = {
+    states: StatesArray;
+};
+export type onAwarenessChangeParameters = {
+    states: StatesArray;
+};
+export type onStatelessParameters = {
+    payload: string;
+};
+export type StatesArray = {
+    clientId: number;
+    [key: string | number]: any;
+}[];

package/dist/packages/server/src/ClientConnection.d.ts

@@ -0,0 +1,63 @@
+import type { IncomingMessage } from "node:http";
+import { type CloseEvent } from "@hocuspocus/common";
+import type WebSocket from "ws";
+import type Document from "./Document.ts";
+import type { Hocuspocus } from "./Hocuspocus.ts";
+import type { onDisconnectPayload } from "./types.ts";
+/**
+ * The `ClientConnection` class is responsible for handling an incoming WebSocket
+ *
+ * TODO-refactor:
+ * - use event handlers instead of calling hooks directly, hooks should probably be called from Hocuspocus.ts
+ */
+export declare class ClientConnection {
+    private readonly websocket;
+    private readonly request;
+    private readonly documentProvider;
+    private readonly hooks;
+    private readonly opts;
+    private readonly defaultContext;
+    private readonly documentConnections;
+    private readonly incomingMessageQueue;
+    private readonly documentConnectionsEstablished;
+    private readonly hookPayloads;
+    private readonly callbacks;
+    private readonly socketId;
+    timeout: number;
+    pingInterval: NodeJS.Timeout;
+    pongReceived: boolean;
+    /**
+     * The `ClientConnection` class receives incoming WebSocket connections,
+     * runs all hooks:
+     *
+     *  - onConnect for all connections
+     *  - onAuthenticate only if required
+     *
+     * … and if nothings fails it’ll fully establish the connection and
+     * load the Document then.
+     */
+    constructor(websocket: WebSocket, request: IncomingMessage, documentProvider: {
+        createDocument: Hocuspocus["createDocument"];
+    }, hooks: Hocuspocus["hooks"], opts: {
+        timeout: number;
+    }, defaultContext?: any);
+    private handleWebsocketClose;
+    close(event?: CloseEvent): void;
+    handlePong: () => void;
+    /**
+     * Check if pong was received and close the connection otherwise
+     * @private
+     */
+    private check;
+    /**
+     * Set a callback that will be triggered when the connection is closed
+     */
+    onClose(callback: (document: Document, payload: onDisconnectPayload) => void): ClientConnection;
+    /**
+     * Create a new connection by the given request and document
+     */
+    private createConnection;
+    private setUpNewConnection;
+    private handleQueueingMessage;
+    private messageHandler;
+}

package/dist/packages/server/src/Connection.d.ts

@@ -0,0 +1,62 @@
+import type { IncomingMessage as HTTPIncomingMessage } from "node:http";
+import { type CloseEvent } from "@hocuspocus/common";
+import type WebSocket from "ws";
+import type Document from "./Document.ts";
+import type { beforeSyncPayload, onStatelessPayload } from "./types.ts";
+export declare class Connection {
+    webSocket: WebSocket;
+    context: any;
+    document: Document;
+    request: HTTPIncomingMessage;
+    callbacks: {
+        onClose: ((document: Document, event?: CloseEvent) => void)[];
+        beforeHandleMessage: (connection: Connection, update: Uint8Array) => Promise<void>;
+        beforeSync: (connection: Connection, payload: Pick<beforeSyncPayload, "type" | "payload">) => Promise<void>;
+        statelessCallback: (payload: onStatelessPayload) => Promise<void>;
+    };
+    socketId: string;
+    readOnly: boolean;
+    /**
+     * Constructor.
+     */
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, socketId: string, context: any, readOnly?: boolean);
+    /**
+     * Set a callback that will be triggered when the connection is closed
+     */
+    onClose(callback: (document: Document, event?: CloseEvent) => void): Connection;
+    /**
+     * Set a callback that will be triggered when an stateless message is received
+     */
+    onStatelessCallback(callback: (payload: onStatelessPayload) => Promise<void>): Connection;
+    /**
+     * Set a callback that will be triggered before an message is handled
+     */
+    beforeHandleMessage(callback: (connection: Connection, update: Uint8Array) => Promise<any>): Connection;
+    /**
+     * Set a callback that will be triggered before a sync message is handled
+     */
+    beforeSync(callback: (connection: Connection, payload: Pick<beforeSyncPayload, "type" | "payload">) => Promise<any>): Connection;
+    /**
+     * Send the given message
+     */
+    send(message: any): void;
+    /**
+     * Send a stateless message with payload
+     */
+    sendStateless(payload: string): void;
+    /**
+     * Graceful wrapper around the WebSocket close method.
+     */
+    close(event?: CloseEvent): void;
+    /**
+     * Send the current document awareness to the client, if any
+     * @private
+     */
+    private sendCurrentAwareness;
+    /**
+     * Handle an incoming message
+     * @public
+     */
+    handleMessage(data: Uint8Array): void;
+}
+export default Connection;

package/dist/packages/server/src/DirectConnection.d.ts

@@ -0,0 +1,14 @@
+import type Document from "./Document.ts";
+import type { Hocuspocus } from "./Hocuspocus.ts";
+import type { DirectConnection as DirectConnectionInterface } from "./types.ts";
+export declare class DirectConnection implements DirectConnectionInterface {
+    document: Document | null;
+    instance: Hocuspocus;
+    context: any;
+    /**
+     * Constructor.
+     */
+    constructor(document: Document, instance: Hocuspocus, context?: any);
+    transact(transaction: (document: Document) => void): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/packages/server/src/Document.d.ts

@@ -0,0 +1,89 @@
+import type WebSocket from "ws";
+import { Awareness } from "y-protocols/awareness";
+import { Doc } from "yjs";
+import type Connection from "./Connection.ts";
+export declare class Document extends Doc {
+    awareness: Awareness;
+    callbacks: {
+        onUpdate: (document: Document, connection: Connection, update: Uint8Array) => void;
+        beforeBroadcastStateless: (document: Document, stateless: string) => void;
+    };
+    connections: Map<WebSocket, {
+        clients: Set<any>;
+        connection: Connection;
+    }>;
+    directConnectionsCount: number;
+    name: string;
+    isLoading: boolean;
+    isDestroyed: boolean;
+    /**
+     * Constructor.
+     */
+    constructor(name: string, yDocOptions?: object);
+    /**
+     * Check if the Document (XMLFragment or Map) is empty
+     */
+    isEmpty(fieldName: string): boolean;
+    /**
+     * Merge the given document(s) into this one
+     */
+    merge(documents: Doc | Array<Doc>): Document;
+    /**
+     * Set a callback that will be triggered when the document is updated
+     */
+    onUpdate(callback: (document: Document, connection: Connection, update: Uint8Array) => void): Document;
+    /**
+     * Set a callback that will be triggered before a stateless message is broadcasted
+     */
+    beforeBroadcastStateless(callback: (document: Document, stateless: string) => void): Document;
+    /**
+     * Register a connection and a set of clients on this document keyed by the
+     * underlying websocket connection
+     */
+    addConnection(connection: Connection): Document;
+    /**
+     * Is the given connection registered on this document
+     */
+    hasConnection(connection: Connection): boolean;
+    /**
+     * Remove the given connection from this document
+     */
+    removeConnection(connection: Connection): Document;
+    addDirectConnection(): Document;
+    removeDirectConnection(): Document;
+    /**
+     * Get the number of active connections for this document
+     */
+    getConnectionsCount(): number;
+    /**
+     * Get an array of registered connections
+     */
+    getConnections(): Array<Connection>;
+    /**
+     * Get the client ids for the given connection instance
+     */
+    getClients(connectionInstance: WebSocket): Set<any>;
+    /**
+     * Has the document awareness states
+     */
+    hasAwarenessStates(): boolean;
+    /**
+     * Apply the given awareness update
+     */
+    applyAwarenessUpdate(connection: Connection, update: Uint8Array): Document;
+    /**
+     * Handle an awareness update and sync changes to clients
+     * @private
+     */
+    private handleAwarenessUpdate;
+    /**
+     * Handle an updated document and sync changes to clients
+     */
+    private handleUpdate;
+    /**
+     * Broadcast stateless message to all connections
+     */
+    broadcastStateless(payload: string, filter?: (conn: Connection) => boolean): void;
+    destroy(): void;
+}
+export default Document;

package/dist/packages/server/src/Hocuspocus.d.ts

@@ -0,0 +1,77 @@
+import type { IncomingMessage } from "node:http";
+import type WebSocket from "ws";
+import { DirectConnection } from "./DirectConnection.ts";
+import Document from "./Document.ts";
+import type { Server } from "./Server.ts";
+import type { Configuration, ConnectionConfiguration, HookName, HookPayloadByName, onStoreDocumentPayload } from "./types.ts";
+export declare const defaultConfiguration: {
+    name: null;
+    timeout: number;
+    debounce: number;
+    maxDebounce: number;
+    quiet: boolean;
+    yDocOptions: {
+        gc: boolean;
+        gcFilter: () => boolean;
+    };
+    unloadImmediately: boolean;
+};
+export declare class Hocuspocus {
+    configuration: Configuration;
+    loadingDocuments: Map<string, Promise<Document>>;
+    documents: Map<string, Document>;
+    server?: Server;
+    debouncer: {
+        debounce: (id: string, func: Function, debounce: number, maxDebounce: number) => any;
+        isDebounced: (id: string) => boolean;
+        executeNow: (id: string) => any;
+    };
+    constructor(configuration?: Partial<Configuration>);
+    /**
+     * Configure Hocuspocus
+     */
+    configure(configuration: Partial<Configuration>): Hocuspocus;
+    /**
+     * Get the total number of active documents
+     */
+    getDocumentsCount(): number;
+    /**
+     * Get the total number of active connections
+     */
+    getConnectionsCount(): number;
+    /**
+     * Force close one or more connections
+     */
+    closeConnections(documentName?: string): void;
+    /**
+     * The `handleConnection` method receives incoming WebSocket connections,
+     * runs all hooks:
+     *
+     *  - onConnect for all connections
+     *  - onAuthenticate only if required
+     *
+     * … and if nothing fails it’ll fully establish the connection and
+     * load the Document then.
+     */
+    handleConnection(incoming: WebSocket, request: IncomingMessage, defaultContext?: any): void;
+    /**
+     * Handle update of the given document
+     *
+     * "connection" is not necessarily type "Connection", it's the Yjs "origin" (which is "Connection" if
+     * the update is incoming from the provider, but can be anything if the updates is originated from an extension.
+     */
+    private handleDocumentUpdate;
+    /**
+     * Create a new document by the given request
+     */
+    createDocument(documentName: string, request: Partial<Pick<IncomingMessage, "headers" | "url">>, socketId: string, connection: ConnectionConfiguration, context?: any): Promise<Document>;
+    loadDocument(documentName: string, request: Partial<Pick<IncomingMessage, "headers" | "url">>, socketId: string, connectionConfig: ConnectionConfiguration, context?: any): Promise<Document>;
+    storeDocumentHooks(document: Document, hookPayload: onStoreDocumentPayload, immediately?: boolean): any;
+    /**
+     * Run the given hook on all configured extensions.
+     * Runs the given callback after each hook.
+     */
+    hooks<T extends HookName>(name: T, payload: HookPayloadByName[T], callback?: Function | null): Promise<any>;
+    unloadDocument(document: Document): Promise<any>;
+    openDirectConnection(documentName: string, context?: any): Promise<DirectConnection>;
+}

package/dist/packages/server/src/IncomingMessage.d.ts

@@ -0,0 +1,25 @@
+import type { Decoder } from "lib0/decoding";
+import type { Encoder } from "lib0/encoding";
+import type { MessageType } from "./types.ts";
+export declare class IncomingMessage {
+    /**
+     * Access to the received message.
+     */
+    decoder: Decoder;
+    /**
+     * Private encoder; can be undefined.
+     *
+     * Lazy creation of the encoder speeds up IncomingMessages that need only a decoder.
+     */
+    private encoderInternal?;
+    constructor(input: any);
+    get encoder(): Encoder;
+    readVarUint8Array(): Uint8Array<ArrayBufferLike>;
+    peekVarUint8Array(): Uint8Array<ArrayBufferLike>;
+    readVarUint(): number;
+    readVarString(): string;
+    toUint8Array(): Uint8Array<ArrayBufferLike>;
+    writeVarUint(type: MessageType): void;
+    writeVarString(string: string): void;
+    get length(): number;
+}

package/dist/packages/server/src/MessageReceiver.d.ts

@@ -0,0 +1,11 @@
+import type Connection from "./Connection.ts";
+import type Document from "./Document.ts";
+import type { IncomingMessage } from "./IncomingMessage.ts";
+export declare class MessageReceiver {
+    message: IncomingMessage;
+    defaultTransactionOrigin?: string;
+    constructor(message: IncomingMessage, defaultTransactionOrigin?: string);
+    apply(document: Document, connection?: Connection, reply?: (message: Uint8Array) => void): Promise<void>;
+    readSyncMessage(message: IncomingMessage, document: Document, connection?: Connection, reply?: (message: Uint8Array) => void, requestFirstSync?: boolean): Promise<0 | 1 | 2>;
+    applyQueryAwarenessMessage(document: Document, reply?: (message: Uint8Array) => void): void;
+}

package/dist/packages/server/src/OutgoingMessage.d.ts

@@ -0,0 +1,22 @@
+import type { Encoder } from "lib0/encoding";
+import type { Awareness } from "y-protocols/awareness";
+import type Document from "./Document.ts";
+export declare class OutgoingMessage {
+    encoder: Encoder;
+    type?: number;
+    category?: string;
+    constructor(documentName: string);
+    createSyncMessage(): OutgoingMessage;
+    createSyncReplyMessage(): OutgoingMessage;
+    createAwarenessUpdateMessage(awareness: Awareness, changedClients?: Array<any>): OutgoingMessage;
+    writeQueryAwareness(): OutgoingMessage;
+    writeAuthenticated(readonly: boolean): OutgoingMessage;
+    writePermissionDenied(reason: string): OutgoingMessage;
+    writeFirstSyncStepFor(document: Document): OutgoingMessage;
+    writeUpdate(update: Uint8Array): OutgoingMessage;
+    writeStateless(payload: string): OutgoingMessage;
+    writeBroadcastStateless(payload: string): OutgoingMessage;
+    writeSyncStatus(updateSaved: boolean): OutgoingMessage;
+    writeCloseMessage(reason: string): OutgoingMessage;
+    toUint8Array(): Uint8Array;
+}

package/dist/packages/server/src/Server.d.ts

@@ -0,0 +1,32 @@
+import type { Server as HTTPServer, IncomingMessage, ServerResponse } from "node:http";
+import { WebSocketServer } from "ws";
+import type { AddressInfo, ServerOptions } from "ws";
+import { Hocuspocus } from "./Hocuspocus.ts";
+import type { Configuration } from "./types.ts";
+export interface ServerConfiguration extends Configuration {
+    port?: number;
+    address?: string;
+    stopOnSignals?: boolean;
+}
+export declare const defaultServerConfiguration: {
+    port: number;
+    address: string;
+    stopOnSignals: boolean;
+};
+export declare class Server {
+    httpServer: HTTPServer;
+    webSocketServer: WebSocketServer;
+    hocuspocus: Hocuspocus;
+    configuration: ServerConfiguration;
+    constructor(configuration?: Partial<ServerConfiguration>, websocketOptions?: ServerOptions);
+    setupWebsocketConnection: () => void;
+    setupHttpUpgrade: () => void;
+    requestHandler: (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+    listen(port?: number, callback?: any): Promise<Hocuspocus>;
+    get address(): AddressInfo;
+    destroy(): Promise<any>;
+    get URL(): string;
+    get webSocketURL(): string;
+    get httpURL(): string;
+    private showStartScreen;
+}

package/dist/packages/server/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./Connection.ts";
+export * from "./Document.ts";
+export * from "./Hocuspocus.ts";
+export * from "./IncomingMessage.ts";
+export * from "./MessageReceiver.ts";
+export * from "./OutgoingMessage.ts";
+export * from "./Server.ts";
+export * from "./types.ts";
+export * from "./util/debounce.ts";