atom.io 0.37.1 → 0.38.0

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