valdres 0.2.0-alpha.74 → 0.2.0-alpha.76

package/dist/index.js

@@ -92,6 +92,9 @@ var equal = (a, b) => {
   }
 };
 
+// src/utils/isAtomFamily.ts
+var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
+
 // src/utils/isAtom.ts
 var isAtom = (state) => Object.hasOwn(state, "defaultValue");
 
@@ -101,32 +104,11 @@ 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/isAtomFamily.ts
-var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
-
 // src/utils/isSelector.ts
 var isSelector = (state) => state && Object.hasOwn(state, "get");
 
@@ -193,6 +175,7 @@ var setAtom = (atom, newValue, data, skipOnSet = false) => {
   if (currentValue?.__isEmptyAtomPromise__) {
     currentValue.__resolveEmptyAtomPromise__(newValue);
   }
+  if (isFamilyAtom(atom)) {}
   propagateUpdatedAtoms([atom], data);
   return newValue;
 };
@@ -226,11 +209,10 @@ var initAtom = (atom, data) => {
   const tmpVal = getAtomInitValue(atom, data);
   let value = setValueInData(atom, tmpVal, data);
   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);
+    const currentAtoms = data.values.get(atom.family) || [];
+    if (!currentAtoms.includes(atom)) {
+      data.values.set(atom.family, [...currentAtoms, atom]);
+      propagateUpdatedAtoms([atom.family], data);
     }
   }
   if (atom.onInit)
@@ -250,14 +232,17 @@ function getState(state, data, circularDependencySet) {
       return getState(state, data.parent, circularDependencySet);
     return initAtom(state, data);
   }
-  if (isSelector(state))
-    return initSelector(state, data, circularDependencySet);
+  if (isSelector(state)) {
+    initSelector(state, data, circularDependencySet);
+    return data.values.get(state);
+  }
   if (isAtomFamily(state)) {
     if ("parent" in data) {
-      const closestData = findClosestStoreWithAtomInitialized(state.__keysAtom, data);
-      return getState(state.__keysSelector, closestData, circularDependencySet);
+      const closestData = findClosestStoreWithAtomInitialized(state, data);
+      return getState(state, closestData, circularDependencySet);
     }
-    return getState(state.__keysSelector, data, circularDependencySet);
+    data.values.set(state, []);
+    return data.values.get(state);
   }
   if (isSelectorFamily(state)) {
     const array = Array.from(state.__valdresSelectorFamilyMap.keys());
@@ -276,6 +261,24 @@ var findClosestStoreWithAtomInitialized = (atom, data) => {
   return findClosestStoreWithAtomInitialized(atom, data.parent);
 };
 
+// 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.familyArgs);
+      }
+    }
+  }
+};
+
 // src/errors/lib/generateSelectorTrace.ts
 var generateSelectorTrace = (selectors) => {
   const lastIndex = selectors.length - 1;
@@ -331,11 +334,11 @@ class SuspendAndWaitForResolveError extends Error {
   }
 }
 var getOrInitConsumersSet = (state, data) => {
-  const set = data.stateConsumers.get(state);
+  const set = data.stateDependents.get(state);
   if (set)
     return set;
   const newSet = new Set;
-  data.stateConsumers.set(state, newSet);
+  data.stateDependents.set(state, newSet);
   return newSet;
 };
 var evaluateSelector = (selector, data, circularDependencyMap = new WeakSet) => {
@@ -392,6 +395,16 @@ var handleSelectorResult = (value, selector, data) => {
   }
 };
 var initSelector = (selector, data, circularDependencySet = new WeakSet) => {
+  const existingValue = data.values.get(selector);
+  const udpatedValue = evaluate(selector, data, circularDependencySet);
+  if (selector.equal(existingValue, udpatedValue)) {
+    return false;
+  } else {
+    setValueInData(selector, udpatedValue, data);
+    return true;
+  }
+};
+var evaluate = (selector, data, circularDependencySet) => {
   let tmpValue;
   try {
     tmpValue = evaluateSelector(selector, data, circularDependencySet);
@@ -400,14 +413,7 @@ var initSelector = (selector, data, circularDependencySet = new WeakSet) => {
       e.track(selector);
     throw e;
   }
-  const value = handleSelectorResult(tmpValue, selector, data);
-  if (data.expiredValues.has(selector)) {
-    const expiredValue = data.expiredValues.get(selector);
-    if (selector.equal(expiredValue, value)) {
-      return setValueInData(selector, expiredValue, data);
-    }
-  }
-  return setValueInData(selector, value, data);
+  return handleSelectorResult(tmpValue, selector, data);
 };
 
 // src/lib/updateSelectorSubscribers.ts
@@ -416,15 +422,6 @@ 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 && selector.family && data.subscriptionsRequireEqualCheck.get(selector.family)) {
-    try {
-      const oldValue = data.expiredValues.get(selector);
-      const newValue = initSelector(selector, data);
-      if (selector.equal(newValue, oldValue))
-        return;
-    } catch (e) {
-    }
-  }
   if (subscribtions?.size) {
     for (const subscribtion of subscribtions) {
       subscribtion.callback();
@@ -432,21 +429,53 @@ var updateSelectorSubscribers = (selector, data) => {
   }
   if (familySubscriptions?.size) {
     for (const subscribtion of familySubscriptions) {
-      subscribtion.callback(selector.familyKey);
+      subscribtion.callback(...selector.familyArgs);
     }
   }
 };
 
 // src/lib/propagateUpdatedAtoms.ts
+var revalidate = (selector, data) => {
+  try {
+    return initSelector(selector, data);
+  } catch (e) {
+    data.expiredValues.set(selector, data.values.get(selector));
+    data.values.delete(selector);
+    return true;
+  }
+};
 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);
