@useavalon/avalon 0.1.47 → 0.1.49

package/dist/src/core/islands/island-persistence.d.ts

@@ -1,74 +0,0 @@
-import type { IslandState } from '../../schemas/layout.ts';
-import type { IIslandPersistence } from '../../types/layout.ts';
-/**
- * IslandPersistence class for state management across navigation
- *
- * Handles saving, loading, and clearing island state using browser storage
- * with support for both sessionStorage and localStorage persistence strategies.
- */
-export declare class IslandPersistence implements IIslandPersistence {
-    private storageType;
-    private keyPrefix;
-    private storage;
-    constructor(options?: {
-        storageType?: 'session' | 'local';
-        keyPrefix?: string;
-    });
-    /**
-     * Save island state to browser storage
-     */
-    saveState(id: string, state: IslandState): void;
-    /**
-     * Load island state from browser storage
-     */
-    loadState(id: string): IslandState | null;
-    /**
-     * Clear island state from browser storage
-     */
-    clearState(id: string): void;
-    /**
-     * Check if state exists for an island
-     */
-    hasState(id: string): boolean;
-    /**
-     * Get all stored island IDs
-     */
-    getStoredIds(): string[];
-    /**
-     * Clear all stored states
-     */
-    clearAllStates(): void;
-    /**
-     * Get the storage key for an island ID
-     */
-    private getStorageKey;
-    /**
-     * Get current storage configuration
-     */
-    getConfig(): {
-        storageType: string;
-        keyPrefix: string;
-        available: boolean;
-    };
-    /**
-     * Get storage usage statistics
-     */
-    getStorageStats(): {
-        totalKeys: number;
-        islandKeys: number;
-        estimatedSize: number;
-    };
-    /**
-     * JSON.stringify replacer function to handle special types
-     */
-    private replacer;
-    /**
-     * JSON.parse reviver function to restore special types
-     */
-    private reviver;
-}
-/**
- * Default island persistence instance
- * Uses sessionStorage by default for better privacy and performance
- */
-export declare const defaultIslandPersistence: IslandPersistence;

package/dist/src/core/islands/island-persistence.js

