@hocuspocus/extension-webhook 3.4.4 → 3.4.5-rc.0

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

@@ -1,119 +0,0 @@
-import type { Event, MessageEvent } from "ws";
-import EventEmitter from "./EventEmitter.ts";
-import type { HocuspocusProvider } from "./HocuspocusProvider.ts";
-import { WebSocketStatus, type onAwarenessChangeParameters, type onAwarenessUpdateParameters, type onCloseParameters, type onDisconnectParameters, type onMessageParameters, type onOpenParameters, type onOutgoingMessageParameters, type onStatusParameters } from "./types.ts";
-export type HocuspocusWebSocket = WebSocket & {
-    identifier: string;
-};
-export type HocusPocusWebSocket = HocuspocusWebSocket;
-export type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "url">> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
-export interface CompleteHocuspocusProviderWebsocketConfiguration {
-    /**
-     * Whether to connect automatically when creating the provider instance. Default=true
-     */
-    autoConnect: boolean;
-    /**
-     * URL of your @hocuspocus/server instance
-     */
-    url: string;
-    /**
-     * By default, trailing slashes are removed from the URL. Set this to true
-     * to preserve trailing slashes if your server configuration requires them.
-     */
-    preserveTrailingSlash: boolean;
-    /**
-     * An optional WebSocket polyfill, for example for Node.js
-     */
-    WebSocketPolyfill: any;
-    /**
-     * Disconnect when no message is received for the defined amount of milliseconds.
-     */
-    messageReconnectTimeout: number;
-    /**
-     * The delay between each attempt in milliseconds. You can provide a factor to have the delay grow exponentially.
-     */
-    delay: number;
-    /**
-     * The initialDelay is the amount of time to wait before making the first attempt. This option should typically be 0 since you typically want the first attempt to happen immediately.
-     */
-    initialDelay: number;
-    /**
-     * The factor option is used to grow the delay exponentially.
-     */
-    factor: number;
-    /**
-     * The maximum number of attempts or 0 if there is no limit on number of attempts.
-     */
-    maxAttempts: number;
-    /**
-     * minDelay is used to set a lower bound of delay when jitter is enabled. This property has no effect if jitter is disabled.
-     */
-    minDelay: number;
-    /**
-     * The maxDelay option is used to set an upper bound for the delay when factor is enabled. A value of 0 can be provided if there should be no upper bound when calculating delay.
-     */
-    maxDelay: number;
-    /**
-     * If jitter is true then the calculated delay will be a random integer value between minDelay and the calculated delay for the current iteration.
-     */
-    jitter: boolean;
-    /**
-     * A timeout in milliseconds. If timeout is non-zero then a timer is set using setTimeout. If the timeout is triggered then future attempts will be aborted.
-     */
-    timeout: number;
-    handleTimeout: (() => Promise<unknown>) | null;
-    onOpen: (data: onOpenParameters) => void;
-    onConnect: () => void;
-    onMessage: (data: onMessageParameters) => void;
-    onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
-    onStatus: (data: onStatusParameters) => void;
-    onDisconnect: (data: onDisconnectParameters) => void;
-    onClose: (data: onCloseParameters) => void;
-    onDestroy: () => void;
-    onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
-    onAwarenessChange: (data: onAwarenessChangeParameters) => void;
-    /**
-     * Map of attached providers keyed by documentName.
-     */
-    providerMap: Map<string, HocuspocusProvider>;
-}
-export declare class HocuspocusProviderWebsocket extends EventEmitter {
-    private messageQueue;
-    configuration: CompleteHocuspocusProviderWebsocketConfiguration;
-    webSocket: HocusPocusWebSocket | null;
-    webSocketHandlers: {
-        [key: string]: any;
-    };
-    shouldConnect: boolean;
-    status: WebSocketStatus;
-    lastMessageReceived: number;
-    identifier: number;
-    intervals: any;
-    connectionAttempt: {
-        resolve: (value?: any) => void;
-        reject: (reason?: any) => void;
-    } | null;
-    constructor(configuration: HocuspocusProviderWebsocketConfiguration);
-    receivedOnOpenPayload?: Event | undefined;
-    onOpen(event: Event): Promise<void>;
-    attach(provider: HocuspocusProvider): void;
-    detach(provider: HocuspocusProvider): void;
-    setConfiguration(configuration?: Partial<HocuspocusProviderWebsocketConfiguration>): void;
-    cancelWebsocketRetry?: () => void;
-    connect(): Promise<unknown>;
-    attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function): void;
-    cleanupWebSocket(): void;
-    createWebSocketConnection(): Promise<unknown>;
-    onMessage(event: MessageEvent): void;
-    resolveConnectionAttempt(): void;
-    stopConnectionAttempt(): void;
-    rejectConnectionAttempt(): void;
-    closeTries: number;
-    checkConnection(): void;
-    get serverUrl(): string;
-    get url(): string;
-    disconnect(): void;
-    send(message: any): void;
-    onClose({ event }: onCloseParameters): void;
-    destroy(): void;
-}

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

