atom.io 0.37.1 → 0.38.1

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

@@ -9,66 +9,90 @@ import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
 import type { Store } from "../store"
-import { counterfeit } 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 function mintInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	familyToken: WritableFamilyToken<T, K>,
 	key: Key,
+	init?: typeof MUST_CREATE,
 ): WritableToken<T, K>
 export function mintInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	familyToken: ReadableFamilyToken<T, K>,
 	key: Key,
+	init?: typeof MUST_CREATE,
 ): ReadableToken<T, K>
 export function mintInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	familyToken: ReadableFamilyToken<T, K>,
 	key: Key,
+	shouldCreate?: 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 = counterfeit(familyToken, key)
-		store.logger.error(
-			`❌`,
-			fakeToken.type,
-			fakeToken.key,
-			`was not found in store "${store.config.name}"; returned a counterfeit token.`,
+		const fakeToken = mint(familyToken, key, COUNTERFEIT)
+		store.logger.warn(
+			`💣`,
+			`key`,
+			stringKey,
+			`was used to mint a counterfeit token for`,
+			familyToken.type,
+			`"${familyToken.key}"`,
 		)
 		return fakeToken
 	}
-	const newStateToken = initFamilyMemberInStore(store, familyToken, key)
-	const target = newest(store)
-	if (newStateToken.family) {
-		if (isRootStore(target)) {
-			switch (newStateToken.type) {
-				case `atom`:
-				case `mutable_atom`:
-					store.on.atomCreation.next(newStateToken)
-					break
-				case `writable_pure_selector`:
-				case `readonly_pure_selector`:
-				case `writable_held_selector`:
-				case `readonly_held_selector`:
-					store.on.selectorCreation.next(newStateToken)
-					break
+
+	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(),
+				})
 			}
-		} else if (
-			isChildStore(target) &&
-			target.on.transactionApplying.state === null
-		) {
-			target.transactionMeta.update.subEvents.push({
-				type: `state_creation`,
-				token: newStateToken,
-				timestamp: Date.now(),
-			})
 		}
+		if (molecule) {
+			target.moleculeData.set(stringKey, familyToken.key)
+		}
+	} else {
+		stateToken = mint(familyToken, key)
 	}
-	if (molecule) {
-		target.moleculeData.set(stringKey, familyToken.key)
-	}
-	return newStateToken
+	return stateToken
 }

package/src/internal/get-state/get-fallback.ts

@@ -0,0 +1,57 @@
+import type { ReadableToken } from "atom.io"
+import { type Canonical, stringifyJson } from "atom.io/json"
+
+import type { ReadableFamily } from ".."
+import type { Store } from "../store"
+
+export function getFallback<T, K extends Canonical>(
+	store: Store,
+	token: ReadableToken<T, K>,
+	family: ReadableFamily<T, K>,
+	subKey: K,
+): T {
+	const disposal = store.disposalTraces.buffer.find(
+		(item) => item?.key === stringifyJson(subKey),
+	)
+	store.logger.error(
+		`❌`,
+		token.type,
+		token.key,
+		`gets a fallback value because key`,
+		subKey,
+		`is not allocated`,
+		disposal
+			? `This key was previously disposed:\n${disposal.trace}`
+			: `(no previous disposal trace found)`,
+	)
+	switch (family.type) {
+		case `mutable_atom_family`: {
+			if (store.defaults.has(family.key)) {
+				return store.defaults.get(family.key)
+			}
+			const defaultValue = new family.class()
+			store.defaults.set(family.key, defaultValue)
+			return defaultValue
+		}
+		case `atom_family`: {
+			if (store.defaults.has(family.key)) {
+				return store.defaults.get(family.key)
+			}
+			const def = family.default as (key: K) => T
+			const defaultValue = def(subKey)
+			store.defaults.set(family.key, defaultValue)
+			return defaultValue
+		}
+		case `readonly_pure_selector_family`:
+		case `writable_pure_selector_family`:
+		case `readonly_held_selector_family`:
+		case `writable_held_selector_family`: {
+			if (store.defaults.has(family.key)) {
+				return store.defaults.get(family.key)
+			}
+			const defaultValue = family.default(subKey)
+			store.defaults.set(family.key, defaultValue)
+			return defaultValue
+		}
+	}
+}

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

