@bkincz/clutch 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,291 @@
+import { Patch, Draft } from 'immer';
+export { Draft } from 'immer';
+import { DependencyList } from 'react';
+
+declare class StateMachineError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+declare class StateValidationError extends StateMachineError {
+    constructor(message: string);
+}
+declare class StatePersistenceError extends StateMachineError {
+    constructor(message: string);
+}
+interface StateConfig<T extends object> {
+    initialState: T;
+    persistenceKey?: string;
+    autoSaveInterval?: number;
+    maxHistorySize?: number;
+    enablePersistence?: boolean;
+    enableAutoSave?: boolean;
+    enableLogging?: boolean;
+    validateState?: (state: T) => boolean;
+}
+interface InternalStateConfig<T extends object> {
+    initialState: T;
+    persistenceKey: string | null;
+    autoSaveInterval: number;
+    maxHistorySize: number;
+    enablePersistence: boolean;
+    enableAutoSave: boolean;
+    enableLogging: boolean;
+    validateState: (state: T) => boolean;
+}
+interface StateSnapshot {
+    patches: Patch[];
+    inversePatches: Patch[];
+    timestamp: number;
+    description?: string;
+}
+interface PersistedState<T> {
+    state: T;
+    timestamp: number;
+    version: string;
+    checksum?: string;
+}
+interface StateHistoryInfo {
+    canUndo: boolean;
+    canRedo: boolean;
+    historyLength: number;
+    currentIndex: number;
+    lastAction: string | null;
+    memoryUsage: number;
+}
+declare const createLogger: (enabled: boolean) => {
+    debug: (msg: string, ...args: unknown[]) => void;
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+};
+declare abstract class StateMachine<T extends object> {
+    protected state: T;
+    protected config: InternalStateConfig<T>;
+    protected listeners: Set<(state: T) => void>;
+    protected history: StateSnapshot[];
+    protected historyIndex: number;
+    protected isDirty: boolean;
+    protected autoSaveTimer: ReturnType<typeof setInterval> | null;
+    protected isDestroyed: boolean;
+    protected logger: ReturnType<typeof createLogger>;
+    protected debouncedNotify: () => void;
+    constructor(config: StateConfig<T>);
+    protected abstract saveToServer(state: T): Promise<void>;
+    protected abstract loadFromServer(): Promise<T | null>;
+    getState(): T;
+    subscribe(listener: (state: T) => void): () => void;
+    mutate(recipe: (draft: Draft<T>) => void, description?: string): void;
+    batch(mutations: Array<(draft: Draft<T>) => void>, description?: string): void;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getHistoryInfo(): StateHistoryInfo;
+    clearHistory(): void;
+    forceSave(): Promise<void>;
+    hasUnsavedChanges(): boolean;
+    setAutoSaveInterval(minutes: number): void;
+    loadFromServerManually(): Promise<boolean>;
+    destroy(): void;
+    protected setState(newState: T, markDirty?: boolean): void;
+    private assertNotDestroyed;
+    private validateConfig;
+    private validateCurrentState;
+    protected validateState(state: T): void;
+    private notifyListeners;
+    private saveToHistory;
+    private persistToLocal;
+    private loadPersistedState;
+    private startAutoSave;
+    private restartAutoSave;
+}
+
+/**
+ * Basic hook to subscribe to a StateMachine instance
+ */
+declare function useStateMachine<T extends object>(engine: StateMachine<T>): {
+    state: T;
+    mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+    batch: (mutations: Array<(draft: Draft<T>) => void>, description?: string) => void;
+};
+/**
+ * Hook to subscribe to a specific slice of state with a selector function
+ */
+declare function useStateSlice<T extends object, TSelected>(engine: StateMachine<T>, selector: (state: T) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): TSelected;
+/**
+ * Hook that provides StateMachine actions/methods
+ */
+declare function useStateActions<T extends object>(engine: StateMachine<T>): {
+    mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+    batch: (mutations: Array<(draft: Draft<T>) => void>, description?: string) => void;
+    undo: () => boolean;
+    redo: () => boolean;
+    forceSave: () => Promise<void>;
+    loadFromServer: () => Promise<boolean>;
+    clearHistory: () => void;
+};
+/**
+ * Hook specifically for undo/redo functionality
+ */
+declare function useStateHistory<T extends object>(engine: StateMachine<T>): {
+    undo: () => boolean;
+    redo: () => boolean;
+    clearHistory: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    historyLength: number;
+    currentIndex: number;
+    lastAction: string | null;
+    memoryUsage: number;
+};
+/**
+ * Hook for managing save/load state and persistence
+ */
+declare function useStatePersist<T extends object>(engine: StateMachine<T>): {
+    isSaving: boolean;
+    isLoading: boolean;
+    hasUnsavedChanges: boolean;
+    lastSaved: Date | null;
+    saveError: string | null;
+    loadError: string | null;
+    clearSaveError: () => void;
+    clearLoadError: () => void;
+    save: () => Promise<boolean>;
+    load: () => Promise<boolean>;
+};
+/**
+ * Comprehensive hook that combines all StateMachine functionality
+ */
+declare function useStateMachineFull<T extends object>(engine: StateMachine<T>): {
+    state: T;
+    mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+    batch: (mutations: ((draft: Draft<T>) => void)[], description?: string) => void;
+    history: {
+        canUndo: boolean;
+        canRedo: boolean;
+        historyLength: number;
+        currentIndex: number;
+        lastAction: string | null;
+        memoryUsage: number;
+        undo: () => boolean;
+        redo: () => boolean;
+        clearHistory: () => void;
+    };
+    persistence: {
+        isSaving: boolean;
+        isLoading: boolean;
+        hasUnsavedChanges: boolean;
+        lastSaved: Date | null;
+        saveError: string | null;
+        loadError: string | null;
+        save: () => Promise<boolean>;
+        load: () => Promise<boolean>;
+        clearSaveError: () => void;
+        clearLoadError: () => void;
+    };
+    forceSave: () => Promise<void>;
+    loadFromServer: () => Promise<boolean>;
+};
+/**
+ * Hook for creating optimistic updates with automatic rollback on failure
+ * -- Still testing this, I'm not sure if this is a good solution.
+ */
+declare function useOptimisticUpdate<T extends object>(engine: StateMachine<T>): {
+    mutateOptimistic: (optimisticUpdate: (draft: Draft<T>) => void, serverUpdate: () => Promise<void>, description?: string) => Promise<void>;
+};
+/**
+ * Hook for debounced state updates (useful for search inputs, etc.)
+ */
+declare function useDebouncedStateUpdate<T extends object>(engine: StateMachine<T>, delay?: number): {
+    debouncedMutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+};
+/**
+ * Hook for subscribing to state changes with cleanup on component unmount
+ */
+declare function useStateSubscription<T extends object>(engine: StateMachine<T>, callback: (state: T) => void, deps?: DependencyList): void;
+/**
+ * Utility hook for shallow equality comparison
+ */
+declare function useShallowEqual<T>(value: T): T;
+/**
+ * Factory function to create typed hooks for a specific StateMachine
+ */
+declare function createStateMachineHooks<T extends object>(engine: StateMachine<T>): {
+    useState: () => {
+        state: T;
+        mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+        batch: (mutations: ((draft: Draft<T>) => void)[], description?: string) => void;
+    };
+    useSlice: <TSelected>(selector: (state: T) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean) => TSelected;
+    useActions: () => {
+        mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+        batch: (mutations: ((draft: Draft<T>) => void)[], description?: string) => void;
+        undo: () => boolean;
+        redo: () => boolean;
+        forceSave: () => Promise<void>;
+        loadFromServer: () => Promise<boolean>;
+        clearHistory: () => void;
+    };
+    useHistory: () => {
+        undo: () => boolean;
+        redo: () => boolean;
+        clearHistory: () => void;
+        canUndo: boolean;
+        canRedo: boolean;
+        historyLength: number;
+        currentIndex: number;
+        lastAction: string | null;
+        memoryUsage: number;
+    };
+    usePersistence: () => {
+        isSaving: boolean;
+        isLoading: boolean;
+        hasUnsavedChanges: boolean;
+        lastSaved: Date | null;
+        saveError: string | null;
+        loadError: string | null;
+        clearSaveError: () => void;
+        clearLoadError: () => void;
+        save: () => Promise<boolean>;
+        load: () => Promise<boolean>;
+    };
+    useComplete: () => {
+        state: T;
+        mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+        batch: (mutations: ((draft: Draft<T>) => void)[], description?: string) => void;
+        history: {
+            canUndo: boolean;
+            canRedo: boolean;
+            historyLength: number;
+            currentIndex: number;
+            lastAction: string | null;
+            memoryUsage: number;
+            undo: () => boolean;
+            redo: () => boolean;
+            clearHistory: () => void;
+        };
+        persistence: {
+            isSaving: boolean;
+            isLoading: boolean;
+            hasUnsavedChanges: boolean;
+            lastSaved: Date | null;
+            saveError: string | null;
+            loadError: string | null;
+            save: () => Promise<boolean>;
+            load: () => Promise<boolean>;
+            clearSaveError: () => void;
+            clearLoadError: () => void;
+        };
+        forceSave: () => Promise<void>;
+        loadFromServer: () => Promise<boolean>;
+    };
+    useOptimistic: () => {
+        mutateOptimistic: (optimisticUpdate: (draft: Draft<T>) => void, serverUpdate: () => Promise<void>, description?: string) => Promise<void>;
+    };
+    useDebounced: (delay?: number) => {
+        debouncedMutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+    };
+    useSubscription: (callback: (state: T) => void, deps?: DependencyList) => void;
+};
+
+export { type PersistedState, type StateConfig, type StateHistoryInfo, StateMachine, StateMachineError, StatePersistenceError, type StateSnapshot, StateValidationError, createStateMachineHooks, useDebouncedStateUpdate, useOptimisticUpdate, useShallowEqual, useStateActions, useStateHistory, useStateMachine, useStateMachineFull, useStatePersist, useStateSlice, useStateSubscription };

