@effuse/store 1.0.2 → 1.0.3

package/dist/index.cjs

@@ -147,18 +147,182 @@ var clearStores = () => {
   stores.clear();
 };
 var getStoreNames = () => Array.from(stores.keys());
-var localStorageAdapter = {
+var getSnapshot = (signalMap) => {
+  const snapshot = {};
+  for (const [key, sig] of signalMap) {
+    snapshot[key] = sig.value;
+  }
+  return snapshot;
+};
+var notifyAll = (deps) => {
+  if (deps.internals.isBatching) return;
+  for (const callback of deps.internals.subscribers) callback();
+};
+var notifyKey = (deps, key, value) => {
+  if (deps.internals.isBatching) return;
+  const subs = deps.internals.keySubscribers.get(key);
+  if (subs) for (const cb of subs) cb(value);
+};
+var persist = (deps) => {
+  if (!deps.config.shouldPersist) return;
+  const snapshot = getSnapshot(deps.internals.signalMap);
+  runAdapter.setItem(
+    deps.config.adapter,
+    deps.config.storageKey,
+    JSON.stringify(snapshot)
+  );
+};
+var updateComputed = (deps) => {
+  const snapshot = getSnapshot(deps.internals.signalMap);
+  for (const [selector, sig] of deps.internals.computedSelectors) {
+    const newValue = selector(snapshot);
+    if (sig.value !== newValue) sig.value = newValue;
+  }
+};
+var logDevtools = (deps, actionType, payload, prevState, nextState) => {
+  if (!deps.config.enableDevtools) return;
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  console.groupCollapsed(
+    `%caction %c${deps.config.name}/${actionType} %c@ ${time}`,
+    "color: gray; font-weight: lighter;",
+    "color: inherit; font-weight: bold;",
+    "color: gray; font-weight: lighter;"
+  );
+  console.log("%cprev state", "color: #9E9E9E; font-weight: bold;", prevState);
+  console.log("%caction", "color: #03A9F4; font-weight: bold;", {
+    type: actionType,
+    payload
+  });
+  console.log("%cnext state", "color: #4CAF50; font-weight: bold;", nextState);
+  console.groupEnd();
+};
+var setValue = (deps, input) => {
+  const { prop, value } = input;
+  const { internals, atomicState, middlewareManager, config } = deps;
+  if (!internals.signalMap.has(prop)) {
+    internals.signalMap.set(prop, core.signal(value));
+  }
+  const sig = internals.signalMap.get(prop);
+  if (!sig) return false;
+  const prevState = config.enableDevtools ? getSnapshot(internals.signalMap) : {};
+  const newState = middlewareManager.execute(
+    { ...atomicState.get(), [prop]: value },
+    `set:${prop}`,
+    [value]
+  );
+  sig.value = newState[prop];
+  atomicState.update((s) => ({ ...s, [prop]: newState[prop] }));
+  logDevtools(deps, `set:${prop}`, value, prevState, {
+    ...atomicState.get(),
+    [prop]: newState[prop]
+  });
+  notifyAll(deps);
+  notifyKey(deps, prop, newState[prop]);
+  persist(deps);
+  updateComputed(deps);
+  return true;
+};
+var resetState = (deps) => {
+  const { internals, atomicState, config } = deps;
+  const prevState = config.enableDevtools ? getSnapshot(internals.signalMap) : {};
+  for (const [key, value] of Object.entries(internals.initialState)) {
+    const sig = internals.signalMap.get(key);
+    if (sig) sig.value = value;
+  }
+  atomicState.set({ ...internals.initialState });
+  logDevtools(deps, "reset", null, prevState, { ...internals.initialState });
+  notifyAll(deps);
+  persist(deps);
+  updateComputed(deps);
+};
+var batchUpdates = (deps, updates) => {
+  deps.internals.isBatching = true;
+  try {
+    updates();
+  } finally {
+    deps.internals.isBatching = false;
+  }
+  notifyAll(deps);
+  persist(deps);
+  updateComputed(deps);
+};
+var updateState = (deps, input) => {
+  const { internals, atomicState, config } = deps;
+  const prevState = config.enableDevtools ? getSnapshot(internals.signalMap) : {};
+  const draft = { ...getSnapshot(internals.signalMap) };
+  input.updater(draft);
+  internals.isBatching = true;
+  for (const [key, val] of Object.entries(draft)) {
+    const sig = internals.signalMap.get(key);
+    if (sig && sig.value !== val) {
+      sig.value = val;
+      atomicState.update((s) => ({ ...s, [key]: val }));
+    }
+  }
+  internals.isBatching = false;
+  logDevtools(
+    deps,
+    "update",
+    null,
+    prevState,
+    getSnapshot(internals.signalMap)
+  );
+  notifyAll(deps);
+  persist(deps);
+  updateComputed(deps);
+};
+var addSubscriber = (internals, input) => {
+  internals.subscribers.add(input.callback);
+  return () => {
+    internals.subscribers.delete(input.callback);
+  };
+};
+var addKeySubscriber = (internals, input) => {
+  let subs = internals.keySubscribers.get(input.key);
+  if (!subs) {
+    subs = /* @__PURE__ */ new Set();
+    internals.keySubscribers.set(input.key, subs);
+  }
+  subs.add(input.callback);
+  return () => {
+    const subsSet = internals.keySubscribers.get(input.key);
+    if (effect.Predicate.isNotNullable(subsSet)) {
+      subsSet.delete(input.callback);
+    }
+  };
+};
+
+// src/persistence/adapters.ts
+var createBrowserStorageAdapter = (storage) => ({
   getItem: (key) => effect.Effect.try({
-    try: () => effect.Option.fromNullable(localStorage.getItem(key)),
+    try: () => effect.Option.fromNullable(storage.getItem(key)),
     catch: () => effect.Option.none()
   }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(effect.Option.none()))),
   setItem: (key, value) => effect.Effect.try(() => {
-    localStorage.setItem(key, value);
+    storage.setItem(key, value);
   }).pipe(effect.Effect.catchAll(() => effect.Effect.void)),
   removeItem: (key) => effect.Effect.try(() => {
-    localStorage.removeItem(key);
-  }).pipe(effect.Effect.catchAll(() => effect.Effect.void))
-};
+    storage.removeItem(key);
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.void)),
+  has: (key) => effect.Effect.try({
+    try: () => storage.getItem(key) !== null,
+    catch: () => false
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(false))),
+  clear: () => effect.Effect.try(() => {
+    storage.clear();
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.void)),
+  keys: () => effect.Effect.try({
+    try: () => Object.keys(storage),
+    catch: () => []
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed([]))),
+  size: () => effect.Effect.try({
+    try: () => storage.length,
+    catch: () => 0
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(0)))
+});
+var localStorageAdapter = createBrowserStorageAdapter(
+  typeof localStorage !== "undefined" ? localStorage : {}
+);
 var runAdapter = {
   getItem: (adapter, key) => effect.Effect.runSync(
     adapter.getItem(key).pipe(effect.Effect.map((opt) => effect.Option.getOrNull(opt)))
@@ -168,7 +332,13 @@ var runAdapter = {
   },
   removeItem: (adapter, key) => {
     effect.Effect.runSync(adapter.removeItem(key));
-  }
+  },
+  has: (adapter, key) => effect.Effect.runSync(adapter.has(key)),
+  clear: (adapter) => {
+    effect.Effect.runSync(adapter.clear());
+  },
+  keys: (adapter) => effect.Effect.runSync(adapter.keys()),
+  size: (adapter) => effect.Effect.runSync(adapter.size())
 };
 var createCancellationToken = () => {
   let cancelled = false;
@@ -219,8 +389,8 @@ var createCancellationScope = () => {
     }
   };
 };
