valdres 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/index.js

@@ -97,10 +97,10 @@ var equal = (a, b, updatedAtomsSet) => {
 };
 
 // src/utils/isAtom.ts
-var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+var isAtom = (state) => state && Object.hasOwn(state, "defaultValue");
 
 // src/utils/isGlobalAtom.ts
-var isGlobalAtom = (state) => Object.hasOwn(state, "stores");
+var isGlobalAtom = (state) => state && Object.hasOwn(state, "stores");
 
 // src/utils/isSelector.ts
 var isSelector = (state) => state && Object.hasOwn(state, "get");
@@ -628,6 +628,14 @@ var evaluate = (selector, data, initializedAtomsSet, circularDependencySet) => {
 };
 
 // src/lib/propagateUpdatedAtoms.ts
+var notifyEntryFor = (notify, data) => {
+  let entry = notify.get(data);
+  if (entry === undefined) {
+    entry = { subscriptions: new Set, families: new Map };
+    notify.set(data, entry);
+  }
+  return entry;
+};
 var reEvaluateSelector = (selector, data, updatedAtoms, depsChange, existingValue) => {
   try {
     const rawValue = evaluateSelector(selector, data, updatedAtoms, undefined, depsChange);
@@ -674,6 +682,35 @@ var callSubscribers = (subscriptions, families) => {
   if (hasError)
     throw firstError;
 };
+var notifyDeferred = (notify) => {
+  let firstError;
+  let hasError = false;
+  for (const entry of notify.values()) {
+    if (entry.subscriptions.size > 0) {
+      try {
+        callSubscribers(entry.subscriptions, entry.families);
+      } catch (error) {
+        if (!hasError) {
+          firstError = error;
+          hasError = true;
+        }
+      }
+    }
+  }
+  if (hasError)
+    throw firstError;
+};
+var collectFamilyAtomsForNotify = (entry, changedByFamily) => {
+  for (const [family, atoms] of changedByFamily) {
+    let target = entry.families.get(family);
+    if (target === undefined) {
+      target = new Set;
+      entry.families.set(family, target);
+    }
+    for (const atom of atoms)
+      target.add(atom);
+  }
+};
 var addSetToSet = (fromSet, toSet) => {
   if (fromSet && fromSet.size > 0) {
     for (const item of fromSet) {
@@ -681,20 +718,24 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now(), evaluatedSelectors) => {
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, deletedFamilyAtoms = new Map, timestamp = performance.now(), notify) => {
+  const notifyEntry = notify ? notifyEntryFor(notify, data) : undefined;
+  if (notifyEntry) {
+    subscriptions = notifyEntry.subscriptions;
+  }
   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);
+      if (!deletedFamilyAtoms.has(atom.family)) {
+        deletedFamilyAtoms.set(atom.family, new Set);
       }
-      families.get(atom.family).add(atom);
+      deletedFamilyAtoms.get(atom.family).add(atom);
     }
   }
-  if (families.size > 0) {
-    for (const [family, familyAtoms] of families) {
+  if (deletedFamilyAtoms.size > 0) {
+    for (const [family, familyAtoms] of deletedFamilyAtoms) {
       addSetToSet(data.stateDependents.get(family), selectors);
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
@@ -702,10 +743,12 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, false, evaluatedSelectors);
-  if (families.size > 0 && data.scopes && data.scopes.size > 0) {
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, deletedFamilyAtoms, false, notify);
+  if (notifyEntry)
+    collectFamilyAtomsForNotify(notifyEntry, deletedFamilyAtoms);
+  if (deletedFamilyAtoms.size > 0 && data.scopes && data.scopes.size > 0) {
     const scopeFamilies = new Map;
-    for (const family of families.keys()) {
+    for (const family of deletedFamilyAtoms.keys()) {
       const scopesWithFamily = data.scopeValueIndex.get(family);
       if (scopesWithFamily) {
         for (const scope of scopesWithFamily) {
@@ -719,11 +762,11 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       }
     }
     for (const [scope, familiesInScope] of scopeFamilies) {
-      propagateInScope(familiesInScope, scope, false, evaluatedSelectors);
+      propagateInScope(familiesInScope, scope, false, notify);
     }
   }
 };
-var propagateAtomUpdate = (atoms, data, isInitOnly = false, evaluatedSelectors) => {
+var propagateAtomUpdate = (atoms, data, isInitOnly = false, notify) => {
   if (atoms.length === 1) {
     const atom = atoms[0];
     if (!isFamilyAtom(atom) && !isAtomFamily(atom)) {
@@ -731,28 +774,32 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false, evaluatedSelectors)
       if ((!dependents || dependents.size === 0) && (!data.scopes || data.scopes.size === 0)) {
         const subs = data.subscriptions.get(atom);
         if (subs && subs.size > 0) {
-          callSubscribers(subs);
+          if (notify)
+            addSetToSet(subs, notifyEntryFor(notify, data).subscriptions);
+          else
+            callSubscribers(subs);
         }
         return;
       }
     }
   }
-  const subscriptions = new Set;
-  const families = new Map;
+  const notifyEntry = notify ? notifyEntryFor(notify, data) : undefined;
+  const subscriptions = notifyEntry ? notifyEntry.subscriptions : new Set;
+  const updatedFamilyAtoms = new Map;
   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);
+      if (!updatedFamilyAtoms.has(atom.family)) {
+        updatedFamilyAtoms.set(atom.family, new Set);
       }
-      families.get(atom.family).add(atom);
+      updatedFamilyAtoms.get(atom.family).add(atom);
     }
   }
-  if (families.size > 0) {
+  if (updatedFamilyAtoms.size > 0) {
     const timestamp = performance.now();
-    for (const [family, familyAtoms] of families) {
+    for (const [family, familyAtoms] of updatedFamilyAtoms) {
       addSetToSet(data.stateDependents.get(family), selectors);
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
@@ -762,35 +809,37 @@ var propagateAtomUpdate = (atoms, data, isInitOnly = false, evaluatedSelectors)
   }
   if (data.scopes && data.scopes.size > 0) {
     for (const atom of atoms) {
-      if (isAtomFamily(atom) && !families.has(atom)) {
+      if (isAtomFamily(atom) && !updatedFamilyAtoms.has(atom)) {
         recursivelyUpdateIndexes(data, atom);
       }
     }
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, evaluatedSelectors);
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, updatedFamilyAtoms, isInitOnly, notify);
+  if (notifyEntry)
+    collectFamilyAtomsForNotify(notifyEntry, updatedFamilyAtoms);
   if (data.scopes && data.scopes.size > 0) {
-    propagateToScopes(atoms, data, isInitOnly, evaluatedSelectors);
+    propagateToScopes(atoms, data, isInitOnly, notify);
   }
 };
-var propagateInScope = (atoms, data, isInitOnly = false, evaluatedSelectors) => {
-  const subscriptions = new Set;
+var propagateInScope = (atoms, data, isInitOnly = false, notify) => {
+  const subscriptions = notify ? notifyEntryFor(notify, data).subscriptions : new Set;
   const families = new Map;
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
   }
-  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, evaluatedSelectors);
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families, isInitOnly, notify);
   if (data.scopes && data.scopes.size > 0) {
-    propagateToScopes(atoms, data, isInitOnly, evaluatedSelectors);
+    propagateToScopes(atoms, data, isInitOnly, notify);
   }
 };
-var propagateToScopes = (atoms, data, isInitOnly, evaluatedSelectors) => {
+var propagateToScopes = (atoms, data, isInitOnly, notify) => {
   if (atoms.length === 1) {
     const atom = atoms[0];
     const shadowingScopes = isAtomFamily(atom) ? undefined : data.scopeValueIndex.get(atom);
     for (const [, scope] of data.scopes) {
       if (!shadowingScopes || !shadowingScopes.has(scope)) {
-        propagateInScope(atoms, scope, isInitOnly, evaluatedSelectors);
+        propagateInScope(atoms, scope, isInitOnly, notify);
       }
     }
     return;
@@ -810,7 +859,7 @@ var propagateToScopes = (atoms, data, isInitOnly, evaluatedSelectors) => {
   }
   if (!anyShadowed) {
     for (const [, scope] of data.scopes) {
-      propagateInScope(atoms, scope, isInitOnly, evaluatedSelectors);
+      propagateInScope(atoms, scope, isInitOnly, notify);
     }
     return;
   }
@@ -827,20 +876,20 @@ var propagateToScopes = (atoms, data, isInitOnly, evaluatedSelectors) => {
       }
     }
     if (atomsToUpdateInScope.length > 0) {
-      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, evaluatedSelectors);
+      propagateInScope(atomsToUpdateInScope, scope, isInitOnly, notify);
     }
   }
 };
-var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false, evaluatedSelectors) => {
+var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, families, isInitOnly = false, notify) => {
   const updatedInitializedAtoms = new Set(updatedAtoms);
   if (selectors.size > 0) {
-    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly, evaluatedSelectors);
+    propagateSelectorUpdates(selectors, data, subscriptions, updatedInitializedAtoms, isInitOnly);
   }
-  if (subscriptions.size > 0) {
+  if (!notify && subscriptions.size > 0) {
     callSubscribers(subscriptions, families);
   }
 };
-var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, evaluatedSelectors) => {
+var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly) => {
   const closure = new Set(seeds);
   {
     const stack = [...seeds];
@@ -901,10 +950,6 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
   let head = 0;
   while (head < ready.length) {
     const selector = ready[head++];
-    if (evaluatedSelectors !== undefined && evaluatedSelectors.has(selector)) {
-      advance(selector, false);
-      continue;
-    }
     const currentValue = data.values.get(selector);
     if (isPromiseLike(currentValue) && isInitOnly) {
       advance(selector, false);
@@ -924,8 +969,6 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
     depsChange.added = undefined;
     depsChange.removed = undefined;
     const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
-    if (evaluatedSelectors !== undefined)
-      evaluatedSelectors.add(selector);
     const added = depsChange.added;
     const removed = depsChange.removed;
     if (added || removed) {
@@ -978,8 +1021,6 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
       depsChange.added = undefined;
       depsChange.removed = undefined;
       const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
-      if (evaluatedSelectors !== undefined)
-        evaluatedSelectors.add(selector);
       const added = depsChange.added;
       const removed = depsChange.removed;
       if ((added || removed) && isLive(selector, data)) {
@@ -1009,15 +1050,12 @@ var propagateDownstreamTopo = (seeds, data, collectedSubscribers, updatedInitial
     work = next;
   }
 };
-var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false, evaluatedSelectors) => {
+var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly = false) => {
   if (selectors.size === 0)
     return;
   let downstreamSeeds;
   const depsChange = {};
   for (const selector of selectors) {
-    if (evaluatedSelectors !== undefined && evaluatedSelectors.has(selector)) {
-      continue;
-    }
     const currentValue = data.values.get(selector);
     if (isPromiseLike(currentValue) && isInitOnly)
       continue;
@@ -1030,8 +1068,6 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
     depsChange.added = undefined;
     depsChange.removed = undefined;
     const wasValueUpdated = reEvaluateSelector(selector, data, updatedInitializedAtoms, depsChange, currentValue);
-    if (evaluatedSelectors !== undefined)
-      evaluatedSelectors.add(selector);
     const added = depsChange.added;
     const removed = depsChange.removed;
     if ((added || removed) && isLive(selector, data)) {
@@ -1061,14 +1097,14 @@ var propagateSelectorUpdates = (selectors, data, collectedSubscribers, updatedIn
     }
   }
   if (downstreamSeeds && downstreamSeeds.size > 0) {
-    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly, evaluatedSelectors);
+    propagateDownstreamTopo(downstreamSeeds, data, collectedSubscribers, updatedInitializedAtoms, isInitOnly);
   }
 };
 
 // src/lib/isFunction.ts
 var isFunction = (value) => typeof value === "function";
 
-// src/lib/setAtom.ts
+// src/lib/resolvePendingDefault.ts
 var resolvePendingDefault = (atom, data, value) => {
   let cur = data;
   while (cur) {
@@ -1081,6 +1117,8 @@ var resolvePendingDefault = (atom, data, value) => {
     cur = "parent" in cur ? cur.parent : undefined;
   }
 };
+
+// src/lib/setAtom.ts
 var handlePromise = (atom, promise, currentValue, data, skipOnSet) => {
   setValueInData(atom, promise, data);
   promise.then((resolvedValue) => {
@@ -1670,7 +1708,8 @@ var writeAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false, onSetQueu
   const updatedAtoms = [];
   for (let [atom, value] of pairs) {
     const currentValue = getState(atom, data, initializedAtomsSet);
-    const areEqual = isPromiseLike(currentValue) || isPromiseLike(value) ? currentValue === value : atom.equal(currentValue, value);
+    const currentIsPromise = isPromiseLike(currentValue);
+    const areEqual = currentIsPromise || isPromiseLike(value) ? currentValue === value : atom.equal(currentValue, value);
     if (!areEqual) {
       updatedAtoms.push(atom);
       value = setValueInData(atom, value, data);
@@ -1680,6 +1719,9 @@ var writeAtoms = (pairs, data, initializedAtomsSet, skipOnSet = false, onSetQueu
         else
           atom.onSet(value, data);
       }
+      if (currentIsPromise && !isPromiseLike(value)) {
+        resolvePendingDefault(atom, data, value);
+      }
     } else {
       setValueInData(atom, value, data);
     }
@@ -1877,13 +1919,14 @@ class Transaction {
     if (!this._scopedTransactions) {
       const initializedAtomsSet = new Set;
       if (this._deleteSet?.size) {
-        const evaluatedSelectors2 = new Set;
+        const notify2 = new Map;
         const updatedAtoms = writeAtoms(this._atomMap, this.data, initializedAtomsSet);
         if (updatedAtoms.length > 0) {
-          propagateAtomUpdate(updatedAtoms, this.data, false, evaluatedSelectors2);
+          propagateAtomUpdate(updatedAtoms, this.data, false, notify2);
         }
         deleteAtomFamilyAtoms(this._deleteSet, this.data);
-        propagateDeletedAtoms([...this._deleteSet], this.data, undefined, undefined, undefined, evaluatedSelectors2);
+        propagateDeletedAtoms([...this._deleteSet], this.data, undefined, undefined, undefined, notify2);
+        notifyDeferred(notify2);
       } else {
         setAtoms(this._atomMap, this.data, initializedAtomsSet);
       }
@@ -1905,15 +1948,16 @@ class Transaction {
         atom.onSet(value, data);
       }
     }
-    const evaluatedSelectors = new Set;
+    const notify = new Map;
     for (const { data, updatedAtoms, deleted } of plan) {
       if (updatedAtoms.length > 0) {
-        propagateAtomUpdate(updatedAtoms, data, false, evaluatedSelectors);
+        propagateAtomUpdate(updatedAtoms, data, false, notify);
       }
       if (deleted) {
-        propagateDeletedAtoms(deleted, data, undefined, undefined, undefined, evaluatedSelectors);
+        propagateDeletedAtoms(deleted, data, undefined, undefined, undefined, notify);
       }
     }
+    notifyDeferred(notify);
   };
   collectStores = (plan) => {
     plan.push({
@@ -2669,38 +2713,27 @@ var index = (family, callback, options) => {
   const map = new Map;
   const index2 = (term) => {
     const termKey = stableStringify(term);
-    if (map.has(termKey))
-      return map.get(termKey);
-    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);
+    const existing = map.get(termKey);
+    if (existing)
+      return existing;
+    const predicateSelectors = new WeakMap;
+    const predicateFor = (atom2) => {
+      let sel = predicateSelectors.get(atom2);
+      if (!sel) {
+        sel = selector((get) => callback(get(atom2), term), {
+          name: `index:callback:selector:${atom2.name}`
         });
-        addedAtoms.forEach((atom2) => {
-          termIndexSelectorSet.add(atom2);
-          termIndexSelectorMap.set(atom2, selector((get2) => callback(get2(atom2), term), {
-            name: `index:callback:selector:${atom2.name}`
-          }));
-        });
-        return new Set(termIndexSelectorSet);
-      } else {
-        return termIndexSelectorSet;
+        predicateSelectors.set(atom2, sel);
       }
-    }, { name: `index:${options?.name}(${termKey})` });
+      return sel;
+    };
     const filteredSelector = selector((get) => {
-      const set = get(termIndexSelector);
       const res = [];
-      set.forEach((atom2) => {
-        if (get(termIndexSelectorMap.get(atom2))) {
+      const members = get(family);
+      for (const atom2 of members) {
+        if (get(predicateFor(atom2)))
           res.push(atom2);
-        }
-      });
+      }
       return res;
     }, {
       name: `index:${options?.name}:${termKey}:termSelector`
@@ -2748,9 +2781,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: ${"1.0.0-beta.5"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.6"}`);
 } else {
-  globalThis.__valdres__ = "1.0.0-beta.5";
+  globalThis.__valdres__ = "1.0.0-beta.6";
 }
 export {
   store,

package/dist/types/indexConstructor.d.ts

@@ -1,5 +1,6 @@
 import type { AtomFamily } from "./types/AtomFamily";
+import type { AtomFamilyAtom } from "./types/AtomFamilyAtom";
 import type { Selector } from "./types/Selector";
 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[]>);
+}) => ((term: Term) => Selector<AtomFamilyAtom<Value, FamilyArgs>[]>);

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

@@ -7,7 +7,13 @@ import type { Subscription } from "../types/Subscription";
 export type { AtomFamilyIndex, } from "./atomFamilyIndex";
 export { cloneAtomFamilyIndex, createAtomFamilyIndex, renderAtomFamilyIndex, } from "./atomFamilyIndex";
 type AtomInput = Atom<any> | AtomFamilyAtom<any, any> | AtomFamily<any, any>;
-export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, timestamp?: number, evaluatedSelectors?: Set<Selector>) => void;
-export declare const propagateAtomUpdate: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean, evaluatedSelectors?: Set<Selector>) => void;
-export declare const propagateInScope: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean, evaluatedSelectors?: Set<Selector>) => void;
-export declare const propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isInitOnly?: boolean, evaluatedSelectors?: Set<Selector>) => void;
+type NotifyStoreEntry = {
+    subscriptions: Set<Subscription>;
+    families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>;
+};
+export type NotifyTarget = Map<StoreData, NotifyStoreEntry>;
+export declare const notifyDeferred: (notify: NotifyTarget) => void;
+export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, deletedFamilyAtoms?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, timestamp?: number, notify?: NotifyTarget) => void;
+export declare const propagateAtomUpdate: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean, notify?: NotifyTarget) => void;
+export declare const propagateInScope: (atoms: AtomInput[], data: StoreData, isInitOnly?: boolean, notify?: NotifyTarget) => void;
+export declare const propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isInitOnly?: boolean, notify?: NotifyTarget) => void;

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

@@ -0,0 +1,32 @@
+import type { Atom } from "../types/Atom";
+import type { StoreData } from "../types/StoreData";
+/** Resolve any outstanding pending-default suspense placeholder for `atom`
+ *  with `value` and remove it. The placeholder may have been registered in a
+ *  parent store (atoms with no `defaultValue` init in whichever scope first
+ *  reads them, which `getState` resolves by walking up to root), so we walk
+ *  the scope chain rather than only checking `data`.
+ *
+ *  Called by every write path that lands a value on an atom that may carry a
+ *  placeholder — `setAtom` (sync + async resolve) and `writeAtoms` (the
+ *  transaction path).
+ *
+ *  Caller contract: pass a SETTLED value, never a promise. The placeholder must
+ *  resolve to the eventual real value, so an in-flight promise stored
+ *  mid-sequence must not consume it — a later settled write still has to find
+ *  the entry here. `setAtom` guarantees this by routing promises through
+ *  `handlePromise` instead; `writeAtoms` by gating on `!isPromiseLike(value)`.
+ *
+ *  Optional optimization (not required): a caller that already knows the prior
+ *  value may skip the call when it isn't promise-like — a placeholder is always
+ *  stored as a promise, so a non-promise prior value can't have one. `writeAtoms`
+ *  does this (gating on `isPromiseLike(currentValue)`) to keep the write hot
+ *  path off this function. `setAtom` calls unconditionally; the walk is a couple
+ *  of WeakMap lookups that bail immediately when there's nothing to resolve.
+ *
+ *  Idempotent and commit-safe: the entry is deleted on first resolve and a
+ *  settled promise ignores later `resolve` calls, so calling this from more
+ *  than one store pass in a single cross-scope commit is harmless. `resolve`
+ *  only schedules the placeholder's `.then` microtasks — it runs no subscriber
+ *  code synchronously — so calling it during a transaction's write phase
+ *  cannot expose a half-applied commit. */
+export declare const resolvePendingDefault: <Value>(atom: Atom<Value>, data: StoreData, value: Value) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "1.0.0-beta.5",
+    "version": "1.0.0-beta.6",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"