ilha 0.10.1 → 0.10.2

package/dist/index.js

@@ -1077,6 +1077,77 @@ function buildDerivedAccessors(envelopes) {
 		return accessors.get(key) ?? defaultDerivedAccessor();
 	} });
 }
+const ILHA_QUERY = Symbol.for("ilha.store.query");
+const ILHA_QUERY_RUN = Symbol.for("ilha.store.query.run");
+const ILHA_QUERY_PENDING = Symbol.for("ilha.store.query.pending");
+const ILHA_QUERY_STACK = Symbol.for("ilha.store.query.stack");
+function queryCaptureStack() {
+	const g = globalThis;
+	let stack = g[ILHA_QUERY_STACK];
+	if (!stack) {
+		stack = [];
+		g[ILHA_QUERY_STACK] = stack;
+	}
+	return stack;
+}
+function isQueryCall(value) {
+	return value !== null && typeof value === "object" && ILHA_QUERY in value;
+}
+function resolveQueryCall(result, captureSlot) {
+	const pending = globalThis[ILHA_QUERY_PENDING];
+	globalThis[ILHA_QUERY_PENDING] = void 0;
+	return captureSlot.queryCall ?? pending ?? (isQueryCall(result) ? result : void 0);
+}
+function runBrandedQuery(queryCall, abortSignal, env) {
+	const writeEnv = (next) => {
+		if (abortSignal.aborted) return;
+		const prevSub = setActiveSub(void 0);
+		env(next);
+		setActiveSub(prevSub);
+	};
+	const run = queryCall[ILHA_QUERY_RUN];
+	if (typeof run !== "function") {
+		writeEnv({
+			loading: false,
+			value: void 0,
+			error: /* @__PURE__ */ new Error("[@ilha] branded query is missing a callable runner")
+		});
+		return;
+	}
+	try {
+		run.call(queryCall, abortSignal, {
+			onResult: (value) => {
+				writeEnv({
+					loading: false,
+					value,
+					error: void 0
+				});
+			},
+			onError: (err) => {
+				writeEnv({
+					loading: false,
+					value: void 0,
+					error: err
+				});
+			},
+			onFetchStart: () => {
+				const prevSub = setActiveSub(void 0);
+				env({
+					loading: true,
+					value: env().value,
+					error: void 0
+				});
+				setActiveSub(prevSub);
+			}
+		});
+	} catch (err) {
+		writeEnv({
+			loading: false,
+			value: void 0,
+			error: err instanceof Error ? err : new Error(String(err))
+		});
+	}
+}
 function createDerivedProxy({ entries, state, input, derivedSnapshot }) {
 	const envelopes = /* @__PURE__ */ new Map();
 	for (const entry of entries) {
@@ -1084,13 +1155,22 @@ function createDerivedProxy({ entries, state, input, derivedSnapshot }) {
 		if (derivedSnapshot != null && entry.key in derivedSnapshot) initialEnvelope = { ...derivedSnapshot[entry.key] };
 		else if (!(entry.fn.constructor.name === "AsyncFunction" || entry.fn.constructor.name === "AsyncGeneratorFunction")) {
 			const ac = new AbortController();
+			const captureSlot = {};
+			const stack = queryCaptureStack();
+			globalThis[ILHA_QUERY_PENDING] = void 0;
+			stack.push(captureSlot);
 			try {
 				const result = entry.fn({
 					state,
 					input,
 					signal: ac.signal
 				});
-				if (!(result instanceof Promise)) initialEnvelope = {
+				if (resolveQueryCall(result, captureSlot)) initialEnvelope = {
+					loading: true,
+					value: void 0,
+					error: void 0
+				};
+				else if (!(result instanceof Promise)) initialEnvelope = {
 					loading: false,
 					value: result,
 					error: void 0
@@ -1104,12 +1184,14 @@ function createDerivedProxy({ entries, state, input, derivedSnapshot }) {
 					result.catch(() => {});
 				}
 			} catch (err) {
+				globalThis[ILHA_QUERY_PENDING] = void 0;
 				initialEnvelope = {
 					loading: false,
 					value: void 0,
 					error: err instanceof Error ? err : new Error(String(err))
 				};
 			} finally {
+				stack.pop();
 				ac.abort();
 			}
 		} else initialEnvelope = {
@@ -1148,6 +1230,10 @@ function createDerivedProxy({ entries, state, input, derivedSnapshot }) {
 				ac = new AbortController();
 				const currentAc = ac;
 				let result;
+				const captureSlot = {};
+				const stack = queryCaptureStack();
+				globalThis[ILHA_QUERY_PENDING] = void 0;
+				stack.push(captureSlot);
 				try {
 					result = entry.fn({
 						state,
@@ -1155,6 +1241,7 @@ function createDerivedProxy({ entries, state, input, derivedSnapshot }) {
 						signal: currentAc.signal
 					});
 				} catch (err) {
+					globalThis[ILHA_QUERY_PENDING] = void 0;
 					if (skipFirst) {
 						skipFirst = false;
 						return;
@@ -1167,12 +1254,19 @@ function createDerivedProxy({ entries, state, input, derivedSnapshot }) {
 					});
 					setActiveSub(prevSub);
 					return;
+				} finally {
+					stack.pop();
 				}
+				const queryCall = resolveQueryCall(result, captureSlot);
 				if (skipFirst) {
 					skipFirst = false;
 					if (result instanceof Promise) result.catch(() => {});
 					return;
 				}
+				if (queryCall) {
+					runBrandedQuery(queryCall, currentAc.signal, env);
+					return;
+				}
 				if (!(result instanceof Promise)) {
 					const prevSub = setActiveSub(void 0);
 					env({
@@ -1193,6 +1287,16 @@ function createDerivedProxy({ entries, state, input, derivedSnapshot }) {
 				setActiveSub(prevSub);
 				result.then((value) => {
 					if (currentAc.signal.aborted) return;
+					if (isQueryCall(value)) {
+						runBrandedQuery(value, currentAc.signal, env);
+						return;
+					}
+					const latePending = globalThis[ILHA_QUERY_PENDING];
+					globalThis[ILHA_QUERY_PENDING] = void 0;
+					if (latePending) {
+						runBrandedQuery(latePending, currentAc.signal, env);
+						return;
+					}
 					env({
 						loading: false,
 						value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilha",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "A tiny, framework-free island architecture library",
   "keywords": [
     "framework-free",