@lenne.tech/ng-base 18.1.2 → 22.0.0

package/fesm2022/lenne.tech-ng-base-sync.mjs

@@ -0,0 +1,1096 @@
+import { DOCUMENT, isPlatformBrowser } from "@angular/common";
+import { DestroyRef, InjectionToken, PLATFORM_ID, assertInInjectionContext, effect, inject, makeEnvironmentProviders, provideAppInitializer, signal, untracked } from "@angular/core";
+import { LT_AUTH_SIGN_OUT_HOOKS, LtAuthStore } from "@lenne.tech/ng-base/auth/provide";
+import { LT_FETCH, LT_RUNTIME_CONFIG, LtApiUrlService, mergeLtFeatureOptions } from "@lenne.tech/ng-base";
+const LT_SYNC_DB_NAME = "lt-offline-sync";
+const LT_SYNC_CHANNEL_NAME = "lt-offline-sync";
+const STORES = [
+	"meta",
+	"outbox",
+	"records"
+];
+const done = (request) => new Promise((resolve, reject) => {
+	request.addEventListener("success", () => resolve(request.result));
+	request.addEventListener("error", () => reject(request.error));
+});
+let connection;
+let opening;
+function openDatabase() {
+	if (connection) return Promise.resolve(connection);
+	opening ??= (async () => {
+		const request = indexedDB.open(LT_SYNC_DB_NAME, 1);
+		request.addEventListener("upgradeneeded", () => {
+			const db = request.result;
+			db.createObjectStore("records", { keyPath: ["model", "id"] }).createIndex("model", "model");
+			const outbox = db.createObjectStore("outbox", {
+				autoIncrement: true,
+				keyPath: "seq"
+			});
+			outbox.createIndex("mutationId", "mutationId", { unique: true });
+			outbox.createIndex("model", "model");
+			db.createObjectStore("meta", { keyPath: "key" });
+		});
+		try {
+			const db = await done(request);
+			db.addEventListener("versionchange", () => {
+				db.close();
+				if (connection === db) connection = void 0;
+			});
+			connection = db;
+			return db;
+		} finally {
+			opening = void 0;
+		}
+	})();
+	return opening;
+}
+var LtSyncOwnerChangedError = class extends Error {
+	constructor() {
+		super("the local sync data changed owner");
+		this.name = "LtSyncOwnerChangedError";
+	}
+};
+async function runLtSyncTx(model, fn, options = {}) {
+	const transaction = (await openDatabase()).transaction(STORES, "readwrite");
+	const finished = new Promise((resolve, reject) => {
+		transaction.addEventListener("complete", () => resolve());
+		transaction.addEventListener("abort", () => reject(transaction.error ?? /* @__PURE__ */ new Error("transaction aborted")));
+		transaction.addEventListener("error", () => reject(transaction.error));
+	});
+	const store = (name) => transaction.objectStore(name);
+	const strip = (stored) => {
+		if (!stored) return void 0;
+		const { model: _model, ...record } = stored;
+		return record;
+	};
+	const tx = {
+		addOutbox: (item) => {
+			const { seq: _seq, ...rest } = item;
+			return done(store("outbox").add({
+				...rest,
+				model
+			}));
+		},
+		clearRecords: async (keepIds) => {
+			const keys = await done(store("records").index("model").getAllKeys(model));
+			for (const key of keys) if (!keepIds.has(key[1])) await done(store("records").delete(key));
+		},
+		deleteMeta: (key) => done(store("meta").delete(key)),
+		deleteRecord: (id) => done(store("records").delete([model, id])),
+		getMeta: async (key) => (await done(store("meta").get(key)))?.value,
+		getRecord: async (id) => strip(await done(store("records").get([model, id]))),
+		listOutbox: async () => {
+			return (await done(store("outbox").index("model").getAll(model))).map(({ model: _model, ...item }) => item);
+		},
+		listRecords: async () => (await done(store("records").index("model").getAll(model))).map((record) => strip(record)),
+		putOutbox: (item) => done(store("outbox").put({
+			...item,
+			model
+		})),
+		putRecord: (record) => done(store("records").put({
+			...record,
+			model
+		})),
+		removeOutbox: async (mutationId) => {
+			const key = await done(store("outbox").index("mutationId").getKey(mutationId));
+			if (key !== void 0) await done(store("outbox").delete(key));
+		},
+		setMeta: (key, value) => done(store("meta").put({
+			key,
+			value
+		}))
+	};
+	let result;
+	try {
+		if (options.owner !== void 0 && await tx.getMeta("owner") !== options.owner) throw new LtSyncOwnerChangedError();
+		result = await fn(tx);
+	} catch (error) {
+		transaction.abort();
+		await finished.catch(() => void 0);
+		throw error;
+	}
+	await finished;
+	return result;
+}
+async function listLtSyncPendingModels() {
+	const transaction = (await openDatabase()).transaction(["outbox"], "readonly");
+	const items = await done(transaction.objectStore("outbox").getAll());
+	return [...new Set(items.map((item) => item.model))];
+}
+function getLtSyncOwner() {
+	return runLtSyncTx("", (tx) => tx.getMeta("owner"));
+}
+async function claimLtSyncOwner(userId) {
+	const transaction = (await openDatabase()).transaction(STORES, "readwrite");
+	const finished = new Promise((resolve, reject) => {
+		transaction.addEventListener("complete", () => resolve());
+		transaction.addEventListener("abort", () => reject(transaction.error ?? /* @__PURE__ */ new Error("transaction aborted")));
+		transaction.addEventListener("error", () => reject(transaction.error));
+	});
+	const meta = transaction.objectStore("meta");
+	const owner = (await done(meta.get("owner")))?.value;
+	let wiped = false;
+	if (owner !== userId) {
+		if (await done(transaction.objectStore("records").count()) + await done(transaction.objectStore("outbox").count()) + await done(meta.count()) > 0) {
+			for (const name of STORES) await done(transaction.objectStore(name).clear());
+			wiped = true;
+		}
+		await done(meta.put({
+			key: "owner",
+			value: userId
+		}));
+	}
+	await finished;
+	if (wiped) postLtSyncMessage({ type: "cleared" });
+	return wiped;
+}
+async function deleteLtSyncDatabase() {
+	if (typeof indexedDB === "undefined") return;
+	await opening?.catch(() => void 0);
+	connection?.close();
+	connection = void 0;
+	await new Promise((resolve, reject) => {
+		const request = indexedDB.deleteDatabase(LT_SYNC_DB_NAME);
+		request.addEventListener("success", () => resolve());
+		request.addEventListener("error", () => reject(request.error));
+		request.addEventListener("blocked", () => void 0);
+	});
+	postLtSyncMessage({ type: "cleared" });
+}
+function postLtSyncMessage(message) {
+	if (typeof BroadcastChannel === "undefined") return;
+	const channel = new BroadcastChannel(LT_SYNC_CHANNEL_NAME);
+	try {
+		channel.postMessage(message);
+	} finally {
+		channel.close();
+	}
+}
+const PUSH_CHUNK = 100;
+const MAX_PUSH_ROUNDS = 50;
+var LtSyncOfflineError = class extends Error {
+	constructor(cause) {
+		super(`offline: ${cause instanceof Error ? cause.message : String(cause)}`);
+		this.name = "LtSyncOfflineError";
+	}
+};
+var LtSyncUnauthorizedError = class extends Error {
+	constructor() {
+		super("unauthorized");
+		this.name = "LtSyncUnauthorizedError";
+	}
+};
+var LtSyncBackoffError = class extends Error {
+	status;
+	retryAfterMs;
+	constructor(status, retryAfterMs) {
+		super(`server answered ${status}`);
+		this.status = status;
+		this.retryAfterMs = retryAfterMs;
+		this.name = "LtSyncBackoffError";
+	}
+};
+const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+function ltSyncObjectId() {
+	const random = /* @__PURE__ */ new Uint8Array(8);
+	globalThis.crypto.getRandomValues(random);
+	return Math.floor(Date.now() / 1e3).toString(16).padStart(8, "0") + hex(random);
+}
+function ltSyncUuidV7() {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	globalThis.crypto.getRandomValues(bytes);
+	let time = Date.now();
+	for (let index = 5; index >= 0; index--) {
+		bytes[index] = time % 256;
+		time = Math.floor(time / 256);
+	}
+	bytes[6] = 112 | bytes[6] & 15;
+	bytes[8] = 128 | bytes[8] & 63;
+	const value = hex(bytes);
+	return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
+}
+let environment = {
+	basePath: "/sync",
+	buildApiUrl: (path) => path,
+	fetch: (input, init) => fetch(input, {
+		credentials: "include",
+		...init
+	})
+};
+function configureLtSync(env) {
+	environment = {
+		...environment,
+		...env
+	};
+}
+function getLtSyncBasePath() {
+	return environment.basePath || "/sync";
+}
+function buildLtSyncUrl(path) {
+	return environment.buildApiUrl(`${getLtSyncBasePath()}${path}`);
+}
+function ltSyncFetch(input, init) {
+	return environment.fetch(input, init);
+}
+function retryAfterMs(value) {
+	if (!value) return void 0;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	const date = Date.parse(value);
+	return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+const engines = /* @__PURE__ */ new Map();
+function ltSyncScope(model, tenantId) {
+	return tenantId ? `${model}#${tenantId}` : model;
+}
+function parseLtSyncScope(scope) {
+	const at = scope.indexOf("#");
+	return at === -1 ? { model: scope } : {
+		model: scope.slice(0, at),
+		tenantId: scope.slice(at + 1)
+	};
+}
+function localOf(item) {
+	return {
+		data: item.deletedAt ? void 0 : item.data,
+		deletedAt: item.deletedAt ?? null,
+		id: item.id,
+		updatedAt: item.updatedAt ?? null,
+		version: item.version
+	};
+}
+function lastPending(outbox, id) {
+	return outbox.filter((item) => item.id === id).at(-1);
+}
+function nextBase(record, pending) {
+	return pending ? (pending.baseVersion ?? 0) + 1 : record.version;
+}
+function pushItem(item) {
+	const { baseVersion, data, id, mutationId, op } = item;
+	return {
+		...baseVersion === void 0 ? {} : { baseVersion },
+		...data === void 0 ? {} : { data },
+		id,
+		mutationId,
+		op
+	};
+}
+function emptyResult$1() {
+	return {
+		applied: 0,
+		conflicts: [],
+		forbidden: false,
+		needsLogin: false,
+		offline: false,
+		rejected: [],
+		resynced: false,
+		retried: 0
+	};
+}
+function createLtSyncEngine(options) {
+	const { idFormat = "objectId", model, onConflict, pageLimit = 200, tenantId } = options;
+	const fetchImpl = options.fetch ?? ltSyncFetch;
+	const scope = ltSyncScope(model, tenantId);
+	const cursorKey = `cursor:${scope}`;
+	const run = (fn) => runLtSyncTx(scope, fn);
+	const runAs = (owner, fn) => runLtSyncTx(scope, fn, owner === void 0 ? {} : { owner });
+	const newId = () => idFormat === "uuidv7" ? ltSyncUuidV7() : ltSyncObjectId();
+	async function request(method, path, payload) {
+		const headers = { accept: "application/json" };
+		if (payload !== void 0) headers["content-type"] = "application/json";
+		if (tenantId) headers["x-tenant-id"] = tenantId;
+		let response;
+		try {
+			response = await fetchImpl(buildLtSyncUrl(path), {
+				body: payload === void 0 ? void 0 : JSON.stringify(payload),
+				headers,
+				method
+			});
+		} catch (error) {
+			throw new LtSyncOfflineError(error);
+		}
+		if (response.status === 401) throw new LtSyncUnauthorizedError();
+		if (response.status === 429 || response.status === 503) throw new LtSyncBackoffError(response.status, retryAfterMs(response.headers.get("retry-after")));
+		const text = await response.text();
+		let body;
+		try {
+			body = text ? JSON.parse(text) : void 0;
+		} catch {
+			body = void 0;
+		}
+		if (response.status === 410 || response.status === 403 && method === "GET") return {
+			body,
+			status: response.status
+		};
+		if (!response.ok) {
+			const error = /* @__PURE__ */ new Error(`${method} ${getLtSyncBasePath()}${path} answered ${response.status}: ${text.slice(0, 300)}`);
+			error.status = response.status;
+			throw error;
+		}
+		return {
+			body,
+			status: response.status
+		};
+	}
+	async function settle(tx, item, outcome, result, resolution) {
+		const status = outcome?.status;
+		if (status === "retry" || !status) {
+			result.retried++;
+			return;
+		}
+		await tx.removeOutbox(item.mutationId);
+		const record = await tx.getRecord(item.id);
+		if (status === "applied") {
+			result.applied++;
+			if (item.op === "delete") await tx.deleteRecord(item.id);
+			else if (record && (record.version ?? 0) < (outcome.version ?? 0)) await tx.putRecord({
+				...record,
+				version: outcome.version
+			});
+			return;
+		}
+		const later = (await tx.listOutbox()).filter((entry) => entry.id === item.id);
+		if (status === "merged" && outcome.record) {
+			result.applied++;
+			const pendingData = later.filter((entry) => entry.op === "upsert").reduce((data, entry) => ({
+				...data,
+				...entry.data
+			}), {});
+			const merged = localOf(outcome.record);
+			await tx.putRecord(merged.deletedAt ? merged : {
+				...merged,
+				data: {
+					...merged.data,
+					...pendingData
+				}
+			});
+			return;
+		}
+		if (status === "conflict") {
+			result.conflicts.push(outcome);
+			for (const entry of later) await tx.removeOutbox(entry.mutationId);
+			if (!outcome.record || outcome.record.deletedAt) {
+				await tx.deleteRecord(item.id);
+				return;
+			}
+			const server = localOf(outcome.record);
+			if (resolution === "server") {
+				await tx.putRecord(server);
+				return;
+			}
+			await tx.putRecord({
+				...server,
+				data: {
+					...server.data,
+					...resolution.data
+				}
+			});
+			await tx.addOutbox({
+				baseVersion: server.version,
+				data: resolution.data,
+				id: item.id,
+				mutationId: ltSyncUuidV7(),
+				op: "upsert"
+			});
+			return;
+		}
+		for (const entry of later) await tx.removeOutbox(entry.mutationId);
+		if (status === "not_found") {
+			await tx.deleteRecord(item.id);
+			return;
+		}
+		result.rejected.push(outcome);
+		if (record && !record.version) await tx.deleteRecord(item.id);
+		else if (record) await tx.deleteMeta(cursorKey);
+	}
+	async function resolveConflict(item, outcome) {
+		if (outcome?.status !== "conflict" || !onConflict || !outcome.record || outcome.record.deletedAt) return "server";
+		const local = await run((tx) => tx.getRecord(item.id));
+		const answer = await onConflict({
+			change: {
+				data: item.data,
+				op: item.op
+			},
+			local,
+			server: localOf(outcome.record)
+		});
+		return answer === "server" || !answer?.data ? "server" : answer;
+	}
+	async function push(result, owner) {
+		const carried = /* @__PURE__ */ new Set();
+		for (let round = 0; round < MAX_PUSH_ROUNDS; round++) {
+			const chunk = await runAs(owner, async (tx) => {
+				const records = /* @__PURE__ */ new Set();
+				const items = [];
+				for (const item of await tx.listOutbox()) {
+					if (items.length === PUSH_CHUNK) break;
+					if (records.has(item.id)) continue;
+					records.add(item.id);
+					if (!carried.has(item.mutationId)) items.push(item);
+				}
+				for (const item of items) await tx.putOutbox({
+					...item,
+					attempted: true
+				});
+				return items;
+			});
+			if (!chunk.length) return;
+			for (const item of chunk) carried.add(item.mutationId);
+			const results = (await request("POST", `/${encodeURIComponent(model)}`, { items: chunk.map(pushItem) })).body?.results ?? [];
+			for (let index = 0; index < chunk.length; index++) {
+				const item = chunk[index];
+				const resolution = await resolveConflict(item, results[index]);
+				await runAs(owner, (tx) => settle(tx, item, results[index], result, resolution));
+			}
+		}
+	}
+	async function pull(result, owner) {
+		let cursor = await run((tx) => tx.getMeta(cursorKey));
+		for (let page = 0; page < 1e4; page++) {
+			const query = new URLSearchParams({ limit: String(pageLimit) });
+			if (cursor) query.set("cursor", cursor);
+			const response = await request("GET", `/${encodeURIComponent(model)}?${query}`);
+			if (response.status === 403) {
+				result.forbidden = true;
+				await runAs(owner, async (tx) => {
+					await tx.clearRecords(new Set((await tx.listOutbox()).map((item) => item.id)));
+					await tx.deleteMeta(cursorKey);
+				});
+				return false;
+			}
+			if (response.status === 410) {
+				if (result.resynced) throw new Error(`resync loop: ${JSON.stringify(response.body)}`);
+				result.resynced = true;
+				await runAs(owner, async (tx) => {
+					await tx.clearRecords(new Set((await tx.listOutbox()).map((item) => item.id)));
+					await tx.deleteMeta(cursorKey);
+				});
+				cursor = void 0;
+				continue;
+			}
+			const body = response.body;
+			await runAs(owner, async (tx) => {
+				const pending = new Set((await tx.listOutbox()).map((item) => item.id));
+				for (const item of body.items ?? []) {
+					if (pending.has(item.id)) continue;
+					const local = await tx.getRecord(item.id);
+					if (local && local.version > item.version) continue;
+					if (item.deletedAt) await tx.deleteRecord(item.id);
+					else await tx.putRecord(localOf(item));
+				}
+				await tx.setMeta(cursorKey, body.cursor);
+			});
+			cursor = body.cursor;
+			if (!body.hasMore) return result.resynced;
+		}
+		throw new Error("pull did not end");
+	}
+	async function syncOnce() {
+		const result = emptyResult$1();
+		try {
+			const owner = await getLtSyncOwner();
+			await push(result, owner);
+			if (await pull(result, owner)) await push(result, owner);
+		} catch (error) {
+			if (error instanceof LtSyncOwnerChangedError) return result;
+			if (error instanceof LtSyncUnauthorizedError) result.needsLogin = true;
+			else if (error instanceof LtSyncOfflineError) result.offline = true;
+			else if (error instanceof LtSyncBackoffError) result.retryAfterMs = error.retryAfterMs ?? 0;
+			else throw error;
+		}
+		return result;
+	}
+	async function syncLocked() {
+		const locks = typeof navigator === "undefined" ? void 0 : navigator.locks;
+		if (!locks) return syncOnce();
+		return await locks.request(`lt-offline-sync:${scope}`, syncOnce);
+	}
+	let current = null;
+	let next = null;
+	function sync() {
+		if (!current) {
+			current = syncLocked().finally(() => {
+				current = null;
+			});
+			return current;
+		}
+		next ??= current.catch(() => void 0).then(() => {
+			next = null;
+			return sync();
+		});
+		return next;
+	}
+	const engine = {
+		async create(data) {
+			const record = {
+				data,
+				deletedAt: null,
+				id: newId(),
+				updatedAt: null,
+				version: 0
+			};
+			await run(async (tx) => {
+				await tx.putRecord(record);
+				await tx.addOutbox({
+					data,
+					id: record.id,
+					mutationId: ltSyncUuidV7(),
+					op: "upsert"
+				});
+			});
+			return record;
+		},
+		get: (id) => run((tx) => tx.getRecord(id)),
+		async list() {
+			return (await run((tx) => tx.listRecords())).filter((record) => !record.deletedAt).sort((a, b) => a.id < b.id ? -1 : 1);
+		},
+		model,
+		pendingCount: () => run(async (tx) => (await tx.listOutbox()).length),
+		async pushPending() {
+			try {
+				await push(emptyResult$1(), await getLtSyncOwner());
+			} catch {}
+		},
+		scope,
+		async remove(id) {
+			await run(async (tx) => {
+				const record = await tx.getRecord(id);
+				if (!record || record.deletedAt) return;
+				const pending = lastPending(await tx.listOutbox(), id);
+				if (pending && !pending.attempted) {
+					await tx.removeOutbox(pending.mutationId);
+					if (pending.baseVersion === void 0) {
+						await tx.deleteRecord(id);
+						return;
+					}
+				}
+				const baseVersion = pending && !pending.attempted ? pending.baseVersion : nextBase(record, pending);
+				await tx.addOutbox({
+					baseVersion,
+					id,
+					mutationId: ltSyncUuidV7(),
+					op: "delete"
+				});
+				await tx.putRecord({
+					...record,
+					data: void 0,
+					deletedAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+			});
+		},
+		sync,
+		async update(id, data) {
+			return run(async (tx) => {
+				const record = await tx.getRecord(id);
+				if (!record || record.deletedAt) throw new Error(`no live local record ${id}`);
+				const pending = lastPending(await tx.listOutbox(), id);
+				if (pending && pending.op === "upsert" && !pending.attempted) await tx.putOutbox({
+					...pending,
+					data: {
+						...pending.data,
+						...data
+					}
+				});
+				else await tx.addOutbox({
+					baseVersion: nextBase(record, pending),
+					data,
+					id,
+					mutationId: ltSyncUuidV7(),
+					op: "upsert"
+				});
+				const changed = {
+					...record,
+					data: {
+						...record.data,
+						...data
+					}
+				};
+				await tx.putRecord(changed);
+				return changed;
+			});
+		}
+	};
+	engines.set(scope, engine);
+	return engine;
+}
+async function flushLtSyncBeforeSignOut(userId, timeoutMs = 5e3) {
+	if (typeof indexedDB === "undefined" || !userId) return;
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(resolve, timeoutMs);
+	});
+	const flush = (async () => {
+		if (await getLtSyncOwner().catch(() => void 0) !== userId) return;
+		const scopes = await listLtSyncPendingModels().catch(() => []);
+		await Promise.all(scopes.map((scope) => (engines.get(scope) ?? createLtSyncEngine(parseLtSyncScope(scope))).pushPending()));
+	})();
+	try {
+		await Promise.race([flush, timeout]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function resetLtSyncEngines() {
+	engines.clear();
+}
+const LINE_LIMIT = 1048576;
+const DEFAULT_RETRY_MS = 3e3;
+const MAX_BACKOFF_MS = 6e4;
+async function readEvents(body, onEvent, signal) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let event = {
+		data: "",
+		event: "message"
+	};
+	const dispatchLine = (line) => {
+		if (line === "") {
+			if (event.data || event.retry !== void 0) onEvent(event);
+			event = {
+				data: "",
+				event: "message"
+			};
+			return;
+		}
+		if (line.startsWith(":")) return;
+		const colon = line.indexOf(":");
+		const field = colon === -1 ? line : line.slice(0, colon);
+		const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+		if (field === "event") event.event = value;
+		else if (field === "data") event.data = event.data ? `${event.data}\n${value}` : value;
+		else if (field === "retry" && /^\d+$/.test(value)) event.retry = Number(value);
+	};
+	const onAbort = () => void reader.cancel().catch(() => void 0);
+	signal.addEventListener("abort", onAbort);
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return;
+			buffer += decoder.decode(value, { stream: true });
+			let newline = buffer.search(/\r?\n|\r/);
+			while (newline !== -1) {
+				const line = buffer.slice(0, newline);
+				const skip = buffer[newline] === "\r" && buffer[newline + 1] === "\n" ? 2 : 1;
+				buffer = buffer.slice(newline + skip);
+				dispatchLine(line);
+				newline = buffer.search(/\r?\n|\r/);
+			}
+			if (buffer.length > LINE_LIMIT) throw new Error("sync hint stream: line exceeds 1 MiB");
+		}
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+		reader.releaseLock();
+	}
+}
+const hubs = /* @__PURE__ */ new Map();
+function subscribeLtSyncHints(subscriber) {
+	const key = subscriber.tenantId ?? "";
+	let hub = hubs.get(key);
+	if (!hub) {
+		hub = {
+			models: "",
+			subscribers: /* @__PURE__ */ new Set()
+		};
+		hubs.set(key, hub);
+	}
+	const joined = hub;
+	joined.subscribers.add(subscriber);
+	connectHub(key, joined);
+	return () => {
+		if (!joined.subscribers.delete(subscriber)) return;
+		if (joined.subscribers.size === 0) {
+			joined.close?.();
+			if (hubs.get(key) === joined) hubs.delete(key);
+			return;
+		}
+		connectHub(key, joined);
+	};
+}
+function connectHub(key, hub) {
+	const models = [...new Set([...hub.subscribers].map((subscriber) => subscriber.model))].sort().join(",");
+	if (hub.close && hub.models === models) return;
+	hub.close?.();
+	hub.models = models;
+	hub.close = openLtSyncHints({
+		models: models.split(","),
+		onConnect: () => {
+			for (const subscriber of Array.from(hub.subscribers)) subscriber.onConnect();
+		},
+		onHint: (model) => {
+			for (const subscriber of Array.from(hub.subscribers)) if (subscriber.model === model) subscriber.onHint();
+		},
+		onStop: (reason) => {
+			hub.close = void 0;
+			hub.models = "";
+			for (const subscriber of Array.from(hub.subscribers)) subscriber.onStop?.(reason);
+		},
+		tenantId: key || void 0
+	});
+}
+function openLtSyncHints(options) {
+	const { models, onConnect, onHint, onStop, tenantId } = options;
+	const fetchImpl = options.fetch ?? ltSyncFetch;
+	let closed = false;
+	let controller;
+	let timer;
+	let wake;
+	let retryMs = DEFAULT_RETRY_MS;
+	let failures = 0;
+	const wait = (ms) => new Promise((resolve) => {
+		wake = resolve;
+		timer = setTimeout(resolve, ms);
+	});
+	const loop = async () => {
+		while (!closed) {
+			controller = new AbortController();
+			try {
+				const query = new URLSearchParams({ models: models.join(",") });
+				const headers = { accept: "text/event-stream" };
+				if (tenantId) headers["x-tenant-id"] = tenantId;
+				const response = await fetchImpl(buildLtSyncUrl(`/hints?${query}`), {
+					headers,
+					method: "GET",
+					signal: controller.signal
+				});
+				if (response.status === 404 || response.status === 401) {
+					await response.body?.cancel().catch(() => void 0);
+					if (!closed) onStop?.(response.status === 404 ? "disabled" : "unauthorized");
+					return;
+				}
+				if (!response.ok || !response.body) throw new Error(`sync hint stream answered ${response.status}`);
+				failures = 0;
+				onConnect();
+				await readEvents(response.body, (event) => {
+					if (event.retry !== void 0) retryMs = event.retry;
+					if (event.event !== "change") return;
+					try {
+						const model = JSON.parse(event.data).model;
+						if (typeof model === "string") onHint(model);
+					} catch {}
+				}, controller.signal);
+				if (!closed) await wait(retryMs);
+			} catch {
+				if (closed) return;
+				failures++;
+				await wait(Math.min(retryMs * 2 ** Math.min(failures - 1, 5), MAX_BACKOFF_MS));
+			}
+		}
+	};
+	loop();
+	return () => {
+		closed = true;
+		controller?.abort();
+		clearTimeout(timer);
+		wake?.();
+	};
+}
+const BACKOFF_START_MS = 1e3;
+const BACKOFF_MAX_MS = 6e4;
+const LOCAL_CHANGE_DELAY_MS = 300;
+const emptyResult = (overrides = {}) => ({
+	applied: 0,
+	conflicts: [],
+	forbidden: false,
+	needsLogin: false,
+	offline: false,
+	rejected: [],
+	resynced: false,
+	retried: 0,
+	...overrides
+});
+function injectLtOfflineSync(model, options = {}) {
+	assertInInjectionContext(injectLtOfflineSync);
+	const records = signal([], ...ngDevMode ? [{ debugName: "records" }] : /* istanbul ignore next */ []);
+	const pendingCount = signal(0, ...ngDevMode ? [{ debugName: "pendingCount" }] : /* istanbul ignore next */ []);
+	const offline = signal(false, ...ngDevMode ? [{ debugName: "offline" }] : /* istanbul ignore next */ []);
+	const syncing = signal(false, ...ngDevMode ? [{ debugName: "syncing" }] : /* istanbul ignore next */ []);
+	const needsLogin = signal(false, ...ngDevMode ? [{ debugName: "needsLogin" }] : /* istanbul ignore next */ []);
+	const forbidden = signal(false, ...ngDevMode ? [{ debugName: "forbidden" }] : /* istanbul ignore next */ []);
+	const conflicts = signal([], ...ngDevMode ? [{ debugName: "conflicts" }] : /* istanbul ignore next */ []);
+	const rejected = signal([], ...ngDevMode ? [{ debugName: "rejected" }] : /* istanbul ignore next */ []);
+	const error = signal(null, ...ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []);
+	const lastSyncedAt = signal(null, ...ngDevMode ? [{ debugName: "lastSyncedAt" }] : /* istanbul ignore next */ []);
+	const state = {
+		conflicts: conflicts.asReadonly(),
+		error: error.asReadonly(),
+		forbidden: forbidden.asReadonly(),
+		lastSyncedAt: lastSyncedAt.asReadonly(),
+		needsLogin: needsLogin.asReadonly(),
+		offline: offline.asReadonly(),
+		pendingCount: pendingCount.asReadonly(),
+		records: records.asReadonly(),
+		rejected: rejected.asReadonly(),
+		syncing: syncing.asReadonly()
+	};
+	if (!isPlatformBrowser(inject(PLATFORM_ID)) || typeof indexedDB === "undefined") {
+		const browserOnly = () => Promise.reject(/* @__PURE__ */ new Error("injectLtOfflineSync: offline sync runs in the browser only"));
+		return {
+			...state,
+			create: browserOnly,
+			get: async () => void 0,
+			remove: browserOnly,
+			sync: async () => emptyResult(),
+			update: browserOnly
+		};
+	}
+	const auth = inject(LtAuthStore);
+	const destroyRef = inject(DestroyRef);
+	const doc = inject(DOCUMENT);
+	const win = doc.defaultView;
+	const auto = options.auto !== false;
+	const engine = createLtSyncEngine({
+		idFormat: options.idFormat,
+		model,
+		onConflict: options.onConflict,
+		pageLimit: options.pageLimit,
+		tenantId: options.tenantId
+	});
+	const channel = typeof BroadcastChannel === "undefined" ? void 0 : new BroadcastChannel(LT_SYNC_CHANNEL_NAME);
+	let ownerId = null;
+	let claiming = null;
+	const currentUserId = () => {
+		const id = auth.user()?.id;
+		return id ? String(id) : null;
+	};
+	async function ensureOwner() {
+		const id = currentUserId();
+		if (!id) {
+			ownerId = null;
+			return false;
+		}
+		if (id === ownerId) return true;
+		if (claiming?.id !== id) {
+			const pending = {
+				done: claimLtSyncOwner(id),
+				id
+			};
+			claiming = pending;
+			pending.done.finally(() => {
+				if (claiming === pending) claiming = null;
+			});
+		}
+		await claiming.done;
+		if (currentUserId() !== id) return ensureOwner();
+		ownerId = id;
+		return true;
+	}
+	async function refresh() {
+		if (!await ensureOwner()) {
+			records.set([]);
+			pendingCount.set(0);
+			return;
+		}
+		const [list, pending] = await Promise.all([engine.list(), engine.pendingCount()]);
+		records.set(list);
+		pendingCount.set(pending);
+	}
+	async function owned(fn) {
+		if (!await ensureOwner()) throw new Error("injectLtOfflineSync: no signed-in user owns the local data");
+		return fn();
+	}
+	let timer;
+	let backoffMs = 0;
+	let disposed = false;
+	let closeHints;
+	let hintsStopped = null;
+	function announce() {
+		const message = {
+			scope: engine.scope,
+			type: "changed"
+		};
+		if (!disposed) {
+			channel?.postMessage(message);
+			return;
+		}
+		if (typeof BroadcastChannel === "undefined") return;
+		const once = new BroadcastChannel(LT_SYNC_CHANNEL_NAME);
+		try {
+			once.postMessage(message);
+		} finally {
+			once.close();
+		}
+	}
+	function schedule(ms) {
+		if (disposed) return;
+		clearTimeout(timer);
+		timer = setTimeout(() => void sync().catch(() => void 0), ms);
+	}
+	function backOff(retryAfterMs = 0) {
+		backoffMs = Math.min(backoffMs ? backoffMs * 2 : BACKOFF_START_MS, BACKOFF_MAX_MS);
+		if (auto && win?.navigator.onLine !== false) schedule(Math.max(retryAfterMs, backoffMs));
+	}
+	async function sync() {
+		if (!await ensureOwner()) {
+			needsLogin.set(true);
+			return emptyResult({ needsLogin: true });
+		}
+		syncing.set(true);
+		try {
+			const result = await engine.sync();
+			error.set(null);
+			offline.set(result.offline);
+			needsLogin.set(result.needsLogin);
+			forbidden.set(result.forbidden);
+			conflicts.set(result.conflicts);
+			rejected.set(result.rejected);
+			if (result.offline || result.retryAfterMs !== void 0 || result.retried) backOff(result.retryAfterMs);
+			else if (!result.needsLogin) {
+				backoffMs = 0;
+				lastSyncedAt.set(/* @__PURE__ */ new Date());
+				if (hintsStopped === "unauthorized") {
+					hintsStopped = null;
+					startHints();
+				}
+			}
+			return result;
+		} catch (caught) {
+			error.set(caught instanceof Error ? caught : new Error(String(caught)));
+			throw caught;
+		} finally {
+			syncing.set(false);
+			await refresh();
+			announce();
+		}
+	}
+	const autoSync = () => {
+		if (auto) sync().catch(() => void 0);
+	};
+	async function afterLocalChange() {
+		announce();
+		await refresh();
+		if (auto) schedule(LOCAL_CHANGE_DELAY_MS);
+	}
+	function startHints() {
+		if (!auto || options.hints === false || closeHints || hintsStopped || disposed) return;
+		if (doc.visibilityState === "hidden" || !auth.user()?.id) return;
+		closeHints = subscribeLtSyncHints({
+			model,
+			onConnect: autoSync,
+			onHint: autoSync,
+			onStop: (reason) => {
+				stopHints();
+				hintsStopped = reason;
+			},
+			tenantId: options.tenantId
+		});
+	}
+	function stopHints() {
+		closeHints?.();
+		closeHints = void 0;
+	}
+	const onOnline = () => {
+		offline.set(false);
+		backoffMs = 0;
+		autoSync();
+	};
+	const onOffline = () => {
+		offline.set(true);
+	};
+	const onVisibility = () => {
+		if (doc.visibilityState === "hidden") {
+			stopHints();
+			return;
+		}
+		startHints();
+		autoSync();
+	};
+	const onMessage = (event) => {
+		if (event.data?.type === "cleared") {
+			ownerId = null;
+			refresh();
+		} else if (event.data?.type === "changed" && event.data.scope === engine.scope) refresh();
+	};
+	win?.addEventListener("online", onOnline);
+	win?.addEventListener("offline", onOffline);
+	win?.addEventListener("focus", autoSync);
+	doc.addEventListener("visibilitychange", onVisibility);
+	if (win?.navigator.onLine === false) offline.set(true);
+	channel?.addEventListener("message", onMessage);
+	let watchedUserId = auth.user()?.id ?? null;
+	const userWatch = effect(() => {
+		const id = auth.user()?.id ?? null;
+		untracked(() => {
+			if (id === watchedUserId) return;
+			watchedUserId = id;
+			stopHints();
+			hintsStopped = hintsStopped === "disabled" ? "disabled" : null;
+			refresh().then(() => {
+				if (!id) return;
+				startHints();
+				autoSync();
+			});
+		});
+	}, ...ngDevMode ? [{ debugName: "userWatch" }] : /* istanbul ignore next */ []);
+	destroyRef.onDestroy(() => {
+		disposed = true;
+		clearTimeout(timer);
+		stopHints();
+		userWatch.destroy();
+		channel?.removeEventListener("message", onMessage);
+		channel?.close();
+		win?.removeEventListener("online", onOnline);
+		win?.removeEventListener("offline", onOffline);
+		win?.removeEventListener("focus", autoSync);
+		doc.removeEventListener("visibilitychange", onVisibility);
+	});
+	refresh().then(() => {
+		startHints();
+		autoSync();
+	});
+	return {
+		...state,
+		async create(data) {
+			const record = await owned(() => engine.create(data));
+			await afterLocalChange();
+			return record;
+		},
+		async get(id) {
+			return await ensureOwner() ? engine.get(id) : void 0;
+		},
+		async remove(id) {
+			await owned(() => engine.remove(id));
+			await afterLocalChange();
+		},
+		sync,
+		async update(id, data) {
+			const record = await owned(() => engine.update(id, data));
+			await afterLocalChange();
+			return record;
+		}
+	};
+}
+const LT_SYNC_INPUT_OPTIONS = new InjectionToken("LT_SYNC_INPUT_OPTIONS", { factory: () => ({}) });
+const LT_SYNC_OPTIONS = new InjectionToken("LT_SYNC_OPTIONS", { factory: () => mergeLtFeatureOptions({ basePath: "/sync" }, inject(LT_SYNC_INPUT_OPTIONS), inject(LT_RUNTIME_CONFIG, { optional: true })?.lt.sync) });
+function provideLtSync(options = {}) {
+	return makeEnvironmentProviders([
+		{
+			provide: LT_SYNC_INPUT_OPTIONS,
+			useValue: options
+		},
+		provideAppInitializer(() => {
+			if (!isPlatformBrowser(inject(PLATFORM_ID))) return;
+			const api = inject(LtApiUrlService);
+			const fetch = inject(LT_FETCH);
+			configureLtSync({
+				basePath: inject(LT_SYNC_OPTIONS).basePath,
+				buildApiUrl: (path) => api.buildUrl(path),
+				fetch: (input, init) => fetch(input, init)
+			});
+		}),
+		{
+			multi: true,
+			provide: LT_AUTH_SIGN_OUT_HOOKS,
+			useFactory: () => {
+				const isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+				return {
+					afterSignOut: () => isBrowser ? deleteLtSyncDatabase() : void 0,
+					beforeSignOut: (userId) => isBrowser ? flushLtSyncBeforeSignOut(userId ?? void 0, 5e3) : void 0
+				};
+			}
+		}
+	]);
+}
+export { LT_SYNC_CHANNEL_NAME, LT_SYNC_DB_NAME, LT_SYNC_OPTIONS, LtSyncBackoffError, LtSyncOfflineError, LtSyncOwnerChangedError, LtSyncUnauthorizedError, buildLtSyncUrl, claimLtSyncOwner, configureLtSync, createLtSyncEngine, deleteLtSyncDatabase, flushLtSyncBeforeSignOut, getLtSyncBasePath, getLtSyncOwner, injectLtOfflineSync, listLtSyncPendingModels, ltSyncFetch, ltSyncObjectId, ltSyncScope, ltSyncUuidV7, openLtSyncHints, provideLtSync, resetLtSyncEngines, runLtSyncTx, subscribeLtSyncHints };
+
+//# sourceMappingURL=lenne.tech-ng-base-sync.mjs.map