@hocuspocus/extension-throttle 2.1.0-alpha.0 → 2.1.0

package/dist/hocuspocus-throttle.cjs

@@ -2,90 +2,90 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-class Throttle {
-    /**
-     * Constructor
-     */
-    constructor(configuration) {
-        this.configuration = {
-            throttle: 15,
-            banTime: 5,
-            consideredSeconds: 60,
-            cleanupInterval: 90,
-        };
-        this.connectionsByIp = new Map();
-        this.bannedIps = new Map();
-        this.configuration = {
-            ...this.configuration,
-            ...configuration,
-        };
-        this.cleanupInterval = setInterval(this.clearMaps.bind(this), this.configuration.cleanupInterval * 1000);
-    }
-    onDestroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-        }
-        return Promise.resolve();
-    }
-    clearMaps() {
-        this.connectionsByIp.forEach((value, key) => {
-            const filteredValue = value
-                .filter(timestamp => timestamp + (this.configuration.consideredSeconds * 1000) > Date.now());
-            if (filteredValue.length) {
-                this.connectionsByIp.set(key, filteredValue);
-            }
-            else {
-                this.connectionsByIp.delete(key);
-            }
-        });
-        this.bannedIps.forEach((value, key) => {
-            if (!this.isBanned(key)) {
-                this.bannedIps.delete(key);
-            }
-        });
-    }
-    isBanned(ip) {
-        const bannedAt = this.bannedIps.get(ip) || 0;
-        return Date.now() < (bannedAt + (this.configuration.banTime * 60 * 1000));
-    }
-    /**
-     * Throttle requests
-     * @private
-     */
-    throttle(ip) {
-        if (!this.configuration.throttle) {
-            return false;
-        }
-        if (this.isBanned(ip))
-            return true;
-        this.bannedIps.delete(ip);
-        // add this connection try to the list of previous connections
-        const previousConnections = this.connectionsByIp.get(ip) || [];
-        previousConnections.push(Date.now());
-        // calculate the previous connections in the last considered time interval
-        const previousConnectionsInTheConsideredInterval = previousConnections
-            .filter(timestamp => timestamp + (this.configuration.consideredSeconds * 1000) > Date.now());
-        this.connectionsByIp.set(ip, previousConnectionsInTheConsideredInterval);
-        if (previousConnectionsInTheConsideredInterval.length > this.configuration.throttle) {
-            this.bannedIps.set(ip, Date.now());
-            return true;
-        }
-        return false;
-    }
-    /**
-     * onConnect hook
-     * @param data
-     */
-    onConnect(data) {
-        const { request } = data;
-        // get the remote ip address
-        const ip = request.headers['x-real-ip']
-            || request.headers['x-forwarded-for']
-            || request.socket.remoteAddress
-            || '';
-        // throttle the connection
-        return this.throttle(ip) ? Promise.reject() : Promise.resolve();
-    }
+class Throttle {
+    /**
+     * Constructor
+     */
+    constructor(configuration) {
+        this.configuration = {
+            throttle: 15,
+            banTime: 5,
+            consideredSeconds: 60,
+            cleanupInterval: 90,
+        };
+        this.connectionsByIp = new Map();
+        this.bannedIps = new Map();
+        this.configuration = {
+            ...this.configuration,
+            ...configuration,
+        };
+        this.cleanupInterval = setInterval(this.clearMaps.bind(this), this.configuration.cleanupInterval * 1000);
+    }
+    onDestroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+        return Promise.resolve();
+    }
+    clearMaps() {
+        this.connectionsByIp.forEach((value, key) => {
+            const filteredValue = value
+                .filter(timestamp => timestamp + (this.configuration.consideredSeconds * 1000) > Date.now());
+            if (filteredValue.length) {
+                this.connectionsByIp.set(key, filteredValue);
+            }
+            else {
+                this.connectionsByIp.delete(key);
+            }
+        });
+        this.bannedIps.forEach((value, key) => {
+            if (!this.isBanned(key)) {
+                this.bannedIps.delete(key);
+            }
+        });
+    }
+    isBanned(ip) {
+        const bannedAt = this.bannedIps.get(ip) || 0;
+        return Date.now() < (bannedAt + (this.configuration.banTime * 60 * 1000));
+    }
+    /**
+     * Throttle requests
+     * @private
+     */
+    throttle(ip) {
+        if (!this.configuration.throttle) {
+            return false;
+        }
+        if (this.isBanned(ip))
+            return true;
+        this.bannedIps.delete(ip);
+        // add this connection try to the list of previous connections
+        const previousConnections = this.connectionsByIp.get(ip) || [];
+        previousConnections.push(Date.now());
+        // calculate the previous connections in the last considered time interval
+        const previousConnectionsInTheConsideredInterval = previousConnections
+            .filter(timestamp => timestamp + (this.configuration.consideredSeconds * 1000) > Date.now());
+        this.connectionsByIp.set(ip, previousConnectionsInTheConsideredInterval);
+        if (previousConnectionsInTheConsideredInterval.length > this.configuration.throttle) {
+            this.bannedIps.set(ip, Date.now());
+            return true;
+        }
+        return false;
+    }
+    /**
+     * onConnect hook
+     * @param data
+     */
+    onConnect(data) {
+        const { request } = data;
+        // get the remote ip address
+        const ip = request.headers['x-real-ip']
+            || request.headers['x-forwarded-for']
+            || request.socket.remoteAddress
+            || '';
+        // throttle the connection
+        return this.throttle(ip) ? Promise.reject() : Promise.resolve();
+    }
 }
 
 exports.Throttle = Throttle;