+      const subscribers = data.subscriptions.get(selector);
+      const dependents = data.stateDependents.get(selector);
+      if (!dependents && !subscribers) {
+        data.expiredValues.set(selector, data.values.get(selector));
+        data.values.delete(selector);
+      } else if (dependents && subscribers) {
+        if (dependents.size === 0)
+          throw new Error("Should not happen");
+        if (subscribers.size === 0)
+          throw new Error("Should not happen");
+        const isValueUpdated = revalidate(selector, data);
+        if (isValueUpdated) {
+          recursivlyResetSelectorTree(dependents, data, clearedSelectors);
+          updateSelectorSubscribers(selector, data);
+        }
+      } else if (dependents) {
+        if (dependents.size === 0)
+          throw new Error("Should not happen");
+        const valueUpdated = revalidate(selector, data);
+        if (valueUpdated) {
+          recursivlyResetSelectorTree(dependents, data, clearedSelectors);
+        }
+      } else if (subscribers) {
+        if (subscribers.size === 0)
+          throw new Error("Should not happen");
+        const isValueUpdated = revalidate(selector, data);
+        if (isValueUpdated) {
+          updateSelectorSubscribers(selector, data);
+        }
       }
     }
   }
@@ -454,21 +483,20 @@ var recursivlyResetSelectorTree = (selectors, 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);
+    const dependents = data.stateDependents.get(atom);
+    if (dependents && dependents.size) {
+      recursivlyResetSelectorTree(dependents, data, clearedSelectors);
     }
     if (isFamilyAtom(atom)) {
-      const consumersFamily = data.stateConsumers.get(atom.family);
+      const consumersFamily = data.stateDependents.get(atom.family);
       if (consumersFamily?.size) {
         recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
       }
     }
   }
-  for (const selector of clearedSelectors) {
-    updateSelectorSubscribers(selector, data);
-  }
   for (const atom of atoms) {
+    if (isAtomFamily(atom))
+      continue;
     updateStateSubscribers(atom, data);
   }
 };
@@ -482,7 +510,7 @@ var generateStoreData = (id = generateId()) => {
     expiredValues: new WeakMap,
     subscriptions: new WeakMap,
     subscriptionsRequireEqualCheck: new WeakMap,
-    stateConsumers: new WeakMap,
+    stateDependents: new WeakMap,
     stateDependencies: new WeakMap,
     scopes: {}
   };
@@ -499,6 +527,20 @@ function createStoreData(id, parent) {
   }
 }
 
+// src/lib/deleteFamilyAtom.ts
+var deleteFamilyAtom = (atom, data) => {
+  const array = data.values.get(atom.family);
+  const index = array.indexOf(atom);
+  const newArray = [
+    ...array.slice(0, index),
+    ...array.slice(index + 1)
+  ];
+  data.values.delete(atom);
+  propagateUpdatedAtoms([atom], data);
+  setValueInData(atom.family, newArray, data);
+  propagateUpdatedAtoms([atom.family], data);
+};
+
 // src/lib/resetAtom.ts
 var resetAtom = (atom, data) => {
   let value = getAtomInitValue(atom, data);
@@ -652,17 +694,18 @@ var setAtoms = (pairs, data) => {
 
 // src/lib/transaction.ts
 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)) {
-        result.add(consumer);
-        findDependencies(consumer, data, result);
+  const dependents = data.stateDependents.get(state);
+  if (dependents?.size) {
+    for (const dependent of dependents) {
+      if (!result.has(dependent)) {
+        result.add(dependent);
+        findDependencies(dependent, data, result);
       }
     }
   }
   return result;
 };
+var DELETE_SYMBOL = Symbol("DELETE_SYMBOL");
 var recursivlyResetTxnSelectorCache = (state, txnSubscribers, txnSelectorCache) => {
   for (const dep of txnSubscribers.get(state)) {
     txnSelectorCache.delete(dep);
@@ -671,33 +714,39 @@ var recursivlyResetTxnSelectorCache = (state, txnSubscribers, txnSelectorCache)
     }
   }
 };
-var captureScopedTransaction = (scopedData, parentGetFromTxnOrData) => {
+var captureScopedTransaction = (scopedData, parentGetInTxnOrData) => {
   let txn;
   transaction((scopedTxn) => {
     txn = scopedTxn;
-  }, scopedData, false, parentGetFromTxnOrData);
+  }, scopedData, false, parentGetInTxnOrData);
   return txn;
 };
