nukejs 0.0.22 → 0.0.23

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { createStore, useStore } from './store';
+export { createStore, createPersistedStore, useStore } from './store';
 export type { Store } from './store';
 export { useHtml } from './use-html';
 export type { HtmlOptions } from './use-html';

package/dist/index.js

@@ -1,4 +1,4 @@
-import { createStore, useStore } from "./store.js";
+import { createStore, createPersistedStore, useStore } from "./store.js";
 import { useHtml } from "./use-html.js";
 import { default as default2 } from "./use-router.js";
 import { useRequest } from "./use-request.js";
@@ -11,6 +11,7 @@ export {
   default3 as Link,
   ansi,
   c,
+  createPersistedStore,
   createStore,
   escapeHtml,
   getDebugLevel,

package/dist/store.d.ts

@@ -65,6 +65,7 @@ interface StoreEntry<T> {
 declare global {
     interface Window {
         __nukeStores?: Map<string, StoreEntry<any>>;
+        __nukePersisted?: Set<string>;
     }
 }
 /**
@@ -80,6 +81,47 @@ declare global {
  * @param initialState  Default state used when the store is first created.
  */
 export declare function createStore<T extends object>(name: string, initialState: T): Store<T>;
+/**
+ * Creates a `Store` that survives full page refreshes by mirroring its state
+ * into `localStorage` (or `sessionStorage`).
+ *
+ * A plain `createStore` only lives in `window.__nukeStores`, which is wiped
+ * on every hard reload — fine for SPA navigations, not for data you want to
+ * keep around. `createPersistedStore` wraps `createStore` and:
+ *
+ *   1. On first creation in the browser, reads any previously saved value
+ *      from storage and applies it via `setState`.
+ *   2. Subscribes to the store and writes the new state to storage on every
+ *      change.
+ *
+ * `store.initialState` (used by `useStore` as the SSR snapshot) is left
+ * untouched as the value you passed in — the persisted value is applied
+ * *after* creation via `setState`, not by changing `initialState`. This
+ * keeps the server-rendered HTML and the client's first hydration pass in
+ * sync (no hydration mismatch); components simply re-render with the
+ * persisted value immediately after mount, the same way `useSyncExternalStore`
+ * already reconciles store mutations.
+ *
+ * Because `createStore` itself is idempotent per `name` but storage I/O is
+ * not, a `window.__nukePersisted` set guards against re-running the
+ * read/subscribe wiring if multiple bundles import the same persisted store.
+ *
+ * @param name          Unique store key — also used to derive the storage key.
+ * @param initialState  Default state used when nothing is in storage yet.
+ * @param options.storage  `'local'` (default) or `'session'`.
+ * @param options.key      Override the storage key (defaults to `nuke-store:${name}`).
+ *
+ * @example
+ * export const cartStore = createPersistedStore('cart', { items: [], total: 0 })
+ *
+ * @example
+ * // Cleared when the tab closes, kept across refreshes within the session
+ * export const draftStore = createPersistedStore('draft', { text: '' }, { storage: 'session' })
+ */
+export declare function createPersistedStore<T extends object>(name: string, initialState: T, options?: {
+    storage?: 'local' | 'session';
+    key?: string;
+}): Store<T>;
 /**
  * React hook that subscribes a component to a store.
  *

package/dist/store.js

@@ -30,6 +30,27 @@ function createStore(name, initialState) {
   };
   return { name, initialState, getState, setState, subscribe };
 }
+function createPersistedStore(name, initialState, options) {
+  const store = createStore(name, initialState);
+  if (typeof window === "undefined") return store;
+  const storageKey = options?.key ?? `nuke-store:${name}`;
+  const backend = options?.storage === "session" ? window.sessionStorage : window.localStorage;
+  if (!window.__nukePersisted) window.__nukePersisted = /* @__PURE__ */ new Set();
+  if (window.__nukePersisted.has(storageKey)) return store;
+  window.__nukePersisted.add(storageKey);
+  try {
+    const raw = backend.getItem(storageKey);
+    if (raw !== null) store.setState(JSON.parse(raw));
+  } catch {
+  }
+  store.subscribe(() => {
+    try {
+      backend.setItem(storageKey, JSON.stringify(store.getState()));
+    } catch {
+    }
+  });
+  return store;
+}
 function useStore(store, selector) {
   const getSnapshot = selector ? () => selector(store.getState()) : () => store.getState();
   const getServerSnapshot = selector ? () => selector(store.initialState) : () => store.initialState;
@@ -40,6 +61,7 @@ function useStore(store, selector) {
   );
 }
 export {
+  createPersistedStore,
   createStore,
   useStore
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nukejs",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "A minimal, opinionated full-stack React framework on Node.js that server-renders everything and hydrates only interactive parts.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",