package/dist/index.d.ts

@@ -0,0 +1,291 @@
+import { Patch, Draft } from 'immer';
+export { Draft } from 'immer';
+import { DependencyList } from 'react';
+
+declare class StateMachineError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+declare class StateValidationError extends StateMachineError {
+    constructor(message: string);
+}
+declare class StatePersistenceError extends StateMachineError {
+    constructor(message: string);
+}
+interface StateConfig<T extends object> {
+    initialState: T;
+    persistenceKey?: string;
+    autoSaveInterval?: number;
+    maxHistorySize?: number;
+    enablePersistence?: boolean;
+    enableAutoSave?: boolean;
+    enableLogging?: boolean;
+    validateState?: (state: T) => boolean;
+}
+interface InternalStateConfig<T extends object> {
+    initialState: T;
+    persistenceKey: string | null;
+    autoSaveInterval: number;
+    maxHistorySize: number;
+    enablePersistence: boolean;
+    enableAutoSave: boolean;
+    enableLogging: boolean;
+    validateState: (state: T) => boolean;
+}
+interface StateSnapshot {
+    patches: Patch[];
+    inversePatches: Patch[];
+    timestamp: number;
+    description?: string;
+}
+interface PersistedState<T> {
+    state: T;
+    timestamp: number;
+    version: string;
+    checksum?: string;
+}
+interface StateHistoryInfo {
+    canUndo: boolean;
+    canRedo: boolean;
+    historyLength: number;
+    currentIndex: number;
+    lastAction: string | null;
+    memoryUsage: number;
+}
+declare const createLogger: (enabled: boolean) => {
+    debug: (msg: string, ...args: unknown[]) => void;
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+};
+declare abstract class StateMachine<T extends object> {
+    protected state: T;
+    protected config: InternalStateConfig<T>;
+    protected listeners: Set<(state: T) => void>;
+    protected history: StateSnapshot[];
+    protected historyIndex: number;
+    protected isDirty: boolean;
+    protected autoSaveTimer: ReturnType<typeof setInterval> | null;
+    protected isDestroyed: boolean;
+    protected logger: ReturnType<typeof createLogger>;
+    protected debouncedNotify: () => void;
+    constructor(config: StateConfig<T>);
+    protected abstract saveToServer(state: T): Promise<void>;
+    protected abstract loadFromServer(): Promise<T | null>;
+    getState(): T;
+    subscribe(listener: (state: T) => void): () => void;
+    mutate(recipe: (draft: Draft<T>) => void, description?: string): void;
+    batch(mutations: Array<(draft: Draft<T>) => void>, description?: string): void;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getHistoryInfo(): StateHistoryInfo;
+    clearHistory(): void;
+    forceSave(): Promise<void>;
+    hasUnsavedChanges(): boolean;
+    setAutoSaveInterval(minutes: number): void;
+    loadFromServerManually(): Promise<boolean>;
+    destroy(): void;
+    protected setState(newState: T, markDirty?: boolean): void;
+    private assertNotDestroyed;
+    private validateConfig;
+    private validateCurrentState;
+    protected validateState(state: T): void;
+    private notifyListeners;
+    private saveToHistory;
+    private persistToLocal;
+    private loadPersistedState;
+    private startAutoSave;
+    private restartAutoSave;
+}
+
+/**
+ * Basic hook to subscribe to a StateMachine instance
+ */
+declare function useStateMachine<T extends object>(engine: StateMachine<T>): {
+    state: T;
+    mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+    batch: (mutations: Array<(draft: Draft<T>) => void>, description?: string) => void;
+};
+/**
+ * Hook to subscribe to a specific slice of state with a selector function
+ */
+declare function useStateSlice<T extends object, TSelected>(engine: StateMachine<T>, selector: (state: T) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): TSelected;
+/**
+ * Hook that provides StateMachine actions/methods
+ */
+declare function useStateActions<T extends object>(engine: StateMachine<T>): {
+    mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+    batch: (mutations: Array<(draft: Draft<T>) => void>, description?: string) => void;
+    undo: () => boolean;
+    redo: () => boolean;
+    forceSave: () => Promise<void>;
+    loadFromServer: () => Promise<boolean>;
+    clearHistory: () => void;
+};
+/**
+ * Hook specifically for undo/redo functionality
+ */
+declare function useStateHistory<T extends object>(engine: StateMachine<T>): {
+    undo: () => boolean;
+    redo: () => boolean;
+    clearHistory: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    historyLength: number;
+    currentIndex: number;
+    lastAction: string | null;
+    memoryUsage: number;
+};
+/**
+ * Hook for managing save/load state and persistence
+ */
+declare function useStatePersist<T extends object>(engine: StateMachine<T>): {
+    isSaving: boolean;
+    isLoading: boolean;
+    hasUnsavedChanges: boolean;
+    lastSaved: Date | null;
+    saveError: string | null;
+    loadError: string | null;
+    clearSaveError: () => void;
+    clearLoadError: () => void;
+    save: () => Promise<boolean>;
+    load: () => Promise<boolean>;
+};
+/**
+ * Comprehensive hook that combines all StateMachine functionality
+ */
+declare function useStateMachineFull<T extends object>(engine: StateMachine<T>): {
+    state: T;
+    mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+    batch: (mutations: ((draft: Draft<T>) => void)[], description?: string) => void;
+    history: {
+        canUndo: boolean;
+        canRedo: boolean;
+        historyLength: number;
+        currentIndex: number;
+        lastAction: string | null;
+        memoryUsage: number;
+        undo: () => boolean;
+        redo: () => boolean;
+        clearHistory: () => void;
+    };
+    persistence: {
+        isSaving: boolean;
+        isLoading: boolean;
+        hasUnsavedChanges: boolean;
+        lastSaved: Date | null;
+        saveError: string | null;
+        loadError: string | null;
+        save: () => Promise<boolean>;
+        load: () => Promise<boolean>;
+        clearSaveError: () => void;
+        clearLoadError: () => void;
+    };
+    forceSave: () => Promise<void>;
+    loadFromServer: () => Promise<boolean>;
+};
+/**
+ * Hook for creating optimistic updates with automatic rollback on failure
+ * -- Still testing this, I'm not sure if this is a good solution.
+ */
+declare function useOptimisticUpdate<T extends object>(engine: StateMachine<T>): {
+    mutateOptimistic: (optimisticUpdate: (draft: Draft<T>) => void, serverUpdate: () => Promise<void>, description?: string) => Promise<void>;
+};
+/**
+ * Hook for debounced state updates (useful for search inputs, etc.)
+ */
+declare function useDebouncedStateUpdate<T extends object>(engine: StateMachine<T>, delay?: number): {
+    debouncedMutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+};
+/**
+ * Hook for subscribing to state changes with cleanup on component unmount
+ */
+declare function useStateSubscription<T extends object>(engine: StateMachine<T>, callback: (state: T) => void, deps?: DependencyList): void;
+/**
+ * Utility hook for shallow equality comparison
+ */
+declare function useShallowEqual<T>(value: T): T;
+/**
+ * Factory function to create typed hooks for a specific StateMachine
+ */
+declare function createStateMachineHooks<T extends object>(engine: StateMachine<T>): {
+    useState: () => {
+        state: T;
+        mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+        batch: (mutations: ((draft: Draft<T>) => void)[], description?: string) => void;
+    };
+    useSlice: <TSelected>(selector: (state: T) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean) => TSelected;
+    useActions: () => {
+        mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+        batch: (mutations: ((draft: Draft<T>) => void)[], description?: string) => void;
+        undo: () => boolean;
+        redo: () => boolean;
+        forceSave: () => Promise<void>;
+        loadFromServer: () => Promise<boolean>;
+        clearHistory: () => void;
+    };
+    useHistory: () => {
+        undo: () => boolean;
+        redo: () => boolean;
+        clearHistory: () => void;
+        canUndo: boolean;
+        canRedo: boolean;
+        historyLength: number;
+        currentIndex: number;
+        lastAction: string | null;
+        memoryUsage: number;
+    };
+    usePersistence: () => {
+        isSaving: boolean;
+        isLoading: boolean;
+        hasUnsavedChanges: boolean;
+        lastSaved: Date | null;
+        saveError: string | null;
+        loadError: string | null;
+        clearSaveError: () => void;
+        clearLoadError: () => void;
+        save: () => Promise<boolean>;
+        load: () => Promise<boolean>;
+    };
+    useComplete: () => {
+        state: T;
+        mutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+        batch: (mutations: ((draft: Draft<T>) => void)[], description?: string) => void;
+        history: {
+            canUndo: boolean;
+            canRedo: boolean;
+            historyLength: number;
+            currentIndex: number;
+            lastAction: string | null;
+            memoryUsage: number;
+            undo: () => boolean;
+            redo: () => boolean;
+            clearHistory: () => void;
+        };
+        persistence: {
+            isSaving: boolean;
+            isLoading: boolean;
+            hasUnsavedChanges: boolean;
+            lastSaved: Date | null;
+            saveError: string | null;
+            loadError: string | null;
+            save: () => Promise<boolean>;
+            load: () => Promise<boolean>;
+            clearSaveError: () => void;
+            clearLoadError: () => void;
+        };
+        forceSave: () => Promise<void>;
+        loadFromServer: () => Promise<boolean>;
+    };
+    useOptimistic: () => {
+        mutateOptimistic: (optimisticUpdate: (draft: Draft<T>) => void, serverUpdate: () => Promise<void>, description?: string) => Promise<void>;
+    };
+    useDebounced: (delay?: number) => {
+        debouncedMutate: (recipe: (draft: Draft<T>) => void, description?: string) => void;
+    };
+    useSubscription: (callback: (state: T) => void, deps?: DependencyList) => void;
+};
+
+export { type PersistedState, type StateConfig, type StateHistoryInfo, StateMachine, StateMachineError, StatePersistenceError, type StateSnapshot, StateValidationError, createStateMachineHooks, useDebouncedStateUpdate, useOptimisticUpdate, useShallowEqual, useStateActions, useStateHistory, useStateMachine, useStateMachineFull, useStatePersist, useStateSlice, useStateSubscription };

