atom.io 0.6.7 → 0.6.9

package/src/internal/set.ts

@@ -1,99 +0,0 @@
-import { become } from "~/packages/anvl/src/function"
-
-import type { Atom, Selector, Store } from "."
-import {
-	IMPLICIT,
-	cacheValue,
-	emitUpdate,
-	evictCachedValue,
-	getState__INTERNAL,
-	isAtomDefault,
-	isDone,
-	markAtomAsNotDefault,
-	markDone,
-	stowUpdate,
-	target,
-} from "."
-
-export const evictDownStream = <T>(
-	state: Atom<T>,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const core = target(store)
-	const downstream = core.selectorAtoms.getRelations(state.key)
-	const downstreamKeys = downstream.map(({ id }) => id)
-	store.config.logger?.info(
-		`   || ${downstreamKeys.length} downstream:`,
-		downstreamKeys,
-	)
-	if (core.operation.open) {
-		store.config.logger?.info(`   ||`, [...core.operation.done], `already done`)
-	}
-	downstream.forEach(({ id: stateKey }) => {
-		if (isDone(stateKey, store)) {
-			store.config.logger?.info(`   || ${stateKey} already done`)
-			return
-		}
-		const state =
-			core.selectors.get(stateKey) ?? core.readonlySelectors.get(stateKey)
-		if (!state) {
-			store.config.logger?.info(
-				`   || ${stateKey} is an atom, and can't be downstream`,
-			)
-			return
-		}
-		evictCachedValue(stateKey, store)
-		store.config.logger?.info(`   xx evicted "${stateKey}"`)
-
-		markDone(stateKey, store)
-	})
-}
-
-export const setAtomState = <T>(
-	atom: Atom<T>,
-	next: T | ((oldValue: T) => T),
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const oldValue = getState__INTERNAL(atom, store)
-	const newValue = become(next)(oldValue)
-	store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
-	cacheValue(atom.key, newValue, store)
-	if (isAtomDefault(atom.key, store)) {
-		markAtomAsNotDefault(atom.key, store)
-	}
-	markDone(atom.key, store)
-	store.config.logger?.info(
-		`   || evicting caches downstream from "${atom.key}"`,
-	)
-	evictDownStream(atom, store)
-	const update = { oldValue, newValue }
-	if (store.transactionStatus.phase !== `building`) {
-		emitUpdate(atom, update, store)
-	} else {
-		stowUpdate(atom, update, store)
-	}
-}
-export const setSelectorState = <T>(
-	selector: Selector<T>,
-	next: T | ((oldValue: T) => T),
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const oldValue = getState__INTERNAL(selector, store)
-	const newValue = become(next)(oldValue)
-
-	store.config.logger?.info(`<< setting selector "${selector.key}" to`, newValue)
-	store.config.logger?.info(`   || propagating change made to "${selector.key}"`)
-
-	selector.set(newValue)
-}
-export const setState__INTERNAL = <T>(
-	state: Atom<T> | Selector<T>,
-	value: T | ((oldValue: T) => T),
-	store: Store = IMPLICIT.STORE,
-): void => {
-	if (`set` in state) {
-		setSelectorState(state, value, store)
-	} else {
-		setAtomState(state, value, store)
-	}
-}

package/src/internal/store.ts

