atom.io 0.37.0 → 0.38.0

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)
 	}
 }

package/src/internal/set-state/set-into-store.ts

@@ -2,7 +2,7 @@ import type { WritableFamilyToken, WritableToken } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import type { Store } from "../store"
-import { operateOnStore } from "./operate-on-store"
+import { operateOnStore, OWN_OP } from "./operate-on-store"
 import type { RESET_STATE } from "./reset-in-store"
 
 export function setIntoStore<T, New extends T>(
@@ -36,5 +36,5 @@ export function setIntoStore<T, New extends T>(
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 ): void {
-	operateOnStore(store, true, ...params)
+	operateOnStore(store, OWN_OP, ...params)
 }

package/src/internal/store/index.ts

@@ -1,5 +1,5 @@
 export * from "./circular-buffer"
-export * from "./counterfeit"
 export * from "./deposit"
+export * from "./mint-or-counterfeit"
 export * from "./store"
 export * from "./withdraw"

package/src/internal/store/{counterfeit.ts → mint-or-counterfeit.ts}

@@ -21,6 +21,8 @@ import { stringifyJson } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
 
+export const COUNTERFEIT: unique symbol = Symbol(`counterfeit`)
+
 export const FAMILY_MEMBER_TOKEN_TYPES = {
 	atom_family: `atom`,
 	molecule_family: `molecule`,
@@ -31,66 +33,76 @@ export const FAMILY_MEMBER_TOKEN_TYPES = {
 	writable_pure_selector_family: `writable_pure_selector`,
 } as const
 
-export function counterfeit<
+export function mint<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>
 
-export function counterfeit<T, K extends Canonical, Key extends K>(
+export function mint<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
+	counterfeit?: typeof COUNTERFEIT,
 ): RegularAtomToken<T>
 
-export function counterfeit<T, K extends Canonical, Key extends K>(
+export function mint<T, K extends Canonical, Key extends K>(
 	token: AtomFamilyToken<T, K>,
 	key: Key,
+	counterfeit?: typeof COUNTERFEIT,
 ): AtomToken<T>
 
-export function counterfeit<T, K extends Canonical, Key extends K>(
+export function mint<T, K extends Canonical, Key extends K>(
 	token: WritablePureSelectorFamilyToken<T, K>,
 	key: Key,
+	counterfeit?: typeof COUNTERFEIT,
 ): WritablePureSelectorToken<T>
 
-export function counterfeit<T, K extends Canonical, Key extends K>(
+export function mint<T, K extends Canonical, Key extends K>(
 	token: ReadonlyPureSelectorFamilyToken<T, K>,
 	key: Key,
+	counterfeit?: typeof COUNTERFEIT,
 ): ReadonlyPureSelectorToken<T>
 
-export function counterfeit<T, K extends Canonical, Key extends K>(
+export function mint<T, K extends Canonical, Key extends K>(
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
+	counterfeit?: typeof COUNTERFEIT,
 ): SelectorToken<T>
 
-export function counterfeit<T, K extends Canonical, Key extends K>(
+export function mint<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
+	counterfeit?: typeof COUNTERFEIT,
 ): WritableToken<T>
 
-export function counterfeit<T, K extends Canonical, Key extends K>(
+export function mint<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
+	counterfeit?: typeof COUNTERFEIT,
 ): ReadableToken<T>
 
-export function counterfeit(
+export function mint(
 	token: ReadableFamilyToken<any, any>,
 	key: Canonical,
+	counterfeit?: typeof COUNTERFEIT,
 ): ReadableToken<any> {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type]
-	const stateToken = {
+	const stateToken: ReadableToken<any> & {
+		counterfeit?: boolean
+	} = {
 		key: fullKey,
 		type,
-	} satisfies ReadableToken<any>
-
-	Object.assign(stateToken, {
 		family: {
 			key: token.key,
 			subKey,
 		},
-	})
+	}
+
+	if (counterfeit) {
+		stateToken.counterfeit = true
+	}
 
-	Object.assign(stateToken, { counterfeit: true })
 	return stateToken
 }

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

@@ -1,6 +1,7 @@
 import type { ReadableToken, StateUpdate, UpdateHandler } from "atom.io"
 
 import { readOrComputeValue } from "../get-state"
+import { reduceReference } from "../get-state/reduce-reference"
 import { traceRootSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 import { withdraw } from "../store"
@@ -25,6 +26,7 @@ export function subscribeToState<T>(
 			handleUpdate(update)
 		}
 	}
+	reduceReference(store, token)
 	const state = withdraw(store, token)
 	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`)
 	const isSelector =

package/src/internal/timeline/create-timeline.ts

@@ -13,6 +13,7 @@ import type {
 	TransactionToken,
 } from "atom.io"
 
+import { reduceReference } from "../get-state/reduce-reference"
 import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
 import { deposit, type Store, withdraw } from "../store"
@@ -130,6 +131,7 @@ function addAtomToTimeline(
 	atomToken: AtomToken<any>,
 	tl: Timeline<any>,
 ): void {
+	reduceReference(store, atomToken)
 	let maybeAtom = withdraw(store, atomToken)
 	if (maybeAtom.type === `mutable_atom`) {
 		const updateToken = getUpdateToken(maybeAtom)

package/src/json/index.ts

@@ -66,9 +66,9 @@ export type stringified<J extends Json.Serializable> = (
   )
 
 /** Type-safe wrapper for {@link JSON.parse} */
-export const parseJson = <S extends stringified<Json.Serializable>>(
-	str: S | string,
-): S extends stringified<infer J> ? J : Json.Serializable => JSON.parse(str)
+export const parseJson = <J extends Json.Serializable>(
+	str: stringified<J> | string,
+): J => JSON.parse(str)
 
 /** Type-safe wrapper for {@link JSON.stringify} */
 export const stringifyJson = <J extends Json.Serializable>(

package/src/main/logger.ts

@@ -8,10 +8,12 @@ const LOGGER_ICON_DICTIONARY = {
 	"⏹️": `Time-travel complete`,
 	"✅": `Realtime transaction success`,
 	"✨": `Computation complete`,
+	"💣": `Dangerous action likely to cause bad errors`,
+	"❗": `Dangerous action unless in development mode`,
 	"❌": `Conflict prevents attempted action`,
 	"⭕": `Operation start`,
 	"🔴": `Operation complete`,
-	"❗": `Operation blocked`,
+	"🚫": `Operation blocked`,
 	"🟢": `Operation unblocked`,
 	"🐞": `Possible bug in AtomIO`,
 	"👀": `Subscription added`,
@@ -55,8 +57,7 @@ export type TokenDenomination =
 	| `atom_family`
 	| `atom`
 	| `continuity`
-	| `molecule_family`
-	| `molecule`
+	| `key`
 	| `mutable_atom_family`
 	| `mutable_atom`
 	| `readonly_held_selector_family`
@@ -72,6 +73,27 @@ export type TokenDenomination =
 	| `writable_pure_selector_family`
 	| `writable_pure_selector`
 
+export const PRETTY_TOKEN_TYPES: Record<TokenDenomination, string> = {
+	atom_family: `atom family`,
+	atom: `atom`,
+	continuity: `continuity`,
+	key: `key`,
+	mutable_atom_family: `atom family [m]`,
+	mutable_atom: `atom [m]`,
+	readonly_held_selector_family: `selector family [h]`,
+	readonly_held_selector: `selector [h]`,
+	readonly_pure_selector_family: `selector family`,
+	readonly_pure_selector: `selector`,
+	state: `state`,
+	timeline: `timeline`,
+	transaction: `transaction`,
+	unknown: `unknown`,
+	writable_held_selector_family: `selector family [wh]`,
+	writable_held_selector: `selector [wh]`,
+	writable_pure_selector_family: `selector family [w]`,
+	writable_pure_selector: `selector [w]`,
+}
+
 export const LOG_LEVELS = [`info`, `warn`, `error`] as const
 export type LogLevel = (typeof LOG_LEVELS)[number]
 
@@ -93,7 +115,7 @@ export const simpleLog =
 	(icon, denomination, tokenKey, message, ...rest) => {
 		/* eslint-disable-next-line no-console */
 		console[logLevel](
-			`${icon} ${denomination} "${tokenKey}" ${message}`,
+			`${icon} ${PRETTY_TOKEN_TYPES[denomination]} \`${tokenKey}\` ${message}`,
 			...rest,
 		)
 	}

package/src/internal/pretty-print.ts

@@ -1,7 +0,0 @@
-import type { AtomIOToken } from "atom.io"
-
-import { capitalize } from "./capitalize"
-
-export function prettyPrintTokenType(token: AtomIOToken): string {
-	return token.type.split(`_`).map(capitalize).join(` `)
-}