@hocuspocus/extension-webhook 1.0.0-alpha.34

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

@@ -0,0 +1,14 @@
+import { Decoder } from 'lib0/decoding';
+import { Encoder } from 'lib0/encoding';
+import { MessageType } from './types';
+export declare class IncomingMessage {
+    data: any;
+    encoder: Encoder;
+    decoder: Decoder;
+    constructor(data: any);
+    readVarUint(): MessageType;
+    readVarUint8Array(): Uint8Array;
+    writeVarUint(type: MessageType): void;
+    writeVarUint8Array(data: Uint8Array): void;
+    length(): number;
+}

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

@@ -0,0 +1,13 @@
+import { HocuspocusProvider } from './HocuspocusProvider';
+import { IncomingMessage } from './IncomingMessage';
+export declare class MessageReceiver {
+    message: IncomingMessage;
+    broadcasted: boolean;
+    constructor(message: IncomingMessage);
+    setBroadcasted(value: boolean): this;
+    apply(provider: HocuspocusProvider, emitSynced?: boolean): void;
+    private applySyncMessage;
+    private applyAwarenessMessage;
+    private applyAuthMessage;
+    private applyQueryAwarenessMessage;
+}

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

@@ -0,0 +1,10 @@
+import { Encoder } from 'lib0/encoding';
+import { ConstructableOutgoingMessage } from './types';
+export declare class MessageSender {
+    encoder: Encoder;
+    message: any;
+    constructor(Message: ConstructableOutgoingMessage, args?: any);
+    create(): Uint8Array;
+    send(webSocket: any): void;
+    broadcast(channel: string): void;
+}

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

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

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

@@ -0,0 +1,7 @@
+import { MessageType, OutgoingMessageArguments } from '../types';
+import { OutgoingMessage } from '../OutgoingMessage';
+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

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

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

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

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

@@ -0,0 +1,8 @@
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types';
+import { OutgoingMessage } from '../OutgoingMessage';
+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

@@ -0,0 +1,8 @@
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types';
+import { OutgoingMessage } from '../OutgoingMessage';
+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

@@ -0,0 +1,7 @@
+import { MessageType, OutgoingMessageArguments } from '../types';
+import { OutgoingMessage } from '../OutgoingMessage';
+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';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,34 @@
+import { Awareness } from 'y-protocols/awareness';
+import * as Y from 'yjs';
+import { Encoder } from 'lib0/encoding';
+import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage';
+import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage';
+import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage';
+import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage';
+import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage';
+import { UpdateMessage } from './OutgoingMessages/UpdateMessage';
+export declare enum MessageType {
+    Sync = 0,
+    Awareness = 1,
+    Auth = 2,
+    QueryAwareness = 3
+}
+export interface OutgoingMessageInterface {
+    encoder: Encoder;
+    type?: MessageType;
+}
+export interface OutgoingMessageArguments {
+    token: string;
+    document: Y.Doc;
+    awareness: Awareness;
+    clients: number[];
+    states: Map<number, {
+        [key: string]: any;
+    }>;
+    update: any;
+    encoder: Encoder;
+}
+export interface Constructable<T> {
+    new (...args: any): T;
+}
+export declare type ConstructableOutgoingMessage = Constructable<AuthenticationMessage> | Constructable<AwarenessMessage> | Constructable<QueryAwarenessMessage> | Constructable<SyncStepOneMessage> | Constructable<SyncStepTwoMessage> | Constructable<UpdateMessage>;

package/dist/packages/provider/src/utils/awarenessStatesToArray.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (states: Map<number, Record<string, any>>) => {
+    clientId: number;
+}[];
+export default _default;

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

@@ -0,0 +1 @@
+export { default as awarenessStatesToArray } from './awarenessStatesToArray';

package/dist/packages/redis/src/Redis.d.ts

@@ -0,0 +1,16 @@
+import { RedisPersistence } from 'y-redis';
+import { Extension, onConnectPayload, onCreateDocumentPayload, onDisconnectPayload } from '@hocuspocus/server';
+export interface Configuration {
+}
+export declare class Redis implements Extension {
+    configuration: Configuration;
+    cluster: boolean;
+    persistence: RedisPersistence | undefined;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<Configuration>);
+    onCreateDocument(data: onCreateDocumentPayload): Promise<import("yjs").Doc | undefined>;
+    onConnect(data: onConnectPayload): Promise<void>;
+    onDisconnect(data: onDisconnectPayload): Promise<void>;
+}

package/dist/packages/redis/src/RedisCluster.d.ts

@@ -0,0 +1,4 @@
+import { Redis } from './Redis';
+export declare class RedisCluster extends Redis {
+    cluster: boolean;
+}

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

@@ -0,0 +1,2 @@
+export * from './Redis';
+export * from './RedisCluster';

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

@@ -0,0 +1,22 @@
+import { Extension, onCreateDocumentPayload } from '@hocuspocus/server';
+import { LeveldbPersistence } from 'y-leveldb';
+export interface Configuration {
+    options: object | undefined;
+    path: string;
+}
+export declare class RocksDB implements Extension {
+    configuration: Configuration;
+    provider: LeveldbPersistence;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<Configuration>);
+    /**
+     * onCreateDocument hook
+     */
+    onCreateDocument(data: onCreateDocumentPayload): Promise<any>;
+    /**
+     * store updates in y-leveldb persistence
+     */
+    store(documentName: string, update: Uint8Array): Promise<any>;
+}

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