@@ -1,151 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-import { doNothing } from "~/packages/anvl/src/function"
-import { Join } from "~/packages/anvl/src/join"
-
-import { Subject } from "."
-import type {
-	Atom,
-	OperationProgress,
-	ReadonlySelector,
-	Selector,
-	TransactionStatus,
-	Timeline,
-	Transaction,
-} from "."
-import type {
-	AtomToken,
-	Logger,
-	ReadonlySelectorToken,
-	SelectorToken,
-	TimelineToken,
-	TransactionToken,
-} from ".."
-
-export type StoreCore = Pick<
-	Store,
-	| `atoms`
-	| `atomsThatAreDefault`
-	| `operation`
-	| `readonlySelectors`
-	| `selectorAtoms`
-	| `selectorGraph`
-	| `selectors`
-	| `timelineAtoms`
-	| `timelines`
-	| `transactions`
-	| `valueMap`
->
-
-export interface Store {
-	atoms: Map<string, Atom<any>>
-	atomsThatAreDefault: Set<string>
-	readonlySelectors: Map<string, ReadonlySelector<any>>
-	selectorAtoms: Join<null, `selectorKey`, `atomKey`>
-	selectorGraph: Join<{ source: string }>
-	selectors: Map<string, Selector<any>>
-	timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-	timelines: Map<string, Timeline>
-	transactions: Map<string, Transaction<any>>
-	valueMap: Map<string, any>
-
-	subject: {
-		atomCreation: Subject<AtomToken<unknown>>
-		selectorCreation: Subject<
-			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
-		>
-		transactionCreation: Subject<TransactionToken<ƒn>>
-		timelineCreation: Subject<TimelineToken>
-		operationStatus: Subject<OperationProgress>
-	}
-
-	operation: OperationProgress
-	transactionStatus: TransactionStatus<ƒn>
-	config: {
-		name: string
-		logger: Logger | null
-		logger__INTERNAL: Logger
-	}
-}
-
-export const createStore = (name: string, store: Store | null = null): Store => {
-	const created = {
-		...(store ??
-			(() => ({
-				atomsThatAreDefault: new Set(),
-				selectorAtoms: new Join({ relationType: `n:n` })
-					.from(`selectorKey`)
-					.to(`atomKey`),
-				selectorGraph: new Join({ relationType: `n:n` }),
-			}))()),
-
-		valueMap: new Map(store?.valueMap),
-		atoms: new Map(),
-		readonlySelectors: new Map(),
-		selectors: new Map(),
-		transactions: new Map(),
-		timelines: new Map(),
-
-		timelineAtoms: new Join({ relationType: `1:n` })
-			.from(`timelineKey`)
-			.to(`atomKey`),
-
-		subject: {
-			atomCreation: new Subject(),
-			selectorCreation: new Subject(),
-			transactionCreation: new Subject(),
-			timelineCreation: new Subject(),
-			operationStatus: new Subject(),
-		},
-
-		operation: {
-			open: false,
-			...store?.operation,
-		},
-		transactionStatus: {
-			phase: `idle`,
-			...store?.transactionStatus,
-		},
-		config: {
-			logger: {
-				...console,
-				info: doNothing,
-				...store?.config?.logger,
-			},
-			logger__INTERNAL: console,
-			...store?.config,
-			name,
-		},
-	} satisfies Store
-
-	store?.atoms.forEach((atom) => {
-		const copiedAtom = { ...atom, subject: new Subject() } satisfies Atom<any>
-		created.atoms.set(atom.key, copiedAtom)
-	})
-	store?.readonlySelectors.forEach((selector) => {
-		selector.install(created)
-	})
-	store?.selectors.forEach((selector) => {
-		selector.install(created)
-	})
-	store?.transactions.forEach((tx) => {
-		tx.install(created)
-	})
-	store?.timelines.forEach((timeline) => {
-		timeline.install(created)
-	})
-
-	return created
-}
-
-export const IMPLICIT = {
-	STORE_INTERNAL: undefined as Store | undefined,
-	get STORE(): Store {
-		return this.STORE_INTERNAL ?? (this.STORE_INTERNAL = createStore(`DEFAULT`))
-	},
-}
-
-export const clearStore = (store: Store = IMPLICIT.STORE): void => {
-	const { config } = store
-	Object.assign(store, createStore(config.name))
-	store.config = config
-}

package/src/internal/subject.ts

@@ -1,24 +0,0 @@
-type Subscriber<T> = (value: T) => void
-
-export class Subject<T> {
-	public subscribers: Subscriber<T>[] = []
-
-	public subscribe(subscriber: Subscriber<T>): { unsubscribe: () => void } {
-		this.subscribers.push(subscriber)
-		const unsubscribe = () => this.unsubscribe(subscriber)
-		return { unsubscribe }
-	}
-
-	private unsubscribe(subscriber: Subscriber<T>) {
-		const subscriberIndex = this.subscribers.indexOf(subscriber)
-		if (subscriberIndex !== -1) {
-			this.subscribers.splice(subscriberIndex, 1)
-		}
-	}
-
-	public next(value: T): void {
-		for (const subscriber of this.subscribers) {
-			subscriber(value)
-		}
-	}
-}

package/src/internal/subscribe-internal.ts

