@plitzi/nexus 0.31.1 → 0.32.0

package/dist/entities/createEntityStore.mjs

@@ -0,0 +1,102 @@
+import e from "../createStore/helpers/Subscribers.mjs";
+import { useCallback as t, useSyncExternalStore as n } from "react";
+//#region src/entities/createEntityStore.ts
+function r(r = [], i = {}) {
+	let a = i.selectId ?? ((e) => e.id), o = i.sortComparer, s = (e) => String(a(e)), c = /* @__PURE__ */ new Map();
+	for (let e of r) c.set(s(e), e);
+	let l = /* @__PURE__ */ new Map(), u = new e(), d = new e(), f, p, m = 0, h = /* @__PURE__ */ new Set(), g = !1, _ = !1, v = (e) => {
+		e && e.length > 0 && e.forEach((e) => e());
+	}, y = (e, t) => {
+		if (t && (f = void 0), p = void 0, m > 0) {
+			h.add(e), g ||= t, _ = !0;
+			return;
+		}
+		v(l.get(e)), t && v(u), v(d);
+	}, b = () => {
+		let e = [...h], t = g, n = _;
+		h.clear(), g = !1, _ = !1;
+		for (let t of e) v(l.get(t));
+		t && v(u), n && v(d);
+	}, x = (e) => {
+		m++;
+		try {
+			e();
+		} finally {
+			m--, m === 0 && _ && b();
+		}
+	}, S = (e, t, n) => {
+		let r = s(e), i = c.get(r), a = i === void 0;
+		if (t && !a) return;
+		let o = n && !a ? {
+			...i,
+			...e
+		} : e;
+		o !== i && (c.set(r, o), y(r, a));
+	}, C = (e) => {
+		S(e, !1, !1);
+	}, w = (e) => {
+		S(e, !0, !1);
+	}, T = (e) => {
+		S(e, !1, !0);
+	}, E = (e, t) => {
+		let n = String(e), r = c.get(n);
+		r !== void 0 && (c.set(n, {
+			...r,
+			...t
+		}), y(n, !1));
+	}, D = (e) => {
+		let t = String(e);
+		c.has(t) && (c.delete(t), y(t, !0));
+	}, O = (e) => c.get(String(e)), k = () => f ??= [...c.keys()], A = () => {
+		if (p === void 0) {
+			let e = [...c.values()];
+			p = o ? e.sort(o) : e;
+		}
+		return p;
+	}, j = (t, n) => {
+		let r = String(t), i = l.get(r);
+		i || (i = new e(), l.set(r, i));
+		let a = i, o = a.add(n);
+		return () => {
+			o(), a.length === 0 && l.get(r) === a && l.delete(r);
+		};
+	}, M = (e) => u.add(e), N = (e) => d.add(e);
+	return {
+		selectId: a,
+		getOne: O,
+		getIds: k,
+		getAll: A,
+		has: (e) => c.has(String(e)),
+		size: () => c.size,
+		setOne: C,
+		setMany: (e) => x(() => e.forEach(C)),
+		setAll: (e) => x(() => {
+			for (let e of [...c.keys()]) D(e);
+			e.forEach(C);
+		}),
+		addOne: w,
+		addMany: (e) => x(() => e.forEach(w)),
+		upsertOne: T,
+		upsertMany: (e) => x(() => e.forEach(T)),
+		updateOne: E,
+		updateMany: (e) => x(() => e.forEach(({ id: e, changes: t }) => E(e, t))),
+		removeOne: D,
+		removeMany: (e) => x(() => e.forEach(D)),
+		removeAll: () => x(() => [...c.keys()].forEach(D)),
+		batch: x,
+		subscribeOne: j,
+		subscribeIds: M,
+		subscribeAll: N,
+		useOne: (e) => {
+			let r = String(e), i = t((e) => j(r, e), [r]), a = t(() => c.get(r), [r]);
+			return n(i, a, a);
+		},
+		useIds: () => n(M, k, k),
+		useAll: () => n(N, A, A),
+		destroy: () => {
+			c.clear(), l.clear(), u.clear(), d.clear(), f = void 0, p = void 0;
+		}
+	};
+}
+//#endregion
+export { r as createEntityStore };

