valdres 0.2.0-alpha.30 → 0.2.0-alpha.32

package/dist/index.js

@@ -1,3 +1,9 @@
+// src/atom.ts
+import equal3 from "fast-deep-equal/es6";
+
+// src/lib/globalAtom.ts
+import equal2 from "fast-deep-equal/es6";
+
 // src/utils/isAtom.ts
 var isAtom = (state) => Object.hasOwn(state, "defaultValue");
 
@@ -7,42 +13,137 @@ var isFamilyState = (state) => state && Object.hasOwn(state, "family");
 // src/utils/isFamilyAtom.ts
 var isFamilyAtom = (state) => isFamilyState(state) && isAtom(state);
 
+// src/lib/updateStateSubscribers.ts
+var updateStateSubscribers = (state, data) => {
+  const subscribtions = data.subscriptions.get(state);
+  if (subscribtions?.size) {
+    for (const subscribtion of subscribtions) {
+      subscribtion.callback();
+    }
+  }
+  if (isFamilyState(state)) {
+    const familySubscriptions = data.subscriptions.get(state.family);
+    if (familySubscriptions?.size) {
+      for (const subscribtion of familySubscriptions) {
+        subscribtion.callback(state.familyKey);
+      }
+    }
+  }
+};
+
 // src/utils/isPromiseLike.ts
 var isPromiseLike = (object) => {
   return object && object.then && typeof object.then === "function";
 };
 
-// src/utils/isSelector.ts
-var isSelector = (state) => state && Object.hasOwn(state, "get");
-
 // src/lib/getState.ts
-import equal2 from "fast-deep-equal/es6";
+import equal from "fast-deep-equal/es6";
 
 // src/utils/isAtomFamily.ts
 var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
 
+// src/utils/isSelector.ts
+var isSelector = (state) => 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/setAtom.ts
+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 (atom.equal(currentValue, newValue))
+    return;
+  data.values.set(atom, newValue);
+  if (atom.onSet && !skipOnSet)
+    atom.onSet(newValue, data);
+  if (currentValue?.__isEmptyAtomPromise__) {
+    currentValue.__resolveEmptyAtomPromise__(newValue);
+  }
+  propagateUpdatedAtoms([atom], data);
+};
 
-// src/lib/updateStateSubscribers.ts
-var updateStateSubscribers = (state, data) => {
-  const subscribtions = data.subscriptions.get(state);
-  if (subscribtions?.size) {
-    for (const subscribtion of subscribtions) {
-      subscribtion.callback();
+// 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 if (isSelector(atom.defaultValue)) {
+    return getState(atom.defaultValue, data);
+  } else {
+    return atom.defaultValue;
   }
-  if (isFamilyState(state)) {
-    const familySubscriptions = data.subscriptions.get(state.family);
-    if (familySubscriptions?.size) {
-      for (const subscribtion of familySubscriptions) {
-        subscribtion.callback(state.familyKey);
-      }
+};
+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/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 (equal(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/initSelector.ts
@@ -113,7 +214,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 (selector.equal(expiredValue, value)) {
       data.values.set(selector, expiredValue);
       return expiredValue;
     }
@@ -122,43 +223,7 @@ 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);
@@ -168,7 +233,7 @@ var updateSelectorSubscribers = (selector, data) => {
     try {
       const oldValue = data.expiredValues.get(selector);
       const newValue = initSelector(selector, data);
-      if (equal3(newValue, oldValue))
+      if (selector.equal(newValue, oldValue))
         return;
     } catch (e) {
     }
@@ -178,316 +243,49 @@ var updateSelectorSubscribers = (selector, data) => {
       subscribtion.callback();
     }
   }
-  if (familySubscriptions?.size) {
-    for (const subscribtion of familySubscriptions) {
-      subscribtion.callback(selector.familyKey);
-    }
-  }
-};
-
-// src/lib/propagateUpdatedAtoms.ts
-var recursivlyResetSelectorTree = (selectors, data, clearedSelectors) => {
-  for (const selector of selectors) {
-    if (!clearedSelectors.has(selector)) {
-      clearedSelectors.add(selector);
-      data.expiredValues.set(selector, data.values.get(selector));
-      data.values.delete(selector);
-      const consumers = data.stateConsumers.get(selector);
-      if (consumers?.size) {
-        recursivlyResetSelectorTree(consumers, data, clearedSelectors);
-      }
-    }
-  }
-};
-var propagateUpdatedAtoms = (atoms, data) => {
-  const clearedSelectors = new Set;
-  for (const atom of atoms) {
-    const consumers = data.stateConsumers.get(atom);
-    if (consumers && consumers.size) {
-      recursivlyResetSelectorTree(consumers, data, clearedSelectors);
-    }
-    if (isFamilyAtom(atom)) {
-      const consumersFamily = data.stateConsumers.get(atom.family);
-      if (consumersFamily?.size) {
-        recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
-      }
-    }
-  }
-  for (const selector of clearedSelectors) {
-    updateSelectorSubscribers(selector, data);
-  }
-  for (const atom of atoms) {
-    updateStateSubscribers(atom, data);
-  }
-};
-
-// src/lib/setAtom.ts
-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 (equal4(currentValue, newValue))
-    return;
-  data.values.set(atom, newValue);
-  if (atom.onSet && !skipOnSet)
-    atom.onSet(newValue, data);
-  if (currentValue?.__isEmptyAtomPromise__) {
-    currentValue.__resolveEmptyAtomPromise__(newValue);
-  }
-  propagateUpdatedAtoms([atom], data);
-};
-
-// 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 if (isSelector(atom.defaultValue)) {
-    return getState(atom.defaultValue, data);
-  } else {
-    return atom.defaultValue;
-  }
-};
-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/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/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 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);
+  if (familySubscriptions?.size) {
+    for (const subscribtion of familySubscriptions) {
+      subscribtion.callback(selector.familyKey);
+    }
   }
