@plitzi/sdk-shared 0.35.10 → 0.36.1

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @plitzi/sdk-shared
 
+## 0.36.1
+
+### Patch Changes
+
+- v0.36.1
+
+## 0.36.0
+
+### Minor Changes
+
+- - **An `apiContainer` can keep its browser requests in a query cache, the way react-query does.** Moving between
+    sections or pages used to ask the API again every time a provider was shown: a provider in a hidden section is
+    mounted but disabled, so showing it fired a fresh request, and a page navigation remounted it and did the same.
+    With the new `cache: true` an answer is kept for `staleTime` seconds (30 by default) and shared by every cached
+    provider asking the same thing — same method, URL, credentials and headers, the token included, so two visitors
+    never share one. Past its time the answer is still drawn at once and a fresh one is fetched behind it; an answer
+    nobody shows is forgotten after `gcTime` seconds (300 by default). A refused request (`4xx`/`5xx`) is shown but
+    never kept. **The cache is off unless an element asks for it**: an uncached provider behaves as before, asking on
+    every mount and sharing nothing.
+
+    The cache is `@plitzi/sdk-shared/queries` (`queryCache`, `useQuery`, `invalidateQueries`,
+    `invalidateQueriesForWrite`), a nexus store written with the per-path `ttl` of `@plitzi/nexus` 1.2.0, which every
+    consumer now requires. It reacts to the store's own freshness events, so anything that expires a query's path
+    makes the providers on screen ask again.
+
+    An answer stops counting as current before its time when the element's `performQuery` runs (it always asks
+    again), when a flow runs the new global `invalidateQueries` step (source `queries`: `elements`, api container ids
+    — a container's requests are tagged with its own id — and/or a `url` prefix), and after a write. Both write steps
+    gained `invalidateQueries` / `invalidateElements`: a `webHook` sent with anything but `GET`/`HEAD` refreshes the
+    requests to its own site by default, a completed `runServerAction` refreshes all of them by default, and either
+    can name containers instead or refresh nothing. A `writeRecord` refreshes all. Providers on screen ask again at
+    once; the rest when they are next shown. A sign-in, sign-out or change of account drops everything held. Server-driven
+    providers and RSC are untouched.
+
+  - **A `webHook` that reads can be cached** (`cache`, `staleTime`), in the same cache and under the same key as an api
+    container asking the same thing. Its declaration now lives beside it (`utility/webHookSpec`) and the authoring
+    catalog gathers it instead of keeping a copy. A `HEAD` is no longer sent with a body, which `fetch` refused.
+
+  - **Step params can pick several elements.** A new param type, `elementIds` (with an `elementType` filter), is drawn
+    in the flow editor as a picker: the matching elements of the space to add, and the picked ones as chips to remove —
+    an id no element answers to any more is kept and flagged. The value is a list of ids, so nobody types a
+    comma-separated list; `invalidateQueries.elements` and the write steps' `invalidateElements` use it, and the MCP
+    catalog says which element type each such param takes.
+
+  - The dev-tools' Store tab lists the paths a store holds with a TTL — how long ago each was written, what is left
+    of it, and a button to expire one or all of them. The query cache appears there as "Queries".
+
+  - `useApi` no longer takes `params`: nothing passed them, and a GET cannot carry a body anyway. A mock now answers
+    synchronously, without a loading frame, and a provider whose URL has not resolved asks for nothing.
+
 ## 0.35.10
 
 ### Patch Changes

package/dist/authoring/builder.mjs

@@ -5,7 +5,8 @@ var e = {
 	select: "select",
 	boolean: "boolean",
 	number: "text",
-	scalar: "text"
+	scalar: "text",
+	elementIds: "elements"
 }, t = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[-_\s]+/).map((e) => `${e.charAt(0).toUpperCase()}${e.slice(1)}`).join(" "), n = (n, r) => ({
 	type: r.builderType ?? e[r.type],
 	label: r.label ?? t(n),
@@ -15,7 +16,8 @@ var e = {
 		label: r.optionLabels?.[e] ?? t(e)
 	})) } : {},
 	...r.when ? { when: r.when } : {},
