@hocuspocus/common 1.0.0-alpha.10

package/dist/packages/extension-monitor/src/Storage.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+export declare class Storage extends EventEmitter {
+    timed: Map<string, any>;
+    constant: Map<string, any>;
+    /**
+     * Get all constant values.
+     */
+    all(): Promise<any>;
+    /**
+     * Get a constant value by the given key.
+     */
+    get(key: string, defaultValue?: any): Promise<any>;
+    /**
+     * Set a constant value by the given key.
+     */
+    set(key: string, value: any): Promise<any>;
+    /**
+     * Delete a constant value by the given key.
+     * @param key
+     */
+    delete(key: string): Promise<any>;
+    /**
+     * Get all timed values.
+     */
+    allTimed(): Promise<any>;
+    /**
+     * Add a timed value by the given key.
+     */
+    add(key: string, value: any): Promise<any>;
+    /**
+     * Remove a timed value by the given timestamp and key.
+     */
+    remove(key: string, timestamp: string): Promise<any>;
+}

package/dist/packages/extension-monitor/src/index.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { Extension, onChangePayload, onConfigurePayload, onLoadDocumentPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload, connectedPayload } from '@hocuspocus/server';
+import { IncomingMessage, ServerResponse } from 'http';
+import WebSocket from 'ws';
+import { Storage } from './Storage';
+import { Dashboard } from './Dashboard';
+import { Collector } from './Collector';
+export interface Configuration {
+    dashboardPath: string;
+    enableDashboard: boolean;
+    metricsInterval: number;
+    osMetricsInterval: number;
+    password: string | undefined;
+    port: number | undefined;
+    user: string | undefined;
+}
+export declare class Monitor implements Extension {
+    configuration: Configuration;
+    storage: Storage;
+    collector: Collector;
+    dashboard?: Dashboard;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<Configuration>);
+    private collectOsMetrics;
+    private collectConnectionMetrics;
+    private cleanMetrics;
+    handleRequest(request: IncomingMessage, response: ServerResponse): boolean | undefined;
+    handleConnection(websocket: WebSocket, request: IncomingMessage): void | undefined;
+    onRequest({ request, response }: onRequestPayload): Promise<void>;
+    onUpgrade({ request, socket, head }: onUpgradePayload): Promise<void>;
+    connected(data: connectedPayload): Promise<void>;
+    onDisconnect(data: onDisconnectPayload): Promise<void>;
+    onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
+    onChange(data: onChangePayload): Promise<void>;
+    onConfigure(data: onConfigurePayload): Promise<void>;
+}

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

@@ -0,0 +1,16 @@
+import { RedisPersistence } from 'y-redis';
+import { Extension, onConnectPayload, onLoadDocumentPayload, 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>);
+    onLoadDocument(data: onLoadDocumentPayload): Promise<import("yjs").Doc | undefined>;
+    onConnect(data: onConnectPayload): Promise<void>;
+    onDisconnect(data: onDisconnectPayload): Promise<void>;
+}

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

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

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

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

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

@@ -0,0 +1,22 @@
+import { Extension, onLoadDocumentPayload } 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>);
+    /**
+     * onLoadDocument hook
+     */
+    onLoadDocument(data: onLoadDocumentPayload): Promise<any>;
+    /**
+     * store updates in y-leveldb persistence
+     */
+    store(documentName: string, update: Uint8Array): Promise<any>;
+}

package/dist/packages/extension-sqlite/src/SQLite.d.ts

@@ -0,0 +1,26 @@
+import { Database, DatabaseConfiguration } from '@hocuspocus/extension-database';
+import sqlite3 from 'sqlite3';
+export declare const schema = "CREATE TABLE IF NOT EXISTS \"documents\" (\n  \"name\" varchar(255) NOT NULL,\n  \"data\" blob NOT NULL,\n  UNIQUE(name)\n)";
+export declare const selectQuery = "\n  SELECT data FROM \"documents\" WHERE name = $name ORDER BY rowid DESC\n";
+export declare const upsertQuery = "\n  INSERT INTO \"documents\" (\"name\", \"data\") VALUES ($name, $data)\n    ON CONFLICT(name) DO UPDATE SET data = $data\n";
+export interface SQLiteConfiguration extends DatabaseConfiguration {
+    /**
+     * Valid values are filenames, ":memory:" for an anonymous in-memory database and an empty
+     * string for an anonymous disk-based database. Anonymous databases are not persisted and
+     * when closing the database handle, their contents are lost.
+     *
+     * https://github.com/mapbox/node-sqlite3/wiki/API#new-sqlite3databasefilename-mode-callback
+     */
+    database: string;
+    /**
+     * The database schema to create.
+     */
+    schema: string;
+}
+export declare class SQLite extends Database {
+    db?: sqlite3.Database;
+    configuration: SQLiteConfiguration;
+    constructor(configuration?: Partial<SQLiteConfiguration>);
+    onConfigure(): Promise<void>;
+    onListen(): Promise<void>;
+}