package/dist/hocuspocus-throttle.esm.js

@@ -1,87 +1,87 @@
-class Throttle {
-    /**
-     * Constructor
-     */
-    constructor(configuration) {
-        this.configuration = {
-            throttle: 15,
-            banTime: 5,
-            consideredSeconds: 60,
-            cleanupInterval: 90,
-        };
-        this.connectionsByIp = new Map();
-        this.bannedIps = new Map();
-        this.configuration = {
-            ...this.configuration,
-            ...configuration,
-        };
-        this.cleanupInterval = setInterval(this.clearMaps.bind(this), this.configuration.cleanupInterval * 1000);
-    }
-    onDestroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-        }
-        return Promise.resolve();
-    }
-    clearMaps() {
-        this.connectionsByIp.forEach((value, key) => {
-            const filteredValue = value
-                .filter(timestamp => timestamp + (this.configuration.consideredSeconds * 1000) > Date.now());
-            if (filteredValue.length) {
-                this.connectionsByIp.set(key, filteredValue);
-            }
-            else {
-                this.connectionsByIp.delete(key);
-            }
-        });
-        this.bannedIps.forEach((value, key) => {
-            if (!this.isBanned(key)) {
-                this.bannedIps.delete(key);
-            }
-        });
-    }
-    isBanned(ip) {
-        const bannedAt = this.bannedIps.get(ip) || 0;
-        return Date.now() < (bannedAt + (this.configuration.banTime * 60 * 1000));
-    }
-    /**
-     * Throttle requests
-     * @private
-     */
-    throttle(ip) {
-        if (!this.configuration.throttle) {
-            return false;
-        }
-        if (this.isBanned(ip))
-            return true;
-        this.bannedIps.delete(ip);
-        // add this connection try to the list of previous connections
-        const previousConnections = this.connectionsByIp.get(ip) || [];
-        previousConnections.push(Date.now());
-        // calculate the previous connections in the last considered time interval
-        const previousConnectionsInTheConsideredInterval = previousConnections
-            .filter(timestamp => timestamp + (this.configuration.consideredSeconds * 1000) > Date.now());
-        this.connectionsByIp.set(ip, previousConnectionsInTheConsideredInterval);
-        if (previousConnectionsInTheConsideredInterval.length > this.configuration.throttle) {
-            this.bannedIps.set(ip, Date.now());
-            return true;
-        }
-        return false;
-    }
-    /**
-     * onConnect hook
-     * @param data
-     */
-    onConnect(data) {
-        const { request } = data;
-        // get the remote ip address
-        const ip = request.headers['x-real-ip']
-            || request.headers['x-forwarded-for']
-            || request.socket.remoteAddress
-            || '';
-        // throttle the connection
-        return this.throttle(ip) ? Promise.reject() : Promise.resolve();
-    }
+class Throttle {
+    /**
+     * Constructor
+     */
+    constructor(configuration) {
+        this.configuration = {
+            throttle: 15,
+            banTime: 5,
+            consideredSeconds: 60,
+            cleanupInterval: 90,
+        };
+        this.connectionsByIp = new Map();
+        this.bannedIps = new Map();
+        this.configuration = {
+            ...this.configuration,
+            ...configuration,
+        };
+        this.cleanupInterval = setInterval(this.clearMaps.bind(this), this.configuration.cleanupInterval * 1000);
+    }
+    onDestroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+        return Promise.resolve();
+    }
+    clearMaps() {
+        this.connectionsByIp.forEach((value, key) => {
+            const filteredValue = value
+                .filter(timestamp => timestamp + (this.configuration.consideredSeconds * 1000) > Date.now());
+            if (filteredValue.length) {
+                this.connectionsByIp.set(key, filteredValue);
+            }
+            else {
+                this.connectionsByIp.delete(key);
+            }
+        });
+        this.bannedIps.forEach((value, key) => {
+            if (!this.isBanned(key)) {
+                this.bannedIps.delete(key);
+            }
+        });
+    }
+    isBanned(ip) {
+        const bannedAt = this.bannedIps.get(ip) || 0;
+        return Date.now() < (bannedAt + (this.configuration.banTime * 60 * 1000));
+    }
+    /**
+     * Throttle requests
+     * @private
+     */
+    throttle(ip) {
+        if (!this.configuration.throttle) {
+            return false;
+        }
+        if (this.isBanned(ip))
+            return true;
+        this.bannedIps.delete(ip);
+        // add this connection try to the list of previous connections
+        const previousConnections = this.connectionsByIp.get(ip) || [];
+        previousConnections.push(Date.now());
+        // calculate the previous connections in the last considered time interval
+        const previousConnectionsInTheConsideredInterval = previousConnections
+            .filter(timestamp => timestamp + (this.configuration.consideredSeconds * 1000) > Date.now());
+        this.connectionsByIp.set(ip, previousConnectionsInTheConsideredInterval);
+        if (previousConnectionsInTheConsideredInterval.length > this.configuration.throttle) {
+            this.bannedIps.set(ip, Date.now());
+            return true;
+        }
+        return false;
+    }
+    /**
+     * onConnect hook
+     * @param data
+     */
+    onConnect(data) {
+        const { request } = data;
+        // get the remote ip address
+        const ip = request.headers['x-real-ip']
+            || request.headers['x-forwarded-for']
+            || request.socket.remoteAddress
+            || '';
+        // throttle the connection
+        return this.throttle(ip) ? Promise.reject() : Promise.resolve();
+    }
 }
 
 export { Throttle };

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