@@ -1,88 +0,0 @@
-import type { Atom, ReadonlySelector, Selector, Store } from "."
-import {
-	getState__INTERNAL,
-	withdraw,
-	recallState,
-	traceAllSelectorAtoms,
-} from "."
-import type { StateUpdate } from ".."
-
-export const prepareUpdate = <T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	store: Store,
-): StateUpdate<T> => {
-	const oldValue = recallState(state, store)
-	const newValue = getState__INTERNAL(state, store)
-	return { newValue, oldValue }
-}
-
-export const stowUpdate = <T>(
-	state: Atom<T>,
-	update: StateUpdate<T>,
-	store: Store,
-): void => {
-	const { key } = state
-	const { logger } = store.config
-	if (store.transactionStatus.phase !== `building`) {
-		store.config.logger?.warn(
-			`stowUpdate called outside of a transaction. This is probably a bug.`,
-		)
-		return
-	}
-	store.transactionStatus.atomUpdates.push({ key, ...update })
-	logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
-}
-
-export const emitUpdate = <T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	update: StateUpdate<T>,
-	store: Store,
-): void => {
-	const { key } = state
-	const { logger } = store.config
-	logger?.info(
-		`📢 ${state.type} "${key}" went (`,
-		update.oldValue,
-		`->`,
-		update.newValue,
-		`)`,
-	)
-	state.subject.next(update)
-}
-
-export const subscribeToRootAtoms = <T>(
-	state: ReadonlySelector<T> | Selector<T>,
-	store: Store,
-): { unsubscribe: () => 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((atomChange) => {
-						store.config.logger?.info(
-							`📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
-							atomChange.oldValue,
-							`->`,
-							atomChange.newValue,
-							`)`,
-						)
-						const oldValue = recallState(state, store)
-						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/time-travel-internal.ts

@@ -1,91 +0,0 @@
-import type { Store } from "."
-import { IMPLICIT } from "."
-import type { TimelineToken } from ".."
-import { setState } from ".."
-
-export const redo__INTERNAL = (
-	token: TimelineToken,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	store.config.logger?.info(`⏩ redo "${token.key}"`)
-	const timelineData = store.timelines.get(token.key)
-	if (!timelineData) {
-		store.config.logger?.error(
-			`Failed to redo on timeline "${token.key}". This timeline has not been initialized.`,
-		)
-		return
-	}
-	if (timelineData.at === timelineData.history.length) {
-		store.config.logger?.warn(
-			`Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`,
-		)
-		return
-	}
-	timelineData.timeTraveling = true
-	const update = timelineData.history[timelineData.at]
-	switch (update.type) {
-		case `atom_update`: {
-			const { key, newValue } = update
-			setState({ key, type: `atom` }, newValue, store)
-			break
-		}
-		case `selector_update`:
-		case `transaction_update`: {
-			for (const atomUpdate of update.atomUpdates) {
-				const { key, newValue } = atomUpdate
-				setState({ key, type: `atom` }, newValue, store)
-			}
-			break
-		}
-	}
-	++timelineData.at
-	timelineData.subject.next(`redo`)
-	timelineData.timeTraveling = false
-	store.config.logger?.info(
-		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
-	)
-}
-
-export const undo__INTERNAL = (
-	token: TimelineToken,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	store.config.logger?.info(`⏪ undo "${token.key}"`)
-	const timelineData = store.timelines.get(token.key)
-	if (!timelineData) {
-		store.config.logger?.error(
-			`Failed to undo on timeline "${token.key}". This timeline has not been initialized.`,
-		)
-		return
-	}
-	if (timelineData.at === 0) {
-		store.config.logger?.warn(
-			`Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`,
-		)
-		return
-	}
-	timelineData.timeTraveling = true
-
-	--timelineData.at
-	const update = timelineData.history[timelineData.at]
-	switch (update.type) {
-		case `atom_update`: {
-			const { key, oldValue } = update
-			setState({ key, type: `atom` }, oldValue, store)
-			break
-		}
-		case `selector_update`:
-		case `transaction_update`: {
-			for (const atomUpdate of update.atomUpdates) {
-				const { key, oldValue } = atomUpdate
-				setState({ key, type: `atom` }, oldValue, store)
-			}
-			break
-		}
-	}
-	timelineData.subject.next(`undo`)
-	timelineData.timeTraveling = false
-	store.config.logger?.info(
-		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
-	)
-}

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

@@ -1,168 +0,0 @@
-import { IMPLICIT, withdraw } from ".."
-import type {
-	Timeline,
-	Store,
-	TimelineTransactionUpdate,
-	TimelineAtomUpdate,
-} from ".."
-import type { AtomFamily, AtomToken, TimelineUpdate } from "../.."
-
-export const addAtomToTimeline = (
-	atomToken: AtomToken<any>,
-	atoms: (AtomFamily<any> | AtomToken<any>)[],
-	tl: Timeline,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const atom = withdraw(atomToken, store)
-	if (atom === null) {
-		throw new Error(
-			`Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`,
-		)
-	}
-	atom.subject.subscribe((update) => {
-		const currentSelectorKey =
-			store.operation.open && store.operation.token.type === `selector`
-				? store.operation.token.key
-				: null
-		const currentSelectorTime =
-			store.operation.open && store.operation.token.type === `selector`
-				? store.operation.time
-				: null
-		const currentTransactionKey =
-			store.transactionStatus.phase === `applying`
-				? store.transactionStatus.key
-				: null
-		const currentTransactionTime =
-			store.transactionStatus.phase === `applying`
-				? store.transactionStatus.time
-				: null
-
-		store.config.logger?.info(
-			`⏳ timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
-			update.oldValue,
-			`->`,
-			update.newValue,
-			currentTransactionKey
-				? `) in transaction "${currentTransactionKey}"`
-				: currentSelectorKey
-				? `) in selector "${currentSelectorKey}"`
-				: `)`,
-		)
-
-		if (tl.timeTraveling === false) {
-			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
-				const mostRecentUpdate: TimelineUpdate | undefined = tl.history.at(-1)
-				if (mostRecentUpdate === undefined) {
-					throw new Error(
-						`Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`,
-					)
-				}
-			}
-			if (
-				currentTransactionKey &&
-				store.transactionStatus.phase === `applying`
-			) {
-				const currentTransaction = withdraw(
-					{ key: currentTransactionKey, type: `transaction` },
-					store,
-				)
-				if (currentTransaction === null) {
-					throw new Error(
-						`Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`,
-					)
-				}
-				if (tl.transactionKey !== currentTransactionKey) {
-					if (tl.transactionKey) {
-						store.config.logger?.error(
-							`Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`,
-						)
-					}
-					tl.transactionKey = currentTransactionKey
-					const subscription = currentTransaction.subject.subscribe((update) => {
-						subscription.unsubscribe()
-						if (tl.timeTraveling === false && 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),
-								),
-							}
-							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}"`,
-						)
-					})
-				}
-			} else if (currentSelectorKey && currentSelectorTime) {
-				let latestUpdate: TimelineUpdate | undefined = tl.history.at(-1)
-
-				if (currentSelectorTime !== tl.selectorTime) {
-					latestUpdate = {
-						type: `selector_update`,
-						timestamp: currentSelectorTime,
-						key: currentSelectorKey,
-						atomUpdates: [],
-					}
-					latestUpdate.atomUpdates.push({
-						key: atom.key,
-						type: `atom_update`,
-						...update,
-					})
-					if (tl.at !== tl.history.length) {
-						tl.history.splice(tl.at)
-					}
-					tl.history.push(latestUpdate)
-
-					store.config.logger?.info(
-						`⌛ timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
-						latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
-					)
-
-					tl.at = tl.history.length
-					tl.selectorTime = currentSelectorTime
-				} else {
-					if (latestUpdate?.type === `selector_update`) {
-						latestUpdate.atomUpdates.push({
-							key: atom.key,
-							type: `atom_update`,
-							...update,
-						})
-						store.config.logger?.info(
-							`   ⌛ timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
-							latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
-						)
-					}
-				}
-				if (latestUpdate) tl.subject.next(latestUpdate)
-			} else {
-				const timestamp = Date.now()
-				tl.selectorTime = null
-				if (tl.at !== tl.history.length) {
-					tl.history.splice(tl.at)
-				}
-				const atomUpdate: TimelineAtomUpdate = {
-					type: `atom_update`,
-					timestamp,
-					key: atom.key,
-					oldValue: update.oldValue,
-					newValue: update.newValue,
-				}
-				tl.history.push(atomUpdate)
-				tl.subject.next(atomUpdate)
-				store.config.logger?.info(
-					`⌛ timeline "${tl.key}" got an atom_update to "${atom.key}"`,
-				)
-				tl.at = tl.history.length
-			}
-		}
-	})
-}

package/src/internal/timeline/index.ts

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