@ikonai/sdk-ui 1.0.66 → 1.0.67

package/last-snapshot-cache.d.ts

@@ -0,0 +1,57 @@
+import { StreamSnapshot } from './ui-store';
+import { UiStreamSnapshotWire } from './ui-store-ops';
+import { UiStylePayload } from './ikon-ui-core';
+export interface LastSnapshotCacheConfig {
+    /** Stable per-app identifier (e.g. the space id). Part of the storage key. */
+    appId: string;
+    /** Connected user id, or null/undefined for anonymous. Part of the storage key. */
+    userId?: string | null;
+    /** Cached state older than this is treated as missing. Default 7 days. */
+    maxAgeMs?: number;
+    /** Serialized envelopes larger than this are dropped (not written). Default ~5 MB. */
+    maxBytes?: number;
+    /** Throttle window for writes (at most one write per window). Default 1000 ms. */
+    debounceMs?: number;
+}
+/** UI state recovered from the cache, shaped for `UiStore.applyStoreOp(ReplaceStreamSnapshot)`. */
+export interface CachedUiState {
+    streams: UiStreamSnapshotWire[];
+    styles: UiStylePayload[];
+}
+/**
+ * Persists the last rendered UI snapshot (view tree + styles) per app/user in `localStorage`, so a
+ * return visit can paint the cached tree before the WebSocket connects. The store is
+ * schema-versioned, age-bounded, size-bounded, and silent on quota/serialization failure — a cache
+ * miss always degrades cleanly to the live connect path.
+ *
+ * Binary payloads (images etc.) are **not** cached: they would dominate the size and make every
+ * write re-encode unchanged bytes. The cached tree paints layout + text instantly; payload-backed
+ * content fills in once the live connection delivers it. Writes are throttled and run at idle time.
+ *
+ * The key embeds the user id, and sibling keys for other users of the same app are pruned on
+ * construction so a shared device never paints one user's UI for another.
+ */
+export declare class LastSnapshotCache {
+    private readonly key;
+    private readonly appId;
+    private readonly userId;
+    private readonly maxAgeMs;
+    private readonly maxBytes;
+    private readonly debounceMs;
+    private writeTimer;
+    private pending;
+    constructor(config: LastSnapshotCacheConfig);
+    load(): CachedUiState | null;
+    /**
+     * Schedule a throttled write of the current UI state (at most one write per window, captured at
+     * the trailing edge). Streams with no root are skipped. The actual write runs at idle time.
+     */
+    save(streams: StreamSnapshot[], styles: readonly UiStylePayload[]): void;
+    /** Write any pending state immediately and synchronously (used on dispose / unmount). */
+    flush(): void;
+    dispose(): void;
+    private writePending;
+    private writeNow;
+    private remove;
+    private pruneOtherUsers;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikonai/sdk-ui",
-  "version": "1.0.66",
+  "version": "1.0.67",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",