package/dist/entities/index.d.ts

@@ -1,2 +1,4 @@
 export { createEntityAdapter } from './createEntityAdapter';
+export { createEntityStore } from './createEntityStore';
 export type { EntityAdapter, EntityAdapterOptions, EntityId, EntityMap, EntityUpdate, EntityUpdater } from './createEntityAdapter';
+export type { EntityStore, EntityStoreOptions, EntityChangeListener } from './createEntityStore';

package/dist/entities/index.mjs

@@ -1,2 +1,3 @@
 import { createEntityAdapter as e } from "./createEntityAdapter.mjs";
-export { e as createEntityAdapter };
+import { createEntityStore as t } from "./createEntityStore.mjs";
+export { e as createEntityAdapter, t as createEntityStore };

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export * from './createStore/hooks/useStoreById';
 export * from './types';
 export { createStore, StoreProvider, useStoreById, useStoreSetter };
 export { setCodegenEnabled } from './createStore/helpers/writeByPath';
+export { createServerSnapshot, isServerSnapshot } from './rsc';

package/dist/index.mjs

@@ -10,12 +10,14 @@ import l from "./createStore/index.mjs";
 import { createDerived as u } from "./derived/createDerived.mjs";
 import { useDerived as d } from "./derived/hooks/useDerived.mjs";
 import { createEntityAdapter as f } from "./entities/createEntityAdapter.mjs";
-import { getStoreHistory as p, historyMiddleware as m } from "./middleware/historyMiddleware.mjs";
-import { useStoreHistory as h } from "./history/hooks/useStoreHistory.mjs";
-import g from "./createStore/hooks/useStoreById.mjs";
-import _ from "./StoreProvider.mjs";
-import { loggerMiddleware as v } from "./middleware/loggerMiddleware.mjs";
-import { persistMiddleware as y } from "./middleware/persistMiddleware.mjs";
-import { reduxDevToolsMiddleware as b } from "./middleware/reduxDevToolsMiddleware.mjs";
-import { cascade as x } from "./middleware/cascade.mjs";
-export { i as CANCEL, a as StoreContext, _ as StoreProvider, o as StoreRegistryContext, x as cascade, e as createAsync, u as createDerived, f as createEntityAdapter, l as createStore, c as createStoreHook, p as getStoreHistory, m as historyMiddleware, v as loggerMiddleware, y as persistMiddleware, b as reduxDevToolsMiddleware, r as setCodegenEnabled, t as useAsync, n as useAsyncValue, d as useDerived, g as useStoreById, h as useStoreHistory, s as useStoreSetter };
+import { createEntityStore as p } from "./entities/createEntityStore.mjs";
+import { getStoreHistory as m, historyMiddleware as h } from "./middleware/historyMiddleware.mjs";
+import { useStoreHistory as g } from "./history/hooks/useStoreHistory.mjs";
+import _ from "./createStore/hooks/useStoreById.mjs";
+import { createServerSnapshot as v, isServerSnapshot as y } from "./rsc/index.mjs";
+import b from "./StoreProvider.mjs";
+import { loggerMiddleware as x } from "./middleware/loggerMiddleware.mjs";
+import { persistMiddleware as S } from "./middleware/persistMiddleware.mjs";
+import { reduxDevToolsMiddleware as C } from "./middleware/reduxDevToolsMiddleware.mjs";
+import { cascade as w } from "./middleware/cascade.mjs";
+export { i as CANCEL, a as StoreContext, b as StoreProvider, o as StoreRegistryContext, w as cascade, e as createAsync, u as createDerived, f as createEntityAdapter, p as createEntityStore, v as createServerSnapshot, l as createStore, c as createStoreHook, m as getStoreHistory, h as historyMiddleware, y as isServerSnapshot, x as loggerMiddleware, S as persistMiddleware, C as reduxDevToolsMiddleware, r as setCodegenEnabled, t as useAsync, n as useAsyncValue, d as useDerived, _ as useStoreById, g as useStoreHistory, s as useStoreSetter };

