@squidcloud/local-backend 1.0.65 → 1.0.67

package/dist/common/src/utils/validation.js

@@ -1,210 +1,210 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasOnlyKeys = exports.isRightType = exports.isNotEmpty = exports.validateQueryLimit = exports.validateMutations = exports.validateOpenIdProviderType = exports.validateOpenIdProvider = exports.validateFieldSort = exports.ValidationError = void 0;
-const assert_1 = require("./assert");
-class ValidationError extends Error {
-    constructor(error, statusCode, details) {
-        super(error);
-        this.statusCode = statusCode;
-        this.details = details;
-    }
-}
-exports.ValidationError = ValidationError;
-function validatePathPart(part) {
-    if (!part || !part.match(/^[a-zA-Z][a-zA-Z0-9!@#$%^&*~_]{0,49}$/)) {
-        throw new Error('A document id and a collection id can contain only a-z, A-Z, 0-9,!@#$%^&*~_, starting' +
-            'with a letter, at least one character, and up to 50.');
-    }
-}
-function validateCollectionName(collectionName) {
-    if (typeof collectionName !== 'string' || !collectionName) {
-        throw new Error('Collection path has to be a non empty string');
-    }
-    validatePathPart(collectionName);
-}
-function validateFieldName(fieldName) {
-    if (!fieldName || typeof fieldName !== 'string') {
-        throw new Error('Field name has to be a non-empty string');
-    }
-    if (fieldName === '__docId__') {
-        return;
-    }
-    if (!fieldName.match(/^[a-zA-Z_$][a-zA-Z0-9!@#$%^&*~_ ]{0,49}$/)) {
-        throw new Error('A Field name can contain only a-z, A-Z, 0-9,!@#$%^&*~_, starting with a letter, at least one character, and up to 50. Field name: ' +
-            fieldName);
-    }
-}
-function validateQueryCondition(condition) {
-    if (!condition) {
-        throw new Error('Condition cannot be empty');
-    }
-    if (!condition.operator ||
-        !['==', '!=', '>', '>=', '<', '<=', 'like', 'not like', 'like_cs', 'not like_cs'].includes(condition.operator)) {
-        throw new Error('Unsupported operator: ' + condition.operator);
-    }
-    validateFieldName(condition.fieldName);
-}
-function validateFieldSort(fieldSort) {
-    if (!(fieldSort instanceof Object)) {
-        throw new Error('Field sort has to be an object');
-    }
-    (0, assert_1.assertTruthy)(hasOnlyKeys(fieldSort, ['fieldName', 'asc']), 'Field sort should only contain a fieldName and asc');
-    (0, assert_1.assertTruthy)(isRightType(fieldSort.asc, 'boolean'), 'Asc needs to be boolean');
-    validateFieldName(fieldSort.fieldName);
-}
-exports.validateFieldSort = validateFieldSort;
-function validateOpenIdProvider(openIdProvider) {
-    (0, assert_1.assertTruthy)(openIdProvider, 'INVALID_PROVIDER');
-    validateOpenIdProviderType(openIdProvider.providerType);
-    (0, assert_1.assertTruthy)(openIdProvider.providerType, 'INVALID_CLIENT_ID');
-    (0, assert_1.assertTruthy)(openIdProvider.clientId, 'INVALID_CLIENT_ID');
-    (0, assert_1.assertTruthy)(openIdProvider.domain, 'INVALID_DOMAIN');
-    return openIdProvider;
-}
-exports.validateOpenIdProvider = validateOpenIdProvider;
-function validateOpenIdProviderType(providerType) {
-    const providerArray = ['auth0'];
-    (0, assert_1.assertTruthy)(providerArray.includes(providerType), 'INVALID_OPEN_ID_PROVIDER_TYPE');
-}
-exports.validateOpenIdProviderType = validateOpenIdProviderType;
-function validateDeleteMutation(mutation) {
-    if (!mutation || mutation.type !== 'delete') {
-        throw new Error('Mutation has to be non empty with type delete.');
-    }
-}
-function validateInsertMutation(mutation) {
-    if (!mutation || mutation.type !== 'insert') {
-        throw new Error('Mutation has to be non empty with type insert.');
-    }
-    if (!mutation.properties || typeof mutation.properties !== 'object') {
-        throw new Error('The properties in insert mutation need to be a JSON object.');
-    }
-    for (const [fieldName] of Object.entries(mutation.properties)) {
-        validateFieldName(fieldName);
-    }
-}
-function validateUpdatePropertyMutation(propertyMutation) {
-    if (!propertyMutation || propertyMutation.type !== 'update') {
-        throw new Error('Update value property mutation has to be of type update');
-    }
-    if (propertyMutation.value === undefined) {
-        throw new Error('Value has to exist in an update value property mutation..');
-    }
-}
-function validateApplyNumericFnPropertyMutation(propertyMutation) {
-    if (!propertyMutation || propertyMutation.type !== 'applyNumericFn') {
-        throw new Error('Apply numeric fn mutation has to be of type applyNumericFn');
-    }
-    if (!['increment'].includes(propertyMutation.fn)) {
-        throw new Error('Invalid fn for apply numeric fn.');
-    }
-    if (typeof propertyMutation.value !== 'number') {
-        throw new Error('The value in an apply numeric fn function has to be numeric.');
-    }
-}
-function validateApplyStringFnPropertyMutation(propertyMutation) {
-    if (!propertyMutation || propertyMutation.type !== 'applyStringFn') {
-        throw new Error('Apply string fn mutation has to be of type applyStringFn');
-    }
-    if (!['trim', 'extendString'].includes(propertyMutation.fn)) {
-        throw new Error('Invalid fn for apply string fn.');
-    }
-    if (typeof propertyMutation.value !== 'string') {
-        throw new Error('The value in an apply string fn function has to be a string.');
-    }
-}
-function validatePropertyMutation(propertyMutation) {
-    if (!propertyMutation || typeof propertyMutation !== 'object') {
-        throw new Error('Property mutation need to be a JSON object.');
-    }
-    if (!['update', 'applyNumericFn', 'applyStringFn'].includes(propertyMutation.type)) {
-        throw new Error(`Property mutation can be of type 'update', 'applyNumericFn', 'applyStringFn'`);
-    }
-    switch (propertyMutation.type) {
-        case 'update':
-            validateUpdatePropertyMutation(propertyMutation);
-            break;
-        case 'applyNumericFn':
-            validateApplyNumericFnPropertyMutation(propertyMutation);
-            break;
-        case 'applyStringFn':
-            validateApplyStringFnPropertyMutation(propertyMutation);
-            break;
-    }
-}
-function validateUpdateMutation(mutation) {
-    if (!mutation || mutation.type !== 'update') {
-        throw new Error('Mutation has to be non empty with type update.');
-    }
-    if (!mutation.properties || typeof mutation.properties !== 'object') {
-        throw new Error('The properties in update mutation need to be a JSON object.');
-    }
-    const entries = Object.entries(mutation.properties);
-    for (const [fieldName, propertyMutations] of entries) {
-        validateFieldName(fieldName);
-        for (const propertyMutation of propertyMutations) {
-            validatePropertyMutation(propertyMutation);
-        }
-    }
-}
-function validateMutation(mutation) {
-    if (!mutation) {
-        throw new Error('Mutation cannot be empty');
-    }
-    if (!['insert', 'delete', 'update'].includes(mutation.type)) {
-        throw new Error(`Mutation type has to be one of 'insert', 'delete', or 'update'`);
-    }
-    validateCollectionName(mutation.squidDocIdObj.collectionName);
-    validatePathPart(mutation.squidDocIdObj.docId);
-    switch (mutation.type) {
-        case 'delete':
-            validateDeleteMutation(mutation);
-            break;
-        case 'insert':
-            validateInsertMutation(mutation);
-            break;
-        case 'update':
-            validateUpdateMutation(mutation);
-            break;
-    }
-}
-function validateMutations(mutations) {
-    if (!mutations || !(mutations instanceof Array) || !mutations.length) {
-        throw new Error('The list of mutations has to be a non-empty array.');
-    }
-    for (const mutation of mutations) {
-        validateMutation(mutation);
-    }
-}
-exports.validateMutations = validateMutations;
-function validateQueryLimit(limit) {
-    (0, assert_1.assertTruthy)(isRightType(limit, 'number'), 'Limit needs to be a number');
-    if (limit === -1)
-        return;
-    (0, assert_1.assertTruthy)(limit > 0, 'query limit has to be greater than 0');
-    (0, assert_1.assertTruthy)(Math.floor(limit) === limit, 'query limit has to be an integer');
-    (0, assert_1.assertTruthy)(limit <= 20000, 'Limit can be maximum 20000');
-}
-exports.validateQueryLimit = validateQueryLimit;
-function isNotEmpty(value) {
-    validateCorrectStringType(value);
-    return typeof value === 'string' && !!value;
-}
-exports.isNotEmpty = isNotEmpty;
-function validateCorrectStringType(value) {
-    if (value !== null && value !== undefined && typeof value !== 'string') {
-        throw new Error(`Unexpected input type ${typeof value}`);
-    }
-}
-function isRightType(value, type) {
-    if (Array.isArray(value)) {
-        return value.every((element) => typeof element === type);
-    }
-    return typeof value === type;
-}
-exports.isRightType = isRightType;
-function hasOnlyKeys(obj, keys) {
-    return !Array.isArray(obj) && [...Object.keys(obj)].every((key) => keys.includes(key));
-}
-exports.hasOnlyKeys = hasOnlyKeys;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOnlyKeys = exports.isRightType = exports.isNotEmpty = exports.validateQueryLimit = exports.validateMutations = exports.validateOpenIdProviderType = exports.validateOpenIdProvider = exports.validateFieldSort = exports.ValidationError = void 0;
+const assert_1 = require("./assert");
+class ValidationError extends Error {
+    constructor(error, statusCode, details) {
+        super(error);
+        this.statusCode = statusCode;
+        this.details = details;
+    }
+}
+exports.ValidationError = ValidationError;
+function validatePathPart(part) {
+    if (!part || !part.match(/^[a-zA-Z][a-zA-Z0-9!@#$%^&*~_]{0,49}$/)) {
+        throw new Error('A document id and a collection id can contain only a-z, A-Z, 0-9,!@#$%^&*~_, starting' +
+            'with a letter, at least one character, and up to 50.');
+    }
+}
+function validateCollectionName(collectionName) {
+    if (typeof collectionName !== 'string' || !collectionName) {
+        throw new Error('Collection path has to be a non empty string');
+    }
+    validatePathPart(collectionName);
+}
+function validateFieldName(fieldName) {
+    if (!fieldName || typeof fieldName !== 'string') {
+        throw new Error('Field name has to be a non-empty string');
+    }
+    if (fieldName === '__docId__') {
+        return;
+    }
+    if (!fieldName.match(/^[a-zA-Z_$][a-zA-Z0-9!@#$%^&*~_ ]{0,49}$/)) {
+        throw new Error('A Field name can contain only a-z, A-Z, 0-9,!@#$%^&*~_, starting with a letter, at least one character, and up to 50. Field name: ' +
+            fieldName);
+    }
+}
+function validateQueryCondition(condition) {
+    if (!condition) {
+        throw new Error('Condition cannot be empty');
+    }
+    if (!condition.operator ||
+        !['==', '!=', '>', '>=', '<', '<=', 'like', 'not like', 'like_cs', 'not like_cs'].includes(condition.operator)) {
+        throw new Error('Unsupported operator: ' + condition.operator);
+    }
+    validateFieldName(condition.fieldName);
+}
+function validateFieldSort(fieldSort) {
+    if (!(fieldSort instanceof Object)) {
+        throw new Error('Field sort has to be an object');
+    }
+    (0, assert_1.assertTruthy)(hasOnlyKeys(fieldSort, ['fieldName', 'asc']), 'Field sort should only contain a fieldName and asc');
+    (0, assert_1.assertTruthy)(isRightType(fieldSort.asc, 'boolean'), 'Asc needs to be boolean');
+    validateFieldName(fieldSort.fieldName);
+}
+exports.validateFieldSort = validateFieldSort;
+function validateOpenIdProvider(openIdProvider) {
+    (0, assert_1.assertTruthy)(openIdProvider, 'INVALID_PROVIDER');
+    validateOpenIdProviderType(openIdProvider.providerType);
+    (0, assert_1.assertTruthy)(openIdProvider.providerType, 'INVALID_CLIENT_ID');
+    (0, assert_1.assertTruthy)(openIdProvider.clientId, 'INVALID_CLIENT_ID');
+    (0, assert_1.assertTruthy)(openIdProvider.domain, 'INVALID_DOMAIN');
+    return openIdProvider;
+}
+exports.validateOpenIdProvider = validateOpenIdProvider;
+function validateOpenIdProviderType(providerType) {
+    const providerArray = ['auth0'];
+    (0, assert_1.assertTruthy)(providerArray.includes(providerType), 'INVALID_OPEN_ID_PROVIDER_TYPE');
+}
+exports.validateOpenIdProviderType = validateOpenIdProviderType;
+function validateDeleteMutation(mutation) {
+    if (!mutation || mutation.type !== 'delete') {
+        throw new Error('Mutation has to be non empty with type delete.');
+    }
+}
+function validateInsertMutation(mutation) {
+    if (!mutation || mutation.type !== 'insert') {
+        throw new Error('Mutation has to be non empty with type insert.');
+    }
+    if (!mutation.properties || typeof mutation.properties !== 'object') {
+        throw new Error('The properties in insert mutation need to be a JSON object.');
+    }
+    for (const [fieldName] of Object.entries(mutation.properties)) {
+        validateFieldName(fieldName);
+    }
+}
+function validateUpdatePropertyMutation(propertyMutation) {
+    if (!propertyMutation || propertyMutation.type !== 'update') {
+        throw new Error('Update value property mutation has to be of type update');
+    }
+    if (propertyMutation.value === undefined) {
+        throw new Error('Value has to exist in an update value property mutation..');
+    }
+}
+function validateApplyNumericFnPropertyMutation(propertyMutation) {
+    if (!propertyMutation || propertyMutation.type !== 'applyNumericFn') {
+        throw new Error('Apply numeric fn mutation has to be of type applyNumericFn');
+    }
+    if (!['increment'].includes(propertyMutation.fn)) {
+        throw new Error('Invalid fn for apply numeric fn.');
+    }
+    if (typeof propertyMutation.value !== 'number') {
+        throw new Error('The value in an apply numeric fn function has to be numeric.');
+    }
+}
+function validateApplyStringFnPropertyMutation(propertyMutation) {
+    if (!propertyMutation || propertyMutation.type !== 'applyStringFn') {
+        throw new Error('Apply string fn mutation has to be of type applyStringFn');
+    }
+    if (!['trim', 'extendString'].includes(propertyMutation.fn)) {
+        throw new Error('Invalid fn for apply string fn.');
+    }
+    if (typeof propertyMutation.value !== 'string') {
+        throw new Error('The value in an apply string fn function has to be a string.');
+    }
+}
+function validatePropertyMutation(propertyMutation) {
+    if (!propertyMutation || typeof propertyMutation !== 'object') {
+        throw new Error('Property mutation need to be a JSON object.');
+    }
+    if (!['update', 'applyNumericFn', 'applyStringFn'].includes(propertyMutation.type)) {
+        throw new Error(`Property mutation can be of type 'update', 'applyNumericFn', 'applyStringFn'`);
+    }
+    switch (propertyMutation.type) {
+        case 'update':
+            validateUpdatePropertyMutation(propertyMutation);
+            break;
+        case 'applyNumericFn':
+            validateApplyNumericFnPropertyMutation(propertyMutation);
+            break;
+        case 'applyStringFn':
+            validateApplyStringFnPropertyMutation(propertyMutation);
+            break;
+    }
+}
+function validateUpdateMutation(mutation) {
+    if (!mutation || mutation.type !== 'update') {
+        throw new Error('Mutation has to be non empty with type update.');
+    }
+    if (!mutation.properties || typeof mutation.properties !== 'object') {
+        throw new Error('The properties in update mutation need to be a JSON object.');
+    }
+    const entries = Object.entries(mutation.properties);
+    for (const [fieldName, propertyMutations] of entries) {
+        validateFieldName(fieldName);
+        for (const propertyMutation of propertyMutations) {
+            validatePropertyMutation(propertyMutation);
+        }
+    }
+}
+function validateMutation(mutation) {
+    if (!mutation) {
+        throw new Error('Mutation cannot be empty');
+    }
+    if (!['insert', 'delete', 'update'].includes(mutation.type)) {
+        throw new Error(`Mutation type has to be one of 'insert', 'delete', or 'update'`);
+    }
+    validateCollectionName(mutation.squidDocIdObj.collectionName);
+    validatePathPart(mutation.squidDocIdObj.docId);
+    switch (mutation.type) {
+        case 'delete':
+            validateDeleteMutation(mutation);
+            break;
+        case 'insert':
+            validateInsertMutation(mutation);
+            break;
+        case 'update':
+            validateUpdateMutation(mutation);
+            break;
+    }
+}
+function validateMutations(mutations) {
+    if (!mutations || !(mutations instanceof Array) || !mutations.length) {
+        throw new Error('The list of mutations has to be a non-empty array.');
+    }
+    for (const mutation of mutations) {
+        validateMutation(mutation);
+    }
+}
+exports.validateMutations = validateMutations;
+function validateQueryLimit(limit) {
+    (0, assert_1.assertTruthy)(isRightType(limit, 'number'), 'Limit needs to be a number');
+    if (limit === -1)
+        return;
+    (0, assert_1.assertTruthy)(limit > 0, 'query limit has to be greater than 0');
+    (0, assert_1.assertTruthy)(Math.floor(limit) === limit, 'query limit has to be an integer');
+    (0, assert_1.assertTruthy)(limit <= 20000, 'Limit can be maximum 20000');
+}
+exports.validateQueryLimit = validateQueryLimit;
+function isNotEmpty(value) {
+    validateCorrectStringType(value);
+    return typeof value === 'string' && !!value;
+}
+exports.isNotEmpty = isNotEmpty;
+function validateCorrectStringType(value) {
+    if (value !== null && value !== undefined && typeof value !== 'string') {
+        throw new Error(`Unexpected input type ${typeof value}`);
+    }
+}
+function isRightType(value, type) {
+    if (Array.isArray(value)) {
+        return value.every((element) => typeof element === type);
+    }
+    return typeof value === type;
+}
+exports.isRightType = isRightType;
+function hasOnlyKeys(obj, keys) {
+    return !Array.isArray(obj) && [...Object.keys(obj)].every((key) => keys.includes(key));
+}
+exports.hasOnlyKeys = hasOnlyKeys;
 //# sourceMappingURL=validation.js.map

package/dist/common/src/webhook-response.d.ts

@@ -1,6 +1,6 @@
-export interface WebhookResponse {
-    headers: Record<string, any>;
-    body: any;
-    statusCode: number;
-    __isWebhookResponse__: true;
-}
+export interface WebhookResponse {
+    headers: Record<string, any>;
+    body: any;
+    statusCode: number;
+    __isWebhookResponse__: true;
+}

package/dist/common/src/webhook-response.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=webhook-response.js.map

package/dist/common/src/websocket.impl.d.ts

@@ -1,21 +1,21 @@
-interface Options {
-    maxAttempts?: number;
-    protocols?: string[];
-    onmessage?: (event: any) => void;
-    onopen?: (event: any) => void;
-    onclose?: (event: any) => void;
-    onerror?: (event: any) => void;
-    onreconnect?: (event: any) => void;
-    onmaximum?: (event: any) => void;
-    timeout?: number;
-}
-export interface WebSocketWrapper {
-    open: () => void;
-    reconnect: (e: any) => void;
-    json: (x: any) => void;
-    send: (x: string) => void;
-    close: (x?: number, y?: string) => void;
-    connected: boolean;
-}
-export declare function createWebSocketWrapper(url: string, opts?: Options): WebSocketWrapper;
-export {};
+interface Options {
+    maxAttempts?: number;
+    protocols?: string[];
+    onmessage?: (event: any) => void;
+    onopen?: (event: any) => void;
+    onclose?: (event: any) => void;
+    onerror?: (event: any) => void;
+    onreconnect?: (event: any) => void;
+    onmaximum?: (event: any) => void;
+    timeout?: number;
+}
+export interface WebSocketWrapper {
+    open: () => void;
+    reconnect: (e: any) => void;
+    json: (x: any) => void;
+    send: (x: string) => void;
+    close: (x?: number, y?: string) => void;
+    connected: boolean;
+}
+export declare function createWebSocketWrapper(url: string, opts?: Options): WebSocketWrapper;
+export {};

package/dist/common/src/websocket.impl.js

@@ -1,77 +1,77 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWebSocketWrapper = void 0;
-const global_utils_1 = require("./utils/global.utils");
-function noop() {
-    return;
-}
-const globalObj = (0, global_utils_1.getGlobal)();
-const WebSocketClass = (_a = globalObj['WebSocket']) !== null && _a !== void 0 ? _a : require('ws');
-function createWebSocketWrapper(url, opts = {}) {
-    let ws;
-    let num = 0;
-    let timer = 1;
-    const $ = {
-        connected: false,
-        open() {
-            var _a;
-            const wsConstructor = (_a = WebSocketClass === null || WebSocketClass === void 0 ? void 0 : WebSocketClass['WebSocket']) !== null && _a !== void 0 ? _a : WebSocketClass;
-            ws = new wsConstructor(url, opts.protocols || []);
-            ws.onmessage = opts.onmessage || noop;
-            ws.onopen = function (e) {
-                $.connected = true;
-                (opts.onopen || noop)(e);
-                num = 0;
-            };
-            ws.onclose = function (e) {
-                $.connected = false;
-                if (e.code !== 4999) {
-                    global_utils_1.DebugLogger.debug('WebSocket closed. Reconnecting. Close code: ', e.code);
-                    (opts.onclose || noop)(e);
-                    $.reconnect(e);
-                    return;
-                }
-                (opts.onclose || noop)(e);
-            };
-            ws.onerror = function (e) {
-                $.connected = false;
-                if (e && 'ECONNREFUSED' === e.code) {
-                    $.reconnect(e);
-                }
-                else {
-                    (opts.onerror || noop)(e);
-                }
-            };
-        },
-        reconnect(e) {
-            const maxAttempts = opts.maxAttempts !== undefined ? opts.maxAttempts : Infinity;
-            if (timer && num++ < maxAttempts) {
-                timer = setTimeout(function () {
-                    (opts.onreconnect || noop)(e);
-                    global_utils_1.DebugLogger.debug('WebSocket trying to reconnect...');
-                    $.open();
-                }, opts.timeout || 1000);
-            }
-            else {
-                (opts.onmaximum || noop)(e);
-            }
-        },
-        json(x) {
-            ws.send(JSON.stringify(x));
-        },
-        send(x) {
-            ws.send(x);
-        },
-        close(code = 4999, message) {
-            $.connected = false;
-            clearTimeout(timer);
-            timer = undefined;
-            ws.close(code, message);
-        },
-    };
-    $.open();
-    return $;
-}
-exports.createWebSocketWrapper = createWebSocketWrapper;
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebSocketWrapper = void 0;
+const global_utils_1 = require("./utils/global.utils");
+function noop() {
+    return;
+}
+const globalObj = (0, global_utils_1.getGlobal)();
+const WebSocketClass = (_a = globalObj['WebSocket']) !== null && _a !== void 0 ? _a : require('ws');
+function createWebSocketWrapper(url, opts = {}) {
+    let ws;
+    let num = 0;
+    let timer = 1;
+    const $ = {
+        connected: false,
+        open() {
+            var _a;
+            const wsConstructor = (_a = WebSocketClass === null || WebSocketClass === void 0 ? void 0 : WebSocketClass['WebSocket']) !== null && _a !== void 0 ? _a : WebSocketClass;
+            ws = new wsConstructor(url, opts.protocols || []);
+            ws.onmessage = opts.onmessage || noop;
+            ws.onopen = function (e) {
+                $.connected = true;
+                (opts.onopen || noop)(e);
+                num = 0;
+            };
+            ws.onclose = function (e) {
+                $.connected = false;
+                if (e.code !== 4999) {
+                    global_utils_1.DebugLogger.debug('WebSocket closed. Reconnecting. Close code: ', e.code);
+                    (opts.onclose || noop)(e);
+                    $.reconnect(e);
+                    return;
+                }
+                (opts.onclose || noop)(e);
+            };
+            ws.onerror = function (e) {
+                $.connected = false;
+                if (e && 'ECONNREFUSED' === e.code) {
+                    $.reconnect(e);
+                }
+                else {
+                    (opts.onerror || noop)(e);
+                }
+            };
+        },
+        reconnect(e) {
+            const maxAttempts = opts.maxAttempts !== undefined ? opts.maxAttempts : Infinity;
+            if (timer && num++ < maxAttempts) {
+                timer = setTimeout(function () {
+                    (opts.onreconnect || noop)(e);
+                    global_utils_1.DebugLogger.debug('WebSocket trying to reconnect...');
+                    $.open();
+                }, opts.timeout || 1000);
+            }
+            else {
+                (opts.onmaximum || noop)(e);
+            }
+        },
+        json(x) {
+            ws.send(JSON.stringify(x));
+        },
+        send(x) {
+            ws.send(x);
+        },
+        close(code = 4999, message) {
+            $.connected = false;
+            clearTimeout(timer);
+            timer = undefined;
+            ws.close(code, message);
+        },
+    };
+    $.open();
+    return $;
+}
+exports.createWebSocketWrapper = createWebSocketWrapper;
 //# sourceMappingURL=websocket.impl.js.map

package/dist/internal-common/src/async-queue.d.ts

@@ -1,4 +1,4 @@
-export declare class AsyncQueue {
-    promise: Promise<void>;
-    enqueue(fn: (...args: any[]) => Promise<any>): Promise<any>;
-}
+export declare class AsyncQueue {
+    promise: Promise<void>;
+    enqueue(fn: (...args: any[]) => Promise<any>): Promise<any>;
+}