@plitzi/sdk-shared 0.38.3 → 0.38.5

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

@@ -1,6 +1,18 @@
 import { CommonState } from '../../types';
 import { PathOf, StoreApi } from '@plitzi/nexus';
 export declare const rscDataPath: (id: string) => PathOf<CommonState>;
+/** Where the visitor is, spelled the way the server reads it back. */
+export declare const currentRscLocation: () => string;
+/**
+ * Stops what a refresh in flight is asking the server for — the request, and the work behind it on the server — and
+ * leaves the payload as it is.
+ *
+ * `ids` cancels the refreshes of those elements; nothing cancels every refresh in flight, a navigation's included.
+ * What a STOP button is: the visitor is done waiting, and what is on screen stays.
+ */
+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;
 /**
  * Re-fetches RSC data into the store.
  *
@@ -11,9 +23,12 @@ export declare const rscDataPath: (id: string) => PathOf<CommonState>;
  * Pass `ids` to refresh only those elements — the response is merged over the existing payload. 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.
+ *
+ * One request per question, and the newest question wins: asking again for what is already in flight is answered by
+ * the request in flight, and a request whose answer a newer one would overwrite anyway — a whole payload asked for
+ * 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.
  */
-/** Where the visitor is, spelled the way the server reads it back. */
-export declare const currentRscLocation: () => string;
 export declare const refreshRsc: (store: StoreApi<CommonState>, ids?: string[], params?: Record<string, string>, 
 /**
  * Resolve for somewhere the visitor is not yet.
@@ -22,7 +37,5 @@ export declare const refreshRsc: (store: StoreApi<CommonState>, ids?: string[],
  * 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, 
-/** Whether this is the one second asking, after a refusal that renewed the session. */
-retried?: boolean) => Promise<void>;
+location?: string) => Promise<void>;
 export default refreshRsc;

package/dist/server/rsc/refreshRsc.mjs

@@ -7,30 +7,90 @@ var o = (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 = async (i, a, u, d, f = !1) => {
-	let { enabled: p, endpoint: m } = i.get("rsc") ?? {};
-	if (!p || !m || typeof window > "u") return;
-	let h = d ?? c(), g = i.get("schema"), _ = i.get("runtime.sources.auth"), v = d ? o(g, d, !!_?.details) : i.get("navigation.currentPageId"), y = d ? void 0 : i.get("runtime.sources.flags");
-	if (g && r(g, v, y)) try {
-		let r = new URLSearchParams({ location: h });
-		a?.length && r.set("ids", a.join(",")), Object.entries(u ?? {}).forEach(([e, t]) => r.set(e, t));
-		let o = await fetch(`${m}?${r.toString()}`, { headers: { Accept: "application/json" } });
-		if (!o.ok) {
-			let n = e(o.status, await o.json().catch(() => void 0));
+}, 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 = () => ({
+	seq: 0,
+	inFlight: /* @__PURE__ */ new Set(),
+	asked: /* @__PURE__ */ new Map()
+}), p = (e) => {
+	let t = e.get("rsc.instance");
+	if (typeof t == "string" && t) {
+		let e = u.get(t);
+		if (e) return e;
+		let n = f();
+		return u.set(t, n), n;
+	}
+	let n = d.get(e);
+	if (n) return n;
+	let r = f();
+	return d.set(e, r), r;
+}, m = (e, t) => {
+	let n = {};
+	t.inFlight.forEach((e) => {
+		e.here && (e.ids ?? [l]).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) => {
+		(!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) => {
+	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);
+		});
+		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))]);
+			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();
+	});
+	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,
+		promise: Promise.resolve()
+	}, k = async (r) => {
+		let a = await fetch(C, {
+			headers: { Accept: "application/json" },
+			signal: D.signal
+		});
+		if (!a.ok) {
+			let n = e(a.status, await a.json().catch(() => void 0));
 			if (n && await t({
 				reason: n,
-				url: m
-			}) && !f) return await l(i, a, u, d, !0);
+				url: f
+			}) && !r) return k(!0);
 			i.set("rsc.stale", !0);
 			return;
 		}
-		let { serverData: c, actionRuns: p } = await o.json();
-		p?.length && n(p), i.batch(() => {
-			a?.length ? Object.entries(c ?? {}).forEach(([e, t]) => i.set(s(e), t)) : i.set("rsc.data", c ?? {}), i.set("rsc.loaded", !0), i.set("rsc.stale", !1), i.set("rsc.location", h);
-		});
-	} catch {
-		i.set("rsc.stale", !0);
-	}
+		let { serverData: o, actionRuns: s } = await a.json();
+		s?.length && n(s), v(i, w, O, o ?? {}, g);
+	};
+	return O.promise = k(!1).catch(() => {
+		D.signal.aborted || i.set("rsc.stale", !0);
+	}).finally(() => {
+		w.inFlight.delete(O), m(i, w);
+	}), w.inFlight.add(O), m(i, w), O.promise;
 };
 //#endregion