-	...r.canBind === void 0 ? {} : { canBind: r.canBind }
+	...r.canBind === void 0 ? {} : { canBind: r.canBind },
+	...r.elementType === void 0 ? {} : { elementType: r.elementType }
 }), r = (e) => Object.fromEntries(Object.entries(e).map(([e, t]) => [e, n(e, t)])), i = (e, t, n, i = {}) => ({
 	action: e,
 	title: t.title,

package/dist/authoring/paramSpec.d.ts

@@ -1,9 +1,9 @@
 import { InteractionParamType } from '../types';
-export type BuiltinParamType = 'text' | 'textarea' | 'select' | 'boolean' | 'number' | 'scalar';
+export type BuiltinParamType = 'text' | 'textarea' | 'select' | 'boolean' | 'number' | 'scalar' | 'elementIds';
 export interface BuiltinParam {
     type: BuiltinParamType;
     description: string;
-    default?: string | number | boolean;
+    default?: string | number | boolean | string[];
     options?: string[];
     when?: (params: Record<string, unknown>) => boolean;
     required?: boolean;
@@ -18,6 +18,8 @@ export interface BuiltinParam {
     builderType?: InteractionParamType | ((params: Record<string, unknown>) => InteractionParamType);
     /** Whether the editor offers to bind this param to a data source. Bindable unless a param says otherwise. */
     canBind?: boolean;
+    /** For `elementIds`: the element type the editor offers (e.g. `apiContainer`); every element without one. */
+    elementType?: string;
 }
 export type ParamSpec = Record<string, BuiltinParam>;
 /** Declared params the agent supplied that end up HIDDEN because their own `when` guard is false against the

package/dist/authoring/paramSpec.mjs

@@ -16,6 +16,7 @@ var t = (e, t, n) => {
 		case "scalar": return typeof e == "string" || typeof e == "number" || typeof e == "boolean";
 		case "text":
 		case "textarea": return typeof e == "string";
+		case "elementIds": return Array.isArray(e) && e.every((e) => typeof e == "string");
 		default: return !0;
 	}
 }, o = (e, t, n) => {

package/dist/queries/index.d.ts

@@ -0,0 +1,56 @@
+import { default as queryCache, QueryMeta } from './queryCache';
+export { QueryCache, GC_TIME, queryId, queryPath } from './queryCache';
+export { default as useQuery } from './useQuery';
+export type { QueriesState, QueryEntry, QueryMeta, QueryObserverOptions } from './queryCache';
+export type { UseQueryOptions, UseQueryResult } from './useQuery';
+/**
+ * Every query that could have read what `url` just wrote: the ones on the same origin.
+ *
+ * The origin, not the path: `POST /api/cart/items` changes what `GET /api/cart` answers, and no path rule tells
+ * those apart from two unrelated resources. Another origin is another backend, and nothing it writes shows up here.
+ */
+export declare const invalidateQueriesForWrite: (url: string) => Promise<void>;
+/** Ids written as a step writes them — `orders, members` — into a list, blanks dropped. */
+export declare const parseIds: (value: unknown) => string[];
+/** What an invalidation picks: requests whose URL starts with `url`, and/or the ones the named elements made. */
+export type QuerySelector = {
+    url?: string;
+    elements?: readonly string[];
+};
+/**
+ * The queries a selector picks — every one of them for an empty selector. Both parts must hold when both are given.
+ *
+ * The URL is compared resolved, so `/api/orders` matches the `https://host/api/orders?page=2` a provider asked for.
+ * An element is named by its id, which is the tag its requests carry: the way to reach a request whose URL is a
+ * template nobody can write down.
+ */
+export declare const matchesQuery: ({ url, elements }: QuerySelector) => (meta: QueryMeta) => boolean;
+/** The `invalidateQueries` step, and anything else that knows which data changed. */
+export declare const invalidateQueries: (selector?: QuerySelector) => Promise<void>;
+/**
+ * One key for one request, whoever makes it — an api container and a webhook step asking the same thing share the
+ * answer. The headers carry the visitor's token, so two visitors never share one; sorted, so the order somebody
+ * typed them in does not split one; and without `Content-Type`, which says how a body is written, not what comes back.
+ */
+export declare const requestKey: ({ method, url, credentials, headers }: {
+    method: string;
+    url: string;
+    credentials: string;
+    headers: Record<string, string>;
+}) => string;
+export { queryCache };
+/** What a write step refreshes when it succeeds. `origin` needs the URL the write went to. */
+export type WriteInvalidation = 'origin' | 'all' | 'elements' | 'none';
+/**
+ * The refresh a write step asked for, once it succeeded.
+ *
+ * `elements` with no ids refreshes nothing: an author who picked "these containers" and named none did not mean all
+ * of them. A mode nobody recognises is treated as the caller's default rather than as `none`, so a typo still
+ * refreshes the page instead of leaving it showing data from before the write.
+ */
+export declare const invalidateAfterWrite: ({ mode, fallback, elements, url }: {
+    mode: unknown;
+    fallback: WriteInvalidation;
+    elements?: unknown;
+    url?: string;
+}) => Promise<void>;

package/dist/queries/index.mjs

@@ -0,0 +1,37 @@
+import e, { GC_TIME as t, QueryCache as n, queryId as r, queryPath as i } from "./queryCache.mjs";
+import a from "./useQuery.mjs";
+//#region src/queries/index.ts
+var o = () => typeof location > "u" ? void 0 : location.href, s = (e) => {
+	try {
+		return new URL(e, o()).origin;
+	} catch {
+		return;
+	}
+}, c = (t) => {
+	let n = s(t);
+	return n ? e.invalidate((e) => s(e.url) === n) : Promise.resolve();
+}, l = (e) => Array.isArray(e) ? e.filter((e) => typeof e == "string" && e.trim() !== "").map((e) => e.trim()) : typeof e == "string" ? e.split(",").map((e) => e.trim()).filter(Boolean) : [], u = (e) => {
+	try {
+		return new URL(e, o()).href;
+	} catch {
+		return e;
+	}
+}, d = ({ url: e, elements: t }) => {
+	let n = e ? u(e) : void 0;
+	return (e) => (n === void 0 || u(e.url).startsWith(n)) && (!t?.length || t.some((t) => e.tags?.includes(t) ?? !1));
+}, f = (t = {}) => t.url || t.elements?.length ? e.invalidate(d(t)) : e.invalidate(), p = ({ method: e, url: t, credentials: n, headers: r }) => JSON.stringify([
+	e.toLowerCase(),
+	t,
+	n,
+	Object.entries(r).filter(([e]) => e.toLowerCase() !== "content-type").sort(([e], [t]) => e < t ? -1 : +(e > t))
+]), m = ({ mode: e, fallback: t, elements: n, url: r }) => {
+	let i = e === "origin" || e === "all" || e === "elements" || e === "none" ? e : t;
+	if (i === "none") return Promise.resolve();
+	if (i === "elements") {
+		let e = l(n);
+		return e.length > 0 ? f({ elements: e }) : Promise.resolve();
+	}
+	return i === "origin" && r ? c(r) : f();
+};
+//#endregion
+export { t as GC_TIME, n as QueryCache, m as invalidateAfterWrite, f as invalidateQueries, c as invalidateQueriesForWrite, d as matchesQuery, l as parseIds, e as queryCache, r as queryId, i as queryPath, p as requestKey, a as useQuery };

package/dist/queries/queryCache.d.ts

@@ -0,0 +1,116 @@
+import { StoreApi } from '@plitzi/nexus';
+/** How long, by default, an answer nobody is rendering is kept, so coming back within it still paints at once. */
+export declare const GC_TIME: number;
+/**
+ * What a query is about, for the invalidations that pick queries by what they read rather than by key: the URL it
+ * asks, and the names its author gave it — the way to invalidate a request whose URL is a template.
+ */
+export type QueryMeta = {
+    url: string;
+    tags?: readonly string[];
+};
+/** One query as the store holds it: what a hook renders from and what the dev-tools show. */
+export type QueryEntry = {
+    key: string;
+    url: string;
+    /** Every tag anybody asking this query gave it. */
+    tags: string[];
+    data?: unknown;
+    error?: unknown;
+    isFetching: boolean;
+};
+export type QueriesState = {
+    entries: Partial<Record<string, QueryEntry>>;
+};
+export type QueryObserverOptions<T> = {
+    meta: QueryMeta;
+    fetcher: () => Promise<T>;
+    /** How long an answer counts as current, in milliseconds. `0` asks again on every mount. */
+    staleTime: number;
+    /** An answer this rejects is shown but never trusted: the next observer to mount asks again. */
+    isCacheable?: (data: T) => boolean;
+};
+/**
+ * One path segment per key.
+ *
+ * A key carries a URL, and a URL is full of dots — the store's path separator — so the key cannot be the segment
+ * itself. cyrb53: 53 bits keep a collision out of reach for the queries one page makes, and the entry stores its
+ * full key besides, so a collision would read as a miss rather than as somebody else's answer.
+ */
+export declare const queryId: (key: string) => string;
+export declare const queryPath: (key: string) => `entries.${string}`;
+/**
+ * Answers to read requests, shared by everything that asks the same question — modelled on react-query.
+ *
+ * An answer is served while it is fresh, served AND asked again in the background once it is stale, and asked again
+ * at once when something says the data behind it changed. The answers live in a nexus store written with the TTL of
+ * whoever asked, so "is this still good?" is the store's own `isStale`, and the dev-tools show exactly what is held.
+ *
+ * A query is "active" while an enabled observer renders it. A provider inside a hidden tab is mounted but not active,
+ * so an invalidation marks its answer stale and it asks when it is shown again, not for a branch nobody sees.
+ *
+ * Memory only, and module-scoped like the action-runs store: the page's own session is the only one it can hold, and
+ * {@link QueryCache.reset} is how a change of session makes sure nothing of the previous one is ever served. Nothing
+ * fills it during a server render — observers attach in effects.
+ */
+export declare class QueryCache {
+    readonly store: StoreApi<QueriesState>;
+    private runtimes;
+    /** Bumped by {@link reset}: an answer carrying an older epoch belongs to a session that has ended. */
+    private epochValue;
+    private unwatch;
+    constructor(store?: StoreApi<QueriesState>);
+    get epoch(): number;
+    /** The entry for `key`; a different key that hashed to the same segment is not it. */
+    getEntry(key: string): QueryEntry | undefined;
+    /** Whether `key` has been answered in this session — every answer is written with a TTL, even a distrusted one. */
+    hasAnswer(key: string): boolean;
+    /**
+     * Keeps `key` from being collected for as long as the returned function is not called, and for `gcTime` after.
+     * The latest reader's `gcTime` is the one kept.
+     */
+    hold(key: string, gcTime?: number): () => void;
+    /** Makes `key` active for as long as the returned function is not called, asking for it if it is not current. */
+    observe<T>(key: string, options: QueryObserverOptions<T>): () => void;
+    /**
+     * The answer for `key`, asking only when what is held is not current — for a caller that is not a component: a
+     * flow step reading a URL. Nobody holds the entry afterwards, so it is collected `gcTime` after this.
+     */
+    fetchQuery<T>(key: string, options: QueryObserverOptions<T> & {
+        gcTime?: number;
+    }): Promise<T | undefined>;
+    /** Asks again for `key` now, whatever the age of what is held — the explicit "reload this". */
+    refetch(key: string): Promise<void>;
+    /**
+     * Marks every query `matches` accepts (all of them without one) as stale, and asks again for the active ones.
+     *
+     * The inactive ones keep what they hold and ask when they are next shown, which is the whole saving: a write does
+     * not turn into a request for every provider on every tab the visitor is not looking at.
+     */
+    invalidate(matches?: (meta: QueryMeta) => boolean): Promise<void>;
+    /**
+     * Forgets every answer, for a change of who is looking.
+     *
+     * Invalidating would not do: a stale query still SHOWS what it holds until the new answer lands, and what it holds
+     * belongs to the previous visitor. The epoch makes a request still in flight from before land nowhere.
+     */
+    reset(): Promise<void>;
+    /**
+     * Expiring the path is the invalidation: {@link onExpired} does the rest, for this call and for anybody else who
+     * expires a query's path — the dev-tools' "Expire" included. A query that has never answered has no record to
+     * expire, so it is marked outdated here, which is what makes a request already out be asked again.
+     */
+    private invalidateOne;
+    /** A query's path was expired: whatever is out now answers from before it, and whoever is looking asks again. */
+    private onExpired;
+    private fetchActive;
+    private fetch;
+    /** The strictest TTL among those rendering the query, so no observer is served an answer older than it accepts. */
+    private ttlOf;
+    private ensure;
+    private cancelGc;
+    private scheduleGc;
+    private collect;
+}
+declare const queryCache: QueryCache;
+export default queryCache;

package/dist/queries/queryCache.mjs

@@ -0,0 +1,166 @@
+import { createStore as e } from "@plitzi/nexus";
+//#region src/queries/queryCache.ts
+var t = 3e5, n = (e) => {
+	let t = 3735928559, n = 1103547991;
+	for (let r = 0; r < e.length; r++) {
+		let i = e.charCodeAt(r);
+		t = Math.imul(t ^ i, 2654435761), n = Math.imul(n ^ i, 1597334677);
+	}
+	return t = Math.imul(t ^ t >>> 16, 2246822507) ^ Math.imul(n ^ n >>> 13, 3266489909), n = Math.imul(n ^ n >>> 16, 2246822507) ^ Math.imul(t ^ t >>> 13, 3266489909), (4294967296 * (2097151 & n) + (t >>> 0)).toString(36);
+}, r = (e) => `entries.${n(e)}`, i = class {
+	store;
+	runtimes = /* @__PURE__ */ new Map();
+	epochValue = 0;
+	unwatch;
+	constructor(t = e({ entries: {} }, { id: "queries" })) {
+		this.store = t;
+	}
+	get epoch() {
+		return this.epochValue;
+	}
+	getEntry(e) {
+		let t = this.store.getPath(r(e));
+		return t?.key === e ? t : void 0;
+	}
+	hasAnswer(e) {
+		return this.getEntry(e) !== void 0 && this.store.getFreshness(r(e)) !== void 0;
+	}
+	hold(e, n = t) {
+		let r = this.ensure(e);
+		return r.gcTime = n, r.holds++, this.cancelGc(r), () => {
+			r.holds--, this.scheduleGc(r);
+		};
+	}
+	observe(e, t) {
+		let n = this.ensure(e), { isCacheable: i } = t, a = {
+			meta: t.meta,
+			staleTime: t.staleTime,
+			fetcher: t.fetcher,
+			isCacheable: i && ((e) => i(e))
+		};
+		return n.observers.add(a), this.cancelGc(n), (!this.hasAnswer(e) || this.store.isStale(r(e))) && this.fetch(n, a), () => {
+			n.observers.delete(a), this.scheduleGc(n);
+		};
+	}
+	async fetchQuery(e, t) {
+		let n = this.ensure(e);
+		if (t.gcTime !== void 0 && (n.gcTime = t.gcTime), this.hasAnswer(e) && !this.store.isStale(r(e))) return this.scheduleGc(n), this.getEntry(e)?.data;
+		let { isCacheable: i } = t;
+		await this.fetch(n, {
+			meta: t.meta,
+			staleTime: t.staleTime,
+			fetcher: t.fetcher,
+			isCacheable: i && ((e) => i(e))
+		});
+		let a = this.getEntry(e)?.data;
+		return this.scheduleGc(n), a;
+	}
+	refetch(e) {
+		let t = this.runtimes.get(n(e));
+		return t ? this.invalidateOne(t) : Promise.resolve();
+	}
+	invalidate(e) {
+		let t = [];
+		return this.runtimes.forEach((n) => {
+			let r = this.getEntry(n.key);
+			!r || e && !e({
+				url: r.url,
+				tags: r.tags
+			}) || t.push(this.invalidateOne(n));
+		}), Promise.all(t).then(() => void 0);
+	}
+	reset() {
+		this.epochValue++, this.runtimes.forEach((e) => {
+			e.version++, e.inFlight = void 0;
+		}), this.store.setState("entries", {});
+		let e = [];
+		return this.runtimes.forEach((t) => e.push(this.fetchActive(t))), Promise.all(e).then(() => void 0);
+	}
+	invalidateOne(e) {
+		return this.store.expire(r(e.key)).length === 0 && e.version++, this.fetchActive(e);
+	}
+	onExpired(e) {
+		let t = this.runtimes.get(e.slice(8).split(".")[0]);
+		t && (t.version++, this.fetchActive(t));
+	}
+	fetchActive(e) {
+		let t = e.observers.values().next();
+		return t.done ? Promise.resolve() : this.fetch(e, t.value);
+	}
+	fetch(e, t) {
+		if (e.inFlight) return e.inFlight;
+		let { key: i } = e, { url: a } = t.meta;
+		t.meta.tags?.forEach((t) => e.tags.add(t));
+		let o = [...e.tags], s = r(i);
+		this.getEntry(i) ? this.store.setState(`${s}.isFetching`, !0) : this.store.setState(s, {
+			key: i,
+			url: a,
+			tags: o,
+			isFetching: !0
+		});
+		let c = this.epochValue, l = e.version, u = (r) => {
+			if (c !== this.epochValue || this.runtimes.get(n(i)) !== e) return Promise.resolve();
+			e.inFlight = void 0;
+			let u = l !== e.version;
+			if ("error" in r) {
+				let e = this.getEntry(i);
+				this.store.setState(s, {
+					key: i,
+					url: a,
+					tags: o,
+					data: e?.data,
+					error: r.error,
+					isFetching: !1
+				}, { ttl: 0 });
+			} else {
+				let n = !u && (t.isCacheable?.(r.data) ?? !0);
+				this.store.setState(s, {
+					key: i,
+					url: a,
+					tags: o,
+					data: r.data,
+					isFetching: !1
+				}, { ttl: n ? this.ttlOf(e, t) : 0 });
+			}
+			return u ? this.fetchActive(e) : Promise.resolve();
+		};
+		return e.inFlight = t.fetcher().then((e) => u({ data: e }), (e) => u({ error: e })), e.inFlight;
+	}
+	ttlOf(e, t) {
+		let n = e.observers.size > 0 ? Infinity : t.staleTime;
+		return e.observers.forEach((e) => {
+			n = Math.min(n, e.staleTime);
+		}), n;
+	}
+	ensure(e) {
+		let r = n(e), i = this.runtimes.get(r);
+		return i || (i = {
+			key: e,
+			tags: /* @__PURE__ */ new Set(),
+			observers: /* @__PURE__ */ new Set(),
+			holds: 0,
+			version: 0,
+			gcTime: t
+		}, this.runtimes.set(r, i)), this.unwatch ??= this.store.watchFreshness("entries", (e) => {
+			e.type === "expired" && this.onExpired(e.path);
+		}), i;
+	}
+	cancelGc(e) {
+		clearTimeout(e.gcTimer), e.gcTimer = void 0;
+	}
+	scheduleGc(e) {
+		if (!(e.holds > 0 || e.observers.size > 0)) {
+			if (this.cancelGc(e), e.gcTime <= 0) {
+				this.collect(e);
+				return;
+			}
+			e.gcTimer = setTimeout(() => this.collect(e), e.gcTime);
+		}
+	}
+	collect(e) {
+		let t = n(e.key);
+		this.runtimes.get(t) === e && e.holds === 0 && e.observers.size === 0 && (this.runtimes.delete(t), this.store.setState(r(e.key), void 0, { unmount: !0 }));
+	}
+}, a = new i();
+//#endregion
+export { t as GC_TIME, i as QueryCache, a as default, n as queryId, r as queryPath };

package/dist/queries/useQuery.d.ts

@@ -0,0 +1,23 @@
+import { QueryMeta } from './queryCache';
+export type UseQueryOptions<T> = {
+    /** What identifies the answer. Without one the hook is inert: it reads, holds and asks for nothing. */
+    key: string | undefined;
+    meta: QueryMeta;
+    fetcher: () => Promise<T>;
+    enabled?: boolean;
+    /** How long an answer counts as current, in milliseconds. */
+    staleTime: number;
+    /** How long an answer nobody renders is kept, in milliseconds. `0` forgets it on unmount. */
+    gcTime?: number;
+    isCacheable?: (data: T) => boolean;
+};
+export type UseQueryResult<T> = {
+    data?: T;
+    /** A request is in flight, or about to be for a query that has never been answered. */
+    isFetching: boolean;
+    /** Nothing to render with yet — as opposed to a refresh of something already on screen. */
+    isLoading: boolean;
+    refetch: () => void;
+};
+declare const useQuery: <T>({ key, meta, fetcher, enabled, staleTime, gcTime, isCacheable }: UseQueryOptions<T>) => UseQueryResult<T>;
+export default useQuery;

package/dist/queries/useQuery.mjs

@@ -0,0 +1,47 @@
+import e, { GC_TIME as t, queryPath as n } from "./queryCache.mjs";
+import { useCallback as r, useEffect as i, useRef as a } from "react";
+import { createStoreHook as o } from "@plitzi/nexus/react";
+//#region src/queries/useQuery.ts
+var { useStore: s } = o(), c = ({ key: o, meta: c, fetcher: l, enabled: u = !0, staleTime: d, gcTime: f = t, isCacheable: p }) => {
+	let m = o !== void 0, [h] = s(n(o ?? ""), {
+		store: e.store,
+		enabled: m
+	}), g = m && h?.key === o ? h : void 0, _ = g !== void 0 && e.hasAnswer(g.key), v = a(l), y = a(p);
+	i(() => {
+		v.current = l, y.current = p;
+	}, [l, p]), i(() => o === void 0 ? void 0 : e.hold(o, f), [o, f]);
+	let { url: b } = c, x = c.tags?.join("\0") ?? "";
+	i(() => {
+		if (u && o !== void 0) return e.observe(o, {
+			meta: {
+				url: b,
+				tags: x ? x.split("\0") : []
+			},
+			staleTime: d,
+			fetcher: () => v.current(),
+			isCacheable: (e) => y.current?.(e) ?? !0
+		});
+	}, [
+		u,
+		o,
+		b,
+		x,
+		d
+	]);
+	let S = _ ? g.data : void 0, C = a(void 0);
+	S === void 0 ? C.current && C.current.epoch !== e.epoch && (C.current = void 0) : C.current = {
+		epoch: e.epoch,
+		data: S
+	};
+	let w = S ?? C.current?.data, T = (g?.isFetching ?? !1) || u && m && !_, E = r(() => {
+		u && o !== void 0 && e.refetch(o);
+	}, [u, o]);
+	return {
+		data: w,
+		isFetching: T,
+		isLoading: T && w === void 0,
+		refetch: E
+	};
+};
+//#endregion
+export { c as default };