@plitzi/sdk-shared 0.38.6 → 0.38.7

package/dist/queries/serverQueries.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A query the page server answers for a provider (`runtime: 'server'`), as the invalidations see it.
+ *
+ * Its answer arrives in the RSC payload, never through the {@link QueryCache}, so an invalidation that only reached
+ * the cache left every server-driven list showing what it held before the write.
+ */
+export type ServerQuery = {
+    /** The provider's element id: what an invalidation naming containers names. */
+    id: string;
+    /** The URL the server reads for it — only a provider that has nothing but a `query`; a connector or action has none. */
+    url?: string;
+    /** Asks the server again for this provider's slice, around every cache. */
+    refresh: () => Promise<void>;
+};
+/** Makes `query` reachable by the invalidations until the returned function is called. */
+export declare const registerServerQuery: (query: ServerQuery) => (() => void);
+/**
+ * Asks again for every server query `matches` accepts — all of them without one.
+ *
+ * Settled, not all-or-nothing: one provider that could not ask again is its own to report, and the rest still refresh.
+ */
+export declare const refreshServerQueries: (matches?: (query: ServerQuery) => boolean) => Promise<void>;

package/dist/queries/serverQueries.mjs

@@ -0,0 +1,9 @@
+//#region src/queries/serverQueries.ts
+var e = /* @__PURE__ */ new Set(), t = (t) => {
+	let n = { ...t };
+	return e.add(n), () => {
+		e.delete(n);
+	};
+}, n = (t) => Promise.allSettled([...e].filter((e) => !t || t(e)).map((e) => e.refresh())).then(() => void 0);
+//#endregion
+export { n as refreshServerQueries, t as registerServerQuery };

package/dist/queries/useServerQuery.d.ts

@@ -0,0 +1,19 @@
+export type UseServerQueryOptions = {
+    id: string;
+    /** The URL the server reads for a provider that has nothing but a `query`. */
+    url?: string;
+    /** Whether the provider has a live answer to refresh at all — never in the builder, which has no page server. */
+    enabled: boolean;
+    /** Whether it is on screen: an invalidation of a hidden one waits until it is shown, as a cached query does. */
+    active: boolean;
+    refresh: () => Promise<void>;
+};
+/**
+ * Keeps a server-driven provider reachable by the invalidations — `invalidateQueries`, and the refresh a write step
+ * asks for — for as long as it is mounted and `enabled`.
+ *
+ * The same saving the cache makes for a hidden query: a provider in a tab nobody is looking at is only marked, and
+ * asks when it is shown, so a write does not turn into a request for every section the visitor cannot see.
+ */
+declare const useServerQuery: ({ id, url, enabled, active, refresh }: UseServerQueryOptions) => void;
+export default useServerQuery;

package/dist/queries/useServerQuery.mjs

@@ -0,0 +1,21 @@
+import { registerServerQuery as e } from "./serverQueries.mjs";
+import { useEffect as t, useRef as n } from "react";
+//#region src/queries/useServerQuery.ts
+var r = ({ id: r, url: i, enabled: a, active: o, refresh: s }) => {
+	let c = n(!1);
+	t(() => {
+		if (a) return o && c.current && (c.current = !1, s()), e({
+			id: r,
+			url: i,
+			refresh: () => o ? s() : (c.current = !0, Promise.resolve())
+		});
+	}, [
+		a,
+		o,
+		r,
+		i,
+		s
+	]);
+};
+//#endregion
+export { r as default };

package/dist/server/rsc/refreshRsc.d.ts

@@ -13,6 +13,25 @@ export declare const currentRscLocation: () => string;
 export declare const cancelRsc: (store: StoreApi<CommonState>, ids?: readonly string[]) => void;
 /** Every refresh of this root aborted and forgotten — the SDK root that owned them is going away. */
 export declare const releaseRscRequests: (instance: string) => void;