-export { c as currentRscLocation, l as default, l as refreshRsc, s as rscDataPath };
+export { g as cancelRsc, c as currentRscLocation, y as default, y as refreshRsc, _ as releaseRscRequests, s as rscDataPath };

package/dist/server/rsc/useRscSync.mjs

@@ -1,27 +1,38 @@
 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";
+import n, { currentRscLocation as r, releaseRscRequests as i } from "./refreshRsc.mjs";
+import { useEffect as a, useId as o } from "react";
+import { useStoreById as s } from "@plitzi/nexus/react";
 //#region src/server/rsc/useRscSync.ts
-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([
+var c = (c) => {
+	let l = s(), u = o(), [d] = e("schema.rsc", { mode: "mount" }), [f] = e([
+		"navigation.routeParams",
+		"navigation.queryParams",
+		"navigation.currentPageId",
+		"navigation.href"
+	]), p = JSON.stringify(f), { rscData: m, rscPath: h } = c ?? {}, g = (d?.enabled ?? !1) && !!h;
+	t([
+		"rsc.enabled",
+		"rsc.endpoint",
+		"rsc.instance"
+	], [
+		g,
+		h,
+		u
+	]), t([
 		"rsc.data",
 		"rsc.loaded",
 		"rsc.location"
 	], [
-		d?.serverData ?? {},
-		d !== void 0,
+		m?.serverData ?? {},
+		m !== 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));
+	], { mode: "mount" }), a(() => () => i(u), [u]), a(() => {
+		!g || l.get("rsc.loaded") && l.get("rsc.location") === r() && !l.get("rsc.stale") || n(l);
 	}, [
+		g,
 		p,
-		m,
-		c
+		l
 	]);
 };
 //#endregion
-export { s as default };
+export { c as default };

package/dist/server/usePluginRoute.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Where a plugin's own server half answers, for its component: `route('/layout')` is the URL of the plugin's
+ * `GET /layout`, served under `/fn/plugins/<type>/` by the server this page came from — with no flow, no server action
+ * and nothing for the space to wire.
+ *
+ * ```tsx
+ * const route = usePluginRoute('board');
+ * const url = route('/layout');
+ * if (url) {
+ *   await fetch(url, { method: 'POST', body: JSON.stringify(layout), credentials: 'same-origin' });
+ * }
+ * ```
+ *
+ * `undefined` while the page is served without a server that runs code — the builder's canvas, an embed, an offline
+ * render — the same answer that leaves a `runServerAction` step inert there, rather than a request to a guaranteed 404.
+ */
+declare const usePluginRoute: (plugin: string) => (path?: string) => string | undefined;
+export default usePluginRoute;

package/dist/server/usePluginRoute.mjs

@@ -0,0 +1,14 @@
+import { pluginRoutePath as e } from "../actions/functions.mjs";
+import { useCommonStore as t } from "../store/index.mjs";
+import { useCallback as n } from "react";
+//#region src/server/usePluginRoute.ts
+var r = (r) => {
+	let [i] = t("actions.endpoint");
+	return n((t = "/") => {
+		if (!i) return;
+		let n = e(r, t);
+		return typeof window > "u" ? n : new URL(n, new URL(i, window.location.href)).href;
+	}, [i, r]);
+};
+//#endregion
+export { r as default };

package/dist/source/export.d.ts

@@ -28,6 +28,11 @@ export type SpaceExport = {
     };
     /** The version taken out: the draft (`main`, revision 0), or a snapshot an environment holds. */
     version: Pick<SpaceVersionContents, 'environment' | 'revision' | 'snapshot'>;
