@hocuspocus/extension-logger 2.1.0-alpha.0 → 2.2.0

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

@@ -1,8 +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;
-}
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+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,8 +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;
-}
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+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,7 +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;
-}
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class UpdateMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
+}

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

@@ -1,11 +1,11 @@
-import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider';
-export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalTiptapCollabProviderConfiguration;
-export interface AdditionalTiptapCollabProviderConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
-     */
-    appId: string;
-}
-export declare class TiptapCollabProvider extends HocuspocusProvider {
-    constructor(configuration: TiptapCollabProviderConfiguration);
-}
+import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
+export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalTiptapCollabProviderConfiguration;
+export interface AdditionalTiptapCollabProviderConfiguration {
+    /**
+     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
+     */
+    appId: string;
+}
+export declare class TiptapCollabProvider extends HocuspocusProvider {
+    constructor(configuration: TiptapCollabProviderConfiguration);
+}

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

@@ -1,11 +1,11 @@
-import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket';
-export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
-export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
-     */
-    appId: string;
-}
-export declare class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
-    constructor(configuration: TiptapCollabProviderWebsocketConfiguration);
-}
+import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
+export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
+export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
+    /**
+     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
+     */
+    appId: string;
+}
+export declare class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
+    constructor(configuration: TiptapCollabProviderWebsocketConfiguration);
+}

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

@@ -1,5 +1,5 @@
-export * from './HocuspocusProvider';
-export * from './TiptapCollabProvider';
-export * from './TiptapCollabProviderWebsocket';
-export * from './HocuspocusProviderWebsocket';
-export * from './types';
+export * from './HocuspocusProvider.js';
+export * from './TiptapCollabProvider.js';
+export * from './TiptapCollabProviderWebsocket.js';
+export * from './HocuspocusProviderWebsocket.js';
+export * from './types.js';

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

@@ -1,84 +1,84 @@
-import { Awareness } from 'y-protocols/awareness';
-import * as Y from 'yjs';
-import { Encoder } from 'lib0/encoding';
-import type { Event, CloseEvent, MessageEvent } from 'ws';
-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';
-import { IncomingMessage } from './IncomingMessage';
-import { OutgoingMessage } from './OutgoingMessage';
-export declare enum MessageType {
-    Sync = 0,
-    Awareness = 1,
-    Auth = 2,
-    QueryAwareness = 3,
-    Stateless = 5,
-    CLOSE = 7
-}
-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 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 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;
-}[];
+import { Awareness } from 'y-protocols/awareness';
+import * as Y from 'yjs';
+import { Encoder } from 'lib0/encoding';
+import type { Event, CloseEvent, MessageEvent } from 'ws';
+import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js';
+import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js';
+import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js';
+import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js';
+import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js';
+import { UpdateMessage } from './OutgoingMessages/UpdateMessage.js';
+import { IncomingMessage } from './IncomingMessage.js';
+import { OutgoingMessage } from './OutgoingMessage.js';
+export declare enum MessageType {
+    Sync = 0,
+    Awareness = 1,
+    Auth = 2,
+    QueryAwareness = 3,
+    Stateless = 5,
+    CLOSE = 7
+}
+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 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 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,56 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import WebSocket from 'ws';
+import { Debugger } from './Debugger.js';
+import Document from './Document.js';
+import { Hocuspocus } from './Hocuspocus.js';
+import { onDisconnectPayload } from './types.js';
+/**
+ * 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 debuggerTool;
+    private readonly opts;
+    private readonly defaultContext;
+    private readonly documentConnections;
+    private readonly incomingMessageQueue;
+    private readonly documentConnectionsEstablished;
+    private readonly hookPayloads;
+    private readonly callbacks;
+    private readonly closeIdleConnectionTimeout;
+    private readonly socketId;
+    /**
+      * 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'], debuggerTool: Debugger, opts: {
+        requiresAuthentication: boolean;
+        timeout: number;
+    }, defaultContext?: any);
+    /**
+     * 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,71 +1,71 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage as HTTPIncomingMessage } from 'http';
-import AsyncLock from 'async-lock';
-import WebSocket from 'ws';
-import { CloseEvent } from '@hocuspocus/common';
-import Document from './Document';
-import { Debugger } from './Debugger';
-import { onStatelessPayload } from './types';
-export 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;
-    logger: Debugger;
-    /**
-     * Constructor.
-     */
-    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly: boolean | undefined, logger: Debugger);
-    boundClose: (event?: CloseEvent) => void;
-    boundHandleMessage: (data: Uint8Array) => void;
-    boundHandlePong: () => void;
-    handlePong(): void;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * Check if pong was received and close the connection otherwise
-     * @private
-     */
-    private check;
-    /**
-     * Send the current document awareness to the client, if any
-     * @private
-     */
-    private sendCurrentAwareness;
-    /**
-     * Handle an incoming message
-     * @private
-     */
-    private handleMessage;
-}
-export default Connection;
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage as HTTPIncomingMessage } from 'http';
+import AsyncLock from 'async-lock';
+import WebSocket from 'ws';
+import { CloseEvent } from '@hocuspocus/common';
+import Document from './Document.js';
+import { Debugger } from './Debugger.js';
+import { onStatelessPayload } from './types.js';
+export 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;
+    logger: Debugger;
+    /**
+     * Constructor.
+     */
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly: boolean | undefined, logger: Debugger);
+    boundClose: (event?: CloseEvent) => void;
+    boundHandleMessage: (data: Uint8Array) => void;
+    boundHandlePong: () => void;
+    handlePong(): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Check if pong was received and close the connection otherwise
+     * @private
+     */
+    private check;
+    /**
+     * Send the current document awareness to the client, if any
+     * @private
+     */
+    private sendCurrentAwareness;
+    /**
+     * Handle an incoming message
+     * @private
+     */
+    private handleMessage;
+}
+export default Connection;

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

@@ -1,14 +1,14 @@
-export declare class Debugger {
-    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 class Debugger {
+    logs: any[];
+    listen: boolean;
+    output: boolean;
+    enable(): void;
+    disable(): void;
+    verbose(): void;
+    quiet(): void;
+    log(message: any): this;
+    flush(): this;
+    get(): {
+        logs: any[];
+    };
+}

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

@@ -0,0 +1,14 @@
+import Document from './Document.js';
+import type { Hocuspocus } from './Hocuspocus.js';
+import type { DirectConnection as DirectConnectionInterface } from './types';
+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(): void;
+}