-var runWithAbortSignal = (effect$1, signal5) => {
-  if (signal5.aborted) {
+var runWithAbortSignal = (effect$1, signal6) => {
+  if (signal6.aborted) {
     return effect.Effect.fail(
       new CancellationError({ message: "Operation was cancelled" })
     );
@@ -233,25 +403,18 @@ var runWithAbortSignal = (effect$1, signal5) => {
         )
       );
     };
-    signal5.addEventListener("abort", onAbort, { once: true });
+    signal6.addEventListener("abort", onAbort, { once: true });
     effect.Effect.runPromise(effect$1).then((result) => {
-      signal5.removeEventListener("abort", onAbort);
+      signal6.removeEventListener("abort", onAbort);
       resume(effect.Effect.succeed(result));
     }).catch((error) => {
-      signal5.removeEventListener("abort", onAbort);
+      signal6.removeEventListener("abort", onAbort);
       resume(effect.Effect.fail(error));
     });
   });
 };
 
 // src/core/store.ts
-var getSnapshot = (signalMap) => {
-  const snapshot = {};
-  for (const [key, sig] of signalMap) {
-    snapshot[key] = sig.value;
-  }
-  return snapshot;
-};
 var createStore = (name, definition, options) => {
   const config = getStoreConfig();
   const shouldPersist = effect.pipe(
@@ -285,6 +448,7 @@ var createStore = (name, definition, options) => {
     keySubscribers: /* @__PURE__ */ new Map(),
     computedSelectors: /* @__PURE__ */ new Map(),
     isBatching: false,
+    cancellationScope: createCancellationScope(),
     pendingActions: /* @__PURE__ */ new Map()
   };
   const middlewareManager = createMiddlewareManager();
@@ -297,6 +461,18 @@ var createStore = (name, definition, options) => {
     }
   }
   const atomicState = createAtomicState({ ...internals.initialState });
+  const handlerDeps = {
+    internals,
+    atomicState,
+    middlewareManager,
+    config: {
+      name,
+      shouldPersist,
+      storageKey,
+      enableDevtools,
+      adapter
+    }
+  };
   if (shouldPersist) {
     effect.pipe(
       runAdapter.getItem(adapter, storageKey),
@@ -320,27 +496,6 @@ var createStore = (name, definition, options) => {
       })
     );
   }