@@ -1 +0,0 @@
-import{IslandStateSerializer as e}from"./island-state-serializer.js";export class IslandPersistence{storageType;keyPrefix;storage=null;constructor(e={}){this.storageType=e.storageType||`session`,this.keyPrefix=e.keyPrefix||`island-state`,typeof window<`u`&&(this.storage=this.storageType===`session`?sessionStorage:localStorage)}saveState(t,n){if(!this.storage){console.warn(`Island persistence: Storage not available (server-side or unsupported browser)`);return}try{let r=this.getStorageKey(t),i=e.serialize({state:n,timestamp:Date.now(),version:`1.0`});this.storage.setItem(r,i),console.log(`Island state saved for ${t}`)}catch(e){console.error(`Failed to save island state for ${t}:`,e)}}loadState(t){if(!this.storage)return console.warn(`Island persistence: Storage not available (server-side or unsupported browser)`),null;try{let n=this.getStorageKey(t),r=this.storage.getItem(n);if(!r)return null;let i=e.deserialize(r);return!i.state||!i.timestamp||!i.version?(console.warn(`Invalid island state format for ${t}, clearing...`),this.clearState(t),null):(console.log(`Island state loaded for ${t}`),i.state)}catch(e){return console.error(`Failed to load island state for ${t}:`,e),this.clearState(t),null}}clearState(e){if(this.storage)try{let t=this.getStorageKey(e);this.storage.removeItem(t),console.log(`Island state cleared for ${e}`)}catch(t){console.error(`Failed to clear island state for ${e}:`,t)}}hasState(e){if(!this.storage)return!1;try{let t=this.getStorageKey(e);return this.storage.getItem(t)!==null}catch(t){return console.error(`Failed to check island state for ${e}:`,t),!1}}getStoredIds(){if(!this.storage)return[];try{let e=[],t=this.keyPrefix.length+1;for(let n=0;n<this.storage.length;n++){let r=this.storage.key(n);r&&r.startsWith(this.keyPrefix+`:`)&&e.push(r.substring(t))}return e}catch(e){return console.error(`Failed to get stored island IDs:`,e),[]}}clearAllStates(){if(this.storage)try{let e=[];for(let t=0;t<this.storage.length;t++){let n=this.storage.key(t);n&&n.startsWith(this.keyPrefix+`:`)&&e.push(n)}e.forEach(e=>this.storage.removeItem(e)),console.log(`Cleared ${e.length} island states`)}catch(e){console.error(`Failed to clear all island states:`,e)}}getStorageKey(e){return`${this.keyPrefix}:${e}`}getConfig(){return{storageType:this.storageType,keyPrefix:this.keyPrefix,available:this.storage!==null}}getStorageStats(){if(!this.storage)return{totalKeys:0,islandKeys:0,estimatedSize:0};try{let e=0,t=0;for(let n=0;n<this.storage.length;n++){let r=this.storage.key(n);if(r&&r.startsWith(this.keyPrefix+`:`)){e++;let n=this.storage.getItem(r);n&&(t+=r.length+n.length)}}return{totalKeys:this.storage.length,islandKeys:e,estimatedSize:t}}catch(e){return console.error(`Failed to get storage stats:`,e),{totalKeys:0,islandKeys:0,estimatedSize:0}}}replacer(e,t){return t instanceof Date?{__type:`Date`,__value:t.toISOString()}:t instanceof RegExp?{__type:`RegExp`,__value:{source:t.source,flags:t.flags}}:t instanceof Map?{__type:`Map`,__value:Array.from(t.entries())}:t instanceof Set?{__type:`Set`,__value:Array.from(t.values())}:typeof t==`function`?(console.warn(`Function found in island state at key "${e}", converting to null`),null):t===void 0?null:t}reviver(e,t){if(t&&typeof t==`object`){let e=t;if(e.__type&&e.__value!==void 0)switch(e.__type){case`Date`:return new Date(e.__value);case`RegExp`:{let t=e.__value;return new RegExp(t.source,t.flags)}case`Map`:return new Map(e.__value);case`Set`:return new Set(e.__value);default:return console.warn(`Unknown special type "${e.__type}" in serialized state`),e.__value}}return t}}export const defaultIslandPersistence=new IslandPersistence({storageType:`session`,keyPrefix:`island-state`});

package/dist/src/core/islands/island-state-serializer.d.ts

@@ -1,53 +0,0 @@
-import type { IslandState } from '../../schemas/layout.ts';
-/**
- * Island State Serializer
- *
- * Handles serialization and deserialization of island state for browser storage.
- * Supports complex data types including Dates, RegExp, and circular references.
- */
-export declare class IslandStateSerializer {
-    /**
-     * Serialize island state to JSON string
-     */
-    static serialize(state: IslandState): string;
-    /**
-     * Deserialize JSON string to island state
-     */
-    static deserialize(serializedState: string): IslandState;
-    /**
-     * Transform state for serialization, handling special types
-     */
-    private static transformForSerialization;
-    /**
-     * JSON.parse reviver function to restore special types
-     */
-    private static reviver;
-    /**
-     * Validate that state can be safely serialized
-     */
-    static validate(state: IslandState): {
-        valid: boolean;
-        errors: string[];
-    };
-    /**
-     * Get size information for serialized state
-     */
-    static getSize(state: IslandState): {
-        bytes: number;
-        kilobytes: number;
-        megabytes: number;
-        readable: string;
-    };
-    /**
-     * Deep clone state object (useful for preventing mutations)
-     */
-    static clone(state: IslandState): IslandState;
-    /**
-     * Compare two states for equality
-     */
-    static equals(state1: IslandState, state2: IslandState): boolean;
-    /**
-     * Sanitize state by removing non-serializable values
-     */
-    static sanitize(state: IslandState): IslandState;
-}