package/dist/packages/extension-sqlite/src/index.d.ts

@@ -0,0 +1 @@
+export * from './SQLite';

package/dist/packages/extension-throttle/src/index.d.ts

@@ -0,0 +1,24 @@
+import { Extension, onConnectPayload } from '@hocuspocus/server';
+export interface ThrottleConfiguration {
+    throttle: number | null | false;
+    banTime: number;
+}
+export declare class Throttle implements Extension {
+    configuration: ThrottleConfiguration;
+    connectionsByIp: Map<string, Array<number>>;
+    bannedIps: Map<string, number>;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<ThrottleConfiguration>);
+    /**
+     * Throttle requests
+     * @private
+     */
+    private throttle;
+    /**
+     * onConnect hook
+     * @param data
+     */
+    onConnect(data: onConnectPayload): Promise<any>;
+}

package/dist/packages/extension-webhook/src/index.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+import { Extension, onChangePayload, onConnectPayload, onLoadDocumentPayload, onDisconnectPayload } from '@hocuspocus/server';
+import { Doc } from 'yjs';
+import { Transformer } from '@hocuspocus/transformer';
+import { AxiosResponse } from 'axios';
+export declare enum Events {
+    onChange = "change",
+    onConnect = "connect",
+    onCreate = "create",
+    onDisconnect = "disconnect"
+}
+export interface Configuration {
+    debounce: number | false | null;
+    debounceMaxWait: number;
+    secret: string;
+    transformer: Transformer | {
+        toYdoc: (document: any) => Doc;
+        fromYdoc: (document: Doc) => any;
+    };
+    url: string;
+    events: Array<Events>;
+}
+export declare class Webhook implements Extension {
+    configuration: Configuration;
+    debounced: Map<string, {
+        timeout: NodeJS.Timeout;
+        start: number;
+    }>;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<Configuration>);
+    /**
+     * Create a signature for the response body
+     */
+    createSignature(body: string): string;
+    /**
+     * debounce the given function, using the given identifier
+     */
+    debounce(id: string, func: Function): void;
+    /**
+     * Send a request to the given url containing the given data
+     */
+    sendRequest(event: Events, payload: any): Promise<AxiosResponse<any, any>>;
+    /**
+     * onChange hook
+     */
+    onChange(data: onChangePayload): Promise<void>;
+    /**
+     * onLoadDocument hook
+     */
+    onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
+    /**
+     * onConnect hook
+     */
+    onConnect(data: onConnectPayload): Promise<any>;
+    onDisconnect(data: onDisconnectPayload): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+export default class EventEmitter {
+    callbacks: {
+        [key: string]: Function[];
+    };
+    on(event: string, fn: Function): this;
+    protected emit(event: string, ...args: any): this;
+    off(event: string, fn?: Function): this;
+    removeAllListeners(): void;
+}

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

@@ -0,0 +1,11 @@
+import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider';
+export declare type HocuspocusCloudProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalHocuspocusCloudProviderConfiguration;
+export interface AdditionalHocuspocusCloudProviderConfiguration {
+    /**
+     * A Hocuspocus Cloud key, get one here: https://hocuspocus.cloud/
+     */
+    key: string;
+}
+export declare class HocuspocusCloudProvider extends HocuspocusProvider {
+    constructor(configuration: HocuspocusCloudProviderConfiguration);
+}

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

