@plitzi/sdk-shared 0.33.1 → 0.34.0

package/dist/server/rsc/refreshRsc.mjs

@@ -1,16 +1,34 @@
+import { authFailureFromResponse as e, reportAuthFailure as t } from "../../auth/failureChannel.mjs";
+import { hasServerElements as n } from "../../schema/serverElements.mjs";
+import { getPaths as r, matchRoutePath as i } from "../../navigation/routes.mjs";
 //#region src/server/rsc/refreshRsc.ts
-var e = (e) => `rsc.data.${e}`, t = async (t, n, r) => {
-	let { enabled: i, endpoint: a } = t.get("rsc") ?? {};
-	if (!(!i || !a || typeof window > "u")) try {
-		let i = new URLSearchParams({ location: `${window.location.pathname}${window.location.search}` });
-		n?.length && i.set("ids", n.join(",")), Object.entries(r ?? {}).forEach(([e, t]) => i.set(e, t));
-		let o = await fetch(`${a}?${i.toString()}`, { headers: { Accept: "application/json" } });
-		if (!o.ok) return;
-		let { serverData: s } = await o.json();
-		t.batch(() => {
-			n?.length ? Object.entries(s ?? {}).forEach(([n, r]) => t.set(e(n), r)) : t.set("rsc.data", s ?? {}), t.set("rsc.loaded", !0);
+var a = (e, t, n) => {
+	if (!e) return;
+	let a = e.pages.reduce((t, n) => (n in e.flat && (t[n] = e.flat[n]), t), {});
+	return i(r(a, e.pageFolders, n), t.split("?")[0], n).pageId;
+}, o = (e) => `rsc.data.${e}`, s = () => typeof window > "u" ? "" : `${window.location.pathname}${window.location.search}`, c = async (r, i, c, l) => {
+	let { enabled: u, endpoint: d } = r.get("rsc") ?? {};
+	if (!u || !d || typeof window > "u") return;
+	let f = l ?? s(), p = r.get("schema"), m = r.get("runtime.sources.auth"), h = l ? a(p, l, !!m?.details) : r.get("navigation.currentPageId");
+	if (p && n(p, h)) try {
+		let n = new URLSearchParams({ location: f });
+		i?.length && n.set("ids", i.join(",")), Object.entries(c ?? {}).forEach(([e, t]) => n.set(e, t));
+		let a = await fetch(`${d}?${n.toString()}`, { headers: { Accept: "application/json" } });
+		if (!a.ok) {
+			let n = e(a.status, await a.json().catch(() => void 0));
+			n && t({
+				reason: n,
+				url: d
+			}), r.set("rsc.stale", !0);
+			return;
+		}
+		let { serverData: s } = await a.json();
+		r.batch(() => {
+			i?.length ? Object.entries(s ?? {}).forEach(([e, t]) => r.set(o(e), t)) : r.set("rsc.data", s ?? {}), r.set("rsc.loaded", !0), r.set("rsc.stale", !1), r.set("rsc.location", f);
 		});
-	} catch {}
+	} catch {
+		r.set("rsc.stale", !0);
+	}
 };
 //#endregion
-export { t as default, t as refreshRsc, e as rscDataPath };
+export { s as currentRscLocation, c as default, c as refreshRsc, o as rscDataPath };

package/dist/server/rsc/useRscSync.mjs

@@ -1,20 +1,27 @@
-import e from "./refreshRsc.mjs";
-import { useCommonStore as t, useCommonStoreSync as n } from "../../store/index.mjs";
-import { useEffect as r, useRef as i } from "react";
-import { useStoreById as a } from "@plitzi/nexus/react";
+import { useCommonStore as e, useCommonStoreSync as t } from "../../store/index.mjs";
+import n, { currentRscLocation as r } from "./refreshRsc.mjs";
+import { useEffect as i, useRef as a } from "react";
+import { useStoreById as o } from "@plitzi/nexus/react";
 //#region src/server/rsc/useRscSync.ts
-var o = (o) => {
-	let s = a(), [c] = t("schema.rsc", { mode: "mount" }), [l] = t("runtime.sources.navigation"), { rscData: u, rscPath: d } = o ?? {}, f = (c?.enabled ?? !1) && !!d;
-	n(["rsc.enabled", "rsc.endpoint"], [f, d]), n(["rsc.data", "rsc.loaded"], [u?.serverData ?? {}, u !== void 0], { mode: "mount" });
-	let p = JSON.stringify(l ?? {}), m = i(u === void 0 ? void 0 : p).current;
-	r(() => {
-		!f || p === m || e(s);
+var s = (s) => {
+	let c = o(), [l] = e("schema.rsc", { mode: "mount" }), [u] = e("runtime.sources.navigation"), { rscData: d, rscPath: f } = s ?? {}, p = (l?.enabled ?? !1) && !!f;
+	t(["rsc.enabled", "rsc.endpoint"], [p, f]), t([
+		"rsc.data",
+		"rsc.loaded",
+		"rsc.location"
+	], [
+		d?.serverData ?? {},
+		d !== void 0,
+		r()
+	], { mode: "mount" });
+	let m = JSON.stringify(u ?? {}), h = a(d === void 0 ? void 0 : m);
+	i(() => {
+		p && m !== h.current && (h.current = m, n(c));
 	}, [
-		f,
 		p,
 		m,
-		s
+		c
 	]);
 };
 //#endregion
-export { o as default };
+export { s as default };

package/dist/state/runtimeStatePersist.mjs

@@ -3,9 +3,10 @@ import { persistMiddleware as e } from "@plitzi/nexus";
 var t = (t) => e({
 	key: `plitzi_${t}_state`,
 	paths: ["runtime.state"],
-	storage: ({ schema: e }) => {
-		let t = e?.settings;
-		return t?.keepState ? t.stateStorage === "sessionStorage" ? "session" : "local" : !1;
+	storage: ({ schema: e, render: t }) => {
+		if (t?.isHydrating && !t.hydrated) return !1;
+		let n = e?.settings;
+		return n?.keepState ? n.stateStorage === "sessionStorage" ? "session" : "local" : !1;
 	}
 });
 //#endregion

package/dist/store/actionRuns/actionRunsRecorder.d.ts

@@ -0,0 +1,36 @@
+import { ActionRunEntry } from '../../types';
+/** Registered by whatever started the run, for as long as stopping it means anything. */
+export declare const registerActionCanceller: (id: string, cancel: () => void) => void;
+export declare const releaseActionCanceller: (id: string) => void;
+/**
+ * Stops a run from outside the flow that started it — the dev-tools panel, today.
+ *
+ * It is deliberately the step's own canceller rather than a request built here: a run is stopped by aborting the
+ * request that carries it AND, when the server has already named it, by telling the server so. Which of those
+ * apply is something only the step knows.
+ */
+export declare const cancelActionRun: (id: string) => void;
+/**
+ * Records a run this page STARTED, the moment it is sent.
+ *
+ * Written when the request leaves rather than when it answers, because the interesting failures are the ones with
+ * no answer: a detached run whose response nobody awaits, a stream that never opens, a server that is not there.
+ * A record that only appeared on success would be missing exactly the runs somebody is looking for.
+ */
+export declare const recordActionRun: (entry: Omit<ActionRunEntry, "id" | "startedAt" | "status" | "progress">) => string;
+/** How it ended, or what it reported on the way. Unknown ids are ignored: a swept-out run is not an error. */
+export declare const updateActionRun: (id: string, patch: Partial<Omit<ActionRunEntry, "id">>) => void;
+/**
+ * One chunk a streaming run emitted, kept in order beside the run it belongs to.
+ *
+ * Capped, and the OLDEST go. The server bounds its own SSE buffer at a megabyte for a peer that stopped reading;
+ * nothing bounded this side, so a stream that runs long — a model answering token by token, a job reporting every
+ * row — grew a panel's array without limit for as long as the tab stayed open. What a person scrolls back to is
+ * the end of a stream, so the end is what is kept.
+ */
+export declare const recordActionProgress: (id: string, chunk: unknown) => void;
+/**
+ * Empties the log. Live runs keep their cancellers: clearing the panel is tidying a VIEW, and taking away the only
+ * way to stop a run that is still going is not something a person asked for by pressing it.
+ */
+export declare const clearActionRuns: () => void;

package/dist/store/actionRuns/actionRunsRecorder.mjs

@@ -0,0 +1,39 @@
+import e from "./actionRunsStore.mjs";
+//#region src/store/actionRuns/actionRunsRecorder.ts
+var t = 0, n = (t) => e.setState("runs", t), r = /* @__PURE__ */ new Map(), i = (e, t) => {
+	r.set(e, t);
+}, a = (e) => {
+	r.delete(e);
+}, o = (e) => {
+	r.get(e)?.();
+}, s = (r) => {
+	t += 1;
+	let i = `run-${t}`;
+	return n([{
+		...r,
+		id: i,
+		status: "running",
+		startedAt: Date.now(),
+		progress: [],
+		cancellable: !0
+	}, ...e.getState().runs].slice(0, 100)), i;
+}, c = (t, r) => {
+	let { runs: i } = e.getState();
+	i.some((e) => e.id === t) && n(i.map((e) => e.id === t ? {
+		...e,
+		...r
+	} : e));
+}, l = (t, r) => {
+	let { runs: i } = e.getState();
+	n(i.map((e) => e.id === t ? {
+		...e,
+		progress: [...e.progress, r].slice(-500)
+	} : e));
+}, u = () => {
+	let t = new Set(e.getState().runs.filter((e) => e.cancellable).map((e) => e.id));
+	[...r.keys()].forEach((e) => {
+		t.has(e) || r.delete(e);
+	}), n([]);
+};
+//#endregion
+export { o as cancelActionRun, u as clearActionRuns, l as recordActionProgress, s as recordActionRun, i as registerActionCanceller, a as releaseActionCanceller, c as updateActionRun };

package/dist/store/actionRuns/actionRunsStore.d.ts

@@ -0,0 +1,16 @@
+import { ActionRunsState } from '../../types';
+/** Newest runs are kept; older ones drop off, so a page left open all day cannot grow unbounded. */
+export declare const MAX_RUNS = 100;
+/** Per run, and for the same reason: a long stream is a run whose progress array would otherwise never stop. */
+export declare const MAX_PROGRESS_CHUNKS = 500;
+export declare const createActionRunsState: () => ActionRunsState;
+/**
+ * DEDICATED, isolated store — deliberately not part of the reactive `CommonState`.
+ *
+ * A run is developer-facing evidence, not page state: nothing an element renders should re-render because a
+ * server action reported progress, and a page that binds `{{ … }}` to anything here would be binding to the
+ * debugger. It follows the tracing store for exactly that reason, and for one more: the panel renders outside the
+ * app's provider tree and needs a store it can read without one.
+ */
+declare const actionRunsStore: import('@plitzi/nexus').StoreApi<ActionRunsState>;
+export default actionRunsStore;

package/dist/store/actionRuns/actionRunsStore.mjs

@@ -0,0 +1,5 @@
+import { createStore as e } from "@plitzi/nexus";
+//#region src/store/actionRuns/actionRunsStore.ts
+var t = 100, n = 500, r = () => ({ runs: [] }), i = e(r(), { id: "action-runs" });
+//#endregion
+export { n as MAX_PROGRESS_CHUNKS, t as MAX_RUNS, r as createActionRunsState, i as default };

package/dist/store/actionRuns/index.d.ts

@@ -0,0 +1,6 @@
+import { default as actionRunsStore } from './actionRunsStore';
+import { default as useActionRuns } from './useActionRuns';
+export { MAX_RUNS, createActionRunsState } from './actionRunsStore';
+export { cancelActionRun, clearActionRuns, recordActionProgress, recordActionRun, registerActionCanceller, releaseActionCanceller, updateActionRun } from './actionRunsRecorder';
+export type { UseActionRunsReturn } from './useActionRuns';
+export { actionRunsStore, useActionRuns };

package/dist/store/actionRuns/index.mjs

@@ -0,0 +1,4 @@
+import e, { MAX_RUNS as t, createActionRunsState as n } from "./actionRunsStore.mjs";
+import { cancelActionRun as r, clearActionRuns as i, recordActionProgress as a, recordActionRun as o, registerActionCanceller as s, releaseActionCanceller as c, updateActionRun as l } from "./actionRunsRecorder.mjs";
+import u from "./useActionRuns.mjs";
+export { t as MAX_RUNS, e as actionRunsStore, r as cancelActionRun, i as clearActionRuns, n as createActionRunsState, a as recordActionProgress, o as recordActionRun, s as registerActionCanceller, c as releaseActionCanceller, l as updateActionRun, u as useActionRuns };

package/dist/store/actionRuns/useActionRuns.d.ts

@@ -0,0 +1,13 @@
+import { ActionRunsState } from '../../types';
+export type UseActionRunsReturn = ActionRunsState & {
+    clear: () => void;
+};
+/**
+ * Reactive view of the runs this page has started.
+ *
+ * Recording is always on — a run that happened before the panel was opened is the one somebody is usually looking
+ * for — and this is a pure view over it. `getState` returns a stable snapshot between writes, which is what
+ * `useSyncExternalStore` needs.
+ */
+declare const useActionRuns: () => UseActionRunsReturn;
+export default useActionRuns;

package/dist/store/actionRuns/useActionRuns.mjs

@@ -0,0 +1,10 @@
+import e from "./actionRunsStore.mjs";
+import { clearActionRuns as t } from "./actionRunsRecorder.mjs";
+import { useSyncExternalStore as n } from "react";
+//#region src/store/actionRuns/useActionRuns.ts
+var r = () => ({
+	...n(e.subscribe, e.getState, e.getState),
+	clear: t
+});
+//#endregion
+export { r as default };