@askrjs/askr 0.0.52 → 0.0.53

package/dist/data/mutation-cell.js

@@ -1,133 +0,0 @@
-import { recordReadableRead } from "../runtime/readable.js";
-import { claimHookIndex, getCurrentComponentInstance } from "../runtime/component-scope.js";
-import "../runtime/index.js";
-import { ensureMutationCleanup, getMutationSlotStore, invalidateQueriesForRuntime, resolveDataRuntimeState } from "./data-runtime.js";
-import { createReadableSource, isAbortError, normalizeAsyncDataError, notifySource } from "./shared.js";
-//#region src/data/mutation-cell.ts
-var MutationCell = class {
-	constructor(options, runtimeState) {
-		this.source = createReadableSource();
-		this.controller = null;
-		this.generation = 0;
-		this.state = {
-			status: "idle",
-			error: null,
-			result: null
-		};
-		this.runtimeState = runtimeState;
-		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) {
-		const action = this.action;
-		const affects = this.affects;
-		const afterSuccess = this.afterSuccess;
-		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 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 (afterSuccess === "invalidate") {
-			const prefixes = affects?.(input, result) ?? [];
-			for (const prefix of new Set(prefixes)) invalidateQueriesForRuntime(this.runtimeState, 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 createMutation(options) {
-	const instance = getCurrentComponentInstance();
-	const runtimeState = resolveDataRuntimeState(options.runtime);
-	if (!instance) return new MutationCell(options, runtimeState);
-	const hookIndex = claimHookIndex(instance, "mutation");
-	ensureMutationCleanup(runtimeState, instance);
-	const slotStore = getMutationSlotStore(runtimeState, instance);
-	const existing = slotStore.get(hookIndex);
-	if (existing) {
-		existing.setOptions(options);
-		return existing;
-	}
-	const created = new MutationCell(options, runtimeState);
-	slotStore.set(hookIndex, created);
-	return created;
-}
-//#endregion
-export { MutationCell, createMutation };

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

@@ -1,47 +0,0 @@
-import { ComponentInstance } from "../runtime/component-internal.js";
-import { Query, QueryOptions, QueryState } from "./types.js";
-
-//#region src/data/query-cell.d.ts
-declare class QueryCell<T> {
-  private readonly source;
-  private readonly key;
-  private readonly cache;
-  private options;
-  private controller;
-  private generation;
-  private startQueued;
-  private pendingRefresh;
-  private pendingRefreshResolve;
-  private pendingRefreshToken;
-  private reconcileAttemptCount;
-  private destroyed;
-  private ownerCount;
-  private readonly owners;
-  private readonly warnedDefinitionConflictKeys;
-  private state;
-  constructor(options: QueryOptions<T>, key: string, cache: Map<string, QueryCell<unknown>>);
-  attach(instance: ComponentInstance, hookIndex: number): void;
-  detach(instance: ComponentInstance, hookIndex: number): void;
-  warnOnConflictingDefinition(options: QueryOptions<T>): void;
-  private destroy;
-  private getDefinitionConflicts;
-  get data(): T | null;
-  get error(): {} | null;
-  get loading(): boolean;
-  get refreshing(): boolean;
-  get stale(): boolean;
-  get consistency(): QueryState<T>['consistency'];
-  get staleReason(): QueryState<T>['staleReason'];
-  ensureStarted(): void;
-  refresh(): Promise<void>;
-  invalidate(): void;
-  markPendingWrite(): void;
-  private queueStart;
-  private finishPendingRefresh;
-  private setState;
-  private start;
-  private reconcile;
-}
-declare function createQuery<T extends {}>(options: QueryOptions<T>): Query<T>;
-//#endregion
-export { QueryCell, createQuery };

package/dist/data/query-cell.js

@@ -1,324 +0,0 @@
-import { logger } from "../common/logger.js";
-import { enqueueRuntimeTask } from "../runtime/access.js";
-import { recordReadableRead } from "../runtime/readable.js";
-import { claimHookIndex, getCurrentComponentInstance } from "../runtime/component-scope.js";
-import "../runtime/index.js";
-import { ensureQueryCleanup, getQuerySlotStore, resolveDataRuntimeState } from "./data-runtime.js";
-import { createReadableSource, isAbortError, normalizeAsyncDataError, notifySource } from "./shared.js";
-//#region src/data/query-cell.ts
-const RECONCILE_MAX_ATTEMPTS = 3;
-const RECONCILE_RETRY_DELAY_MS = 25;
-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.pendingRefreshToken = 0;
-		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();
-	}
-	invalidate() {
-		if (this.destroyed) return;
-		if (this.pendingRefresh) {
-			this.controller?.abort();
-			this.finishPendingRefresh(this.pendingRefreshToken);
-		}
-		this.queueStart("invalidate");
-	}
-	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;
-		const token = ++this.pendingRefreshToken;
-		this.pendingRefresh = new Promise((resolve) => {
-			this.pendingRefreshResolve = resolve;
-			enqueueRuntimeTask(() => {
-				this.startQueued = false;
-				if (this.destroyed) {
-					this.finishPendingRefresh(token);
-					return;
-				}
-				this.start(reason).finally(() => {
-					this.finishPendingRefresh(token);
-				});
-			});
-		});
-	}
-	finishPendingRefresh(token = this.pendingRefreshToken) {
-		if (token !== this.pendingRefreshToken) return;
-		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;
-		let isConsistent;
-		try {
-			isConsistent = this.options.isConsistent?.(nextData) ?? true;
-		} catch (error) {
-			this.setState({
-				loading: false,
-				refreshing: false,
-				stale: true,
-				consistency: "stale",
-				error: normalizeAsyncDataError(error, "Query consistency check failed"),
-				staleReason: "error"
-			});
-			return;
-		}
-		if (!isConsistent) {
-			this.setState({
-				data: nextData,
-				loading: false,
-				refreshing: false,
-				stale: true,
-				consistency: "stale",
-				staleReason: "inconsistent"
-			});
-			try {
-				await this.reconcile(nextData);
-			} catch (error) {
-				if (this.generation === generation && this.controller === controller) this.setState({
-					loading: false,
-					refreshing: false,
-					stale: true,
-					consistency: "stale",
-					error: normalizeAsyncDataError(error, "Query reconciliation failed"),
-					staleReason: "error"
-				});
-			}
-			return;
-		}
-		this.reconcileAttemptCount = 0;
-		this.setState({
-			data: nextData,
-			loading: false,
-			refreshing: false,
-			stale: false,
-			consistency: "fresh",
-			error: null,
-			staleReason: null
-		});
-	}
-	async reconcile(data) {
-		if (!await (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;
-		this.invalidate();
-	}
-};
-function createQuery(options) {
-	const instance = getCurrentComponentInstance();
-	const runtimeState = resolveDataRuntimeState(options.runtime);
-	const cache = runtimeState.queryCache;
-	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(runtimeState, instance);
-	const slotStore = getQuerySlotStore(runtimeState, 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;
-}
-//#endregion
-export { QueryCell, createQuery };

package/dist/data/query-key.js

@@ -1,40 +0,0 @@
-//#region src/data/query-key.ts
-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(",")}]`;
-			const objectPart = part;
-			return `o{${Object.keys(objectPart).sort().map((key) => `${encodeURIComponent(key)}=${serializeQueryKeyPart(objectPart[key])}`).join(",")}}`;
-		default: return String(part);
-	}
-}
-function createQueryScope(namespace, invalidate) {
-	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);
-		}
-	};
-}
-//#endregion
-export { createQueryScope };

package/dist/data/shared.js

@@ -1,20 +0,0 @@
-import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders } from "../runtime/readable.js";
-import "../runtime/index.js";
-//#region src/data/shared.ts
-function createReadableSource() {
-	return (() => void 0);
-}
-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) {
-	if (error instanceof Error) return error;
-	return new Error(error == null ? fallbackMessage : String(error));
-}
-//#endregion
-export { createReadableSource, isAbortError, normalizeAsyncDataError, notifySource };

package/dist/data/testing.js

@@ -1,2 +0,0 @@
-import { addInvalidationListener } from "./invalidation-listeners.js";
-export { addInvalidationListener };