atom.io 0.12.1 → 0.13.0

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

@@ -9,10 +9,10 @@ import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import { createAtom } from "../atom"
+import { newest } from "../lineage"
 import { deposit, withdraw } from "../store"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import { target } from "../transaction"
 
 export function createAtomFamily<T, K extends Json.Serializable>(
 	options: AtomFamilyOptions<T, K>,
@@ -54,7 +54,7 @@ export function createAtomFamily<T, K extends Json.Serializable>(
 			subject,
 		} as const,
 	)
-	const core = target(store)
-	core.families.set(options.key, atomFamily)
+	const target = newest(store)
+	target.families.set(options.key, atomFamily)
 	return atomFamily
 }

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

@@ -7,23 +7,23 @@ import type {
 import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import { newest } from "../lineage"
 import { createSelector } from "../selector"
 import { type Store, deposit } from "../store"
 import { Subject } from "../subject"
-import { target } from "../transaction"
 
 export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
 ): ReadonlySelectorFamily<T, K> {
-	const core = target(store)
 	const subject = new Subject<ReadonlySelectorToken<T>>()
 	return Object.assign(
 		(key: K): ReadonlySelectorToken<T> => {
+			const target = newest(store)
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = core.readonlySelectors.get(fullKey)
+			const existing = target.readonlySelectors.get(fullKey)
 			if (existing) {
 				return deposit(existing)
 			}

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

@@ -9,11 +9,11 @@ import type {
 import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import { newest } from "../lineage"
 import { createSelector } from "../selector"
 import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
-import { target } from "../transaction"
 import { createReadonlySelectorFamily } from "./create-readonly-selector-family"
 
 export function createSelectorFamily<T, K extends Json.Serializable>(
@@ -33,7 +33,7 @@ export function createSelectorFamily<T, K extends Json.Serializable>(
 	if (isReadonly) {
 		return createReadonlySelectorFamily(options, store)
 	}
-	const core = target(store)
+	const target = newest(store)
 	const subject = new Subject<SelectorToken<T>>()
 
 	const selectorFamily = Object.assign(
@@ -41,7 +41,7 @@ export function createSelectorFamily<T, K extends Json.Serializable>(
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = core.selectors.get(fullKey)
+			const existing = target.selectors.get(fullKey)
 			if (existing) {
 				return deposit(existing)
 			}
@@ -62,6 +62,6 @@ export function createSelectorFamily<T, K extends Json.Serializable>(
 			type: `selector_family`,
 		} as const,
 	) as SelectorFamily<T, K>
-	core.families.set(options.key, selectorFamily)
+	target.families.set(options.key, selectorFamily)
 	return selectorFamily
 }

package/internal/src/index.ts

@@ -1,5 +1,6 @@
 export * from "./atom"
 export * from "./caching"
+export * from "./lineage"
 export * from "./families"
 export * from "./future"
 export * from "./keys"

package/internal/src/keys.ts

@@ -1,5 +1,5 @@
+import { newest } from "./lineage"
 import type { Store } from "./store"
-import { target } from "./transaction"
 
 export type AtomKey<T> = string & { __atomKey?: never; __brand?: T }
 export type SelectorKey<T> = string & { __selectorKey?: never; __brand?: T }
@@ -9,16 +9,16 @@ export type ReadonlySelectorKey<T> = string & {
 }
 
 export const isAtomKey = (key: string, store: Store): key is AtomKey<unknown> =>
-	target(store).atoms.has(key)
+	newest(store).atoms.has(key)
 export const isSelectorKey = (
 	key: string,
 	store: Store,
-): key is SelectorKey<unknown> => target(store).selectors.has(key)
+): key is SelectorKey<unknown> => newest(store).selectors.has(key)
 export const isReadonlySelectorKey = (
 	key: string,
 	store: Store,
 ): key is ReadonlySelectorKey<unknown> =>
-	target(store).readonlySelectors.has(key)
+	newest(store).readonlySelectors.has(key)
 
 export type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>
 export const isStateKey = (

package/internal/src/lazy-map.ts

@@ -12,13 +12,17 @@ export class LazyMap<K, V> extends Map<K, V> {
 		}
 		if (!this.deleted.has(key) && this.source.has(key)) {
 			const value = this.source.get(key)
-			super.set(key, value as V)
 			return value
 		}
 		return undefined
 	}
 
-	public _has(key: K): boolean {
+	public set(key: K, value: V): this {
+		this.deleted.delete(key)
+		return super.set(key, value)
+	}
+
+	public hasOwn(key: K): boolean {
 		return super.has(key)
 	}
 

package/internal/src/lineage.ts

@@ -0,0 +1,18 @@
+export interface Lineage {
+	parent: typeof this | null
+	child: typeof this | null
+}
+
+export function newest<T extends Lineage>(scion: T): T {
+	while (scion.child !== null) {
+		scion = scion.child
+	}
+	return scion
+}
+
+export function eldest<T extends Lineage>(scion: T): T {
+	while (scion.parent !== null) {
+		scion = scion.parent
+	}
+	return scion
+}

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

@@ -4,8 +4,8 @@ import type { Json } from "atom.io/json"
 import { selectJson } from "atom.io/json"
 
 import { createAtom } from "../atom"
+import { newest } from "../lineage"
 import type { Store } from "../store"
-import { target } from "../transaction"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
@@ -25,18 +25,19 @@ export function createMutableAtom<
 	const coreState = createAtom<Core>(options, undefined, store)
 	new Tracker(coreState, store)
 	const jsonState = selectJson(coreState, options, store)
+	const target = newest(store)
 	subscribe(
 		jsonState,
 		() => {
-			const trackerHasBeenInitialized = target(store).trackers.has(coreState.key)
+			const trackerHasBeenInitialized = newest(store).trackers.has(coreState.key)
 			if (!trackerHasBeenInitialized) {
 				new Tracker(coreState, store)
 			}
 		},
 		`tracker-initializer:${store?.config.name}:${
-			store.transactionStatus.phase === `idle`
+			target.transactionMeta === null
 				? `main`
-				: store.transactionStatus.key
+				: `${target.transactionMeta.update.key}`
 		}`,
 	)
 	return coreState as MutableAtomToken<Core, SerializableCore>

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

@@ -1,8 +1,8 @@
 import type { MutableAtomFamily, SelectorFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 
+import { newest } from "../lineage"
 import type { Store } from "../store"
-import { target } from "../transaction"
 import type { Transceiver } from "./transceiver"
 
 export const getJsonFamily = <
@@ -13,9 +13,9 @@ export const getJsonFamily = <
 	mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>,
 	store: Store,
 ): SelectorFamily<SerializableCore, Key> => {
-	const core = target(store)
+	const target = newest(store)
 	const key = `${mutableAtomFamily.key}:JSON`
-	const jsonFamily: SelectorFamily<SerializableCore, Key> = core.families.get(
+	const jsonFamily: SelectorFamily<SerializableCore, Key> = target.families.get(
 		key,
 	) as SelectorFamily<SerializableCore, Key>
 	return jsonFamily

package/internal/src/mutable/tracker.ts

@@ -3,8 +3,8 @@ import { getState, setState, subscribe, subscribeToTimeline } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
+import { newest } from ".."
 import { createAtom, deleteAtom } from "../atom"
-import { target } from "../transaction"
 import type { Transceiver } from "./transceiver"
 
 /**
@@ -48,11 +48,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		store: Store,
 	): void {
 		const originalInnerValue = getState(mutableState, store)
+		const target = newest(store)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			`tracker:${store.config.name}:${
-				store.transactionStatus.phase === `idle`
+				target.transactionMeta === null
 					? `main`
-					: store.transactionStatus.key
+					: target.transactionMeta.update.key
 			}`,
 			(update) => {
 				const unsubscribe = store.subject.operationStatus.subscribe(
@@ -69,11 +70,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			(update) => {
 				if (update.newValue !== update.oldValue) {
 					this.unsubscribeFromInnerValue?.()
+					const target = newest(store)
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						`tracker:${store.config.name}:${
-							store.transactionStatus.phase === `idle`
+							target.transactionMeta === null
 								? `main`
-								: store.transactionStatus.key
+								: target.transactionMeta.update.key
 						}`,
 						(update) => {
 							const unsubscribe = store.subject.operationStatus.subscribe(
@@ -136,6 +138,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 						const updateNumber = mutable.getUpdateNumber(newValue)
 						const eventOffset = updateNumber - mutable.cacheUpdateNumber
 						if (newValue && eventOffset === 1) {
+							// ❗ new:"0=add:\"myHand\"",old:"0=add:\"deckId\""
 							setState(
 								mutableState,
 								(transceiver) => (transceiver.do(newValue), transceiver),
@@ -158,10 +161,10 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		store: Store,
 	) {
 		this.mutableState = mutableState
-		this.latestUpdateState = this.initializeState(mutableState, store)
-		this.observeCore(mutableState, this.latestUpdateState, store)
-		this.updateCore(mutableState, this.latestUpdateState, store)
-		const core = target(store)
-		core.trackers.set(mutableState.key, this)
+		const target = newest(store)
+		this.latestUpdateState = this.initializeState(mutableState, target)
+		this.observeCore(mutableState, this.latestUpdateState, target)
+		this.updateCore(mutableState, this.latestUpdateState, target)
+		target.trackers.set(mutableState.key, this)
 	}
 }

package/internal/src/operation.ts

@@ -1,7 +1,7 @@
 import type { StateToken } from "atom.io"
 
+import { newest } from "./lineage"
 import type { Store } from "./store"
-import { target } from "./transaction"
 
 export type OperationProgress =
 	| {
@@ -19,17 +19,17 @@ export const openOperation = (
 	token: StateToken<any>,
 	store: Store,
 ): `rejection` | undefined => {
-	const core = target(store)
-	if (core.operation.open) {
+	const target = newest(store)
+	if (target.operation.open) {
 		store.logger.error(
 			`❌`,
 			token.type,
 			token.key,
-			`failed to setState during a setState for "${core.operation.token.key}"`,
+			`failed to setState during a setState for "${target.operation.token.key}"`,
 		)
 		return `rejection`
 	}
-	core.operation = {
+	target.operation = {
 		open: true,
 		done: new Set(),
 		prev: new Map(),
@@ -41,29 +41,29 @@ export const openOperation = (
 		token.type,
 		token.key,
 		`operation start in store "${store.config.name}"${
-			store.transactionStatus.phase === `idle`
+			target.transactionMeta === null
 				? ``
-				: ` ${store.transactionStatus.phase} "${store.transactionStatus.key}"`
+				: ` ${target.transactionMeta.phase} "${target.transactionMeta.update.key}"`
 		}`,
 	)
 }
 export const closeOperation = (store: Store): void => {
-	const core = target(store)
-	if (core.operation.open) {
+	const target = newest(store)
+	if (target.operation.open) {
 		store.logger.info(
 			`🔴`,
-			core.operation.token.type,
-			core.operation.token.key,
+			target.operation.token.type,
+			target.operation.token.key,
 			`operation done in store "${store.config.name}"`,
 		)
 	}
-	core.operation = { open: false }
-	store.subject.operationStatus.next(core.operation)
+	target.operation = { open: false }
+	store.subject.operationStatus.next(target.operation)
 }
 
 export const isDone = (key: string, store: Store): boolean => {
-	const core = target(store)
-	if (!core.operation.open) {
+	const target = newest(store)
+	if (!target.operation.open) {
 		store.logger.warn(
 			`🐞`,
 			`unknown`,
@@ -72,11 +72,11 @@ export const isDone = (key: string, store: Store): boolean => {
 		)
 		return true
 	}
-	return core.operation.done.has(key)
+	return target.operation.done.has(key)
 }
 export const markDone = (key: string, store: Store): void => {
-	const core = target(store)
-	if (!core.operation.open) {
+	const target = newest(store)
+	if (!target.operation.open) {
 		store.logger.warn(
 			`🐞`,
 			`unknown`,
@@ -85,5 +85,5 @@ export const markDone = (key: string, store: Store): void => {
 		)
 		return
 	}
-	core.operation.done.add(key)
+	target.operation.done.add(key)
 }

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

@@ -1,9 +1,10 @@
 import type { FamilyMetadata, SelectorOptions, SelectorToken } from "atom.io"
 
 import { cacheValue } from "../caching"
+import { newest } from "../lineage"
 import { markDone } from "../operation"
 import { become } from "../set-state/become"
-import type { Store, StoreCore } from "../store"
+import type { Store } from "../store"
 import { Subject } from "../subject"
 import type { Selector } from "./create-selector"
 import { createSelector } from "./create-selector"
@@ -13,8 +14,8 @@ export const createReadWriteSelector = <T>(
 	options: SelectorOptions<T>,
 	family: FamilyMetadata | undefined,
 	store: Store,
-	core: StoreCore,
 ): SelectorToken<T> => {
+	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 
 	const { get, set } = registerSelector(options.key, store)
@@ -40,7 +41,7 @@ export const createReadWriteSelector = <T>(
 		)
 		cacheValue(options.key, newValue, subject, store)
 		markDone(options.key, store)
-		if (store.transactionStatus.phase === `idle`) {
+		if (target.transactionMeta === null) {
 			subject.next({ newValue, oldValue })
 		}
 		options.set({ get, set }, newValue)
@@ -54,7 +55,7 @@ export const createReadWriteSelector = <T>(
 		type: `selector`,
 		...(family && { family }),
 	}
-	core.selectors.set(options.key, mySelector)
+	target.selectors.set(options.key, mySelector) // ❓
 	const initialValue = getSelf()
 	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue)
 	const token: SelectorToken<T> = {

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

@@ -5,7 +5,8 @@ import type {
 } from "atom.io"
 
 import { cacheValue } from "../caching"
-import type { Store, StoreCore } from "../store"
+import { newest } from "../lineage"
+import type { Store } from "../store"
 import { Subject } from "../subject"
 import type { ReadonlySelector } from "./create-selector"
 import { createSelector } from "./create-selector"
@@ -15,8 +16,8 @@ export const createReadonlySelector = <T>(
 	options: ReadonlySelectorOptions<T>,
 	family: FamilyMetadata | undefined,
 	store: Store,
-	core: StoreCore,
 ): ReadonlySelectorToken<T> => {
+	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 
 	const { get } = registerSelector(options.key, store)
@@ -34,7 +35,7 @@ export const createReadonlySelector = <T>(
 		type: `readonly_selector`,
 		...(family && { family }),
 	}
-	core.readonlySelectors.set(options.key, readonlySelector)
+	target.readonlySelectors.set(options.key, readonlySelector)
 	const initialValue = getSelf()
 	store.logger.info(
 		`✨`,

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

@@ -6,9 +6,9 @@ import type {
 	SelectorToken,
 } from "atom.io"
 
+import { newest } from "../lineage"
 import type { Store } from "../store"
 import type { Subject } from "../subject"
-import { target } from "../transaction"
 import { createReadWriteSelector } from "./create-read-write-selector"
 import { createReadonlySelector } from "./create-readonly-selector"
 
@@ -45,9 +45,9 @@ export function createSelector<T>(
 	family: FamilyMetadata | undefined,
 	store: Store,
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
-	const core = target(store)
-	const existingWritable = core.selectors.get(options.key)
-	const existingReadonly = core.readonlySelectors.get(options.key)
+	const target = newest(store)
+	const existingWritable = target.selectors.get(options.key)
+	const existingReadonly = target.readonlySelectors.get(options.key)
 
 	if (existingWritable || existingReadonly) {
 		store.logger.error(
@@ -59,7 +59,7 @@ export function createSelector<T>(
 	}
 
 	if (`set` in options) {
-		return createReadWriteSelector(options, family, store, core)
+		return createReadWriteSelector(options, family, store)
 	}
-	return createReadonlySelector(options, family, store, core)
+	return createReadonlySelector(options, family, store)
 }

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

@@ -1,37 +1,37 @@
 import type { ReadonlySelectorToken, SelectorToken } from "atom.io"
 
+import { newest } from ".."
 import type { Store } from ".."
-import { target } from ".."
 
 export function deleteSelector(
 	selectorToken: ReadonlySelectorToken<unknown> | SelectorToken<unknown>,
 	store: Store,
 ): void {
-	const core = target(store)
+	const target = newest(store)
 	const { key } = selectorToken
 	switch (selectorToken.type) {
 		case `selector`:
-			core.selectors.delete(key)
+			target.selectors.delete(key)
 			break
 		case `readonly_selector`:
-			core.readonlySelectors.delete(key)
+			target.readonlySelectors.delete(key)
 			break
 	}
-	core.valueMap.delete(key)
-	core.selectorAtoms.delete(key)
-	const downstreamTokens = core.selectorGraph
+	target.valueMap.delete(key)
+	target.selectorAtoms.delete(key)
+	const downstreamTokens = target.selectorGraph
 		.getRelationEntries({ upstreamSelectorKey: key })
 		.filter(([_, { source }]) => source === key)
 		.map(
 			([downstreamSelectorKey]) =>
-				core.selectors.get(downstreamSelectorKey) ??
-				core.readonlySelectors.get(downstreamSelectorKey),
+				target.selectors.get(downstreamSelectorKey) ??
+				target.readonlySelectors.get(downstreamSelectorKey),
 		)
 	for (const downstreamToken of downstreamTokens) {
 		if (downstreamToken) {
 			deleteSelector(downstreamToken, store)
 		}
 	}
-	core.selectorGraph.delete(key)
+	target.selectorGraph.delete(key)
 	store.logger.info(`🔥`, selectorToken.type, `${key}`, `deleted`)
 }

package/internal/src/selector/get-selector-dependency-keys.ts

@@ -1,7 +1,7 @@
 import type { AtomKey, ReadonlySelectorKey, SelectorKey } from "../keys"
 import { isStateKey } from "../keys"
+import { newest } from "../lineage"
 import type { Store } from "../store"
-import { target } from "../transaction"
 
 export const getSelectorDependencyKeys = (
 	key: string,
@@ -11,7 +11,7 @@ export const getSelectorDependencyKeys = (
 	| ReadonlySelectorKey<unknown>
 	| SelectorKey<unknown>
 )[] => {
-	const sources = target(store)
+	const sources = newest(store)
 		.selectorGraph.getRelationEntries({ downstreamSelectorKey: key })
 		.filter(([_, { source }]) => source !== key)
 		.map(([_, { source }]) => source)

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

@@ -1,10 +1,10 @@
 import type { Transactors } from "atom.io"
 
+import { newest } from "../lineage"
 import { readOrComputeValue } from "../read-or-compute-value"
 import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
 import { withdraw } from "../store"
-import { target } from "../transaction/create-transaction"
 import { updateSelectorAtoms } from "./update-selector-atoms"
 
 export const registerSelector = (
@@ -12,8 +12,8 @@ export const registerSelector = (
 	store: Store,
 ): Transactors => ({
 	get: (dependency) => {
-		const core = target(store)
-		const alreadyRegistered = core.selectorGraph
+		const target = newest(store)
+		const alreadyRegistered = target.selectorGraph
 			.getRelationEntries({ downstreamSelectorKey: selectorKey })
 			.some(([_, { source }]) => source === dependency.key)
 
@@ -35,7 +35,7 @@ export const registerSelector = (
 		)
 
 		if (!alreadyRegistered) {
-			core.selectorGraph = core.selectorGraph.set(
+			target.selectorGraph = target.selectorGraph.set(
 				{
 					upstreamSelectorKey: dependency.key,
 					downstreamSelectorKey: selectorKey,

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

@@ -1,7 +1,7 @@
 import type { ReadonlySelectorToken, StateToken } from "atom.io"
 
+import { newest } from "../lineage"
 import type { Store } from "../store"
-import { target } from "../transaction"
 import { traceSelectorAtoms } from "./trace-selector-atoms"
 
 export const updateSelectorAtoms = (
@@ -9,7 +9,7 @@ export const updateSelectorAtoms = (
 	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
 	store: Store,
 ): void => {
-	const core = target(store)
+	const core = newest(store)
 	if (dependency.type === `atom`) {
 		core.selectorAtoms = core.selectorAtoms.set({
 			selectorKey,

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

@@ -2,19 +2,20 @@ import type { JsonInterface } from "atom.io/json"
 
 import type { Atom } from "../atom"
 import { Tracker } from "../mutable"
-import type { Store, StoreCore } from "../store"
+import type { Store } from "../store"
 
 export function copyMutableIfNeeded<T>(
 	atom: Atom<T>,
 	transform: JsonInterface<T>,
 	origin: Store,
-	target: StoreCore,
+	target: Store,
 ): T {
 	const originValue = origin.valueMap.get(atom.key)
 	const targetValue = target.valueMap.get(atom.key)
 	if (originValue === targetValue) {
 		origin.logger.info(`📃`, `atom`, `${atom.key}`, `copying`)
-		const copiedValue = transform.fromJson(transform.toJson(originValue))
+		const jsonValue = transform.toJson(originValue)
+		const copiedValue = transform.fromJson(jsonValue)
 		target.valueMap.set(atom.key, copiedValue)
 		new Tracker(atom, origin)
 		return copiedValue