-  const notifySubscribers = () => {
-    if (internals.isBatching) return;
-    for (const callback of internals.subscribers) callback();
-  };
-  const notifyKeySubscribers = (key, value) => {
-    if (internals.isBatching) return;
-    const subs = internals.keySubscribers.get(key);
-    if (subs) for (const cb of subs) cb(value);
-  };
-  const persistState = () => {
-    if (!shouldPersist) return;
-    const snapshot = getSnapshot(internals.signalMap);
-    runAdapter.setItem(adapter, storageKey, JSON.stringify(snapshot));
-  };
-  const updateComputed = () => {
-    const snapshot = getSnapshot(internals.signalMap);
-    for (const [selector, sig] of internals.computedSelectors) {
-      const newValue = selector(snapshot);
-      if (sig.value !== newValue) sig.value = newValue;
-    }
-  };
   const stateProxy = new Proxy({}, {
     get(_, prop) {
       const sig = internals.signalMap.get(prop);
@@ -350,44 +505,7 @@ var createStore = (name, definition, options) => {
       return void 0;
     },
     set(_, prop, value) {
-      if (!internals.signalMap.has(prop)) return false;
-      const sig = internals.signalMap.get(prop);
-      if (!sig) return false;
-      const newState = middlewareManager.execute(
-        { ...atomicState.get(), [prop]: value },
-        `set:${prop}`,
-        [value]
-      );
-      sig.value = newState[prop];
-      atomicState.update((s) => ({ ...s, [prop]: newState[prop] }));
-      if (enableDevtools) {
-        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
-        console.groupCollapsed(
-          `%caction %c${name}/set:${prop} %c@ ${time}`,
-          "color: gray; font-weight: lighter;",
-          "color: inherit; font-weight: bold;",
-          "color: gray; font-weight: lighter;"
-        );
-        console.log(
-          "%cprev state",
-          "color: #9E9E9E; font-weight: bold;",
-          atomicState.get()
-        );
-        console.log("%caction", "color: #03A9F4; font-weight: bold;", {
-          type: `set:${prop}`,
-          payload: value
-        });
-        console.log("%cnext state", "color: #4CAF50; font-weight: bold;", {
-          ...atomicState.get(),
-          [prop]: newState[prop]
-        });
-        console.groupEnd();
-      }
-      notifySubscribers();
-      notifyKeySubscribers(prop, newState[prop]);
-      persistState();
-      updateComputed();
-      return true;
+      return setValue(handlerDeps, { prop, value });
     }
   });
   const boundActions = {};
@@ -431,7 +549,7 @@ var createStore = (name, definition, options) => {
               );
               console.groupEnd();
             }
-            notifySubscribers();
+            for (const callback of internals.subscribers) callback();
           }
           return value;
         }).catch((error) => {
@@ -465,7 +583,7 @@ var createStore = (name, definition, options) => {
         );
         console.groupEnd();
       }
-      notifySubscribers();
+      for (const callback of internals.subscribers) callback();
       return result;
     };
   }