@@ -1,29 +1,29 @@
-export interface CloseEvent {
-    code: number;
-    reason: string;
-}
-/**
- * The server is terminating the connection because a data frame was received
- * that is too large.
- * See: https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
- */
-export declare const MessageTooBig: CloseEvent;
-/**
- * The server successfully processed the request, asks that the requester reset
- * its document view, and is not returning any content.
- */
-export declare const ResetConnection: CloseEvent;
-/**
- * Similar to Forbidden, but specifically for use when authentication is required and has
- * failed or has not yet been provided.
- */
-export declare const Unauthorized: CloseEvent;
-/**
- * The request contained valid data and was understood by the server, but the server
- * is refusing action.
- */
-export declare const Forbidden: CloseEvent;
-/**
- * The server timed out waiting for the request.
- */
-export declare const ConnectionTimeout: CloseEvent;
+export interface CloseEvent {
+    code: number;
+    reason: string;
+}
+/**
+ * The server is terminating the connection because a data frame was received
+ * that is too large.
+ * See: https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+ */
+export declare const MessageTooBig: CloseEvent;
+/**
+ * The server successfully processed the request, asks that the requester reset
+ * its document view, and is not returning any content.
+ */
+export declare const ResetConnection: CloseEvent;
+/**
+ * Similar to Forbidden, but specifically for use when authentication is required and has
+ * failed or has not yet been provided.
+ */
+export declare const Unauthorized: CloseEvent;
+/**
+ * The request contained valid data and was understood by the server, but the server
+ * is refusing action.
+ */
+export declare const Forbidden: CloseEvent;
+/**
+ * The server timed out waiting for the request.
+ */
+export declare const ConnectionTimeout: CloseEvent;

package/dist/packages/common/src/auth.d.ts

