atom.io 0.33.21 → 0.34.0

package/src/internal/selector/update-selector-atoms.ts

@@ -2,7 +2,7 @@ import type { ReadonlyPureSelectorToken, WritableToken } from "atom.io"
 
 import { newest } from "../lineage"
 import type { Store } from "../store"
-import { traceSelectorAtoms } from "./trace-selector-atoms"
+import { traceRootSelectorAtoms } from "./trace-selector-atoms"
 
 export const updateSelectorAtoms = (
 	store: Store,
@@ -29,16 +29,16 @@ export const updateSelectorAtoms = (
 			`discovers root atom "${dependencyKey}"`,
 		)
 	} else {
-		const rootKeys = traceSelectorAtoms(store, dependencyKey, covered)
+		const rootKeys = traceRootSelectorAtoms(store, dependencyKey, covered)
 		store.logger.info(
 			`🔍`,
 			selectorType,
 			selectorKey,
-			`discovers root atoms: [ ${rootKeys
-				.map((key) => `"${key}"`)
+			`discovers root atoms: [ ${[...rootKeys.values()]
+				.map((root) => `"${root.key}"`)
 				.join(`, `)} ]`,
 		)
-		for (const atomKey of rootKeys) {
+		for (const { key: atomKey } of rootKeys.values()) {
 			target.selectorAtoms = target.selectorAtoms.set({
 				selectorKey,
 				atomKey,

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

@@ -29,7 +29,7 @@ export function evictDownStream(store: Store, atom: Atom<any>): void {
 			if (isDone(target, key)) {
 				continue
 			}
-			evictCachedValue(key, target)
+			evictCachedValue(target, key)
 			markDone(target, key)
 		}
 	}
@@ -49,7 +49,7 @@ export function evictDownStreamFromSelector(
 		if (isDone(target, downstreamSelectorKey)) {
 			continue
 		}
-		evictCachedValue(downstreamSelectorKey, target)
+		evictCachedValue(target, downstreamSelectorKey)
 		markDone(target, downstreamSelectorKey)
 	}
 }

package/src/internal/set-state/reset-atom-or-selector.ts

@@ -1,5 +1,5 @@
 import type { Atom, WritableState } from ".."
-import { traceAllSelectorAtoms } from ".."
+import { traceRootSelectorAtoms } from ".."
 import type { Store } from "../store"
 import { setAtom } from "./set-atom"
 
@@ -23,8 +23,8 @@ export function resetAtomOrSelector(
 		case `writable_pure_selector`:
 		case `writable_held_selector`:
 			{
-				const atoms = traceAllSelectorAtoms(state, store)
-				for (const atom of atoms) {
+				const atoms = traceRootSelectorAtoms(store, state.key)
+				for (const atom of atoms.values()) {
 					resetAtom(store, atom)
 				}
 			}

package/src/internal/store/store.ts

@@ -193,7 +193,6 @@ export class Store implements Lineage {
 			...config,
 		}
 		if (store !== null) {
-			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
 			if (isRootStore(store)) {
 				this.transactionMeta = {

package/src/internal/subscribe/subscribe-to-root-atoms.ts

@@ -1,46 +1,50 @@
-import type { Selector } from ".."
+import type { Atom, Selector } from ".."
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
-import { newest } from "../lineage"
-import { traceAllSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 import { recallState } from "./recall-state"
 
-export const subscribeToRootAtoms = <T>(
-	store: Store,
-	selector: Selector<T>,
-): (() => void)[] => {
-	const target = newest(store)
-	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
-		(atom) => {
-			return atom.subject.subscribe(
-				`${selector.type}:${selector.key}`,
-				(atomChange) => {
-					store.logger.info(
-						`📢`,
-						selector.type,
-						selector.key,
-						`root`,
-						atom.key,
-						`went`,
-						atomChange.oldValue,
-						`->`,
-						atomChange.newValue,
-					)
-					const oldValue = recallState(target, selector)
-					const newValue = readOrComputeValue(target, selector)
-					store.logger.info(
-						`✨`,
-						selector.type,
-						selector.key,
-						`went`,
-						oldValue,
-						`->`,
-						newValue,
-					)
-					selector.subject.next({ newValue, oldValue })
-				},
+export const subscribeToRootDependency = (
+	target: Store,
+	selector: Selector<any>,
+	atom: Atom<any>,
+): (() => void) => {
+	return atom.subject.subscribe(
+		`${selector.type}:${selector.key}`,
+		(atomChange) => {
+			target.logger.info(
+				`📢`,
+				selector.type,
+				selector.key,
+				`root`,
+				atom.key,
+				`went`,
+				atomChange.oldValue,
+				`->`,
+				atomChange.newValue,
 			)
+			const oldValue = recallState(target, selector)
+			const newValue = readOrComputeValue(target, selector)
+			target.logger.info(
+				`✨`,
+				selector.type,
+				selector.key,
+				`went`,
+				oldValue,
+				`->`,
+				newValue,
+			)
+			selector.subject.next({ newValue, oldValue })
 		},
 	)
-	return dependencySubscriptions
 }
+
+// export const subscribeToRootAtoms = (
+// 	store: Store,
+// 	selector: Selector<any>,
+// ): (() => void)[] => {
+// 	const target = newest(store)
+// 	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
+// 		(atom) => subscribeToRootDependency(target, selector, atom),
+// 	)
+// 	return dependencySubscriptions
+// }

package/src/internal/subscribe/subscribe-to-state.ts

@@ -1,8 +1,10 @@
 import type { ReadableToken, StateUpdate, UpdateHandler } from "atom.io"
 
+import { readOrComputeValue } from "../get-state"
+import { traceRootSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 import { withdraw } from "../store"
-import { subscribeToRootAtoms } from "./subscribe-to-root-atoms"
+import { subscribeToRootDependency } from "./subscribe-to-root-atoms"
 
 export function subscribeToState<T>(
 	store: Store,
@@ -28,14 +30,26 @@ export function subscribeToState<T>(
 	const isSelector =
 		state.type === `writable_pure_selector` ||
 		state.type === `readonly_pure_selector`
-	let dependencyUnsubFunctions: (() => void)[] | null = null
+	const rootSubs = new Map<string, () => void>()
 	let updateHandler: UpdateHandler<T> = safelyHandleUpdate
 	if (isSelector) {
-		dependencyUnsubFunctions = subscribeToRootAtoms(store, state)
-		updateHandler = (update) => {
-			if (dependencyUnsubFunctions) {
-				dependencyUnsubFunctions.length = 0
-				dependencyUnsubFunctions.push(...subscribeToRootAtoms(store, state))
+		readOrComputeValue(store, state)
+		for (const [atomKey, atom] of traceRootSelectorAtoms(store, state.key)) {
+			rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom))
+		}
+		updateHandler = function updateRootsBeforeHandlingUpdate(update) {
+			const dependencies = traceRootSelectorAtoms(store, state.key)
+			for (const [previousRootKey, unsub] of rootSubs) {
+				const currentRoot = dependencies.get(previousRootKey)
+				if (currentRoot) {
+					dependencies.delete(previousRootKey)
+				} else {
+					unsub()
+					rootSubs.delete(previousRootKey)
+				}
+			}
+			for (const [atomKey, atom] of dependencies) {
+				rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom))
 			}
 			safelyHandleUpdate(update)
 		}
@@ -49,10 +63,8 @@ export function subscribeToState<T>(
 			`Removing subscription "${key}"`,
 		)
 		mainUnsubFunction()
-		if (dependencyUnsubFunctions) {
-			for (const unsubFromDependency of dependencyUnsubFunctions) {
-				unsubFromDependency()
-			}
+		for (const unsubFromDependency of rootSubs.values()) {
+			unsubFromDependency()
 		}
 	}
 

package/src/realtime-client/realtime-client-stores/client-sync-store.ts

@@ -4,12 +4,12 @@ export const optimisticUpdateQueue: AtomIO.RegularAtomToken<
 	AtomIO.TransactionUpdate<any>[]
 > = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>({
 	key: `updateQueue`,
-	default: [],
+	default: () => [],
 })
 
 export const confirmedUpdateQueue: AtomIO.RegularAtomToken<
 	AtomIO.TransactionUpdate<any>[]
 > = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>({
 	key: `serverConfirmedUpdateQueue`,
-	default: [],
+	default: () => [],
 })

package/src/realtime-testing/setup-realtime-test.tsx

@@ -192,11 +192,6 @@ export const setupRealtimeTestClient = (
 			auth: { token: `test`, username: `${name}-${testNumber}` },
 		})
 		const silo = new AtomIO.Silo({ name, lifespan: `ephemeral` }, IMPLICIT.STORE)
-		for (const [key, value] of silo.store.valueMap.entries()) {
-			if (Array.isArray(value)) {
-				silo.store.valueMap.set(key, [...value])
-			}
-		}
 		silo.setState(RTC.myUsernameState, `${name}-${testNumber}`)
 
 		const { document } = new Happy.Window()