active-connect-ng2 0.2.50 → 0.3.0

package/fesm2022/active-connect-ng2.mjs

@@ -0,0 +1,1186 @@
+import * as i0 from "@angular/core";
+import { NgModule, signal, untracked } from "@angular/core";
+import * as i1 from "ngx-indexed-db";
+import { NgxIndexedDBModule, 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 }
+			}
+		]
+	}]
+};
+var ActiveConnectNg2Module = class ActiveConnectNg2Module {
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: ActiveConnectNg2Module,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.NgModule
+		});
+	}
+	static {
+		this.ɵmod = i0.ɵɵngDeclareNgModule({
+			minVersion: "14.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: ActiveConnectNg2Module,
+			imports: [i1.NgxIndexedDBModule],
+			exports: [NgxIndexedDBModule]
+		});
+	}
+	static {
+		this.ɵinj = i0.ɵɵngDeclareInjector({
+			minVersion: "12.0.0",
+			version: "22.2.3",
+			ngImport: i0,
+			type: ActiveConnectNg2Module,
+			imports: [NgxIndexedDBModule.forRoot(dbConfig), NgxIndexedDBModule]
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.3",
+	ngImport: i0,
+	type: ActiveConnectNg2Module,
+	decorators: [{
+		type: NgModule,
+		args: [{
+			declarations: [],
+			imports: [NgxIndexedDBModule.forRoot(dbConfig)],
+			exports: [NgxIndexedDBModule]
+		}]
+	}]
+});
+var JsonParser = 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;
+	}
+};
+var WebsocketClient = class WebsocketClient {
+	constructor(url, supportsCache, dbService) {
+		this.url = url;
+		this.supportsCache = supportsCache;
+		this.dbService = dbService;
+		this._connected = signal(false, ...ngDevMode ? [{ debugName: "_connected" }] : /* istanbul ignore next */ []);
+		this.requestStack = [];
+		this.requestHistoryLogs = [];
+		this._token = "";
+		this.connectionEstablishedOnce = false;
+		this.messageId = 0;
+		this.rejectCallbacks = /* @__PURE__ */ new Map();
+		this.expectedMethods = /* @__PURE__ */ new Map();
+		this.closed = false;
+		if (supportsCache) this.initCache();
+		if (typeof document === "undefined" || typeof WebSocket === "undefined") return;
+		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";
+			}
+			url = protocol + "//" + document.location.hostname + port + "/wss";
+		}
+		this.url = url;
+		this.closed = false;
+		this.connect(this.url);
+	}
+	connect(url) {
+		if (!this.target.___connectionId) this.target.___connectionId = 0;
+		this.target.___connectionId++;
+		if (this.ws && (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN)) return;
+		this.create(url);
+	}
+	initTabSuspendedListener() {
+		if (typeof document !== "undefined") 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.closed = false;
+				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) try {
+			if (typeof window !== "undefined" && window.localStorage) this._token = window.localStorage.getItem("token") || "";
+		} catch {}
+		return this._token;
+	}
+	set Token(val) {
+		this._token = val;
+		try {
+			if (typeof window !== "undefined" && window.localStorage) window.localStorage.setItem("token", val);
+		} catch {}
+	}
+	set Connected(value) {
+		if (value) {
+			this.sendBrowserInfoToServer();
+			this.auth(this.Token).catch((err) => {
+				console.log("ActiveConnect: auth failed on reconnect: " + err);
+			}).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, false, e.messageId);
+							this.requestStack = this.requestStack.filter((e1) => e1 != e);
+						});
+					}, 2e3);
+				});
+			});
+		}
+		if (this.pool && this.pool.WssConnected) this.pool.WssConnected = value;
+	}
+	static {
+		this.resetRequestedStateCallbacks = [];
+	}
+	resetRequestedState() {
+		if (this.connectionEstablishedOnce) WebsocketClient.resetRequestedStateCallbacks.forEach((reset) => {
+			reset(this);
+		});
+		else this.connectionEstablishedOnce = true;
+	}
+	static addResetRequestingStateCallback(callback) {
+		WebsocketClient.resetRequestedStateCallbacks.push(callback);
+	}
+	static {
+		this.HANDSHAKE_TIMEOUT_MS = 1e4;
+	}
+	clearHandshakeTimer() {
+		if (this.handshakeTimer !== void 0) {
+			clearTimeout(this.handshakeTimer);
+			this.handshakeTimer = void 0;
+		}
+	}
+	create(url) {
+		if (this.ws) {
+			this.ws.onopen = null;
+			this.ws.onmessage = null;
+			this.ws.onerror = null;
+			this.ws.onclose = null;
+			if (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN) this.ws.close();
+		}
+		this.clearReconnectTimer();
+		this.clearHandshakeTimer();
+		this.closed = false;
+		this.logEntry("TCP/HTTP:CONNECT-SERVER");
+		this.ws = new WebSocket(url + (this.supportsCache ? "?cache=true" : ""));
+		this.handshakeTimer = setTimeout(() => {
+			if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+				this.logEntry("TCP/HTTP:HANDSHAKE-TIMEOUT");
+				console.log("ActiveConnect: Handshake timed out, retrying connection...");
+				this.ws.onopen = null;
+				this.ws.onmessage = null;
+				this.ws.onerror = null;
+				this.ws.onclose = null;
+				try {
+					this.ws.close();
+				} catch (err) {}
+				if (!this.closed) {
+					this.clearReconnectTimer();
+					this.reconnectTimer = setTimeout(() => {
+						this.reconnectTimer = void 0;
+						this.connect(url);
+					}, 1e3);
+				}
+			}
+		}, WebsocketClient.HANDSHAKE_TIMEOUT_MS);
+		this.ws.onerror = (err) => {
+			this.ws.close();
+			this.logEntry("TCP/HTTP:ERROR:" + err);
+			console.log("ActiveConnect: " + err);
+		};
+		this.ws.onopen = () => {
+			this.clearHandshakeTimer();
+			this._connected.set(true);
+			this.logEntry("TCP/HTTP:CONNECTED");
+			this.Connected = true;
+		};
+		this.ws.onmessage = (e) => {
+			let parsed;
+			try {
+				parsed = JsonParser.parse(e.data.toString());
+			} catch (err) {
+				console.log("ActiveConnect: failed to parse incoming message: " + err);
+				return;
+			}
+			this.messageReceived(parsed);
+		};
+		this.ws.onclose = () => {
+			this.clearHandshakeTimer();
+			this._connected.set(false);
+			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();
+				this.clearReconnectTimer();
+				this.reconnectTimer = setTimeout(() => {
+					this.reconnectTimer = void 0;
+					this.connect(url);
+				}, 1e3);
+			}
+		};
+	}
+	clearReconnectTimer() {
+		if (this.reconnectTimer !== void 0) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = void 0;
+		}
+	}
+	sendToSocket(method, data, dontEnsureTransmission, forcedMessageId) {
+		const messageId = forcedMessageId ?? ++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)) this.expectedMethods.get(method).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 {
+		this.outbounds = /* @__PURE__ */ new Map();
+	}
+	static expectOutbound(method, callback) {
+		WebsocketClient.outbounds.set(method, callback);
+	}
+	static {
+		this.handles = /* @__PURE__ */ new Map();
+	}
+	static registerHandle(method, callback) {
+		WebsocketClient.handles.set(method, callback);
+	}
+	get isConnected() {
+		this._connected();
+		if (this.ws) return this.ws.readyState == WebSocket.OPEN;
+		return true;
+	}
+	sendBrowserInfoToServer() {
+		const browser = this.getBrowser();
+		const os = this.getOS();
+		this.send("___browser", { browser: `${browser.name} ${browser.version} ${os}` });
+	}
+	getBrowser() {
+		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 {
+		this.onSuccessHandlers = [];
+	}
+	static onSuccess(callback, regexp) {
+		this.onSuccessHandlers.push({
+			callback,
+			regexp
+		});
+	}
+	static {
+		this.onReconnectCallback = [];
+	}
+	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) {
+		this.closed = true;
+		this._connected.set(false);
+		this.clearReconnectTimer();
+		this.clearHandshakeTimer();
+		if (this.ws) this.ws.close();
+		if (!restart && this.ws) {
+			this.ws.onopen = null;
+			this.ws.onmessage = null;
+			this.ws.onerror = null;
+			this.ws.onclose = null;
+		}
+	}
+	initCache() {}
+	get target() {
+		return this.__proto__;
+	}
+};
+var DecorableFunction = class {
+	constructor(objConfig) {
+		this.objConfig = objConfig;
+		const prototype = this.objConfig.target.prototype || this.objConfig.target;
+		if (!prototype.___constructorOverridden) prototype.___constructorOverridden = true;
+	}
+	get Func() {
+		if (this.objConfig?.target && this.objConfig.target[this.objConfig.propertyKey]) return this.objConfig.target[this.objConfig.propertyKey].bind(this.getBindObject());
+		return null;
+	}
+	getBindObject() {
+		return (this.objConfig.target.prototype || this.objConfig.target).___data._obj;
+	}
+};
+function Handle(method) {
+	return function _Handle(target, propertyKey) {
+		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 defer(fn) {
+	queueMicrotask(fn);
+}
+var ReactiveLoadingMap = class extends Map {
+	bump() {
+		this._version.update((v) => v + 1);
+	}
+	get(key) {
+		this._version();
+		return super.get(key);
+	}
+	has(key) {
+		this._version();
+		return super.has(key);
+	}
+	set(key, value) {
+		const changed = !super.has(key) || super.get(key) !== value;
+		super.set(key, value);
+		if (changed) this.bump();
+		return this;
+	}
+	delete(key) {
+		const existed = super.delete(key);
+		if (existed) this.bump();
+		return existed;
+	}
+	clear() {
+		let hadEntries = false;
+		super.forEach(() => hadEntries = true);
+		super.clear();
+		if (hadEntries) this.bump();
+	}
+	forEach(callbackfn, thisArg) {
+		this._version();
+		super.forEach(callbackfn, thisArg);
+	}
+	constructor() {
+		super();
+		this._version = signal(0, ...ngDevMode ? [{ debugName: "_version" }] : /* istanbul ignore next */ []);
+		this.prunePending = false;
+		const nativeSize = Object.getOwnPropertyDescriptor(Map.prototype, "size").get;
+		Object.defineProperty(this, "size", {
+			configurable: true,
+			get: () => {
+				this._version();
+				return nativeSize.call(this);
+			}
+		});
+	}
+	keys() {
+		this._version();
+		return super.keys();
+	}
+	values() {
+		this._version();
+		return super.values();
+	}
+	entries() {
+		this._version();
+		return super.entries();
+	}
+	[Symbol.iterator]() {
+		this._version();
+		return super[Symbol.iterator]();
+	}
+	peek(key) {
+		return super.get(key);
+	}
+	pruneWhenIdle() {
+		if (this.prunePending) return;
+		this.prunePending = true;
+		defer(() => {
+			this.prunePending = false;
+			let anyTrue = false;
+			super.forEach((v) => anyTrue ||= v);
+			if (!anyTrue) this.clear();
+		});
+	}
+};
+function ensureLoadingMap(target) {
+	if (!(target.loading instanceof ReactiveLoadingMap)) target.loading = new ReactiveLoadingMap();
+	return target.loading;
+}
+function ticksOf(target) {
+	if (!target.___ticks) target.___ticks = {};
+	return target.___ticks;
+}
+function readTick(target, key) {
+	const ticks = ticksOf(target);
+	return (ticks[key] ??= signal(0))();
+}
+function bumpTick(target, key) {
+	const ticks = ticksOf(target);
+	(ticks[key] ??= signal(0)).update((v) => v + 1);
+}
+const reactiveLoadingElements = /* @__PURE__ */ new WeakSet();
+function isReactiveLoadingElements(obj) {
+	return !!obj && typeof obj === "object" && reactiveLoadingElements.has(obj);
+}
+function createLoadingElements(initial) {
+	const signals = /* @__PURE__ */ new Map();
+	const sigFor = (key) => {
+		let s = signals.get(key);
+		if (!s) {
+			s = signal(0);
+			signals.set(key, s);
+		}
+		return s;
+	};
+	Object.entries(initial || {}).forEach(([k, v]) => sigFor(k).set(v));
+	const proxy = new Proxy({}, {
+		get: (_t, key) => typeof key === "string" ? sigFor(key)() : void 0,
+		set: (_t, key, value) => {
+			if (typeof key === "string") sigFor(key).set(value);
+			return true;
+		},
+		has: (_t, key) => typeof key === "string" && signals.has(key),
+		deleteProperty: (_t, key) => {
+			if (typeof key === "string") sigFor(key).set(0);
+			return true;
+		},
+		ownKeys: () => Array.from(signals.keys()),
+		getOwnPropertyDescriptor: (_t, key) => typeof key === "string" && signals.has(key) ? {
+			value: sigFor(key)(),
+			enumerable: true,
+			configurable: true,
+			writable: true
+		} : void 0
+	});
+	reactiveLoadingElements.add(proxy);
+	return proxy;
+}
+function Outbound(method, requestingRequired, cached, sortBy) {
+	return function _Outbound(target, propertyKey) {
+		ensureLoadingMap(target);
+		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);
+						bumpTick(target, propertyKey);
+					});
+				} 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] = void 0;
+				target.loading.set(propertyKey, false);
+				bumpTick(target, propertyKey);
+			} else if (data == "data_delete") {
+				target.___data[propertyKey] = void 0;
+				target.loading.set(propertyKey, false);
+				target.___received[propertyKey] = false;
+				target.___requested[propertyKey] = false;
+				bumpTick(target, propertyKey);
+			} 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);
+				bumpTick(target, propertyKey);
+				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);
+				bumpTick(target, propertyKey);
+				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(client) {
+			if (target.___requested && target.___requested[propertyKey]) client.send("request." + method, null).then();
+		});
+		const obj = {
+			configurable: true,
+			get() {
+				readTick(target, propertyKey);
+				if (!target.___requested) target.___requested = {};
+				if (requestingRequired && !target.___requested[propertyKey]) {
+					target.___requested[propertyKey] = true;
+					defer(() => this.send("request." + method, null).then());
+				}
+				if (!target.___data) target.___data = {};
+				const loadingMap = target.loading;
+				if (!target.___data[propertyKey]) {
+					if (loadingMap.peek(propertyKey) !== true) defer(() => loadingMap.set(propertyKey, true));
+				} else if (loadingMap.peek(propertyKey)) defer(() => loadingMap.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);
+				target.___data[propertyKey] = val;
+				bumpTick(target, propertyKey);
+				return val;
+			}
+		};
+		target[propertyKey] = obj;
+		return obj;
+	};
+}
+function ensureReactiveLoadingElements(service) {
+	if (!isReactiveLoadingElements(service.loadingElements)) try {
+		service.loadingElements = createLoadingElements(service.loadingElements);
+	} catch {}
+}
+function Route(method, loadingKey, dontEnsureTransmission) {
+	return function _Route(target, propertyKey) {
+		const original = target[propertyKey];
+		target[propertyKey] = async function execRoute(...data) {
+			if (loadingKey) {
+				ensureReactiveLoadingElements(this);
+				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]) this.loadingElements[loadingKey]--;
+				throw err;
+			});
+			await promise;
+			if (loadingKey && this.loadingElements[loadingKey]) this.loadingElements[loadingKey]--;
+			return res;
+		};
+		return target;
+	};
+}
+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) {};
+}
+var LoadingStatus = class extends WebsocketClient {
+	get loadingMap() {
+		return ensureLoadingMap(Object.getPrototypeOf(this));
+	}
+	countLoading() {
+		const map = this.loadingMap;
+		let count = 0;
+		map.forEach((e) => {
+			if (e) count++;
+		});
+		if (count == 0) map.pruneWhenIdle();
+		return count;
+	}
+	get isLoading() {
+		return this.countLoading() > 0;
+	}
+	getLoadingMap() {
+		return this.loadingMap;
+	}
+	get getCurrent() {
+		return this.countLoading();
+	}
+	get getTotal() {
+		return this.countLoading() > 0 ? this.loadingMap.size : 0;
+	}
+};
+var OutboundObject = class {
+	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 = /* @__PURE__ */ new Map();
+		this._dataSig = signal(void 0, ...ngDevMode ? [{ debugName: "_dataSig" }] : /* istanbul ignore next */ []);
+		this.loadScheduled = false;
+		this.requested = false;
+		this._loadingSig = signal(false, ...ngDevMode ? [{ debugName: "_loadingSig" }] : /* istanbul ignore next */ []);
+		this._lengthSig = signal(void 0, ...ngDevMode ? [{ debugName: "_lengthSig" }] : /* istanbul ignore next */ []);
+		this.requestedId = null;
+		this.requestedIdConnectionId = null;
+		this.loadedObservable = null;
+		this.loadedId = null;
+		this.loadedIdData = null;
+		this.loadedIdChanged = null;
+		this.requestedGroupId = null;
+		this.requestedGroupIdConnectionId = null;
+		this.loadedGroupObservable = null;
+		this.loadedGroupId = null;
+		this.loadedGroupData = null;
+		this.loadedGroupChanged = null;
+		ensureLoadingMap(this.target);
+		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 = void 0;
+				_this.dataMap = /* @__PURE__ */ new Map();
+				_this.requested = false;
+				_this.loadedGroupData = null;
+				_this.loadedGroupId = null;
+				_this._length = void 0;
+				_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.requestedGroupIdConnectionId = _this.target.___connectionId;
+					_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.requestedIdConnectionId = _this.target.___connectionId;
+					_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 data() {
+		return untracked(this._dataSig);
+	}
+	set data(value) {
+		this._dataSig.set(value);
+	}
+	get(id) {
+		if (this.requestedId == id && this.target.___connectionId == this.requestedIdConnectionId && 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.target.___connectionId != this.requestedIdConnectionId || !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.target.___connectionId == this.requestedGroupIdConnectionId && this.loadedGroupObservable && this.loadedGroupData) {
+			setTimeout(() => {
+				if (this.loadedGroupData) this.loadedGroupChanged?.next(this.loadedGroupData);
+			}, 50);
+			return this.loadedGroupObservable;
+		}
+		let observablePromise;
+		if (this.requestedGroupId != groupId || this.target.___connectionId != this.requestedGroupIdConnectionId || !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() {
+		this.ensureLoaded();
+		return this._dataSig();
+	}
+	ensureLoaded() {
+		if (this.requested || !this.lazyLoaded || this.loadScheduled) return;
+		this.loadScheduled = true;
+		defer(() => {
+			this.loadScheduled = false;
+			if (!this.requested) this.load().catch((e) => console.error("ActiveConnect: lazy load failed", e));
+		});
+	}
+	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 : void 0 : void 0 : this.previouslyCachedCount || this.initialLoadingCount,
+				loaded: this.loadedLength
+			});
+		} else throw Error("Active-Connect: Cannot run loading request as this outbound is not lazy-loaded.");
+	}
+	get _loading() {
+		return untracked(this._loadingSig);
+	}
+	set _loading(value) {
+		this._loadingSig.set(value);
+	}
+	set loading(value) {
+		this._loading = value;
+		this.target.loading.set(this.method, value);
+	}
+	get loading() {
+		return this._loadingSig();
+	}
+	get loadedLength() {
+		return this._dataSig()?.length || 0;
+	}
+	get _length() {
+		return untracked(this._lengthSig);
+	}
+	set _length(value) {
+		this._lengthSig.set(value);
+	}
+	get length() {
+		return this._lengthSig();
+	}
+	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) {
+		const incoming = data;
+		if (this.sortBy) incoming.sort(this.sortBy);
+		const next = [...incoming];
+		this._length = next.length;
+		this.dataMap = /* @__PURE__ */ new Map();
+		next.forEach((d) => {
+			this.dataMap.set(d.id, d);
+		});
+		this.data = next;
+	}
+	get isEmpty() {
+		return this._dataSig() == void 0;
+	}
+	update(callback) {
+		if (this.data) {
+			const updateLengthVariable = this.data.length == this._length;
+			const length = this._length;
+			const copy = [...this.data];
+			callback(copy);
+			this.setData(copy);
+			if (!updateLengthVariable) this._length = length;
+		}
+	}
+	afterServerReconnected() {
+		if (this.requested && this.lazyLoaded) {
+			this.requested = false;
+			this.load(this.loadedLength).then();
+		}
+		if (this.loadedId) {
+			this.loadedIdData = null;
+			this.requestById(this.loadedId).catch(() => {});
+		}
+		if (this.loadedGroupId) {
+			this.loadedGroupData = null;
+			this.requestForGroup(this.loadedGroupId).catch(() => {});
+		}
+	}
+};
+export { ActiveConnectNg2Module, Handle, LoadingStatus, NgxIndexedDBService, OnReconnect, OnSuccess, Outbound, OutboundObject, ReactiveLoadingMap, Route, Shared, WebsocketClient, bumpTick, createLoadingElements, defer, ensureLoadingMap, isReactiveLoadingElements, readTick };
+
+//# sourceMappingURL=active-connect-ng2.mjs.map