+export type RscRefreshOptions = {
+    /**
+     * Resolve for somewhere the visitor is not yet.
+     *
+     * A route change that renders first and fetches after paints a page whose sections have no answer, so the
+     * navigation asks for the destination BEFORE it commits. Absent means where the visitor already is, which is
+     * every other caller: the initial load, a pager, an element refreshing itself.
+     */
+    location?: string;
+    /**
+     * Ask the server itself, around the browser's cache and the page server's.
+     *
+     * Outside `main` an answer is kept for a while on both — the same question from many visitors is resolved once —
+     * which is right for a page window and wrong for a refresh that exists because something changed: a write, an
+     * explicit reload. Asked through either cache, that refresh is answered with the slice from before the write. A
+     * header rather than a query parameter, because every parameter of the request is input to what it resolves.
+     */
+    fresh?: boolean;
+};
 /**
  * Re-fetches RSC data into the store.
  *
@@ -20,7 +39,8 @@ export declare const releaseRscRequests: (instance: string) => void;
  * has what it needs through the store it can reach, and an element buried under any number of scopes writes to the
  * root by delegation (nothing but the root owns `rsc`).
  *
- * Pass `ids` to refresh only those elements — the response is merged over the existing payload. Omit them for a full
+ * Pass `requestedIds` to refresh only those elements — the response is merged over the existing payload; of them,
+ * only the ones the server resolves at that location are asked for, and none is no request. Omit them for a full
  * refresh, which replaces it. `params` ride along on the query string; that is how a provider asks for a different
  * page window.
  *
@@ -29,13 +49,5 @@ export declare const releaseRscRequests: (instance: string) => void;
  * again, an element asked for again — is aborted, here and on the server. Before this a click on a link asked twice
  * (its prefetch, then the route change), and a slow answer could land over a newer one.
  */
-export declare const refreshRsc: (store: StoreApi<CommonState>, ids?: string[], params?: Record<string, string>, 
-/**
- * Resolve for somewhere the visitor is not yet.
- *
- * A route change that renders first and fetches after paints a page whose sections have no answer, so the
- * navigation asks for the destination BEFORE it commits. Absent means where the visitor already is, which is
- * every other caller: the initial load, a pager, an element refreshing itself.
- */
-location?: string) => Promise<void>;
+export declare const refreshRsc: (store: StoreApi<CommonState>, requestedIds?: string[], params?: Record<string, string>, { location, fresh }?: RscRefreshOptions) => Promise<void>;
 export default refreshRsc;

package/dist/server/rsc/refreshRsc.mjs

@@ -1,96 +1,108 @@
 import { authFailureFromResponse as e, reportAuthFailure as t } from "../../auth/failureChannel.mjs";
 import { recordRenderActionRuns as n } from "../../store/actionRuns/actionRunsRecorder.mjs";
-import { hasServerElements as r } from "../../schema/serverElements.mjs";
-import { getPaths as i, matchRoutePath as a } from "../../navigation/routes.mjs";
+import { collectServerElements as r, hasServerElements as i } from "../../schema/serverElements.mjs";
+import { getPaths as a, matchRoutePath as o } from "../../navigation/routes.mjs";
 //#region src/server/rsc/refreshRsc.ts
