valdres 0.2.0-pre.2 → 0.2.0-pre.20

package/dist/index.js

@@ -187,7 +187,7 @@ var isProd = () => {
 
 // src/lib/setValueInData.ts
 var setValueInData = (atom, value, data) => {
-  if (isProd()) {
+  if (atom.mutable || isProd()) {
     data.values.set(atom, value);
     return value;
   } else {
@@ -278,7 +278,7 @@ function getState(state, data, initializedAtomsSet, circularDependencySet) {
       const closestData = findClosestStoreWithAtomInitialized(state, data);
       return getState(state, closestData, initializedAtomsSet, circularDependencySet);
     }
-    data.values.set(state, []);
+    data.values.set(state, renderAtomFamilyIndex(createAtomFamilyIndex()));
     initializedAtomsSet.add(state);
     return data.values.get(state);
   }
@@ -422,30 +422,140 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var findClosestStoreWithAtomInitialized2 = (atom, data) => {
-  if ("parent" in data === false)
-    return data;
-  if (data.values.has(atom))
-    return data;
-  return findClosestStoreWithAtomInitialized2(atom, data.parent);
+var getAtomFamilyRenderedMap = (index) => {
+  if (index.rendered)
+    return index.rendered;
+  const result = new Map(index.parentIndex ? getAtomFamilyRenderedMap(index.parentIndex) : undefined);
+  for (const [atom, timestamp] of index.created) {
+    result.set(atom, timestamp);
+  }
+  for (const [atom, timestamp] of index.deleted) {
+    result.delete(atom, timestamp);
+  }
+  index.rendered = result;
+  return result;
 };
-var findInClosestStore = (state, data) => {
-  const store = findClosestStoreWithAtomInitialized2(state, data);
-  return store.values.get(state);
+var getSortedKeysByValues = (map) => {
+  return Array.from(map.entries()).sort((a, b) => a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0).map((entry) => entry[0]);
 };
-var addFamilyAtomsToSet = (family, familyAtoms, data) => {
-  const currentAtoms = findInClosestStore(family, data) || [];
-  const atomsToAdd = [];
-  for (const familyAtom of familyAtoms) {
-    if (!currentAtoms.includes(familyAtom)) {
-      atomsToAdd.push(familyAtom);
+var renderAtomFamilyIndex = (index) => {
+  if (index.renderedArray) {
+    console.log("Using cached rendered array");
+    return index.renderedArray;
+  }
+  const renderedMap = getAtomFamilyRenderedMap(index);
+  const array = getSortedKeysByValues(renderedMap);
+  array.__index = index;
+  index.renderedArray = array;
+  return array;
+};
+var cloneAtomFamilyIndex = (index, parentIndexOverride) => {
+  return {
+    created: new Map(index.created),
+    deleted: new Map(index.deleted),
+    rendered: null,
+    renderedArray: null,
+    parentIndex: parentIndexOverride || index.parentIndex
+  };
+};
+var createAtomFamilyIndex = (parentIndex) => {
+  return {
+    created: new Map,
+    deleted: new Map,
+    rendered: null,
+    renderedArray: null,
+    parentIndex
+  };
+};
+var deleteFamilyAtomsFromSet = (family, familyAtoms, data, timestamp) => {
+  if (familyAtoms.size === 0)
+    return;
+  const index = findFamilyIndex(family, data);
+  for (const atom of familyAtoms) {
+    index.deleted.set(atom, timestamp);
+  }
+  index.rendered = null;
+  index.renderedArray = null;
+  data.values.set(family, renderAtomFamilyIndex(index));
+  recursivlyUpdateIndexes(data, family);
+};
+var initFamilyIndex = (family, data) => {
+  if (data.values.has(family))
+    return data.values.get(family).__index;
+  let parentIndex;
+  if ("parent" in data) {
+    parentIndex = initFamilyIndex(family, data.parent);
+    if (!parentIndex)
+      throw new Error("Parent index is missing");
+  }
+  const index = createAtomFamilyIndex(parentIndex);
+  data.values.set(family, renderAtomFamilyIndex(index));
+  return index;
+};
+var findFamilyIndex = (family, data) => {
+  if (!data.values.has(family)) {
+    initFamilyIndex(family, data);
+  }
+  const value = data.values.get(family);
+  if (!value?.__index) {
+    console.log("value", value);
+    throw new Error("Family index is missing");
+  }
+  return value.__index;
+};
+var recursivlyUpdateIndexes = (data, family) => {
+  Object.keys(data.scopes).forEach((scopeKey) => {
+    const scopedData = data.scopes[scopeKey];
+    if (scopeKey) {
+      if (scopedData.values.has(family)) {
+        const index = scopedData.values.get(family).__index;
+        index.rendered = null;
+        index.renderedArray = null;
+        scopedData.values.set(family, renderAtomFamilyIndex(index));
+      }
+      recursivlyUpdateIndexes(scopedData, family);
+    }
+  });
+};
+var addFamilyAtomsToSet = (family, familyAtoms, data, timestamp) => {
+  if (familyAtoms.size === 0)
+    return;
+  const index = findFamilyIndex(family, data);
+  if (!index)
+    throw new Error("index not found");
+  for (const atom of familyAtoms) {
+    index.created.set(atom, timestamp);
+    index.deleted.delete(atom);
+  }
+  index.rendered = null;
+  index.renderedArray = null;
+  data.values.set(family, renderAtomFamilyIndex(index));
+  recursivlyUpdateIndexes(data, family);
+};
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now()) => {
+  const selectors = new Set;
+  for (const atom of atoms) {
+    addSetToSet(data.stateDependents.get(atom), selectors);
+    addSetToSet(data.subscriptions.get(atom), subscriptions);
+    if (isFamilyAtom(atom)) {
+      if (!families.has(atom.family)) {
+        families.set(atom.family, new Set);
+      }
+      families.get(atom.family).add(atom);
     }
   }
-  if (atomsToAdd.length > 0) {
-    data.values.set(family, [...currentAtoms, ...atomsToAdd]);
+  if (families.size > 0) {
+    for (const [family, familyAtoms] of families) {
+      addSetToSet(data.stateDependents.get(family), selectors);
+      addSetToSet(data.subscriptions.get(family), subscriptions);
+      if (familyAtoms.size === 0)
+        throw new Error("Should not be possible");
+      deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
+    }
   }
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
 };
-var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = new Map, isRecursive = false) => {
+var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = new Map, isRecursive = false, timestamp = performance.now()) => {
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
@@ -463,7 +573,7 @@ var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = ne
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
         throw new Error("Should not be possible");
-      addFamilyAtomsToSet(family, familyAtoms, data);
+      addFamilyAtomsToSet(family, familyAtoms, data, timestamp);
     }
   }
   if (!isRecursive) {
@@ -496,18 +606,6 @@ var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, fam
     }
   }
 };
-var findAllDependents = (selector, data, depsRes = new Set, subsRes = new Set) => {
-  const dependents = data.stateDependents.get(selector);
-  const subscriptions = data.subscriptions.get(selector);
-  addSetToSet(dependents, depsRes);
-  addSetToSet(subscriptions, subsRes);
-  if (dependents && dependents.size > 0) {
-    for (const dependent of dependents) {
-      findAllDependents(dependent, data, depsRes, subsRes);
-    }
-  }
-  return [depsRes, subsRes];
-};
 var recursivlyHandleSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, seen = new Set) => {
   const selectorsForNextPass = new Set;
   for (const selector of selectors) {
@@ -523,23 +621,10 @@ var recursivlyHandleSelectorUpdates = (selectors, data, collectedSubscribers, up
       data.values.delete(selector);
     } else {
       const [wasValueUpdated, didEvalCrash, error] = reEvaluteSelector(selector, data, updatedInitializedAtoms);
-      if (didEvalCrash) {
-        const [deps, subs] = findAllDependents(selector, data);
-        if (deps.size > 0) {
-          for (const dep of deps) {
-            data.expiredValues.set(dep, data.values.get(dep));
-            data.values.delete(dep);
-          }
-        }
-        if (subs.size > 0) {
-          addSetToSet(subs, collectedSubscribers);
-        }
-      } else {
-        if (!wasValueUpdated)
-          continue;
-        addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
-        addSetToSet(subscribers, collectedSubscribers);
-      }
+      if (!wasValueUpdated)
+        continue;
+      addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
+      addSetToSet(subscribers, collectedSubscribers);
     }
   }
   if (selectorsForNextPass.size > 0) {
@@ -575,16 +660,8 @@ 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);
+  propagateDeletedAtoms([atom], data);
 };
 
 // src/lib/resetAtom.ts
@@ -744,6 +821,8 @@ var setAtoms = (pairs, data, initializedAtomsSet) => {
       value = setValueInData(atom, value, data);
       if (atom.onSet)
         atom.onSet(value, data);
+    } else {
+      setValueInData(atom, value, data);
     }
   }
   const result = new Set([...updatedAtoms, ...initializedAtomsSet]);
@@ -753,174 +832,238 @@ var setAtoms = (pairs, data, initializedAtomsSet) => {
 };
 
 // src/lib/transaction.ts
-var findDependencies = (state, data, result = new Set) => {
-  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 recursivlyResetTxnSelectorCache = (state, txnSubscribers, txnSelectorCache) => {
-  for (const dep of txnSubscribers.get(state)) {
-    txnSelectorCache.delete(dep);
-    if (txnSubscribers.get(dep)?.size) {
-      recursivlyResetTxnSelectorCache(dep, txnSubscribers, txnSelectorCache);
-    }
-  }
-};
-var captureScopedTransaction = (scopedData, parentGetInTxnOrData) => {
-  let txn;
-  transaction((scopedTxn) => {
-    txn = scopedTxn;
-  }, scopedData, false, parentGetInTxnOrData);
-  return txn;
-};
 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 getInTxnOrData = (state) => {
-    if (txnAtomMap.has(state)) {
-      return txnAtomMap.get(state);
+
+class Transaction {
+  data;
+  parentTransaction;
+  dirty;
+  _scopedTransactions;
+  _initializedAtomsSet;
+  _deleteSet;
+  _selectorDependencies;
+  _selectorCache;
+  _atomMap;
+  constructor(data, parentTransaction, childTransaction) {
+    this.data = data;
+    this.parentTransaction = parentTransaction;
+    this.dirty = false;
+    if (childTransaction) {
+      this._scopedTransactions = new Map([
+        [childTransaction.data.id, childTransaction]
+      ]);
+    }
+  }
+  valueFromTxnOrData = (state) => {
+    if (this.atomMap.has(state)) {
+      return this.atomMap.get(state);
     }
-    if (data.values.has(state)) {
-      return data.values.get(state);
+    if (this.data.values.has(state)) {
+      return this.data.values.get(state);
     }
-    if (parentGetInTxnOrData) {
-      return parentGetInTxnOrData(state);
+    if (this.parentTransaction) {
+      return this.parentTransaction.valueFromTxnOrData(state);
     }
   };
-  const initializedAtomsSet = new Set;
-  const txnGet = (state) => {
-    if (isAtom(state)) {
-      const value = getInTxnOrData(state);
+  get = (state) => {
+    if (isAtom(state) || isAtomFamily(state)) {
+      const value = this.valueFromTxnOrData(state);
       if (value)
         return value;
-      return getState(state, data, initializedAtomsSet);
+      return getState(state, this.data, this.initializedAtomsSet);
     } else if (isSelector(state)) {
-      if (txnSelectorCache.has(state)) {
-        return txnSelectorCache.get(state);
+      if (this.dirty) {
+        this.selectorCache.clear();
+        this.selectorDependencies.clear();
+        this.dirty = false;
+      } else if (this.selectorCache.has(state)) {
+        return this.selectorCache.get(state);
       }
-      const deps = new Set;
       const res = state.get((s) => {
-        deps.add(s);
-        return txnGet(s);
-      }, data.id);
-      for (const dep of deps) {
-        if (!txnSubscribers.has(dep)) {
-          txnSubscribers.set(dep, new Set);
+        if (!this.selectorDependencies.has(s)) {
+          this.selectorDependencies.add(s);
         }
-        txnSubscribers.get(dep).add(state);
-      }
-      txnSelectorCache.set(state, res);
+        return this.get(s);
+      }, this.data.id);
+      this.selectorCache.set(state, res);
       return res;
-    } else if (isAtomFamily(state)) {
-      const value = getInTxnOrData(state);
-      if (value)
-        return value;
-      return getState(state, data, initializedAtomsSet);
     } else {
       throw new Error("Unsupported state");
     }
   };
-  const txnSet = (atom, value) => {
+  set = (atom, value) => {
     if (!isAtom(atom))
       throw new Error("Not an atom");
     if (isFunction(value)) {
-      const currentValue = txnGet(atom);
+      const currentValue = this.get(atom);
       value = value(currentValue);
     }
-    for (const selector of findDependencies(atom, data)) {
-      dirtySelectors.add(selector);
-      txnSelectorCache.delete(selector);
-    }
-    if (txnSubscribers.get(atom)?.size) {
-      recursivlyResetTxnSelectorCache(atom, txnSubscribers, txnSelectorCache);
-    }
     if (isProd()) {
-      txnAtomMap.set(atom, value);
+      this.atomMap.set(atom, value);
     } else {
-      txnAtomMap.set(atom, deepFreeze(value));
+      this.atomMap.set(atom, deepFreeze(value));
     }
+    if (!this.dirty)
+      this.dirty = true;
     if (isFamilyAtom(atom)) {
-      const currentFamilyList = txnGet(atom.family);
-      if (!currentFamilyList.includes(atom)) {
-        const newArr = [...currentFamilyList, atom];
-        txnAtomMap.set(atom.family, newArr);
+      if (!this.atomMap.has(atom.family)) {
+        this.cloneFamilyIntoTxn(atom.family);
       }
+      const index = this.atomMap.get(atom.family).__index;
+      index.created.set(atom, performance.now());
+      index.deleted.delete(atom);
+      index.rendered = null;
+      index.renderedArray = null;
+      this.recursivlyUpdateAtomFamilyIndexes(atom.family);
     }
     return value;
   };
-  const txnReset = (atom) => {
-    const value = getAtomInitValue(atom, data, initializedAtomsSet);
-    txnAtomMap.set(atom, value);
-    return value;
+  batchSetFamilyAtoms = (family, pairs) => {
+    if (!this.atomMap.has(family)) {
+      this.cloneFamilyIntoTxn(family);
+    }
+    const index = this.atomMap.get(family).__index;
+    for (const [atom, value] of pairs) {
+      if (atom.family !== family) {
+        throw new Error("Atom does not belong to the provided family");
+      }
+      index.created.set(atom, performance.now());
+      if (index.deleted.has(atom))
+        index.deleted.delete(atom);
+      this.atomMap.set(atom, value);
+    }
+    index.rendered = null;
+    index.renderedArray = null;
+    this.recursivlyUpdateAtomFamilyIndexes(family);
+  };
+  del = (atom) => {
+    if (!this.atomMap.has(atom.family)) {
+      this.cloneFamilyIntoTxn(atom.family);
+    }
+    const index = this.atomMap.get(atom.family).__index;
+    index.created.delete(atom);
+    index.deleted.set(atom, performance.now());
+    index.rendered = null;
+    index.renderedArray = null;
+    this.atomMap.set(atom.family, renderAtomFamilyIndex(index));
+    this.recursivlyUpdateAtomFamilyIndexes(atom.family);
+    if (this.data.values.has(atom)) {
+      this.deleteSet.add(atom);
+    }
+    if (this.atomMap.has(atom)) {
+      this.atomMap.delete(atom);
+    }
+  };
+  scope = (scopeId, callback) => {
+    if (scopeId in this.data.scopes) {
+      return this.scopedTransaction(scopeId).execute(callback, false);
+    } else {
+      throw new Error(`Scope '${scopeId}' not found. Registered scopes: ${Object.keys(this.data.scopes).join(", ")}`);
+    }
   };
-  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);
+  parentScope = (callback) => {
+    if (!this.parentTransaction) {
+      this.parentTransaction = new Transaction(this.data.parent, undefined, this);
     }
-    if (txnAtomMap.has(atom)) {
-      txnAtomMap.delete(atom);
+    return this.parentTransaction.execute(callback, false);
+  };
+  reset = (atom) => {
+    const value = getAtomInitValue(atom, this.data, this.initializedAtomsSet);
+    this.atomMap.set(atom, value);
+    return value;
+  };
+  execute = (callback, autoCommit = true) => {
+    const result = callback(this);
+    if (autoCommit)
+      this.txnCommit();
+    return result;
+  };
+  txnCommit = () => {
+    if (this.parentTransaction) {
+      this.parentTransaction.txnCommit();
+    } else {
+      this.commit();
     }
   };
-  const commit = () => {
-    setAtoms(txnAtomMap, data, initializedAtomsSet);
-    if (txnAtomDeleteSet.size) {
-      deleteAtomFamilyAtoms(txnAtomDeleteSet, data);
+  commit = () => {
+    const initializedAtomsSet = new Set;
+    setAtoms(this.atomMap, this.data, initializedAtomsSet);
+    if (this.deleteSet?.size) {
+      deleteAtomFamilyAtoms(this.deleteSet, this.data);
     }
-    dirtySelectors.clear();
-    if (scopedTransactions) {
-      for (const scopedTxn of Object.values(scopedTransactions)) {
+    if (this._scopedTransactions) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
         scopedTxn.commit();
       }
     }
   };
-  const result = callback({
-    set: txnSet,
-    get: txnGet,
-    del: txnDel,
-    reset: txnReset,
-    commit,
-    scope: (scopeId, callback2) => {
-      if (scopeId in data.scopes) {
-        const scopedData = data.scopes[scopeId];
-        if (scopedTransactions === undefined) {
-          scopedTransactions = {};
-        }
-        if (scopedTransactions[scopeId] === undefined) {
-          scopedTransactions[scopeId] = captureScopedTransaction(scopedData, getInTxnOrData);
-        }
-        return callback2(scopedTransactions[scopeId]);
-      } else {
-        throw new Error(`Scope '${scopeId}' not found. Registered scopes: ${Object.keys(data.scopes).join(", ")}`);
+  get atomMap() {
+    if (!this._atomMap)
+      this._atomMap = new Map;
+    return this._atomMap;
+  }
+  get selectorCache() {
+    if (!this._selectorCache)
+      this._selectorCache = new Map;
+    return this._selectorCache;
+  }
+  get selectorDependencies() {
+    if (!this._selectorDependencies)
+      this._selectorDependencies = new Set;
+    return this._selectorDependencies;
+  }
+  get deleteSet() {
+    if (!this._deleteSet)
+      this._deleteSet = new Set;
+    return this._deleteSet;
+  }
+  get initializedAtomsSet() {
+    if (!this._initializedAtomsSet)
+      this._initializedAtomsSet = new Set;
+    return this._initializedAtomsSet;
+  }
+  scopedTransaction(scopeId) {
+    if (!this._scopedTransactions)
+      this._scopedTransactions = new Map;
+    if (!this._scopedTransactions.has(scopeId)) {
+      const scopedData = this.data.scopes[scopeId];
+      const scopedTransaction = new Transaction(scopedData, this);
+      this._scopedTransactions.set(scopeId, scopedTransaction);
+    }
+    return this._scopedTransactions.get(scopeId);
+  }
+  cloneFamilyIntoTxn(family, parentIndex, moveUpIfParent = true) {
+    if (moveUpIfParent && this.parentTransaction)
+      return this.parentTransaction.cloneFamilyIntoTxn(family, parentIndex, moveUpIfParent);
+    const currentFamilyList = this.get(family);
+    const clonedIndex = cloneAtomFamilyIndex(currentFamilyList.__index, parentIndex);
+    if (this._scopedTransactions?.size) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
+        scopedTxn.cloneFamilyIntoTxn(family, clonedIndex, false);
       }
-    },
-    data
-  });
-  if (autoCommit)
-    commit();
-  return result;
+    }
+    this.atomMap.set(family, renderAtomFamilyIndex(clonedIndex));
+  }
+  recursivlyUpdateAtomFamilyIndexes(atomFamily) {
+    const currentIndex = this.atomMap.get(atomFamily).__index;
+    currentIndex.rendered = null;
+    currentIndex.renderedArray = null;
+    const updatedValue = renderAtomFamilyIndex(currentIndex);
+    this.atomMap.set(atomFamily, updatedValue);
+    if (this._scopedTransactions?.size) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
+        scopedTxn.recursivlyUpdateAtomFamilyIndexes(atomFamily);
+      }
+    }
+  }
+}
+var transaction = (callback, data) => {
+  const txn = new Transaction(data);
+  return txn.execute(callback);
 };
 
 // src/lib/storeFromStoreData.ts
@@ -963,7 +1106,10 @@ function storeFromStoreData(data, detach) {
       scopedStoreData.scopeConsumers.delete(detach2);
       if (scopedStoreData.scopeConsumers.size === 0) {
         delete data.scopes[scopeId];
+        return true;
       }
+      console.warn(`Scope ${scopeId} still has ${scopedStoreData.scopeConsumers.size} consumers, will not detach`);
+      return false;
     };
     scopedStoreData.scopeConsumers.add(detach2);
     const newStore = storeFromStoreData(data.scopes[scopeId], detach2);
@@ -1326,9 +1472,9 @@ var isFamilySelector = (state) => isFamilyState(state) && isSelector(state);
 
 // src/index.ts
 if (globalThis.__valdres__) {
-  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"0.2.0-pre.2"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"0.2.0-pre.20"}`);
 } else {
-  globalThis.__valdres__ = "0.2.0-pre.2";
+  globalThis.__valdres__ = "0.2.0-pre.20";
 }
 export {
   store,

package/dist/types/index.d.ts

@@ -34,3 +34,4 @@ export type { Store } from "./types/Store";
 export type { StoreData } from "./types/StoreData";
 export type { TransactionFn } from "./types/TransactionFn";
 export type { TransactionInterface } from "./types/TransactionInterface";
+export type { Transaction } from "./lib/transaction";

package/dist/types/indexConstructor.d.ts

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

package/dist/types/lib/createGlobalAtomFamily.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 createGlobalAtomFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options: AtomOptions<Value>) => AtomFamily<Value, Args>;
+export declare const createGlobalAtomFamily: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options: AtomOptions<Value>) => AtomFamily<Value, Args>;

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

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

package/dist/types/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, initializedAtomsSet: Set<Atom>) => any;
-export declare const initAtom: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(atom: Atom<Value> | AtomFamilyAtom<Value, Args>, data: StoreData, initializedAtomsSet: Set<Atom>) => void;
+export declare const initAtom: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(atom: Atom<Value> | AtomFamilyAtom<Value, Args>, data: StoreData, initializedAtomsSet: Set<Atom>) => void;

package/dist/types/lib/isFunction.d.ts

@@ -1 +1 @@
-export declare const isFunction: (value: unknown) => value is Function;
+export declare const isFunction: (value: any) => value is Function;

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

@@ -5,6 +5,21 @@ import type { Family } from "../types/Family";
 import type { Selector } from "../types/Selector";
 import type { StoreData } from "../types/StoreData";
 import type { Subscription } from "../types/Subscription";
-export declare const addFamilyAtomsToSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData) => void;
-export declare const propagateUpdatedAtoms: (atoms: (Atom<any> | AtomFamilyAtom<any, any> | AtomFamily<any, any>)[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isRecursive?: boolean) => void;
+export declare const renderAtomFamilyIndex: (index: AtomFamilyIndex) => unknown[];
+type AtomFamilyIndex = {
+    created: Map<AtomFamilyAtom<any, any>, Number>;
+    deleted: Map<AtomFamilyAtom<any, any>, Number>;
+    rendered: Map<AtomFamilyAtom<any, any>, Number> | null;
+    renderedArray: (AtomFamilyAtom<any, any>[] & {
+        __index: AtomFamilyIndex;
+    }) | null;
+    parentIndex?: AtomFamilyIndex;
+};
+export declare const cloneAtomFamilyIndex: (index: AtomFamilyIndex, parentIndexOverride?: AtomFamilyIndex) => AtomFamilyIndex;
+export declare const createAtomFamilyIndex: (parentIndex?: AtomFamilyIndex) => AtomFamilyIndex;
+export declare const deleteFamilyAtomsFromSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData, timestamp: number) => void;
+export declare const addFamilyAtomsToSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData, timestamp: Number) => void;
+export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, timestamp?: number) => void;
+export declare const propagateUpdatedAtoms: (atoms: (Atom<any> | AtomFamilyAtom<any, any> | AtomFamily<any, any>)[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isRecursive?: boolean, timestamp?: number) => void;
 export declare const propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>) => void;
+export {};

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

@@ -1,8 +1,37 @@
 import type { Atom } from "../types/Atom";
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
+import type { GetValue } from "../types/GetValue";
 import type { StoreData } from "../types/StoreData";
 import type { TransactionFn } from "../types/TransactionFn";
-type GetAtomValue = {
-    <V>(atom: Atom<V>): V;
-};
-export declare const transaction: (callback: TransactionFn, data: StoreData, autoCommit?: boolean, parentGetInTxnOrData?: GetAtomValue) => any;
-export {};
+export declare class Transaction {
+    data: StoreData;
+    parentTransaction: Transaction | undefined;
+    dirty: boolean;
+    private _scopedTransactions;
+    private _initializedAtomsSet;
+    private _deleteSet;
+    private _selectorDependencies;
+    private _selectorCache;
+    private _atomMap;
+    constructor(data: StoreData, parentTransaction?: Transaction, childTransaction?: Transaction);
+    private valueFromTxnOrData;
+    get: GetValue;
+    set: <V>(atom: Atom<V>, value: V | ((currentValue: V) => V)) => V;
+    batchSetFamilyAtoms: (family: any, pairs: any) => void;
+    del: (atom: AtomFamilyAtom<any, any>) => void;
+    scope: (scopeId: string, callback: (txn: Transaction) => any) => any;
+    parentScope: (callback: (txn: Transaction) => any) => any;
+    reset: (atom: Atom) => any;
+    execute: (callback: TransactionFn, autoCommit?: boolean) => any;
+    private txnCommit;
+    commit: () => void;
+    private get atomMap();
+    private get selectorCache();
+    private get selectorDependencies();
+    private get deleteSet();
+    private get initializedAtomsSet();
+    private scopedTransaction;
+    private cloneFamilyIntoTxn;
+    private recursivlyUpdateAtomFamilyIndexes;
+}
+export declare const transaction: (callback: TransactionFn, data: StoreData) => any;

package/dist/types/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 extends unknown, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(get: (get: GetValue, storeId: string) => Value | Promise<Value>, options?: SelectorOptions<Value>) => Selector<Value, FamilyArgs>;
+export declare const selector: <Value extends any, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(get: (get: GetValue, storeId: string) => Value | Promise<Value>, options?: SelectorOptions<Value>) => Selector<Value, FamilyArgs>;

package/dist/types/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";
-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>;
+export declare const selectorFamily: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(callback: (...args: Args) => (get: GetValue) => Value | Promise<Value>, options?: SelectorOptions<Value>) => SelectorFamily<Value, Args>;

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

@@ -10,5 +10,6 @@ export type Atom<Value = unknown> = {
     onSet?: AtomOnSet<Value>;
     onMount?: () => void | (() => void);
     maxAge?: number;
+    mutable?: boolean;
     staleWhileRevalidate?: number;
 };

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

@@ -5,5 +5,6 @@ export type AtomFamily<Value extends any, Args extends [any, ...any[]] = [any, .
     release: (...args: Args) => void;
     equal: EqualFunc<Value>;
     name?: string;
+    mutable?: boolean;
     __valdresAtomFamilyMap: Map<Value, AtomFamilyAtom<Value, Args>>;
 };

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

@@ -8,6 +8,7 @@ export type AtomOptions<Value = unknown> = {
     onSet?: AtomOnSet<Value>;
     onMount?: () => () => void;
     maxAge?: number;
+    mutable?: boolean;
     staleWhileRevalidate?: number;
     equal?: EqualFunc<Value>;
 };

package/dist/types/types/TransactionFn.d.ts

@@ -1,2 +1,2 @@
-import type { TransactionInterface } from "./TransactionInterface";
-export type TransactionFn = (args: TransactionInterface) => any;
+import type { Transaction } from "../lib/transaction";
+export type TransactionFn = (args: Transaction) => any;

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

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

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

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

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

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

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

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

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

@@ -1,2 +1,2 @@
 import type { SelectorFamily } from "../types/SelectorFamily";
-export declare const isSelectorFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is SelectorFamily<Value, Args>;
+export declare const isSelectorFamily: <Value extends any, 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-pre.2",
+    "version": "0.2.0-pre.20",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"