@@ -1,10 +1,10 @@
 import type { ReadableFamilyToken, ReadableToken } from "atom.io"
-import { type Canonical, parseJson } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
-import { findInStore } from "../families"
-import type { Store } from "../store"
-import { withdraw } from "../store"
+import { type Store, withdraw } from "../store"
+import { getFallback } from "./get-fallback"
 import { readOrComputeValue } from "./read-or-compute-value"
+import { reduceReference } from "./reduce-reference"
 
 export function getFromStore<T>(store: Store, token: ReadableToken<T>): T
 
@@ -20,63 +20,13 @@ export function getFromStore(
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 		| [token: ReadableToken<any>]
 ): any {
-	let token: ReadableToken<any>
-	let family: ReadableFamilyToken<any, Canonical> | null
-	let key: Canonical | null
-	if (params.length === 1) {
-		token = params[0]
-	} else {
-		family = params[0]
-		key = params[1]
-		token = findInStore(store, family, key)
-	}
-	if (`counterfeit` in token && `family` in token) {
-		// biome-ignore lint/style/noNonNullAssertion: family must be present
-		family = store.families.get(token.family.key)!
-		const subKey = token.family.subKey
-		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === subKey,
-		)
-		store.logger.error(
-			`❌`,
-			token.type,
-			token.key,
-			`could not be retrieved because it was not found in the store "${store.config.name}".`,
-			disposal
-				? `This state was previously disposed:\n${disposal.trace}`
-				: `No previous disposal trace was found.`,
-		)
-		switch (family.type) {
-			case `mutable_atom_family`: {
-				if (store.defaults.has(family.key)) {
-					return store.defaults.get(family.key)
-				}
-				const mutableFamily = withdraw(store, family)
-				const defaultValue = new mutableFamily.class()
-				store.defaults.set(family.key, defaultValue)
-				return defaultValue
-			}
-			case `atom_family`: {
-				if (store.defaults.has(family.key)) {
-					return store.defaults.get(token.family.key)
-				}
-				const defaultValue = withdraw(store, family).default(parseJson(subKey))
-				store.defaults.set(family.key, defaultValue)
-				return defaultValue
-			}
-			case `readonly_pure_selector_family`:
-			case `writable_pure_selector_family`:
-			case `readonly_held_selector_family`:
-			case `writable_held_selector_family`: {
-				if (store.defaults.has(family.key)) {
-					return store.defaults.get(token.family.key)
-				}
-				const defaultValue = withdraw(store, family).default(parseJson(subKey))
-				store.defaults.set(family.key, defaultValue)
-				return defaultValue
-			}
-		}
+	const { token, familyToken, subKey } = reduceReference(store, ...params)
+
+	if (`counterfeit` in token && familyToken && subKey) {
+		const family = withdraw(store, familyToken)
+		return getFallback(store, token, family, subKey)
 	}
+	const state = withdraw(store, token)
 
-	return readOrComputeValue(store, withdraw(store, token))
+	return readOrComputeValue(store, state)
 }

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

@@ -0,0 +1,66 @@
+import type { ReadableFamilyToken, ReadableToken } from "atom.io"
+import { type Canonical, parseJson } from "atom.io/json"
+
+import { seekInStore } from "../families"
+import { getFamilyOfToken } from "../families/get-family-of-token"
+import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+
+export function reduceReference<T, K extends Canonical>(
+	store: Store,
+	...params:
+		| [token: ReadableFamilyToken<T, K>, key: K]
+		| [token: ReadableToken<T>]
+): {
+	token: ReadableToken<T>
+	familyToken: ReadableFamilyToken<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 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)
+			subKey = parseJson(token.family.subKey)
+			existingToken = seekInStore(store, familyToken, subKey)
+			if (`counterfeit` in token) {
+				return {
+					token,
+					familyToken,
+					subKey,
+					isNew: false,
+				}
+			}
+			if (!existingToken) {
+				brandNewToken = mintInStore(store, familyToken, subKey, MUST_CREATE)
+				token = brandNewToken
+			} else {
+				token = existingToken
+			}
+		}
+	} else {
+		familyToken = params[0]
+		subKey = params[1]
+		existingToken = seekInStore(store, familyToken, subKey)
+		if (!existingToken) {
+			brandNewToken = mintInStore(store, familyToken, subKey, MUST_CREATE)
+			token = brandNewToken
+		} else {
+			token = existingToken
+		}
+	}
+
+	return {
+		token,
+		familyToken,
+		subKey,
+		isNew: Boolean(brandNewToken),
+	}
+}

