@askrjs/askr 0.0.48 → 0.0.49

package/dist/data/index.js

@@ -1,539 +1,5 @@
-import { logger } from "../dev/logger.js";
-import { globalScheduler } from "../runtime/scheduler.js";
-import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "../runtime/readable.js";
-import { claimHookIndex, getCurrentComponentInstance } from "../runtime/component.js";
-import { getRenderContext } from "../ssr/context.js";
-import { emitInvalidation } from "./invalidation-listeners.js";
-import { documentVisible, routeActive, timer, windowFocused } from "../runtime/operations.js";
-//#region src/data/index.ts
-const RECONCILE_MAX_ATTEMPTS = 3;
-const RECONCILE_RETRY_DELAY_MS = 25;
-const globalQueryCache = /* @__PURE__ */ new Map();
-const querySlotsByInstance = /* @__PURE__ */ new WeakMap();
-const mutationSlotsByInstance = /* @__PURE__ */ new WeakMap();
-const queryCleanupRegistered = /* @__PURE__ */ new WeakSet();
-const mutationCleanupRegistered = /* @__PURE__ */ new WeakSet();
-function createReadableSource() {
-	return (() => void 0);
-}
-function getQueryCache() {
-	return getRenderContext()?.queryCache ?? globalQueryCache;
-}
-function getQuerySlotStore(instance) {
-	let store = querySlotsByInstance.get(instance);
-	if (!store) {
-		store = /* @__PURE__ */ new Map();
-		querySlotsByInstance.set(instance, store);
-	}
-	return store;
-}
-function getMutationSlotStore(instance) {
-	let store = mutationSlotsByInstance.get(instance);
-	if (!store) {
-		store = /* @__PURE__ */ new Map();
-		mutationSlotsByInstance.set(instance, store);
-	}
-	return store;
-}
-function ensureQueryCleanup(instance) {
-	if (queryCleanupRegistered.has(instance)) return;
-	queryCleanupRegistered.add(instance);
-	instance.cleanupFns.push(() => {
-		const slots = querySlotsByInstance.get(instance);
-		if (!slots) {
-			queryCleanupRegistered.delete(instance);
-			return;
-		}
-		for (const [hookIndex, slot] of slots) slot.cell.detach(instance, hookIndex);
-		slots.clear();
-		querySlotsByInstance.delete(instance);
-		queryCleanupRegistered.delete(instance);
-	});
-}
-function ensureMutationCleanup(instance) {
-	if (mutationCleanupRegistered.has(instance)) return;
-	mutationCleanupRegistered.add(instance);
-	instance.cleanupFns.push(() => {
-		const slots = mutationSlotsByInstance.get(instance);
-		if (!slots) {
-			mutationCleanupRegistered.delete(instance);
-			return;
-		}
-		for (const cell of slots.values()) cell.abort();
-		slots.clear();
-		mutationSlotsByInstance.delete(instance);
-		mutationCleanupRegistered.delete(instance);
-	});
-}
-function notifySource(source) {
-	markReadableDerivedSubscribersDirty(source);
-	markReactivePropsDirtySource(source);
-	notifyReadableReaders(source);
-}
-function isAbortError(error, signal) {
-	return signal.aborted || error instanceof Error && error.name === "AbortError" || typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError";
-}
-function normalizeAsyncDataError(error, fallbackMessage) {
-	return error ?? new Error(fallbackMessage);
-}
-function invalidateQueries(prefix, markPendingWrite) {
-	emitInvalidation({
-		prefix,
-		markPendingWrite
-	});
-	const cache = getQueryCache();
-	for (const [key, query] of cache) {
-		if (!key.startsWith(prefix)) continue;
-		if (markPendingWrite) query.markPendingWrite();
-		query.refresh();
-	}
-}
-var QueryCell = class {
-	constructor(options, key, cache) {
-		this.source = createReadableSource();
-		this.controller = null;
-		this.generation = 0;
-		this.startQueued = false;
-		this.pendingRefresh = null;
-		this.pendingRefreshResolve = null;
-		this.reconcileAttemptCount = 0;
-		this.destroyed = false;
-		this.ownerCount = 0;
-		this.owners = /* @__PURE__ */ new Map();
-		this.warnedDefinitionConflictKeys = /* @__PURE__ */ new Set();
-		this.state = {
-			data: null,
-			error: null,
-			loading: true,
-			refreshing: false,
-			stale: false,
-			consistency: "fresh",
-			staleReason: null
-		};
-		this.options = options;
-		this.key = key;
-		this.cache = cache;
-	}
-	attach(instance, hookIndex) {
-		let hooks = this.owners.get(instance);
-		if (!hooks) {
-			hooks = /* @__PURE__ */ new Set();
-			this.owners.set(instance, hooks);
-		}
-		if (hooks.has(hookIndex)) return;
-		hooks.add(hookIndex);
-		this.ownerCount += 1;
-	}
-	detach(instance, hookIndex) {
-		const hooks = this.owners.get(instance);
-		if (!hooks || !hooks.delete(hookIndex)) return;
-		this.ownerCount -= 1;
-		if (hooks.size === 0) this.owners.delete(instance);
-		if (this.ownerCount <= 0) this.destroy();
-	}
-	warnOnConflictingDefinition(options) {
-		const conflicts = this.getDefinitionConflicts(options);
-		if (conflicts.length === 0) return;
-		const conflictKey = conflicts.join(",");
-		if (this.warnedDefinitionConflictKeys.has(conflictKey)) return;
-		this.warnedDefinitionConflictKeys.add(conflictKey);
-		const callbackLabel = conflicts.length === 1 ? `callback \`${conflicts[0]}\`` : `callbacks ${conflicts.map((field) => `\`${field}\``).join(", ")}`;
-		logger.warn(`[askr] Conflicting shared query definition for key "${this.key}". Shared queries are canonical by key, so reuse the same ${callbackLabel} for every reader of that key.`);
-	}
-	destroy() {
-		if (this.destroyed) return;
-		this.destroyed = true;
-		this.controller?.abort();
-		this.controller = null;
-		this.startQueued = false;
-		this.reconcileAttemptCount = 0;
-		this.ownerCount = 0;
-		this.owners.clear();
-		this.cache.delete(this.key);
-		this.finishPendingRefresh();
-	}
-	getDefinitionConflicts(options) {
-		const conflicts = [];
-		if (this.options.fetch !== options.fetch) conflicts.push("fetch");
-		if (this.options.isConsistent !== options.isConsistent) conflicts.push("isConsistent");
-		if (this.options.reconcile !== options.reconcile) conflicts.push("reconcile");
-		return conflicts;
-	}
-	get data() {
-		recordReadableRead(this.source);
-		return this.state.data;
-	}
-	get error() {
-		recordReadableRead(this.source);
-		return this.state.error;
-	}
-	get loading() {
-		recordReadableRead(this.source);
-		return this.state.loading;
-	}
-	get refreshing() {
-		recordReadableRead(this.source);
-		return this.state.refreshing;
-	}
-	get stale() {
-		recordReadableRead(this.source);
-		return this.state.stale;
-	}
-	get consistency() {
-		recordReadableRead(this.source);
-		return this.state.consistency;
-	}
-	get staleReason() {
-		recordReadableRead(this.source);
-		return this.state.staleReason;
-	}
-	ensureStarted() {
-		if (this.destroyed || this.state.data !== null || this.pendingRefresh || this.startQueued) return;
-		this.queueStart("initial");
-	}
-	refresh() {
-		if (this.destroyed) return Promise.resolve();
-		if (this.pendingRefresh) return this.pendingRefresh;
-		this.queueStart("manual");
-		return this.pendingRefresh ?? Promise.resolve();
-	}
-	markPendingWrite() {
-		if (this.destroyed) return;
-		if (this.state.data === null) return;
-		this.setState({
-			loading: false,
-			error: null,
-			refreshing: true,
-			stale: true,
-			consistency: "pending-write",
-			staleReason: null
-		});
-	}
-	queueStart(reason) {
-		if (this.destroyed) return;
-		this.startQueued = true;
-		this.pendingRefresh = new Promise((resolve) => {
-			this.pendingRefreshResolve = resolve;
-			globalScheduler.enqueue(() => {
-				this.startQueued = false;
-				if (this.destroyed) {
-					this.finishPendingRefresh();
-					return;
-				}
-				this.start(reason).finally(() => {
-					this.finishPendingRefresh();
-				});
-			});
-		});
-	}
-	finishPendingRefresh() {
-		const resolve = this.pendingRefreshResolve;
-		this.pendingRefresh = null;
-		this.pendingRefreshResolve = null;
-		resolve?.();
-	}
-	setState(next) {
-		if (this.destroyed) return;
-		this.state = {
-			...this.state,
-			...next
-		};
-		notifySource(this.source);
-	}
-	async start(reason) {
-		if (this.destroyed) return;
-		this.generation += 1;
-		const generation = this.generation;
-		this.controller?.abort();
-		const controller = new AbortController();
-		this.controller = controller;
-		const hasData = this.state.data !== null;
-		this.setState({
-			loading: !hasData,
-			refreshing: hasData,
-			stale: hasData,
-			consistency: reason === "pending-write" ? "pending-write" : hasData ? "refreshing" : "fresh",
-			error: null,
-			staleReason: null
-		});
-		let nextData;
-		try {
-			nextData = await this.options.fetch({ signal: controller.signal });
-		} catch (error) {
-			if (this.destroyed || this.generation !== generation || this.controller !== controller) return;
-			if (isAbortError(error, controller.signal)) {
-				this.setState(hasData ? {
-					loading: false,
-					refreshing: false,
-					stale: true,
-					consistency: "stale",
-					error: null,
-					staleReason: "aborted"
-				} : {
-					loading: true,
-					refreshing: false,
-					stale: false,
-					consistency: "fresh",
-					error: null,
-					staleReason: null
-				});
-				return;
-			}
-			this.setState({
-				loading: false,
-				refreshing: false,
-				stale: true,
-				consistency: "stale",
-				error: normalizeAsyncDataError(error, "Unknown query error"),
-				staleReason: "error"
-			});
-			return;
-		}
-		if (this.destroyed || this.generation !== generation || this.controller !== controller) return;
-		if (!(this.options.isConsistent?.(nextData) ?? true)) {
-			this.setState({
-				data: nextData,
-				loading: false,
-				refreshing: false,
-				stale: true,
-				consistency: "stale",
-				staleReason: "inconsistent"
-			});
-			await this.reconcile(nextData);
-			return;
-		}
-		this.reconcileAttemptCount = 0;
-		this.setState({
-			data: nextData,
-			loading: false,
-			refreshing: false,
-			stale: false,
-			consistency: "fresh",
-			error: null,
-			staleReason: null
-		});
-	}
-	async reconcile(data) {
-		if (!(this.options.reconcile?.(data, { key: this.options.key }) ?? false) || this.destroyed) return;
-		this.reconcileAttemptCount += 1;
-		if (this.reconcileAttemptCount > RECONCILE_MAX_ATTEMPTS) {
-			this.setState({
-				consistency: "stale",
-				refreshing: false,
-				staleReason: "inconsistent"
-			});
-			return;
-		}
-		await new Promise((resolve) => setTimeout(resolve, RECONCILE_RETRY_DELAY_MS));
-		if (this.destroyed || this.state.consistency === "fresh") return;
-		await this.refresh();
-	}
-};
-var MutationCell = class {
-	constructor(options) {
-		this.source = createReadableSource();
-		this.controller = null;
-		this.generation = 0;
-		this.state = {
-			status: "idle",
-			error: null,
-			result: null
-		};
-		this.action = options.action;
-		this.affects = options.affects;
-		this.afterSuccess = options.afterSuccess;
-	}
-	setOptions(options) {
-		this.action = options.action;
-		this.affects = options.affects;
-		this.afterSuccess = options.afterSuccess;
-	}
-	get status() {
-		recordReadableRead(this.source);
-		return this.state.status;
-	}
-	get pending() {
-		recordReadableRead(this.source);
-		return this.state.status === "pending";
-	}
-	get error() {
-		recordReadableRead(this.source);
-		return this.state.error;
-	}
-	get result() {
-		recordReadableRead(this.source);
-		return this.state.result;
-	}
-	setState(next) {
-		this.state = {
-			...this.state,
-			...next
-		};
-		notifySource(this.source);
-	}
-	async execute(input) {
-		this.generation += 1;
-		const generation = this.generation;
-		this.controller?.abort();
-		const controller = new AbortController();
-		this.controller = controller;
-		this.setState({
-			status: "pending",
-			error: null,
-			result: null
-		});
-		let result;
-		try {
-			result = await this.action(input, { signal: controller.signal });
-		} catch (error) {
-			if (this.generation !== generation || this.controller !== controller) throw error;
-			if (isAbortError(error, controller.signal)) {
-				this.setState({
-					status: "idle",
-					error: null
-				});
-				throw error;
-			}
-			this.setState({
-				status: "error",
-				error: normalizeAsyncDataError(error, "Unknown mutation error")
-			});
-			throw error;
-		}
-		if (this.generation !== generation || this.controller !== controller) return result;
-		this.setState({
-			status: "success",
-			error: null,
-			result
-		});
-		if (this.afterSuccess === "invalidate") {
-			const prefixes = this.affects?.(input, result) ?? [];
-			for (const prefix of new Set(prefixes)) invalidateQueries(prefix, true);
-		}
-		return result;
-	}
-	abort() {
-		if (this.state.status !== "pending") return;
-		this.generation += 1;
-		this.controller?.abort();
-		this.controller = null;
-		this.setState({
-			status: "idle",
-			error: null,
-			result: null
-		});
-	}
-	reset() {
-		this.generation += 1;
-		this.controller?.abort();
-		this.controller = null;
-		this.setState({
-			status: "idle",
-			error: null,
-			result: null
-		});
-	}
-};
-function createQuery(options) {
-	const instance = getCurrentComponentInstance();
-	const cache = getQueryCache();
-	if (!instance) {
-		let cell = cache.get(options.key);
-		if (!cell) {
-			cell = new QueryCell(options, options.key, cache);
-			cache.set(options.key, cell);
-			cell.ensureStarted();
-		} else cell.warnOnConflictingDefinition(options);
-		return cell;
-	}
-	const hookIndex = claimHookIndex(instance, "query");
-	ensureQueryCleanup(instance);
-	const slotStore = getQuerySlotStore(instance);
-	const existingSlot = slotStore.get(hookIndex);
-	if (existingSlot && existingSlot.key === options.key) {
-		existingSlot.cell.warnOnConflictingDefinition(options);
-		return existingSlot.cell;
-	}
-	if (existingSlot) existingSlot.cell.detach(instance, hookIndex);
-	let cell = cache.get(options.key);
-	if (!cell) {
-		cell = new QueryCell(options, options.key, cache);
-		cache.set(options.key, cell);
-		cell.ensureStarted();
-	} else cell.warnOnConflictingDefinition(options);
-	slotStore.set(hookIndex, {
-		key: options.key,
-		cell
-	});
-	cell.attach(instance, hookIndex);
-	return cell;
-}
-function invalidate(prefix, options) {
-	invalidateQueries(prefix, options?.markPendingWrite ?? false);
-}
-function serializeQueryKeyNumber(part) {
-	if (Number.isNaN(part)) return "NaN";
-	if (Object.is(part, -0)) return "-0";
-	if (part === Infinity) return "Infinity";
-	if (part === -Infinity) return "-Infinity";
-	return String(part);
-}
-function serializeQueryKeyPart(part) {
-	if (typeof part === "symbol") throw new Error("[Askr] queryScope() key parts cannot be symbols.");
-	if (part === null) return "null";
-	if (part === void 0) return "undefined";
-	switch (typeof part) {
-		case "string": return `s=${encodeURIComponent(part)}`;
-		case "number": return `n=${serializeQueryKeyNumber(part)}`;
-		case "boolean": return `b=${part ? "1" : "0"}`;
-		case "object":
-			if (Array.isArray(part)) return `a[${part.map((item) => serializeQueryKeyPart(item)).join(",")}]`;
-			return `o{${Object.keys(part).sort().map((key) => `${encodeURIComponent(key)}=${serializeQueryKeyPart(part[key])}`).join(",")}}`;
-		default: return String(part);
-	}
-}
-function queryScope(namespace) {
-	if (typeof namespace !== "string" || namespace.trim().length === 0) throw new Error("[Askr] queryScope() requires a non-empty namespace string.");
-	const build = (parts) => [namespace, ...parts].map(serializeQueryKeyPart).join(":") + ":";
-	return {
-		key(...parts) {
-			return build(parts);
-		},
-		prefix(...parts) {
-			return build(parts);
-		},
-		invalidate(parts, options) {
-			invalidate(build(parts), options);
-		}
-	};
-}
-const INVALIDATE_ON_INTERVAL_OPTIONS_ERROR = "[Askr] invalidateOnInterval() requires an options object with a finite numeric intervalMs.";
-function invalidateOnInterval(prefix, options) {
-	if (!options || typeof options !== "object" || typeof options.intervalMs !== "number" || !Number.isFinite(options.intervalMs)) throw new Error(INVALIDATE_ON_INTERVAL_OPTIONS_ERROR);
-	const when = [];
-	if (options.activeOn) when.push(routeActive(options.activeOn));
-	if (options.visibleOnly) when.push(documentVisible());
-	if (options.focusedOnly) when.push(windowFocused());
-	timer(options.intervalMs, () => {
-		invalidate(prefix, { markPendingWrite: options.markPendingWrite });
-	}, when.length > 0 ? { when } : void 0);
-}
-function createMutation(options) {
-	const instance = getCurrentComponentInstance();
-	if (!instance) return new MutationCell(options);
-	const hookIndex = claimHookIndex(instance, "mutation");
-	ensureMutationCleanup(instance);
-	const slotStore = getMutationSlotStore(instance);
-	const existing = slotStore.get(hookIndex);
-	if (existing) {
-		existing.setOptions(options);
-		return existing;
-	}
-	const created = new MutationCell(options);
-	slotStore.set(hookIndex, created);
-	return created;
-}
-//#endregion
-export { createMutation, createQuery, invalidate, invalidateOnInterval, queryScope };
-
-//# sourceMappingURL=index.js.map
+import { createDataRuntime, getDefaultDataRuntime } from "./data-runtime.js";
+import { invalidate, invalidateOnInterval, queryScope } from "./invalidation.js";
+import { createMutation } from "./mutation-cell.js";
+import { createQuery } from "./query-cell.js";
+export { createDataRuntime, createMutation, createQuery, getDefaultDataRuntime, invalidate, invalidateOnInterval, queryScope };

package/dist/data/invalidation.d.ts

@@ -0,0 +1,9 @@
+import { InvalidateOnIntervalOptions, InvalidateOptions, QueryScope } from "./types.js";
+
+//#region src/data/invalidation.d.ts
+declare function invalidate(prefix: string, options?: InvalidateOptions): void;
+declare function queryScope(namespace: string): QueryScope;
+declare function invalidateOnInterval(prefix: string, options: InvalidateOnIntervalOptions): void;
+//#endregion
+export { invalidate, invalidateOnInterval, queryScope };
+//# sourceMappingURL=invalidation.d.ts.map

package/dist/data/invalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidation.d.ts","names":[],"sources":["../../src/data/invalidation.ts"],"mappings":";;;iBAkBgB,UAAA,CAAW,MAAA,UAAgB,OAAA,GAAU,iBAAiB;AAAA,iBAQtD,UAAA,CAAW,SAAA,WAAoB,UAAU;AAAA,iBAOzC,oBAAA,CACd,MAAA,UACA,OAAA,EAAS,2BAA2B"}

package/dist/data/invalidation.js

@@ -0,0 +1,27 @@
+import { invalidateQueriesForRuntime, resolveDataRuntimeState } from "./data-runtime.js";
+import { documentVisible, routeActive, timer, windowFocused } from "../runtime/lifecycle-operations.js";
+import "../runtime/operations.js";
+import { createQueryScope } from "./query-key.js";
+//#region src/data/invalidation.ts
+function invalidate(prefix, options) {
+	invalidateQueriesForRuntime(resolveDataRuntimeState(options?.runtime), prefix, options?.markPendingWrite ?? false);
+}
+function queryScope(namespace) {
+	return createQueryScope(namespace, invalidate);
+}
+const INVALIDATE_ON_INTERVAL_OPTIONS_ERROR = "[Askr] invalidateOnInterval() requires an options object with a finite numeric intervalMs.";
+function invalidateOnInterval(prefix, options) {
+	if (!options || typeof options !== "object" || typeof options.intervalMs !== "number" || !Number.isFinite(options.intervalMs)) throw new Error(INVALIDATE_ON_INTERVAL_OPTIONS_ERROR);
+	const runtimeState = resolveDataRuntimeState(options.runtime);
+	const when = [];
+	if (options.activeOn) when.push(routeActive(options.activeOn));
+	if (options.visibleOnly) when.push(documentVisible());
+	if (options.focusedOnly) when.push(windowFocused());
+	timer(options.intervalMs, () => {
+		invalidateQueriesForRuntime(runtimeState, prefix, options.markPendingWrite ?? false);
+	}, when.length > 0 ? { when } : void 0);
+}
+//#endregion
+export { invalidate, invalidateOnInterval, queryScope };
+
+//# sourceMappingURL=invalidation.js.map

package/dist/data/invalidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidation.js","names":[],"sources":["../../src/data/invalidation.ts"],"sourcesContent":["import {\n  documentVisible,\n  routeActive,\n  timer,\n  windowFocused,\n  type ActivityPredicate,\n} from '../runtime/operations';\nimport {\n  invalidateQueriesForRuntime,\n  resolveDataRuntimeState,\n} from './data-runtime';\nimport { createQueryScope } from './query-key';\nimport type {\n  InvalidateOnIntervalOptions,\n  InvalidateOptions,\n  QueryScope,\n} from './types';\n\nexport function invalidate(prefix: string, options?: InvalidateOptions): void {\n  invalidateQueriesForRuntime(\n    resolveDataRuntimeState(options?.runtime),\n    prefix,\n    options?.markPendingWrite ?? false\n  );\n}\n\nexport function queryScope(namespace: string): QueryScope {\n  return createQueryScope(namespace, invalidate);\n}\n\nconst INVALIDATE_ON_INTERVAL_OPTIONS_ERROR =\n  '[Askr] invalidateOnInterval() requires an options object with a finite numeric intervalMs.';\n\nexport function invalidateOnInterval(\n  prefix: string,\n  options: InvalidateOnIntervalOptions\n): void {\n  if (\n    !options ||\n    typeof options !== 'object' ||\n    typeof options.intervalMs !== 'number' ||\n    !Number.isFinite(options.intervalMs)\n  ) {\n    throw new Error(INVALIDATE_ON_INTERVAL_OPTIONS_ERROR);\n  }\n\n  const runtimeState = resolveDataRuntimeState(options.runtime);\n  const when: ActivityPredicate[] = [];\n\n  if (options.activeOn) {\n    when.push(routeActive(options.activeOn));\n  }\n\n  if (options.visibleOnly) {\n    when.push(documentVisible());\n  }\n\n  if (options.focusedOnly) {\n    when.push(windowFocused());\n  }\n\n  timer(\n    options.intervalMs,\n    () => {\n      invalidateQueriesForRuntime(\n        runtimeState,\n        prefix,\n        options.markPendingWrite ?? false\n      );\n    },\n    when.length > 0 ? { when } : undefined\n  );\n}\n"],"mappings":";;;;;AAkBA,SAAgB,WAAW,QAAgB,SAAmC;CAC5E,4BACE,wBAAwB,SAAS,OAAO,GACxC,QACA,SAAS,oBAAoB,KAC/B;AACF;AAEA,SAAgB,WAAW,WAA+B;CACxD,OAAO,iBAAiB,WAAW,UAAU;AAC/C;AAEA,MAAM,uCACJ;AAEF,SAAgB,qBACd,QACA,SACM;CACN,IACE,CAAC,WACD,OAAO,YAAY,YACnB,OAAO,QAAQ,eAAe,YAC9B,CAAC,OAAO,SAAS,QAAQ,UAAU,GAEnC,MAAM,IAAI,MAAM,oCAAoC;CAGtD,MAAM,eAAe,wBAAwB,QAAQ,OAAO;CAC5D,MAAM,OAA4B,CAAC;CAEnC,IAAI,QAAQ,UACV,KAAK,KAAK,YAAY,QAAQ,QAAQ,CAAC;CAGzC,IAAI,QAAQ,aACV,KAAK,KAAK,gBAAgB,CAAC;CAG7B,IAAI,QAAQ,aACV,KAAK,KAAK,cAAc,CAAC;CAG3B,MACE,QAAQ,kBACF;EACJ,4BACE,cACA,QACA,QAAQ,oBAAoB,KAC9B;CACF,GACA,KAAK,SAAS,IAAI,EAAE,KAAK,IAAI,MAC/B;AACF"}

package/dist/data/mutation-cell.d.ts

@@ -0,0 +1,28 @@
+import { Mutation, MutationOptions } from "./types.js";
+import { DataRuntimeState } from "./data-runtime.js";
+
+//#region src/data/mutation-cell.d.ts
+declare class MutationCell<TInput, TResult> {
+  private readonly source;
+  private readonly runtimeState;
+  private action;
+  private affects?;
+  private afterSuccess?;
+  private controller;
+  private generation;
+  private state;
+  constructor(options: MutationOptions<TInput, TResult>, runtimeState: DataRuntimeState);
+  setOptions(options: MutationOptions<TInput, TResult>): void;
+  get status(): 'idle' | 'pending' | 'success' | 'error';
+  get pending(): boolean;
+  get error(): {} | null;
+  get result(): TResult | null;
+  private setState;
+  execute(input: TInput): Promise<TResult>;
+  abort(): void;
+  reset(): void;
+}
+declare function createMutation<TInput, TResult>(options: MutationOptions<TInput, TResult>): Mutation<TInput, TResult>;
+//#endregion
+export { MutationCell, createMutation };
+//# sourceMappingURL=mutation-cell.d.ts.map

package/dist/data/mutation-cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-cell.d.ts","names":[],"sources":["../../src/data/mutation-cell.ts"],"mappings":";;;;cAoBa,YAAA;EAAA,iBACM,MAAA;EAAA,iBACA,YAAA;EAAA,QACT,MAAA;EAAA,QACA,OAAA;EAAA,QACA,YAAA;EAAA,QACA,UAAA;EAAA,QACA,UAAA;EAAA,QAEA,KAAA;cAON,OAAA,EAAS,eAAA,CAAgB,MAAA,EAAQ,OAAA,GACjC,YAAA,EAAc,gBAAA;EAQhB,UAAA,CAAW,OAAA,EAAS,eAAA,CAAgB,MAAA,EAAQ,OAAA;EAAA,IAMxC,MAAA;EAAA,IAKA,OAAA;EAAA,IAKA,KAAA;EAAA,IAKA,MAAA,IAAU,OAAA;EAAA,QAKN,QAAA;EAQF,OAAA,CAAQ,KAAA,EAAO,MAAA,GAAS,OAAA,CAAQ,OAAA;EA8CtC,KAAA;EAWA,KAAA;AAAA;AAAA,iBAQc,cAAA,kBACd,OAAA,EAAS,eAAA,CAAgB,MAAA,EAAQ,OAAA,IAChC,QAAA,CAAS,MAAA,EAAQ,OAAA"}