@@ -0,0 +1,4 @@
+import { CloseEvent } from './types';
+export declare const Forbidden: CloseEvent;
+export declare const ResetConnection: CloseEvent;
+export declare const CloseEvents: CloseEvent[];

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

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import AsyncLock from 'async-lock';
+import WebSocket from 'ws';
+import { IncomingMessage as HTTPIncomingMessage } from 'http';
+import Document from './Document';
+import { CloseEvent } from './types';
+import { MessageLogger } from './Debugger';
+declare class Connection {
+    webSocket: WebSocket;
+    context: any;
+    document: Document;
+    pingInterval: NodeJS.Timeout;
+    pongReceived: boolean;
+    request: HTTPIncomingMessage;
+    timeout: number;
+    callbacks: any;
+    socketId: string;
+    lock: AsyncLock;
+    readOnly: Boolean;
+    debugger: MessageLogger;
+    /**
+     * Constructor.
+     */
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly?: boolean);
+    /**
+     * Set a callback that will be triggered when the connection is closed
+     */
+    onClose(callback: (document: Document) => void): Connection;
+    /**
+     * Send the given message
+     */
+    send(message: any): void;
+    /**
+     * Graceful wrapper around the WebSocket close method.
+     */
+    close(event?: CloseEvent): void;
+    /**
+     * Check if pong was received and close the connection otherwise
+     * @private
+     */
+    private check;
+    /**
+     * Send first sync step
+     * @private
+     */
+    /**
+     * Handle an incoming message
+     * @private
+     */
+    private handleMessage;
+    /**
+     * Get the underlying connection instance
+     * @deprecated
+     */
+    get instance(): WebSocket;
+    /**
+     * Get the underlying connection instance
+     * @deprecated
+     */
+    get connection(): WebSocket;
+}
+export default Connection;

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

@@ -0,0 +1,15 @@
+export declare class MessageLogger {
+    logs: any[];
+    listen: boolean;
+    output: boolean;
+    enable(): void;
+    disable(): void;
+    verbose(): void;
+    quiet(): void;
+    log(message: any): this;
+    flush(): this;
+    get(): {
+        logs: any[];
+    };
+}
+export declare const Debugger: MessageLogger;

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

@@ -0,0 +1,75 @@
+import WebSocket from 'ws';
+import { Awareness } from 'y-protocols/awareness';
+import { Doc } from 'yjs';
+import { mutex } from 'lib0/mutex.js';
+import Connection from './Connection';
+import { MessageLogger } from './Debugger';
+declare class Document extends Doc {
+    awareness: Awareness;
+    callbacks: {
+        onUpdate: (document: Document, connection: Connection, update: Uint8Array) => void;
+    };
+    connections: Map<any, any>;
+    name: string;
+    mux: mutex;
+    debugger: MessageLogger;
+    /**
+     * Constructor.
+     */
+    constructor(name: string);
+    /**
+     * Check if the Document 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+export default Document;

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

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import WebSocket from 'ws';
+import { IncomingMessage, Server as HTTPServer } from 'http';
+import { Configuration } from './types';
+import { MessageLogger } from './Debugger';
+export declare const defaultConfiguration: {
+    port: number;
+    timeout: number;
+};
+/**
+ * Hocuspocus server
+ */
+export declare class Hocuspocus {
+    configuration: Configuration;
+    documents: Map<any, any>;
+    httpServer?: HTTPServer;
+    webSocketServer?: WebSocket.Server;
+    debugger: MessageLogger;
+    /**
+     * Configure the server
+     */
+    configure(configuration: Partial<Configuration>): Hocuspocus;
+    get authenticationRequired(): boolean;
+    /**
+     * Start the server
+     */
+    listen(): Promise<void>;
+    /**
+     * 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;
+    /**
+     * Destroy the server
+     */
+    destroy(): Promise<any>;
+    /**
+     * Handle the incoming WebSocket connection
+     */
+    handleConnection(incoming: WebSocket, request: IncomingMessage, documentName: string, context?: any): void;
+    /**
+     * Handle update of the given document
+     * @private
+     */
+    private handleDocumentUpdate;
+    /**
+     * Create a new document by the given request
+     * @private
+     */
+    private createDocument;
+    /**
+     * Create a new connection by the given request and document
+     * @private
+     */
+    private createConnection;
+    /**
+     * Run the given hook on all configured extensions
+     * Runs the given callback after each hook
+     * @private
+     */
+    private hooks;
+    /**
+     * Get parameters by the given request
+     * @private
+     */
+    private static getParameters;
+    /**
+     * Get document name by the given request
+     * @private
+     */
+    private static getDocumentName;
+    enableDebugging(): void;
+    enableMessageLogging(): void;
+    disableLogging(): void;
+    disableDebugging(): void;
+    flushMessageLogs(): this;
+    getMessageLogs(): any[];
+}
+export declare const Server: Hocuspocus;