package/dist/src/core/islands/island-state-serializer.js

@@ -1 +0,0 @@
-export class IslandStateSerializer{static serialize(t){try{let n=IslandStateSerializer.transformForSerialization(t);return JSON.stringify(n)}catch(e){throw console.error(`Failed to serialize island state:`,e),Error(`State serialization failed: ${e instanceof Error?e.message:String(e)}`)}}static deserialize(t){try{return JSON.parse(t,IslandStateSerializer.reviver)}catch(e){throw console.error(`Failed to deserialize island state:`,e),Error(`State deserialization failed: ${e instanceof Error?e.message:String(e)}`)}}static transformForSerialization(t){if(t===null)return t;if(t===void 0)return null;if(t instanceof Date)return{__type:`Date`,__value:t.toISOString()};if(t instanceof RegExp)return{__type:`RegExp`,__value:{source:t.source,flags:t.flags}};if(t instanceof Map)return{__type:`Map`,__value:Array.from(t.entries()).map(([t,n])=>[IslandStateSerializer.transformForSerialization(t),IslandStateSerializer.transformForSerialization(n)])};if(t instanceof Set)return{__type:`Set`,__value:Array.from(t.values()).map(t=>IslandStateSerializer.transformForSerialization(t))};if(typeof t==`function`)return console.warn(`Function found in island state, converting to null`),null;if(Array.isArray(t))return t.map(t=>IslandStateSerializer.transformForSerialization(t));if(typeof t==`object`){let n={},r=t;for(let t in r)Object.hasOwn(r,t)&&(n[t]=IslandStateSerializer.transformForSerialization(r[t]));return n}return t}static reviver(e,t){if(t&&typeof t==`object`){let e=t;if(e.__type&&e.__value!==void 0)switch(e.__type){case`Date`:return new Date(e.__value);case`RegExp`:{let t=e.__value;return new RegExp(t.source,t.flags)}case`Map`:return new Map(e.__value);case`Set`:return new Set(e.__value);case`undefined`:return null;default:return console.warn(`Unknown special type "${typeof e.__type==`string`?e.__type:`non-string`}" in serialized state`),e.__value}}return t}static validate(e){let t=[];try{let n=this.serialize(e),r=new Blob([n]).size,i=5*1024*1024;r>i&&t.push(`Serialized state size (${Math.round(r/1024)}KB) exceeds recommended limit (${Math.round(i/1024)}KB)`),this.deserialize(n)}catch(e){t.push(e instanceof Error?e.message:String(e))}return{valid:t.length===0,errors:t}}static getSize(e){try{let t=this.serialize(e),n=new Blob([t]).size,r=n/1024,i=r/1024,a;return a=i>=1?`${i.toFixed(2)} MB`:r>=1?`${r.toFixed(2)} KB`:`${n} bytes`,{bytes:n,kilobytes:r,megabytes:i,readable:a}}catch(e){return console.error(`Failed to calculate state size:`,e),{bytes:0,kilobytes:0,megabytes:0,readable:`0 bytes`}}}static clone(e){try{let t=this.serialize(e);return this.deserialize(t)}catch(t){return console.error(`Failed to clone island state:`,t),{...e}}}static equals(e,t){try{return this.serialize(e)===this.serialize(t)}catch(e){return console.error(`Failed to compare island states:`,e),!1}}static sanitize(e){try{let t=this.serialize(e);return this.deserialize(t)}catch(e){return console.error(`Failed to sanitize island state:`,e),{}}}}

package/dist/src/core/islands/persistent-island-context.d.ts

