valdres 0.2.0-alpha.3 → 0.2.0-alpha.30

package/dist/index.js

@@ -1,108 +1,31 @@
-// src/atom.ts
-var atom = (defaultValue, options) => {
-  if (!options)
-    return { defaultValue };
-  return {
-    defaultValue,
-    ...options
-  };
-};
+// src/utils/isAtom.ts
+var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+
+// src/utils/isFamilyState.ts
+var isFamilyState = (state) => state && Object.hasOwn(state, "family");
+
+// src/utils/isFamilyAtom.ts
+var isFamilyAtom = (state) => isFamilyState(state) && isAtom(state);
+
 // src/utils/isPromiseLike.ts
 var isPromiseLike = (object) => {
   return object && object.then && typeof object.then === "function";
 };
 
-// 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/isSelector.ts
+var isSelector = (state) => state && Object.hasOwn(state, "get");
 
-// src/atomFamily.ts
-var atomFamily = (defaultValue, debugLabel) => {
-  const map = new Map;
-  const atomFamily2 = (key, defaultOverride) => {
-    const keyStringified = stableStringify(key);
-    if (map.has(keyStringified)) {
-      return map.get(keyStringified);
-    }
-    const atomDebugLabel = debugLabel && debugLabel + "_" + keyStringified;
-    const newAtom = atom(typeof defaultValue === "function" ? () => defaultValue(key) : defaultValue, {
-      label: atomDebugLabel
-    });
-    newAtom.family = atomFamily2;
-    newAtom.familyKey = Object.freeze(key);
-    map.set(keyStringified, newAtom);
-    return newAtom;
-  };
-  atomFamily2._map = map;
-  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/getState.ts
+import equal2 from "fast-deep-equal/es6";
 
-// src/utils/isAtom.ts
-var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+// src/utils/isAtomFamily.ts
+var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
 
-// src/utils/isSelector.ts
-var isSelector = (state) => Object.hasOwn(state, "get");
+// src/utils/isSelectorFamily.ts
+var isSelectorFamily = (state) => state && Object.hasOwn(state, "__valdresSelectorFamilyMap");
+
+// src/lib/initSelector.ts
+import equal from "fast-deep-equal/es6";
 
 // src/lib/updateStateSubscribers.ts
 var updateStateSubscribers = (state, data) => {
@@ -112,7 +35,7 @@ var updateStateSubscribers = (state, data) => {
       subscribtion.callback();
     }
   }
-  if (state.family) {
+  if (isFamilyState(state)) {
     const familySubscriptions = data.subscriptions.get(state.family);
     if (familySubscriptions?.size) {
       for (const subscribtion of familySubscriptions) {
@@ -122,11 +45,7 @@ var updateStateSubscribers = (state, data) => {
   }
 };
 
-// src/lib/updateSelectorSubscribers.ts
-import equal2 from "fast-deep-equal";
-
 // src/lib/initSelector.ts
-import equal from "fast-deep-equal";
 class SuspendAndWaitForResolveError extends Error {
   promise;
   constructor(promise) {
@@ -143,17 +62,16 @@ var getOrInitConsumersSet = (state, data) => {
   return newSet;
 };
 var evaluateSelector = (selector, data) => {
-  const currentDependencies = data.stateDependencies.get(selector) ?? new Set;
   const updatedDependencies = new Set;
   let result;
   try {
     result = selector.get((state) => {
-      const value = getState2(state, data);
+      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;
@@ -161,6 +79,7 @@ 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 state of added) {
@@ -182,7 +101,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 {
@@ -203,17 +122,53 @@ var initSelector = (selector, data) => {
   return value;
 };
 
+// src/lib/getState.ts
+function getState(state, data) {
+  if (data.values.has(state))
+    return data.values.get(state);
+  if (isAtom(state)) {
+    if ("parent" in data)
+      return getState(state, data.parent);
+    return initAtom(state, data);
+  }
+  if (isSelector(state))
+    return initSelector(state, data);
+  if (isAtomFamily(state)) {
+    if ("parent" in data) {
+      const closestData = findClosestStoreWithAtomInitialized(state.__keysAtom, data);
+      return getState(state.__keysSelector, closestData);
+    }
+    return getState(state.__keysSelector, data);
+  }
+  if (isSelectorFamily(state)) {
+    const array = Array.from(state.__valdresSelectorFamilyMap.keys());
+    if (equal2(array, state._keyArray))
+      return state._keyArray;
+    state._keyArray = array;
+    return array;
+  }
+  throw new Error("Invalid object passed to get");
+}
+var findClosestStoreWithAtomInitialized = (atom, data) => {
+  if ("parent" in data === false)
+    return data;
+  if (data.values.has(atom))
+    return data;
+  return findClosestStoreWithAtomInitialized(atom, data.parent);
+};
+
 // src/lib/updateSelectorSubscribers.ts
+import equal3 from "fast-deep-equal/es6";
 var updateSelectorSubscribers = (selector, data) => {
   const subscribtions = data.subscriptions.get(selector);
   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) {
     }
@@ -246,13 +201,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 (isFamilyAtom(atom)) {
+      const consumersFamily = data.stateConsumers.get(atom.family);
       if (consumersFamily?.size) {
         recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
       }
@@ -261,32 +216,34 @@ 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);
+import equal4 from "fast-deep-equal/es6";
+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) {
+var getAtomInitValue = (atom, data) => {
+  if (atom.defaultValue === undefined) {
     let promiseResolve;
     const promise = new Promise((resolve) => {
       promiseResolve = resolve;
@@ -294,61 +251,284 @@ var getAtomInitValue = (atom3, data) => {
     promise.__isEmptyAtomPromise__ = true;
     promise.__resolveEmptyAtomPromise__ = promiseResolve;
     return promise;
-  } else if (typeof atom3.defaultValue === "function") {
-    const value = atom3.defaultValue();
+  } else if (typeof atom.defaultValue === "function") {
+    const value = atom.defaultValue();
     if (isPromiseLike(value)) {
       value.then((resolvedValue) => {
-        data.values.set(atom3, resolvedValue);
-        propagateUpdatedAtoms([atom3], data);
+        data.values.set(atom, resolvedValue);
+        propagateUpdatedAtoms([atom], data);
       });
     }
     return value;
+  } else if (isSelector(atom.defaultValue)) {
+    return getState(atom.defaultValue, data);
   } else {
-    return atom3.defaultValue;
+    return atom.defaultValue;
   }
 };
-var initAtom = (atom3, data) => {
-  const value = getAtomInitValue(atom3, data);
-  data.values.set(atom3, value);
-  if (atom3.onInit)
-    atom3.onInit((newVal) => {
-      setAtom(atom3, newVal, data);
-    });
+var initAtom = (atom, data) => {
+  let value = getAtomInitValue(atom, data);
+  data.values.set(atom, value);
+  if (isFamilyAtom(atom)) {
+    const currentKeySet = getState(atom.family.__keysAtom, data);
+    if (!currentKeySet.has(atom.familyKey)) {
+      const newSet = new Set(currentKeySet);
+      newSet.add(atom.familyKey);
+      setAtom(atom.family.__keysAtom, newSet, data);
+    }
+  }
+  if (atom.onInit)
+    atom.onInit((newVal) => {
+      value = newVal;
+      setAtom(atom, newVal, data, true);
+    }, data);
   return value;
 };
 
-// src/utils/isFamily.ts
-var isFamily = (state) => Object.hasOwn(state, "_map");
+// src/lib/globalAtom.ts
+var getFirstItemInSet = (set) => {
+  for (let item of set) {
+    return item;
+  }
+  throw new Error("Non Empty Set");
+};
+var globalAtom = (defaultValue, options) => {
+  const stores = new Set;
+  let value = defaultValue;
+  let initialized = false;
+  let onReset;
+  if (options.onSet)
+    throw new Error("onSet on globalAtom is currently not supported");
+  const onInit = (setSelf2, data) => {
+    if (!initialized) {
+      if (value === defaultValue) {
+        value = getAtomInitValue(atom, data);
+      }
+      setSelf2(value);
+      initialized = true;
+      if (options.onInit) {
+        onReset = options.onInit((newVal) => {
+          setSelf2(newVal);
+          value = newVal;
+        }, data);
+      }
+    } else {
+      setSelf2(value);
+    }
+    stores.add(data);
+  };
+  const onSet = (newValue, currentStore) => {
+    value = newValue;
+    if (stores.size > 1) {
+      for (const store of stores) {
+        if (store.id !== currentStore.id) {
+          setAtom(atom, value, store, true);
+        }
+      }
+    }
+  };
+  const setSelf = (newValue) => {
+    value = newValue;
+    if (stores.size > 0) {
+      getFirstItemInSet(stores);
+      const store = getFirstItemInSet(stores);
+      setAtom(atom, newValue, store);
+    }
+  };
+  const resetSelf = () => {
+    value = defaultValue;
+    initialized = false;
+    for (const store of stores) {
+      if (store.stateDependencies.has(atom)) {
+        throw new Error("TODO: Reset support for stateDependencies");
+      }
+      store.values.delete(atom);
+      store.expiredValues.delete(atom);
+      propagateUpdatedAtoms([atom], store);
+      stores.delete(store);
+      onReset?.();
+    }
+  };
+  const atom = {
+    ...options,
+    defaultValue,
+    label: options?.label,
+    onInit,
+    onSet,
+    setSelf,
+    resetSelf,
+    get currentValue() {
+      return value;
+    }
+  };
+  return atom;
+};
 
-// src/lib/getState.ts
-var getState2 = (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 res = [];
-    for (const atom3 of state._map.values()) {
-      res.push([atom3.familyKey, getState2(atom3, data)]);
+// src/atom.ts
+function atom(defaultValue, options) {
+  if (!options)
+    return { defaultValue };
+  if (options.global) {
+    return globalAtom(defaultValue, options);
+  }
+  return {
+    defaultValue,
+    ...options
+  };
+}
+// src/lib/atomFamilyAtom.ts
+function atomFamilyAtom(defaultValue, options) {
+  if (options.global) {
+    return globalAtom(defaultValue, options);
+  }
+  return {
+    ...options,
+    defaultValue
+  };
+}
+
+// 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 res;
+    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/selector.ts
+var selector = (get, options) => {
+  if (!options)
+    return { get };
+  return { ...options, get };
+};
+
+// src/atomFamily.ts
+var createOptions = (options = {}, family, familyKey, keyStringified) => {
+  if (options.label) {
+    return {
+      ...options,
+      label: options?.label + "_" + keyStringified,
+      family,
+      familyKey
+    };
+  } else {
+    return { ...options, family, familyKey };
   }
-  throw new Error("Invalid object passed to get");
 };
+var handleDefaultValue = (defaultValue, key) => {
+  if (isSelectorFamily(defaultValue))
+    return defaultValue(key);
+  if (typeof defaultValue === "function")
+    return () => defaultValue(key);
+  return defaultValue;
+};
+function atomFamily(defaultValue, options) {
+  const map = new Map;
+  const atomFamily2 = (key) => {
+    const keyStringified = stableStringify(key);
+    if (map.has(keyStringified)) {
+      return map.get(keyStringified);
+    }
+    const familyAtom = atomFamilyAtom(handleDefaultValue(defaultValue, key), createOptions(options, atomFamily2, Object.freeze(key), keyStringified));
+    map.set(keyStringified, familyAtom);
+    return familyAtom;
+  };
+  atomFamily2.__valdresAtomFamilyMap = map;
+  atomFamily2.release = (key) => map.delete(key);
+  const keysAtom = atom(new Set);
+  atomFamily2.__keysAtom = keysAtom;
+  atomFamily2.__keysSelector = selector((get) => Array.from(get(keysAtom)));
+  if (options?.label)
+    atomFamily2.label = options.label;
+  return atomFamily2;
+}
+// src/lib/createStoreData.ts
+var generateId = () => (Math.random() + 1).toString(36).substring(7);
+var generateStoreData = (id = generateId()) => {
+  return {
+    id,
+    values: new WeakMap,
+    expiredValues: new WeakMap,
+    subscriptions: new WeakMap,
+    subscriptionsRequireEqualCheck: new WeakMap,
+    stateConsumers: new WeakMap,
+    stateDependencies: new WeakMap,
+    scopes: {}
+  };
+};
+function createStoreData(id, parent) {
+  if (parent) {
+    return {
+      ...generateStoreData(id),
+      parent,
+      scopeConsumers: parent ? new Set : undefined
+    };
+  } else {
+    return generateStoreData(id);
+  }
+}
 
 // src/lib/resetAtom.ts
-var resetAtom = (atom3, data) => {
-  const res = initAtom(atom3, data);
-  if (!isPromiseLike(res)) {
-    propagateUpdatedAtoms([atom3], data);
+var resetAtom = (atom2, data) => {
+  let value = getAtomInitValue(atom2, data);
+  data.values.set(atom2, value);
+  if (!isPromiseLike(value)) {
+    propagateUpdatedAtoms([atom2], data);
   }
-  return res;
+  return value;
 };
 
+// src/utils/isFamily.ts
+var isFamily = (state) => isAtomFamily(state) || isSelectorFamily(state);
+
 // src/lib/unsubscribe.ts
-var unsubscribe = (state, subscription, data, mount) => {
+var unsubscribe = (state, subscription, data, mount, maxAgeCleanup) => {
   const subscribers = data.subscriptions.get(state);
   if (subscribers) {
     subscribers.delete(subscription);
@@ -364,10 +544,15 @@ var unsubscribe = (state, subscription, data, mount) => {
         data.subscriptionsRequireEqualCheck.delete(state);
       }
     }
+    if (subscribers.size === 0) {
+      if (maxAgeCleanup)
+        maxAgeCleanup();
+      data.subscriptions.delete(state);
+    }
     if (mount) {
       if (subscribers.size === mount.mountSubscriptions.size) {
-        if (state.onUnmount) {
-          state.onUnmount(mount.onMountRes);
+        if (typeof mount.onUnmount === "function") {
+          mount.onUnmount();
         }
       }
     }
@@ -381,6 +566,14 @@ var initSubscribers = (state, data) => {
   return set;
 };
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
+  if ("parent" in data && !data.values.has(state) && isAtom(state)) {
+    const parentUnsubscribe = subscribe(state, callback, requireDeepEqualCheckBeforeCallback, data.parent);
+    let originalCallback = callback;
+    callback = () => {
+      parentUnsubscribe();
+      originalCallback();
+    };
+  }
   const subscribers = data.subscriptions.get(state) || initSubscribers(state, data);
   if (isSelector(state) && !data.values.has(state)) {
     initSelector(state, data);
@@ -400,34 +593,63 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
   }
   subscribers.add(subscription);
   let mount;
-  if (subscribers.size === 1 && state.onMount) {
-    const store = storeFromStoreData2(data);
-    const mountSubscriptions = new Set;
-    const originalSub = store.sub;
-    store.sub = (state2, callback2) => {
-      mountSubscriptions.add(callback2);
-      return originalSub(state2, callback2);
-    };
-    mount = {
-      onMountRes: state.onMount(store, state),
-      mountSubscriptions
-    };
+  let maxAgeCleanup;
+  if (subscribers.size === 1) {
+    if (isAtom(state) && state.maxAge) {
+      let timeout;
+      const interval = setInterval(() => {
+        let value = getAtomInitValue(state, data);
+        if (isPromiseLike(value)) {
+          if (state.staleWhileRevalidate) {
+            const oldValue = data.values.get(state);
+            timeout = setTimeout(() => {
+              const nowValue = data.values.get(state);
+              console.log("todo", oldValue);
+            }, state.staleWhileRevalidate);
+            value.then((res) => clearTimeout(timeout));
+          }
+        } else {
+          data.values.set(state, value);
+          propagateUpdatedAtoms([state], data);
+        }
+      }, state.maxAge);
+      maxAgeCleanup = () => {
+        clearInterval(interval);
+        if (timeout)
+          clearTimeout(timeout);
+      };
+    }
+    if (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(state, subscription, data, mount);
+  return () => unsubscribe(state, subscription, data, mount, maxAgeCleanup);
 };
 
 // src/lib/setAtoms.ts
-import equal4 from "fast-deep-equal";
+import equal5 from "fast-deep-equal/es6";
 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);
+      if (atom2.onSet)
+        atom2.onSet(value, data);
+      data.values.set(atom2, value);
     }
   }
   propagateUpdatedAtoms(updatedAtoms, data);
@@ -446,41 +668,62 @@ var findDependencies = (state, 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 = (state) => {
     if (isAtom(state)) {
-      return txnAtomMap.has(state) ? txnAtomMap.get(state) : getState2(state, data);
-    } else {
+      return txnAtomMap.has(state) ? txnAtomMap.get(state) : getState(state, data);
+    } else if (isSelector(state)) {
       if (txnSelectorCache.has(state)) {
         return txnSelectorCache.get(state);
-      } else if (dirtySelectors.has(state)) {
-        const res = state.get(txnGet);
-        txnSelectorCache.set(state, res);
-        return res;
-      } else {
-        return getState2(state, data);
       }
+      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)) {
-      dirtySelectors.add(selector);
-      txnSelectorCache.delete(selector);
+    for (const selector2 of findDependencies(atom2, data)) {
+      dirtySelectors.add(selector2);
+      txnSelectorCache.delete(selector2);
+    }
+    if (txnSubscribers.get(atom2)?.size) {
+      recursivlyResetTxnSelectorCache(atom2, txnSubscribers, txnSelectorCache);
     }
-    txnAtomMap.set(atom3, value);
+    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 = () => {
@@ -493,84 +736,132 @@ var transaction = (callback, data) => {
 };
 
 // src/lib/storeFromStoreData.ts
-var storeFromStoreData2 = (data) => {
-  const get = (state) => getState2(state, data);
+var SelectorProvidedToSetError = `Invalid state object passed to set().
+You provided a \`selector\`.
+Only \`atom\` cam be set.
+`;
+var InvalidStateSetError = `Invalid state object passed to set().
+Only \`atom\` can be set.
+`;
+function storeFromStoreData(data, detach) {
+  const get = (state) => getState(state, data);
   const set = (state, value) => {
-    if (isAtom(state)) {
+    if (isAtom(state))
       return setAtom(state, value, data);
-    } else {
-      if (isSelector(state)) {
-        if (state.set) {
-          txn((set2, get2) => state.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");
-    }
+    if (isSelector(state))
+      throw new Error(SelectorProvidedToSetError);
+    throw new Error(InvalidStateSetError);
   };
-  const reset = (atom3) => resetAtom(atom3, 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,
-    set,
-    sub,
-    txn,
-    reset,
-    data
+  const scope = (scopeId) => {
+    let scopedStoreData;
+    if (scopeId in data.scopes) {
+      scopedStoreData = data.scopes[scopeId];
+    } else {
+      scopedStoreData = createStoreData(scopeId, data);
+      data.scopes[scopeId] = scopedStoreData;
+    }
+    const detach2 = () => {
+      scopedStoreData.scopeConsumers.delete(detach2);
+      if (scopedStoreData.scopeConsumers.size === 0) {
+        delete data.scopes[scopeId];
+      }
+    };
+    scopedStoreData.scopeConsumers.add(detach2);
+    const newStore = storeFromStoreData(data.scopes[scopeId], detach2);
+    return newStore;
   };
-};
+  if (detach) {
+    return {
+      get,
+      set,
+      sub,
+      txn,
+      reset,
+      data,
+      scope,
+      detach
+    };
+  } else {
+    return {
+      get,
+      set,
+      sub,
+      txn,
+      reset,
+      data,
+      scope
+    };
+  }
+}
 
-// src/createStore.ts
-var createStore = (id) => {
+// src/createStoreWithSelectorSet.ts
+var setSelector = (selector2, values, store) => {
+  return selector2.set(store.set, store.get, store.reset, ...values);
+};
+var createStoreWithSelectorSet = (id) => {
   const data = createStoreData(id);
-  return storeFromStoreData2(data);
+  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");
-}
-var getDefaultStore = () => globalThis._valdresStore;
-var resetDefaultStore = () => globalThis._valdresStore = createStore();
-// src/selector.ts
-var selector = (get, debugLabel) => ({
-  get,
-  debugLabel
-});
 // 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;
   };
-  selectorFamily2._map = map;
+  selectorFamily2.__valdresSelectorFamilyMap = map;
+  if (options?.label)
+    selectorFamily2.label = options.label;
   return selectorFamily2;
 };
+// src/store.ts
+var store = (id) => {
+  const data = createStoreData(id);
+  return storeFromStoreData(data);
+};
+// src/utils/isFamilySelector.ts
+var isFamilySelector = (state) => isFamilyState(state) && isSelector(state);
 export {
+  store,
   selectorFamily,
   selector,
-  resetDefaultStore,
+  isSelectorFamily,
   isSelector,
   isPromiseLike,
+  isFamilyState,
+  isFamilySelector,
+  isFamilyAtom,
   isFamily,
+  isAtomFamily,
   isAtom,
-  getDefaultStore,
-  createStore,
+  createStoreWithSelectorSet,
   atomFamily,
   atom
 };