@ngstato/core 0.1.1 → 0.2.0

package/README.md

@@ -23,14 +23,21 @@ const store = createStore({
     }
   },
 
-  computed: {
+  selectors: {
     total: (state) => state.users.length
-  }
+  },
+
+  effects: [
+    [
+      (state) => state.users.length,
+      (count) => console.log('Total users:', count)
+    ]
+  ]
 })
 
 await store.loadUsers()
 console.log(store.users)   // User[]
-console.log(store.total)   // number
+console.log(store.total)   // number (selector memoïzé)
 ```
 
 ## Helpers
@@ -43,6 +50,13 @@ console.log(store.total)   // number
 | `retryable()` | Retry avec backoff fixe ou exponentiel |
 | `fromStream()` | Realtime — WebSocket, Firebase, Supabase |
 | `optimistic()` | Optimistic update + rollback automatique |
+| `withPersist()` | Persistance localStorage/sessionStorage + migration |
+
+## Nouvautés v0.2
+
+- `selectors` memoïzés (recalcul seulement quand les dépendances changent)
+- `effects` réactifs explicites avec cleanup automatique
+- `withPersist()` pour hydrater/persister le state
 
 ## Documentation
 

package/dist/{index.d.cts → index.d.mts}

@@ -1,7 +1,16 @@
-type StateSlice<T> = Omit<T, 'actions' | 'computed' | 'hooks'>;
+type StateSlice<T> = Omit<T, 'actions' | 'computed' | 'selectors' | 'hooks'>;
 type Action<S> = (state: S, ...args: any[]) => void | Promise<void> | (() => void);
 type ActionsMap<S> = Record<string, Action<S>>;
 type ComputedFn<S> = (state: S) => unknown;
+type SelectorFn<S> = (state: S) => unknown;
+type EffectDepsFn<S> = (state: S) => unknown | unknown[];
+type EffectCleanup = void | (() => void);
+type EffectRunner<S> = (depsValue: unknown | unknown[], ctx: {
+    state: Readonly<S>;
+    store: any;
+    prevDepsValue?: unknown | unknown[];
+}) => EffectCleanup | Promise<EffectCleanup>;
+type EffectEntry<S> = [EffectDepsFn<S>, EffectRunner<S>];
 interface StatoHooks<S> {
     onInit?: (store: S) => void | Promise<void>;
     onDestroy?: (store: S) => void | Promise<void>;
@@ -13,6 +22,8 @@ interface StatoHooks<S> {
 interface StatoStoreConfig<S extends object> {
     actions?: ActionsMap<StateSlice<S>>;
     computed?: Record<string, ComputedFn<StateSlice<S>> | unknown[]>;
+    selectors?: Record<string, SelectorFn<StateSlice<S>> | unknown[]>;
+    effects?: EffectEntry<StateSlice<S>>[];
     hooks?: StatoHooks<any>;
     [key: string]: unknown;
 }
@@ -95,6 +106,21 @@ declare function fromStream<S, T>(setupFn: (state: S) => StatoObservable<T>, upd
 
 declare function optimistic<S, A extends unknown[]>(immediate: (state: S, ...args: A) => void, confirm: (state: S, ...args: A) => Promise<void>): (state: S, ...args: A) => Promise<void>;
 
+interface PersistStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+interface PersistOptions<S extends object> {
+    key: string;
+    version?: number;
+    storage?: PersistStorage;
+    pick?: (keyof S)[];
+    migrate?: (data: unknown, fromVersion: number) => Partial<S>;
+    onError?: (error: Error) => void;
+}
+declare function withPersist<S extends object>(config: S & StatoStoreConfig<S>, options: PersistOptions<StateSlice<S>>): S & StatoStoreConfig<S>;
+
 interface ActionLog {
     id: number;
     name: string;
@@ -124,4 +150,4 @@ declare function createDevTools(maxLogs?: number): DevToolsInstance;
 declare const devTools: DevToolsInstance;
 declare function connectDevTools(store: any, storeName: string): void;
 
-export { type ActionLog, type DevToolsInstance, type DevToolsState, type RequestOptions, type StatoConfig, type StatoHooks, StatoHttp, StatoHttpError, type StatoStoreConfig, type StatoStoreInstance, abortable, configureHttp, connectDevTools, createDevTools, createHttp, createStore, debounced, devTools, fromStream, http, optimistic, retryable, throttled };
+export { type ActionLog, type DevToolsInstance, type DevToolsState, type EffectDepsFn, type EffectEntry, type EffectRunner, type PersistOptions, type PersistStorage, type RequestOptions, type StatoConfig, type StatoHooks, StatoHttp, StatoHttpError, type StatoStoreConfig, type StatoStoreInstance, abortable, configureHttp, connectDevTools, createDevTools, createHttp, createStore, debounced, devTools, fromStream, http, optimistic, retryable, throttled, withPersist };

package/dist/index.d.ts

@@ -1,7 +1,16 @@
-type StateSlice<T> = Omit<T, 'actions' | 'computed' | 'hooks'>;
+type StateSlice<T> = Omit<T, 'actions' | 'computed' | 'selectors' | 'hooks'>;
 type Action<S> = (state: S, ...args: any[]) => void | Promise<void> | (() => void);
 type ActionsMap<S> = Record<string, Action<S>>;
 type ComputedFn<S> = (state: S) => unknown;
+type SelectorFn<S> = (state: S) => unknown;
+type EffectDepsFn<S> = (state: S) => unknown | unknown[];
+type EffectCleanup = void | (() => void);
+type EffectRunner<S> = (depsValue: unknown | unknown[], ctx: {
+    state: Readonly<S>;
+    store: any;
+    prevDepsValue?: unknown | unknown[];
+}) => EffectCleanup | Promise<EffectCleanup>;
+type EffectEntry<S> = [EffectDepsFn<S>, EffectRunner<S>];
 interface StatoHooks<S> {
     onInit?: (store: S) => void | Promise<void>;
     onDestroy?: (store: S) => void | Promise<void>;
@@ -13,6 +22,8 @@ interface StatoHooks<S> {
 interface StatoStoreConfig<S extends object> {
     actions?: ActionsMap<StateSlice<S>>;
     computed?: Record<string, ComputedFn<StateSlice<S>> | unknown[]>;
+    selectors?: Record<string, SelectorFn<StateSlice<S>> | unknown[]>;
+    effects?: EffectEntry<StateSlice<S>>[];
     hooks?: StatoHooks<any>;
     [key: string]: unknown;
 }
@@ -95,6 +106,21 @@ declare function fromStream<S, T>(setupFn: (state: S) => StatoObservable<T>, upd
 
 declare function optimistic<S, A extends unknown[]>(immediate: (state: S, ...args: A) => void, confirm: (state: S, ...args: A) => Promise<void>): (state: S, ...args: A) => Promise<void>;
 
+interface PersistStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+interface PersistOptions<S extends object> {
+    key: string;
+    version?: number;
+    storage?: PersistStorage;
+    pick?: (keyof S)[];
+    migrate?: (data: unknown, fromVersion: number) => Partial<S>;
+    onError?: (error: Error) => void;
+}
+declare function withPersist<S extends object>(config: S & StatoStoreConfig<S>, options: PersistOptions<StateSlice<S>>): S & StatoStoreConfig<S>;
+
 interface ActionLog {
     id: number;
     name: string;
@@ -124,4 +150,4 @@ declare function createDevTools(maxLogs?: number): DevToolsInstance;
 declare const devTools: DevToolsInstance;
 declare function connectDevTools(store: any, storeName: string): void;
 
-export { type ActionLog, type DevToolsInstance, type DevToolsState, type RequestOptions, type StatoConfig, type StatoHooks, StatoHttp, StatoHttpError, type StatoStoreConfig, type StatoStoreInstance, abortable, configureHttp, connectDevTools, createDevTools, createHttp, createStore, debounced, devTools, fromStream, http, optimistic, retryable, throttled };
+export { type ActionLog, type DevToolsInstance, type DevToolsState, type EffectDepsFn, type EffectEntry, type EffectRunner, type PersistOptions, type PersistStorage, type RequestOptions, type StatoConfig, type StatoHooks, StatoHttp, StatoHttpError, type StatoStoreConfig, type StatoStoreInstance, abortable, configureHttp, connectDevTools, createDevTools, createHttp, createStore, debounced, devTools, fromStream, http, optimistic, retryable, throttled, withPersist };

package/dist/index.js

@@ -1,3 +1,5 @@
+'use strict';
+
 // src/store.ts
 var StatoStore = class {
   // Le state interne — jamais accessible directement
@@ -8,12 +10,44 @@ var StatoStore = class {
   _actions = {};
   // Les computed enregistrés
   _computed = {};
+  _selectors = {};
   // Les cleanups à appeler à la destruction
   _cleanups = [];
   // Les hooks lifecycle
   _hooks;
+  _publicStore = null;
+  _effects = [];
+  _createMemoizedSelector(fn) {
+    let initialized = false;
+    let cachedResult;
+    let trackedKeys = [];
+    let trackedValues = [];
+    return () => {
+      if (initialized && trackedKeys.length) {
+        const unchanged = trackedKeys.every(
+          (key, index) => Object.is(this._state[key], trackedValues[index])
+        );
+        if (unchanged) return cachedResult;
+      }
+      const reads = /* @__PURE__ */ new Set();
+      const trackingState = new Proxy(this._state, {
+        get: (target, prop, receiver) => {
+          if (typeof prop === "string" && prop in target) {
+            reads.add(prop);
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+      const result = fn(trackingState);
+      trackedKeys = Array.from(reads);
+      trackedValues = trackedKeys.map((key) => this._state[key]);
+      cachedResult = result;
+      initialized = true;
+      return result;
+    };
+  }
   constructor(config) {
-    const { actions, computed, hooks, ...initialState } = config;
+    const { actions, computed, selectors, effects, hooks, ...initialState } = config;
     this._state = initialState;
     this._hooks = hooks ?? {};
     if (actions) {
@@ -28,6 +62,27 @@ var StatoStore = class {
         }
       }
     }
+    if (selectors) {
+      for (const [name, fn] of Object.entries(selectors)) {
+        if (typeof fn === "function") {
+          this._selectors[name] = this._createMemoizedSelector(fn);
+        }
+      }
+    }
+    if (effects) {
+      for (const entry of effects) {
+        const [deps, run] = entry;
+        if (typeof deps === "function" && typeof run === "function") {
+          this._effects.push({
+            deps,
+            run,
+            hasRun: false,
+            running: false,
+            rerunRequested: false
+          });
+        }
+      }
+    }
   }
   // ── Lire le state ──────────────────────────────────
   getState() {
@@ -36,8 +91,56 @@ var StatoStore = class {
   // ── Modifier le state — usage interne uniquement ───
   _setState(partial) {
     this._state = { ...this._state, ...partial };
+    this._runEffects();
     this._notify();
   }
+  _normalizeDeps(value) {
+    return Array.isArray(value) ? value : [value];
+  }
+  _depsChanged(prev, next) {
+    if (!prev) return true;
+    if (prev.length !== next.length) return true;
+    for (let i = 0; i < next.length; i++) {
+      if (!Object.is(prev[i], next[i])) return true;
+    }
+    return false;
+  }
+  _runEffects(force = false) {
+    for (const effect of this._effects) {
+      const depsValue = effect.deps(this._state);
+      const depsArray = this._normalizeDeps(depsValue);
+      const shouldRun = force || this._depsChanged(effect.prevDeps, depsArray);
+      if (!shouldRun) continue;
+      const execute = async () => {
+        if (effect.running) {
+          effect.rerunRequested = true;
+          return;
+        }
+        effect.running = true;
+        effect.rerunRequested = false;
+        const prevDepsValue = effect.prevDeps;
+        effect.prevDeps = depsArray;
+        try {
+          effect.cleanup?.();
+          const maybeCleanup = await effect.run(depsValue, {
+            state: { ...this._state },
+            store: this._publicStore,
+            prevDepsValue
+          });
+          effect.cleanup = typeof maybeCleanup === "function" ? maybeCleanup : void 0;
+          effect.hasRun = true;
+        } catch (error) {
+          this._hooks.onError?.(error, "effect");
+        } finally {
+          effect.running = false;
+          if (effect.rerunRequested) {
+            this._runEffects();
+          }
+        }
+      };
+      void execute();
+    }
+  }
   // ── Notifier tous les abonnés ──────────────────────
   _notify() {
     for (const subscriber of this._subscribers) {
@@ -80,16 +183,34 @@ var StatoStore = class {
     if (!fn) throw new Error(`[Stato] Computed "${name}" introuvable`);
     return fn();
   }
+  getSelector(name) {
+    const fn = this._selectors[name];
+    if (!fn) throw new Error(`[Stato] Selector "${name}" introuvable`);
+    return fn();
+  }
   // ── Enregistrer un cleanup (pour fromStream) ───────
   registerCleanup(fn) {
     this._cleanups.push(fn);
   }
+  hydrate(partial) {
+    this._setState(partial);
+  }
+  setPublicStore(publicStore) {
+    this._publicStore = publicStore;
+    this._runEffects(true);
+  }
   // ── Lifecycle — appelé par l'adaptateur Angular ────
   init(publicStore) {
+    this._publicStore = publicStore;
     this._hooks.onInit?.(publicStore);
+    this._runEffects(true);
   }
   destroy(publicStore) {
     this._hooks.onDestroy?.(publicStore);
+    for (const effect of this._effects) {
+      effect.cleanup?.();
+      effect.cleanup = void 0;
+    }
     for (const cleanup of this._cleanups) {
       cleanup();
     }
@@ -117,7 +238,7 @@ function createStore(config) {
       configurable: true
     });
   }
-  const { actions, computed } = config;
+  const { actions, computed, selectors } = config;
   if (actions) {
     for (const name of Object.keys(actions)) {
       publicStore[name] = (...args) => store.dispatch(name, ...args);
@@ -132,6 +253,16 @@ function createStore(config) {
       });
     }
   }
+  if (selectors) {
+    for (const name of Object.keys(selectors)) {
+      Object.defineProperty(publicStore, name, {
+        get: () => store.getSelector(name),
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  store.setPublicStore(publicStore);
   return publicStore;
 }
 
@@ -364,6 +495,85 @@ function optimistic(immediate, confirm) {
   };
 }
 
+// src/helpers/with-persist.ts
+function resolveStorage(custom) {
+  if (custom) return custom;
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function pickState(state, keys) {
+  if (!keys?.length) return state;
+  const picked = {};
+  for (const key of keys) {
+    picked[key] = state[key];
+  }
+  return picked;
+}
+function withPersist(config, options) {
+  const {
+    key,
+    version = 1,
+    storage: customStorage,
+    pick,
+    migrate,
+    onError
+  } = options;
+  const storage = resolveStorage(customStorage);
+  const userHooks = config.hooks ?? {};
+  const mergedHooks = {
+    ...userHooks,
+    onInit(store) {
+      try {
+        if (!storage) return userHooks.onInit?.(store);
+        const raw = storage.getItem(key);
+        if (!raw) return userHooks.onInit?.(store);
+        const parsed = JSON.parse(raw);
+        const data = parsed.v === version ? parsed.data : migrate ? migrate(parsed.data, parsed.v) : parsed.data;
+        if (data && typeof data === "object") {
+          store.__store__?.hydrate?.(data);
+        }
+      } catch (error) {
+        onError?.(error);
+      }
+      return userHooks.onInit?.(store);
+    },
+    onStateChange(prev, next) {
+      try {
+        if (storage) {
+          const payload = {
+            v: version,
+            data: pickState(next, pick)
+          };
+          storage.setItem(key, JSON.stringify(payload));
+        }
+      } catch (error) {
+        onError?.(error);
+      }
+      userHooks.onStateChange?.(prev, next);
+    },
+    onDestroy(store) {
+      return userHooks.onDestroy?.(store);
+    },
+    onAction(name, args) {
+      return userHooks.onAction?.(name, args);
+    },
+    onActionDone(name, duration) {
+      return userHooks.onActionDone?.(name, duration);
+    },
+    onError(error, actionName) {
+      return userHooks.onError?.(error, actionName);
+    }
+  };
+  return {
+    ...config,
+    hooks: mergedHooks
+  };
+}
+
 // src/devtools.ts
 function createDevTools(maxLogs = 50) {
   let counter = 0;
@@ -450,6 +660,21 @@ function connectDevTools(store, storeName) {
   };
 }
 
-export { StatoHttp, StatoHttpError, abortable, configureHttp, connectDevTools, createDevTools, createHttp, createStore, debounced, devTools, fromStream, http, optimistic, retryable, throttled };
+exports.StatoHttp = StatoHttp;
+exports.StatoHttpError = StatoHttpError;
+exports.abortable = abortable;
+exports.configureHttp = configureHttp;
+exports.connectDevTools = connectDevTools;
+exports.createDevTools = createDevTools;
+exports.createHttp = createHttp;
+exports.createStore = createStore;
+exports.debounced = debounced;
+exports.devTools = devTools;
+exports.fromStream = fromStream;
+exports.http = http;
+exports.optimistic = optimistic;
+exports.retryable = retryable;
+exports.throttled = throttled;
+exports.withPersist = withPersist;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map