@@ -1,6 +1,6 @@
-import * as encoding from 'lib0/encoding';
-import * as decoding from 'lib0/decoding';
-export declare const writeAuthentication: (encoder: encoding.Encoder, auth: string) => void;
-export declare const writePermissionDenied: (encoder: encoding.Encoder, reason: string) => void;
-export declare const writeAuthenticated: (encoder: encoding.Encoder) => void;
-export declare const readAuthMessage: (decoder: decoding.Decoder, permissionDeniedHandler: (reason: string) => void, authenticatedHandler: () => void) => void;
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+export declare const writeAuthentication: (encoder: encoding.Encoder, auth: string) => void;
+export declare const writePermissionDenied: (encoder: encoding.Encoder, reason: string) => void;
+export declare const writeAuthenticated: (encoder: encoding.Encoder, scope: 'readonly' | 'read-write') => void;
+export declare const readAuthMessage: (decoder: decoding.Decoder, permissionDeniedHandler: (reason: string) => void, authenticatedHandler: (scope: string) => void) => void;

package/dist/packages/common/src/awarenessStatesToArray.d.ts

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

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

@@ -1,4 +1,4 @@
-export * from './auth';
-export * from './CloseEvents';
-export * from './awarenessStatesToArray';
-export * from './types';
+export * from './auth.js';
+export * from './CloseEvents.js';
+export * from './awarenessStatesToArray.js';
+export * from './types.js';

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

@@ -1,10 +1,10 @@
-/**
- * State of the WebSocket connection.
- * https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
- */
-export declare enum WsReadyStates {
-    Connecting = 0,
-    Open = 1,
-    Closing = 2,
-    Closed = 3
-}
+/**
+ * State of the WebSocket connection.
+ * https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
+ */
+export declare enum WsReadyStates {
+    Connecting = 0,
+    Open = 1,
+    Closing = 2,
+    Closed = 3
+}

package/dist/packages/extension-database/src/Database.d.ts

@@ -1,30 +1,30 @@
-import { Extension, onChangePayload, onLoadDocumentPayload, storePayload, fetchPayload } from '@hocuspocus/server';
-export interface DatabaseConfiguration {
-    /**
-     * Pass a Promise to retrieve updates from your database. The Promise should resolve to
-     * an array of items with Y.js-compatible binary data.
-     */
-    fetch: (data: fetchPayload) => Promise<Uint8Array | null>;
-    /**
-     * Pass a function to store updates in your database.
-     */
-    store: (data: storePayload) => void;
-}
-export declare class Database implements Extension {
-    /**
-     * Default configuration
-     */
-    configuration: DatabaseConfiguration;
-    /**
-     * Constructor
-     */
-    constructor(configuration: Partial<DatabaseConfiguration>);
-    /**
-     * Get stored data from the database.
-     */
-    onLoadDocument(data: onLoadDocumentPayload): Promise<any>;
-    /**
-     * Store new updates in the database.
-     */
-    onStoreDocument(data: onChangePayload): Promise<void>;
-}
+import { Extension, onChangePayload, onLoadDocumentPayload, storePayload, fetchPayload } from '@hocuspocus/server';
+export interface DatabaseConfiguration {
+    /**
+     * Pass a Promise to retrieve updates from your database. The Promise should resolve to
+     * an array of items with Y.js-compatible binary data.
+     */
+    fetch: (data: fetchPayload) => Promise<Uint8Array | null>;
+    /**
+     * Pass a function to store updates in your database.
+     */
+    store: (data: storePayload) => void;
+}
+export declare class Database implements Extension {
+    /**
+     * Default configuration
+     */
+    configuration: DatabaseConfiguration;
+    /**
+     * Constructor
+     */
+    constructor(configuration: Partial<DatabaseConfiguration>);
+    /**
+     * Get stored data from the database.
+     */
+    onLoadDocument(data: onLoadDocumentPayload): Promise<any>;
+    /**
+     * Store new updates in the database.
+     */
+    onStoreDocument(data: onChangePayload): Promise<void>;
+}

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

@@ -1 +1 @@
-export * from './Database';
+export * from './Database.js';

package/dist/packages/extension-logger/src/Logger.d.ts