@@ -476,27 +594,14 @@ var createStore = (name, definition, options) => {
   const store = {
     name,
     state: storeState,
-    subscribe: (callback) => {
-      internals.subscribers.add(callback);
-      return () => {
-        internals.subscribers.delete(callback);
-      };
-    },
+    subscribe: (callback) => addSubscriber(internals, { callback }),
     subscribeToKey: (key, callback) => {
       const keyStr = String(key);
-      let subs = internals.keySubscribers.get(keyStr);
-      if (!subs) {
-        subs = /* @__PURE__ */ new Set();
-        internals.keySubscribers.set(keyStr, subs);
-      }
       const typedCallback = callback;
-      subs.add(typedCallback);
-      return () => {
-        const subsSet = internals.keySubscribers.get(keyStr);
-        if (effect.Predicate.isNotNullable(subsSet)) {
-          subsSet.delete(typedCallback);
-        }
-      };
+      return addKeySubscriber(internals, {
+        key: keyStr,
+        callback: typedCallback
+      });
     },
     getSnapshot: () => getSnapshot(internals.signalMap),
     computed: (selector) => {
@@ -509,40 +614,17 @@ var createStore = (name, definition, options) => {
       return sig;
     },
     batch: (updates) => {
-      internals.isBatching = true;
-      updates();
-      internals.isBatching = false;
-      notifySubscribers();
-      persistState();
-      updateComputed();
+      batchUpdates(handlerDeps, updates);
     },
     reset: () => {
-      for (const [key, value] of Object.entries(internals.initialState)) {
-        const sig = internals.signalMap.get(key);
-        if (sig) sig.value = value;
-      }
-      atomicState.set({ ...internals.initialState });
-      notifySubscribers();
-      persistState();
-      updateComputed();
+      resetState(handlerDeps);
     },
     use: (middleware) => middlewareManager.add(middleware),
     toJSON: () => getSnapshot(internals.signalMap),
     update: (updater) => {
-      const draft = { ...getSnapshot(internals.signalMap) };
-      updater(draft);
-      internals.isBatching = true;
-      for (const [key, val] of Object.entries(draft)) {
-        const sig = internals.signalMap.get(key);
-        if (sig && sig.value !== val) {
-          sig.value = val;
-          atomicState.update((s) => ({ ...s, [key]: val }));
-        }
-      }
-      internals.isBatching = false;
-      notifySubscribers();
-      persistState();
-      updateComputed();
+      updateState(handlerDeps, {
+        updater
+      });
     },
     select: (selector) => {
       const selectorKey = selector;
@@ -567,6 +649,13 @@ var createStore = (name, definition, options) => {
       if (sig) return sig;
       if (propStr in boundActions) return boundActions[propStr];
       return void 0;
+    },
+    set(target, prop, value) {
+      const propStr = String(prop);
+      if (propStr in target) {
+        return false;
+      }
+      return setValue(handlerDeps, { prop: propStr, value });
     }
   });
   registerStore(name, storeProxy);
@@ -676,7 +765,7 @@ var createCancellableAction = (fn) => {
       currentController.abort();
     }
     currentController = new AbortController();
-    const signal5 = currentController.signal;
+    const signal6 = currentController.signal;
     pending = true;
     try {
       const effect$1 = effect.Effect.tryPromise({
@@ -684,7 +773,7 @@ var createCancellableAction = (fn) => {
         catch: (error) => error
       });
       const result = await effect.Effect.runPromise(
-        runWithAbortSignal(effect$1, signal5)
+        runWithAbortSignal(effect$1, signal6)
       );
       return result;
     } finally {
@@ -863,12 +952,12 @@ var dispatchSync = (store, actionName, ...args) => {
   return actionFn(...args);
 };
 var withAbortSignal = (fn) => {
-  return (signal5, ...args) => {
+  return (signal6, ...args) => {
     const effect$1 = effect.Effect.tryPromise({
       try: async () => fn(...args),
       catch: (error) => error
     });
-    return effect.Effect.runPromise(runWithAbortSignal(effect$1, signal5));
+    return effect.Effect.runPromise(runWithAbortSignal(effect$1, signal6));
   };
 };
 var validateState = (schema, state) => {