atom.io 0.33.8 → 0.33.10

package/src/internal/caching.ts

@@ -1,9 +1,13 @@
 import type { StateUpdate } from "atom.io"
 
 import type { ReadableState } from "."
-import { isChildStore } from "."
+import { closeOperation, isChildStore, openOperation } from "."
 import { Future } from "./future"
 import { copyMutableIfNeeded } from "./set-state/copy-mutable-if-needed"
+import {
+	evictDownStream,
+	evictDownStreamFromSelector,
+} from "./set-state/evict-downstream"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
 
@@ -28,15 +32,37 @@ export function cacheValue<T>(
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future) {
 		const future = currentValue
-		future.use(value)
+		if (value instanceof Promise) {
+			return future
+		}
+		target.valueMap.set(key, value)
+		return value
 	}
 	if (value instanceof Promise) {
 		const future = new Future<T>(value)
 		target.valueMap.set(key, future)
 		future
 			.then((resolved) => {
-				cacheValue(target, key, resolved, subject)
-				subject.next({ newValue: resolved, oldValue: future })
+				const current = target.valueMap.get(key)
+				if (current === future) {
+					cacheValue(target, key, resolved, subject)
+					const atom = target.atoms.get(key)
+					if (atom) {
+						openOperation(target, atom)
+						evictDownStream(target, atom)
+						closeOperation(target)
+					} else {
+						const selector =
+							target.writableSelectors.get(key) ??
+							target.readonlySelectors.get(key)
+						if (selector) {
+							openOperation(target, selector)
+							evictDownStreamFromSelector(target, selector)
+							closeOperation(target)
+						}
+					}
+					subject.next({ newValue: resolved, oldValue: future })
+				}
 			})
 			.catch((thrown) => {
 				target.logger.error(`💥`, `state`, key, `rejected:`, thrown)

package/src/internal/operation.ts

@@ -1,4 +1,4 @@
-import type { WritableToken } from "atom.io"
+import type { ReadableToken } from "atom.io"
 
 import type { Store } from "./store"
 import { isChildStore } from "./transaction/is-root-store"
@@ -12,12 +12,12 @@ export type OperationProgress =
 			done: Set<string>
 			prev: Map<string, any>
 			time: number
-			token: WritableToken<any>
+			token: ReadableToken<any>
 	  }
 
 export const openOperation = (
 	store: Store,
-	token: WritableToken<any>,
+	token: ReadableToken<any>,
 ): number | undefined => {
 	if (store.operation.open) {
 		const rejectionTime = performance.now()

package/src/internal/set-state/evict-downstream.ts

@@ -1,10 +1,10 @@
-import type { Atom } from ".."
+import type { Atom, Selector } from ".."
 import { evictCachedValue } from "../caching"
 import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
 
-export const evictDownStream = <T>(store: Store, atom: Atom<T>): void => {
+export function evictDownStream(store: Store, atom: Atom<any>): void {
 	const target = newest(store)
 	const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key)
 	target.logger.info(
@@ -34,3 +34,22 @@ export const evictDownStream = <T>(store: Store, atom: Atom<T>): void => {
 		}
 	}
 }
+
+export function evictDownStreamFromSelector(
+	store: Store,
+	selector: Selector<any>,
+): void {
+	const target = newest(store)
+	const relationEntries = target.selectorGraph
+		.getRelationEntries({
+			upstreamSelectorKey: selector.key,
+		})
+		.filter(([_, { source }]) => source === selector.key)
+	for (const [downstreamSelectorKey] of relationEntries) {
+		if (isDone(target, downstreamSelectorKey)) {
+			continue
+		}
+		evictCachedValue(downstreamSelectorKey, target)
+		markDone(target, downstreamSelectorKey)
+	}
+}