atom.io 0.6.8 → 0.7.0

package/internal/src/store/store.ts

@@ -0,0 +1,154 @@
+import type {
+	AtomFamily,
+	AtomToken,
+	Logger,
+	ReadonlySelectorFamily,
+	ReadonlySelectorToken,
+	SelectorFamily,
+	SelectorToken,
+	TimelineToken,
+	TransactionToken,
+	ƒn,
+} from "atom.io"
+
+import { Junction } from "~/packages/rel8/junction/src"
+
+import type { Atom } from "../atom"
+import type { MutableAtom, Tracker, Transceiver } from "../mutable"
+import type { OperationProgress } from "../operation"
+import type { ReadonlySelector, Selector } from "../selector"
+import { Subject } from "../subject"
+import type { Timeline } from "../timeline"
+import type { Transaction, TransactionStatus } from "../transaction"
+
+export type StoreCore = Pick<
+	Store,
+	| `atoms`
+	| `atomsThatAreDefault`
+	| `families`
+	| `operation`
+	| `readonlySelectors`
+	| `selectorAtoms`
+	| `selectorGraph`
+	| `selectors`
+	| `timelineAtoms`
+	| `timelines`
+	| `trackers`
+	| `transactions`
+	| `valueMap`
+>
+
+export class Store {
+	public valueMap = new Map<string, any>()
+
+	public atoms = new Map<string, Atom<any> | MutableAtom<any>>()
+	public selectors = new Map<string, Selector<any>>()
+	public readonlySelectors = new Map<string, ReadonlySelector<any>>()
+
+	public trackers = new Map<string, Tracker<Transceiver<any>>>()
+	public families = new Map<
+		string,
+		| AtomFamily<any, any>
+		| ReadonlySelectorFamily<any, any>
+		| SelectorFamily<any, any>
+	>()
+
+	public timelines = new Map<string, Timeline>()
+	public transactions = new Map<string, Transaction<ƒn>>()
+
+	public atomsThatAreDefault = new Set<string>()
+
+	public timelineAtoms = new Junction({
+		between: [`timelineKey`, `atomKey`],
+		cardinality: `1:n`,
+	})
+	public selectorAtoms = new Junction({
+		between: [`selectorKey`, `atomKey`],
+		cardinality: `n:n`,
+	})
+	public selectorGraph = new Junction<
+		`upstreamSelectorKey`,
+		`downstreamSelectorKey`,
+		{ source: string }
+	>(
+		{
+			between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
+			cardinality: `n:n`,
+		},
+		{
+			makeContentKey: (...keys) => keys.sort().join(`:`),
+		},
+	)
+
+	public subject = {
+		atomCreation: new Subject<AtomToken<unknown>>(),
+		selectorCreation: new Subject<
+			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+		>(),
+		transactionCreation: new Subject<TransactionToken<ƒn>>(),
+		timelineCreation: new Subject<TimelineToken>(),
+		operationStatus: new Subject<OperationProgress>(),
+	}
+	public operation: OperationProgress = { open: false }
+	public transactionStatus: TransactionStatus<ƒn> = { phase: `idle` }
+
+	public config: {
+		name: string
+		logger: Logger | null
+		logger__INTERNAL: Logger
+	} = {
+		name: `IMPLICIT_STORE`,
+		logger: { ...console, info: () => undefined },
+		logger__INTERNAL: console,
+	}
+
+	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 = {
+				...store?.config,
+				logger__INTERNAL: console,
+				logger: {
+					...console,
+					info: () => undefined,
+					...store?.config?.logger,
+				},
+				name,
+			}
+		}
+
+		store?.atoms.forEach((atom) => {
+			atom.install(this)
+		})
+		store?.readonlySelectors.forEach((selector) => {
+			selector.install(this)
+		})
+		store?.selectors.forEach((selector) => {
+			selector.install(this)
+		})
+		store?.transactions.forEach((tx) => {
+			tx.install(this)
+		})
+		store?.timelines.forEach((timeline) => {
+			timeline.install(this)
+		})
+	}
+}
+
+export const IMPLICIT = {
+	STORE_INTERNAL: undefined as Store | undefined,
+	get STORE(): Store {
+		return (
+			this.STORE_INTERNAL ?? (this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`))
+		)
+	},
+}
+
+export const clearStore = (store: Store = IMPLICIT.STORE): void => {
+	const { config } = store
+	Object.assign(store, new Store(config.name))
+	store.config = config
+}

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

@@ -0,0 +1,53 @@
+import type {
+	AtomToken,
+	ReadonlySelectorToken,
+	SelectorToken,
+	StateToken,
+} from "atom.io"
+import type { Atom, ReadonlySelector, Selector, Store } from ".."
+import { withdraw } from ".."
+import { target } from "../transaction"
+
+export function withdrawNewFamilyMember<T>(
+	token: AtomToken<T>,
+	store: Store,
+): Atom<T> | null
+export function withdrawNewFamilyMember<T>(
+	token: SelectorToken<T>,
+	store: Store,
+): Selector<T> | null
+export function withdrawNewFamilyMember<T>(
+	token: ReadonlySelectorToken<T>,
+	store: Store,
+): ReadonlySelector<T> | null
+export function withdrawNewFamilyMember<T>(
+	token: StateToken<T>,
+	store: Store,
+): Atom<T> | Selector<T> | null
+export function withdrawNewFamilyMember<T>(
+	token: ReadonlySelectorToken<T> | StateToken<T>,
+	store: Store,
+): Atom<T> | ReadonlySelector<T> | Selector<T> | null
+export function withdrawNewFamilyMember<T>(
+	token:
+		| AtomToken<T>
+		| ReadonlySelectorToken<T>
+		| SelectorToken<T>
+		| StateToken<T>,
+	store: Store,
+): Atom<T> | ReadonlySelector<T> | Selector<T> | null {
+	store.config.logger?.info(
+		`👪 creating new family member "${token.key}" in store "${store.config.name}"`,
+	)
+	if (token.family) {
+		const core = target(store)
+		const family = core.families.get(token.family.key)
+		if (family) {
+			const jsonSubKey = JSON.parse(token.family.subKey)
+			family(jsonSubKey)
+			const state = withdraw(token, store)
+			return state
+		}
+	}
+	return null
+}

package/internal/src/store/withdraw.ts

@@ -0,0 +1,113 @@
+import type {
+	AtomToken,
+	ReadonlySelectorToken,
+	SelectorToken,
+	StateToken,
+	TimelineToken,
+	TransactionToken,
+	ƒn,
+} from "atom.io"
+
+import type { Atom } from "../atom"
+import type { ReadonlySelector, Selector } from "../selector"
+import { addAtomToTimeline } from "../timeline"
+import type { Timeline } from "../timeline"
+import type { Transaction } from "../transaction"
+import { target } from "../transaction"
+import type { Store } from "./store"
+
+export function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | null
+export function withdraw<T>(
+	token: SelectorToken<T>,
+	store: Store,
+): Selector<T> | null
+export function withdraw<T>(
+	token: StateToken<T>,
+	store: Store,
+): Atom<T> | Selector<T> | null
+export function withdraw<T>(
+	token: ReadonlySelectorToken<T>,
+	store: Store,
+): ReadonlySelector<T> | null
+export function withdraw<T>(
+	token: TransactionToken<T>,
+	store: Store,
+): Transaction<T extends ƒn ? T : never> | null
+export function withdraw<T>(
+	token: ReadonlySelectorToken<T> | StateToken<T>,
+	store: Store,
+): Atom<T> | ReadonlySelector<T> | Selector<T> | null
+export function withdraw<T>(token: TimelineToken, store: Store): Timeline | null
+export function withdraw<T>(
+	token:
+		| ReadonlySelectorToken<T>
+		| StateToken<T>
+		| TimelineToken
+		| TransactionToken<T>,
+	store: Store,
+):
+	| Atom<T>
+	| ReadonlySelector<T>
+	| Selector<T>
+	| Timeline
+	| Transaction<T extends ƒn ? T : never>
+	| null {
+	let core = target(store)
+	let state =
+		core.atoms.get(token.key) ??
+		core.selectors.get(token.key) ??
+		core.readonlySelectors.get(token.key) ??
+		core.transactions.get(token.key) ??
+		core.timelines.get(token.key)
+	if (state) {
+		return state
+	}
+	if (store.transactionStatus.phase === `applying`) {
+		core = store.transactionStatus.core
+		state =
+			core.atoms.get(token.key) ??
+			core.selectors.get(token.key) ??
+			core.readonlySelectors.get(token.key) ??
+			core.transactions.get(token.key) ??
+			core.timelines.get(token.key)
+
+		if (state) {
+			store.config.logger?.info(`🛠️ add ${token.type} "${token.key}"`)
+			switch (state.type) {
+				case `atom`: {
+					store.atoms.set(token.key, state)
+					store.valueMap.set(token.key, state.default)
+					const stateKey = state.key
+					const familyKey = state.family?.key
+					let timelineKey = core.timelineAtoms.getRelatedKey(stateKey)
+					if (timelineKey === undefined && typeof familyKey === `string`) {
+						timelineKey = core.timelineAtoms.getRelatedKey(familyKey)
+					}
+					const timeline =
+						typeof timelineKey === `string`
+							? store.timelines.get(timelineKey)
+							: undefined
+
+					if (timeline) {
+						addAtomToTimeline(state, timeline, store)
+					}
+					break
+				}
+				case `selector`:
+					core.selectors.set(token.key, state)
+					break
+				case `readonly_selector`:
+					core.readonlySelectors.set(token.key, state)
+					break
+				case `transaction`:
+					core.transactions.set(token.key, state)
+					break
+				case `timeline`:
+					core.timelines.set(token.key, state)
+					break
+			}
+			return state
+		}
+	}
+	return null
+}

package/internal/src/subject.ts

@@ -0,0 +1,21 @@
+export class Subject<T> {
+	public Subscriber: (value: T) => void
+
+	public subscribers: Map<string, this[`Subscriber`]> = new Map()
+
+	public subscribe(key: string, subscriber: this[`Subscriber`]): () => void {
+		this.subscribers.set(key, subscriber)
+		const unsubscribe = () => this.unsubscribe(key)
+		return unsubscribe
+	}
+
+	private unsubscribe(key: string) {
+		this.subscribers.delete(key)
+	}
+
+	public next(value: T): void {
+		for (const subscriber of this.subscribers.values()) {
+			subscriber(value)
+		}
+	}
+}

package/internal/src/subscribe/index.ts

@@ -0,0 +1 @@
+export * from "./subscribe-to-root-atoms"

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

@@ -0,0 +1,19 @@
+import type { Atom } from "../atom"
+import type { ReadonlySelector, Selector } from "../selector"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { target } from "../transaction"
+
+export const recallState = <T>(
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	store: Store = IMPLICIT.STORE,
+): T => {
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`recall called outside of an operation. This is probably a bug.`,
+		)
+		return core.valueMap.get(state.key)
+	}
+	return core.operation.prev.get(state.key)
+}

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

@@ -0,0 +1,47 @@
+import { getState__INTERNAL } from "../get-state-internal"
+import type { ReadonlySelector, Selector } from "../selector"
+import { traceAllSelectorAtoms } from "../selector"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+import { recallState } from "./recall-state"
+
+export const subscribeToRootAtoms = <T>(
+	state: ReadonlySelector<T> | Selector<T>,
+	store: Store,
+): (() => void)[] | null => {
+	const dependencySubscriptions =
+		`default` in state
+			? null
+			: traceAllSelectorAtoms(state.key, store).map((atomToken) => {
+					const atom = withdraw(atomToken, store)
+					if (atom === null) {
+						throw new Error(
+							`Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
+						)
+					}
+					return atom.subject.subscribe(
+						`${state.type}:${state.key}`,
+						(atomChange) => {
+							store.config.logger?.info(
+								`📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
+								atomChange.oldValue,
+								`->`,
+								atomChange.newValue,
+								`)`,
+							)
+							const oldValue = recallState(state, store)
+							// ❗ this retrieves a stale cached value when applying a transaction on the server
+							const newValue = getState__INTERNAL(state, store)
+							store.config.logger?.info(
+								`   <- "${state.key}" went (`,
+								oldValue,
+								`->`,
+								newValue,
+								`)`,
+							)
+							state.subject.next({ newValue, oldValue })
+						},
+					)
+			  })
+	return dependencySubscriptions
+}

package/{src/internal → internal/src}/timeline/add-atom-to-timeline.ts

@@ -1,15 +1,16 @@
-import { IMPLICIT, withdraw } from ".."
+import type { AtomToken, TimelineUpdate } from "atom.io"
+
+import type { Store } from "../store"
+import { IMPLICIT, withdraw } from "../store"
+import { target } from "../transaction"
 import type {
 	Timeline,
-	Store,
-	TimelineTransactionUpdate,
 	TimelineAtomUpdate,
-} from ".."
-import type { AtomFamily, AtomToken, TimelineUpdate } from "../.."
+	TimelineTransactionUpdate,
+} from "./timeline-internal"
 
 export const addAtomToTimeline = (
 	atomToken: AtomToken<any>,
-	atoms: (AtomFamily<any> | AtomToken<any>)[],
 	tl: Timeline,
 	store: Store = IMPLICIT.STORE,
 ): void => {
@@ -19,7 +20,7 @@ export const addAtomToTimeline = (
 			`Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`,
 		)
 	}
-	atom.subject.subscribe((update) => {
+	atom.subject.subscribe(`timeline`, (update) => {
 		const currentSelectorKey =
 			store.operation.open && store.operation.token.type === `selector`
 				? store.operation.token.key
@@ -78,29 +79,46 @@ export const addAtomToTimeline = (
 						)
 					}
 					tl.transactionKey = currentTransactionKey
-					const subscription = currentTransaction.subject.subscribe((update) => {
-						subscription.unsubscribe()
-						if (tl.timeTraveling === null && currentTransactionTime) {
-							if (tl.at !== tl.history.length) {
-								tl.history.splice(tl.at)
-							}
-							const timelineTransactionUpdate: TimelineTransactionUpdate = {
-								type: `transaction_update`,
-								timestamp: currentTransactionTime,
-								...update,
-								atomUpdates: update.atomUpdates.filter((atomUpdate) =>
-									atoms.some((atom) => atom.key === atomUpdate.key),
-								),
+					const unsubscribe = currentTransaction.subject.subscribe(
+						`timeline:${tl.key}`,
+						(update) => {
+							unsubscribe()
+							if (tl.timeTraveling === null && currentTransactionTime) {
+								if (tl.at !== tl.history.length) {
+									tl.history.splice(tl.at)
+								}
+
+								const atomUpdates = update.atomUpdates.filter((atomUpdate) => {
+									const core = target(store)
+									const atomOrFamilyKeys = core.timelineAtoms.getRelatedKeys(
+										tl.key,
+									)
+
+									return atomOrFamilyKeys
+										? [...atomOrFamilyKeys].some(
+												(key) =>
+													key === atomUpdate.key ||
+													key === atomUpdate.family?.key,
+										  )
+										: false
+								})
+
+								const timelineTransactionUpdate: TimelineTransactionUpdate = {
+									type: `transaction_update`,
+									timestamp: currentTransactionTime,
+									...update,
+									atomUpdates,
+								}
+								tl.history.push(timelineTransactionUpdate)
+								tl.at = tl.history.length
+								tl.subject.next(timelineTransactionUpdate)
 							}
-							tl.history.push(timelineTransactionUpdate)
-							tl.at = tl.history.length
-							tl.subject.next(timelineTransactionUpdate)
-						}
-						tl.transactionKey = null
-						store.config.logger?.info(
-							`⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`,
-						)
-					})
+							tl.transactionKey = null
+							store.config.logger?.info(
+								`⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`,
+							)
+						},
+					)
 				}
 			} else if (currentSelectorKey && currentSelectorTime) {
 				let latestUpdate: TimelineUpdate | undefined = tl.history.at(-1)
@@ -156,6 +174,9 @@ export const addAtomToTimeline = (
 					oldValue: update.oldValue,
 					newValue: update.newValue,
 				}
+				if (atom.family) {
+					atomUpdate.family = atom.family
+				}
 				tl.history.push(atomUpdate)
 				tl.subject.next(atomUpdate)
 				store.config.logger?.info(

package/internal/src/timeline/index.ts

@@ -0,0 +1,3 @@
+export * from "./add-atom-to-timeline"
+export * from "./time-travel-internal"
+export * from "./timeline-internal"

package/{src/internal → internal/src/timeline}/time-travel-internal.ts

@@ -1,7 +1,8 @@
-import type { Store } from "."
-import { IMPLICIT } from "."
-import type { TimelineToken } from ".."
-import { setState } from ".."
+import type { TimelineToken } from "atom.io"
+import { setState } from "atom.io"
+
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
 
 export const redo__INTERNAL = (
 	token: TimelineToken,
@@ -65,7 +66,6 @@ export const undo__INTERNAL = (
 		return
 	}
 	timelineData.timeTraveling = `into_past`
-
 	--timelineData.at
 	const update = timelineData.history[timelineData.at]
 	switch (update.type) {
@@ -76,7 +76,7 @@ export const undo__INTERNAL = (
 		}
 		case `selector_update`:
 		case `transaction_update`: {
-			for (const atomUpdate of update.atomUpdates) {
+			for (const atomUpdate of [...update.atomUpdates].reverse()) {
 				const { key, oldValue } = atomUpdate
 				setState({ key, type: `atom` }, oldValue, store)
 			}

package/{src/internal → internal/src/timeline}/timeline-internal.ts

@@ -1,20 +1,24 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from "."
-import { Subject, target, IMPLICIT } from "."
-import { addAtomToTimeline } from "./timeline/add-atom-to-timeline"
 import type {
+	FamilyMetadata,
 	StateUpdate,
 	TimelineOptions,
 	TimelineToken,
 	TimelineUpdate,
 	TransactionUpdate,
-} from ".."
+	ƒn,
+} from "atom.io"
+
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { Subject } from "../subject"
+import { target } from "../transaction"
+import { addAtomToTimeline } from "./add-atom-to-timeline"
 
 export type TimelineAtomUpdate = StateUpdate<unknown> & {
 	key: string
 	type: `atom_update`
 	timestamp: number
+	family?: FamilyMetadata
 }
 export type TimelineSelectorUpdate = {
 	key: string
@@ -29,6 +33,7 @@ export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 }
 
 export type Timeline = {
+	type: `timeline`
 	key: string
 	at: number
 	timeTraveling: `into_future` | `into_past` | null
@@ -51,6 +56,7 @@ export function timeline__INTERNAL(
 	data: Timeline | null = null,
 ): TimelineToken {
 	const tl: Timeline = {
+		type: `timeline`,
 		key: options.key,
 		at: 0,
 		timeTraveling: null,
@@ -64,7 +70,7 @@ export function timeline__INTERNAL(
 
 	const core = target(store)
 	for (const tokenOrFamily of options.atoms) {
-		const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
+		const timelineKey = core.timelineAtoms.getRelatedKey(tokenOrFamily.key)
 		if (timelineKey) {
 			store.config.logger?.error(
 				`❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`,
@@ -73,13 +79,15 @@ export function timeline__INTERNAL(
 		}
 		if (tokenOrFamily.type === `atom_family`) {
 			const family = tokenOrFamily
-			family.subject.subscribe((token) =>
-				addAtomToTimeline(token, options.atoms, tl, store),
-			)
+			family.subject.subscribe(`timeline:${options.key}`, (token) => {
+				if (!core.atoms.has(token.key)) {
+					addAtomToTimeline(token, tl, store)
+				}
+			})
 		} else {
 			const token = tokenOrFamily
 			if (`family` in token && token.family) {
-				const familyTimelineKey = core.timelineAtoms.getRelatedId(
+				const familyTimelineKey = core.timelineAtoms.getRelatedKey(
 					token.family.key,
 				)
 				if (familyTimelineKey) {
@@ -89,7 +97,7 @@ export function timeline__INTERNAL(
 					continue
 				}
 			}
-			addAtomToTimeline(token, options.atoms, tl, store)
+			addAtomToTimeline(token, tl, store)
 		}
 		core.timelineAtoms = core.timelineAtoms.set({
 			atomKey: tokenOrFamily.key,

package/{src/internal → internal/src}/transaction/abort-transaction.ts

@@ -1,4 +1,4 @@
-import type { Store } from ".."
+import type { Store } from "../store"
 
 export const abortTransaction = (store: Store): void => {
 	if (store.transactionStatus.phase === `idle`) {