active-connect-ng2 0.2.41 → 0.2.43

package/fesm2020/active-connect-ng2.mjs

@@ -0,0 +1,1166 @@
+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();
+        this.setUrl(this.url);
+    }
+    setUrl(url) {
+        if (!url) {
+            let protocol;
+            let port;
+            switch (document.location.protocol) {
+                case 'https:': {
+                    protocol = 'wss:';
+                    port = ':443';
+                    break;
+                }
+                default: {
+                    protocol = 'ws:';
+                    port = ':80';
+                    break;
+                }
+            }
+            url = protocol + '//' + document.location.hostname + port + '/wss';
+        }
+        this.url = url;
+        this.disconnect();
+        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;
+                this.logEntry('TCP/HTTP:RESET-REQUESTED-OUTBOUND-STATE');
+                this.resetRequestedState();
+                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;
+        if (this.ws)
+            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