@hocuspocus/extension-sqlite 2.0.6 → 2.1.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/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,13 @@
+import Document from './Document.js';
+import type { Hocuspocus } from './Hocuspocus.js';
+export declare class DirectConnection {
+    document: Document | null;
+    instance: Hocuspocus;
+    context: any;
+    /**
+     * Constructor.
+     */
+    constructor(document: Document, instance: Hocuspocus, context?: any);
+    transact(transaction: (document: Document) => void): Promise<void>;
+    disconnect(): void;
+}

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

@@ -1,88 +1,91 @@
-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 { Debugger } from './Debugger';
-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;
-    }>;
-    name: string;
-    mux: mutex;
-    logger: Debugger;
-    isLoading: boolean;
-    /**
-     * Constructor.
-     */
-    constructor(name: string, logger: Debugger, yDocOptions: {});
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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): void;
-}
-export default Document;
+import WebSocket from 'ws';
+import { Awareness } from 'y-protocols/awareness';
+import { Doc } from 'yjs';
+import { mutex } from 'lib0/mutex.js';
+import Connection from './Connection.js';
+import { Debugger } from './Debugger.js';
+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;
+    mux: mutex;
+    logger: Debugger;
+    isLoading: boolean;
+    /**
+     * Constructor.
+     */
+    constructor(name: string, logger: Debugger, yDocOptions: {});
+    /**
+     * 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;
+    /**
+     * 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): void;
+}
+export default Document;