@@ -0,0 +1,156 @@
+import * as Y from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+import * as mutex from 'lib0/mutex';
+import type { Event, CloseEvent, MessageEvent } from 'ws';
+import EventEmitter from './EventEmitter';
+import { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters, onSyncedParameters, WebSocketStatus } from './types';
+import { onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.';
+export declare type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'url' | 'name'>> & Partial<CompleteHocuspocusProviderConfiguration>;
+export interface CompleteHocuspocusProviderConfiguration {
+    /**
+     * URL of your @hocuspocus/server instance
+     */
+    url: string;
+    /**
+     * The identifier/name of your document
+     */
+    name: string;
+    /**
+     * The actual Y.js document
+     */
+    document: Y.Doc;
+    /**
+     * Pass `false` to start the connection manually.
+     */
+    connect: boolean;
+    /**
+     * Pass false to disable broadcasting between browser tabs.
+     */
+    broadcast: boolean;
+    /**
+     * An Awareness instance to keep the presence state of all clients.
+     */
+    awareness: Awareness;
+    /**
+     * A token that’s sent to the backend for authentication purposes.
+     */
+    token: string | (() => string) | (() => Promise<string>) | null;
+    /**
+     * URL parameters that should be added.
+     */
+    parameters: {
+        [key: string]: any;
+    };
+    /**
+     * An optional WebSocket polyfill, for example for Node.js
+     */
+    WebSocketPolyfill: any;
+    /**
+     * Force syncing the document in the defined interval.
+     */
+    forceSyncInterval: false | number;
+    /**
+     * 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 intialDelay 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;
+    onAuthenticated: () => void;
+    onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
+    onOpen: (data: onOpenParameters) => void;
+    onConnect: () => void;
+    onMessage: (data: onMessageParameters) => void;
+    onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
+    onStatus: (data: onStatusParameters) => void;
+    onSynced: (data: onSyncedParameters) => void;
+    onDisconnect: (data: onDisconnectParameters) => void;
+    onClose: (data: onCloseParameters) => void;
+    onDestroy: () => void;
+    onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
+    onAwarenessChange: (data: onAwarenessChangeParameters) => void;
+    /**
+     * Don’t output any warnings.
+     */
+    quiet: boolean;
+}
+export declare class HocuspocusProvider extends EventEmitter {
+    configuration: CompleteHocuspocusProviderConfiguration;
+    subscribedToBroadcastChannel: boolean;
+    webSocket: WebSocket | null;
+    shouldConnect: boolean;
+    status: WebSocketStatus;
+    isSynced: boolean;
+    isAuthenticated: boolean;
+    lastMessageReceived: number;
+    mux: mutex.mutex;
+    intervals: any;
+    connectionAttempt: {
+        resolve: (value?: any) => void;
+        reject: (reason?: any) => void;
+    } | null;
+    constructor(configuration: HocuspocusProviderConfiguration);
+    setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
+    connect(): Promise<void>;
+    createWebSocketConnection(): Promise<unknown>;
+    resolveConnectionAttempt(): void;
+    stopConnectionAttempt(): void;
+    rejectConnectionAttempt(): void;
+    get document(): Y.Doc;
+    get awareness(): Awareness;
+    checkConnection(): void;
+    forceSync(): void;
+    registerEventListeners(): void;
+    documentUpdateHandler(update: Uint8Array, origin: any): void;
+    awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
+    permissionDeniedHandler(reason: string): void;
+    authenticatedHandler(): void;
+    get serverUrl(): string;
+    get url(): string;
+    get synced(): boolean;
+    set synced(state: boolean);
+    get isAuthenticationRequired(): boolean;
+    disconnect(): void;
+    onOpen(event: Event): Promise<void>;
+    getToken(): Promise<string | null>;
+    startSync(): void;
+    send(Message: ConstructableOutgoingMessage, args: any, broadcast?: boolean): void;
+    onMessage(event: MessageEvent): void;
+    onClose(event: CloseEvent): void;
+    destroy(): void;
+    get broadcastChannel(): string;
+    broadcastChannelSubscriber(data: ArrayBuffer): void;
+    subscribeToBroadcastChannel(): void;
+    disconnectBroadcastChannel(): void;
+    broadcast(Message: ConstructableOutgoingMessage, args?: any): void;
+    setAwarenessField(key: string, value: any): void;
+}

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 './HocuspocusCloudProvider';
+export * from './types';

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

@@ -0,0 +1,77 @@
+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
+}
+export declare enum WebSocketStatus {
+    Connecting = "connecting",
+    Connected = "connected",
+    Disconnected = "disconnected"
+}
+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>;
+export declare type onAuthenticationFailedParameters = {
+    reason: string;
+};
+export declare type onOpenParameters = {
+    event: Event;
+};
+export declare type onMessageParameters = {
+    event: MessageEvent;
+    message: IncomingMessage;
+};
+export declare type onOutgoingMessageParameters = {
+    message: OutgoingMessage;
+};
+export declare type onStatusParameters = {
+    status: WebSocketStatus;
+};
+export declare type onSyncedParameters = {
+    state: boolean;
+};
+export declare type onDisconnectParameters = {
+    event: CloseEvent;
+};
+export declare type onCloseParameters = {
+    event: CloseEvent;
+};
+export declare type onAwarenessUpdateParameters = {
+    states: StatesArray;
+};
+export declare type onAwarenessChangeParameters = {
+    states: StatesArray;
+};
+export declare type StatesArray = {
+    clientId: number;
+    [key: string | number]: any;
+}[];