valdres 0.2.0-alpha.0 → 0.2.0-alpha.11

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { atom } from "./src/atom";
 export { atomFamily } from "./src/atomFamily";
 export { createStore } from "./src/createStore";
+export { createStoreWithSelectorSet } from "./src/createStoreWithSelectorSet";
 export { getDefaultStore, resetDefaultStore } from "./src/getDefaultStore";
 export { selector } from "./src/selector";
 export { selectorFamily } from "./src/selectorFamily";
@@ -9,6 +10,12 @@ export { isSelector } from "./src/utils/isSelector";
 export { isFamily } from "./src/utils/isFamily";
 export { isPromiseLike } from "./src/utils/isPromiseLike";
 export type { Atom } from "./src/types/Atom";
+export type { AtomFamily } from "./src/types/AtomFamily";
+export type { GetValue } from "./src/types/GetValue";
 export type { Selector } from "./src/types/Selector";
+export type { SelectorFamily } from "./src/types/SelectorFamily";
+export type { SetAtom } from "./src/types/SetAtom";
+export type { SetAtomValue } from "./src/types/SetAtomValue";
 export type { State } from "./src/types/State";
 export type { Store } from "./src/types/Store";
+export type { StoreData } from "./src/types/StoreData";

package/dist/index.js

@@ -1,121 +1,100 @@
-// src/atom.ts
-var atom = (defaultValue, options) => {
-  if (!options)
-    return { defaultValue };
-  return {
-    defaultValue,
-    ...options
-  };
-};
-// src/utils/isPromiseLike.ts
-var isPromiseLike = (object) => object && object.then && typeof object.then === "function";
+// src/lib/setAtom.ts
+import equal4 from "fast-deep-equal";
 