package/dist/middleware/historyMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { Path, StoreApi, StoreMiddleware } from '../types';
+import { MiddlewareOptions, Path, StoreApi, StoreMiddleware } from '../types';
 export type HistoryEntry<TState> = {
     path?: Path;
     value?: unknown;
@@ -19,10 +19,10 @@ export type StoreHistory<TState> = {
     travelTo: (index: number) => void;
     clear: () => void;
 };
-export type StoreHistoryOptions = {
+export type StoreHistoryOptions<TState extends object = object> = MiddlewareOptions<TState> & {
     limit?: number;
     path?: Path;
     shouldRecord?: (changedPath: Path | undefined) => boolean;
 };
 export declare function getStoreHistory<TState extends object>(store: StoreApi<TState>): StoreHistory<TState> | undefined;
-export declare const historyMiddleware: <TState extends object>(options?: StoreHistoryOptions) => StoreMiddleware<TState>;
+export declare const historyMiddleware: <TState extends object>(options?: StoreHistoryOptions<TState>) => StoreMiddleware<TState>;

package/dist/middleware/historyMiddleware.mjs

@@ -1,16 +1,17 @@
 import { isPlainObject as e } from "../createStore/helpers/deepMerge.mjs";
 import t from "../helpers/getByPath.mjs";
-import n from "../helpers/isPathAffected.mjs";
+import { isDisabled as n } from "./isDisabled.mjs";
+import r from "../helpers/isPathAffected.mjs";
 //#region src/middleware/historyMiddleware.ts
-var r = (t, n, i = 12) => {
+var i = (t, n, r = 12) => {
 	if (!Object.is(t, n)) {
-		if (i <= 0 || !e(t) || !e(n)) return {
+		if (r <= 0 || !e(t) || !e(n)) return {
 			path: "",
 			value: n
 		};
 		for (let e of new Set([...Object.keys(t), ...Object.keys(n)])) {
 			if (Object.is(t[e], n[e])) continue;
-			let a = r(t[e], n[e], i - 1);
+			let a = i(t[e], n[e], r - 1);
 			if (a) return {
 				path: a.path ? `${e}.${a.path}` : e,
 				value: a.value
@@ -18,8 +19,8 @@ var r = (t, n, i = 12) => {
 		}
 	}
 };
-function i(e, i = {}) {
-	let a = i.limit ?? 100, o = i.path, s = i.shouldRecord, c = [{
+function a(e, n = {}) {
+	let a = n.limit ?? 100, o = n.path, s = n.shouldRecord, c = [{
 		state: e.getState(),
 		timestamp: Date.now()
 	}], l = 0, u = !1, d = () => ({
@@ -29,11 +30,11 @@ function i(e, i = {}) {
 		canRedo: l < c.length - 1
 	}), f = d(), p = /* @__PURE__ */ new Set(), m = () => {
 		f = d(), p.forEach((e) => e());
-	}, h = ({ path: i }) => {
-		if (u || s && !s(i) || o && i !== void 0 && !n(i, o)) return;
-		let d = l < c.length - 1 ? c.slice(0, l + 1) : c, f = d[d.length - 1].state, p = e.getState(), h = i ?? o, g, _ = i ?? o;
+	}, h = ({ path: n }) => {
+		if (u || s && !s(n) || o && n !== void 0 && !r(n, o)) return;
+		let d = l < c.length - 1 ? c.slice(0, l + 1) : c, f = d[d.length - 1].state, p = e.getState(), h = n ?? o, g, _ = n ?? o;
 		if (_) try {
-			let e = r(t(f, _), t(p, _));
+			let e = i(t(f, _), t(p, _));
 			e && (h = e.path ? `${_}.${e.path}` : _, g = e.value);
 		} catch {}
 		let v = [...d, {
@@ -69,13 +70,17 @@ function i(e, i = {}) {
 		record: h
 	};
 }
-var a = /* @__PURE__ */ new WeakMap();
-function o(e) {
-	return a.get(e);
+var o = /* @__PURE__ */ new WeakMap();
+function s(e) {
+	return o.get(e);
 }
-var s = (e) => (t) => {
-	let { handle: n, record: r } = i(t, e);
-	return a.set(t, n), { onChange: r };
+var c = (e) => {
+	let t = e?.enabled;
+	return (r) => {
+		if (n(t, r.getState())) return;
+		let { handle: i, record: s } = a(r, e);
+		return o.set(r, i), { onChange: s };
+	};
 };
 //#endregion
-export { o as getStoreHistory, s as historyMiddleware };
+export { s as getStoreHistory, c as historyMiddleware };

package/dist/middleware/index.d.ts

@@ -4,5 +4,5 @@ export { historyMiddleware } from './historyMiddleware';
 export { reduxDevToolsMiddleware } from './reduxDevToolsMiddleware';
 export { cascade } from './cascade';
 export type { LoggerOptions } from './loggerMiddleware';
-export type { PersistOptions, PersistStorage } from './persistMiddleware';
+export type { PersistOptions, PersistStorage, PersistTarget, PersistTargetOption } from './persistMiddleware';
 export type { ReduxDevToolsOptions } from './reduxDevToolsMiddleware';

package/dist/middleware/isDisabled.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareOptions } from '../types';
+export declare const isDisabled: <T extends object>(enabled: MiddlewareOptions<T>["enabled"], state: T) => boolean;

package/dist/middleware/isDisabled.mjs

@@ -0,0 +1,4 @@
+//#region src/middleware/isDisabled.ts
+var e = (e, t) => typeof e == "function" ? !e(t) : e === !1;
+//#endregion
+export { e as isDisabled };

package/dist/middleware/loggerMiddleware.d.ts

@@ -1,5 +1,5 @@
-import { StoreChange, StoreError, StoreMiddleware } from '../types';
-export type LoggerOptions<TState extends object> = {
+import { MiddlewareOptions, StoreChange, StoreError, StoreMiddleware } from '../types';
+export type LoggerOptions<TState extends object> = MiddlewareOptions<TState> & {
     filter?: (change: StoreChange<TState>) => boolean;
     sink?: (change: StoreChange<TState>) => void;
     errorSink?: (failure: StoreError<TState>) => void;

package/dist/middleware/loggerMiddleware.mjs

@@ -1,20 +1,19 @@
+import { isDisabled as e } from "./isDisabled.mjs";
 //#region src/middleware/loggerMiddleware.ts
-var e = (e) => {
+var t = (e) => {
 	console.log("[store]", e.path ?? "(root)", e.next);
-}, t = (e) => {
+}, n = (e) => {
 	console.error("[store]", `${e.phase} error at`, e.path ?? "(root)", e.error);
-}, n = (n = {}) => {
-	let { filter: r, sink: i = e, errorSink: a = t } = typeof n == "function" ? {
-		filter: void 0,
-		sink: n,
-		errorSink: t
-	} : n;
-	return () => ({
-		onChange: (e) => {
-			(!r || r(e)) && i(e);
-		},
-		onError: a
-	});
+}, r = (r = {}) => {
+	let { filter: i, sink: a = t, errorSink: o = n, enabled: s } = typeof r == "function" ? { sink: r } : r;
+	return (t) => {
+		if (!e(s, t.getState())) return {
+			onChange: (e) => {
+				(!i || i(e)) && a(e);
+			},
+			onError: o
+		};
+	};
 };
 //#endregion
-export { n as loggerMiddleware };
+export { r as loggerMiddleware };

package/dist/middleware/persistMiddleware.d.ts

@@ -1,16 +1,18 @@
-import { StoreMiddleware } from '../types';
+import { MiddlewareOptions, PathOf, StoreMiddleware } from '../types';
 export type PersistStorage = {
     getItem: (key: string) => string | null;
     setItem: (key: string, value: string) => void;
     removeItem: (key: string) => void;
 };
-export type PersistOptions<TState extends object> = {
+export type PersistTarget = PersistStorage | 'local' | 'session';
+export type PersistTargetOption<TState extends object> = PersistTarget | ((state: TState) => PersistTarget | false);
+export type PersistOptions<TState extends object> = MiddlewareOptions<TState> & {
     key: string;
-    storage?: PersistStorage;
+    storage?: PersistTargetOption<TState>;
+    paths?: ReadonlyArray<PathOf<TState>>;
     partialize?: (state: TState) => Partial<TState>;
     version?: number;
-    migrate?: (persisted: unknown, version: number) => Partial<TState>;
+    migrate?: (persisted: unknown, version: number) => unknown;
     merge?: (persisted: Partial<TState>, current: TState) => Partial<TState>;
-    debounce?: number;
 };
 export declare const persistMiddleware: <TState extends object>(options: PersistOptions<TState>) => StoreMiddleware<TState>;

package/dist/middleware/persistMiddleware.mjs

@@ -1,36 +1,68 @@
+import e from "../helpers/getByPath.mjs";
+import { isDisabled as t } from "./isDisabled.mjs";
+import n from "../helpers/isPathAffected.mjs";
 //#region src/middleware/persistMiddleware.ts
-var e = {
-	getItem: () => null,
-	setItem: () => {},
-	removeItem: () => {}
-}, t = () => typeof localStorage < "u" ? localStorage : e, n = (e) => {
-	let { key: n, storage: i = t(), partialize: a, version: o = 0, migrate: s, merge: c, debounce: l = 0 } = e, u = (e) => {
-		let t = e.getState(), r = {
-			version: o,
-			state: a ? a(t) : t
+var r = (e = "local") => {
+	if (typeof e != "string") return e;
+	try {
+		return e === "session" ? globalThis.sessionStorage : globalThis.localStorage;
+	} catch {
+		return;
+	}
+}, i = (i) => {
+	let { key: o, storage: s, paths: c, partialize: l, version: u = 0, migrate: d, merge: f, enabled: p } = i, m = typeof s == "function" ? s : void 0, h = typeof s == "function" ? void 0 : r(s);
+	if (!m && !h) return () => void 0;
+	let g = (e) => {
+		if (!m) return h;
+		let t = m(e);
+		return t ? r(t) : void 0;
+	}, _ = (t) => {
+		if (c) {
+			let n = {};
+			for (let r of c) n[r] = e(t, r);
+			return n;
+		}
+		return l ? l(t) : t;
+	}, v = (e) => {
+		let t = e.getState(), n = g(t);
+		if (!n) return;
+		let r = {
+			version: u,
+			state: _(t)
 		};
-		i.setItem(n, JSON.stringify(r));
-	};
+		n.setItem(o, JSON.stringify(r));
+	}, y = (e) => !c || c.some((t) => n(e, t));
 	return (e) => {
-		r(e, n, i, o, s, c);
-		let t;
-		return { onChange: () => {
-			if (l <= 0) {
-				u(e);
-				return;
+		if (t(p, e.getState())) return;
+		let n = !1, r = () => {
+			if (n) return;
+			let t = g(e.getState());
+			t && (n = !0, a(e, o, t, u, c, d, f));
+		};
+		return {
+			hydrate: r,
+			onChange: (t) => {
+				r(), y(t.path) && v(e);
 			}
-			clearTimeout(t), t = setTimeout(() => u(e), l);
-		} };
+		};
 	};
 };
-function r(e, t, n, r, i, a) {
-	let o = n.getItem(t);
-	if (o) try {
-		let t = JSON.parse(o), n = t.version !== r && i ? i(t.state, t.version) : t.state;
-		e.setState(void 0, a ? a(n, e.getState()) : n);
+function a(e, t, n, r, i, a, o) {
+	let s = n?.getItem(t);
+	if (s) try {
+		let t = JSON.parse(s), n = t.version !== r && a ? a(t.state, t.version) : t.state;
+		if (i) {
+			let t = n;
+			e.batch(() => {
+				for (let n of i) n in t && e.setState(n, t[n]);
+			});
+			return;
+		}
+		let c = n;
+		e.setState(void 0, o ? o(c, e.getState()) : c);
 	} catch {
-		n.removeItem(t);
+		n?.removeItem(t);
 	}
 }
 //#endregion
-export { n as persistMiddleware };
+export { i as persistMiddleware };

package/dist/middleware/reduxDevToolsMiddleware.d.ts

@@ -1,5 +1,5 @@
-import { StoreChange, StoreMiddleware } from '../types';
-export type ReduxDevToolsOptions<TState extends object> = {
+import { MiddlewareOptions, StoreChange, StoreMiddleware } from '../types';
+export type ReduxDevToolsOptions<TState extends object> = MiddlewareOptions<TState> & {
     name?: string;
     action?: (change: StoreChange<TState>) => string;
 };

package/dist/middleware/reduxDevToolsMiddleware.mjs

@@ -1,26 +1,31 @@
+import { isDisabled as e } from "./isDisabled.mjs";
 //#region src/middleware/reduxDevToolsMiddleware.ts
-var e = () => {
+var t = () => {
 	if (!(typeof window > "u")) return window.__REDUX_DEVTOOLS_EXTENSION__;
-}, t = (t = {}) => (n) => {
-	let r = e();
-	if (!r) return;
-	let { name: i = "nexus", action: a } = t, o = r.connect({ name: i });
-	o.init(n.getState());
-	let s = !1;
-	return o.subscribe((e) => {
-		if (e.type !== "DISPATCH" || e.state === void 0) return;
-		let t = e.payload?.type;
-		if (!(t !== "JUMP_TO_STATE" && t !== "JUMP_TO_ACTION" && t !== "ROLLBACK")) {
-			s = !0;
-			try {
-				n.setState(void 0, JSON.parse(e.state));
-			} finally {
-				s = !1;
+}, n = (n = {}) => {
+	let { enabled: r } = n;
+	return (i) => {
+		if (e(r, i.getState())) return;
+		let a = t();
+		if (!a) return;
+		let { name: o = "nexus", action: s } = n, c = a.connect({ name: o });
+		c.init(i.getState());
+		let l = !1;
+		return c.subscribe((e) => {
+			if (e.type !== "DISPATCH" || e.state === void 0) return;
+			let t = e.payload?.type;
+			if (!(t !== "JUMP_TO_STATE" && t !== "JUMP_TO_ACTION" && t !== "ROLLBACK")) {
+				l = !0;
+				try {
+					i.setState(void 0, JSON.parse(e.state));
+				} finally {
+					l = !1;
+				}
 			}
-		}
-	}), { onChange: (e) => {
-		s || o.send({ type: a ? a(e) : e.path ?? "SET_STATE" }, n.getState());
-	} };
+		}), { onChange: (e) => {
+			l || c.send({ type: s ? s(e) : e.path ?? "SET_STATE" }, i.getState());
+		} };
+	};
 };
 //#endregion
-export { t as reduxDevToolsMiddleware };
+export { n as reduxDevToolsMiddleware };

package/dist/next/index.d.ts

@@ -0,0 +1,26 @@
+import { PathOf, PathValue, StoreApi } from '../types';
+export type ServerActionResult<TState extends object, P extends PathOf<TState>> = (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => Promise<void>;
+/**
+ * Binds a Nexus store path to a Next.js Server Action, giving you
+ * optimistic updates + automatic revalidation.
+ *
+ * ```ts
+ * 'use client';
+ * import { useStore } from '@plitzi/nexus';
+ * import { bindServerAction } from '@plitzi/nexus/next';
+ *
+ * function Likes({ store, updateLikes }: { store: StoreApi<State>; updateLikes: ServerAction }) {
+ *   const [likes, setLikes] = useStore('likes');
+ *   const syncLikes = bindServerAction(store, 'likes', updateLikes, { revalidatePath: '/dashboard' });
+ *
+ *   return <button onClick={() => syncLikes(n => n + 1)}>{likes}</button>;
+ * }
+ * ```
+ *
+ * ⚠️ This file imports from `next/cache` dynamically. It only works within
+ * Next.js App Router — not a peer dependency, just a compatibility layer.
+ */
+export declare function bindServerAction<TState extends object, P extends PathOf<TState>>(store: StoreApi<TState>, path: P, action: (value: PathValue<TState, P>) => Promise<PathValue<TState, P>>, options?: {
+    revalidatePath?: string;
+    revalidateTag?: string;
+}): ServerActionResult<TState, P>;

package/dist/next/index.mjs

@@ -0,0 +1,18 @@
+//#region src/next/index.ts
+function e(e, t, n, r) {
+	let i = r?.revalidatePath || r?.revalidateTag;
+	return async (a) => {
+		let o = e.getPath(t), s = typeof a == "function" ? a(o) : a;
+		e.setState(t, s);
+		try {
+			if (await n(s), i) {
+				let e = await import("next/cache");
+				r.revalidatePath && e.revalidatePath(r.revalidatePath), r.revalidateTag && e.revalidateTag(r.revalidateTag);
+			}
+		} catch (n) {
+			throw e.setState(t, o), n;
+		}
+	};
+}
+//#endregion
+export { e as bindServerAction };

package/dist/rsc/index.d.ts

@@ -0,0 +1,29 @@
+declare const SSR_FLAG: unique symbol;
+type WithSsrFlag<T> = T & {
+    readonly [SSR_FLAG]: true;
+};
+/**
+ * Wraps server-fetched data so Nexus knows it came from SSR.
+ *
+ * Usage in a Server Component (App Router):
+ *
+ * ```tsx
+ * import { createServerSnapshot } from '@plitzi/nexus/rsc';
+ * import { StoreProvider } from '@plitzi/nexus';
+ *
+ * export default async function Page() {
+ *   const data = await fetch('https://api.example.com/user');
+ *   return (
+ *     <StoreProvider value={createServerSnapshot(data)}>
+ *       <ClientComponent />
+ *     </StoreProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function createServerSnapshot<T extends object>(data: T): WithSsrFlag<T>;
+/** @internal */
+export declare function isServerSnapshot<T>(value: T): value is WithSsrFlag<T>;
+/** @internal Strip the SSR flag from a snapshot (returns a plain object). */
+export declare function stripServerFlag<T extends object>(value: T): T;
+export {};

package/dist/rsc/index.mjs

@@ -0,0 +1,18 @@
+//#region src/rsc/index.ts
+var e = Symbol("@plitzi/nexus/ssr-snapshot");
+function t(t) {
+	return e in t ? t : Object.defineProperty(t, e, {
+		value: !0,
+		enumerable: !1,
+		writable: !1,
+		configurable: !1
+	});
+}
+function n(t) {
+	return typeof t == "object" && !!t && e in t;
+}
+function r(e) {
+	return n(e) ? { ...e } : e;
+}
+//#endregion
+export { t as createServerSnapshot, n as isServerSnapshot, r as stripServerFlag };