-var o = (e, t, n) => {
+var s = (e, t, n) => {
 	if (!e) return;
 	let r = e.pages.reduce((t, n) => (n in e.flat && (t[n] = e.flat[n]), t), {});
-	return a(i(r, e.pageFolders, n), t.split("?")[0], n).pageId;
-}, s = (e) => `rsc.data.${e}`, c = () => typeof window > "u" ? "" : `${window.location.pathname}${window.location.search}`, l = "*", u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new WeakMap(), f = () => ({
+	return o(a(r, e.pageFolders, n), t.split("?")[0], n).pageId;
+}, c = (e, t, n, i) => {
+	let a = new Set(r(e, t, [...n], i).map(({ id: e }) => e));
+	return n.filter((e) => a.has(e));
+}, l = (e) => `rsc.data.${e}`, u = () => typeof window > "u" ? "" : `${window.location.pathname}${window.location.search}`, d = "*", f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new WeakMap(), m = () => ({
 	seq: 0,
 	inFlight: /* @__PURE__ */ new Set(),
 	asked: /* @__PURE__ */ new Map()
-}), p = (e) => {
+}), h = (e) => {
 	let t = e.get("rsc.instance");
 	if (typeof t == "string" && t) {
-		let e = u.get(t);
+		let e = f.get(t);
 		if (e) return e;
-		let n = f();
-		return u.set(t, n), n;
+		let n = m();
+		return f.set(t, n), n;
 	}
-	let n = d.get(e);
+	let n = p.get(e);
 	if (n) return n;
-	let r = f();
-	return d.set(e, r), r;
-}, m = (e, t) => {
+	let r = m();
+	return p.set(e, r), r;
+}, g = (e, t) => {
 	let n = {};
 	t.inFlight.forEach((e) => {
-		e.here && (e.ids ?? [l]).forEach((e) => {
+		e.here && (e.ids ?? [d]).forEach((e) => {
 			n[e] = !0;
 		});
 	}), e.set("rsc.refreshing", n);
-}, h = (e, t) => !e || !!t && t.every((t) => e.includes(t)), g = (e, t) => {
-	p(e).inFlight.forEach((e) => {
+}, _ = (e, t) => !e || !!t && t.every((t) => e.includes(t)), v = (e, t) => {
+	h(e).inFlight.forEach((e) => {
 		(!t || e.ids?.some((e) => t.includes(e))) && e.controller.abort();
 	});
-}, _ = (e) => {
-	u.get(e)?.inFlight.forEach((e) => e.controller.abort()), u.delete(e);
-}, v = (e, t, n, r, i) => {
+}, y = (e) => {
+	f.get(e)?.inFlight.forEach((e) => e.controller.abort()), f.delete(e);
+}, b = (e, t, n, r, i) => {
 	let { ids: a, seq: o } = n;
 	e.batch(() => {
 		if (a?.length) Object.entries(r).forEach(([n, r]) => {
-			(t.asked.get(n) ?? 0) <= o && (t.asked.get(l) ?? 0) <= o && e.set(s(n), r);
+			(t.asked.get(n) ?? 0) <= o && (t.asked.get(d) ?? 0) <= o && e.set(l(n), r);
 		});
 		else {
-			let n = e.get("rsc.data") ?? {}, i = (e) => e !== l && (t.asked.get(e) ?? 0) > o, a = Object.fromEntries([...Object.entries(r).filter(([e]) => !i(e)), ...Object.entries(n).filter(([e]) => i(e))]);
+			let n = e.get("rsc.data") ?? {}, i = (e) => e !== d && (t.asked.get(e) ?? 0) > o, a = Object.fromEntries([...Object.entries(r).filter(([e]) => !i(e)), ...Object.entries(n).filter(([e]) => i(e))]);
 			e.set("rsc.data", a);
 		}
 		e.set("rsc.loaded", !0), e.set("rsc.stale", !1), e.set("rsc.location", i);
 	});
-}, y = async (i, a, s, u) => {
-	let { enabled: d, endpoint: f } = i.get("rsc") ?? {};
-	if (!d || !f || typeof window > "u") return;
-	let g = u ?? c(), _ = i.get("schema"), y = i.get("runtime.sources.auth"), b = u ? o(_, u, !!y?.details) : i.get("navigation.currentPageId"), x = u ? void 0 : i.get("runtime.sources.flags");
-	if (!_ || !r(_, b, x)) return;
-	let S = new URLSearchParams({ location: g });
-	a?.length && S.set("ids", a.join(",")), Object.entries(s ?? {}).forEach(([e, t]) => S.set(e, t));
-	let C = `${f}?${S.toString()}`, w = p(i), T = [...w.inFlight].find((e) => e.url === C);
-	if (T) return T.promise;
-	w.inFlight.forEach((e) => {
-		h(a, e.ids) && e.controller.abort();
+}, x = async (r, a, o, { location: l, fresh: f = !1 } = {}) => {
+	let { enabled: p, endpoint: m } = r.get("rsc") ?? {};
+	if (!p || !m || typeof window > "u") return;
+	let v = l ?? u(), y = r.get("schema"), x = r.get("runtime.sources.auth"), S = l ? s(y, l, !!x?.details) : r.get("navigation.currentPageId"), C = l ? void 0 : r.get("runtime.sources.flags");
+	if (!y) return;
+	let w = a?.length ? c(y, S, a, C) : void 0;
+	if (w ? !w.length : !i(y, S, C)) return;
+	let T = new URLSearchParams({ location: v });
+	w?.length && T.set("ids", w.join(",")), Object.entries(o ?? {}).forEach(([e, t]) => T.set(e, t));
+	let E = `${m}?${T.toString()}`, D = h(r), O = [...D.inFlight].find((e) => e.url === E && (e.fresh || !f));
+	if (O) return O.promise;
+	D.inFlight.forEach((e) => {
+		_(w, e.ids) && e.controller.abort();
 	});
-	let E = ++w.seq;
-	a?.length ? a.forEach((e) => w.asked.set(e, E)) : (w.asked.clear(), w.asked.set(l, E));
-	let D = new AbortController(), O = {
-		url: C,
-		...a?.length ? { ids: a } : {},
-		here: g === c(),
-		seq: E,
-		controller: D,
+	let k = ++D.seq;
+	w?.length ? w.forEach((e) => D.asked.set(e, k)) : (D.asked.clear(), D.asked.set(d, k));
+	let A = new AbortController(), j = {
+		url: E,
+		...w?.length ? { ids: w } : {},
+		here: v === u(),
+		fresh: f,
+		seq: k,
+		controller: A,
 		promise: Promise.resolve()
-	}, k = async (r) => {
-		let a = await fetch(C, {
-			headers: { Accept: "application/json" },
-			signal: D.signal
+	}, M = async (i) => {
+		let a = await fetch(E, {
+			...f ? {
+				cache: "no-cache",
+				headers: {
+					Accept: "application/json",
+					"Cache-Control": "no-cache"
+				}
+			} : { headers: { Accept: "application/json" } },
+			signal: A.signal
 		});
 		if (!a.ok) {
 			let n = e(a.status, await a.json().catch(() => void 0));
 			if (n && await t({
 				reason: n,
-				url: f
-			}) && !r) return k(!0);
-			i.set("rsc.stale", !0);
+				url: m
+			}) && !i) return M(!0);
+			r.set("rsc.stale", !0);
 			return;
 		}
 		let { serverData: o, actionRuns: s } = await a.json();
-		s?.length && n(s), v(i, w, O, o ?? {}, g);
+		s?.length && n(s), b(r, D, j, o ?? {}, v);
 	};
-	return O.promise = k(!1).catch(() => {
-		D.signal.aborted || i.set("rsc.stale", !0);
+	return j.promise = M(!1).catch(() => {
+		A.signal.aborted || r.set("rsc.stale", !0);
 	}).finally(() => {
-		w.inFlight.delete(O), m(i, w);
-	}), w.inFlight.add(O), m(i, w), O.promise;
+		D.inFlight.delete(j), g(r, D);
+	}), D.inFlight.add(j), g(r, D), j.promise;
 };
 //#endregion
-export { g as cancelRsc, c as currentRscLocation, y as default, y as refreshRsc, _ as releaseRscRequests, s as rscDataPath };
+export { v as cancelRsc, u as currentRscLocation, x as default, x as refreshRsc, y as releaseRscRequests, l as rscDataPath };

package/dist/server/rsc/useRscRefresh.d.ts

@@ -1,2 +1,3 @@
-declare const useRscRefresh: () => (ids?: string[], params?: Record<string, string>) => Promise<void>;
+import { RscRefreshOptions } from './refreshRsc';
+declare const useRscRefresh: () => (ids?: string[], params?: Record<string, string>, { fresh }?: Pick<RscRefreshOptions, "fresh">) => Promise<void>;
 export default useRscRefresh;

package/dist/server/rsc/useRscRefresh.mjs

@@ -4,7 +4,7 @@ import { useStoreById as n } from "@plitzi/nexus/react";
 //#region src/server/rsc/useRscRefresh.ts
 var r = () => {
 	let r = n();
-	return t((t, n) => e(r, t, n), [r]);
+	return t((t, n, { fresh: i } = {}) => e(r, t, n, { fresh: i }), [r]);
 };
 //#endregion
 export { r as default };