bleam 0.0.11 → 0.0.12

package/dist/state-CAwe-Vw1.js

@@ -1,767 +0,0 @@
-import { t as ensureNativeScript } from "./native-runtime-C85Nuc4F.js";
-import { t as crypto } from "./crypto-BB92-Upx.js";
-import { n as schema } from "./schema-Bo5Jvqus.js";
-import { use, useSyncExternalStore } from "react";
-
-//#region src/state/atom.ts
-var LiveStore = class {
-	listeners = /* @__PURE__ */ new Set();
-	constructor(value) {
-		this.value = value;
-	}
-	get() {
-		return this.value;
-	}
-	set(value) {
-		if (Object.is(this.value, value)) return;
-		this.value = value;
-		for (const listener of this.listeners) listener();
-	}
-	update(updater) {
-		this.set(updater(this.value));
-	}
-	subscribe(listener) {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
-	}
-};
-function atom(initialValue) {
-	return new LiveStore(initialValue);
-}
-function useStore(store) {
-	return useSyncExternalStore(store.subscribe.bind(store), store.get.bind(store), store.get.bind(store));
-}
-function useAtom(value) {
-	const current = useStore(value);
-	const set = (next) => {
-		if (typeof next === "function") {
-			value.update(next);
-			return;
-		}
-		value.set(next);
-	};
-	return [current, set];
-}
-
-//#endregion
-//#region src/app-storage.ts
-let cachedStorageKey;
-function launchArgument(name) {
-	const argumentsList = NSProcessInfo.processInfo.arguments();
-	const count = Number(argumentsList.count ?? 0);
-	for (let index = 0; index < count - 1; index += 1) if (String(argumentsList.objectAtIndex(index)) === name) return String(argumentsList.objectAtIndex(index + 1));
-}
-function storageKey(name) {
-	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "app";
-}
-function currentAppStorageKey() {
-	if (cachedStorageKey) return cachedStorageKey;
-	ensureNativeScript();
-	const configPath = launchArgument("--bleam-project-config");
-	if (configPath) try {
-		const text = String(NSString.stringWithContentsOfFileEncodingError(configPath, NSUTF8StringEncoding, null));
-		const config = JSON.parse(text);
-		if (typeof config.id === "string" && config.id) {
-			cachedStorageKey = config.id;
-			return cachedStorageKey;
-		}
-		if (typeof config.name === "string" && config.name) {
-			cachedStorageKey = storageKey(config.name);
-			return cachedStorageKey;
-		}
-	} catch {}
-	cachedStorageKey = "app";
-	return cachedStorageKey;
-}
-
-//#endregion
-//#region src/state/collection.ts
-const collectionsByName = /* @__PURE__ */ new Map();
-let database;
-let schemaInitialized;
-function getDatabase() {
-	database ??= import("./native-sqlite-xcGdamRD.js").then((module) => module.openNativeSQLiteDatabase(`${currentAppStorageKey()}.sqlite3`));
-	return database;
-}
-async function initializeCollectionSchema() {
-	schemaInitialized ??= (async () => {
-		const database$1 = await getDatabase();
-		await database$1.execute("PRAGMA journal_mode = WAL");
-		await database$1.execute(`CREATE TABLE IF NOT EXISTS collections (
-      collection TEXT NOT NULL,
-      id TEXT NOT NULL,
-      data TEXT NOT NULL,
-      createdAt TEXT NOT NULL,
-      updatedAt TEXT NOT NULL,
-      version INTEGER NOT NULL DEFAULT 1,
-      PRIMARY KEY (collection, id)
-    )`);
-		await database$1.execute(`CREATE TABLE IF NOT EXISTS links (
-      id TEXT PRIMARY KEY,
-      collections TEXT NOT NULL,
-      ids TEXT NOT NULL,
-      createdAt TEXT NOT NULL
-    )`);
-		await database$1.execute("CREATE INDEX IF NOT EXISTS collections_collection_createdAt_idx ON collections(collection, createdAt)");
-		await database$1.execute("CREATE UNIQUE INDEX IF NOT EXISTS links_collections_ids_idx ON links(collections, ids)");
-		await database$1.execute("CREATE INDEX IF NOT EXISTS links_collections_idx ON links(collections)");
-	})();
-	return schemaInitialized;
-}
-async function initializedDatabase() {
-	await initializeCollectionSchema();
-	return getDatabase();
-}
-function createEntry() {
-	return {
-		value: void 0,
-		error: void 0,
-		promise: null,
-		version: 0,
-		listeners: /* @__PURE__ */ new Set()
-	};
-}
-function notify(entry) {
-	for (const listener of entry.listeners) listener();
-}
-function stableStringify(value) {
-	if (value === null || value === void 0) return "";
-	if (typeof value !== "object") return String(value);
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	return `{${Object.keys(value).sort().map((key) => `${key}:${stableStringify(value[key])}`).join("|")}}`;
-}
-function entryChanged(entry, nextValue) {
-	return stableStringify(entry.value) !== stableStringify(nextValue);
-}
-function rowValue(row, key) {
-	const value = row[key];
-	if (typeof value !== "string") throw new Error(`Expected SQLite row field ${key} to be a string`);
-	return value;
-}
-function parsePersistedRow(row) {
-	return {
-		id: rowValue(row, "id"),
-		data: rowValue(row, "data"),
-		createdAt: rowValue(row, "createdAt"),
-		updatedAt: rowValue(row, "updatedAt")
-	};
-}
-function decodeRecordData(collection$1, data) {
-	const value = JSON.parse(data);
-	return collection$1.validator.parse(value);
-}
-function encodeRecordData(collection$1, data) {
-	return JSON.stringify(collection$1.validator.parse(data));
-}
-function recordKey(collection$1, id) {
-	return stableStringify([
-		"view",
-		typeof collection$1 === "string" ? collection$1 : collection$1.name,
-		id
-	]);
-}
-function listKey(collection$1, options) {
-	return stableStringify([
-		"list",
-		collection$1.name,
-		normalizeListOptions(options)
-	]);
-}
-function normalizeWhereValue(value) {
-	if (Array.isArray(value)) {
-		if (value.length === 2 && typeof value[0] === "string") return [value];
-		return [...value].map(([operator, operand]) => [operator, operand]).sort((left, right) => stableStringify(left).localeCompare(stableStringify(right)));
-	}
-	return [["equals", value]];
-}
-function normalizeListOptions(options) {
-	if (!options) return {};
-	return {
-		where: options.where ? Object.fromEntries(Object.entries(options.where).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, normalizeWhereValue(value)])) : void 0,
-		sortBy: options.sortBy ? String(options.sortBy) : void 0,
-		order: options.order,
-		take: options.take
-	};
-}
-function compileListDependencies(collection$1, options) {
-	const paths = /* @__PURE__ */ new Set();
-	for (const key of Object.keys(options.where ?? {})) paths.add(key);
-	if (options.sortBy && options.sortBy !== "createdAt" && options.sortBy !== "updatedAt") paths.add(options.sortBy);
-	return {
-		collection: collection$1,
-		paths,
-		options
-	};
-}
-function getPathValue(record, path) {
-	if (!record) return;
-	if (path === "createdAt" || path === "updatedAt") return record[path];
-	return record.data[path];
-}
-function createRecordChange(collection$1, id, previous, next) {
-	const changedPaths = /* @__PURE__ */ new Set();
-	if (previous?.createdAt !== next?.createdAt) changedPaths.add("createdAt");
-	if (previous?.updatedAt !== next?.updatedAt) changedPaths.add("updatedAt");
-	const paths = new Set([...Object.keys(previous?.data ?? {}), ...Object.keys(next?.data ?? {})]);
-	for (const path of paths) if (stableStringify(getPathValue(previous, path)) !== stableStringify(getPathValue(next, path))) changedPaths.add(path);
-	return {
-		collection: collection$1,
-		id,
-		previous,
-		next,
-		changedPaths
-	};
-}
-function listMayBeAffectedByRecordChange(dependencies, change, currentIds) {
-	if (dependencies.collection !== change.collection) return false;
-	if (change.previous === null && change.next !== null) return true;
-	if (change.previous !== null && change.next === null) return currentIds ? currentIds.includes(change.id) : true;
-	if (dependencies.paths.size === 0) return false;
-	for (const path of change.changedPaths) if (dependencies.paths.has(path)) return true;
-	return false;
-}
-function encodePart(value) {
-	return encodeURIComponent(value);
-}
-function encodePair(first, second) {
-	return `${encodePart(first)}:${encodePart(second)}`;
-}
-function decodePair(value) {
-	const parts = value.split(":");
-	if (parts.length !== 2 || parts[0] === void 0 || parts[1] === void 0) throw new Error(`Invalid encoded link pair "${value}"`);
-	return [decodeURIComponent(parts[0]), decodeURIComponent(parts[1])];
-}
-function storedLinkFor(first, second) {
-	const sameCollection = first.collection.name === second.collection.name;
-	const ordered = first.collection.name < second.collection.name || sameCollection && first.id <= second.id ? [first, second] : [second, first];
-	const collections = encodePair(ordered[0].collection.name, ordered[1].collection.name);
-	const ids = encodePair(ordered[0].id, ordered[1].id);
-	return {
-		id: encodePair(collections, ids),
-		collections,
-		ids
-	};
-}
-function linkIncludesRecord(row, collectionName, id) {
-	const [firstCollection, secondCollection] = decodePair(rowValue(row, "collections"));
-	const [firstId, secondId] = decodePair(rowValue(row, "ids"));
-	return firstCollection === collectionName && firstId === id || secondCollection === collectionName && secondId === id;
-}
-function linkedIdFromRow(row, source, targetName) {
-	const [firstCollection, secondCollection] = decodePair(rowValue(row, "collections"));
-	const [firstId, secondId] = decodePair(rowValue(row, "ids"));
-	if (firstCollection === source.collection && firstId === source.id && secondCollection === targetName) return secondId;
-	if (secondCollection === source.collection && secondId === source.id && firstCollection === targetName) return firstId;
-}
-function resolveRecordReference(first, second) {
-	return {
-		collection: first,
-		id: second
-	};
-}
-async function linkedIds(source, targetName) {
-	const rows = await (await initializedDatabase()).select("SELECT collections, ids FROM links");
-	const ids = [];
-	for (const row of rows) {
-		const id = linkedIdFromRow(row, source, targetName);
-		if (id) ids.push(id);
-	}
-	return ids;
-}
-function toView(collection$1, raw) {
-	return {
-		id: raw.id,
-		collection: raw.collection,
-		createdAt: raw.createdAt,
-		updatedAt: raw.updatedAt,
-		data: collection$1.validator.parse(raw.data),
-		links: raw.links
-	};
-}
-function isRecordLoaded(entry) {
-	return entry.value !== void 0;
-}
-function isRelatedPath(left, right) {
-	return left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
-}
-var Collection = class {
-	validator;
-	records = /* @__PURE__ */ new Map();
-	lists = /* @__PURE__ */ new Map();
-	fields = /* @__PURE__ */ new Map();
-	constructor(name, shape) {
-		this.name = name;
-		this.shape = shape;
-		if (collectionsByName.has(name)) throw new Error(`Collection "${name}" is already registered`);
-		collectionsByName.set(name, this);
-		this.validator = schema(shape);
-	}
-	validateListOptions(options) {
-		if (!options) return;
-		if (options.sortBy && options.sortBy !== "createdAt" && options.sortBy !== "updatedAt" && !(options.sortBy in this.shape)) throw new Error(`Invalid sort field "${String(options.sortBy)}" for collection "${this.name}"`);
-		for (const key of Object.keys(options.where ?? {})) if (!(key in this.shape)) throw new Error(`Invalid where field "${key}" for collection "${this.name}"`);
-	}
-	getRecordEntry(id) {
-		const key = recordKey(this.name, id);
-		const existing = this.records.get(key);
-		if (existing) return existing;
-		const entry = createEntry();
-		this.records.set(key, entry);
-		return entry;
-	}
-	getListEntry(options) {
-		const normalized = normalizeListOptions(options);
-		const key = listKey(this, options);
-		const existing = this.lists.get(key);
-		if (existing) return existing;
-		const entry = {
-			...createEntry(),
-			dependencies: compileListDependencies(this.name, normalized)
-		};
-		this.lists.set(key, entry);
-		return entry;
-	}
-	getFieldEntry(id, path) {
-		const key = recordKey(this.name, id);
-		let entries = this.fields.get(key);
-		if (!entries) {
-			entries = /* @__PURE__ */ new Map();
-			this.fields.set(key, entries);
-		}
-		const existing = entries.get(path);
-		if (existing) return existing;
-		const entry = {
-			version: 0,
-			listeners: /* @__PURE__ */ new Set()
-		};
-		entries.set(path, entry);
-		return entry;
-	}
-	notifyFields(id, changedPaths) {
-		const entries = this.fields.get(recordKey(this.name, id));
-		if (!entries) return;
-		for (const [path, entry] of entries) {
-			if (changedPaths !== null && ![...changedPaths].some((changedPath) => isRelatedPath(path, changedPath))) continue;
-			entry.version += 1;
-			notify(entry);
-		}
-	}
-	setRecordValue(id, value, changedPaths = null) {
-		const entry = this.getRecordEntry(id);
-		const changed = entryChanged(entry, value);
-		entry.value = value;
-		entry.error = void 0;
-		entry.promise = null;
-		if (changed) {
-			entry.version += 1;
-			notify(entry);
-			this.notifyFields(id, changedPaths);
-		}
-		return changed;
-	}
-	async rawRecord(id, links) {
-		const row = await (await initializedDatabase()).get("SELECT id, data, createdAt, updatedAt FROM collections WHERE collection = ? AND id = ?", [this.name, id]);
-		if (!row) return null;
-		const persisted = parsePersistedRow(row);
-		const nextLinks = { ...this.peekRecord(id)?.links ?? {} };
-		for (const target of links ?? []) nextLinks[target.name] = await linkedIds({
-			collection: this.name,
-			id
-		}, target.collection.name);
-		return {
-			id: persisted.id,
-			collection: this.name,
-			createdAt: persisted.createdAt,
-			updatedAt: persisted.updatedAt,
-			data: decodeRecordData(this, persisted.data),
-			links: nextLinks
-		};
-	}
-	async loadRecord(id, options) {
-		const links = (options?.links ?? []).map((collection$1) => ({
-			name: collection$1.name,
-			collection: collection$1
-		}));
-		const entry = this.getRecordEntry(id);
-		if (isRecordLoaded(entry) && links.every((link$1) => entry.value?.links[link$1.name] !== void 0)) return entry.value ?? null;
-		if (entry.promise) return entry.promise;
-		const promise = this.rawRecord(id, links).then((value) => {
-			this.setRecordValue(id, value);
-			return value;
-		}).catch((error) => {
-			entry.error = error;
-			entry.promise = null;
-			entry.version += 1;
-			notify(entry);
-			throw error;
-		});
-		entry.promise = promise;
-		return promise;
-	}
-	async loadListRows(options) {
-		this.validateListOptions(options);
-		const entry = this.getListEntry(options);
-		if (entry.value !== void 0) return entry.value;
-		if (entry.promise) return entry.promise;
-		const promise = this.selectListRows(options).then((rows) => {
-			for (const row of rows) this.setRecordValue(row.id, row);
-			const ids = rows.map((row) => row.id);
-			const changed = entryChanged(entry, ids);
-			entry.value = ids;
-			entry.error = void 0;
-			entry.promise = null;
-			if (changed) {
-				entry.version += 1;
-				notify(entry);
-			}
-			return ids;
-		}).catch((error) => {
-			entry.error = error;
-			entry.promise = null;
-			entry.version += 1;
-			notify(entry);
-			throw error;
-		});
-		entry.promise = promise;
-		return promise;
-	}
-	async selectListRows(options) {
-		const rows = await (await initializedDatabase()).select("SELECT id, data, createdAt, updatedAt FROM collections WHERE collection = ? ORDER BY createdAt ASC", [this.name]);
-		const normalized = normalizeListOptions(options);
-		const views = rows.map((row) => {
-			const persisted = parsePersistedRow(row);
-			return {
-				id: persisted.id,
-				collection: this.name,
-				createdAt: persisted.createdAt,
-				updatedAt: persisted.updatedAt,
-				data: decodeRecordData(this, persisted.data),
-				links: this.peekRecord(persisted.id)?.links ?? {}
-			};
-		});
-		return this.applyListOptions(views, normalized);
-	}
-	applyListOptions(records, options) {
-		let next = records;
-		if (options.where) next = next.filter((record) => {
-			for (const [key, clauses] of Object.entries(options.where ?? {})) {
-				const value = getPathValue(record, key);
-				if (!clauses.every(([operator, operand]) => matchesWhere(value, operator, operand))) return false;
-			}
-			return true;
-		});
-		if (options.sortBy) {
-			const direction = options.order === "desc" ? -1 : 1;
-			next = [...next].sort((left, right) => {
-				const leftValue = getPathValue(left, options.sortBy);
-				const rightValue = getPathValue(right, options.sortBy);
-				if (leftValue === rightValue) return 0;
-				return stableStringify(leftValue) < stableStringify(rightValue) ? -1 * direction : direction;
-			});
-		}
-		return typeof options.take === "number" ? next.slice(0, options.take) : next;
-	}
-	async refreshListEntry(key, entry) {
-		const rows = await this.selectListRows(entry.dependencies.options);
-		for (const row of rows) this.setRecordValue(row.id, row);
-		const ids = rows.map((row) => row.id);
-		const changed = entryChanged(entry, ids);
-		entry.value = ids;
-		entry.error = void 0;
-		entry.promise = null;
-		if (changed) {
-			entry.version += 1;
-			notify(entry);
-		}
-		this.lists.set(key, entry);
-	}
-	async invalidateChanges(recordChanges, edgeChanges = []) {
-		for (const change of recordChanges) this.setRecordValue(change.id, change.next, change.changedPaths);
-		for (const change of edgeChanges) await this.refreshLoadedLinks(change);
-		const candidateKeys = /* @__PURE__ */ new Set();
-		for (const [key, entry] of this.lists.entries()) if (recordChanges.some((change) => listMayBeAffectedByRecordChange(entry.dependencies, change, entry.value))) candidateKeys.add(key);
-		for (const key of candidateKeys) {
-			const entry = this.lists.get(key);
-			if (entry) await this.refreshListEntry(key, entry);
-		}
-	}
-	async refreshLoadedLinks(change) {
-		const affected = [change.left, change.right].filter((record) => record.collection === this.name);
-		for (const record of affected) {
-			const current = this.getRecordEntry(record.id).value;
-			if (!current) continue;
-			const linkNames = Object.keys(current.links);
-			if (linkNames.length === 0) continue;
-			const nextLinks = { ...current.links };
-			for (const name of linkNames) nextLinks[name] = await linkedIds({
-				collection: this.name,
-				id: record.id
-			}, name);
-			this.setRecordValue(record.id, {
-				...current,
-				links: nextLinks
-			});
-		}
-	}
-	peekRecord(id) {
-		return this.getRecordEntry(id).value;
-	}
-	async insert(value) {
-		const database$1 = await initializedDatabase();
-		const parsed = this.validator.parse(value);
-		const id = crypto.randomUUID();
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		const parameters = [
-			this.name,
-			id,
-			encodeRecordData(this, parsed),
-			timestamp,
-			timestamp
-		];
-		await database$1.execute(`INSERT INTO collections (collection, id, data, createdAt, updatedAt, version)
-       VALUES (?, ?, ?, ?, ?, 1)`, parameters);
-		const next = {
-			id,
-			collection: this.name,
-			createdAt: timestamp,
-			updatedAt: timestamp,
-			data: parsed,
-			links: {}
-		};
-		await this.invalidateChanges([createRecordChange(this.name, id, null, next)]);
-		return id;
-	}
-	async update(id, value) {
-		const database$1 = await initializedDatabase();
-		if (Object.keys(value).filter((key) => key in this.shape).length === 0) return;
-		const previous = await this.rawRecord(id);
-		if (!previous) throw new Error(`Cannot update missing collection record "${this.name}:${id}"`);
-		const nextData = this.validator.parse({
-			...previous.data,
-			...value
-		});
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		await database$1.execute(`UPDATE collections
-       SET data = ?, updatedAt = ?, version = version + 1
-       WHERE collection = ? AND id = ?`, [
-			encodeRecordData(this, nextData),
-			timestamp,
-			this.name,
-			id
-		]);
-		const next = {
-			...previous,
-			updatedAt: timestamp,
-			data: nextData
-		};
-		await this.invalidateChanges([createRecordChange(this.name, id, previous, next)]);
-	}
-	async delete(id) {
-		const database$1 = await initializedDatabase();
-		const previous = await this.rawRecord(id);
-		if (!previous) throw new Error(`Cannot delete missing collection record "${this.name}:${id}"`);
-		await database$1.transaction(async () => {
-			await database$1.execute("DELETE FROM collections WHERE collection = ? AND id = ?", [this.name, id]);
-			await this.deleteLinksForRecord(id);
-		});
-		await this.invalidateChanges([createRecordChange(this.name, id, previous, null)]);
-	}
-	async all() {
-		return (await this.selectListRows()).map((row) => toView(this, row));
-	}
-	async get(id) {
-		const row = await this.loadRecord(id);
-		return row ? toView(this, row) : null;
-	}
-	subscribeRecord(id, listener) {
-		const entry = this.getRecordEntry(id);
-		entry.listeners.add(listener);
-		return () => {
-			entry.listeners.delete(listener);
-		};
-	}
-	subscribeList(options, listener) {
-		const entry = this.getListEntry(options);
-		entry.listeners.add(listener);
-		return () => {
-			entry.listeners.delete(listener);
-		};
-	}
-	subscribeField(id, path, listener) {
-		const entry = this.getFieldEntry(id, path);
-		entry.listeners.add(listener);
-		return () => {
-			entry.listeners.delete(listener);
-			if (entry.listeners.size > 0) return;
-			const key = recordKey(this.name, id);
-			const entries = this.fields.get(key);
-			if (!entries) return;
-			entries.delete(path);
-			if (entries.size === 0) this.fields.delete(key);
-		};
-	}
-	getRecordVersion(id) {
-		return this.getRecordEntry(id).version;
-	}
-	getListVersion(options) {
-		return this.getListEntry(options).version;
-	}
-	getFieldVersion(id, path) {
-		return this.getFieldEntry(id, path).version;
-	}
-	getRecordSnapshot(id, options) {
-		const row = this.peekRecord(id);
-		if (!row) return row ?? null;
-		if ((options?.links ?? []).some((link$1) => row.links[link$1.name] === void 0)) return;
-		return toView(this, row);
-	}
-	getListSnapshot(options) {
-		return this.getListEntry(options).value;
-	}
-	async ensureRecord(id, options) {
-		return this.loadRecord(id, options);
-	}
-	async ensureList(options) {
-		return this.loadListRows(options);
-	}
-	async deleteLinksForRecord(id) {
-		const database$1 = await initializedDatabase();
-		const rows = await database$1.select("SELECT id, collections, ids FROM links");
-		const deleted = [];
-		for (const row of rows) {
-			if (!linkIncludesRecord(row, this.name, id)) continue;
-			const [firstCollection, secondCollection] = decodePair(rowValue(row, "collections"));
-			const [firstId, secondId] = decodePair(rowValue(row, "ids"));
-			deleted.push({
-				type: "unlink",
-				left: {
-					collection: firstCollection,
-					id: firstId
-				},
-				right: {
-					collection: secondCollection,
-					id: secondId
-				}
-			});
-			await database$1.execute("DELETE FROM links WHERE id = ?", [rowValue(row, "id")]);
-		}
-		for (const change of deleted) await notifyEdgeChange(change);
-	}
-};
-function matchesWhere(value, operator, operand) {
-	switch (operator) {
-		case "equals": return value === operand;
-		case "greater-than": return typeof value === "number" && typeof operand === "number" && value > operand;
-		case "less-than": return typeof value === "number" && typeof operand === "number" && value < operand;
-		case "contains": return typeof value === "string" && typeof operand === "string" && value.includes(operand);
-		default: throw new Error(`Invalid where operator "${operator}"`);
-	}
-}
-function collection(name, shape) {
-	return new Collection(name, shape);
-}
-async function notifyEdgeChange(change) {
-	const names = new Set([change.left.collection, change.right.collection]);
-	for (const name of names) await collectionsByName.get(name)?.invalidateChanges([], [change]);
-}
-async function link(firstCollection, firstId, secondCollection, secondId) {
-	const row = storedLinkFor(resolveRecordReference(firstCollection, firstId), resolveRecordReference(secondCollection, secondId));
-	await (await initializedDatabase()).execute("INSERT OR IGNORE INTO links (id, collections, ids, createdAt) VALUES (?, ?, ?, ?)", [
-		row.id,
-		row.collections,
-		row.ids,
-		(/* @__PURE__ */ new Date()).toISOString()
-	]);
-	await notifyEdgeChange({
-		type: "link",
-		left: {
-			collection: firstCollection.name,
-			id: firstId
-		},
-		right: {
-			collection: secondCollection.name,
-			id: secondId
-		}
-	});
-}
-async function unlink(firstCollection, firstId, secondCollection, secondId) {
-	const row = storedLinkFor(resolveRecordReference(firstCollection, firstId), resolveRecordReference(secondCollection, secondId));
-	await (await initializedDatabase()).execute("DELETE FROM links WHERE id = ?", [row.id]);
-	await notifyEdgeChange({
-		type: "unlink",
-		left: {
-			collection: firstCollection.name,
-			id: firstId
-		},
-		right: {
-			collection: secondCollection.name,
-			id: secondId
-		}
-	});
-}
-async function isLinked(firstCollection, firstId, secondCollection, secondId) {
-	const row = storedLinkFor(resolveRecordReference(firstCollection, firstId), resolveRecordReference(secondCollection, secondId));
-	return await (await initializedDatabase()).get("SELECT id FROM links WHERE id = ?", [row.id]) !== void 0;
-}
-function useList(collection$1, options) {
-	collection$1.validateListOptions(options);
-	useSyncExternalStore((listener) => collection$1.subscribeList(options, listener), () => collection$1.getListVersion(options), () => collection$1.getListVersion(options));
-	const entry = collection$1.getListEntry(options);
-	if (entry.error) throw entry.error;
-	if (entry.value === void 0) use(collection$1.ensureList(options));
-	return collection$1.getListSnapshot(options) ?? [];
-}
-function useView(collection$1, id, options) {
-	useSyncExternalStore((listener) => collection$1.subscribeRecord(id, listener), () => collection$1.getRecordVersion(id), () => collection$1.getRecordVersion(id));
-	const entry = collection$1.getRecordEntry(id);
-	if (entry.error) throw entry.error;
-	if (collection$1.getRecordSnapshot(id, options) === void 0) use(collection$1.ensureRecord(id, options));
-	return collection$1.getRecordSnapshot(id, options);
-}
-function useField(collection$1, id, key) {
-	useSyncExternalStore((listener) => collection$1.subscribeField(id, key, listener), () => collection$1.getFieldVersion(id, key), () => collection$1.getFieldVersion(id, key));
-	const entry = collection$1.getRecordEntry(id);
-	if (entry.error) throw entry.error;
-	if (entry.value === void 0) use(collection$1.ensureRecord(id));
-	return (collection$1.getRecordSnapshot(id)?.data)?.[key];
-}
-
-//#endregion
-//#region src/state/setting.ts
-function settingKey(key) {
-	return `bleam.apps.${currentAppStorageKey()}.${key}`;
-}
-function readSettingValue(key, fallback) {
-	const value = NSUserDefaults.standardUserDefaults.objectForKey(settingKey(key));
-	return value === null || value === void 0 ? fallback : value;
-}
-function writeSettingValue(key, value) {
-	const userDefaults = NSUserDefaults.standardUserDefaults;
-	if (value === void 0) {
-		userDefaults.removeObjectForKey(settingKey(key));
-		return;
-	}
-	userDefaults.setObjectForKey(value, settingKey(key));
-}
-function setting(key, initialValue) {
-	const store = new LiveStore(readSettingValue(key, initialValue));
-	return {
-		get: store.get.bind(store),
-		subscribe: store.subscribe.bind(store),
-		set(value) {
-			writeSettingValue(key, value);
-			store.set(value);
-		},
-		update(updater) {
-			this.set(updater(store.get()));
-		}
-	};
-}
-function useSetting(value) {
-	return useAtom(value);
-}
-
-//#endregion
-export { isLinked as a, useField as c, LiveStore as d, atom as f, collection as i, useList as l, useStore as m, useSetting as n, link as o, useAtom as p, Collection as r, unlink as s, setting as t, useView as u };