-var transaction = (callback, data, autoCommit = true, parentGetFromTxnOrData) => {
+var deleteAtomFamilyAtoms = (set, data) => {
+  set.forEach((atom) => {
+    data.values.delete(atom);
+  });
+};
+var transaction = (callback, data, autoCommit = true, parentGetInTxnOrData) => {
   const txnAtomMap = new Map;
+  const txnAtomDeleteSet = new Set;
   const txnSelectorCache = new Map;
   const txnSubscribers = new Map;
   const dirtySelectors = new Set;
   let scopedTransactions;
-  const getFromTxnOrData = (state) => {
+  const getInTxnOrData = (state) => {
     if (txnAtomMap.has(state)) {
       return txnAtomMap.get(state);
     }
     if (data.values.has(state)) {
       return data.values.get(state);
     }
-    if (parentGetFromTxnOrData) {
-      return parentGetFromTxnOrData(state);
+    if (parentGetInTxnOrData) {
+      return parentGetInTxnOrData(state);
     }
   };
   const txnGet = (state) => {
     if (isAtom(state)) {
-      const value = getFromTxnOrData(state);
+      const value = getInTxnOrData(state);
       if (value)
         return value;
       return getState(state, data);
@@ -719,7 +768,10 @@ var transaction = (callback, data, autoCommit = true, parentGetFromTxnOrData) =>
       txnSelectorCache.set(state, res);
       return res;
     } else if (isAtomFamily(state)) {
-      return txnGet(state.__keysSelector);
+      const value = getInTxnOrData(state);
+      if (value)
+        return value;
+      return getState(state, data);
     } else {
       throw new Error("Unsupported state");
     }
@@ -744,11 +796,10 @@ var transaction = (callback, data, autoCommit = true, parentGetFromTxnOrData) =>
       txnAtomMap.set(atom, deepFreeze(value));
     }
     if (isFamilyAtom(atom)) {
-      const currentKeySet = txnGet(atom.family.__keysAtom);
-      if (!currentKeySet.has(atom.familyKey)) {
-        const newSet = new Set(currentKeySet);
-        newSet.add(atom.familyKey);
-        txnSet(atom.family.__keysAtom, newSet);
+      const currentFamilyList = txnGet(atom.family);
+      if (!currentFamilyList.includes(atom)) {
+        const newArr = [...currentFamilyList, atom];
+        txnAtomMap.set(atom.family, newArr);
       }
     }
     return value;
@@ -758,8 +809,26 @@ var transaction = (callback, data, autoCommit = true, parentGetFromTxnOrData) =>
     txnAtomMap.set(atom, value);
     return value;
   };
+  const txnDel = (atom) => {
+    const array = txnGet(atom.family);
+    const index = array.indexOf(atom);
+    const newArr = [
+      ...array.slice(0, index),
+      ...array.slice(index + 1)
+    ];
+    txnAtomMap.set(atom.family, newArr);
+    if (data.values.has(atom)) {
+      txnAtomDeleteSet.add(atom);
+    }
+    if (txnAtomMap.has(atom)) {
+      txnAtomMap.delete(atom);
+    }
+  };
   const commit = () => {
     setAtoms(txnAtomMap, data);
+    if (txnAtomDeleteSet.size) {
+      deleteAtomFamilyAtoms(txnAtomDeleteSet, data);
+    }
     dirtySelectors.clear();
     if (scopedTransactions) {
       for (const scopedTxn of Object.values(scopedTransactions)) {
@@ -770,6 +839,7 @@ var transaction = (callback, data, autoCommit = true, parentGetFromTxnOrData) =>
   const result = callback({
     set: txnSet,
     get: txnGet,
+    del: txnDel,
     reset: txnReset,
     commit,
     scope: (scopeId, callback2) => {
@@ -779,7 +849,7 @@ var transaction = (callback, data, autoCommit = true, parentGetFromTxnOrData) =>
           scopedTransactions = {};
         }
         if (scopedTransactions[scopeId] === undefined) {
-          scopedTransactions[scopeId] = captureScopedTransaction(scopedData, getFromTxnOrData);
+          scopedTransactions[scopeId] = captureScopedTransaction(scopedData, getInTxnOrData);
         }
         return callback2(scopedTransactions[scopeId]);
       } else {
@@ -811,6 +881,7 @@ function storeFromStoreData(data, detach) {
     throw new Error(InvalidStateSetError);
   };
   const reset = (atom) => resetAtom(atom, data);
+  const deleteFn = (atom) => deleteFamilyAtom(atom, data);
   const sub = (state, callback, deepEqualCheckBeforeCallback = true) => subscribe(state, callback, deepEqualCheckBeforeCallback, data);
   const txn = (callback) => transaction(callback, data);
   const scope = (scopeId) => {
@@ -838,6 +909,7 @@ function storeFromStoreData(data, detach) {
       sub,
       txn,
       reset,
+      delete: deleteFn,
       data,
       scope,
       detach
@@ -849,6 +921,7 @@ function storeFromStoreData(data, detach) {
       sub,
       txn,
       reset,
+      delete: deleteFn,
       data,
       scope
     };
@@ -942,13 +1015,6 @@ function atom(defaultValue, options) {
     ...options
   };
 }
-// src/selector.ts
-var selector = (get, options) => {
-  if (!options)
-    return { equal, get };
-  return { equal, ...options, get };
-};
-
 // src/lib/atomFamilyAtom.ts
 function atomFamilyAtom(defaultValue, options) {
   if (options.global) {
@@ -1014,43 +1080,47 @@ var stableStringify = (x) => {
   return stableStringifyRecurse(x);
 };
 
+// src/lib/stringifyFamilyArgs.ts
+var stringifyFamilyArgs = (args) => {
+  return args.length === 1 ? stableStringify(args[0]) : stableStringify(args);
+};
+
 // src/lib/createAtomFamily.ts
-var createOptions = (options = {}, family, familyKey, keyStringified) => {
+var createOptions = (options = {}, family, familyArgs, familyArgsStringified) => {
   if (options.name) {
     return {
       equal,
       ...options,
-      name: options?.name + "_" + keyStringified,
+      name: options?.name + "_" + familyArgsStringified,
       family,
-      familyKey
+      familyArgs,
+      familyArgsStringified
     };
   } else {
-    return { equal, ...options, family, familyKey };
+    return { equal, ...options, family, familyArgs, familyArgsStringified };
   }
 };
-var handleDefaultValue = (defaultValue, key) => {
+var handleDefaultValue = (defaultValue, ...args) => {
   if (isSelectorFamily(defaultValue))
-    return defaultValue(key);
+    return defaultValue(...args);
   if (typeof defaultValue === "function")
-    return () => defaultValue(key);
+    return () => defaultValue(...args);
   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 atomFamily = Object.assign((...args) => {
+    const argsStringified = stringifyFamilyArgs(args);
+    if (map.has(argsStringified)) {
+      return map.get(argsStringified);
     }
-    const familyAtom = atomFamilyAtom(handleDefaultValue(defaultValue, key), createOptions(options, atomFamily, Object.freeze(key), keyStringified));
-    map.set(keyStringified, familyAtom);
+    const familyAtom = atomFamilyAtom(handleDefaultValue(defaultValue, ...args), createOptions(options, atomFamily, args, argsStringified));
+    map.set(argsStringified, familyAtom);
     return familyAtom;
   }, {
     __valdresAtomFamilyMap: map,
-    release: (key) => map.delete(key),
-    __keysAtom: keysAtom,
-    __keysSelector: selector((get) => Array.from(get(keysAtom)))
+    release: (...args) => map.delete(stringifyFamilyArgs(args)),
+    equal
   });
   if (options?.name)
     Object.defineProperty(atomFamily, "name", {
@@ -1079,8 +1149,8 @@ function atomFamily(defaultValue, options) {
   return createAtomFamily(defaultValue, options);
 }
 // src/createStoreWithSelectorSet.ts
-var setSelector = (selector2, values, store2) => {
-  return selector2.set(store2.set, store2.get, store2.reset, ...values);
+var setSelector = (selector, values, store2) => {
+  return selector.set(store2.set, store2.get, store2.reset, ...values);
 };
 var createStoreWithSelectorSet = (id) => {
   const data = createStoreData(id);
@@ -1095,59 +1165,82 @@ var createStoreWithSelectorSet = (id) => {
   store2.kind = "storeWithSelectorSet";
   return store2;
 };
+// src/selector.ts
+var selector = (get, options) => {
+  if (!options)
+    return { equal, get };
+  return { equal, ...options, get };
+};
+
 // src/indexConstructor.ts
-var index = (family, callback) => {
+var index = (family, callback, options) => {
   const map = new Map;
-  return (term) => {
+  const indexFn = (term) => {
     const termKey = stableStringify(term);
     if (map.has(termKey))
       return map.get(termKey);
-    const itemSelectorMap = new Map;
-    const selectorMapIndex = selector((get) => {
-      const ids = get(family);
-      ids.forEach((id) => {
-        if (itemSelectorMap.has(id))
-          return;
-        itemSelectorMap.set(id, selector((get2) => callback(get2(family(id)), term)));
-      });
-      return itemSelectorMap;
-    });
+    const termIndexSelectorSet = new Set;
+    const termIndexSelectorMap = new Map;
+    const termIndexSelector = selector((get) => {
+      const allFamilyAtoms = new Set(get(family));
+      const deletedAtoms = termIndexSelectorSet.symmetricDifference(allFamilyAtoms);
+      const addedAtoms = allFamilyAtoms.difference(termIndexSelectorSet);
+      if (deletedAtoms.size || addedAtoms.size) {
+        deletedAtoms.forEach((atom2) => {
+          termIndexSelectorSet.delete(atom2);
+          termIndexSelectorMap.delete(atom2);
+        });
+        addedAtoms.forEach((atom2) => {
+          termIndexSelectorSet.add(atom2);
+          termIndexSelectorMap.set(atom2, selector((get2) => callback(get2(atom2), term), {
+            name: `index:callback:selector:${atom2.name}`
+          }));
+        });
+      }
+      return termIndexSelectorSet;
+    }, { name: `index:${options?.name}:${termKey}` });
     const filteredSelector = selector((get) => {
-      const map2 = get(selectorMapIndex);
+      const set = get(termIndexSelector);
       const res = [];
-      map2.forEach((selector2, key) => {
-        if (get(selector2)) {
-          res.push(key);
+      set.forEach((atom2) => {
+        if (get(termIndexSelectorMap.get(atom2))) {
+          res.push(atom2);
         }
       });
       return res;
+    }, {
+      name: `index:${options?.name}:${termKey}:termSelector`
     });
     map.set(termKey, filteredSelector);
     return filteredSelector;
   };
+  return Object.assign(indexFn, {
+    map
+  });
 };
 // src/selectorFamily.ts
-var createOptions2 = (options = {}, family, familyKey, keyStringified) => {
+var createOptions2 = (options = {}, family, familyArgs, familyArgsStringified) => {
   if (options.name) {
     return {
       equal,
       ...options,
-      name: options?.name + "_" + keyStringified,
+      name: options?.name + "_" + familyArgsStringified,
       family,
-      familyKey
+      familyArgs,
+      familyArgsStringified
     };
   } else {
-    return { equal, ...options, family, familyKey };
+    return { equal, ...options, family, familyArgs, familyArgsStringified };
   }
 };
-var selectorFamily = (get, options) => {
+var selectorFamily = (callback, options) => {
   const map = new Map;
-  const selectorFamily2 = (key) => {
-    const keyStringified = stableStringify(key);
-    if (map.has(keyStringified))
-      return map.get(keyStringified);
-    const newSelector = selector((selectorArgs) => get(key)(selectorArgs), createOptions2(options, selectorFamily2, key, keyStringified));
-    map.set(keyStringified, newSelector);
+  const selectorFamily2 = (...args) => {
+    const argsStringified = stringifyFamilyArgs(args);
+    if (map.has(argsStringified))
+      return map.get(argsStringified);
+    const newSelector = selector((selectorArgs) => callback(...args)(selectorArgs), createOptions2(options, selectorFamily2, args, argsStringified));
+    map.set(argsStringified, newSelector);
     return newSelector;
   };
   selectorFamily2.__valdresSelectorFamilyMap = map;

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

@@ -1,4 +1,3 @@
-import type { AtomOptions } from "./types/AtomOptions";
-import type { FamilyKey } from "./types/FamilyKey";
 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>;
+import type { AtomOptions } from "./types/AtomOptions";
+export declare function atomFamily<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue?: AtomFamilyDefaultValue<Value, Args>, options?: AtomOptions<Value>): import(".").AtomFamily<Value, Args>;

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

@@ -1,4 +1,5 @@
 import type { AtomFamily } from "./types/AtomFamily";
-import type { FamilyKey } from "./types/FamilyKey";
 import type { Selector } from "./types/Selector";
-export declare const index: <T, K extends FamilyKey = FamilyKey, V = unknown>(family: AtomFamily<K, V>, callback: (value: V, term: T) => boolean) => ((term: T) => Selector<T[]>);
+export declare const index: <Term, Value extends unknown, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(family: AtomFamily<Value, FamilyArgs>, callback: (value: Value, term: Term) => boolean, options?: {
+    name?: string;
+}) => ((term: Term) => Selector<Term[]>);

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

@@ -2,7 +2,7 @@ import type { AtomDefaultValue } from "../types/AtomDefaultValue";
 import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
 import type { AtomFamilyGlobalAtom } from "../types/AtomFamilyGlobalAtom";
 import type { AtomOptions } from "../types/AtomOptions";
-export declare function atomFamilyAtom<Key, Value>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value> & {
+export declare function atomFamilyAtom<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value> & {
     global: true;
-}): AtomFamilyGlobalAtom<Key, Value>;
-export declare function atomFamilyAtom<Key, Value>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value>): AtomFamilyAtom<Key, Value>;
+}): AtomFamilyGlobalAtom<Value, Args>;
+export declare function atomFamilyAtom<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value>): AtomFamilyAtom<Value, Args>;

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

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

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

@@ -1,5 +1,4 @@
-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>;
+import type { AtomFamilyDefaultValue } from "../types/AtomFamilyDefaultValue";
+import type { AtomOptions } from "../types/AtomOptions";
+export declare const createGlobalAtomFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options: AtomOptions<Value>) => AtomFamily<Value, Args>;

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

@@ -0,0 +1,3 @@
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
+import type { StoreData } from "../types/StoreData";
+export declare const deleteFamilyAtom: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(atom: AtomFamilyAtom<Value, Args>, data: StoreData) => void;

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

@@ -2,6 +2,7 @@ import type { Atom } from "../types/Atom";
 import type { AtomFamily } from "../types/AtomFamily";
 import type { Selector } from "../types/Selector";
 import type { StoreData } from "../types/StoreData";
-export declare function getState<V, K>(atom: Atom<V>, data: StoreData, circularDependencySet?: WeakSet<Selector>): V;
-export declare function getState<V, K>(selector: Selector<V>, data: StoreData, circularDependencySet?: WeakSet<Selector>): V;
-export declare function getState<V, K>(family: AtomFamily<V, K>, data: StoreData, circularDependencySet?: WeakSet<Selector>): K[];
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
+export declare function getState<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(atom: Atom<Value>, data: StoreData, circularDependencySet?: WeakSet<Selector>): Value;
+export declare function getState<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(selector: Selector<Value>, data: StoreData, circularDependencySet?: WeakSet<Selector>): Value;
+export declare function getState<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(family: AtomFamily<Value, Args>, data: StoreData, circularDependencySet?: WeakSet<Selector>): AtomFamilyAtom<Value, Args>[];

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

@@ -2,4 +2,4 @@ import type { Atom } from "../types/Atom";
 import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
 import type { StoreData } from "../types/StoreData";
 export declare const getAtomInitValue: <V = any>(atom: Atom<V>, data: StoreData) => any;
-export declare const initAtom: <V, K>(atom: Atom<V> | AtomFamilyAtom<K, V>, data: StoreData) => V;
+export declare const initAtom: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(atom: Atom<Value> | AtomFamilyAtom<Value, Args>, data: StoreData) => any;

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

@@ -1,3 +1,3 @@
 import type { StoreData } from "../types/StoreData";
 import type { Selector } from "../types/Selector";
-export declare const initSelector: <V>(selector: Selector<V>, data: StoreData, circularDependencySet?: WeakSet<WeakKey>) => V | Promise<V>;
+export declare const initSelector: <V>(selector: Selector<V>, data: StoreData, circularDependencySet?: WeakSet<WeakKey>) => boolean;

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

@@ -1,4 +1,5 @@
 import type { Atom } from "../types/Atom";
-import type { StoreData } from "../types/StoreData";
+import type { AtomFamily } from "../types/AtomFamily";
 import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
-export declare const propagateUpdatedAtoms: (atoms: (Atom<any> | AtomFamilyAtom<any, any>)[], data: StoreData) => void;
+import type { StoreData } from "../types/StoreData";
+export declare const propagateUpdatedAtoms: (atoms: (Atom<any> | AtomFamilyAtom<any, any> | AtomFamily<any, any>)[], data: StoreData) => void;

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

@@ -1,3 +1,4 @@
 import type { Atom } from "../types/Atom";
+import type { AtomFamily } from "../types/AtomFamily";
 import type { StoreData } from "../types/StoreData";
-export declare const setValueInData: <Value = any>(atom: Atom<Value>, value: Value, data: StoreData) => Value;
+export declare const setValueInData: <Value extends unknown>(atom: Atom<Value> | AtomFamily<any, any>, value: Value, data: StoreData) => Value;

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

@@ -0,0 +1 @@
+export declare const stringifyFamilyArgs: (args: any[]) => string | number | boolean;

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

@@ -4,5 +4,5 @@ import type { TransactionFn } from "../types/TransactionFn";
 type GetAtomValue = {
     <V>(atom: Atom<V>): V;
 };
-export declare const transaction: (callback: TransactionFn, data: StoreData, autoCommit?: boolean, parentGetFromTxnOrData?: GetAtomValue) => any;
+export declare const transaction: (callback: TransactionFn, data: StoreData, autoCommit?: boolean, parentGetInTxnOrData?: GetAtomValue) => any;
 export {};

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

@@ -1,3 +1,3 @@
 import type { State } from "../types/State";
 import type { StoreData } from "../types/StoreData";
-export declare const updateStateSubscribers: <V>(state: State, data: StoreData) => void;
+export declare const updateStateSubscribers: (state: State, 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<Value>) => Selector<Value, FamilyKey>;
+export declare const selector: <Value extends unknown, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(get: (get: GetValue, storeId: string) => Value | Promise<Value>, options?: SelectorOptions<Value>) => Selector<Value, FamilyArgs>;

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

@@ -1,4 +1,4 @@
+import type { GetValue } from "./types/GetValue";
 import type { SelectorFamily } from "./types/SelectorFamily";
 import type { SelectorOptions } from "./types/SelectorOptions";
-import type { GetValue } from "./types/GetValue";
-export declare const selectorFamily: <Key, Value>(get: (key: Key) => (get: GetValue) => Value, options?: SelectorOptions<Value>) => SelectorFamily<Key, Value>;
+export declare const selectorFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(callback: (...args: Args) => (get: GetValue) => Value | Promise<Value>, options?: SelectorOptions<Value>) => SelectorFamily<Value, Args>;

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

@@ -1,12 +1,9 @@
-import type { Atom } from "./Atom";
 import type { AtomFamilyAtom } from "./AtomFamilyAtom";
-import type { FamilyKey } from "./FamilyKey";
-import type { Selector } from "./Selector";
-export type AtomFamily<Key = FamilyKey, Value = unknown> = {
-    (key: Key): AtomFamilyAtom<Key, Value>;
-    release: (key: Key) => void;
+import type { EqualFunc } from "./EqualFunc";
+export type AtomFamily<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]> = {
+    (...args: Args): AtomFamilyAtom<Value, Args>;
+    release: (...args: Args) => void;
+    equal: EqualFunc<Value>;
     name?: string;
-    __valdresAtomFamilyMap: Map<Key, AtomFamilyAtom<Key, Value>>;
-    __keysAtom: Atom<Set<Key>>;
-    __keysSelector: Selector<Key[]>;
+    __valdresAtomFamilyMap: Map<Value, AtomFamilyAtom<Value, Args>>;
 };

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

@@ -1,6 +1,7 @@
 import type { Atom } from "./Atom";
 import type { AtomFamily } from "./AtomFamily";
-export type AtomFamilyAtom<Key = unknown, Value = unknown> = Atom<Value> & {
-    family: AtomFamily<Key, Value>;
-    familyKey: Key;
+export type AtomFamilyAtom<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]> = Atom<Value> & {
+    family: AtomFamily<Value, Args>;
+    familyArgs: Args;
+    familyArgsStringified: string;
 };

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

@@ -1,5 +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>;
+type DefaultValueCallback<Value extends any, Args extends [any, ...any[]]> = (...args: Args) => Value | Promise<Value>;
+export type AtomFamilyDefaultValue<Value extends any, Args extends [any, ...any[]]> = undefined | Value | DefaultValueCallback<Value, Args> | Selector<Value, Args> | SelectorFamily<Value, Args>;
 export {};

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

@@ -1,3 +1,3 @@
 import type { AtomFamilyAtom } from "./AtomFamilyAtom";
 import type { GlobalAtom } from "./GlobalAtom";
-export type AtomFamilyGlobalAtom<Key = unknown, Value = unknown> = AtomFamilyAtom<Key, Value> & GlobalAtom<Value>;
+export type AtomFamilyGlobalAtom<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]> = AtomFamilyAtom<Value, Args> & GlobalAtom<Value>;

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

@@ -1,6 +1,6 @@
 import type { Selector } from "./Selector";
 import type { SelectorFamily } from "./SelectorFamily";
-export type AtomFamilySelector<Value = unknown, Key = unknown> = Selector<Value> & {
-    family: SelectorFamily<Key, Value>;
-    familyKey: Key;
+export type AtomFamilySelector<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]> = Selector<Value> & {
+    family: SelectorFamily<Value, Args>;
+    familyArgs: Args;
 };

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

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

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

@@ -1,3 +1,3 @@
 import type { SelectorFamily } from "./SelectorFamily";
 import type { AtomFamily } from "./AtomFamily";
-export type Family<Key, Value = any> = AtomFamily<Key, Value> | SelectorFamily<Key, Value>;
+export type Family<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]> = AtomFamily<Value, Args> | SelectorFamily<Value, Args>;

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

@@ -1,8 +1,9 @@
 import type { Atom } from "./Atom";
 import type { AtomFamily } from "./AtomFamily";
+import type { AtomFamilyAtom } from "./AtomFamilyAtom";
 import type { Selector } from "./Selector";
 export type GetValue = {
-    <V>(atom: Atom<V>): V;
-    <V>(selector: Selector<V>): V;
-    <V, K>(family: AtomFamily<K, V>): K[];
+    <Value extends any>(atom: Atom<Value>): Value;
+    <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(selector: Selector<Value, Args>): Value;
+    <Value extends any, Args extends [any, ...any[]]>(family: AtomFamily<Value, Args>): AtomFamilyAtom<Value, Args>[];
 };

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

@@ -1,11 +1,11 @@
 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;
+export type Selector<Value extends any = any, FamilyArgs extends [any, ...any[]] = [any, ...any[]]> = {
+    get: (get: GetValue, storeId: string) => Value | Promise<Value>;
     equal: EqualFunc<Value>;
     name?: string;
-    family?: SelectorFamily<FamilyKey, Value>;
-    familyKey?: FamilyKey;
+    family?: SelectorFamily<Value, FamilyArgs>;
+    familyArgs?: FamilyArgs;
     onMount?: () => void | (() => void);
 };

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

@@ -1,6 +1,5 @@
-import type { FamilyKey } from "./FamilyKey";
 import type { Selector } from "./Selector";
-export type SelectorFamily<Key = FamilyKey, Value = unknown> = {
-    (key: Key, defaultOverride?: any): Selector<Value>;
-    __valdresSelectorFamilyMap: Map<Key, Selector<Value, Key>>;
+export type SelectorFamily<Value extends any, Args extends [any, ...any[]]> = {
+    (...args: Args): Selector<Value, Args>;
+    __valdresSelectorFamilyMap: Map<Args, Selector<Value, Args>>;
 };

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

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

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

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

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

@@ -6,15 +6,17 @@ import type { ScopedStoreData, StoreData } from "./StoreData";
 import type { SubscribeFn } from "./SubscribeFn";
 import type { TransactionFn } from "./TransactionFn";
 type SetAtom = {
-    <V, K>(atom: AtomFamilyAtom<K, V>, value: V): void;
-    <V>(atom: Atom<V>, value: V): void;
+    <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(atom: AtomFamilyAtom<Value, Args>, value: Value): void;
+    <Value extends any>(atom: Atom<Value>, value: Value): void;
 };
+type DeleteAtom = <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(atom: AtomFamilyAtom<Value, Args>) => void;
 export type Store<T = StoreData> = {
     data: T;
     get: GetValue;
     set: SetAtom;
     sub: SubscribeFn;
     reset: ResetAtom;
+    delete: DeleteAtom;
     txn: (callback: TransactionFn) => void;
     scope: (scopeId: string) => ScopedStore;
 };

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

@@ -4,7 +4,7 @@ export type RootStoreData = {
     expiredValues: WeakMap<WeakKey, any>;
     subscriptions: WeakMap<WeakKey, Set<any>>;
     subscriptionsRequireEqualCheck: WeakMap<WeakKey, boolean>;
-    stateConsumers: WeakMap<WeakKey, any>;
+    stateDependents: WeakMap<WeakKey, any>;
     stateDependencies: WeakMap<WeakKey, any>;
     scopes: {
         [scopeId: string]: ScopedStoreData;

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

@@ -3,7 +3,7 @@ import type { Family } from "./Family";
 import type { Selector } from "./Selector";
 type UnsuscribeFn = () => void;
 export type SubscribeFn = {
-    <V, K>(state: Family<K, V>, callback: (arg: K) => void, requireDeepEqualCheckBeforeCallback?: boolean): UnsuscribeFn;
-    <V>(state: Atom<V> | Selector<V>, callback: () => void, requireDeepEqualCheckBeforeCallback?: boolean): UnsuscribeFn;
+    <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(state: Family<Value, Args>, callback: (...args: Args) => void, requireDeepEqualCheckBeforeCallback?: boolean): UnsuscribeFn;
+    <Value extends any>(state: Atom<Value> | Selector<Value>, callback: () => void, requireDeepEqualCheckBeforeCallback?: boolean): UnsuscribeFn;
 };
 export {};

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

@@ -1,4 +1,5 @@
 import type { Atom } from "./Atom";
+import type { AtomFamilyAtom } from "./AtomFamilyAtom";
 import type { GetValue } from "./GetValue";
 import type { ResetAtom } from "./ResetAtom";
 import type { SetAtom } from "./SetAtom";
@@ -10,6 +11,7 @@ export type SetAtom2 = {
 export type TransactionInterface = {
     set: SetAtom;
     get: GetValue;
+    del: (atom: AtomFamilyAtom<any, any>) => void;
     reset: ResetAtom;
     commit: () => void;
     scope: <Callback extends TransactionFn>(scopeId: string, callback: Callback) => ReturnType<Callback>;

package/dist/types/src/utils/isAtomFamily.d.ts

@@ -1,2 +1,2 @@
 import type { AtomFamily } from "../types/AtomFamily";
-export declare const isAtomFamily: <K, V>(state: any) => state is AtomFamily<K, V>;
+export declare const isAtomFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamily<Value, Args>;

package/dist/types/src/utils/isFamily.d.ts

@@ -1 +1 @@
-export declare const isFamily: (state: any) => state is import("..").SelectorFamily<unknown, unknown> | import("..").AtomFamily<unknown, unknown>;
+export declare const isFamily: (state: any) => state is import("..").SelectorFamily<unknown, [any, ...any[]]> | import("..").AtomFamily<unknown, [any, ...any[]]>;

package/dist/types/src/utils/isFamilyAtom.d.ts

@@ -1,2 +1,2 @@
 import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
-export declare const isFamilyAtom: <K, V>(state: any) => state is AtomFamilyAtom<K, V>;
+export declare const isFamilyAtom: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilyAtom<Value, Args>;

package/dist/types/src/utils/isFamilySelector.d.ts

@@ -1,2 +1,2 @@
 import type { AtomFamilySelector } from "../types/AtomFamilySelector";
-export declare const isFamilySelector: <K, V>(state: any) => state is AtomFamilySelector<K, V>;
+export declare const isFamilySelector: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilySelector<Value, Args>;

package/dist/types/src/utils/isFamilyState.d.ts

@@ -1,3 +1,3 @@
 import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
 import type { AtomFamilySelector } from "../types/AtomFamilySelector";
-export declare const isFamilyState: <K, V>(state: any) => state is AtomFamilyAtom<K, V> | AtomFamilySelector<K, V>;
+export declare const isFamilyState: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilyAtom<Value, Args> | AtomFamilySelector<Value, Args>;

package/dist/types/src/utils/isSelectorFamily.d.ts

@@ -1,2 +1,2 @@
 import type { SelectorFamily } from "../types/SelectorFamily";
-export declare const isSelectorFamily: <K, V>(state: any) => state is SelectorFamily<K, V>;
+export declare const isSelectorFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is SelectorFamily<Value, Args>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.74",
+    "version": "0.2.0-alpha.76",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
@@ -36,5 +36,5 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "bff29372cef5badd771e1cc9ea59f4b3fb8a5dc3"
+    "gitHead": "184b86a8548d25cb8df609184718cf62de9d97c8"
 }