atom.io 0.38.2 → 0.39.0

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

@@ -55,7 +55,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
 	}
 

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

@@ -22,6 +22,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`:
@@ -34,29 +35,18 @@ export function readOrComputeValue<T>(
 			let def: T
 			if (state.default instanceof Function) {
 				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"