package/dist/index.js

@@ -0,0 +1 @@
+"use strict";var t=require("immer"),e=require("react");t.enablePatches();var s=class extends Error{constructor(t,e){super(t),this.name="StateMachineError",this.code=e}},i=class extends s{constructor(t){super(t,"VALIDATION_ERROR")}},r=class extends s{constructor(t){super(t,"PERSISTENCE_ERROR")}},n=t=>{try{return new Blob([JSON.stringify(t)]).size}catch{return 0}},a=t=>{try{const e=JSON.stringify(t);let s=0;for(let t=0;t<e.length;t++)s=(s<<5)-s+e.charCodeAt(t)&s;return s.toString(36)}catch{return""}};function o(t){const[s,i]=e.useState(()=>t.getState());return e.useEffect(()=>t.subscribe(i),[t]),{state:s,mutate:e.useCallback((e,s)=>{t.mutate(e,s)},[t]),batch:e.useCallback((e,s)=>{t.batch(e,s)},[t])}}function h(t,s,i){const[r,n]=e.useState(()=>s(t.getState()));return e.useEffect(()=>t.subscribe(t=>{const e=s(t);i?i(r,e)||n(e):r!==e&&n(e)}),[t,s,r,i]),r}function c(t){return{mutate:e.useCallback((e,s)=>{t.mutate(e,s)},[t]),batch:e.useCallback((e,s)=>{t.batch(e,s)},[t]),undo:e.useCallback(()=>t.undo(),[t]),redo:e.useCallback(()=>t.redo(),[t]),forceSave:e.useCallback(async()=>t.forceSave(),[t]),loadFromServer:e.useCallback(async()=>t.loadFromServerManually(),[t]),clearHistory:e.useCallback(()=>{t.clearHistory()},[t])}}function u(t){const[s,i]=e.useState(()=>t.getHistoryInfo());return e.useEffect(()=>t.subscribe(()=>{i(t.getHistoryInfo())}),[t]),{...s,undo:e.useCallback(()=>{const e=t.undo();return e&&i(t.getHistoryInfo()),e},[t]),redo:e.useCallback(()=>{const e=t.redo();return e&&i(t.getHistoryInfo()),e},[t]),clearHistory:e.useCallback(()=>{t.clearHistory(),i(t.getHistoryInfo())},[t])}}function l(t){const[s,i]=e.useState(!1),[r,n]=e.useState(!1),[a,o]=e.useState(null),[h,c]=e.useState(null),[u,l]=e.useState(null),d=t.hasUnsavedChanges(),f=e.useCallback(async()=>{if(s)return!1;i(!0),c(null);try{return await t.forceSave(),o(new Date),!0}catch(t){const e=t instanceof Error?t.message:"Save failed";return c(e),!1}finally{i(!1)}},[t,s]),p=e.useCallback(async()=>{if(r)return!1;n(!0),l(null);try{const e=await t.loadFromServerManually();return e&&o(new Date),e}catch(t){const e=t instanceof Error?t.message:"Load failed";return l(e),!1}finally{n(!1)}},[t,r]),v=e.useCallback(()=>{c(null)},[]),y=e.useCallback(()=>{l(null)},[]);return{isSaving:s,isLoading:r,hasUnsavedChanges:d,lastSaved:a,saveError:h,loadError:u,clearSaveError:v,clearLoadError:y,save:f,load:p}}function d(t){const{state:e,mutate:s,batch:i}=o(t),r=c(t),n=u(t),a=l(t);return{state:e,mutate:s,batch:i,history:{canUndo:n.canUndo,canRedo:n.canRedo,historyLength:n.historyLength,currentIndex:n.currentIndex,lastAction:n.lastAction,memoryUsage:n.memoryUsage,undo:n.undo,redo:n.redo,clearHistory:n.clearHistory},persistence:{isSaving:a.isSaving,isLoading:a.isLoading,hasUnsavedChanges:a.hasUnsavedChanges,lastSaved:a.lastSaved,saveError:a.saveError,loadError:a.loadError,save:a.save,load:a.load,clearSaveError:a.clearSaveError,clearLoadError:a.clearLoadError},forceSave:r.forceSave,loadFromServer:r.loadFromServer}}function f(t){return{mutateOptimistic:e.useCallback(async(e,s,i)=>{t.mutate(e,`${i} (optimistic)`);try{await s()}catch(e){throw t.undo(),e}},[t])}}function p(t,s=300){const[i]=e.useState(()=>{let e;return(i,r)=>{clearTimeout(e),e=setTimeout(()=>{t.mutate(i,r)},s)}});return e.useEffect(()=>()=>{clearTimeout(i)},[i]),{debouncedMutate:i}}function v(t,s,i=[]){e.useEffect(()=>t.subscribe(s),[t,s,...i])}exports.StateMachine=class{constructor(t){var e;this.listeners=new Set,this.history=[],this.historyIndex=-1,this.isDirty=!1,this.autoSaveTimer=null,this.isDestroyed=!1,this.validateConfig(t),this.config={initialState:t.initialState,persistenceKey:t.persistenceKey||null,autoSaveInterval:t.autoSaveInterval??5,maxHistorySize:t.maxHistorySize??50,enablePersistence:t.enablePersistence??!0,enableAutoSave:t.enableAutoSave??!0,enableLogging:t.enableLogging??!1,validateState:t.validateState??(()=>!0)},this.logger={debug:(e=this.config.enableLogging)?(t,...e)=>{}:()=>{},info:e?(t,...e)=>{}:()=>{},warn:e?(t,...e)=>{}:()=>{},error:e?(t,...e)=>{}:()=>{}},this.debouncedNotify=function(t){let e;return(...s)=>{clearTimeout(e),e=setTimeout(()=>t(...s),16)}}(()=>this.notifyListeners());try{this.state=this.loadPersistedState()||t.initialState,this.validateCurrentState()}catch(e){this.logger.warn("Failed to load persisted state, using initial state",e),this.state=t.initialState,this.validateCurrentState()}this.config.enableAutoSave&&this.startAutoSave(),this.logger.info("StateMachine initialized",{persistenceKey:this.config.persistenceKey,autoSaveInterval:this.config.autoSaveInterval,maxHistorySize:this.config.maxHistorySize})}getState(){return this.assertNotDestroyed(),this.state}subscribe(t){if(this.assertNotDestroyed(),"function"!=typeof t)throw new i("Listener must be a function");this.listeners.add(t);try{t(this.state)}catch(t){this.logger.error("Initial listener call failed",t)}return this.logger.debug("Listener subscribed",{totalListeners:this.listeners.size}),()=>{this.listeners.delete(t),this.logger.debug("Listener unsubscribed",{totalListeners:this.listeners.size})}}mutate(e,r){if(this.assertNotDestroyed(),"function"!=typeof e)throw new i("Recipe must be a function");try{let s=[],i=[];const n=t.produce(this.state,e,(t,e)=>{s=t,i=e});s.length>0&&(this.validateState(n),this.saveToHistory(s,i,r),this.setState(n),this.logger.debug("State mutated",{description:r,patchCount:s.length,historySize:this.history.length}))}catch(t){if(this.logger.error("State mutation failed",{description:r,error:t}),t instanceof i)throw t;throw new s(`State mutation failed: ${t instanceof Error?t.message:"Unknown error"}`,"MUTATION_ERROR")}}batch(e,r){if(this.assertNotDestroyed(),!Array.isArray(e))throw new i("Mutations must be an array");if(0!==e.length)try{const s=[],n=[],a=e.reduce((e,r,a)=>{if("function"!=typeof r)throw new i(`Mutation at index ${a} must be a function`);let o=[],h=[];const c=t.produce(e,r,(t,e)=>{o=t,h=e});return s.push(...o),n.unshift(...h),c},this.state);s.length>0&&(this.validateState(a),this.saveToHistory(s,n,r||"Batch operation"),this.setState(a),this.logger.debug("Batch operation completed",{description:r,mutationCount:e.length,patchCount:s.length}))}catch(t){throw this.logger.error("Batch operation failed",{description:r,error:t}),new s(`Batch operation failed: ${t instanceof Error?t.message:"Unknown error"}`,"BATCH_ERROR")}else this.logger.debug("Empty batch operation ignored")}undo(){if(this.assertNotDestroyed(),!this.canUndo())return this.logger.debug("Undo operation ignored - no history available"),!1;try{const e=this.history[this.historyIndex];if(!e)return!1;const s=t.applyPatches(this.state,e.inversePatches);return this.validateState(s),this.historyIndex--,this.setState(s,!1),this.logger.debug("Undo operation completed",{description:e.description,newHistoryIndex:this.historyIndex}),!0}catch(t){return this.logger.error("Undo operation failed",t),!1}}redo(){if(this.assertNotDestroyed(),!this.canRedo())return this.logger.debug("Redo operation ignored - no future history available"),!1;try{this.historyIndex++;const e=this.history[this.historyIndex];if(!e)return this.historyIndex--,!1;const s=t.applyPatches(this.state,e.patches);return this.validateState(s),this.setState(s,!1),this.logger.debug("Redo operation completed",{description:e.description,newHistoryIndex:this.historyIndex}),!0}catch(t){return this.logger.error("Redo operation failed",t),this.historyIndex--,!1}}canUndo(){return this.historyIndex>=0}canRedo(){return this.historyIndex<this.history.length-1}getHistoryInfo(){return{canUndo:this.canUndo(),canRedo:this.canRedo(),historyLength:this.history.length,currentIndex:this.historyIndex,lastAction:this.history[this.historyIndex]?.description||null,memoryUsage:n(this.history)}}clearHistory(){this.assertNotDestroyed();const t=this.history.length;this.history=[],this.historyIndex=-1,this.logger.info("History cleared",{previousLength:t})}async forceSave(){if(this.assertNotDestroyed(),this.isDirty)try{this.logger.debug("Force save started"),await this.saveToServer(this.state),this.persistToLocal(),this.isDirty=!1,this.logger.info("Force save completed successfully")}catch(t){throw this.logger.error("Force save failed",t),new r(`Force save failed: ${t instanceof Error?t.message:"Unknown error"}`)}else this.logger.debug("Force save skipped - no changes")}hasUnsavedChanges(){return this.isDirty}setAutoSaveInterval(t){if(this.assertNotDestroyed(),"number"!=typeof t||t<=0)throw new i("Auto-save interval must be a positive number");this.config.autoSaveInterval=t,this.restartAutoSave(),this.logger.info("Auto-save interval updated",{minutes:t})}async loadFromServerManually(){this.assertNotDestroyed();try{this.logger.debug("Manual server load started");const t=await this.loadFromServer();return t?(this.validateState(t),this.state=t,this.isDirty=!1,this.clearHistory(),this.notifyListeners(),this.persistToLocal(),this.logger.info("Manual server load completed successfully"),!0):(this.logger.debug("No server state available"),!1)}catch(t){return this.logger.error("Manual server load failed",t),!1}}destroy(){this.isDestroyed||(this.logger.info("Destroying StateMachine"),this.isDestroyed=!0,this.listeners.clear(),this.autoSaveTimer&&(clearInterval(this.autoSaveTimer),this.autoSaveTimer=null),this.history=[],this.listeners=new Set,this.logger.info("StateMachine destroyed"))}setState(t,e=!0){this.state=t,e&&(this.isDirty=!0),this.debouncedNotify(),this.persistToLocal()}assertNotDestroyed(){if(this.isDestroyed)throw new s("Cannot operate on destroyed StateMachine","DESTROYED")}validateConfig(t){if(!t.initialState||"object"!=typeof t.initialState||null===t.initialState)throw new i("Initial state must be an object");if(void 0!==t.autoSaveInterval&&t.autoSaveInterval<=0)throw new i("Auto-save interval must be positive");if(void 0!==t.maxHistorySize&&t.maxHistorySize<=0)throw new i("Max history size must be positive")}validateCurrentState(){this.validateState(this.state)}validateState(t){if(!this.config.validateState(t))throw new i("State validation failed")}notifyListeners(){if(0===this.listeners.size)return;const t=this.state;let e=0;this.listeners.forEach(s=>{try{s(t)}catch(t){e++,this.logger.error("Listener notification failed",t)}}),e>0&&this.logger.warn(`${e} listener(s) failed during notification`)}saveToHistory(t,e,s){this.historyIndex<this.history.length-1&&(this.history=this.history.slice(0,this.historyIndex+1));const i={patches:t,inversePatches:e,timestamp:Date.now()};s&&(i.description=s),this.history.push(i),this.historyIndex++,this.history.length>this.config.maxHistorySize&&(this.history.shift(),this.historyIndex--,this.logger.debug("History trimmed to max size",{maxSize:this.config.maxHistorySize}))}persistToLocal(){if(this.config.enablePersistence&&this.config.persistenceKey)try{const t={state:this.state,timestamp:Date.now(),version:"1.0.0",checksum:a(this.state)};localStorage.setItem(this.config.persistenceKey,JSON.stringify(t))}catch(t){this.logger.warn("Failed to persist state to localStorage",t)}}loadPersistedState(){if(!this.config.enablePersistence||!this.config.persistenceKey)return null;try{const t=localStorage.getItem(this.config.persistenceKey);if(!t)return null;const e=JSON.parse(t);if(e.checksum){const t=a(e.state);if(e.checksum!==t)return this.logger.warn("Persisted state checksum mismatch, ignoring"),null}return this.logger.debug("Loaded persisted state",{timestamp:e.timestamp,version:e.version}),e.state}catch(t){return this.logger.warn("Failed to load persisted state",t),null}}startAutoSave(){if(!this.config.enableAutoSave)return;const t=60*this.config.autoSaveInterval*1e3;this.autoSaveTimer=setInterval(async()=>{if(this.isDirty&&!this.isDestroyed)try{await this.forceSave()}catch(t){this.logger.error("Auto-save failed",t)}},t),this.logger.debug("Auto-save started",{intervalMinutes:this.config.autoSaveInterval})}restartAutoSave(){this.autoSaveTimer&&clearInterval(this.autoSaveTimer),this.startAutoSave()}},exports.StateMachineError=s,exports.StatePersistenceError=r,exports.StateValidationError=i,exports.createStateMachineHooks=function(t){return{useState:()=>o(t),useSlice:(e,s)=>h(t,e,s),useActions:()=>c(t),useHistory:()=>u(t),usePersistence:()=>l(t),useComplete:()=>d(t),useOptimistic:()=>f(t),useDebounced:e=>p(t,e),useSubscription:(e,s)=>v(t,e,s)}},exports.useDebouncedStateUpdate=p,exports.useOptimisticUpdate=f,exports.useShallowEqual=function(t){const[s,i]=e.useState(t);return e.useEffect(()=>{if("object"==typeof t&&null!==t){const e=Object.keys(s),r=Object.keys(t);if(e.length!==r.length)return void i(t);for(const r of e)if(s[r]!==t[r])return void i(t)}else s!==t&&i(t)},[t,s]),s},exports.useStateActions=c,exports.useStateHistory=u,exports.useStateMachine=o,exports.useStateMachineFull=d,exports.useStatePersist=l,exports.useStateSlice=h,exports.useStateSubscription=v;//# sourceMappingURL=index.js.map