@ngstato/core 0.3.0 → 0.4.0

package/dist/index.js

@@ -42,6 +42,7 @@ var StatoStore = class {
   _publicStore = null;
   _publicActions = {};
   _initialized = false;
+  _timeTraveling = false;
   _effects = [];
   _createMemoizedSelector(fn) {
     let initialized = false;
@@ -117,7 +118,9 @@ var StatoStore = class {
   // ── Modifier le state — usage interne uniquement ───
   _setState(partial) {
     this._state = { ...this._state, ...partial };
-    this._runEffects();
+    if (!this._timeTraveling) {
+      this._runEffects();
+    }
     this._notify();
   }
   _normalizeDeps(value) {
@@ -199,7 +202,13 @@ var StatoStore = class {
       await action(stateProxy, ...args);
       const duration = Date.now() - start;
       this._hooks.onActionDone?.(actionName, duration);
-      this._hooks.onStateChange?.(prevState, { ...this._state });
+      const nextState = { ...this._state };
+      const hasChanged = Object.keys(nextState).some(
+        (k) => !Object.is(prevState[k], nextState[k])
+      );
+      if (hasChanged) {
+        this._hooks.onStateChange?.(prevState, nextState);
+      }
       if (publicAction) {
         emitActionEvent({
           action: publicAction,
@@ -247,9 +256,15 @@ var StatoStore = class {
   hydrate(partial) {
     this._setState(partial);
   }
+  // ── Time-travel — restaurer un snapshot sans déclencher les effects ──
+  hydrateForTimeTravel(fullState) {
+    this._timeTraveling = true;
+    this._state = { ...fullState };
+    this._notify();
+    this._timeTraveling = false;
+  }
   setPublicStore(publicStore) {
     this._publicStore = publicStore;
-    this._runEffects(true);
   }
   // ── Lifecycle — appelé par l'adaptateur Angular ────
   init(publicStore) {
@@ -274,7 +289,7 @@ var StatoStore = class {
     this._initialized = false;
   }
 };
-function createStore(config) {
+function createStore(config, __internal) {
   const store = new StatoStore(config);
   const publicStore = {
     // Accès au store interne — pour les adaptateurs Angular/React/Vue
@@ -320,22 +335,28 @@ function createStore(config) {
       });
     }
   }
-  store.init(publicStore);
+  if (!__internal?.skipInit) {
+    store.init(publicStore);
+  }
   return publicStore;
 }
 function on(sourceAction, handler) {
-  return subscribeToAction(sourceAction, (event) => {
-    try {
-      void handler(event.store, {
-        name: event.name,
-        args: event.args,
-        status: event.status,
-        duration: event.duration,
-        error: event.error
-      });
-    } catch {
-    }
-  });
+  const actions = Array.isArray(sourceAction) ? sourceAction : [sourceAction];
+  const unsubs = actions.map(
+    (action) => subscribeToAction(action, (event) => {
+      try {
+        void handler(event.store, {
+          name: event.name,
+          args: event.args,
+          status: event.status,
+          duration: event.duration,
+          error: event.error
+        });
+      } catch {
+      }
+    })
+  );
+  return () => unsubs.forEach((unsub) => unsub());
 }
 
 // src/types.ts
@@ -462,12 +483,16 @@ function abortable(fn) {
 // src/helpers/debounced.ts
 function debounced(fn, ms = 300) {
   let timer = null;
+  let latestState;
+  let latestArgs;
   return (state, ...args) => {
     if (timer) clearTimeout(timer);
+    latestState = state;
+    latestArgs = args;
     return new Promise((resolve, reject) => {
       timer = setTimeout(async () => {
         try {
-          await fn(state, ...args);
+          await fn(latestState, ...latestArgs);
           resolve();
         } catch (error) {
           reject(error);
@@ -483,16 +508,20 @@ function debounced(fn, ms = 300) {
 function throttled(fn, ms = 300) {
   let lastCall = 0;
   let timer = null;
+  let latestState;
+  let latestArgs;
   return async (state, ...args) => {
     const now = Date.now();
     const remaining = ms - (now - lastCall);
+    latestState = state;
+    latestArgs = args;
     if (remaining <= 0) {
       lastCall = now;
       if (timer) {
         clearTimeout(timer);
         timer = null;
       }
-      await fn(state, ...args);
+      await fn(latestState, ...latestArgs);
     } else {
       if (timer) clearTimeout(timer);
       return new Promise((resolve, reject) => {
@@ -500,7 +529,7 @@ function throttled(fn, ms = 300) {
           lastCall = Date.now();
           timer = null;
           try {
-            await fn(state, ...args);
+            await fn(latestState, ...latestArgs);
             resolve();
           } catch (error) {
             reject(error);
@@ -556,7 +585,7 @@ function fromStream(setupFn, updateFn, options) {
 // src/helpers/optimistic.ts
 function optimistic(immediate, confirm) {
   return async (state, ...args) => {
-    const snapshot = { ...state };
+    const snapshot = structuredClone(state);
     immediate(state, ...args);
     try {
       await confirm(state, ...args);
@@ -1581,30 +1610,261 @@ function withPersist(config, options) {
   };
 }
 
+// src/helpers/with-feature.ts
+function mergeHooks(a, b) {
+  if (!a) return b ?? {};
+  if (!b) return a;
+  const hookNames = [
+    "onInit",
+    "onDestroy",
+    "onAction",
+    "onActionDone",
+    "onError",
+    "onStateChange"
+  ];
+  const merged = { ...a };
+  for (const name of hookNames) {
+    const fnA = a[name];
+    const fnB = b[name];
+    if (fnA && fnB) {
+      merged[name] = (...args) => {
+        fnA(...args);
+        fnB(...args);
+      };
+    } else if (fnB) {
+      merged[name] = fnB;
+    }
+  }
+  return merged;
+}
+function mergeFeatures(...features) {
+  const result = {};
+  for (const feature of features) {
+    if (feature.state) {
+      Object.assign(result, feature.state);
+    }
+    if (feature.actions) {
+      result.actions = { ...result.actions ?? {}, ...feature.actions };
+    }
+    if (feature.computed) {
+      result.computed = { ...result.computed ?? {}, ...feature.computed };
+    }
+    if (feature.selectors) {
+      result.selectors = { ...result.selectors ?? {}, ...feature.selectors };
+    }
+    if (feature.effects?.length) {
+      result.effects = [...result.effects ?? [], ...feature.effects];
+    }
+    if (feature.hooks) {
+      result.hooks = mergeHooks(result.hooks, feature.hooks);
+    }
+  }
+  return result;
+}
+
+// src/helpers/with-props.ts
+function withProps(store, props) {
+  const enhanced = store;
+  for (const [key, value] of Object.entries(props)) {
+    Object.defineProperty(enhanced, key, {
+      get: () => value,
+      enumerable: true,
+      configurable: false
+    });
+  }
+  return enhanced;
+}
+
 // src/devtools.ts
-function createDevTools(maxLogs = 50) {
+function createDevTools(maxLogs = 100) {
   let counter = 0;
   const state = {
     logs: [],
     isOpen: false,
-    maxLogs
+    maxLogs,
+    activeLogId: null,
+    isTimeTraveling: false
   };
   const listeners = /* @__PURE__ */ new Set();
+  const storeRegistry = /* @__PURE__ */ new Map();
   function notify() {
-    listeners.forEach((cb) => cb({ ...state, logs: [...state.logs] }));
+    const snapshot = {
+      ...state,
+      logs: [...state.logs]
+    };
+    listeners.forEach((cb) => cb(snapshot));
+  }
+  function findLogIndex(logId) {
+    return state.logs.findIndex((l) => l.id === logId);
+  }
+  function getStoreForTravel(storeName) {
+    const entry = storeRegistry.get(storeName);
+    if (!entry) return null;
+    return entry.internalStore;
   }
   return {
     state,
+    // ── Action logging ─────────────────────────────────
     logAction(log) {
       const entry = {
         ...log,
         id: ++counter,
         at: (/* @__PURE__ */ new Date()).toISOString()
       };
+      if (state.isTimeTraveling && state.activeLogId !== null) {
+        const activeIdx = findLogIndex(state.activeLogId);
+        if (activeIdx >= 0) {
+          state.logs = state.logs.slice(activeIdx);
+        }
+        state.activeLogId = null;
+        state.isTimeTraveling = false;
+      }
       state.logs = [entry, ...state.logs].slice(0, maxLogs);
       notify();
     },
+    // ── Travel to a specific action ─────────────────────
+    travelTo(logId) {
+      const idx = findLogIndex(logId);
+      if (idx === -1) return;
+      const log = state.logs[idx];
+      const internalStore = getStoreForTravel(log.storeName);
+      if (!internalStore) return;
+      internalStore.hydrateForTimeTravel(log.nextState);
+      state.activeLogId = logId;
+      state.isTimeTraveling = true;
+      notify();
+    },
+    // ── Undo — step back in time ───────────────────────
+    // activeLogId always points to the log whose nextState is currently displayed.
+    // Logs are newest-first: [idx0=newest, idx1, ..., idxN=oldest]
+    // Undo moves deeper (higher index = older). Redo moves shallower (lower index = newer).
+    undo() {
+      if (!state.logs.length) return;
+      if (!state.isTimeTraveling || state.activeLogId === null) {
+        const latest = state.logs[0];
+        const internalStore2 = getStoreForTravel(latest.storeName);
+        if (!internalStore2) return;
+        if (state.logs.length > 1) {
+          const olderLog = state.logs[1];
+          internalStore2.hydrateForTimeTravel(olderLog.nextState);
+          state.activeLogId = olderLog.id;
+        } else {
+          internalStore2.hydrateForTimeTravel(latest.prevState);
+          state.activeLogId = -1;
+        }
+        state.isTimeTraveling = true;
+        notify();
+        return;
+      }
+      if (state.activeLogId === -1) return;
+      const currentIdx = findLogIndex(state.activeLogId);
+      if (currentIdx === -1) return;
+      const targetIdx = currentIdx + 1;
+      if (targetIdx >= state.logs.length) {
+        const currentLog = state.logs[currentIdx];
+        const internalStore2 = getStoreForTravel(currentLog.storeName);
+        if (!internalStore2) return;
+        internalStore2.hydrateForTimeTravel(currentLog.prevState);
+        state.activeLogId = -1;
+        notify();
+        return;
+      }
+      const targetLog = state.logs[targetIdx];
+      const internalStore = getStoreForTravel(targetLog.storeName);
+      if (!internalStore) return;
+      internalStore.hydrateForTimeTravel(targetLog.nextState);
+      state.activeLogId = targetLog.id;
+      notify();
+    },
+    // ── Redo — step forward in time ─────────────────────
+    redo() {
+      if (!state.isTimeTraveling || state.activeLogId === null) return;
+      if (state.activeLogId === -1) {
+        if (!state.logs.length) return;
+        const oldest = state.logs[state.logs.length - 1];
+        const internalStore2 = getStoreForTravel(oldest.storeName);
+        if (!internalStore2) return;
+        internalStore2.hydrateForTimeTravel(oldest.nextState);
+        state.activeLogId = oldest.id;
+        notify();
+        return;
+      }
+      const currentIdx = findLogIndex(state.activeLogId);
+      if (currentIdx === -1) return;
+      const targetIdx = currentIdx - 1;
+      if (targetIdx <= 0) {
+        this.resume();
+        return;
+      }
+      const targetLog = state.logs[targetIdx];
+      const internalStore = getStoreForTravel(targetLog.storeName);
+      if (!internalStore) return;
+      internalStore.hydrateForTimeTravel(targetLog.nextState);
+      state.activeLogId = targetLog.id;
+      notify();
+    },
+    // ── Resume — back to live state ─────────────────────
+    resume() {
+      if (!state.isTimeTraveling) return;
+      if (state.logs.length) {
+        const latest = state.logs[0];
+        const internalStore = getStoreForTravel(latest.storeName);
+        if (internalStore) {
+          internalStore.hydrateForTimeTravel(latest.nextState);
+        }
+      }
+      state.activeLogId = null;
+      state.isTimeTraveling = false;
+      notify();
+    },
+    // ── Replay — re-execute an action ───────────────────
+    replay(logId) {
+      const idx = findLogIndex(logId);
+      if (idx === -1) return;
+      const log = state.logs[idx];
+      const entry = storeRegistry.get(log.storeName);
+      if (!entry) return;
+      const rawName = log.name.replace(/^\[.*?\]\s*/, "");
+      if (state.isTimeTraveling) {
+        this.resume();
+      }
+      const publicStore = entry.store;
+      if (typeof publicStore[rawName] === "function") {
+        void publicStore[rawName](...log.args);
+      }
+    },
+    // ── Export snapshot ──────────────────────────────────
+    exportSnapshot() {
+      const stores = {};
+      for (const [name, { store }] of storeRegistry) {
+        stores[name] = store.getState();
+      }
+      return {
+        version: 1,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        stores,
+        logs: [...state.logs]
+      };
+    },
+    // ── Import snapshot ─────────────────────────────────
+    importSnapshot(snapshot) {
+      if (!snapshot || snapshot.version !== 1) return;
+      for (const [name, storeState] of Object.entries(snapshot.stores)) {
+        const entry = storeRegistry.get(name);
+        if (entry) {
+          entry.internalStore.hydrateForTimeTravel(storeState);
+        }
+      }
+      state.logs = snapshot.logs;
+      state.activeLogId = null;
+      state.isTimeTraveling = false;
+      notify();
+    },
+    // ── Basic controls ──────────────────────────────────
     clear() {
+      if (state.isTimeTraveling) {
+        this.resume();
+      }
       state.logs = [];
       notify();
     },
@@ -1623,6 +1883,13 @@ function createDevTools(maxLogs = 50) {
     subscribe(cb) {
       listeners.add(cb);
       return () => listeners.delete(cb);
+    },
+    // ── Store registry ──────────────────────────────────
+    registerStore(name, publicStore, internalStore) {
+      storeRegistry.set(name, { store: publicStore, internalStore });
+    },
+    getStoreRegistry() {
+      return storeRegistry;
     }
   };
 }
@@ -1632,6 +1899,7 @@ function connectDevTools(store, storeName) {
   let prevState = {};
   const internalStore = store.__store__;
   if (!internalStore) return;
+  devTools.registerStore(storeName, store, internalStore);
   const existingHooks = { ...internalStore["_hooks"] };
   internalStore["_hooks"] = {
     ...existingHooks,
@@ -1643,6 +1911,7 @@ function connectDevTools(store, storeName) {
       const nextState = store.getState();
       devTools.logAction({
         name: `[${storeName}] ${name}`,
+        storeName,
         args: [],
         duration,
         status: "success",
@@ -1654,6 +1923,7 @@ function connectDevTools(store, storeName) {
     onError(error, actionName) {
       devTools.logAction({
         name: `[${storeName}] ${actionName}`,
+        storeName,
         args: [],
         duration: 0,
         status: "error",
@@ -1692,6 +1962,7 @@ exports.forkJoin = forkJoin;
 exports.fromStream = fromStream;
 exports.http = http;
 exports.mapStream = mapStream;
+exports.mergeFeatures = mergeFeatures;
 exports.mergeMapStream = mergeMapStream;
 exports.on = on;
 exports.optimistic = optimistic;
@@ -1705,5 +1976,6 @@ exports.throttleStream = throttleStream;
 exports.throttled = throttled;
 exports.withEntities = withEntities;
 exports.withPersist = withPersist;
+exports.withProps = withProps;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map