atom.io 0.38.2 → 0.39.1

package/src/internal/{ingest-updates → events}/ingest-creation-disposal.ts

@@ -9,45 +9,46 @@ import type {
 import { parseJson, stringifyJson } from "atom.io/json"
 
 import { disposeFromStore } from "../families"
-import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
+import { getFromStore } from "../get-state"
 import {
 	allocateIntoStore,
 	claimWithinStore,
 	deallocateFromStore,
 } from "../molecule"
+import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 
 export function ingestCreationEvent(
-	update: StateCreationEvent<any>,
-	applying: `newValue` | `oldValue`,
 	store: Store,
+	event: StateCreationEvent<any>,
+	applying: `newValue` | `oldValue`,
 ): void {
 	switch (applying) {
 		case `newValue`: {
-			createInStore(update, store)
+			createInStore(store, event)
 			break
 		}
 		case `oldValue`: {
-			disposeFromStore(store, update.token)
+			disposeFromStore(store, event.token)
 			break
 		}
 	}
 }
 
 export function ingestDisposalEvent(
-	update: StateDisposalEvent<ReadableToken<any>>,
-	applying: `newValue` | `oldValue`,
 	store: Store,
+	event: StateDisposalEvent<ReadableToken<any>>,
+	applying: `newValue` | `oldValue`,
 ): void {
 	switch (applying) {
 		case `newValue`: {
-			disposeFromStore(store, update.token)
+			disposeFromStore(store, event.token)
 			break
 		}
 		case `oldValue`: {
-			createInStore(update, store)
-			if (update.subType === `atom`) {
-				store.valueMap.set(update.token.key, update.value)
+			createInStore(store, event)
+			if (event.subType === `atom`) {
+				store.valueMap.set(event.token.key, event.value)
 			}
 			break
 		}
@@ -55,52 +56,51 @@ export function ingestDisposalEvent(
 }
 
 function createInStore(
-	update: StateCreationEvent<any> | StateDisposalEvent<any>,
 	store: Store,
+	event: StateCreationEvent<any> | StateDisposalEvent<any>,
 ): void {
-	const { family: familyMeta } = update.token
-	if (familyMeta) {
-		const family = store.families.get(familyMeta.key)
-		if (family) {
-			mintInStore(store, family, parseJson(familyMeta.subKey), MUST_CREATE)
-		}
+	const { token } = event
+	if (event.subType === `writable` && event.value) {
+		setIntoStore(store, token, event.value)
+	} else {
+		getFromStore(store, token)
 	}
 }
 
 export function ingestMoleculeCreationEvent(
-	update: MoleculeCreationEvent,
-	applying: `newValue` | `oldValue`,
 	store: Store,
+	event: MoleculeCreationEvent,
+	applying: `newValue` | `oldValue`,
 ): void {
 	switch (applying) {
 		case `newValue`:
-			allocateIntoStore<any, any, any>(store, update.provenance, update.key)
+			allocateIntoStore<any, any, any>(store, event.provenance, event.key)
 			break
 
 		case `oldValue`:
-			deallocateFromStore<any, any>(store, update.key)
+			deallocateFromStore<any, any>(store, event.key)
 			break
 	}
 }
 export function ingestMoleculeDisposalEvent(
-	update: MoleculeDisposalEvent,
-	applying: `newValue` | `oldValue`,
 	store: Store,
+	event: MoleculeDisposalEvent,
+	applying: `newValue` | `oldValue`,
 ): void {
 	switch (applying) {
 		case `newValue`:
-			deallocateFromStore<any, any>(store, update.key)
+			deallocateFromStore<any, any>(store, event.key)
 			break
 
 		case `oldValue`:
 			{
-				const provenanceJson = update.provenance.map(parseJson)
-				allocateIntoStore<any, any, any>(store, provenanceJson, update.key)
-				for (const [familyKey, value] of update.values) {
+				const provenanceJson = event.provenance.map(parseJson)
+				allocateIntoStore<any, any, any>(store, provenanceJson, event.key)
+				for (const [familyKey, value] of event.values) {
 					const family = store.families.get(familyKey)
 					if (family) {
-						mintInStore(store, family, update.key, MUST_CREATE)
-						const memberKey = `${familyKey}(${stringifyJson(update.key)})`
+						getFromStore(store, family, event.key)
+						const memberKey = `${familyKey}(${stringifyJson(event.key)})`
 						store.valueMap.set(memberKey, value)
 					}
 				}
@@ -109,19 +109,19 @@ export function ingestMoleculeDisposalEvent(
 	}
 }
 export function ingestMoleculeTransferEvent(
-	update: MoleculeTransferEvent,
-	applying: `newValue` | `oldValue`,
 	store: Store,
+	event: MoleculeTransferEvent,
+	applying: `newValue` | `oldValue`,
 ): void {
 	switch (applying) {
 		case `newValue`:
 			{
-				for (const newOwner of update.to) {
+				for (const newOwner of event.to) {
 					claimWithinStore<any, any, any>(
 						store,
 						newOwner,
-						update.key,
-						update.exclusive ? `exclusive` : undefined,
+						event.key,
+						event.exclusive ? `exclusive` : undefined,
 					)
 				}
 			}
@@ -129,11 +129,11 @@ export function ingestMoleculeTransferEvent(
 		case `oldValue`:
 			{
 				let exclusivity: `exclusive` | undefined = `exclusive`
-				for (const previousOwner of update.from) {
+				for (const previousOwner of event.from) {
 					claimWithinStore<any, any, any>(
 						store,
 						previousOwner,
-						update.key,
+						event.key,
 						exclusivity,
 					)
 					exclusivity = undefined

package/src/internal/{ingest-updates → events}/ingest-selector-update.ts

@@ -6,12 +6,12 @@ import type {
 } from "atom.io"
 
 import type { Store } from "../store"
-import { ingestAtomUpdate } from "./ingest-atom-update"
+import { ingestAtomUpdateEvent } from "./ingest-atom-update"
 
-export function ingestSelectorUpdate(
-	applying: `newValue` | `oldValue`,
-	selectorUpdate: TimelineSelectorUpdateEvent<any>,
+export function ingestSelectorUpdateEvent(
 	store: Store,
+	selectorUpdate: TimelineSelectorUpdateEvent<any>,
+	applying: `newValue` | `oldValue`,
 ): void {
 	let updates: AtomUpdateEvent<AtomOnly<TimelineManageable>>[]
 	if (applying === `newValue`) {
@@ -20,6 +20,6 @@ export function ingestSelectorUpdate(
 		updates = selectorUpdate.atomUpdates.toReversed()
 	}
 	for (const atomUpdate of updates) {
-		ingestAtomUpdate(applying, atomUpdate, store)
+		ingestAtomUpdateEvent(store, atomUpdate, applying)
 	}
 }

package/src/internal/events/ingest-transaction-update.ts

@@ -0,0 +1,45 @@
+import type { TransactionOutcomeEvent } from "atom.io"
+
+import type { Store } from "../store"
+import { ingestAtomUpdateEvent } from "./ingest-atom-update"
+import {
+	ingestCreationEvent,
+	ingestDisposalEvent,
+	ingestMoleculeCreationEvent,
+	ingestMoleculeDisposalEvent,
+	ingestMoleculeTransferEvent,
+} from "./ingest-creation-disposal"
+
+export function ingestTransactionOutcomeEvent(
+	store: Store,
+	event: TransactionOutcomeEvent<any>,
+	applying: `newValue` | `oldValue`,
+): void {
+	const subEvents =
+		applying === `newValue` ? event.subEvents : [...event.subEvents].reverse()
+	for (const subEvent of subEvents) {
+		switch (subEvent.type) {
+			case `atom_update`:
+				ingestAtomUpdateEvent(store, subEvent, applying)
+				break
+			case `state_creation`:
+				ingestCreationEvent(store, subEvent, applying)
+				break
+			case `state_disposal`:
+				ingestDisposalEvent(store, subEvent, applying)
+				break
+			case `molecule_creation`:
+				ingestMoleculeCreationEvent(store, subEvent, applying)
+				break
+			case `molecule_disposal`:
+				ingestMoleculeDisposalEvent(store, subEvent, applying)
+				break
+			case `molecule_transfer`:
+				ingestMoleculeTransferEvent(store, subEvent, applying)
+				break
+			case `transaction_outcome`:
+				ingestTransactionOutcomeEvent(store, subEvent, applying)
+				break
+		}
+	}
+}

package/src/internal/families/create-readonly-held-selector-family.ts

@@ -61,7 +61,7 @@ export function createReadonlyHeldSelectorFamily<
 			family,
 		)
 
-		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
+		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/create-readonly-pure-selector-family.ts

@@ -64,7 +64,7 @@ export function createReadonlyPureSelectorFamily<T, K extends Canonical>(
 			family,
 		)
 
-		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
+		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/create-regular-atom-family.ts

@@ -12,6 +12,7 @@ import { stringifyJson } from "atom.io/json"
 
 import type { RegularAtomFamily } from ".."
 import { createRegularAtom } from "../atom"
+import { isFn } from "../is-fn"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
@@ -47,7 +48,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 		const def = options.default
 		const individualOptions: RegularAtomOptions<T> = {
 			key: fullKey,
-			default: def instanceof Function ? () => def(key) : def,
+			default: isFn(def) ? () => def(key) : def,
 		}
 		if (options.effects) {
 			individualOptions.effects = options.effects(key)
@@ -55,7 +56,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 
 		const token = createRegularAtom(target, individualOptions, family)
 
-		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
+		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 
@@ -67,7 +68,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 	}) satisfies RegularAtomFamily<T, K>
 
 	store.families.set(options.key, atomFamily)
-	if (options.default instanceof Function === false) {
+	if (isFn(options.default) === false) {
 		store.defaults.set(options.key, options.default)
 	}
 	return familyToken

package/src/internal/families/create-writable-held-selector-family.ts

@@ -61,7 +61,7 @@ export function createWritableHeldSelectorFamily<
 			family,
 		)
 
-		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
+		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/create-writable-pure-selector-family.ts

@@ -64,7 +64,7 @@ export function createWritablePureSelectorFamily<T, K extends Canonical>(
 			family,
 		)
 
-		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
+		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/families/find-in-store.ts

@@ -85,11 +85,11 @@ export function findInStore(
 	familyToken: ReadableFamilyToken<any, any>,
 	key: Canonical,
 ): ReadableToken<any> {
-	withdraw(store, familyToken)
+	const family = withdraw(store, familyToken)
 	const existingStateToken = seekInStore(store, familyToken, key)
 	if (existingStateToken) {
 		return existingStateToken
 	}
-	const newStateToken = mintInStore(store, familyToken, key)
+	const newStateToken = mintInStore(store, family, key)
 	return newStateToken
 }

package/src/internal/families/get-family-of-token.ts

@@ -43,6 +43,7 @@ export function getFamilyOfToken<T, K extends Canonical>(
 	store: Store,
 	token: WritableToken<T, K>,
 ): WritableFamily<T, K>
+
 export function getFamilyOfToken<T, K extends Canonical>(
 	store: Store,
 	token: ReadableToken<T, K>,

package/src/internal/families/index.ts

@@ -5,5 +5,4 @@ export * from "./create-selector-family"
 export * from "./create-writable-pure-selector-family"
 export * from "./dispose-from-store"
 export * from "./find-in-store"
-export * from "./init-family-member"
 export * from "./seek-in-store"

package/src/internal/families/mint-in-store.ts

@@ -1,98 +1,64 @@
-import type {
-	ReadableFamilyToken,
-	ReadableToken,
-	WritableFamilyToken,
-	WritableToken,
-} from "atom.io"
+import type { ReadableToken, WritableToken } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import { newest } from "../lineage"
+import type { ReadableFamily } from ".."
 import type { Store } from "../store"
 import { COUNTERFEIT, mint } from "../store"
-import { isChildStore, isRootStore } from "../transaction"
-import { initFamilyMemberInStore } from "./init-family-member"
 
-export const MUST_CREATE: unique symbol = Symbol(`MUST_NOT_EXIST`)
+export const MUST_CREATE: unique symbol = Symbol(`MUST_CREATE`)
 
 export function mintInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	familyToken: WritableFamilyToken<T, K>,
+	family: ReadableFamily<T, K>,
 	key: Key,
-	init?: typeof MUST_CREATE,
+	mustCreate?: typeof MUST_CREATE,
 ): WritableToken<T, K>
 export function mintInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	familyToken: ReadableFamilyToken<T, K>,
+	family: ReadableFamily<T, K>,
 	key: Key,
-	init?: typeof MUST_CREATE,
+	mustCreate?: typeof MUST_CREATE,
 ): ReadableToken<T, K>
 export function mintInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	familyToken: ReadableFamilyToken<T, K>,
+	family: ReadableFamily<T, K>,
 	key: Key,
-	shouldCreate?: typeof MUST_CREATE,
+	mustCreate?: typeof MUST_CREATE,
 ): ReadableToken<T, K> {
-	let stateToken: ReadableToken<T, K>
-
-	let willCreate: boolean
-	switch (shouldCreate) {
-		case MUST_CREATE:
-			willCreate = true
-			break
-		case undefined:
-			willCreate = false
-			break
-	}
-
 	const stringKey = stringifyJson(key)
 	const molecule = store.molecules.get(stringKey)
-	if (!molecule && store.config.lifespan === `immortal`) {
-		const fakeToken = mint(familyToken, key, COUNTERFEIT)
+
+	const cannotCreate = !molecule && store.config.lifespan === `immortal`
+
+	if (cannotCreate) {
 		store.logger.warn(
 			`💣`,
 			`key`,
 			stringKey,
 			`was used to mint a counterfeit token for`,
-			familyToken.type,
-			`"${familyToken.key}"`,
+			family.type,
+			`"${family.key}"`,
 		)
-		return fakeToken
+		return mint(family, key, COUNTERFEIT)
 	}
 
-	if (willCreate) {
-		stateToken = initFamilyMemberInStore(store, familyToken, key)
-		const target = newest(store)
-		if (stateToken.family) {
-			if (isRootStore(target)) {
-				switch (stateToken.type) {
-					case `atom`:
-					case `mutable_atom`:
-						store.on.atomCreation.next(stateToken)
-						break
-					case `writable_pure_selector`:
-					case `readonly_pure_selector`:
-					case `writable_held_selector`:
-					case `readonly_held_selector`:
-						store.on.selectorCreation.next(stateToken)
-						break
-				}
-			} else if (
-				isChildStore(target) &&
-				target.on.transactionApplying.state === null
-			) {
-				target.transactionMeta.update.subEvents.push({
-					type: `state_creation`,
-					token: stateToken,
-					timestamp: Date.now(),
-				})
-			}
-		}
+	let token: ReadableToken<T, K>
+	if (mustCreate === MUST_CREATE) {
+		store.logger.info(
+			`👪`,
+			family.type,
+			family.key,
+			`adds member`,
+			typeof key === `string` ? `\`${key}\`` : key,
+		)
+		token = family(key)
 		if (molecule) {
-			target.moleculeData.set(stringKey, familyToken.key)
+			store.moleculeData.set(stringKey, family.key)
 		}
 	} else {
-		stateToken = mint(familyToken, key)
+		token = mint(family, key)
 	}
-	return stateToken
+
+	return token
 }

package/src/internal/get-state/get-from-store.ts

@@ -20,10 +20,9 @@ export function getFromStore(
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 		| [token: ReadableToken<any>]
 ): any {
-	const { token, familyToken, subKey } = reduceReference(store, ...params)
+	const { token, family, subKey } = reduceReference(store, ...params)
 
-	if (`counterfeit` in token && familyToken && subKey) {
-		const family = withdraw(store, familyToken)
+	if (`counterfeit` in token && family && subKey) {
 		return getFallback(store, token, family, subKey)
 	}
 	const state = withdraw(store, token)

package/src/internal/get-state/read-or-compute-value.ts

@@ -2,6 +2,7 @@ import type { ViewOf } from "atom.io"
 
 import type { ReadableState } from ".."
 import { readFromCache, writeToCache } from "../caching"
+import { isFn } from "../is-fn"
 import type { Store } from "../store"
 
 export function readOrComputeValue<T>(
@@ -22,6 +23,7 @@ export function readOrComputeValue<T>(
 	if (target.valueMap.has(state.key)) {
 		return readFromCache(target, state, mut)
 	}
+	target.logger.info(`❔`, state.type, state.key, `value not found in cache`)
 	const { key } = state
 	switch (state.type) {
 		case `readonly_held_selector`:
@@ -32,31 +34,20 @@ export function readOrComputeValue<T>(
 			return state.getFrom(target)
 		case `atom`: {
 			let def: T
-			if (state.default instanceof Function) {
+			if (isFn(state.default)) {
 				def = state.default()
+				target.logger.info(`✨`, state.type, key, `computed default`, def)
 			} else {
 				def = state.default
+				target.logger.info(`✨`, state.type, key, `using static default`, def)
 			}
 			const cachedValue = writeToCache(target, state, def)
-			target.logger.info(
-				`💁`,
-				`atom`,
-				state.key,
-				`could not find cached value; using default`,
-				def,
-			)
 			return cachedValue
 		}
 		case `mutable_atom`: {
 			const instance = new state.class()
+			target.logger.info(`✨`, state.type, key, `created new instance`, instance)
 			const cachedValue = writeToCache(target, state, instance)
-			target.logger.info(
-				`💁`,
-				`mutable_atom`,
-				state.key,
-				`could not find cached value; using default`,
-				instance,
-			)
 			return cachedValue
 		}
 	}

package/src/internal/get-state/reduce-reference.ts

@@ -1,6 +1,12 @@
-import type { ReadableFamilyToken, ReadableToken } from "atom.io"
+import type {
+	ReadableFamilyToken,
+	ReadableToken,
+	StateCreationEvent,
+} from "atom.io"
 import { type Canonical, parseJson } from "atom.io/json"
 
+import type { ReadableFamily, Subject } from ".."
+import { isChildStore, isRootStore, newest } from ".."
 import { seekInStore } from "../families"
 import { getFamilyOfToken } from "../families/get-family-of-token"
 import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
@@ -13,27 +19,27 @@ export function reduceReference<T, K extends Canonical>(
 		| [token: ReadableFamilyToken<T, K>, key: K]
 		| [token: ReadableToken<T>]
 ): {
-	token: ReadableToken<T>
-	familyToken: ReadableFamilyToken<T, K> | undefined
+	token: ReadableToken<T, K>
+	family: ReadableFamily<T, K> | undefined
 	subKey: K | undefined
 	isNew: boolean
 } {
 	let existingToken: ReadableToken<T> | undefined
 	let brandNewToken: ReadableToken<T> | undefined
-	let familyToken: ReadableFamilyToken<T, K> | undefined
+	let family: ReadableFamily<T, K> | undefined
 	let subKey: K | undefined
 	let token: ReadableToken<T, K>
 	if (params.length === 1) {
 		token = params[0]
 		if (`family` in token) {
-			familyToken = getFamilyOfToken(store, token)
-			withdraw(store, familyToken)
+			const familyToken = getFamilyOfToken(store, token)
+			family = withdraw(store, familyToken) as ReadableFamily<T, K>
 			subKey = parseJson(token.family.subKey)
 			existingToken = seekInStore(store, familyToken, subKey)
 			if (`counterfeit` in token) {
 				return {
 					token,
-					familyToken,
+					family,
 					subKey,
 					isNew: false,
 				}
@@ -46,20 +52,55 @@ export function reduceReference<T, K extends Canonical>(
 			}
 		}
 	} else {
-		familyToken = params[0]
+		family = withdraw(store, params[0])
 		subKey = params[1]
-		existingToken = seekInStore(store, familyToken, subKey)
+		existingToken = seekInStore(store, family, subKey)
 		if (!existingToken) {
-			brandNewToken = mintInStore(store, familyToken, subKey, MUST_CREATE)
+			brandNewToken = mintInStore(store, family, subKey, MUST_CREATE)
 			token = brandNewToken
 		} else {
 			token = existingToken
 		}
 	}
 
+	const isCounterfeit = `counterfeit` in token
+	const isNewlyCreated = Boolean(brandNewToken) && isCounterfeit === false
+	if (isNewlyCreated && family) {
+		const stateCreationEvent: StateCreationEvent<ReadableToken<T>> = {
+			type: `state_creation`,
+			subType: `readable`,
+			token,
+			timestamp: Date.now(),
+		}
+		const familySubject = family.subject as Subject<StateCreationEvent<any>>
+		familySubject.next(stateCreationEvent)
+		const target = newest(store)
+		if (token.family) {
+			if (isRootStore(target)) {
+				switch (token.type) {
+					case `atom`:
+					case `mutable_atom`:
+						store.on.atomCreation.next(token)
+						break
+					case `writable_pure_selector`:
+					case `readonly_pure_selector`:
+					case `writable_held_selector`:
+					case `readonly_held_selector`:
+						store.on.selectorCreation.next(token)
+						break
+				}
+			} else if (
+				isChildStore(target) &&
+				target.on.transactionApplying.state === null
+			) {
+				target.transactionMeta.update.subEvents.push(stateCreationEvent)
+			}
+		}
+	}
+
 	return {
 		token,
-		familyToken,
+		family,
 		subKey,
 		isNew: Boolean(brandNewToken),
 	}

package/src/internal/index.ts

@@ -29,22 +29,22 @@ export * from "./arbitrary"
 export * from "./atom"
 export * from "./caching"
 export * from "./capitalize"
+export * from "./events"
 export * from "./families"
 export * from "./future"
 export * from "./get-environment-data"
 export * from "./get-state"
 export * from "./get-trace"
-export * from "./ingest-updates"
 export * from "./install-into-store"
 export * from "./join"
 export * from "./junction"
 export * from "./keys"
-export * from "./lazy-map"
 export * from "./lineage"
 export * from "./molecule"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
+export * from "./overlays"
 export * from "./reserved-keys"
 export * from "./selector"
 export * from "./set-state"