atom.io 0.10.2 → 0.10.4

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

@@ -30,14 +30,19 @@ export function createAtom<T>(
 	store: Store = IMPLICIT.STORE,
 ): AtomToken<T> {
 	store.logger.info(
-		`🔨 creating atom "${options.key}" in store "${store.config.name}"`,
+		`🔨`,
+		`atom`,
+		options.key,
+		`creating in store "${store.config.name}"`,
 	)
 	const core = target(store)
 	const existing = core.atoms.get(options.key)
 	if (existing) {
 		store.logger.error(
-			`❓ Tried to create atom "${options.key}",`,
-			`but it already exists in the store.`,
+			`❌`,
+			`atom`,
+			options.key,
+			`Tried to create atom, but it already exists in the store.`,
 			`(Ignore if you are in development using hot module replacement.)`,
 		)
 		return deposit(existing)
@@ -47,8 +52,14 @@ export function createAtom<T>(
 		...options,
 		type: `atom`,
 		install: (store: Store) => {
+			// store.logger.info(
+			// 	`🛠️  installing atom "${options.key}" in store "${store.config.name}"`,
+			// )
 			store.logger.info(
-				`🛠️  installing atom "${options.key}" in store "${store.config.name}"`,
+				`🛠️`,
+				`atom`,
+				options.key,
+				`installing in store "${store.config.name}"`,
 			)
 			return `mutable` in options
 				? createMutableAtom(options, store)

package/internal/src/atom/delete-atom.ts

@@ -13,5 +13,5 @@ export function deleteAtom(
 	core.selectorAtoms.delete(key)
 	core.atomsThatAreDefault.delete(key)
 	core.timelineAtoms.delete(key)
-	store.logger.info(`🔥 Atom "${key}" deleted`)
+	store.logger.info(`🔥`, `atom`, `${key}`, `deleted`)
 }

package/internal/src/caching.ts

@@ -26,9 +26,9 @@ export const cacheValue = (
 				cacheValue(key, value, subject, store)
 				subject.next({ newValue: value, oldValue: value })
 			})
-			.catch((error) => {
-				if (error !== `canceled`) {
-					store.logger.error(`🙅‍♂️ Promised value for "${key}" rejected:`, error)
+			.catch((thrown) => {
+				if (thrown !== `canceled`) {
+					store.logger.error(`💥`, `state`, key, `rejected:`, thrown)
 				}
 			})
 	} else {
@@ -59,5 +59,5 @@ export const evictCachedValue = (
 		core.operation.prev.set(key, currentValue)
 	}
 	core.valueMap.delete(key)
-	store.logger.info(`🗑 evicted "${key}"`)
+	store.logger.info(`🗑`, `state`, key, `evicted`)
 }

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

@@ -9,15 +9,13 @@ export const getState__INTERNAL = <T>(
 	store: Store = IMPLICIT.STORE,
 ): T => {
 	if (isValueCached(state.key, store)) {
-		store.logger.info(`📖 reading "${state.key}"`)
+		store.logger.info(`📖`, state.type, state.key, `reading cached value`)
 		return readCachedValue(state.key, store)
 	}
 	if (state.type !== `atom`) {
-		store.logger.info(`🧮 calculating "${state.key}"`)
+		store.logger.info(`🧮`, state.type, state.key, `calculating value`)
 		return state.get()
 	}
-	store.logger.error(
-		`🐞 Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`,
-	)
+	store.logger.error(`🐞`, `atom`, state.key, `could not find cached value`)
 	return state.default
 }

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

@@ -18,7 +18,10 @@ export function createMutableAtom<
 	store: Store = IMPLICIT.STORE,
 ): MutableAtomToken<Core, SerializableCore> {
 	store.logger.info(
-		`🔧 creating mutable atom "${options.key}" in store "${store.config.name}"`,
+		`🔧`,
+		`atom`,
+		options.key,
+		`creating in store "${store.config.name}"`,
 	)
 	const coreState = createAtom<Core>(options, undefined, store)
 	new Tracker(coreState, store)
@@ -26,15 +29,6 @@ export function createMutableAtom<
 	subscribe(
 		jsonState,
 		() => {
-			store.logger.info(
-				`🔍 tracker-initializer:${store?.config.name}:${
-					store.transactionStatus.phase === `idle`
-						? `main`
-						: store.transactionStatus.key
-				}`,
-				`Initializing tracker for ${coreState.key}`,
-			)
-
 			const trackerHasBeenInitialized = target(store).trackers.has(coreState.key)
 			if (!trackerHasBeenInitialized) {
 				new Tracker(coreState, store)

package/internal/src/operation.ts

@@ -23,7 +23,10 @@ export const openOperation = (
 	const core = target(store)
 	if (core.operation.open) {
 		store.logger.error(
-			`❌ failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`,
+			`❌`,
+			token.type,
+			token.key,
+			`failed to setState during a setState for "${core.operation.token.key}"`,
 		)
 		return `rejection`
 	}
@@ -35,9 +38,10 @@ export const openOperation = (
 		token,
 	}
 	store.logger.info(
-		`⭕ Operation start from ${token.type} "${token.key}" in store "${
-			store.config.name
-		}"${
+		`⭕`,
+		token.type,
+		token.key,
+		`operation start in store "${store.config.name}"${
 			store.transactionStatus.phase === `idle`
 				? ``
 				: ` ${store.transactionStatus.phase} "${store.transactionStatus.key}"`
@@ -48,7 +52,10 @@ export const closeOperation = (store: Store): void => {
 	const core = target(store)
 	if (core.operation.open) {
 		store.logger.info(
-			`🔴 Operation done for ${core.operation.token.type} "${core.operation.token.key}" in store ${store.config.name}`,
+			`🔴`,
+			core.operation.token.type,
+			core.operation.token.key,
+			`operation done in store "${store.config.name}"`,
 		)
 	}
 	core.operation = { open: false }
@@ -59,7 +66,10 @@ export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
 	const core = target(store)
 	if (!core.operation.open) {
 		store.logger.warn(
-			`🐞 isDone called outside of an operation. This is probably a bug.`,
+			`🐞`,
+			`unknown`,
+			key,
+			`isDone called outside of an operation. This is probably a bug.`,
 		)
 		return true
 	}
@@ -69,7 +79,10 @@ export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
 	const core = target(store)
 	if (!core.operation.open) {
 		store.logger.warn(
-			`🐞 markDone called outside of an operation. This is probably a bug.`,
+			`🐞`,
+			`unknown`,
+			key,
+			`markDone called outside of an operation. This is probably a bug.`,
 		)
 		return
 	}

package/internal/src/selector/create-read-write-selector.ts

@@ -27,7 +27,17 @@ export const createReadWriteSelector = <T>(
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
 		const oldValue = getSelf()
 		const newValue = become(next)(oldValue)
-		store.logger.info(`📝 set "${options.key}" (`, oldValue, `->`, newValue, `)`)
+		// store.logger.info(`📝 set "${options.key}" (`, oldValue, `->`, newValue, `)`)
+		store.logger.info(
+			`📝`,
+			`selector`,
+			options.key,
+			`set (`,
+			oldValue,
+			`->`,
+			newValue,
+			`)`,
+		)
 		cacheValue(options.key, newValue, subject, store)
 		markDone(options.key, store)
 		if (store.transactionStatus.phase === `idle`) {
@@ -46,7 +56,7 @@ export const createReadWriteSelector = <T>(
 	}
 	core.selectors.set(options.key, mySelector)
 	const initialValue = getSelf()
-	store.logger.info(`✨ "${options.key}" =`, initialValue)
+	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue)
 	const token: SelectorToken<T> = {
 		key: options.key,
 		type: `selector`,

package/internal/src/selector/create-readonly-selector.ts

@@ -36,7 +36,13 @@ export const createReadonlySelector = <T>(
 	}
 	core.readonlySelectors.set(options.key, readonlySelector)
 	const initialValue = getSelf()
-	store.logger.info(`✨ "${options.key}" =`, initialValue)
+	store.logger.info(
+		`✨`,
+		readonlySelector.type,
+		readonlySelector.key,
+		`=`,
+		initialValue,
+	)
 	const token: ReadonlySelectorToken<T> = {
 		key: options.key,
 		type: `readonly_selector`,

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

@@ -52,11 +52,10 @@ export function createSelector<T>(
 
 	if (existingWritable || existingReadonly) {
 		store.logger.error(
-			`❓ Tried to create ${
-				existingReadonly ? `readonly selector` : `selector`
-			}`,
-			`"${options.key}", but it already exists in the store.`,
-			`(Ignore if you are in development using hot module replacement.)`,
+			`❌`,
+			existingReadonly ? `readonly_selector` : `selector`,
+			options.key,
+			`Tried to create selector, but it already exists in the store. (Ignore if you are in development using hot module replacement.)`,
 		)
 	}
 

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

@@ -26,8 +26,14 @@ export const registerSelector = (
 		const dependencyValue = getState__INTERNAL(dependencyState, store)
 
 		store.logger.info(
-			`🔌 selector "${selectorKey}" registers dependency ( "${dependency.key}" = ${dependencyValue} )`,
+			`🔌`,
+			`selector`,
+			selectorKey,
+			`registers dependency ( "${dependency.key}" =`,
+			dependencyValue,
+			`)`,
 		)
+
 		if (!alreadyRegistered) {
 			core.selectorGraph = core.selectorGraph.set(
 				{

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

@@ -16,13 +16,20 @@ export const updateSelectorAtoms = (
 			atomKey: dependency.key,
 		})
 		store.logger.info(
-			`🔍 selector "${selectorKey}" discovers root atom "${dependency.key}"`,
+			`🔍`,
+			`selector`,
+			selectorKey,
+			`discovers root atom "${dependency.key}"`,
 		)
 	} else {
 		const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store)
 		store.logger.info(
-			`🔍 selector "${selectorKey}" discovers root atoms:`,
-			rootKeys.map((r) => r),
+			`🔍`,
+			`selector`,
+			selectorKey,
+			`discovers root atoms: [ ${rootKeys
+				.map((key) => `"${key}"`)
+				.join(`, `)} ]`,
 		)
 		for (const atomKey of rootKeys) {
 			core.selectorAtoms = core.selectorAtoms.set({

package/internal/src/set-state/copy-mutable-if-needed.ts

@@ -13,7 +13,7 @@ export function copyMutableIfNeeded<T>(
 	const originValue = origin.valueMap.get(atom.key)
 	const targetValue = target.valueMap.get(atom.key)
 	if (originValue === targetValue) {
-		origin.logger.info(`📃 copying`, `${atom.key}`)
+		origin.logger.info(`📃`, `atom`, `${atom.key}`, `copying`)
 		const copiedValue = transform.fromJson(transform.toJson(originValue))
 		target.valueMap.set(atom.key, copiedValue)
 		new Tracker(atom, origin)

package/internal/src/set-state/copy-mutable-in-transaction.ts

@@ -14,9 +14,6 @@ export function copyMutableIfWithinTransaction<T>(
 		store.transactionStatus.phase === `applying`
 	) {
 		if (`toJson` in atom && `fromJson` in atom) {
-			store.logger.info(
-				`📄 copyMutableIfWithinTransaction: ${atom.key} is mutable`,
-			)
 			const copiedValue = copyMutableIfNeeded(
 				atom,
 				atom,

package/internal/src/set-state/emit-update.ts

@@ -12,14 +12,14 @@ export const emitUpdate = <T>(
 	const { key } = state
 	const { logger } = store
 	logger.info(
-		`📢 ${state.type} "${key}" went (`,
+		`📢`,
+		state.type,
+		state.key,
+		`went (`,
 		update.oldValue,
 		`->`,
 		update.newValue,
-		`)`,
-	)
-	logger.info(
-		`📢 notifying subscribers to "${state.key}"`,
+		`) subscribers:`,
 		state.subject.subscribers,
 	)
 	state.subject.next(update)

package/internal/src/set-state/evict-downstream.ts

@@ -6,34 +6,31 @@ import { IMPLICIT } from "../store"
 import { target } from "../transaction"
 
 export const evictDownStream = <T>(
-	state: Atom<T>,
+	atom: Atom<T>,
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	const downstreamKeys = core.selectorAtoms.getRelatedKeys(state.key)
+	const downstreamKeys = core.selectorAtoms.getRelatedKeys(atom.key)
 	store.logger.info(
-		`🧹 evicting ${downstreamKeys?.size ?? 0} states downstream from ${
-			state.type
-		} "${state.key}":`,
+		`🧹`,
+		atom.type,
+		atom.key,
+		`evicting ${downstreamKeys?.size ?? 0} states downstream:`,
 		downstreamKeys,
 	)
 	if (downstreamKeys !== undefined) {
 		if (core.operation.open) {
 			store.logger.info(
-				`🧹 [ ${[...core.operation.done].join(`, `)} ] already done`,
+				`🧹`,
+				atom.type,
+				atom.key,
+				`[ ${[...core.operation.done].join(`, `)} ] already done`,
 			)
 		}
 		for (const key of downstreamKeys) {
 			if (isDone(key, store)) {
 				continue
 			}
-			const state = core.selectors.get(key) ?? core.readonlySelectors.get(key)
-			if (!state) {
-				store.logger.error(
-					`🐞 "${key}" was not found in selectors or readonlySelectors`,
-				)
-				return
-			}
 			evictCachedValue(key, store)
 			markDone(key, store)
 		}

package/internal/src/set-state/set-atom.ts

@@ -19,7 +19,7 @@ export const setAtom = <T>(
 	const oldValue = getState__INTERNAL(atom, store)
 	let newValue = copyMutableIfWithinTransaction(atom, store)
 	newValue = become(next)(newValue)
-	store.logger.info(`📝 setting atom "${atom.key}" to`, newValue)
+	store.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
 	cacheValue(atom.key, newValue, atom.subject, store)
 	if (isAtomDefault(atom.key, store)) {
 		markAtomAsNotDefault(atom.key, store)

package/internal/src/set-state/stow-update.ts

@@ -23,8 +23,11 @@ export const stowUpdate = <T>(
 ): void => {
 	const { key } = state
 	if (store.transactionStatus.phase !== `building`) {
-		store.logger.warn(
-			`🐞 stowUpdate called outside of a transaction. This is probably a bug.`,
+		store.logger.error(
+			`🐞`,
+			`atom`,
+			key,
+			`stowUpdate called outside of a transaction. This is probably a bug.`,
 		)
 		return
 	}
@@ -38,7 +41,10 @@ export const stowUpdate = <T>(
 	}
 	store.transactionStatus.atomUpdates.push(atomUpdate)
 	store.logger.info(
-		`📁 ${key} stowed (`,
+		`📁`,
+		`atom`,
+		key,
+		`stowed (`,
 		update.oldValue,
 		`->`,
 		update.newValue,

package/internal/src/store/store.ts

@@ -1,4 +1,4 @@
-import { AtomIOLogger } from "atom.io"
+import { AtomIOLogger, simpleLogger } from "atom.io"
 import type {
 	AtomFamily,
 	AtomToken,
@@ -100,34 +100,23 @@ export class Store {
 	}
 
 	public loggers: AtomIOLogger[] = [
-		new AtomIOLogger(
-			{ ...console },
-			`warn`,
-			(message) => !message.includes(`👁‍🗨`),
-		),
+		new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`👁‍🗨`)),
 	]
 	public logger: Logger = {
-		error: (...messages: unknown[]) => {
-			for (const logger of this.loggers) {
-				logger.error(...messages)
-			}
+		error: (...messages) => {
+			for (const logger of this.loggers) logger.error(...messages)
 		},
-		info: (...messages: unknown[]) => {
-			for (const logger of this.loggers) {
-				logger.info(...messages)
-			}
+		info: (...messages) => {
+			for (const logger of this.loggers) logger.info(...messages)
 		},
-		warn: (...messages: unknown[]) => {
-			for (const logger of this.loggers) {
-				logger.warn(...messages)
-			}
+		warn: (...messages) => {
+			for (const logger of this.loggers) logger.warn(...messages)
 		},
 	}
 
 	public constructor(name: string, store: Store | null = null) {
 		if (store !== null) {
 			this.valueMap = new Map(store?.valueMap)
-
 			this.operation = { ...store?.operation }
 			this.transactionStatus = { ...store?.transactionStatus }
 			this.config = {

package/internal/src/store/withdraw-new-family-member.ts

@@ -37,7 +37,10 @@ export function withdrawNewFamilyMember<T>(
 	store: Store,
 ): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined {
 	store.logger.info(
-		`👪 creating new family member "${token.key}" in store "${store.config.name}"`,
+		`👪`,
+		token.type,
+		token.key,
+		`creating new family member in store "${store.config.name}"`,
 	)
 	if (token.family) {
 		const core = target(store)

package/internal/src/store/withdraw.ts

@@ -78,7 +78,12 @@ export function withdraw<T>(
 			core.timelines.get(token.key)
 
 		if (state) {
-			store.logger.info(`🛠️ add ${token.type} "${token.key}"`)
+			store.logger.info(
+				`🛠️`,
+				token.type,
+				token.key,
+				`add ${token.type} "${token.key}"`,
+			)
 			switch (state.type) {
 				case `atom`: {
 					store.atoms.set(token.key, state)

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

@@ -11,7 +11,10 @@ export const recallState = <T>(
 	const core = target(store)
 	if (!core.operation.open) {
 		store.logger.warn(
-			`🐞 recall called outside of an operation. This is probably a bug.`,
+			`🐞`,
+			state.type,
+			state.key,
+			`recall called outside of an operation. This is probably a bug.`,
 		)
 		return core.valueMap.get(state.key)
 	}

package/internal/src/subscribe/subscribe-to-root-atoms.ts

@@ -22,21 +22,27 @@ export const subscribeToRootAtoms = <T>(
 						`${state.type}:${state.key}`,
 						(atomChange) => {
 							store.logger.info(
-								`📢 selector "${state.key}" saw root "${atomKey}" go (`,
+								`📢`,
+								state.type,
+								state.key,
+								`root`,
+								atomKey,
+								`went`,
 								atomChange.oldValue,
 								`->`,
 								atomChange.newValue,
-								`)`,
 							)
 							const oldValue = recallState(state, store)
-							// ❗ this retrieves a stale cached value when applying a transaction on the server
+							// ❌ this retrieves a stale cached value when applying a transaction on the server
 							const newValue = getState__INTERNAL(state, store)
 							store.logger.info(
-								`✨ "${state.key}" went (`,
+								`✨`,
+								state.type,
+								state.key,
+								`went`,
 								oldValue,
 								`->`,
 								newValue,
-								`)`,
 							)
 							state.subject.next({ newValue, oldValue })
 						},

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -38,16 +38,32 @@ export const addAtomToTimeline = (
 				? store.transactionStatus.time
 				: null
 
+		// store.logger.info(
+		// 	`⏳ timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
+		// 	update.oldValue,
+		// 	`->`,
+		// 	update.newValue,
+		// 	currentTransactionKey
+		// 		? `) in transaction "${currentTransactionKey}"`
+		// 		: currentSelectorKey
+		// 		? `) in selector "${currentSelectorKey}"`
+		// 		: `)`,
+		// )
 		store.logger.info(
-			`⏳ timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
+			`⏳`,
+			`timeline`,
+			tl.key,
+			`atom`,
+			atomToken.key,
+			`went`,
 			update.oldValue,
 			`->`,
 			update.newValue,
 			currentTransactionKey
-				? `) in transaction "${currentTransactionKey}"`
+				? `in transaction "${currentTransactionKey}"`
 				: currentSelectorKey
-				? `) in selector "${currentSelectorKey}"`
-				: `)`,
+				? `in selector "${currentSelectorKey}"`
+				: ``,
 		)
 
 		if (tl.timeTraveling === null) {
@@ -75,7 +91,10 @@ export const addAtomToTimeline = (
 				if (tl.transactionKey !== currentTransactionKey) {
 					if (tl.transactionKey) {
 						store.logger.error(
-							`🐞 Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`,
+							`🐞`,
+							`timeline`,
+							tl.key,
+							`unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`,
 						)
 					}
 					tl.transactionKey = currentTransactionKey
@@ -119,7 +138,10 @@ export const addAtomToTimeline = (
 							}
 							tl.transactionKey = null
 							store.logger.info(
-								`⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`,
+								`⌛`,
+								`timeline`,
+								tl.key,
+								`got a transaction_update "${update.key}"`,
 							)
 						},
 					)
@@ -146,7 +168,10 @@ export const addAtomToTimeline = (
 					tl.history.push(latestUpdate)
 
 					store.logger.info(
-						`⌛ timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
+						`⌛`,
+						`timeline`,
+						tl.key,
+						`got a selector_update "${currentSelectorKey}" with`,
 						latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
 					)
 
@@ -160,7 +185,10 @@ export const addAtomToTimeline = (
 							...update,
 						})
 						store.logger.info(
-							`⌛ timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
+							`⌛`,
+							`timeline`,
+							tl.key,
+							`set selector_update "${currentSelectorKey}" to`,
 							latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
 						)
 					}
@@ -193,7 +221,10 @@ export const addAtomToTimeline = (
 				}
 				const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true
 				store.logger.info(
-					`⌛ timeline "${tl.key}" got an atom_update to "${atom.key}"`,
+					`⌛`,
+					`timeline`,
+					tl.key,
+					`got an atom_update to "${atom.key}"`,
 				)
 				if (willCapture) {
 					tl.history.push(atomUpdate)