@@ -1,17 +0,0 @@
-import type { Decoder } from "lib0/decoding";
-import type { Encoder } from "lib0/encoding";
-import type { MessageType } from "./types.ts";
-export declare class IncomingMessage {
-    data: any;
-    encoder: Encoder;
-    decoder: Decoder;
-    constructor(data: any);
-    peekVarString(): string;
-    readVarUint(): MessageType;
-    readVarString(): string;
-    readVarUint8Array(): Uint8Array<ArrayBufferLike>;
-    writeVarUint(type: MessageType): void;
-    writeVarString(string: string): void;
-    writeVarUint8Array(data: Uint8Array): void;
-    length(): number;
-}

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

@@ -1,12 +0,0 @@
-import type { HocuspocusProvider } from "./HocuspocusProvider.ts";
-import type { IncomingMessage } from "./IncomingMessage.ts";
-export declare class MessageReceiver {
-    message: IncomingMessage;
-    constructor(message: IncomingMessage);
-    apply(provider: HocuspocusProvider, emitSynced: boolean): void;
-    private applySyncMessage;
-    applySyncStatusMessage(provider: HocuspocusProvider, applied: boolean): void;
-    private applyAwarenessMessage;
-    private applyAuthMessage;
-    private applyQueryAwarenessMessage;
-}

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

@@ -1,9 +0,0 @@
-import type { Encoder } from "lib0/encoding";
-import type { ConstructableOutgoingMessage } from "./types.ts";
-export declare class MessageSender {
-    encoder: Encoder;
-    message: any;
-    constructor(Message: ConstructableOutgoingMessage, args?: any);
-    create(): Uint8Array<ArrayBufferLike>;
-    send(webSocket: any): void;
-}

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

@@ -1,9 +0,0 @@
-import type { Encoder } from "lib0/encoding";
-import type { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from "./types.ts";
-export declare class OutgoingMessage implements OutgoingMessageInterface {
-    encoder: Encoder;
-    type?: MessageType;
-    constructor();
-    get(args: Partial<OutgoingMessageArguments>): Encoder | undefined;
-    toUint8Array(): Uint8Array<ArrayBufferLike>;
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,93 +0,0 @@
-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 type AuthorizedScope = "read-write" | "readonly";
-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: AuthorizedScope;
-};
-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

@@ -1,63 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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>;
-        onTokenSyncCallback: (payload: {
-            token: string;
-        }) => 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;
-    /**
-     * Set a callback that will be triggered when on token sync message is received
-     */
-    onTokenSyncCallback(callback: (payload: {
-        token: string;
-    }) => Promise<void>): Connection;
-    /**
-     * Send the given message
-     */
-    send(message: any): void;
-    /**
-     * Send a stateless message with payload
-     */
-    sendStateless(payload: string): void;
-    /**
-     * Request current token from the client
-     */
-    requestToken(): 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

@@ -1,14 +0,0 @@
-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

@@ -1,92 +0,0 @@
-import { Mutex } from "async-mutex";
-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;
-    saveMutex: Mutex;
-    lastChangeTime: number;
-    /**
-     * 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;