bleam 0.0.6 → 0.0.8

package/dist/state.js

@@ -1,747 +1,6 @@
 import "./native-runtime-C85Nuc4F.js";
-import { t as crypto } from "./crypto-BB92-Upx.js";
-import { n as schema } from "./schema-DVmoD9JL.js";
-import { useSyncExternalStore } from "react";
-import { openOrCreate } from "@nativescript-community/sqlite";
+import "./crypto-BB92-Upx.js";
+import { a as isLinked, c as useField, d as LiveStore, f as atom, i as collection, l as useList, m as useStore, n as useSetting, o as link, p as useAtom, r as Collection, s as unlink, t as setting, u as useView } from "./state-CAwe-Vw1.js";
+import "./schema-Bo5Jvqus.js";
 
-//#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) {
-	return useStore(value);
-}
-
-//#endregion
-//#region src/native-sqlite.ts
-const databases = /* @__PURE__ */ new Map();
-function documentsDirectory() {
-	const path = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.Document, NSSearchPathDomainMask.UserDomain, true).objectAtIndex(0);
-	if (!path) throw new Error("Could not resolve documents directory");
-	return String(path);
-}
-function ensureDirectory(path) {
-	const fileManager = NSFileManager.defaultManager;
-	if (fileManager.fileExistsAtPath(path)) return;
-	fileManager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(path, true, null, null);
-}
-function databasePath(name) {
-	const directory = `${documentsDirectory()}/bleam`;
-	ensureDirectory(directory);
-	return `${directory}/${name}`;
-}
-function toPluginParameters(parameters) {
-	return parameters;
-}
-function toSQLiteValue(value) {
-	if (typeof value === "string" || typeof value === "number" || value === null) return value;
-	throw new Error("SQLite blobs are not supported by Bleam state yet");
-}
-function toSQLiteRow(row) {
-	const output = {};
-	for (const [key, value] of Object.entries(row)) output[key] = toSQLiteValue(value);
-	return output;
-}
-var NativeSQLiteDatabase = class {
-	constructor(database$1) {
-		this.database = database$1;
-	}
-	execute(query, parameters) {
-		return this.database.execute(query, toPluginParameters(parameters));
-	}
-	async select(query, parameters) {
-		return (await this.database.select(query, toPluginParameters(parameters))).map(toSQLiteRow);
-	}
-	async get(query, parameters) {
-		const row = await this.database.get(query, toPluginParameters(parameters));
-		return row ? toSQLiteRow(row) : void 0;
-	}
-	transaction(action) {
-		return this.database.transaction(action);
-	}
-	close() {
-		this.database.close();
-	}
-};
-function openNativeSQLiteDatabase(name = "bleam.sqlite3") {
-	const path = databasePath(name);
-	const existing = databases.get(path);
-	if (existing) return new NativeSQLiteDatabase(existing);
-	const database$1 = openOrCreate(path);
-	databases.set(path, database$1);
-	return new NativeSQLiteDatabase(database$1);
-}
-
-//#endregion
-//#region src/state/collection.ts
-const database = openNativeSQLiteDatabase();
-const recordMetadata = /* @__PURE__ */ new WeakMap();
-const recordAttachments = /* @__PURE__ */ new WeakMap();
-const collectionsByName = /* @__PURE__ */ new Map();
-let schemaInitialized;
-async function initializeCollectionSchema() {
-	schemaInitialized ??= (async () => {
-		await database.execute("PRAGMA journal_mode = WAL");
-		await database.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.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.execute(`CREATE TABLE IF NOT EXISTS pins (
-      sourceCollection TEXT NOT NULL,
-      sourceId TEXT NOT NULL,
-      name TEXT NOT NULL,
-      targetCollection TEXT NOT NULL,
-      targetId TEXT NOT NULL,
-      createdAt TEXT NOT NULL,
-      updatedAt TEXT NOT NULL,
-      PRIMARY KEY (sourceCollection, sourceId, name)
-    )`);
-		await database.execute("CREATE INDEX IF NOT EXISTS collections_collection_createdAt_idx ON collections(collection, createdAt)");
-		await database.execute("CREATE UNIQUE INDEX IF NOT EXISTS links_collections_ids_idx ON links(collections, ids)");
-		await database.execute("CREATE INDEX IF NOT EXISTS links_collections_idx ON links(collections)");
-		await database.execute("CREATE INDEX IF NOT EXISTS pins_source_idx ON pins(sourceCollection, sourceId)");
-		await database.execute("CREATE INDEX IF NOT EXISTS pins_target_idx ON pins(targetCollection, targetId)");
-	})();
-	return schemaInitialized;
-}
-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")
-	};
-}
-function isReservedRecordField(key) {
-	return key === "id" || key === "data" || key === "delete" || key === "set" || key === "with";
-}
-function assertCollectionShape(name, shape) {
-	for (const key of Object.keys(shape)) if (isReservedRecordField(key)) throw new Error(`Collection "${name}" field "${key}" is reserved by Bleam records`);
-}
-function attachmentKey(value) {
-	return typeof value === "string" ? `pin:${value}` : `join:${value.name}`;
-}
-function setAttachment(record, key, value) {
-	let attachments = recordAttachments.get(record);
-	if (!attachments) {
-		attachments = /* @__PURE__ */ new Map();
-		recordAttachments.set(record, attachments);
-	}
-	attachments.set(key, value);
-}
-function getAttachment(record, key) {
-	return recordAttachments.get(record)?.get(key);
-}
-function extractRecordData(collection$1, record) {
-	const output = {};
-	for (const key of Object.keys(collection$1.shape)) {
-		if (isReservedRecordField(key)) throw new Error(`Collection "${collection$1.name}" field "${key}" is reserved by Bleam records`);
-		const value = record[key];
-		if (value !== void 0) output[key] = value;
-	}
-	return collection$1.validator.parse(output);
-}
-function applyRecordData(collection$1, record, data) {
-	for (const key of Object.keys(collection$1.shape)) {
-		if (key in data) {
-			Object.defineProperty(record, key, {
-				value: data[key],
-				enumerable: true,
-				writable: true,
-				configurable: true
-			});
-			continue;
-		}
-		delete record[key];
-	}
-}
-function createRecord(collection$1, id, data) {
-	const record = {};
-	Object.defineProperty(record, "id", {
-		value: id,
-		enumerable: true,
-		writable: false,
-		configurable: false
-	});
-	applyRecordData(collection$1, record, data);
-	Object.defineProperty(record, "data", {
-		value() {
-			return recordMetadata.has(this) ? extractRecordData(collection$1, this) : void 0;
-		},
-		enumerable: true,
-		writable: false,
-		configurable: false
-	});
-	Object.defineProperty(record, "delete", {
-		value() {
-			return collection$1.delete(this);
-		},
-		enumerable: true,
-		writable: false,
-		configurable: false
-	});
-	Object.defineProperty(record, "set", {
-		get() {
-			return (patch) => collection$1.update(this, patch);
-		},
-		enumerable: true,
-		configurable: false
-	});
-	Object.defineProperty(record, "with", {
-		value(value) {
-			return getAttachment(this, attachmentKey(value)) ?? (typeof value === "string" ? void 0 : []);
-		},
-		enumerable: true,
-		writable: false,
-		configurable: false
-	});
-	recordMetadata.set(record, {
-		collection: collection$1,
-		id
-	});
-	return record;
-}
-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 metadataFor(record) {
-	const metadata = recordMetadata.get(record);
-	if (!metadata) throw new Error("Expected a collection record loaded by Bleam");
-	return metadata;
-}
-function resolveRecordReference(first, second) {
-	if (first instanceof Collection) {
-		if (!second) throw new Error("Expected a record id");
-		return {
-			collection: first,
-			id: second
-		};
-	}
-	return metadataFor(first);
-}
-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.name && firstId === source.id && secondCollection === targetName) return secondId;
-	if (secondCollection === source.collection.name && secondId === source.id && firstCollection === targetName) return firstId;
-}
-function collectionForName(name) {
-	const collection$1 = collectionsByName.get(name);
-	if (!collection$1) throw new Error(`Unknown collection "${name}"`);
-	return collection$1;
-}
-async function notifyCollections(...names) {
-	for (const name of new Set(names)) await collectionForName(name).refreshQueries();
-}
-var Collection = class {
-	validator;
-	queries = /* @__PURE__ */ new Set();
-	store = {
-		loaded: false,
-		records: /* @__PURE__ */ new Map(),
-		order: [],
-		listListeners: /* @__PURE__ */ new Set(),
-		recordListeners: /* @__PURE__ */ new Map()
-	};
-	constructor(name, shape) {
-		this.name = name;
-		this.shape = shape;
-		assertCollectionShape(name, shape);
-		if (collectionsByName.has(name)) throw new Error(`Collection "${name}" is already registered`);
-		collectionsByName.set(name, this);
-		this.validator = schema(shape);
-	}
-	initialize() {
-		return initializeCollectionSchema();
-	}
-	async load() {
-		if (this.store.loaded) return;
-		this.store.loading ??= (async () => {
-			await this.initialize();
-			const rows = await database.select("SELECT id, data FROM collections WHERE collection = ? ORDER BY createdAt ASC", [this.name]);
-			this.store.records.clear();
-			this.store.order = [];
-			for (const row of rows) {
-				const persisted = parsePersistedRow(row);
-				const data = decodeRecordData(this, persisted.data);
-				const record = createRecord(this, persisted.id, data);
-				this.store.records.set(persisted.id, record);
-				this.store.order.push(persisted.id);
-			}
-			this.store.loaded = true;
-		})();
-		return this.store.loading;
-	}
-	notifyRecordListeners(id) {
-		const listeners = this.store.recordListeners.get(id);
-		if (!listeners) return;
-		for (const listener of listeners) listener();
-	}
-	currentRecords() {
-		const records = [];
-		for (const id of this.store.order) {
-			const record = this.store.records.get(id);
-			if (record) records.push(record);
-		}
-		return records;
-	}
-	async refreshQueries() {
-		for (const query of this.queries) await query.refresh();
-		for (const listener of this.store.listListeners) listener();
-	}
-	async insert(value) {
-		await this.load();
-		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.execute(`INSERT INTO collections (collection, id, data, createdAt, updatedAt, version)
-       VALUES (?, ?, ?, ?, ?, 1)`, parameters);
-		const record = createRecord(this, id, parsed);
-		this.store.records.set(id, record);
-		this.store.order.push(id);
-		await this.refreshQueries();
-		this.notifyRecordListeners(id);
-		return record;
-	}
-	async update(record, value) {
-		await this.load();
-		const id = typeof record === "string" ? record : metadataFor(record).id;
-		const loadedRecord = this.store.records.get(id);
-		if (!loadedRecord) throw new Error("Cannot update a collection record that was not loaded by Bleam");
-		if (Object.keys(value).filter((key) => key in this.shape).length === 0) return;
-		const next = this.validator.parse({
-			...extractRecordData(this, loadedRecord),
-			...value
-		});
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		await database.execute(`UPDATE collections
-       SET data = ?, updatedAt = ?, version = version + 1
-       WHERE collection = ? AND id = ?`, [
-			encodeRecordData(this, next),
-			timestamp,
-			this.name,
-			id
-		]);
-		applyRecordData(this, loadedRecord, next);
-		this.notifyRecordListeners(id);
-	}
-	async delete(record) {
-		await this.load();
-		const id = typeof record === "string" ? record : metadataFor(record).id;
-		const loadedRecord = this.store.records.get(id);
-		if (!loadedRecord) throw new Error("Cannot delete a collection record that was not loaded by Bleam");
-		const affectedCollections = new Set([this.name]);
-		await database.transaction(async () => {
-			await database.execute("DELETE FROM collections WHERE collection = ? AND id = ?", [this.name, id]);
-			for (const collectionName of await this.deleteLinksForRecord(id)) affectedCollections.add(collectionName);
-			for (const collectionName of await this.deletePinsForRecord(id)) affectedCollections.add(collectionName);
-		});
-		this.store.records.delete(id);
-		this.store.order = this.store.order.filter((currentId) => currentId !== id);
-		recordMetadata.delete(loadedRecord);
-		this.notifyRecordListeners(id);
-		await notifyCollections(...affectedCollections);
-	}
-	async all() {
-		await this.load();
-		return this.currentRecords();
-	}
-	async get(id) {
-		await this.load();
-		return this.store.records.get(id);
-	}
-	async pin(record, name, target, targetId) {
-		const sourceId = typeof record === "string" ? record : metadataFor(record).id;
-		const targetReference = resolveRecordReference(target, targetId);
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		await initializeCollectionSchema();
-		await database.execute(`INSERT INTO pins (sourceCollection, sourceId, name, targetCollection, targetId, createdAt, updatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(sourceCollection, sourceId, name)
-       DO UPDATE SET
-        targetCollection = excluded.targetCollection,
-        targetId = excluded.targetId,
-        updatedAt = excluded.updatedAt`, [
-			this.name,
-			sourceId,
-			name,
-			targetReference.collection.name,
-			targetReference.id,
-			timestamp,
-			timestamp
-		]);
-		await this.refreshQueries();
-	}
-	async unpin(record, name) {
-		const sourceId = typeof record === "string" ? record : metadataFor(record).id;
-		await initializeCollectionSchema();
-		await database.execute("DELETE FROM pins WHERE sourceCollection = ? AND sourceId = ? AND name = ?", [
-			this.name,
-			sourceId,
-			name
-		]);
-		await this.refreshQueries();
-	}
-	subscribeRecord(record, listener) {
-		const id = metadataFor(record).id;
-		let listeners = this.store.recordListeners.get(id);
-		if (!listeners) {
-			listeners = /* @__PURE__ */ new Set();
-			this.store.recordListeners.set(id, listeners);
-		}
-		listeners.add(listener);
-		return () => {
-			listeners.delete(listener);
-			if (listeners.size === 0) this.store.recordListeners.delete(id);
-		};
-	}
-	queryStore(query) {
-		const subscription = {
-			value: [],
-			listeners: /* @__PURE__ */ new Set(),
-			refresh: async () => {
-				subscription.value = await this.executeQuery(query);
-				for (const listener of subscription.listeners) listener();
-			}
-		};
-		this.queries.add(subscription);
-		subscription.refresh();
-		return {
-			get() {
-				return subscription.value;
-			},
-			subscribe: (listener) => {
-				subscription.listeners.add(listener);
-				return () => {
-					subscription.listeners.delete(listener);
-					if (subscription.listeners.size === 0) this.queries.delete(subscription);
-				};
-			}
-		};
-	}
-	async executeQuery(query) {
-		await this.load();
-		let records = this.currentRecords();
-		for (const join of query?.joins ?? []) {
-			const target = join.kind === "record" ? metadataFor(join.record) : {
-				collection: join.collection,
-				id: join.id
-			};
-			const filtered = [];
-			for (const record of records) if (await areLinked(metadataFor(record), target)) filtered.push(record);
-			records = filtered;
-		}
-		for (const include of query?.joinIncludes ?? []) for (const record of records) {
-			const linked = await linkedRecords(metadataFor(record), include.collection);
-			setAttachment(record, attachmentKey(include.collection), linked);
-		}
-		for (const include of query?.pinIncludes ?? []) for (const record of records) {
-			const pinned = await pinnedRecord(metadataFor(record), include.name, include.target);
-			setAttachment(record, attachmentKey(include.name), pinned);
-		}
-		return records;
-	}
-	async deleteLinksForRecord(id) {
-		const rows = await database.select("SELECT id, collections, ids FROM links");
-		const affectedCollections = /* @__PURE__ */ new Set();
-		for (const row of rows) if (linkIncludesRecord(row, this.name, id)) {
-			const [firstCollection, secondCollection] = decodePair(rowValue(row, "collections"));
-			affectedCollections.add(firstCollection);
-			affectedCollections.add(secondCollection);
-			await database.execute("DELETE FROM links WHERE id = ?", [rowValue(row, "id")]);
-		}
-		return affectedCollections;
-	}
-	async deletePinsForRecord(id) {
-		const rows = await database.select(`SELECT sourceCollection, targetCollection FROM pins
-       WHERE (sourceCollection = ? AND sourceId = ?)
-       OR (targetCollection = ? AND targetId = ?)`, [
-			this.name,
-			id,
-			this.name,
-			id
-		]);
-		const affectedCollections = /* @__PURE__ */ new Set();
-		for (const row of rows) {
-			affectedCollections.add(rowValue(row, "sourceCollection"));
-			affectedCollections.add(rowValue(row, "targetCollection"));
-		}
-		await database.execute(`DELETE FROM pins
-       WHERE (sourceCollection = ? AND sourceId = ?)
-       OR (targetCollection = ? AND targetId = ?)`, [
-			this.name,
-			id,
-			this.name,
-			id
-		]);
-		return affectedCollections;
-	}
-};
-function collection(name, shape) {
-	return new Collection(name, shape);
-}
-async function areLinked(first, second) {
-	await initializeCollectionSchema();
-	const row = storedLinkFor(first, second);
-	return await database.get("SELECT id FROM links WHERE id = ?", [row.id]) !== void 0;
-}
-async function linkedRecords(source, target) {
-	await initializeCollectionSchema();
-	const rows = await database.select("SELECT collections, ids FROM links");
-	const records = [];
-	for (const row of rows) {
-		const id = linkedIdFromRow(row, source, target.name);
-		if (!id) continue;
-		const record = await target.get(id);
-		if (record) records.push(record);
-	}
-	return records;
-}
-async function pinnedRecord(source, name, target) {
-	await initializeCollectionSchema();
-	const row = await database.get(`SELECT targetId FROM pins
-     WHERE sourceCollection = ?
-     AND sourceId = ?
-     AND name = ?
-     AND targetCollection = ?`, [
-		source.collection.name,
-		source.id,
-		name,
-		target.name
-	]);
-	if (!row) return;
-	return target.get(rowValue(row, "targetId"));
-}
-async function link(first, second, third, fourth) {
-	const firstReference = resolveRecordReference(first, typeof second === "string" ? second : void 0);
-	const secondReference = third ? resolveRecordReference(third, fourth) : resolveRecordReference(second);
-	const row = storedLinkFor(firstReference, secondReference);
-	await initializeCollectionSchema();
-	await database.execute("INSERT OR IGNORE INTO links (id, collections, ids, createdAt) VALUES (?, ?, ?, ?)", [
-		row.id,
-		row.collections,
-		row.ids,
-		(/* @__PURE__ */ new Date()).toISOString()
-	]);
-	await notifyCollections(firstReference.collection.name, secondReference.collection.name);
-}
-async function unlink(first, second, third, fourth) {
-	const firstReference = resolveRecordReference(first, typeof second === "string" ? second : void 0);
-	const secondReference = third ? resolveRecordReference(third, fourth) : resolveRecordReference(second);
-	const row = storedLinkFor(firstReference, secondReference);
-	await initializeCollectionSchema();
-	await database.execute("DELETE FROM links WHERE id = ?", [row.id]);
-	await notifyCollections(firstReference.collection.name, secondReference.collection.name);
-}
-async function isLinked(first, second, third, fourth) {
-	return areLinked(resolveRecordReference(first, typeof second === "string" ? second : void 0), third ? resolveRecordReference(third, fourth) : resolveRecordReference(second));
-}
-async function pin(source, second, third, fourth, fifth) {
-	if (source instanceof Collection) {
-		if (typeof third !== "string" || !fourth || !fifth) throw new Error("Expected source id, pin name, target collection, and target id");
-		const sourceRecord$1 = resolveRecordReference(source, second);
-		const targetRecord = resolveRecordReference(fourth, fifth);
-		await sourceRecord$1.collection.pin(sourceRecord$1.id, third, targetRecord.collection, targetRecord.id);
-		return;
-	}
-	if (typeof third !== "object") throw new Error("Expected a target record");
-	const sourceRecord = metadataFor(source);
-	await sourceRecord.collection.pin(sourceRecord.id, second, third);
-}
-async function unpin(source, second, third) {
-	if (source instanceof Collection) {
-		if (!third) throw new Error("Expected source id and pin name");
-		await source.unpin(second, third);
-		return;
-	}
-	const sourceRecord = metadataFor(source);
-	await sourceRecord.collection.unpin(sourceRecord.id, second);
-}
-async function isPinned(source, second, third, fourth, fifth) {
-	const sourceRecord = source instanceof Collection ? resolveRecordReference(source, second) : metadataFor(source);
-	const name = source instanceof Collection ? String(third) : second;
-	const targetRecord = source instanceof Collection ? resolveRecordReference(fourth, fifth) : resolveRecordReference(third);
-	await initializeCollectionSchema();
-	return await database.get(`SELECT targetId FROM pins
-     WHERE sourceCollection = ?
-     AND sourceId = ?
-     AND name = ?
-     AND targetCollection = ?
-     AND targetId = ?`, [
-		sourceRecord.collection.name,
-		sourceRecord.id,
-		name,
-		targetRecord.collection.name,
-		targetRecord.id
-	]) !== void 0;
-}
-var CollectionQuery = class {
-	joins = [];
-	joinIncludes = [];
-	pinIncludes = [];
-	cachedStore;
-	constructor(collection$1) {
-		this.collection = collection$1;
-	}
-	join(value, id) {
-		if (value instanceof Collection) {
-			if (id) {
-				this.joins.push({
-					kind: "id",
-					collection: value,
-					id
-				});
-				return this;
-			}
-			this.joinIncludes.push({ collection: value });
-			return this;
-		}
-		this.joins.push({
-			kind: "record",
-			record: value
-		});
-		return this;
-	}
-	with(name, target) {
-		this.pinIncludes.push({
-			name,
-			target
-		});
-		return this;
-	}
-	get() {
-		return this.store().get();
-	}
-	subscribe(listener) {
-		return this.store().subscribe(listener);
-	}
-	store() {
-		this.cachedStore ??= this.collection.queryStore({
-			joins: this.joins,
-			joinIncludes: this.joinIncludes,
-			pinIncludes: this.pinIncludes
-		});
-		return this.cachedStore;
-	}
-};
-var QueryBuilder = class {
-	from(collection$1) {
-		return new CollectionQuery(collection$1);
-	}
-};
-function useQuery(query) {
-	return useStore(query(new QueryBuilder()));
-}
-
-//#endregion
-//#region src/state/setting.ts
-function readSettingValue(key, fallback) {
-	const value = NSUserDefaults.standardUserDefaults.objectForKey(key);
-	return value === null || value === void 0 ? fallback : value;
-}
-function writeSettingValue(key, value) {
-	const userDefaults = NSUserDefaults.standardUserDefaults;
-	if (value === void 0) {
-		userDefaults.removeObjectForKey(key);
-		return;
-	}
-	userDefaults.setObjectForKey(value, 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 useStore(value);
-}
-
-//#endregion
-export { Collection, LiveStore, QueryBuilder, atom, collection, isLinked, isPinned, link, pin, setting, unlink, unpin, useAtom, useQuery, useSetting, useStore };
+export { Collection, LiveStore, atom, collection, isLinked, link, setting, unlink, useAtom, useField, useList, useSetting, useStore, useView };