@@ -1,36 +0,0 @@
-import type { ComponentChildren } from 'preact';
-import type { IslandState } from '../../schemas/layout.ts';
-import { defaultIslandPersistence } from './island-persistence.ts';
-/**
- * Explicit interface for persistent island context
- * (Zod z.any() inference for function types is unreliable)
- */
-export interface PersistentIslandContextType {
-    saveState: (state: IslandState) => void;
-    loadState: () => IslandState | null;
-    clearState: () => void;
-}
-/**
- * Context for persistent island state operations
- *
- * Provides save, load, and clear operations for island state management
- * across navigation and browser sessions.
- */
-export declare const PersistentIslandContextProvider: import("preact").Context<PersistentIslandContextType>;
-/**
- * Create a persistent island context for a specific island ID
- */
-export declare function createPersistentIslandContext(persistentId: string, persistence?: import("./island-persistence.ts").IslandPersistence): PersistentIslandContextType;
-/**
- * Hook to use persistent island context
- * Must be used within a PersistentIsland component
- */
-export declare function usePersistentIslandContext(): PersistentIslandContextType;
-/**
- * Provider component for persistent island context
- */
-export declare function PersistentIslandProvider({ persistentId, children, persistence, }: Readonly<{
-    persistentId: string;
-    children: ComponentChildren;
-    persistence?: typeof defaultIslandPersistence;
-}>): import("preact").JSX.Element;

package/dist/src/core/islands/persistent-island-context.js

@@ -1 +0,0 @@
-import{createContext as e}from"preact";import{useContext as t}from"preact/hooks";import{defaultIslandPersistence as n}from"./island-persistence.js";import{jsx as r}from"preact/jsx-runtime";export const PersistentIslandContextProvider=e(null);export function createPersistentIslandContext(e,t=n){return{saveState:n=>{t.saveState(e,n)},loadState:()=>t.loadState(e),clearState:()=>{t.clearState(e)}}}export function usePersistentIslandContext(){let e=t(PersistentIslandContextProvider);if(!e)throw Error(`usePersistentIslandContext must be used within a PersistentIsland component`);return e}export function PersistentIslandProvider({persistentId:e,children:t,persistence:i=n}){let a=createPersistentIslandContext(e,i);return r(PersistentIslandContextProvider.Provider,{value:a,children:t})}

package/dist/src/core/islands/use-persistent-state.d.ts

@@ -1,17 +0,0 @@
-/**
- * Hook for persistent island state — like useState but survives navigations.
- *
- * State is serialized to sessionStorage (supports Date, Map, Set, RegExp).
- * On the server or when storage is unavailable, falls back to in-memory state.
- *
- * ```tsx
- * const [count, setCount, clearCount] = usePersistentState('my-counter', 0);
- * ```
- *
- * @param id - Unique storage key for this piece of state
- * @param initialValue - Default value when no persisted state exists
- * @param options - Optional: `storage` ('session' | 'local'), defaults to 'session'
- */
-export declare function usePersistentState<T>(id: string, initialValue: T, options?: {
-    storage?: 'session' | 'local';
-}): [T, (value: T | ((prev: T) => T)) => void, () => void];

package/dist/src/core/islands/use-persistent-state.js

@@ -1 +0,0 @@
-import{useState as e,useEffect as t,useCallback as n}from"preact/hooks";import{IslandStateSerializer as r}from"./island-state-serializer.js";export function usePersistentState(i,a,o){let s=o?.storage??`session`,c=`avalon-island:${i}`,[l,u]=e(()=>{if(typeof window>`u`)return a;try{let e=(s===`local`?localStorage:sessionStorage).getItem(c);return e===null?a:r.deserialize(e).v??a}catch{return a}});return t(()=>{if(!(typeof window>`u`))try{(s===`local`?localStorage:sessionStorage).setItem(c,r.serialize({v:l}))}catch{}},[l,c,s]),[l,n(e=>{u(t=>typeof e==`function`?e(t):e)},[]),n(()=>{if(u(a),!(typeof window>`u`))try{(s===`local`?localStorage:sessionStorage).removeItem(c)}catch{}},[a,c,s])]}