-  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 };
+// src/lib/propagateUpdatedAtoms.ts
+var recursivlyResetSelectorTree = (selectors, data, clearedSelectors) => {
+  for (const selector of selectors) {
+    if (!clearedSelectors.has(selector)) {
+      clearedSelectors.add(selector);
+      data.expiredValues.set(selector, data.values.get(selector));
+      data.values.delete(selector);
+      const consumers = data.stateConsumers.get(selector);
+      if (consumers?.size) {
+        recursivlyResetSelectorTree(consumers, data, clearedSelectors);
+      }
+    }
   }
 };
-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);
+var propagateUpdatedAtoms = (atoms, data) => {
+  const clearedSelectors = new Set;
+  for (const atom of atoms) {
+    const consumers = data.stateConsumers.get(atom);
+    if (consumers && consumers.size) {
+      recursivlyResetSelectorTree(consumers, data, clearedSelectors);
     }
-    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;
-}
+    if (isFamilyAtom(atom)) {
+      const consumersFamily = data.stateConsumers.get(atom.family);
+      if (consumersFamily?.size) {
+        recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
+      }
+    }
+  }
+  for (const selector of clearedSelectors) {
+    updateSelectorSubscribers(selector, data);
+  }
+  for (const atom of atoms) {
+    updateStateSubscribers(atom, data);
+  }
+};
+
 // src/lib/createStoreData.ts
 var generateId = () => (Math.random() + 1).toString(36).substring(7);
 var generateStoreData = (id = generateId()) => {
@@ -515,11 +313,11 @@ function createStoreData(id, parent) {
 }
 
 // src/lib/resetAtom.ts
-var resetAtom = (atom2, data) => {
-  let value = getAtomInitValue(atom2, data);
-  data.values.set(atom2, value);
+var resetAtom = (atom, data) => {
+  let value = getAtomInitValue(atom, data);
+  data.values.set(atom, value);
   if (!isPromiseLike(value)) {
-    propagateUpdatedAtoms([atom2], data);
+    propagateUpdatedAtoms([atom], data);
   }
   return value;
 };
@@ -566,18 +364,24 @@ var initSubscribers = (state, data) => {
   return set;
 };
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
+  let parentUnsubscribe;
   if ("parent" in data && !data.values.has(state) && isAtom(state)) {
-    const parentUnsubscribe = subscribe(state, callback, requireDeepEqualCheckBeforeCallback, data.parent);
-    let originalCallback = callback;
+    const originalCallback = callback;
+    parentUnsubscribe = subscribe(state, originalCallback, requireDeepEqualCheckBeforeCallback, data.parent);
     callback = () => {
-      parentUnsubscribe();
+      if (parentUnsubscribe) {
+        parentUnsubscribe();
+        parentUnsubscribe = undefined;
+      }
       originalCallback();
     };
+  } else if (!data.values.has(state) && isAtom(state)) {
+    initAtom(state, data);
   }
-  const subscribers = data.subscriptions.get(state) || initSubscribers(state, data);
   if (isSelector(state) && !data.values.has(state)) {
     initSelector(state, data);
   }
+  const subscribers = data.subscriptions.get(state) || initSubscribers(state, data);
   let subscription;
   if (isFamily(state)) {
     subscription = {
@@ -636,20 +440,24 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
   if (requireDeepEqualCheckBeforeCallback && data.subscriptionsRequireEqualCheck.get(state) !== true) {
     data.subscriptionsRequireEqualCheck.set(state, true);
   }
-  return () => unsubscribe(state, subscription, data, mount, maxAgeCleanup);
+  return () => {
+    if (parentUnsubscribe) {
+      parentUnsubscribe();
+    }
+    unsubscribe(state, subscription, data, mount, maxAgeCleanup);
+  };
 };
 
 // src/lib/setAtoms.ts
-import equal5 from "fast-deep-equal/es6";
 var setAtoms = (pairs, data) => {
   const updatedAtoms = [];
-  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);
+  for (let [atom, value] of pairs) {
+    const currentValue = getState(atom, data);
+    if (!atom.equal(currentValue, value)) {
+      updatedAtoms.push(atom);
+      if (atom.onSet)
+        atom.onSet(value, data);
+      data.values.set(atom, value);
     }
   }
   propagateUpdatedAtoms(updatedAtoms, data);
@@ -705,25 +513,25 @@ var transaction = (callback, data) => {
       throw new Error("Unsupported state");
     }
   };
-  const txnSet = (atom2, value) => {
-    if (!isAtom(atom2))
+  const txnSet = (atom, value) => {
+    if (!isAtom(atom))
       throw new Error("Not an atom");
     if (typeof value === "function") {
-      const currentValue = txnGet(atom2);
+      const currentValue = txnGet(atom);
       value = value(currentValue);
     }
-    for (const selector2 of findDependencies(atom2, data)) {
-      dirtySelectors.add(selector2);
-      txnSelectorCache.delete(selector2);
+    for (const selector of findDependencies(atom, data)) {
+      dirtySelectors.add(selector);
+      txnSelectorCache.delete(selector);
     }
-    if (txnSubscribers.get(atom2)?.size) {
-      recursivlyResetTxnSelectorCache(atom2, txnSubscribers, txnSelectorCache);
+    if (txnSubscribers.get(atom)?.size) {
+      recursivlyResetTxnSelectorCache(atom, txnSubscribers, txnSelectorCache);
     }
-    txnAtomMap.set(atom2, value);
+    txnAtomMap.set(atom, value);
   };
-  const txnReset = (atom2) => {
-    const value = getAtomInitValue(atom2, data);
-    txnAtomMap.set(atom2, value);
+  const txnReset = (atom) => {
+    const value = getAtomInitValue(atom, data);
+    txnAtomMap.set(atom, value);
     return value;
   };
   const commit = () => {
@@ -752,7 +560,7 @@ function storeFromStoreData(data, detach) {
       throw new Error(SelectorProvidedToSetError);
     throw new Error(InvalidStateSetError);
   };
-  const reset = (atom2) => resetAtom(atom2, data);
+  const reset = (atom) => resetAtom(atom, data);
   const sub = (state, callback, deepEqualCheckBeforeCallback = true) => subscribe(state, callback, deepEqualCheckBeforeCallback, data);
   const txn = (callback) => transaction(callback, data);
   const scope = (scopeId) => {
@@ -797,32 +605,268 @@ function storeFromStoreData(data, detach) {
   }
 }
 
+// src/store.ts
+var store = (id) => {
+  const data = createStoreData(id);
+  return storeFromStoreData(data);
+};
+// package.json
+var version = "0.2.0-alpha.32";
+
+// src/globalStore.ts
+if (globalThis.__valdres__) {
+  throw new Error(`Error! An instance of valdres is already loaded`);
+} else {
+  globalThis.__valdres__ = version;
+}
+var globalStore = Object.assign(store("valdres-global-store"), {
+  atoms: new Map,
+  atomFamilies: new Map
+});
+
+// src/lib/globalAtom.ts
+var globalAtom = (defaultValue, options) => {
+  const stores = new Set;
+  let value;
+  let initialized = false;
+  let onReset;
+  if (options.onSet)
+    throw new Error("onSet on globalAtom is currently not supported");
+  const onInit = (setSelf2, data) => {
+    setSelf2(globalStore.get(atom));
+    if (!initialized && options.onInit) {
+      onReset = options.onInit((newVal) => {
+        setSelf2(newVal);
+        value = newVal;
+      }, data);
+      initialized = true;
+    }
+    stores.add(data);
+  };
+  const onSet = (newValue, currentStore) => {
+    value = newValue;
+    if (stores.size > 1) {
+      for (const store2 of stores) {
+        if (store2.id !== currentStore.id) {
+          setAtom(atom, value, store2, true);
+        }
+      }
+    }
+  };
+  const getSelf = () => globalStore.get(atom);
+  const setSelf = (newValue) => globalStore.set(atom, newValue);
+  const resetSelf = () => {
+    value = undefined;
+    initialized = false;
+    for (const store2 of stores) {
+      if (store2.stateDependencies.has(atom)) {
+        throw new Error("TODO: Reset support for stateDependencies");
+      }
+      store2.values.delete(atom);
+      store2.expiredValues.delete(atom);
+      propagateUpdatedAtoms([atom], store2);
+      stores.delete(store2);
+      onReset?.();
+    }
+  };
+  const atom = {
+    equal: equal2,
+    ...options,
+    defaultValue,
+    name: options?.name,
+    onInit,
+    onSet,
+    setSelf,
+    getSelf,
+    resetSelf,
+    get stores() {
+      return stores;
+    }
+  };
+  return atom;
+};
+
+// src/atom.ts
+function atom(defaultValue, options) {
+  if (!options)
+    return { equal: equal3, defaultValue };
+  if (options.global) {
+    return globalAtom(defaultValue, options);
+  }
+  return {
+    equal: equal3,
+    defaultValue,
+    ...options
+  };
+}
+// src/lib/createAtomFamily.ts
+import equal5 from "fast-deep-equal/es6";
+
+// 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 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
+import equal4 from "fast-deep-equal/es6";
+var selector = (get, options) => {
+  if (!options)
+    return { equal: equal4, get };
+  return { equal: equal4, ...options, get };
+};
+
+// src/lib/createAtomFamily.ts
+var createOptions = (options = {}, family, familyKey, keyStringified) => {
+  if (options.name) {
+    return {
+      equal: equal5,
+      ...options,
+      name: options?.name + "_" + keyStringified,
+      family,
+      familyKey
+    };
+  } else {
+    return { equal: equal5, ...options, family, familyKey };
+  }
+};
+var handleDefaultValue = (defaultValue, key) => {
+  if (isSelectorFamily(defaultValue))
+    return defaultValue(key);
+  if (typeof defaultValue === "function")
+    return () => defaultValue(key);
+  return defaultValue;
+};
+var createAtomFamily = (defaultValue, options) => {
+  const map = new Map;
+  const keysAtom = atom(new Set);
+  const atomFamily = Object.assign((key) => {
+    const keyStringified = stableStringify(key);
+    if (map.has(keyStringified)) {
+      return map.get(keyStringified);
+    }
+    const familyAtom = atomFamilyAtom(handleDefaultValue(defaultValue, key), createOptions(options, atomFamily, Object.freeze(key), keyStringified));
+    map.set(keyStringified, familyAtom);
+    return familyAtom;
+  }, {
+    __valdresAtomFamilyMap: map,
+    release: (key) => map.delete(key),
+    __keysAtom: keysAtom,
+    __keysSelector: selector((get) => Array.from(get(keysAtom)))
+  });
+  if (options?.name)
+    Object.defineProperty(atomFamily, "name", {
+      value: options.name,
+      writable: false
+    });
+  return atomFamily;
+};
+
+// src/lib/createGlobalAtomFamily.ts
+var createGlobalAtomFamily = (defaultValue, options) => {
+  if (globalStore.atomFamilies.has(options.name)) {
+    return globalStore.atomFamilies.get(options.name);
+  }
+  const family = createAtomFamily(defaultValue, options);
+  globalStore.atomFamilies.set(options.name, family);
+  return family;
+};
+
+// src/atomFamily.ts
+function atomFamily(defaultValue, options) {
+  if (options?.global)
+    return createGlobalAtomFamily(defaultValue, options);
+  return createAtomFamily(defaultValue, options);
+}
 // src/createStoreWithSelectorSet.ts
-var setSelector = (selector2, values, store) => {
-  return selector2.set(store.set, store.get, store.reset, ...values);
+var setSelector = (selector2, values, store2) => {
+  return selector2.set(store2.set, store2.get, store2.reset, ...values);
 };
 var createStoreWithSelectorSet = (id) => {
   const data = createStoreData(id);
-  const store = storeFromStoreData(data);
-  store.set = (state, value, ...rest) => {
+  const store2 = storeFromStoreData(data);
+  store2.set = (state, value, ...rest) => {
     if (isAtom(state))
       return setAtom(state, value, data);
     if (isSelector(state))
-      return setSelector(state, [value, ...rest], store);
+      return setSelector(state, [value, ...rest], store2);
     throw new Error("Invalid state object");
   };
-  store.kind = "storeWithSelectorSet";
-  return store;
+  store2.kind = "storeWithSelectorSet";
+  return store2;
 };
 // src/selectorFamily.ts
-var createOptions2 = (options, key) => {
-  if (options.label) {
+import equal6 from "fast-deep-equal/es6";
+var createOptions2 = (options = {}, family, familyKey, keyStringified) => {
+  if (options.name) {
     return {
+      equal: equal6,
       ...options,
-      label: options?.label + "_" + key
+      name: options?.name + "_" + keyStringified,
+      family,
+      familyKey
     };
   } else {
-    return options;
+    return { equal: equal6, ...options, family, familyKey };
   }
 };
 var selectorFamily = (get, options) => {
@@ -831,21 +875,18 @@ var selectorFamily = (get, options) => {
     const keyStringified = stableStringify(key);
     if (map.has(keyStringified))
       return map.get(keyStringified);
-    const newSelector = selector((selectorArgs) => get(key)(selectorArgs), options ? createOptions2(options, keyStringified) : undefined);
-    newSelector.family = selectorFamily2;
+    const newSelector = selector((selectorArgs) => get(key)(selectorArgs), createOptions2(options, selectorFamily2, key, keyStringified));
     map.set(keyStringified, newSelector);
     return newSelector;
   };
   selectorFamily2.__valdresSelectorFamilyMap = map;
-  if (options?.label)
-    selectorFamily2.label = options.label;
+  if (options?.name)
+    Object.defineProperty(selectorFamily2, "name", {
+      value: options.name,
+      writable: false
+    });
   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 {

package/dist/types/index.d.ts

@@ -15,6 +15,7 @@ export { isSelector } from "./src/utils/isSelector";
 export { isSelectorFamily } from "./src/utils/isSelectorFamily";
 export type { Atom } from "./src/types/Atom";
 export type { AtomFamily } from "./src/types/AtomFamily";
+export type { FamilyKey } from "./src/types/FamilyKey";
 export type { GetValue } from "./src/types/GetValue";
 export type { GlobalAtom } from "./src/types/GlobalAtom";
 export type { ResetAtom } from "./src/types/ResetAtom";

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

@@ -7,7 +7,7 @@ import type { GlobalAtom } from "./types/GlobalAtom";
  *
  * @example
  *
- * const user = atom<string>("Default Value", { label: "userAtom"})
+ * const user = atom<string>("Default Value", { name: "userAtom"})
  *
  */
 export declare function atom<V>(defaultValue: AtomDefaultValue<V>, options: AtomOptions<V> & {

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

@@ -1,10 +1,4 @@
-import type { AtomFamily } from "./types/AtomFamily";
 import type { AtomOptions } from "./types/AtomOptions";
 import type { FamilyKey } from "./types/FamilyKey";
-import type { Selector } from "./types/Selector";
-import type { SelectorFamily } from "./types/SelectorFamily";
-type DefaultValueCallback<Key, Value> = (arg: Key) => Value | Promise<Value>;
-type AtomFamilyDefaultValue<Key, Value> = undefined | Value | DefaultValueCallback<Key, Value> | Selector<Value> | SelectorFamily<Key, Value>;
-/** [Docs Reference](https://valdres.dev/valdres/api/atomFamily) */
-export declare function atomFamily<Key = FamilyKey, Value = unknown>(defaultValue?: AtomFamilyDefaultValue<Key, Value>, options?: AtomOptions<Value>): AtomFamily<Key, Value>;
-export {};
+import type { AtomFamilyDefaultValue } from "./types/AtomFamilyDefaultValue";
+export declare function atomFamily<Key = FamilyKey, Value = unknown>(defaultValue?: AtomFamilyDefaultValue<Key, Value>, options?: AtomOptions<Value>): import("..").AtomFamily<Key, Value>;

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

@@ -0,0 +1,4 @@
+export declare const globalStore: import("..").Store & {
+    atoms: Map<any, any>;
+    atomFamilies: Map<any, any>;
+};

package/dist/types/src/lib/createAtomFamily.d.ts

@@ -0,0 +1,4 @@
+import type { AtomFamily } from "../types/AtomFamily";
+import type { AtomOptions } from "../types/AtomOptions";
+import type { AtomFamilyDefaultValue } from "../types/AtomFamilyDefaultValue";
+export declare const createAtomFamily: <Key, Value>(defaultValue: AtomFamilyDefaultValue<Key, Value>, options?: AtomOptions<Value>) => AtomFamily<Key, Value>;

package/dist/types/src/lib/createGlobalAtomFamily.d.ts

@@ -0,0 +1,5 @@
+import type { AtomOptions } from "../types/AtomOptions";
+import type { FamilyKey } from "../types/FamilyKey";
+import type { AtomFamilyDefaultValue } from "../types/AtomFamilyDefaultValue";
+import type { AtomFamily } from "../types/AtomFamily";
+export declare const createGlobalAtomFamily: <Key = FamilyKey, Value = unknown>(defaultValue: AtomFamilyDefaultValue<Key, Value>, options: AtomOptions<Value>) => AtomFamily<Key, Value>;

package/dist/types/src/lib/globalAtom.d.ts

@@ -1,4 +1,4 @@
 import type { AtomDefaultValue } from "../types/AtomDefaultValue";
 import type { AtomOptions } from "./../types/AtomOptions";
 import type { GlobalAtom } from "./../types/GlobalAtom";
-export declare const globalAtom: <Value = any>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value>) => GlobalAtom<Value>;
+export declare const globalAtom: <Value = unknown>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value>) => GlobalAtom<Value>;

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

@@ -1,4 +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> | Family<V>, callback: any, requireDeepEqualCheckBeforeCallback: boolean, data: StoreData) => () => void;
+export declare const subscribe: <V>(state: State<V> | Family<V>, callback: () => void, requireDeepEqualCheckBeforeCallback: boolean, data: StoreData) => () => void;

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

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

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

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

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

@@ -1,9 +1,11 @@
 import type { AtomDefaultValue } from "./AtomDefaultValue";
 import type { AtomOnInit } from "./AtomOnInit";
 import type { AtomOnSet } from "./AtomOnSet";
+import type { EqualFunc } from "./EqualFunc";
 export type Atom<Value = unknown> = {
+    equal: EqualFunc<Value>;
     defaultValue?: AtomDefaultValue<Value>;
-    label?: string;
+    name?: string;
     onInit?: AtomOnInit<Value>;
     onSet?: AtomOnSet<Value>;
     onMount?: () => void | (() => void);

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

@@ -5,7 +5,7 @@ import type { Selector } from "./Selector";
 export type AtomFamily<Key = FamilyKey, Value = unknown> = {
     (key: Key): AtomFamilyAtom<Key, Value>;
     release: (key: Key) => void;
-    label?: string;
+    name?: string;
     __valdresAtomFamilyMap: Map<Key, AtomFamilyAtom<Key, Value>>;
     __keysAtom: Atom<Set<Key>>;
     __keysSelector: Selector<Key[]>;

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

@@ -0,0 +1,5 @@
+import type { Selector } from "./Selector";
+import type { SelectorFamily } from "./SelectorFamily";
+type DefaultValueCallback<Key, Value> = (arg: Key) => Value | Promise<Value>;
+export type AtomFamilyDefaultValue<Key, Value> = undefined | Value | DefaultValueCallback<Key, Value> | Selector<Value> | SelectorFamily<Key, Value>;
+export {};

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

@@ -1,11 +1,13 @@
 import type { AtomOnSet } from "./AtomOnSet";
+import type { EqualFunc } from "./EqualFunc";
 import type { StoreData } from "./StoreData";
 export type AtomOptions<Value = unknown> = {
     global?: boolean;
-    label?: string;
+    name?: string;
     onInit?: (setSelf: (value: Value) => void, store: StoreData) => (() => void) | void;
     onSet?: AtomOnSet<Value>;
     onMount?: () => () => void;
     maxAge?: number;
     staleWhileRevalidate?: number;
+    equal?: EqualFunc<Value>;
 };

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

@@ -0,0 +1 @@
+export type EqualFunc<Value> = (a: Value, b: Value) => boolean;

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

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

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

@@ -1,7 +1,11 @@
 import type { Atom } from "./Atom";
-import type { GlobalAtomSetSelfFunc } from "./GlobalAtomSetSelfFunc";
+import type { GlobalAtomGetSelfFunc } from "./GlobalAtomGetSelfFunc";
 import type { GlobalAtomResetSelfFunc } from "./GlobalAtomResetSelfFunc";
+import type { GlobalAtomSetSelfFunc } from "./GlobalAtomSetSelfFunc";
+import type { StoreData } from "./StoreData";
 export type GlobalAtom<Value = unknown> = Atom<Value> & {
     setSelf: GlobalAtomSetSelfFunc<Value>;
     resetSelf: GlobalAtomResetSelfFunc;
+    getSelf: GlobalAtomGetSelfFunc<Value>;
+    stores: Set<StoreData>;
 };

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

@@ -0,0 +1 @@
+export type GlobalAtomGetSelfFunc<Value = unknown> = () => Value;

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

@@ -1,8 +1,10 @@
+import type { EqualFunc } from "./EqualFunc";
 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;
+    equal: EqualFunc<Value>;
+    name?: string;
     family?: SelectorFamily<FamilyKey, Value>;
     familyKey?: FamilyKey;
     onMount?: () => void | (() => void);

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

@@ -1,3 +1,5 @@
-export type SelectorOptions = {
-    label?: string;
+import type { EqualFunc } from "./EqualFunc";
+export type SelectorOptions<Value> = {
+    name?: string;
+    equal?: EqualFunc<Value>;
 };

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.30",
+    "version": "0.2.0-alpha.32",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
@@ -33,11 +33,11 @@
         "react": ">=18",
         "react-dom": ">=18",
         "recoil": "0.7.7",
-        "typescript": "5.6.2"
+        "typescript": "5.6.3"
     },
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "5b94699fe0e875ccfd7e95e535bec8a7ecedcb30"
+    "gitHead": "27342cf65a13e2ec86f5f400d814385d0c8de2cd"
 }