+    /**
+     * Which state of the draft's documents this is — its schema, style, actions and connectors — what `plitzi push`
+     * checks the space's draft has not moved on from. `null` for a snapshot, which no push writes.
+     */
+    draft: string | null;
     /** The space as authoring code, by path (`index.ts`, a file per page): none for a project that reads it from Plitzi. */
     authoring: {
         exportName: string;
@@ -55,6 +60,14 @@ export type SpaceExport = {
         version: string;
         files: Record<string, string>;
     };
+    /**
+     * The space's own data, by path in `src/data/` (JSON its providers read on the server, never served), and the version
+     * of it this is — what `plitzi push` checks the space's copy has not moved on from.
+     */
+    data: {
+        version: string;
+        files: Record<string, string>;
+    };
     /**
      * The source its plugins and runtime were built from, merged: every file by its path in the project (bytes in
      * base64), the packages they need, and where each build starts.
@@ -72,9 +85,14 @@ export type SpaceExport = {
     };
     /** What there is no source of: kept built, so the project runs it as it is and cannot change it. */
     builtOnly: {
+        /**
+         * Each plugin's built files, and its server half's source when it brings one (by path in its `functions/`): the
+         * platform keeps that privately, so it travels here rather than as a file on the CDN.
+         */
         plugins: {
             type: string;
             files: SpaceExportFile[];
+            functions?: Record<string, string>;
         }[];
         /** The packed runtime, in base64 — what `@plitzi/sdk-server/runtime` loads. */
         runtime: string | null;

package/dist/source/import.d.ts

@@ -0,0 +1,55 @@
+import { Schema, Style } from '../types';
+/**
+ * A project's space put back on Plitzi as the space's draft (docs/en/projects-from-spaces.md): what `plitzi push` sends
+ * to `PUT /spaces/:spaceId/import`, and what it is answered. The way back of `SpaceExport` — one shape for both ends.
+ */
+export declare const SPACE_IMPORT_FORMAT = 1;
+export type SpaceImport = {
+    format: typeof SPACE_IMPORT_FORMAT;
+    /** The space as the project authors it: the two documents the draft is made of, replaced whole. */
+    documents: {
+        schema: Schema;
+        style: Style;
+    };
+    /**
+     * Every server action the project keeps, and every connector: the space's become exactly these. Left out, the project
+     * keeps none of its own, and the space's are left as they are.
+     */
+    actions?: {
+        identifier: string;
+        name: string;
+        document: unknown;
+    }[];
+    connectors?: {
+        identifier: string;
+        name: string;
+        manifest: unknown;
+    }[];
+    /**
+     * The draft the project was last given or last pushed (`SpaceExport.draft`): the push is refused when the space's has
+     * moved on since. `null` for a project that never had one — refused unless the space is still as it was created.
+     */
+    base: string | null;
+    /** Replace the draft whatever it holds now. */
+    force: boolean;
+};
+/** Why a push was not taken, before anything was checked: the draft is not the one the project knows. */
+export type SpaceImportRefusalCode = 'DRAFT_MOVED' | 'DRAFT_NOT_EMPTY';
+export type SpaceImportResult = 
+/** Taken: `draft` is what the project knows from now on; `changed` false when it already was the space's draft. */
+{
+    ok: true;
+    changed: boolean;
+    draft: string;
+} | {
+    ok: false;
+    refusal: {
+        code: SpaceImportRefusalCode;
+        error: string;
+    };
+}
+/** Not taken: what is wrong with what was sent, each problem where it is. */
+ | {
+    ok: false;
+    problems: string[];
+};

package/dist/source/import.mjs

@@ -0,0 +1,4 @@
+//#region src/source/import.ts
+var e = 1;
+//#endregion
+export { e as SPACE_IMPORT_FORMAT };

package/dist/source/index.d.ts

@@ -1,4 +1,6 @@
 export { readSourceSnapshot, secretIn, sourcePathProblem, SOURCE_SNAPSHOT_FORMAT, SOURCE_SNAPSHOT_LIMITS } from './snapshot';
 export { SPACE_EXPORT_FORMAT } from './export';
+export { SPACE_IMPORT_FORMAT } from './import';
 export type { SourceSnapshot, SourceSnapshotKind, SourceSnapshotReading } from './snapshot';
 export type { SpaceExport, SpaceExportConflict, SpaceExportFile } from './export';
+export type { SpaceImport, SpaceImportRefusalCode, SpaceImportResult } from './import';

package/dist/source/index.mjs

@@ -1,3 +1,4 @@
 import { SPACE_EXPORT_FORMAT as e } from "./export.mjs";
-import { SOURCE_SNAPSHOT_FORMAT as t, SOURCE_SNAPSHOT_LIMITS as n, readSourceSnapshot as r, secretIn as i, sourcePathProblem as a } from "./snapshot.mjs";
-export { t as SOURCE_SNAPSHOT_FORMAT, n as SOURCE_SNAPSHOT_LIMITS, e as SPACE_EXPORT_FORMAT, r as readSourceSnapshot, i as secretIn, a as sourcePathProblem };
+import { SPACE_IMPORT_FORMAT as t } from "./import.mjs";
+import { SOURCE_SNAPSHOT_FORMAT as n, SOURCE_SNAPSHOT_LIMITS as r, readSourceSnapshot as i, secretIn as a, sourcePathProblem as o } from "./snapshot.mjs";
+export { n as SOURCE_SNAPSHOT_FORMAT, r as SOURCE_SNAPSHOT_LIMITS, e as SPACE_EXPORT_FORMAT, t as SPACE_IMPORT_FORMAT, i as readSourceSnapshot, a as secretIn, o as sourcePathProblem };