-// src/lib/stableStringify.ts
-var stableStringifyRecurse = (x, key) => {
-  if (typeof x === "string" && !x.includes('"') && !x.includes("\\")) {
-    return `"${x}"`;
-  }
-  switch (typeof x) {
-    case "undefined":
-      return "";
-    case "boolean":
-      return x ? "true" : "false";
-    case "number":
-    case "symbol":
-      return String(x);
-    case "string":
-      return JSON.stringify(x);
-    case "function":
-      return `__FUNCTION(${x.toString()})__`;
-  }
-  if (x === null) {
-    return "null";
-  }
-  if (typeof x !== "object") {
-    return JSON.stringify(x) ?? "";
-  }
-  if (isPromiseLike(x)) {
-    return "__PROMISE__";
-  }
-  if (Array.isArray(x)) {
-    return `[${x.map((v, i) => stableStringifyRecurse(v, i.toString()))}]`;
-  }
-  if (typeof x.toJSON === "function") {
-    return stableStringifyRecurse(x.toJSON(key), key);
-  }
-  if (x instanceof Map) {
-    const obj = {};
-    for (const [k, v] of x) {
-      obj[typeof k === "string" ? k : stringify(k, opt)] = v;
-    }
-    return stableStringifyRecurse(obj, key);
-  }
-  if (x instanceof Set) {
-    return stableStringifyRecurse(Array.from(x).sort((a, b) => stableStringifyRecurse(a).localeCompare(stableStringifyRecurse(b))), key);
-  }
-  if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === "function") {
-    return stableStringifyRecurse(Array.from(x), key);
-  }
-  return `{${Object.keys(x).filter((k) => x[k] !== undefined).sort().map((k) => `${stableStringifyRecurse(k)}:${stableStringifyRecurse(x[k], k)}`).join(",")}}`;
-};
-var stableStringify = (x) => {
-  if (typeof x === "string" || typeof x === "boolean" || typeof x === "number")
-    return x;
-  return stableStringifyRecurse(x);
+// src/utils/isPromiseLike.ts
+var isPromiseLike = (object) => {
+  return object && object.then && typeof object.then === "function";
 };
 
-// src/atomFamily.ts
-var handleDefaultValue = (defaultValue, override, key) => {
-  if (override) {
-    return typeof override === "function" ? () => typeof defaultValue === "function" ? override(defaultValue(key)) : override(defaultValue) : override;
-  } else {
-    return typeof defaultValue === "function" ? () => defaultValue(key) : defaultValue;
-  }
-};
-var atomFamily = (defaultValue, debugLabel) => {
-  const map = new Map;
-  const atomFamily2 = (key, defaultOverride) => {
-    const keyStringified = stableStringify(key);
-    if (map.has(keyStringified)) {
-      if (defaultOverride)
-        throw new Error("defaultOverride is only allowed first time an atom is initiaizlied");
-      return map.get(keyStringified);
-    }
-    const atomDebugLabel = debugLabel && debugLabel + "_" + keyStringified;
-    const newAtom = atom(handleDefaultValue(defaultValue, defaultOverride, key), {
-      label: atomDebugLabel
-    });
-    newAtom.family = atomFamily2;
-    newAtom.familyKey = Object.freeze(key);
-    map.set(keyStringified, newAtom);
-    return newAtom;
-  };
-  atomFamily2._map = map;
-  return atomFamily2;
-};
 // src/lib/updateStateSubscribers.ts
-var updateStateSubscribers = (state2, data) => {
-  const subscribtions = data.subscriptions.get(state2);
+var updateStateSubscribers = (state, data) => {
+  const subscribtions = data.subscriptions.get(state);
   if (subscribtions?.size) {
     for (const subscribtion of subscribtions) {
       subscribtion.callback();
     }
   }
-  if (state2.family) {
-    const familySubscriptions = data.subscriptions.get(state2.family);
+  if (state.family) {
+    const familySubscriptions = data.subscriptions.get(state.family);
     if (familySubscriptions?.size) {
       for (const subscribtion of familySubscriptions) {
-        subscribtion.callback(state2.familyKey);
+        subscribtion.callback(state.familyKey);
       }
     }
   }
 };
 
 // src/lib/updateSelectorSubscribers.ts
-import equal2 from "fast-deep-equal";
+import equal3 from "fast-deep-equal";
 
 // src/lib/initSelector.ts
+import equal2 from "fast-deep-equal";
+
+// src/lib/getState.ts
 import equal from "fast-deep-equal";
+
+// src/lib/initAtom.ts
+var getAtomInitValue = (atom, data) => {
+  if (atom.defaultValue === undefined) {
+    let promiseResolve;
+    const promise = new Promise((resolve) => {
+      promiseResolve = resolve;
+    });
+    promise.__isEmptyAtomPromise__ = true;
+    promise.__resolveEmptyAtomPromise__ = promiseResolve;
+    return promise;
+  } else if (typeof atom.defaultValue === "function") {
+    const value = atom.defaultValue();
+    if (isPromiseLike(value)) {
+      value.then((resolvedValue) => {
+        data.values.set(atom, resolvedValue);
+        propagateUpdatedAtoms([atom], data);
+      });
+    }
+    return value;
+  } else {
+    return atom.defaultValue;
+  }
+};
+var initAtom = (atom, data) => {
+  let value = getAtomInitValue(atom, data);
+  data.values.set(atom, value);
+  if (atom.onInit)
+    atom.onInit((newVal) => {
+      value = newVal;
+      setAtom(atom, newVal, data, true);
+    }, data);
+  return value;
+};
+
+// src/utils/isAtom.ts
+var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+
+// src/utils/isSelector.ts
+var isSelector = (state) => Object.hasOwn(state, "get");
+
+// src/utils/isFamily.ts
+var isFamily = (state) => Object.hasOwn(state, "_map");
+
+// src/lib/getState.ts
+function getState(state, data) {
+  if (data.values.has(state))
+    return data.values.get(state);
+  if (isAtom(state))
+    return initAtom(state, data);
+  if (isSelector(state))
+    return initSelector(state, data);
+  if (isFamily(state)) {
+    const array = Array.from(state._map.keys());
+    if (equal(array, state._keyArray))
+      return state._keyArray;
+    state._keyArray = array;
+    return array;
+  }
+  throw new Error("Invalid object passed to get");
+}
+
+// src/lib/initSelector.ts
 class SuspendAndWaitForResolveError extends Error {
   promise;
   constructor(promise) {
@@ -123,26 +102,25 @@ class SuspendAndWaitForResolveError extends Error {
     this.promise = promise;
   }
 }
-var getOrInitConsumersSet = (state2, data) => {
-  const set = data.stateConsumers.get(state2);
+var getOrInitConsumersSet = (state, data) => {
+  const set = data.stateConsumers.get(state);
   if (set)
     return set;
   const newSet = new Set;
-  data.stateConsumers.set(state2, newSet);
+  data.stateConsumers.set(state, newSet);
   return newSet;
 };
 var evaluateSelector = (selector, data) => {
-  const currentDependencies = data.stateDependencies.get(selector) ?? new Set;
   const updatedDependencies = new Set;
   let result;
   try {
-    result = selector.get((state2) => {
-      const value = getState2(state2, data);
-      updatedDependencies.add(state2);
+    result = selector.get((state) => {
+      const value = getState(state, data);
+      updatedDependencies.add(state);
       if (isPromiseLike(value))
         throw new SuspendAndWaitForResolveError(value);
       return value;
-    });
+    }, data.id);
   } catch (error) {
     if (error instanceof SuspendAndWaitForResolveError) {
       result = error;
@@ -150,14 +128,15 @@ var evaluateSelector = (selector, data) => {
       throw error;
     }
   }
+  const currentDependencies = data.stateDependencies.get(selector) ?? new Set;
   const added = updatedDependencies?.difference(currentDependencies);
   const removed = currentDependencies?.difference(updatedDependencies);
-  for (const state2 of added) {
-    const set = getOrInitConsumersSet(state2, data);
+  for (const state of added) {
+    const set = getOrInitConsumersSet(state, data);
     set.add(selector);
   }
-  for (const state2 of removed) {
-    const set = getOrInitConsumersSet(state2, data);
+  for (const state of removed) {
+    const set = getOrInitConsumersSet(state, data);
     set.delete(selector);
   }
   data.stateDependencies.set(selector, updatedDependencies);
@@ -171,7 +150,7 @@ var handleSelectorResult = (value, selector, data) => {
     value.then((resolved) => {
       data.values.set(selector, resolved);
       updateStateSubscribers(selector, data);
-      console.log(`TODO: Should we check if other selectors are using this?`);
+      console.log("Should we reEvaluate?");
     });
     return value;
   } else {
@@ -183,7 +162,7 @@ var initSelector = (selector, data) => {
   const value = handleSelectorResult(tmpValue, selector, data);
   if (data.expiredValues.has(selector)) {
     const expiredValue = data.expiredValues.get(selector);
-    if (equal(expiredValue, value)) {
+    if (equal2(expiredValue, value)) {
       data.values.set(selector, expiredValue);
       return expiredValue;
     }
@@ -198,11 +177,11 @@ var updateSelectorSubscribers = (selector, data) => {
   const familySubscriptions = selector.family && data.subscriptions.get(selector.family);
   if (!subscribtions?.size && !familySubscriptions?.size)
     return;
-  if (subscribtions?.size && data.subscriptionsRequireEqualCheck.get(selector) || familySubscriptions?.size && data.subscriptionsRequireEqualCheck.get(selector.family)) {
+  if (subscribtions?.size && data.subscriptionsRequireEqualCheck.get(selector) || familySubscriptions?.size && selector.family && data.subscriptionsRequireEqualCheck.get(selector.family)) {
     try {
       const oldValue = data.expiredValues.get(selector);
       const newValue = initSelector(selector, data);
-      if (equal2(newValue, oldValue))
+      if (equal3(newValue, oldValue))
         return;
     } catch (e) {
     }
@@ -214,7 +193,7 @@ var updateSelectorSubscribers = (selector, data) => {
   }
   if (familySubscriptions?.size) {
     for (const subscribtion of familySubscriptions) {
-      subscribtion.callback(state.familyKey);
+      subscribtion.callback(selector.familyKey);
     }
   }
 };
@@ -235,13 +214,13 @@ var recursivlyResetSelectorTree = (selectors, data, clearedSelectors) => {
 };
 var propagateUpdatedAtoms = (atoms, data) => {
   const clearedSelectors = new Set;
-  for (const atom3 of atoms) {
-    const consumers = data.stateConsumers.get(atom3);
+  for (const atom of atoms) {
+    const consumers = data.stateConsumers.get(atom);
     if (consumers && consumers.size) {
       recursivlyResetSelectorTree(consumers, data, clearedSelectors);
     }
-    if (atom3.family) {
-      const consumersFamily = data.stateConsumers.get(atom3.family);
+    if (atom.family) {
+      const consumersFamily = data.stateConsumers.get(atom.family);
       if (consumersFamily?.size) {
         recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
       }
@@ -250,95 +229,176 @@ var propagateUpdatedAtoms = (atoms, data) => {
   for (const selector of clearedSelectors) {
     updateSelectorSubscribers(selector, data);
   }
-  for (const atom3 of atoms) {
-    updateStateSubscribers(atom3, data);
+  for (const atom of atoms) {
+    updateStateSubscribers(atom, data);
   }
 };
 
 // src/lib/setAtom.ts
-import equal3 from "fast-deep-equal";
-var setAtom = (atom3, newValue, data) => {
-  const currentValue = getState2(atom3, data);
+var setAtom = (atom, newValue, data, skipOnSet = false) => {
+  const currentValue = getState(atom, data);
   if (typeof newValue === "function") {
     newValue = newValue(currentValue);
     if (isPromiseLike(newValue) || isPromiseLike(currentValue))
       throw new Error("Todo, how should we handle this?");
   }
-  if (equal3(currentValue, newValue))
+  if (equal4(currentValue, newValue))
     return;
-  data.values.set(atom3, newValue);
+  data.values.set(atom, newValue);
+  if (atom.onSet && !skipOnSet)
+    atom.onSet(newValue, data);
   if (currentValue?.__isEmptyAtomPromise__) {
     currentValue.__resolveEmptyAtomPromise__(newValue);
   }
-  propagateUpdatedAtoms([atom3], data);
+  propagateUpdatedAtoms([atom], data);
 };
 
-// src/lib/initAtom.ts
-var getAtomInitValue = (atom3, data) => {
-  if (atom3.defaultValue === undefined) {
-    let promiseResolve;
-    const promise = new Promise((resolve) => {
-      promiseResolve = resolve;
-    });
-    promise.__isEmptyAtomPromise__ = true;
-    promise.__resolveEmptyAtomPromise__ = promiseResolve;
-    return promise;
-  } else if (typeof atom3.defaultValue === "function") {
-    const value = atom3.defaultValue();
-    if (isPromiseLike(value)) {
-      value.then((resolvedValue) => {
-        data.values.set(atom3, resolvedValue);
-        propagateUpdatedAtoms([atom3], data);
-      });
+// src/atom.ts
+var globalAtom = (defaultValue, options) => {
+  const stores = new Set;
+  let value = defaultValue;
+  const onSet = (newValue, currentStore) => {
+    value = newValue;
+    if (stores.size > 1) {
+      for (const store of stores) {
+        if (store.id !== currentStore.id) {
+          setAtom(newAtom, value, store, true);
+        }
+      }
     }
-    return value;
-  } else {
-    return atom3.defaultValue;
+  };
+  const newAtom = {
+    defaultValue,
+    ...options,
+    onInit: (setSelf, store) => {
+      setSelf(value);
+      stores.add(store);
+    },
+    onSet,
+    label: options?.label
+  };
+  return newAtom;
+};
+var atom = (defaultValue, options) => {
+  if (!options)
+    return { defaultValue };
+  if (options.global)
+    return globalAtom(defaultValue, options);
+  return {
+    defaultValue,
+    ...options
+  };
+};
+// src/lib/stableStringify.ts
+var stableStringifyRecurse = (x, key) => {
+  if (typeof x === "string" && !x.includes('"') && !x.includes("\\")) {
+    return `"${x}"`;
+  }
+  switch (typeof x) {
+    case "undefined":
+      return "";
+    case "boolean":
+      return x ? "true" : "false";
+    case "number":
+    case "symbol":
+      return String(x);
+    case "string":
+      return JSON.stringify(x);
+    case "function":
+      return `__FUNCTION(${x.toString()})__`;
   }
+  if (x === null) {
+    return "null";
+  }
+  if (typeof x !== "object") {
+    return JSON.stringify(x) ?? "";
+  }
+  if (isPromiseLike(x)) {
+    return "__PROMISE__";
+  }
+  if (Array.isArray(x)) {
+    return `[${x.map((v, i) => stableStringifyRecurse(v, i.toString()))}]`;
+  }
+  if (typeof x.toJSON === "function") {
+    return stableStringifyRecurse(x.toJSON(key), key);
+  }
+  if (x instanceof Map) {
+    const obj = {};
+    for (const [k, v] of x) {
+      obj[typeof k === "string" ? k : stringify(k, opt)] = v;
+    }
+    return stableStringifyRecurse(obj, key);
+  }
+  if (x instanceof Set) {
+    return stableStringifyRecurse(Array.from(x).sort((a, b) => stableStringifyRecurse(a).localeCompare(stableStringifyRecurse(b))), key);
+  }
+  if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === "function") {
+    return stableStringifyRecurse(Array.from(x), key);
+  }
+  return `{${Object.keys(x).filter((k) => x[k] !== undefined).sort().map((k) => `${stableStringifyRecurse(k)}:${stableStringifyRecurse(x[k], k)}`).join(",")}}`;
 };
-var initAtom = (atom3, data) => {
-  const value = getAtomInitValue(atom3, data);
-  data.values.set(atom3, value);
-  if (atom3.onInit)
-    atom3.onInit((newVal) => {
-      setAtom(atom3, newVal, data);
-    });
-  return value;
+var stableStringify = (x) => {
+  if (typeof x === "string" || typeof x === "boolean" || typeof x === "number")
+    return x;
+  return stableStringifyRecurse(x);
 };
 
-// src/utils/isAtom.ts
-var isAtom = (state2) => Object.hasOwn(state2, "defaultValue");
-
-// src/utils/isSelector.ts
-var isSelector = (state2) => Object.hasOwn(state2, "get");
-
-// src/utils/isFamily.ts
-var isFamily = (state2) => Object.hasOwn(state2, "_map");
-
-// src/lib/getState.ts
-var getState2 = (state2, data) => {
-  if (data.values.has(state2))
-    return data.values.get(state2);
-  if (isAtom(state2))
-    return initAtom(state2, data);
-  if (isSelector(state2))
-    return initSelector(state2, data);
-  if (isFamily(state2)) {
-    const res = [];
-    for (const atom3 of state2._map.values()) {
-      res.push([atom3.familyKey, getState2(atom3, data)]);
+// src/atomFamily.ts
+var createOptions = (options, key) => {
+  if (options.label) {
+    return {
+      ...options,
+      label: options?.label + "_" + key
+    };
+  } else {
+    return options;
+  }
+};
+var atomFamily = (defaultValue, options) => {
+  const map = new Map;
+  const atomFamily2 = (key) => {
+    const keyStringified = stableStringify(key);
+    if (map.has(keyStringified)) {
+      return map.get(keyStringified);
     }
-    return res;
+    const newAtom = atom(typeof defaultValue === "function" ? () => defaultValue(key) : defaultValue, options ? createOptions(options, keyStringified) : undefined);
+    newAtom.family = atomFamily2;
+    newAtom.familyKey = Object.freeze(key);
+    map.set(keyStringified, newAtom);
+    return newAtom;
+  };
+  atomFamily2._map = map;
+  if (options?.label)
+    atomFamily2.label = options.label;
+  return atomFamily2;
+};
+// src/lib/createStoreData.ts
+var generateId = () => (Math.random() + 1).toString(36).substring(7);
+var createStoreData = (id = generateId()) => ({
+  id,
+  values: new WeakMap,
+  expiredValues: new WeakMap,
+  subscriptions: new WeakMap,
+  subscriptionsRequireEqualCheck: new WeakMap,
+  stateConsumers: new WeakMap,
+  stateDependencies: new WeakMap
+});
+
+// src/lib/resetAtom.ts
+var resetAtom = (atom2, data) => {
+  const res = initAtom(atom2, data);
+  if (!isPromiseLike(res)) {
+    propagateUpdatedAtoms([atom2], data);
   }
-  throw new Error("Invalid object passed to get");
+  return res;
 };
 
 // src/lib/unsubscribe.ts
-var unsubscribe = (state2, subscription, data, mountRes) => {
-  const subscribers = data.subscriptions.get(state2);
+var unsubscribe = (state, subscription, data, mount) => {
+  const subscribers = data.subscriptions.get(state);
   if (subscribers) {
     subscribers.delete(subscription);
-    if (data.subscriptionsRequireEqualCheck.get(state2)) {
+    if (data.subscriptionsRequireEqualCheck.get(state)) {
       let remove = true;
       for (const subscriber of subscribers) {
         if (subscriber.requireDeepEqualCheckBeforeCallback) {
@@ -347,33 +407,35 @@ var unsubscribe = (state2, subscription, data, mountRes) => {
         }
       }
       if (remove) {
-        data.subscriptionsRequireEqualCheck.delete(state2);
+        data.subscriptionsRequireEqualCheck.delete(state);
       }
     }
-    if (subscribers.size === 0) {
-      if (state2.onUnmount) {
-        state2.onUnmount(mountRes);
+    if (mount) {
+      if (subscribers.size === mount.mountSubscriptions.size) {
+        if (typeof mount.onUnmount === "function") {
+          mount.onUnmount();
+        }
       }
     }
   }
 };
 
 // src/lib/subscribe.ts
-var initSubscribers = (state2, data) => {
+var initSubscribers = (state, data) => {
   const set = new Set;
-  data.subscriptions.set(state2, set);
+  data.subscriptions.set(state, set);
   return set;
 };
-var subscribe = (state2, callback, requireDeepEqualCheckBeforeCallback, data) => {
-  const subscribers = data.subscriptions.get(state2) || initSubscribers(state2, data);
-  if (isSelector(state2) && !data.values.has(state2)) {
-    initSelector(state2, data);
+var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
+  const subscribers = data.subscriptions.get(state) || initSubscribers(state, data);
+  if (isSelector(state) && !data.values.has(state)) {
+    initSelector(state, data);
   }
   let subscription;
-  if (isFamily(state2)) {
+  if (isFamily(state)) {
     subscription = {
       callback,
-      state: state2,
+      state,
       requireDeepEqualCheckBeforeCallback
     };
   } else {
@@ -382,36 +444,44 @@ var subscribe = (state2, callback, requireDeepEqualCheckBeforeCallback, data) =>
       requireDeepEqualCheckBeforeCallback
     };
   }
-  let mountRes;
-  if (subscribers.size === 0 && state2.onMount) {
-    mountRes = state2.onMount((value) => {
-      setAtom(state2, value, data);
-    });
-  }
   subscribers.add(subscription);
-  if (requireDeepEqualCheckBeforeCallback && data.subscriptionsRequireEqualCheck.get(state2) !== true) {
-    data.subscriptionsRequireEqualCheck.set(state2, true);
+  let mount;
+  if (subscribers.size === 1 && state.onMount) {
+    const store = storeFromStoreData(data);
+    const mountSubscriptions = new Set;
+    const originalSub = store.sub;
+    store.sub = (state2, callback2) => {
+      mountSubscriptions.add(callback2);
+      return originalSub(state2, callback2);
+    };
+    mount = {
+      onUnmount: state.onMount(store, state),
+      mountSubscriptions
+    };
+  }
+  if (requireDeepEqualCheckBeforeCallback && data.subscriptionsRequireEqualCheck.get(state) !== true) {
+    data.subscriptionsRequireEqualCheck.set(state, true);
   }
-  return () => unsubscribe(state2, subscription, data, mountRes);
+  return () => unsubscribe(state, subscription, data, mount);
 };
 
 // src/lib/setAtoms.ts
-import equal4 from "fast-deep-equal";
+import equal5 from "fast-deep-equal";
 var setAtoms = (pairs, data) => {
   const updatedAtoms = [];
-  for (let [atom3, value] of pairs) {
-    const currentValue = getState2(atom3, data);
-    if (!equal4(currentValue, value)) {
-      updatedAtoms.push(atom3);
-      data.values.set(atom3, value);
+  for (let [atom2, value] of pairs) {
+    const currentValue = getState(atom2, data);
+    if (!equal5(currentValue, value)) {
+      updatedAtoms.push(atom2);
+      data.values.set(atom2, value);
     }
   }
   propagateUpdatedAtoms(updatedAtoms, data);
 };
 
 // src/lib/transaction.ts
-var findDependencies = (state2, data, result = new Set) => {
-  const consumers = data.stateConsumers.get(state2);
+var findDependencies = (state, data, result = new Set) => {
+  const consumers = data.stateConsumers.get(state);
   if (consumers?.size) {
     for (const consumer of consumers) {
       if (!result.has(consumer)) {
@@ -422,41 +492,62 @@ var findDependencies = (state2, data, result = new Set) => {
   }
   return result;
 };
+var recursivlyResetTxnSelectorCache = (state, txnSubscribers, txnSelectorCache) => {
+  for (const dep of txnSubscribers.get(state)) {
+    txnSelectorCache.delete(dep);
+    if (txnSubscribers.get(dep)?.size) {
+      recursivlyResetTxnSelectorCache(dep, txnSubscribers, txnSelectorCache);
+    }
+  }
+};
 var transaction = (callback, data) => {
   let txnAtomMap = new Map;
   let txnSelectorCache = new Map;
+  let txnSubscribers = new Map;
   let dirtySelectors = new Set;
-  const txnGet = (state2) => {
-    if (isAtom(state2)) {
-      return txnAtomMap.has(state2) ? txnAtomMap.get(state2) : getState2(state2, data);
-    } else {
-      if (txnSelectorCache.has(state2)) {
-        return txnSelectorCache.get(state2);
-      } else if (dirtySelectors.has(state2)) {
-        const res = state2.get(txnGet);
-        txnSelectorCache.set(state2, res);
-        return res;
-      } else {
-        return getState2(state2, data);
+  const txnGet = (state) => {
+    if (isAtom(state)) {
+      return txnAtomMap.has(state) ? txnAtomMap.get(state) : getState(state, data);
+    } else if (isSelector(state)) {
+      if (txnSelectorCache.has(state)) {
+        return txnSelectorCache.get(state);
+      }
+      const deps = new Set;
+      const res = state.get((s) => {
+        deps.add(s);
+        return txnGet(s);
+      }, data.id);
+      for (const dep of deps) {
+        if (!txnSubscribers.has(dep)) {
+          txnSubscribers.set(dep, new Set);
+        }
+        txnSubscribers.get(dep).add(state);
       }
+      txnSelectorCache.set(state, res);
+      return res;
+    } else {
+      throw new Error("Unsupported state");
     }
   };
-  const txnSet = (atom3, value) => {
-    if (!isAtom(atom3))
+  const txnSet = (atom2, value) => {
+    if (!isAtom(atom2))
       throw new Error("Not an atom");
     if (typeof value === "function") {
-      const currentValue = txnGet(atom3);
+      const currentValue = txnGet(atom2);
       value = value(currentValue);
     }
-    for (const selector of findDependencies(atom3, data)) {
+    for (const selector of findDependencies(atom2, data)) {
       dirtySelectors.add(selector);
       txnSelectorCache.delete(selector);
     }
-    txnAtomMap.set(atom3, value);
+    if (txnSubscribers.get(atom2)?.size) {
+      recursivlyResetTxnSelectorCache(atom2, txnSubscribers, txnSelectorCache);
+    }
+    txnAtomMap.set(atom2, value);
   };
-  const txnReset = (atom3) => {
-    const value = getAtomInitValue(atom3, data);
-    txnAtomMap.set(atom3, value);
+  const txnReset = (atom2) => {
+    const value = getAtomInitValue(atom2, data);
+    txnAtomMap.set(atom2, value);
     return value;
   };
   const commit = () => {
@@ -468,45 +559,16 @@ var transaction = (callback, data) => {
   return result;
 };
 
-// src/lib/resetAtom.ts
-var resetAtom = (atom3, data) => {
-  const res = initAtom(atom3, data);
-  if (!isPromiseLike(res)) {
-    propagateUpdatedAtoms([atom3], data);
-  }
-  return res;
-};
-
-// src/createStore.ts
-var generateId = () => (Math.random() + 1).toString(36).substring(7);
-var createStore = (id) => {
-  const data = {
-    id: id ?? generateId(),
-    values: new WeakMap,
-    expiredValues: new WeakMap,
-    subscriptions: new WeakMap,
-    subscriptionsRequireEqualCheck: new WeakMap,
-    stateConsumers: new WeakMap,
-    stateDependencies: new WeakMap
+// src/lib/storeFromStoreData.ts
+var storeFromStoreData = (data) => {
+  const get = (state) => getState(state, data);
+  const set = (state, value) => {
+    if (!isAtom(state))
+      throw new Error("Invalid state object");
+    return setAtom(state, value, data);
   };
-  const get = (state2) => getState2(state2, data);
-  const set = (state2, value) => {
-    if (isAtom(state2)) {
-      return setAtom(state2, value, data);
-    } else {
-      if (isSelector(state2)) {
-        if (state2.set) {
-          txn((set2, get2) => state2.set({ get: get2, set: set2 }, value));
-          return;
-        } else {
-          throw new Error("set on selector is not supported");
-        }
-      }
-      throw new Error("Invalid state object passed to set");
-    }
-  };
-  const reset = (atom3) => resetAtom(atom3, data);
-  const sub = (state2, callback, deepEqualCheckBeforeCallback = true) => subscribe(state2, callback, deepEqualCheckBeforeCallback, data);
+  const reset = (atom2) => resetAtom(atom2, data);
+  const sub = (state, callback, deepEqualCheckBeforeCallback = true) => subscribe(state, callback, deepEqualCheckBeforeCallback, data);
   const txn = (callback) => transaction(callback, data);
   return {
     get,
@@ -517,6 +579,29 @@ var createStore = (id) => {
     data
   };
 };
+
+// src/createStore.ts
+var createStore = (id) => {
+  const data = createStoreData(id);
+  return storeFromStoreData(data);
+};
+// src/createStoreWithSelectorSet.ts
+var setSelector = (selector, values, store) => {
+  return selector.set(store.set, store.get, store.reset, ...values);
+};
+var createStoreWithSelectorSet = (id) => {
+  const data = createStoreData(id);
+  const store = storeFromStoreData(data);
+  store.set = (state, value, ...rest) => {
+    if (isAtom(state))
+      return setAtom(state, value, data);
+    if (isSelector(state))
+      return setSelector(state, [value, ...rest], store);
+    throw new Error("Invalid state object");
+  };
+  store.kind = "storeWithSelectorSet";
+  return store;
+};
 // src/getDefaultStore.ts
 if (!globalThis._valdresStore) {
   globalThis._valdresStore = createStore("default");
@@ -524,25 +609,29 @@ if (!globalThis._valdresStore) {
 var getDefaultStore = () => globalThis._valdresStore;
 var resetDefaultStore = () => globalThis._valdresStore = createStore();
 // src/selector.ts
-var selector = (get, debugLabel) => ({
-  get,
-  debugLabel
-});
+var selector = (get, options) => {
+  if (!options)
+    return { get };
+  return { ...options, get };
+};
 // src/selectorFamily.ts
-var selectorFamily = (get, debugLabel) => {
+var createOptions2 = (options, key) => {
+  if (options.label) {
+    return {
+      ...options,
+      label: options?.label + "_" + key
+    };
+  } else {
+    return options;
+  }
+};
+var selectorFamily = (get, options) => {
   const map = new Map;
   const selectorFamily2 = (key) => {
-    let keyStringified;
-    try {
-      keyStringified = stableStringify(key);
-    } catch (e) {
-      console.log(`errro`, { key, debugLabel, e });
-      throw e;
-    }
+    const keyStringified = stableStringify(key);
     if (map.has(keyStringified))
       return map.get(keyStringified);
-    const selectorDebugLabel = debugLabel ? debugLabel + "_" + keyStringified : undefined;
-    const newSelector = selector((selectorArgs) => get(key)(selectorArgs), selectorDebugLabel);
+    const newSelector = selector((selectorArgs) => get(key)(selectorArgs), options ? createOptions2(options, keyStringified) : undefined);
     newSelector.family = selectorFamily2;
     map.set(keyStringified, newSelector);
     return newSelector;
@@ -559,6 +648,7 @@ export {
   isFamily,
   isAtom,
   getDefaultStore,
+  createStoreWithSelectorSet,
   createStore,
   atomFamily,
   atom

package/dist/src/atom.d.ts

@@ -1,9 +1,4 @@
 import type { Atom } from "./types/Atom";
-type AtomOptions<M = any> = {
-    label?: string;
-    onInit?: () => void;
-    onMount?: () => M;
-    onUnmount?: (mountRes?: M) => void;
-};
-export declare const atom: <Value, FamilyKey = undefined, MountReturnValue = undefined>(defaultValue?: Value | (() => Value | Promise<Value>), options?: AtomOptions<MountReturnValue>) => Atom<Value, FamilyKey>;
-export {};
+import type { AtomOptions } from "./types/AtomOptions";
+export declare const globalAtom: <Value = any, FamilyKey = undefined>(defaultValue: Value | (() => Value | Promise<Value>), options: AtomOptions<Value>) => Atom<Value>;
+export declare const atom: <Value = any, FamilyKey = undefined>(defaultValue?: Value | (() => Value | Promise<Value>), options?: AtomOptions<Value>) => Atom<Value, FamilyKey>;

package/dist/src/atomFamily.d.ts

@@ -1,2 +1,5 @@
 import type { AtomFamily } from "./types/AtomFamily";
-export declare const atomFamily: <Value, Key>(defaultValue?: Value | ((arg: Key) => Value | Promise<Value>), debugLabel?: string) => AtomFamily<Value, Key>;
+import type { AtomOptions } from "./types/AtomOptions";
+type DefaultValueCallback<Key, Value> = (arg: Key) => Value | Promise<Value>;
+export declare const atomFamily: <Value = unknown, Key = unknown>(defaultValue?: Value | DefaultValueCallback<Key, Value>, options?: AtomOptions<Value>) => AtomFamily<Value, Key>;
+export {};

package/dist/src/createStoreWithSelectorSet.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from "./types/Store";
+export declare const createStoreWithSelectorSet: (id?: string) => Store;

package/dist/src/lib/createStoreData.d.ts

@@ -0,0 +1,2 @@
+import type { StoreData } from "../types/StoreData";
+export declare const createStoreData: (id?: string) => StoreData;

package/dist/src/lib/getState.d.ts

@@ -1,3 +1,7 @@
-import type { State } from "../types/State";
 import type { StoreData } from "../types/StoreData";
-export declare const getState: <V>(state: State<V>, data: StoreData) => V | Promise<V>;
+import type { Atom } from "../types/Atom";
+import type { AtomFamily } from "../types/AtomFamily";
+import type { Selector } from "../types/Selector";
+export declare function getState<V, K>(atom: Atom<V>, data: StoreData): V;
+export declare function getState<V, K>(selector: Selector<V>, data: StoreData): V;
+export declare function getState<V, K>(family: AtomFamily<V, K>, data: StoreData): K[];

package/dist/src/lib/initSelector.d.ts

@@ -1,4 +1,4 @@
 import type { StoreData } from "../types/StoreData";
 import type { Selector } from "../types/Selector";
 export declare const reEvaluateSelector: <V>(selector: Selector<V>, data: StoreData) => void;
-export declare const initSelector: <V>(selector: Selector<V>, data: StoreData) => V;
+export declare const initSelector: <V>(selector: Selector<V>, data: StoreData) => V | Promise<V>;

package/dist/src/lib/setAtom.d.ts

@@ -1,3 +1,3 @@
 import type { Atom } from "../types/Atom";
 import type { StoreData } from "../types/StoreData";
-export declare const setAtom: <V>(atom: Atom<V>, newValue: V, data: StoreData) => void;
+export declare const setAtom: <Value = any>(atom: Atom<Value>, newValue: Value, data: StoreData, skipOnSet?: boolean) => void;

package/dist/src/lib/storeFromStoreData.d.ts

@@ -0,0 +1,3 @@
+import type { Store } from "../types/Store";
+import type { StoreData } from "../types/StoreData";
+export declare const storeFromStoreData: (data: StoreData) => Store;

package/dist/src/lib/subscribe.d.ts

@@ -1,3 +1,4 @@
+import type { Family } from "../types/Family";
 import type { State } from "../types/State";
 import type { StoreData } from "../types/StoreData";
-export declare const subscribe: <V>(state: State<V>, callback: any, data: StoreData) => () => void;
+export declare const subscribe: <V>(state: State<V> | Family<V>, callback: any, requireDeepEqualCheckBeforeCallback: boolean, data: StoreData) => () => void;

package/dist/src/lib/transaction.d.ts

@@ -1,8 +1,9 @@
 import type { State } from "../types/State";
 import type { StoreData } from "../types/StoreData";
+import type { Atom } from "../types/Atom";
 type GetValdresValue = <V>(state: State<V>) => V;
 type SetValdresValue = <V>(state: State<V>, value: V) => void;
-type ResetValdresValue = <V>(state: State<V>) => V;
+type ResetValdresValue = <V>(atom: Atom<V>) => V;
 type TransactionInterface = (set: SetValdresValue, get: GetValdresValue, reset: ResetValdresValue, commit: () => void) => void;
 export declare const transaction: (callback: TransactionInterface, data: StoreData) => void;
 export {};

package/dist/src/lib/unsubscribe.d.ts

@@ -1,3 +1,5 @@
+import type { Family } from "../types/Family";
 import type { State } from "../types/State";
 import type { StoreData } from "../types/StoreData";
-export declare const unsubscribe: <V>(state: State<V>, subscription: any, store: StoreData, mountRes?: any) => void;
+import type { Subscription } from "../types/Subscription";
+export declare const unsubscribe: <V>(state: State<V> | Family<V>, subscription: Subscription, data: StoreData, mount?: any) => void;

package/dist/src/lib/updateSelectorSubscribers.d.ts

@@ -1,3 +1,3 @@
 import type { Selector } from "../types/Selector";
 import type { StoreData } from "../types/StoreData";
-export declare const updateSelectorSubscribers: (selector: Selector, data: StoreData, oldValue: any) => void;
+export declare const updateSelectorSubscribers: (selector: Selector, data: StoreData) => void;

package/dist/src/selector.d.ts

@@ -1,5 +1,4 @@
 import type { GetValue } from "./types/GetValue";
-export declare const selector: (get: GetValue, debugLabel?: string) => {
-    get: GetValue;
-    debugLabel: string;
-};
+import type { Selector } from "./types/Selector";
+import type { SelectorOptions } from "./types/SelectorOptions";
+export declare const selector: <Value, FamilyKey = undefined>(get: (get: GetValue, storeId: string) => Value, options?: SelectorOptions) => Selector<Value, FamilyKey>;

package/dist/src/selectorFamily.d.ts

@@ -1,4 +1,3 @@
-export declare const selectorFamily: <V, A>(get: any, debugLabel?: string) => {
-    (key: A): any;
-    _map: Map<any, any>;
-};
+import type { SelectorFamily } from "./types/SelectorFamily";
+import type { SelectorOptions } from "./types/SelectorOptions";
+export declare const selectorFamily: <Value, Key>(get: any, options?: SelectorOptions) => SelectorFamily<Value, Key>;

package/dist/src/types/Atom.d.ts

@@ -1,7 +1,12 @@
 import type { AtomFamily } from "./AtomFamily";
-export type Atom<Value = unknown, FamilyKey = undefined> = {
+import type { AtomOnInit } from "./AtomOnInit";
+import type { AtomOnSet } from "./AtomOnSet";
+export type Atom<Value = any, FamilyKey = undefined> = {
     defaultValue?: Value | (() => Value | Promise<Value>);
     label?: string;
     family?: AtomFamily<Value, FamilyKey>;
     familyKey?: FamilyKey;
+    onInit?: AtomOnInit<Value>;
+    onSet?: AtomOnSet<Value>;
+    onMount?: () => void | (() => void);
 };

package/dist/src/types/AtomFamily.d.ts

@@ -1,5 +1,6 @@
 import type { Atom } from "./Atom";
 export type AtomFamily<Value, Key> = {
-    (key: Key, defaultOverride?: any): Atom<Value, Key>;
+    (key: Key, defaultOverride?: any): Atom<Value>;
+    label?: string;
     _map: Map<Key, Atom<Value, Key>>;
 };

package/dist/src/types/AtomOnInit.d.ts

@@ -0,0 +1,2 @@
+import type { StoreData } from "./StoreData";
+export type AtomOnInit<Value = unknown> = (setSelf: (value: Value) => void, store: StoreData) => void;

package/dist/src/types/AtomOnSet.d.ts

@@ -0,0 +1,2 @@
+import type { StoreData } from "./StoreData";
+export type AtomOnSet<Value = unknown> = (value: Value, store: StoreData) => void;

package/dist/src/types/AtomOptions.d.ts

@@ -0,0 +1,9 @@
+import type { AtomOnSet } from "./AtomOnSet";
+import type { StoreData } from "./StoreData";
+export type AtomOptions<Value = any> = {
+    global?: boolean;
+    label?: string;
+    onInit?: (setSelf: (value: Value) => void, store: StoreData) => void;
+    onSet?: AtomOnSet<Value>;
+    onMount?: () => () => void;
+};

package/dist/src/types/Family.d.ts

@@ -1,3 +1,3 @@
 import type { SelectorFamily } from "./SelectorFamily";
 import type { AtomFamily } from "./AtomFamily";
-export type Family<V, K> = AtomFamily<V, K> | SelectorFamily<V, K>;
+export type Family<V, K = any> = AtomFamily<V, K> | SelectorFamily<V, K>;

package/dist/src/types/GetValue.d.ts

@@ -1,2 +1,8 @@
-import type { State } from "./State";
-export type GetValue = <V>(state: State<V>) => V;
+import type { Atom } from "./Atom";
+import type { AtomFamily } from "./AtomFamily";
+import type { Selector } from "./Selector";
+export type GetValue = {
+    <V, K>(atom: Atom<V>): V;
+    <V, K>(selector: Selector<V>): V;
+    <V, K>(family: AtomFamily<V, K>): K[];
+};

package/dist/src/types/ResetAtom.d.ts

@@ -1,2 +1,2 @@
 import type { Atom } from "./Atom";
-export type ResetAtom = <V>(state: Atom<V>) => V;
+export type ResetAtom = <V>(state: Atom<V>) => V | Promise<V>;

package/dist/src/types/Selector.d.ts

@@ -1,4 +1,9 @@
-export type Selector<V = any> = {
-    get: () => {};
-    debugLabel?: string;
+import type { GetValue } from "./GetValue";
+import type { SelectorFamily } from "./SelectorFamily";
+export type Selector<Value = unknown, FamilyKey = undefined> = {
+    get: (get: GetValue, storeId: string) => Value;
+    label?: string;
+    family?: SelectorFamily<Value, FamilyKey>;
+    familyKey?: FamilyKey;
+    onMount?: () => void | (() => void);
 };

package/dist/src/types/SelectorFamily.d.ts

@@ -1 +1,5 @@
-export type SelectorFamily<A, V> = {};
+import type { Selector } from "./Selector";
+export type SelectorFamily<Value, Key> = {
+    (key: Key, defaultOverride?: any): Selector<Value>;
+    _map: Map<Key, Selector<Value, Key>>;
+};

package/dist/src/types/SelectorOptions.d.ts

@@ -0,0 +1,3 @@
+export type SelectorOptions = {
+    label?: string;
+};

package/dist/src/types/SetAtom.d.ts

@@ -1,2 +1,3 @@
 import type { Atom } from "./Atom";
-export type SetAtom = <V>(atom: Atom<V>, value: V) => void;
+import type { SetAtomValue } from "./SetAtomValue";
+export type SetAtom<V = any> = (atom: Atom<V>, value: SetAtomValue<V>) => void;

package/dist/src/types/SetAtomValue.d.ts

@@ -0,0 +1 @@
+export type SetAtomValue<V> = V | ((current: V) => V);

package/dist/src/types/StoreData.d.ts

@@ -1,7 +1,9 @@
 export type StoreData = {
     id: string;
     values: WeakMap<WeakKey, any>;
-    subscriptions: WeakMap<WeakKey, any>;
+    expiredValues: WeakMap<WeakKey, any>;
+    subscriptions: WeakMap<WeakKey, Set<any>>;
+    subscriptionsRequireEqualCheck: WeakMap<WeakKey, boolean>;
     stateConsumers: WeakMap<WeakKey, any>;
     stateDependencies: WeakMap<WeakKey, any>;
 };

package/dist/src/types/SubscribeFn.d.ts

@@ -1,2 +1,2 @@
 import type { State } from "./State";
-export type SubscribeFn = <V>(state: State<V>, callback: () => void) => () => void;
+export type SubscribeFn = <V>(state: State<V>, callback: () => void, requireDeepEqualCheckBeforeCallback?: boolean) => () => void;

package/dist/src/types/Subscription.d.ts

@@ -0,0 +1 @@
+export type Subscription = {};

package/dist/src/utils/isAtom.d.ts

@@ -1,2 +1,2 @@
-import type { State } from "../types/State";
-export declare const isAtom: (state: State) => boolean;
+import type { Atom } from "../types/Atom";
+export declare const isAtom: (state: any) => state is Atom;

package/dist/src/utils/isPromiseLike.d.ts

@@ -1 +1 @@
-export declare const isPromiseLike: (object: any) => boolean;
+export declare const isPromiseLike: <T>(object: any) => object is Promise<T>;

package/dist/src/utils/isSelector.d.ts

@@ -1,3 +1,2 @@
 import type { Selector } from "../types/Selector";
-import type { State } from "../types/State";
-export declare const isSelector: (state: State) => state is Selector;
+export declare const isSelector: (state: any) => state is Selector;

package/package.json

@@ -1,10 +1,15 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.0",
+    "version": "0.2.0-alpha.11",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
     },
+    "homepage": "https://valdres.dev",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/eigilsagafos/valdres.git"
+    },
     "type": "module",
     "exports": {
         "types": "./dist/index.d.ts",
@@ -14,8 +19,8 @@
         "dist"
     ],
     "scripts": {
-        "build": "NODE_ENV=production bun scripts/build.ts",
-        "build:types": "tsc index.ts --declaration --emitDeclarationOnly --outDir dist",
+        "build": "rm -rf dist && NODE_ENV=production bun scripts/build.ts",
+        "build:types": "tsc",
         "test": "bun test"
     },
     "dependencies": {
@@ -23,15 +28,16 @@
     },
     "devDependencies": {
         "@testing-library/react-hooks": "8.0.1",
+        "jotai": "2.10.0",
         "mitata": "0.1.14",
         "react": ">=18",
         "react-dom": ">=18",
         "recoil": "0.7.7",
-        "typescript": "5.5.4"
+        "typescript": "5.6.2"
     },
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "ec1d460976eb7aa8b97c5def2c39bc406670d74c"
+    "gitHead": "081fe9031067f895bb2f79dec2648a88ac891cc9"
 }