package/src/internal/index.ts

@@ -45,7 +45,6 @@ export * from "./molecule"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
-export * from "./pretty-print"
 export * from "./reserved-keys"
 export * from "./selector"
 export * from "./set-state"

package/src/internal/ingest-updates/ingest-creation-disposal.ts

@@ -8,7 +8,8 @@ import type {
 } from "atom.io"
 import { parseJson, stringifyJson } from "atom.io/json"
 
-import { disposeFromStore, findInStore } from "../families"
+import { disposeFromStore } from "../families"
+import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
 import {
 	allocateIntoStore,
 	claimWithinStore,
@@ -61,7 +62,7 @@ function createInStore(
 	if (familyMeta) {
 		const family = store.families.get(familyMeta.key)
 		if (family) {
-			findInStore(store, family, parseJson(familyMeta.subKey))
+			mintInStore(store, family, parseJson(familyMeta.subKey), MUST_CREATE)
 		}
 	}
 }
@@ -98,7 +99,7 @@ export function ingestMoleculeDisposalEvent(
 				for (const [familyKey, value] of update.values) {
 					const family = store.families.get(familyKey)
 					if (family) {
-						findInStore(store, family, update.key)
+						mintInStore(store, family, update.key, MUST_CREATE)
 						const memberKey = `${familyKey}(${stringifyJson(update.key)})`
 						store.valueMap.set(memberKey, value)
 					}

package/src/internal/molecule.ts

@@ -97,7 +97,7 @@ export function allocateIntoStore<
 		)
 		store.logger.error(
 			`❌`,
-			`molecule`,
+			`key`,
 			key,
 			`allocation failed:`,
 			`Could not allocate to ${claim} in store "${store.config.name}".`,
@@ -147,7 +147,7 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 		)
 		store.logger.error(
 			`❌`,
-			`molecule`,
+			`key`,
 			claim,
 			`deallocation failed:`,
 			`Could not find allocation for ${stringKey} in store "${store.config.name}".`,
@@ -244,8 +244,8 @@ export function claimWithinStore<
 		)
 		store.logger.error(
 			`❌`,
-			`molecule`,
-			claim,
+			`key`,
+			stringKey,
 			`claim failed:`,
 			`Could not allocate to ${stringKey} in store "${store.config.name}".`,
 			disposal
@@ -263,7 +263,7 @@ export function claimWithinStore<
 		)
 		store.logger.error(
 			`❌`,
-			`molecule`,
+			`key`,
 			claim,
 			`claim failed:`,
 			`Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,

package/src/internal/mutable/create-mutable-atom-family.ts

@@ -6,14 +6,11 @@ import type {
 	MutableAtomToken,
 	StateLifecycleEvent,
 } from "atom.io"
+import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import {
-	createWritablePureSelectorFamily,
-	type MutableAtomFamily,
-	prettyPrintTokenType,
-} from ".."
+import { createWritablePureSelectorFamily, type MutableAtomFamily } from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
@@ -41,9 +38,7 @@ export function createMutableAtomFamily<
 			`❗`,
 			`mutable_atom_family`,
 			options.key,
-			`Overwriting an existing ${prettyPrintTokenType(
-				existing,
-			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+			`Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
 		)
 	}
 

package/src/internal/mutable/get-json-token.ts

@@ -3,6 +3,7 @@ import type {
 	WritablePureSelectorFamilyToken,
 	WritablePureSelectorToken,
 } from "atom.io"
+import { parseJson } from "atom.io/json"
 
 import { findInStore } from "../families"
 import { newest } from "../lineage"
@@ -21,7 +22,7 @@ export const getJsonToken = <T extends Transceiver<any, any, any>>(
 			type: `writable_pure_selector_family`,
 		}
 		const family = withdraw(target, jsonFamilyToken)
-		const subKey = JSON.parse(mutableAtomToken.family.subKey)
+		const subKey = parseJson(mutableAtomToken.family.subKey)
 		const jsonToken = findInStore(store, family, subKey)
 		return jsonToken
 	}

package/src/internal/not-found-error.ts

@@ -1,13 +1,12 @@
-import type { AtomIOToken } from "atom.io"
+import { type AtomIOToken, PRETTY_TOKEN_TYPES } from "atom.io"
 import { stringifyJson } from "atom.io/json"
 
-import { prettyPrintTokenType } from "./pretty-print"
 import type { Store } from "./store"
 
 export class NotFoundError extends Error {
 	public constructor(token: AtomIOToken, store: Store) {
 		super(
-			`${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${
+			`${PRETTY_TOKEN_TYPES[token.type]} ${stringifyJson(token.key)} not found in store "${
 				store.config.name
 			}".`,
 		)

package/src/internal/operation.ts

@@ -23,7 +23,7 @@ export function openOperation(
 	if (store.operation.open) {
 		const rejectionTime = performance.now()
 		store.logger.info(
-			`❗`,
+			`🚫`,
 			token.type,
 			token.key,
 			`deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`,

package/src/internal/selector/register-selector.ts

@@ -7,13 +7,15 @@ import type {
 	WritableToken,
 	WriterToolkit,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import { findInStore } from "../families"
+import { getFallback } from "../get-state/get-fallback"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
+import { reduceReference } from "../get-state/reduce-reference"
 import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
-import { operateOnStore } from "../set-state/operate-on-store"
+import { JOIN_OP, operateOnStore } from "../set-state/operate-on-store"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import { updateSelectorAtoms } from "./update-selector-atoms"
@@ -31,48 +33,39 @@ export function registerSelector(
 	return {
 		get: (
 			...params:
-				| [ReadableFamilyToken<any, any>, Json.Serializable]
+				| [ReadableFamilyToken<any, any>, Canonical]
 				| [ReadableToken<any>]
 		) => {
 			const target = newest(store)
-			let dependency: ReadableToken<any>
-
-			if (params.length === 2) {
-				const [family, key] = params
-				dependency = findInStore(store, family, key)
+			const { token, familyToken, subKey } = reduceReference(store, ...params)
+			let dependencyValue: unknown
+			if (`counterfeit` in token && familyToken && subKey) {
+				const dependencyFamily = withdraw(store, familyToken)
+				dependencyValue = getFallback(store, token, dependencyFamily, subKey)
 			} else {
-				;[dependency] = params
+				const dependency = withdraw(store, token)
+				dependencyValue = readOrComputeValue(store, dependency)
 			}
 
-			const dependencyState = withdraw(store, dependency)
-			const dependencyValue = readOrComputeValue(store, dependencyState)
-			const dependencyKey = dependency.key
-
 			store.logger.info(
 				`🔌`,
 				selectorType,
 				selectorKey,
-				`registers dependency ( "${dependencyKey}" =`,
+				`registers dependency ( "${token.key}" =`,
 				dependencyValue,
 				`)`,
 			)
 
 			target.selectorGraph.set(
 				{
-					upstreamSelectorKey: dependencyKey,
+					upstreamSelectorKey: token.key,
 					downstreamSelectorKey: selectorKey,
 				},
 				{
-					source: dependency.key,
+					source: token.key,
 				},
 			)
-			updateSelectorAtoms(
-				store,
-				selectorType,
-				selectorKey,
-				dependency as any,
-				covered,
-			)
+			updateSelectorAtoms(store, selectorType, selectorKey, token, covered)
 			return dependencyValue
 		},
 		set: (<T, K extends Canonical, New extends T, Key extends K>(
@@ -85,7 +78,7 @@ export function registerSelector(
 				| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 		) => {
 			const target = newest(store)
-			operateOnStore(target, false, ...params)
+			operateOnStore(target, JOIN_OP, ...params)
 		}) as typeof setState,
 		find: ((...args: Parameters<typeof findState>) =>
 			findInStore(store, ...args)) as typeof findState,

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

@@ -1,4 +1,4 @@
-import type { ReadonlyPureSelectorToken, WritableToken } from "atom.io"
+import type { ReadableToken } from "atom.io"
 
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -12,7 +12,7 @@ export function updateSelectorAtoms(
 		| `writable_held_selector`
 		| `writable_pure_selector`,
 	selectorKey: string,
-	dependency: ReadonlyPureSelectorToken<unknown> | WritableToken<unknown>,
+	dependency: ReadableToken<unknown>,
 	covered: Set<string>,
 ): void {
 	const target = newest(store)

package/src/internal/set-state/operate-on-store.ts

@@ -3,7 +3,7 @@ import { type Canonical, parseJson } from "atom.io/json"
 
 import { seekInStore } from "../families"
 import { getFamilyOfToken } from "../families/get-family-of-token"
-import { mintInStore } from "../families/mint-in-store"
+import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
 import type { OpenOperation } from "../operation"
 import { closeOperation, openOperation } from "../operation"
 import { type Store, withdraw } from "../store"
@@ -12,9 +12,12 @@ import { resetAtomOrSelector } from "./reset-atom-or-selector"
 import { RESET_STATE } from "./reset-in-store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
+export const OWN_OP: unique symbol = Symbol(`OWN_OP`)
+export const JOIN_OP: unique symbol = Symbol(`JOIN_OP`)
+
 export function operateOnStore<T, New extends T>(
 	store: Store,
-	ownOp: boolean,
+	opMode: typeof JOIN_OP | typeof OWN_OP,
 	...params:
 		| [
 				token: WritableFamilyToken<T, Canonical>,
@@ -35,13 +38,12 @@ export function operateOnStore<T, New extends T>(
 	if (params.length === 2) {
 		token = params[0]
 		value = params[1]
-		if (token.family) {
-			// biome-ignore lint/style/noNonNullAssertion: this token belongs to a family
-			family = getFamilyOfToken(store, token)!
+		if (`family` in token) {
+			family = getFamilyOfToken(store, token)
 			key = parseJson(token.family.subKey)
 			existingToken = seekInStore(store, family, key)
 			if (!existingToken) {
-				brandNewToken = mintInStore(store, family, key)
+				brandNewToken = mintInStore(store, family, key, MUST_CREATE)
 				token = brandNewToken
 			} else {
 				token = existingToken
@@ -53,7 +55,7 @@ export function operateOnStore<T, New extends T>(
 		value = params[2]
 		existingToken = seekInStore(store, family, key)
 		if (!existingToken) {
-			brandNewToken = mintInStore(store, family, key)
+			brandNewToken = mintInStore(store, family, key, MUST_CREATE)
 			token = brandNewToken
 		} else {
 			token = existingToken
@@ -64,7 +66,7 @@ export function operateOnStore<T, New extends T>(
 
 	let target: Store & { operation: OpenOperation }
 
-	if (ownOp) {
+	if (opMode === OWN_OP) {
 		const result = openOperation(store, token)
 		const rejected = typeof result === `number`
 		if (rejected) {
@@ -81,7 +83,7 @@ export function operateOnStore<T, New extends T>(
 						action,
 						`from T-${rejectionTime}`,
 					)
-					operateOnStore(store, ownOp, token, value)
+					operateOnStore(store, opMode, token, value)
 				},
 			)
 			return
@@ -102,10 +104,12 @@ export function operateOnStore<T, New extends T>(
 			token.key,
 			`could not be`,
 			action,
-			`because it was not found in the store "${store.config.name}".`,
+			`because key`,
+			subKey,
+			`is not allocated.`,
 			disposal
-				? `This state was previously disposed:\n${disposal.trace}`
-				: `No previous disposal trace was found.`,
+				? `this key was previously disposed:${disposal.trace}`
+				: `(no previous disposal trace found)`,
 		)
 		return
 	}
@@ -120,7 +124,7 @@ export function operateOnStore<T, New extends T>(
 	const isNewlyCreated = Boolean(brandNewToken)
 	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated)
 
-	if (ownOp) {
+	if (opMode === OWN_OP) {
 		closeOperation(target)
 	}
 }