active-connect-ng2 0.2.39 → 0.2.41

package/fesm2020/active-connect-ng2.mjs

@@ -1,1158 +0,0 @@
-import * as i0 from '@angular/core';
-import { NgModule } from '@angular/core';
-import * as i1 from 'ngx-indexed-db';
-import { NgxIndexedDBModule } from 'ngx-indexed-db';
-export { NgxIndexedDBService } from 'ngx-indexed-db';
-import { Observable } from 'rxjs';
-
-const dbConfig = {
-    name: 'activeconnect_cache',
-    version: 2,
-    objectStoresMeta: [
-        {
-            store: 'outbound',
-            storeConfig: { keyPath: 'method', autoIncrement: false },
-            storeSchema: [
-                { name: 'method', keypath: 'method', options: { unique: true } },
-                { name: 'data', keypath: 'data', options: { unique: false } },
-                {
-                    name: 'specificHash',
-                    keypath: 'specificHash',
-                    options: { unique: false },
-                },
-                {
-                    name: 'length',
-                    keypath: 'length',
-                    options: { unique: false },
-                },
-            ],
-        },
-    ],
-};
-class ActiveConnectNg2Module {
-}
-ActiveConnectNg2Module.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ActiveConnectNg2Module, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ActiveConnectNg2Module.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ActiveConnectNg2Module, imports: [i1.NgxIndexedDBModule], exports: [NgxIndexedDBModule] });
-ActiveConnectNg2Module.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ActiveConnectNg2Module, imports: [NgxIndexedDBModule.forRoot(dbConfig), NgxIndexedDBModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ActiveConnectNg2Module, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [],
-                    imports: [NgxIndexedDBModule.forRoot(dbConfig)],
-                    exports: [NgxIndexedDBModule],
-                }]
-        }] });
-
-class JsonParser {
-    static stringify(obj) {
-        return JSON.stringify(obj);
-    }
-    static parsingFunction(key, value) {
-        var a;
-        if (typeof value === "string") {
-            a =
-                /^[0-9]{4}\-[0-9]{2}\-[0-9]{2}T[0-9]{2}\:[0-9]{2}\:[0-9]{2}\.[0-9]{3}Z$/.exec(value);
-            if (a) {
-                return new Date(a);
-            }
-        }
-        return value;
-    }
-    static parse(str) {
-        if (str && str != "undefined") {
-            return JSON.parse(str, JsonParser.parsingFunction);
-        }
-        return str;
-    }
-}
-
-class WebsocketClient {
-    constructor(url, supportsCache, dbService) {
-        this.url = url;
-        this.supportsCache = supportsCache;
-        this.dbService = dbService;
-        this.requestStack = [];
-        this.requestHistoryLogs = [];
-        this._token = '';
-        this.connectionEstablishedOnce = false;
-        this.messageId = 0;
-        this.rejectCallbacks = new Map();
-        this.expectedMethods = new Map();
-        this.closed = false;
-        if (supportsCache)
-            this.initCache();
-        if (!url) {
-            let protocol;
-            let port;
-            switch (document.location.protocol) {
-                case 'https:': {
-                    protocol = 'wss:';
-                    port = ':443';
-                    break;
-                }
-                default: {
-                    protocol = 'ws:';
-                    port = ':80';
-                    break;
-                }
-            }
-            this.url = protocol + '//' + document.location.hostname + port + '/wss';
-        }
-        this.connect(this.url);
-    }
-    connect(url) {
-        if (!this.subject) {
-            this.create(url);
-        }
-        return this.subject;
-    }
-    initTabSuspendedListener() {
-        if (document) {
-            document.addEventListener('visibilitychange', () => {
-                if (document.visibilityState === 'hidden') {
-                    console.log('ActiveConnect: Closing WebSocket due to tab suspension...');
-                    this.disconnect(true);
-                }
-                else if (document.visibilityState === 'visible') {
-                    console.log('ActiveConnect: Reconnecting WebSocket...');
-                    this.connect(this.url);
-                }
-            });
-        }
-    }
-    logEntry(method) {
-        this.requestHistoryLogs.push({ timestamp: new Date(Date.now()), method });
-    }
-    get logs() {
-        return this.requestHistoryLogs;
-    }
-    get Token() {
-        if (!this._token) {
-            if (window.localStorage)
-                this._token = window.localStorage.getItem('token') || '';
-        }
-        return this._token;
-    }
-    set Token(val) {
-        this._token = val;
-        if (window.localStorage)
-            window.localStorage.setItem('token', val);
-    }
-    set Connected(value) {
-        if (value) {
-            this.sendBrowserInfoToServer();
-            this.auth(this.Token).then(() => {
-                Promise.all(WebsocketClient.onReconnectCallback.map((c) => c.Func ? c.Func() : null)).then(() => {
-                    setTimeout(() => {
-                        this.resetRequestedState();
-                        this.requestStack.forEach((e) => {
-                            this.sendToSocket(e.method, e.data);
-                            this.requestStack = this.requestStack.filter((e1) => e1 != e);
-                        });
-                    }, 2000);
-                });
-            });
-        }
-        if (this.pool && this.pool.WssConnected)
-            this.pool.WssConnected = value;
-    }
-    resetRequestedState() {
-        if (this.connectionEstablishedOnce) {
-            // reset requested state for outbounds
-            WebsocketClient.resetRequestedStateCallbacks.forEach((reset) => {
-                reset();
-            });
-        }
-        else {
-            this.connectionEstablishedOnce = true;
-        }
-    }
-    static addResetRequestingStateCallback(callback) {
-        WebsocketClient.resetRequestedStateCallbacks.push(callback);
-    }
-    create(url) {
-        // create new connection
-        this.logEntry('TCP/HTTP:CONNECT-SERVER');
-        this.ws = new WebSocket(url + (this.supportsCache ? '?cache=true' : ''));
-        this.ws.onerror = (err) => {
-            this.ws.close();
-            this.logEntry('TCP/HTTP:ERROR:' + err);
-            console.log('ActiveConnect: ' + err);
-        };
-        this.ws.onopen = () => {
-            this.logEntry('TCP/HTTP:CONNECTED');
-            this.Connected = true;
-        };
-        this.ws.onmessage = (e) => {
-            this.messageReceived(JsonParser.parse(e.data.toString()));
-        };
-        this.ws.onclose = () => {
-            this.logEntry('TCP/HTTP:CLOSED');
-            if (!this.closed) {
-                if (this.pool && this.pool.WssConnected)
-                    this.pool.WssConnected = false;
-                setTimeout(() => {
-                    this.connect(url);
-                }, 1000);
-            }
-        };
-    }
-    sendToSocket(method, data, dontEnsureTransmission) {
-        const messageId = ++this.messageId;
-        if (this.ws.readyState != this.ws.OPEN) {
-            if (!dontEnsureTransmission)
-                this.requestStack.push({ method, data, messageId });
-            else
-                return false;
-        }
-        else {
-            this.ws.send(JsonParser.stringify({ method, value: data, messageId }));
-        }
-        return messageId;
-    }
-    async auth(token) {
-        return this.sendToSocket('auth.token', token);
-    }
-    send(method, data, dontEnsureTransmission) {
-        this.logEntry('SEND:' + method);
-        const messageId = this.sendToSocket(method, data, dontEnsureTransmission || false);
-        if (messageId) {
-            return this.expectMethod(`m.${method}`, messageId);
-        }
-        else {
-            return new Promise((resolve) => {
-                resolve(false);
-            });
-        }
-    }
-    expectMethod(method, messageId) {
-        return new Promise((resolve, reject) => {
-            if (messageId) {
-                this.expectedMethods.set(messageId, [resolve]);
-                this.rejectCallbacks.set(messageId, reject);
-            }
-            else {
-                if (this.expectedMethods.has(method)) {
-                    let arr = this.expectedMethods.get(method);
-                    arr.push(resolve);
-                }
-                else {
-                    this.expectedMethods.set(method, [resolve]);
-                }
-            }
-        });
-    }
-    messageReceived({ method, value, messageId, specificHash, inserted, updated, deleted, length, }) {
-        this.logEntry('RECEIVED:' + method);
-        if (method == '___cache') {
-            this.handleOutboundCacheRequest(value);
-        }
-        if (messageId) {
-            if (method == 'm.error') {
-                const reject = this.rejectCallbacks.get(messageId);
-                if (reject) {
-                    reject(value);
-                }
-                messageId = -1;
-            }
-        }
-        if (messageId != null) {
-            const callback = this.expectedMethods.get(messageId);
-            if (callback) {
-                const func = callback.shift();
-                if (func)
-                    func(value);
-                this.invokeSuccessHandlers(method);
-            }
-            else {
-                const callback = this.expectedMethods.get(method);
-                if (callback && callback.length > 0) {
-                    const func = callback.shift();
-                    if (func)
-                        func(value);
-                }
-                else {
-                    const out = WebsocketClient.outbounds.get(method);
-                    if (out) {
-                        out(value, specificHash, inserted, updated, deleted, length, this);
-                    }
-                    const handle = WebsocketClient.handles.get(method);
-                    if (handle) {
-                        handle.Func(value);
-                    }
-                }
-            }
-        }
-        else {
-            throw Error('No MessageId was provided, the connection is not supported.');
-        }
-    }
-    handleOutboundCacheRequest(method) {
-        if (this.dbService) {
-            try {
-                this.dbService.getByKey('outbound', method).subscribe((item) => {
-                    if (item) {
-                        this.send('___cache', {
-                            method,
-                            specificHash: item.specificHash || null,
-                        });
-                    }
-                    else {
-                        this.send('___cache', {
-                            method,
-                            specificHash: null,
-                        });
-                    }
-                });
-            }
-            catch (e) {
-                this.send('___cache', {
-                    method,
-                    specificHash: null,
-                });
-                console.error('ActiveConnect: ' + e);
-            }
-        }
-        else {
-            this.send('___cache', {
-                method,
-                specificHash: null,
-            });
-            console.error('Active-Connect: Caching not possible as the indexedDB has not been initialized');
-        }
-    }
-    static expectOutbound(method, callback) {
-        WebsocketClient.outbounds.set(method, callback);
-    }
-    static registerHandle(method, callback) {
-        WebsocketClient.handles.set(method, callback);
-    }
-    get isConnected() {
-        if (this.ws)
-            return this.ws.readyState == WebSocket.OPEN;
-        return true;
-    }
-    sendBrowserInfoToServer() {
-        // send browser / os information
-        const browser = this.getBrowser();
-        const os = this.getOS();
-        this.send('___browser', {
-            browser: `${browser.name} ${browser.version} ${os}`,
-        });
-    }
-    getBrowser() {
-        // https://www.gregoryvarghese.com/how-to-get-browser-name-and-version-via-javascript/
-        var ua = navigator.userAgent, tem, M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
-        if (/trident/i.test(M[1])) {
-            tem = /\brv[ :]+(\d+)/g.exec(ua) || [];
-            return { name: 'IE ', version: tem[1] || '' };
-        }
-        if (M[1] === 'Chrome') {
-            tem = ua.match(/\bOPR\/(\d+)/);
-            if (tem != null) {
-                return { name: 'Opera', version: tem[1] };
-            }
-        }
-        M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];
-        if ((tem = ua.match(/version\/(\d+)/i)) != null) {
-            M.splice(1, 1, tem[1]);
-        }
-        return {
-            name: M[0],
-            version: M[1],
-        };
-    }
-    getOS() {
-        var userAgent = window.navigator.userAgent, platform = window.navigator.platform, macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'], windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'], iosPlatforms = ['iPhone', 'iPad', 'iPod'], os = null;
-        if (macosPlatforms.indexOf(platform) !== -1) {
-            os = 'Mac OS';
-        }
-        else if (iosPlatforms.indexOf(platform) !== -1) {
-            os = 'iOS';
-        }
-        else if (windowsPlatforms.indexOf(platform) !== -1) {
-            os = 'Windows';
-        }
-        else if (/Android/.test(userAgent)) {
-            os = 'Android';
-        }
-        else if (!os && /Linux/.test(platform)) {
-            os = 'Linux';
-        }
-        return os || '';
-    }
-    static onSuccess(callback, regexp) {
-        this.onSuccessHandlers.push({ callback, regexp });
-    }
-    static onReconnect(callback) {
-        WebsocketClient.onReconnectCallback.push(callback);
-    }
-    invokeSuccessHandlers(method) {
-        WebsocketClient.onSuccessHandlers
-            .filter((e) => e.regexp.test(method))
-            .forEach((e) => {
-            var res = e.callback.Func();
-            if (res && res.then) {
-                res.then();
-            }
-        });
-    }
-    disconnect(restart) {
-        if (!restart)
-            this.closed = true;
-        this.ws.close();
-    }
-    initCache() { }
-}
-WebsocketClient.resetRequestedStateCallbacks = [];
-WebsocketClient.outbounds = new Map();
-WebsocketClient.handles = new Map();
-WebsocketClient.onSuccessHandlers = [];
-WebsocketClient.onReconnectCallback = [];
-
-/**
- * Represents the reference to an object method used for websocket routes and outbounds.
- */
-class DecorableFunction {
-    /**
-     * Creates an instance of DecorableFunction.
-     * @param objConfig - The configuration object for the object method.
-     * @param objConfig.target - The target object.
-     * @param objConfig.propertyKey - The property key of the target object.
-     */
-    constructor(objConfig) {
-        this.objConfig = objConfig;
-        // singelton service - fetch from angular
-        const prototype = this.objConfig.target.prototype || this.objConfig.target;
-        if (!prototype.___constructorOverridden) {
-            prototype.___constructorOverridden = true;
-        }
-    }
-    /**
-     * Returns the decorated function.
-     * @returns - The decorated function.
-     */
-    get Func() {
-        if (this.objConfig?.target &&
-            this.objConfig.target[this.objConfig.propertyKey]) {
-            return this.objConfig.target[this.objConfig.propertyKey].bind(this.getBindObject());
-        }
-        return null;
-    }
-    /**
-     * Returns the bind object.
-     * @private
-     * @returns - The bind object.
-     */
-    getBindObject() {
-        const prototype = this.objConfig.target.prototype || this.objConfig.target;
-        return prototype.___data._obj;
-    }
-}
-
-function Handle(method) {
-    return function _Handle(target, propertyKey) {
-        // method annotation
-        WebsocketClient.registerHandle(method, new DecorableFunction({ target, propertyKey }));
-    };
-}
-
-function OnSuccess(regexp) {
-    return function _Route(target, propertyKey) {
-        WebsocketClient.onSuccess(new DecorableFunction({ target, propertyKey }), regexp);
-    };
-}
-
-function OnReconnect(target, propertyKey) {
-    WebsocketClient.onReconnect(new DecorableFunction({ target, propertyKey }));
-}
-
-function Outbound(method, requestingRequired, cached, sortBy) {
-    return function _Outbound(target, propertyKey) {
-        target.loading = new Map();
-        // property annotation
-        WebsocketClient.expectOutbound(method, function setOutbound(data, specificHash, inserted, updated, deleted, length, _this) {
-            if (!target.___received)
-                target.___received = {};
-            if (!target.___data)
-                target.___data = {};
-            if (!target.___received)
-                target.___received = {};
-            if (!target.___requested)
-                target.___requested = {};
-            if (!cached) {
-                if (_this.dbService) {
-                    try {
-                        _this.dbService
-                            .deleteByKey('outbound', method)
-                            .subscribe(() => { });
-                    }
-                    catch (e) {
-                        console.error('ActiveConnect: could not delete indexdb cache entry');
-                    }
-                }
-            }
-            if (data == 'cache_restore') {
-                if (_this.dbService) {
-                    try {
-                        _this.dbService
-                            .getByKey('outbound', method)
-                            .subscribe((result) => {
-                            target.___received[propertyKey] = true;
-                            target.___data[propertyKey] = result.data;
-                            target.loading.set(propertyKey, false);
-                        });
-                    }
-                    catch (e) {
-                        console.error('ActiveConnect: Unable to restore cached data.');
-                        console.error(e);
-                    }
-                }
-                else {
-                    console.error('ActiveConnect: Caching / restore not possible as the indexedDB is not accessible');
-                }
-            }
-            else if (data == 'cache_delete') {
-                if (_this.dbService) {
-                    try {
-                        _this.dbService
-                            .deleteByKey('outbound', method)
-                            .subscribe(() => { });
-                    }
-                    catch (e) {
-                        console.error('ActiveConnect: Unable to delete cached data');
-                        console.error(e);
-                    }
-                }
-                else {
-                    console.error('ActiveConnect: Caching / restore not possible as the indexedDB is not accessible');
-                }
-                target.___received[propertyKey] = false;
-                target.___data[propertyKey] = undefined;
-                target.loading.set(propertyKey, false);
-            }
-            else if (data == 'data_delete') {
-                target.___data[propertyKey] = undefined;
-                target.loading.set(propertyKey, false);
-                target.___received[propertyKey] = false;
-                target.___requested[propertyKey] = false;
-            }
-            else if (data == 'data_diff') {
-                var data = target.___data[propertyKey] || [];
-                inserted?.forEach((e) => {
-                    const matching = data.filter((d) => d.id == e.id);
-                    if (matching.length > 0) {
-                        data[data.indexOf(matching[0])] = e;
-                    }
-                    else {
-                        data.push(e);
-                    }
-                });
-                updated?.forEach((e) => {
-                    const matching = data.filter((d) => d.id == e.id);
-                    if (matching.length > 0) {
-                        data[data.indexOf(matching[0])] = e;
-                    }
-                    else {
-                        data.push(e);
-                    }
-                });
-                deleted?.forEach((e) => {
-                    data = data.filter((d) => d.id != e.id);
-                });
-                if (sortBy && data)
-                    data = data.sort(sortBy);
-                target.___data[propertyKey] = data;
-                target.loading.set(propertyKey, false);
-                if (cached && specificHash) {
-                    if (_this.dbService) {
-                        if (data && data?.length > 0) {
-                            try {
-                                _this.dbService
-                                    .update('outbound', {
-                                    method,
-                                    data,
-                                    specificHash,
-                                })
-                                    .subscribe(() => { });
-                            }
-                            catch (e) {
-                                console.error('ActiveConnect: Unable to update cached data');
-                                console.error(e);
-                            }
-                        }
-                        else {
-                            try {
-                                _this.dbService
-                                    .deleteByKey('outbound', method)
-                                    .subscribe(() => { });
-                            }
-                            catch (e) {
-                                console.error('ActiveConnect: Unable to delete cached data');
-                                console.error(e);
-                            }
-                        }
-                    }
-                    else {
-                        console.error('ActiveConnect: Caching not possible as the indexedDB has not been initialized');
-                    }
-                }
-            }
-            else {
-                if (sortBy && data)
-                    data = data.sort(sortBy);
-                target.___received[propertyKey] = true;
-                target.___data[propertyKey] = data;
-                target.loading.set(propertyKey, false);
-                if (cached && specificHash) {
-                    if (_this.dbService) {
-                        if (data && data?.length > 0) {
-                            try {
-                                _this.dbService
-                                    .update('outbound', {
-                                    method,
-                                    data,
-                                    specificHash,
-                                })
-                                    .subscribe(() => { });
-                            }
-                            catch (e) {
-                                console.error('ActiveConnect: Unable to update cached data');
-                                console.error(e);
-                            }
-                        }
-                        else {
-                            try {
-                                _this.dbService
-                                    .deleteByKey('outbound', method)
-                                    .subscribe(() => { });
-                            }
-                            catch (e) {
-                                console.error('ActiveConnect: Unable to update cached data');
-                                console.error(e);
-                            }
-                        }
-                    }
-                    else {
-                        console.error('ActiveConnect: Caching not possible as the indexedDB has not been initialized');
-                    }
-                }
-            }
-        });
-        if (requestingRequired) {
-            WebsocketClient.addResetRequestingStateCallback(function callback() {
-                if (target.___requested) {
-                    target.___requested[propertyKey] = false;
-                }
-            });
-        }
-        const obj = {
-            configurable: true,
-            get() {
-                if (!target.___requested)
-                    target.___requested = {};
-                if (requestingRequired && !target.___requested[propertyKey]) {
-                    target.___requested[propertyKey] = true;
-                    this.send('request.' + method, null).then();
-                }
-                if (!target.___data)
-                    target.___data = {};
-                if (!target.___data[propertyKey]) {
-                    target.loading.set(propertyKey, true);
-                }
-                else if (target.loading[propertyKey]) {
-                    target.loading.set(propertyKey, false);
-                }
-                return target.___data[propertyKey];
-            },
-            set(val) {
-                if (!target.___data)
-                    target.___data = {};
-                target.loading.set(propertyKey, false);
-                if (sortBy && val)
-                    val = val.sort(sortBy);
-                return (target.___data[propertyKey] = val);
-            },
-        };
-        target[propertyKey] = obj;
-        return obj;
-    };
-}
-
-function Route(method, loadingKey, dontEnsureTransmission) {
-    return function _Route(target, propertyKey) {
-        // method annotation
-        const original = target[propertyKey];
-        target[propertyKey] = async function execRoute(...data) {
-            if (loadingKey) {
-                if (!this.loadingElements[loadingKey]) {
-                    this.loadingElements[loadingKey] = 0;
-                }
-                this.loadingElements[loadingKey]++;
-            }
-            const promise = original.bind(this)(...data);
-            let res = null;
-            if (this.client) {
-                res = await this.client
-                    .send(method, data[0], dontEnsureTransmission)
-                    ?.catch((err) => {
-                    if (loadingKey)
-                        this.loadingElements[loadingKey]--;
-                    throw err;
-                });
-            }
-            await promise;
-            if (loadingKey)
-                this.loadingElements[loadingKey]--;
-            return res;
-        };
-        return target;
-    };
-}
-
-/**
- * @deprecated
- */
-function Shared(defaultValue) {
-    if (defaultValue) {
-        throw Error("Active-Connect/@Shared: defaultValue is no longer supported, please assign the value to the variable itself.");
-    }
-    return function _Shared(target, propertyKey) { };
-}
-
-class LoadingStatus extends WebsocketClient {
-    get isLoading() {
-        // return general loading
-        let anyTrue = false;
-        this.__proto__.loading.forEach((e) => {
-            anyTrue || (anyTrue = e);
-        });
-        if (!anyTrue)
-            this.__proto__.loading.clear();
-        return this.__proto__.loading.size > 0;
-    }
-    getLoadingMap() {
-        return this.__proto__.loading;
-    }
-    get getCurrent() {
-        let count = 0;
-        this.__proto__.loading.forEach((e) => {
-            if (e)
-                count++;
-        });
-        if (count == 0) {
-            this.__proto__.loading.clear();
-        }
-        return count;
-    }
-    get getTotal() {
-        return this.__proto__.loading.size;
-    }
-}
-
-class OutboundObject {
-    constructor(client, method, lazyLoaded, cached, initialLoadingCount, sortBy) {
-        this.client = client;
-        this.method = method;
-        this.lazyLoaded = lazyLoaded;
-        this.cached = cached;
-        this.initialLoadingCount = initialLoadingCount;
-        this.sortBy = sortBy;
-        this.dataMap = new Map();
-        this.data = undefined;
-        this.requested = false;
-        this._loading = false;
-        this._length = undefined;
-        this.requestedId = null;
-        this.loadedObservable = null;
-        this.loadedId = null;
-        this.loadedIdData = null;
-        this.loadedIdChanged = null;
-        this.requestedGroupId = null;
-        this.loadedGroupObservable = null;
-        this.loadedGroupId = null;
-        this.loadedGroupData = null;
-        this.loadedGroupChanged = null;
-        this.target.loading = new Map();
-        if (this.client.dbService) {
-            try {
-                this.client.dbService
-                    .getByKey('outbound', method)
-                    .subscribe((result) => {
-                    if (result) {
-                        this.previouslyCachedCount = result.data?.length || null;
-                    }
-                });
-            }
-            catch (e) {
-                console.error('ActiveConnect: Unable to read cached data');
-                console.error(e);
-            }
-        }
-        const _this = this;
-        WebsocketClient.expectOutbound(method, function setOutbound(data, specificHash, insertedOrGroupData, updatedOrGroupId, deleted, length, _client) {
-            if (!cached) {
-                if (_client.dbService) {
-                    try {
-                        _client.dbService
-                            .deleteByKey('outbound', method)
-                            .subscribe(() => { });
-                    }
-                    catch (e) {
-                        console.error('ActiveConnect: Unable to delete cached data');
-                        console.error(e);
-                    }
-                }
-            }
-            if (data == 'cache_restore') {
-                if (_client.dbService) {
-                    try {
-                        _client.dbService
-                            .getByKey('outbound', method)
-                            .subscribe((result) => {
-                            _this.setData(result.data);
-                            if (result.length)
-                                _this._length = result.length;
-                            _this.loading = false;
-                        });
-                    }
-                    catch (e) {
-                        console.error('ActiveConnect: Unable to restore cached data');
-                        console.error(e);
-                    }
-                }
-                else {
-                    console.error('ActiveConnect: Caching / restore not possible as the indexedDB is not accessible');
-                }
-            }
-            else if (data == 'cache_delete') {
-                if (_client.dbService) {
-                    try {
-                        _client.dbService
-                            .deleteByKey('outbound', method)
-                            .subscribe(() => { });
-                    }
-                    catch (e) {
-                        console.error('ActiveConnect: Unable to delete cached data');
-                        console.error(e);
-                    }
-                }
-                else {
-                    console.error('ActiveConnect: Caching / restore not possible as the indexedDB is not accessible');
-                }
-                _this.loading = false;
-                _this.requested = false;
-            }
-            else if (data == 'data_delete') {
-                _this.data = undefined;
-                _this.dataMap = new Map();
-                _this.requested = false;
-                _this.loadedGroupData = null;
-                _this.loadedGroupId = null;
-                _this._length = undefined;
-                _this.loading = false;
-            }
-            else if (data == 'data_group') {
-                if (_this.requestedGroupId ==
-                    (updatedOrGroupId ? updatedOrGroupId[0] : 0)) {
-                    _this.loadedGroupData = insertedOrGroupData;
-                    _this.loadedGroupId = updatedOrGroupId ? updatedOrGroupId[0] : 0;
-                    _this.loadedGroupChanged?.next(insertedOrGroupData);
-                    _this.loading = false;
-                }
-            }
-            else if (data == 'data_id') {
-                if (_this.requestedId == (updatedOrGroupId ? updatedOrGroupId[0] : 0)) {
-                    _this.loadedIdData =
-                        (insertedOrGroupData?.length || 0) > 0
-                            ? insertedOrGroupData[0]
-                            : null;
-                    _this.loadedId = updatedOrGroupId ? updatedOrGroupId[0] : 0;
-                    _this.loadedIdChanged?.next(_this.loadedIdData);
-                    _this.loading = false;
-                }
-            }
-            else if (data == 'data_diff') {
-                insertedOrGroupData?.forEach((e) => {
-                    _this.dataMap.set(e.id, e);
-                    if (e.id == _this.loadedId) {
-                        _this.loadedIdChanged?.next(e);
-                    }
-                });
-                updatedOrGroupId?.forEach((e) => {
-                    _this.dataMap.set(e.id, e);
-                    if (e.id == _this.loadedId) {
-                        _this.loadedIdChanged?.next(e);
-                    }
-                });
-                deleted?.forEach((e) => {
-                    _this.dataMap.delete(e.id);
-                    if (e.id == _this.loadedId) {
-                        _this.loadedIdChanged?.next(null);
-                    }
-                });
-                _this.data = Array.from(_this.dataMap.values());
-                if (_this.data && _this.sortBy)
-                    _this.data = _this.data.sort(_this.sortBy);
-                _this.loading = false;
-                if (cached && specificHash) {
-                    if (_client.dbService) {
-                        try {
-                            if (_this.data && _this.data?.length > 0) {
-                                _client.dbService
-                                    .update('outbound', {
-                                    method,
-                                    data: _this.data,
-                                    specificHash,
-                                    length,
-                                })
-                                    .subscribe(() => { });
-                            }
-                            else {
-                                _client.dbService
-                                    .deleteByKey('outbound', method)
-                                    .subscribe(() => { });
-                            }
-                        }
-                        catch (e) {
-                            console.error('ActiveConnect: Unable to update cached data.');
-                            console.error(e);
-                        }
-                    }
-                    else {
-                        console.error('ActiveConnect: Caching not possible as the indexedDB has not been initialized');
-                    }
-                }
-            }
-            else {
-                _this.setData(data);
-                if (_this.loadedId) {
-                    const loadedValue = _this.dataMap.get(_this.loadedId);
-                    if (loadedValue) {
-                        _this.loadedIdData = loadedValue;
-                        _this.loadedIdChanged?.next(_this.loadedIdData);
-                    }
-                }
-                _this.loading = false;
-                if (cached && specificHash) {
-                    if (_client.dbService) {
-                        try {
-                            if (data && data?.length > 0) {
-                                _client.dbService
-                                    .update('outbound', {
-                                    method,
-                                    data,
-                                    specificHash,
-                                    length,
-                                })
-                                    .subscribe(() => { });
-                            }
-                            else {
-                                _client.dbService
-                                    .deleteByKey('outbound', method)
-                                    .subscribe(() => { });
-                            }
-                        }
-                        catch (e) {
-                            console.error('ActiveConnect: Unable to update cached data.');
-                            console.error(e);
-                        }
-                    }
-                    else {
-                        console.error('ActiveConnect: Caching not possible as the indexedDB has not been initialized');
-                    }
-                }
-            }
-            if (length)
-                _this._length = length;
-        });
-        WebsocketClient.addResetRequestingStateCallback(() => {
-            this.afterServerReconnected();
-        });
-    }
-    get target() {
-        return this.client.__proto__;
-    }
-    get(id) {
-        if (this.requestedId == id && this.loadedObservable && this.loadedIdData) {
-            if (this.loadedIdData)
-                setTimeout(() => {
-                    if (this.loadedIdData)
-                        this.loadedIdChanged?.next(this.loadedIdData);
-                }, 50);
-            return this.loadedObservable;
-        }
-        let observablePromise;
-        if (this.requestedId != id || !this.loadedObservable) {
-            observablePromise = new Promise((resolve) => {
-                this.loadedObservable = new Observable((observer) => {
-                    this.loadedIdChanged = observer;
-                    resolve();
-                });
-            });
-        }
-        Promise.all([observablePromise]).then(() => {
-            new Promise(async (resolve) => {
-                if (!this.requested && this.lazyLoaded) {
-                    this.load().then();
-                }
-                if (this.data) {
-                    const res = this.dataMap.get(id);
-                    if (res) {
-                        this.loadedIdChanged?.next(res);
-                        resolve();
-                        return;
-                    }
-                }
-                if (this.loadedId == id) {
-                    this.loadedIdChanged?.next(this.loadedIdData);
-                }
-                else {
-                    await this.requestById(id);
-                }
-                resolve();
-            }).then();
-        });
-        return this.loadedObservable;
-    }
-    getForGroup(groupId) {
-        if (this.requestedGroupId == groupId &&
-            this.loadedGroupObservable &&
-            this.loadedGroupData) {
-            setTimeout(() => {
-                if (this.loadedGroupData)
-                    this.loadedGroupChanged?.next(this.loadedGroupData);
-            }, 50);
-            return this.loadedGroupObservable;
-        }
-        let observablePromise;
-        if (this.requestedGroupId != groupId || !this.loadedGroupObservable) {
-            observablePromise = new Promise((resolve) => {
-                this.loadedGroupObservable = new Observable((observer) => {
-                    this.loadedGroupChanged = observer;
-                    resolve();
-                });
-            });
-        }
-        Promise.all([observablePromise]).then(() => {
-            new Promise(async (resolve) => {
-                if (!this.requested && this.lazyLoaded) {
-                    this.load().then();
-                }
-                if (this.loadedGroupId == groupId && this.loadedGroupData) {
-                    this.loadedGroupChanged?.next(this.loadedGroupData);
-                }
-                else {
-                    await this.requestForGroup(groupId);
-                }
-                resolve();
-            }).then();
-        });
-        return this.loadedGroupObservable;
-    }
-    get all() {
-        if (!this.requested && this.lazyLoaded) {
-            this.load().then();
-        }
-        return this.data;
-    }
-    async load(count) {
-        if (this.lazyLoaded) {
-            const hasBeenRequestedBefore = this.requested;
-            this._loading = true;
-            if (!this.requested) {
-                this.loading = true;
-            }
-            this.requested = true;
-            await this.client.send('request.' + this.method, {
-                count: hasBeenRequestedBefore
-                    ? this.data
-                        ? count || this.initialLoadingCount
-                            ? (count || this.initialLoadingCount) +
-                                this.loadedLength
-                            : undefined
-                        : undefined
-                    : this.previouslyCachedCount || this.initialLoadingCount,
-                loaded: this.loadedLength,
-            });
-        }
-        else {
-            throw Error('Active-Connect: Cannot run loading request as this outbound is not lazy-loaded.');
-        }
-    }
-    set loading(value) {
-        this._loading = value;
-        this.target.loading.set(this.method, value);
-    }
-    get loading() {
-        return this._loading;
-    }
-    get loadedLength() {
-        return this.data?.length || 0;
-    }
-    get length() {
-        return this._length;
-    }
-    requestById(id) {
-        this.loading = true;
-        this.requestedId = id;
-        return this.client.send('request.' + this.method, { id });
-    }
-    requestForGroup(groupId) {
-        this.loading = true;
-        this.requestedGroupId = groupId;
-        return this.client.send('request.' + this.method, { groupId });
-    }
-    setData(data) {
-        this.data = data;
-        if (this.data && this.sortBy)
-            this.data = this.data.sort(this.sortBy);
-        this._length = data.length;
-        this.dataMap = new Map();
-        this.data.forEach((d) => {
-            this.dataMap.set(d.id, d);
-        });
-    }
-    get isEmpty() {
-        return this.data == undefined;
-    }
-    /**
-     * The contained data can be modified within the callback method
-     */
-    update(callback) {
-        if (this.data) {
-            const updateLengthVariable = this.data.length == this._length;
-            const length = this.length;
-            callback(this.data);
-            this.setData(this.data);
-            if (!updateLengthVariable) {
-                this._length = length;
-            }
-        }
-    }
-    afterServerReconnected() {
-        if (this.requested && this.lazyLoaded) {
-            this.requested = false;
-            this.load(1).then();
-        }
-        if (this.loadedId) {
-            this.loadedIdData = null;
-            this.get(this.loadedId);
-        }
-        if (this.loadedGroupId) {
-            this.loadedGroupData = null;
-            this.getForGroup(this.loadedGroupId);
-        }
-    }
-}
-
-/*
- * Public API Surface of active-connect-ng2
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { ActiveConnectNg2Module, Handle, LoadingStatus, OnReconnect, OnSuccess, Outbound, OutboundObject, Route, Shared, WebsocketClient };
-//# sourceMappingURL=active-connect-ng2.mjs.map