atom.io 0.18.0 → 0.18.1

package/internal/src/atom/delete-atom.ts

@@ -1,12 +1,9 @@
-import type { RegularAtomToken } from "atom.io"
+import type { AtomToken } from "atom.io"
 
 import type { Store } from ".."
-import { deleteSelector, newest } from ".."
+import { deleteSelector, getUpdateToken, newest } from ".."
 
-export function deleteAtom(
-	atomToken: RegularAtomToken<unknown>,
-	store: Store,
-): void {
+export function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void {
 	const target = newest(store)
 	const { key } = atomToken
 	const atom = target.atoms.get(key)
@@ -35,5 +32,9 @@ export function deleteAtom(
 	target.selectorAtoms.delete(key)
 	target.atomsThatAreDefault.delete(key)
 	target.timelineAtoms.delete(key)
+	if (atomToken.type === `mutable_atom`) {
+		const updateToken = getUpdateToken(atomToken)
+		deleteAtom(updateToken, store)
+	}
 	store.logger.info(`🔥`, `atom`, `${key}`, `deleted`)
 }

package/internal/src/caching.ts

@@ -53,12 +53,12 @@ export const readCachedValue = <T>(
 	token: ReadableState<any>,
 	target: Store,
 ): T => {
-	const value = target.valueMap.get(token.key) as T
-	// if (token.type === `mutable_atom` && isChildStore(target)) {
-	// 	const { parent } = target
-	// 	const copiedValue = copyMutableIfNeeded(token, parent, target)
-	// 	value = copiedValue
-	// }
+	let value = target.valueMap.get(token.key) as T
+	if (token.type === `mutable_atom` && isChildStore(target)) {
+		const { parent } = target
+		const copiedValue = copyMutableIfNeeded(token, parent, target)
+		value = copiedValue
+	}
 	return value
 }
 

package/internal/src/ingest-updates/ingest-atom-update.ts

@@ -1,4 +1,4 @@
-import type { KeyedStateUpdate } from "atom.io"
+import type { KeyedStateUpdate, RegularAtomToken } from "atom.io"
 
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
@@ -10,5 +10,9 @@ export function ingestAtomUpdate(
 ): void {
 	const { key, newValue, oldValue } = atomUpdate
 	const value = applying === `newValue` ? newValue : oldValue
-	setIntoStore({ key, type: `atom` }, value, store)
+	const token: RegularAtomToken<unknown> = { key, type: `atom` }
+	if (atomUpdate.family) {
+		Object.assign(token, { family: atomUpdate.family })
+	}
+	setIntoStore(token, value, store)
 }

package/internal/src/set-state/copy-mutable-if-needed.ts

@@ -9,7 +9,12 @@ export function copyMutableIfNeeded<T extends Transceiver<any>>(
 ): T {
 	const originValue = origin.valueMap.get(atom.key)
 	const targetValue = target.valueMap.get(atom.key)
+
 	if (originValue === targetValue) {
+		if (originValue === undefined) {
+			return typeof atom.default === `function` ? atom.default() : atom.default
+		}
+
 		origin.logger.info(`📃`, `atom`, `${atom.key}`, `copying`)
 		const jsonValue = atom.toJson(originValue)
 		const copiedValue = atom.fromJson(jsonValue)

package/internal/src/set-state/emit-update.ts

@@ -8,16 +8,30 @@ export const emitUpdate = <T>(
 	update: StateUpdate<T>,
 	store: Store,
 ): void => {
-	store.logger.info(
-		`📢`,
-		state.type,
-		state.key,
-		`went (`,
-		update.oldValue,
-		`->`,
-		update.newValue,
-		`) subscribers:`,
-		state.subject.subscribers,
-	)
+	switch (state.type) {
+		case `mutable_atom`:
+			store.logger.info(
+				`📢`,
+				state.type,
+				state.key,
+				`is now (`,
+				update.newValue,
+				`) subscribers:`,
+				state.subject.subscribers,
+			)
+			break
+		default:
+			store.logger.info(
+				`📢`,
+				state.type,
+				state.key,
+				`went (`,
+				update.oldValue,
+				`->`,
+				update.newValue,
+				`) subscribers:`,
+				state.subject.subscribers,
+			)
+	}
 	state.subject.next(update)
 }

package/internal/src/set-state/set-atom.ts

@@ -42,12 +42,13 @@ export const setAtom = <T>(
 			const mutableKey = atom.key.slice(1)
 			const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
 			let transceiver: Transceiver<any> = target.valueMap.get(mutableKey)
-			if (atom.type === `mutable_atom` && isChildStore(target)) {
+			if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
 				const { parent } = target
-				const copiedValue = copyMutableIfNeeded(atom, parent, target)
+				const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target)
 				transceiver = copiedValue
 			}
-			transceiver.do(update.newValue)
+			const accepted = transceiver.do(update.newValue) === null
+			if (accepted) evictDownStream(mutableAtom, target)
 		}
 	}
 }

package/internal/src/transaction/apply-transaction.ts

@@ -60,7 +60,6 @@ export const applyTransaction = <ƒ extends ƒn>(
 	}
 	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent)
 	if (isRootStore(parent)) {
-		console.log(child.transactionMeta.update)
 		setEpochNumberOfAction(
 			child.transactionMeta.update.key,
 			child.transactionMeta.update.epoch,

package/internal/src/transaction/set-epoch-number.ts

@@ -26,6 +26,5 @@ export function setEpochNumberOfAction(
 
 	if (continuityKey !== undefined) {
 		store.transactionMeta.epoch.set(continuityKey, newEpoch)
-		console.log(`epoch is now`, newEpoch)
 	}
 }

package/json/src/index.ts

@@ -1,9 +1,9 @@
-export * from "anvl/json"
-export * from "anvl/primitive"
+export * from "~/packages/anvl/src/json"
+export * from "~/packages/anvl/src/primitive"
 
 export * from "./select-json"
 export * from "./select-json-family"
 
-import type { Json } from "anvl/json"
+import type { Json } from "~/packages/anvl/src/json"
 
 export type JsonIO = (...params: Json.Serializable[]) => Json.Serializable | void