@@ -1,67 +1,67 @@
-import { Extension, onChangePayload, onConfigurePayload, onConnectPayload, onLoadDocumentPayload, onDestroyPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload } from '@hocuspocus/server';
-export interface LoggerConfiguration {
-    /**
-     * Prepend all logging message with a string.
-     *
-     * @deprecated
-     */
-    prefix: null | string;
-    /**
-     * Whether to log something for the `onLoadDocument` hook.
-     */
-    onLoadDocument: boolean;
-    /**
-     * Whether to log something for the `onChange` hook.
-     */
-    onChange: boolean;
-    /**
-     * Whether to log something for the `onStoreDocument` hook.
-     */
-    onStoreDocument: boolean;
-    /**
-     * Whether to log something for the `onConnect` hook.
-     */
-    onConnect: boolean;
-    /**
-     * Whether to log something for the `onDisconnect` hook.
-     */
-    onDisconnect: boolean;
-    /**
-     * Whether to log something for the `onUpgrade` hook.
-     */
-    onUpgrade: boolean;
-    /**
-     * Whether to log something for the `onRequest` hook.
-     */
-    onRequest: boolean;
-    /**
-     * Whether to log something for the `onDestroy` hook.
-     */
-    onDestroy: boolean;
-    /**
-     * Whether to log something for the `onConfigure` hook.
-     */
-    onConfigure: boolean;
-    /**
-     * A log function, if none is provided output will go to console
-     */
-    log: (...args: any[]) => void;
-}
-export declare class Logger implements Extension {
-    name: string | null;
-    configuration: LoggerConfiguration;
-    /**
-     * Constructor
-     */
-    constructor(configuration?: Partial<LoggerConfiguration>);
-    onConfigure(data: onConfigurePayload): Promise<void>;
-    onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
-    onChange(data: onChangePayload): Promise<void>;
-    onStoreDocument(data: onDisconnectPayload): Promise<void>;
-    onConnect(data: onConnectPayload): Promise<void>;
-    onDisconnect(data: onDisconnectPayload): Promise<void>;
-    onUpgrade(data: onUpgradePayload): Promise<void>;
-    onRequest(data: onRequestPayload): Promise<void>;
-    onDestroy(data: onDestroyPayload): Promise<void>;
-    private log;
-}
+import { Extension, onChangePayload, onConfigurePayload, onConnectPayload, onLoadDocumentPayload, onDestroyPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload } from '@hocuspocus/server';
+export interface LoggerConfiguration {
+    /**
+     * Prepend all logging message with a string.
+     *
+     * @deprecated
+     */
+    prefix: null | string;
+    /**
+     * Whether to log something for the `onLoadDocument` hook.
+     */
+    onLoadDocument: boolean;
+    /**
+     * Whether to log something for the `onChange` hook.
+     */
+    onChange: boolean;
+    /**
+     * Whether to log something for the `onStoreDocument` hook.
+     */
+    onStoreDocument: boolean;
+    /**
+     * Whether to log something for the `onConnect` hook.
+     */
+    onConnect: boolean;
+    /**
+     * Whether to log something for the `onDisconnect` hook.
+     */
+    onDisconnect: boolean;
+    /**
+     * Whether to log something for the `onUpgrade` hook.
+     */
+    onUpgrade: boolean;
+    /**
+     * Whether to log something for the `onRequest` hook.
+     */
+    onRequest: boolean;
+    /**
+     * Whether to log something for the `onDestroy` hook.
+     */
+    onDestroy: boolean;
+    /**
+     * Whether to log something for the `onConfigure` hook.
+     */
+    onConfigure: boolean;
+    /**
+     * A log function, if none is provided output will go to console
+     */
+    log: (...args: any[]) => void;
+}
+export declare class Logger implements Extension {
+    name: string | null;
+    configuration: LoggerConfiguration;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<LoggerConfiguration>);
+    onConfigure(data: onConfigurePayload): Promise<void>;
+    onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
+    onChange(data: onChangePayload): Promise<void>;
+    onStoreDocument(data: onDisconnectPayload): Promise<void>;
+    onConnect(data: onConnectPayload): Promise<void>;
+    onDisconnect(data: onDisconnectPayload): Promise<void>;
+    onUpgrade(data: onUpgradePayload): Promise<void>;
+    onRequest(data: onRequestPayload): Promise<void>;
+    onDestroy(data: onDestroyPayload): Promise<void>;
+    private log;
+}

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

@@ -1 +1 @@
-export * from './Logger';
+export * from './Logger.js';