atom.io 0.6.9 → 0.8.0

package/internal/src/operation.ts

@@ -0,0 +1,68 @@
+import type { StateToken } from "atom.io"
+
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+import { target } from "./transaction"
+
+export type OperationProgress =
+	| {
+			open: false
+	  }
+	| {
+			open: true
+			done: Set<string>
+			prev: Map<string, any>
+			time: number
+			token: StateToken<any>
+	  }
+
+export const openOperation = (token: StateToken<any>, store: Store): void => {
+	const core = target(store)
+	if (core.operation.open) {
+		store.config.logger?.error(
+			`❌ failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`,
+		)
+		throw Symbol(`violation`)
+	}
+	core.operation = {
+		open: true,
+		done: new Set(),
+		prev: new Map(store.valueMap),
+		time: Date.now(),
+		token,
+	}
+	store.config.logger?.info(
+		`⭕ operation start from "${token.key}" in store "${store.config.name}"${
+			store.transactionStatus.phase === `idle`
+				? ``
+				: ` ${store.transactionStatus.phase} "${store.transactionStatus.key}"`
+		}`,
+	)
+}
+export const closeOperation = (store: Store): void => {
+	const core = target(store)
+	core.operation = { open: false }
+	store.config.logger?.info(`🔴 operation done`)
+	store.subject.operationStatus.next(core.operation)
+}
+
+export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`isDone called outside of an operation. This is probably a bug.`,
+		)
+		return true
+	}
+	return core.operation.done.has(key)
+}
+export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`markDone called outside of an operation. This is probably a bug.`,
+		)
+		return
+	}
+	core.operation.done.add(key)
+}

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

@@ -0,0 +1,65 @@
+import type { FamilyMetadata, SelectorOptions, SelectorToken } from "atom.io"
+
+import { cacheValue } from "../caching"
+import { markDone } from "../operation"
+import { become } from "../set-state/become"
+import type { Store, StoreCore } from "../store"
+import { Subject } from "../subject"
+import type { Selector } from "./create-selector"
+import { createSelector } from "./create-selector"
+import { registerSelector } from "./register-selector"
+
+export const createReadWriteSelector = <T>(
+	options: SelectorOptions<T>,
+	family: FamilyMetadata | undefined,
+	store: Store,
+	core: StoreCore,
+): SelectorToken<T> => {
+	const subject = new Subject<{ newValue: T; oldValue: T }>()
+
+	const { get, set } = registerSelector(options.key, store)
+	const getSelf = () => {
+		const value = options.get({ get })
+		cacheValue(options.key, value, subject, store)
+		return value
+	}
+
+	const setSelf = (next: T | ((oldValue: T) => T)): void => {
+		const oldValue = getSelf()
+		store.config.logger?.info(
+			`   <- "${options.key}" went (`,
+			oldValue,
+			`->`,
+			next,
+			`)`,
+		)
+		const newValue = become(next)(oldValue)
+		cacheValue(options.key, newValue, subject, store)
+		markDone(options.key, store)
+		if (store.transactionStatus.phase === `idle`) {
+			subject.next({ newValue, oldValue })
+		}
+		options.set({ get, set }, newValue)
+	}
+	const mySelector: Selector<T> = {
+		...options,
+		subject,
+		install: (s: Store) => createSelector(options, family, s),
+		get: getSelf,
+		set: setSelf,
+		type: `selector`,
+		...(family && { family }),
+	}
+	core.selectors.set(options.key, mySelector)
+	const initialValue = getSelf()
+	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
+	const token: SelectorToken<T> = {
+		key: options.key,
+		type: `selector`,
+	}
+	if (family) {
+		token.family = family
+	}
+	store.subject.selectorCreation.next(token)
+	return token
+}

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

@@ -0,0 +1,49 @@
+import type {
+	FamilyMetadata,
+	ReadonlySelectorOptions,
+	ReadonlySelectorToken,
+} from "atom.io"
+
+import { cacheValue } from "../caching"
+import type { Store, StoreCore } from "../store"
+import { Subject } from "../subject"
+import type { ReadonlySelector } from "./create-selector"
+import { createSelector } from "./create-selector"
+import { registerSelector } from "./register-selector"
+
+export const createReadonlySelector = <T>(
+	options: ReadonlySelectorOptions<T>,
+	family: FamilyMetadata | undefined,
+	store: Store,
+	core: StoreCore,
+): ReadonlySelectorToken<T> => {
+	const subject = new Subject<{ newValue: T; oldValue: T }>()
+
+	const { get } = registerSelector(options.key, store)
+	const getSelf = () => {
+		const value = options.get({ get })
+		cacheValue(options.key, value, subject, store)
+		return value
+	}
+
+	const readonlySelector: ReadonlySelector<T> = {
+		...options,
+		subject,
+		install: (s: Store) => createSelector(options, family, s),
+		get: getSelf,
+		type: `readonly_selector`,
+		...(family && { family }),
+	}
+	core.readonlySelectors.set(options.key, readonlySelector)
+	const initialValue = getSelf()
+	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
+	const token: ReadonlySelectorToken<T> = {
+		key: options.key,
+		type: `readonly_selector`,
+	}
+	if (family) {
+		token.family = family
+	}
+	store.subject.selectorCreation.next(token)
+	return token
+}

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

@@ -0,0 +1,65 @@
+import type {
+	FamilyMetadata,
+	ReadonlySelectorOptions,
+	ReadonlySelectorToken,
+	SelectorOptions,
+	SelectorToken,
+} from "atom.io"
+
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import type { Subject } from "../subject"
+import { target } from "../transaction"
+import { createReadWriteSelector } from "./create-read-write-selector"
+import { createReadonlySelector } from "./create-readonly-selector"
+
+export type Selector<T> = {
+	key: string
+	type: `selector`
+	family?: FamilyMetadata
+	install: (store: Store) => void
+	subject: Subject<{ newValue: T; oldValue: T }>
+	get: () => T
+	set: (newValue: T | ((oldValue: T) => T)) => void
+}
+export type ReadonlySelector<T> = {
+	key: string
+	type: `readonly_selector`
+	family?: FamilyMetadata
+	install: (store: Store) => void
+	subject: Subject<{ newValue: T; oldValue: T }>
+	get: () => T
+}
+
+export function createSelector<T>(
+	options: SelectorOptions<T>,
+	family?: FamilyMetadata,
+	store?: Store,
+): SelectorToken<T>
+export function createSelector<T>(
+	options: ReadonlySelectorOptions<T>,
+	family?: FamilyMetadata,
+	store?: Store,
+): ReadonlySelectorToken<T>
+export function createSelector<T>(
+	options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
+	family?: FamilyMetadata,
+	store: Store = IMPLICIT.STORE,
+): ReadonlySelectorToken<T> | SelectorToken<T> {
+	const core = target(store)
+	const existingWritable = core.selectors.get(options.key)
+	const existingReadonly = core.readonlySelectors.get(options.key)
+
+	if (existingWritable || existingReadonly) {
+		store.config.logger?.error?.(
+			`Tried to create ${existingReadonly ? `readonly selector` : `selector`}`,
+			`"${options.key}", but it already exists in the store.`,
+			`(Ignore if you are using hot module replacement.)`,
+		)
+	}
+
+	if (`set` in options) {
+		return createReadWriteSelector(options, family, store, core)
+	}
+	return createReadonlySelector(options, family, store, core)
+}

package/internal/src/selector/index.ts

@@ -0,0 +1,5 @@
+export * from "./lookup-selector-sources"
+export * from "./register-selector"
+export * from "./create-selector"
+export * from "./trace-selector-atoms"
+export * from "./update-selector-atoms"

package/internal/src/selector/lookup-selector-sources.ts

@@ -0,0 +1,20 @@
+import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "atom.io"
+
+import type { Store } from "../store"
+import { lookup } from "../store"
+import { target } from "../transaction"
+
+export const lookupSelectorSources = (
+	key: string,
+	store: Store,
+): (
+	| AtomToken<unknown>
+	| ReadonlySelectorToken<unknown>
+	| SelectorToken<unknown>
+)[] => {
+	const sources = target(store)
+		.selectorGraph.getRelationEntries({ downstreamSelectorKey: key })
+		.filter(([_, { source }]) => source !== key)
+		.map(([_, { source }]) => lookup(source, store))
+	return sources
+}

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

@@ -0,0 +1,61 @@
+import type { Transactors } from "atom.io"
+
+import { getState__INTERNAL } from "../get-state-internal"
+import { setState__INTERNAL } from "../set-state"
+import type { Store } from "../store"
+import { IMPLICIT, withdraw } from "../store"
+import { target } from "../transaction/transaction-internal"
+import { updateSelectorAtoms } from "./update-selector-atoms"
+
+export const registerSelector = (
+	selectorKey: string,
+	store: Store = IMPLICIT.STORE,
+): Transactors => ({
+	get: (dependency) => {
+		const core = target(store)
+		const alreadyRegistered = core.selectorGraph
+			.getRelationEntries({ downstreamSelectorKey: selectorKey })
+			.some(([_, { source }]) => source === dependency.key)
+
+		const dependencyState = withdraw(dependency, store)
+		if (dependencyState === null) {
+			throw new Error(
+				`State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
+			)
+		}
+		const dependencyValue = getState__INTERNAL(dependencyState, store)
+
+		if (alreadyRegistered) {
+			store.config.logger?.info(
+				`   || ${selectorKey} <- ${dependency.key} =`,
+				dependencyValue,
+			)
+		} else {
+			store.config.logger?.info(
+				`🔌 registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
+				dependencyValue,
+				`)`,
+			)
+			core.selectorGraph = core.selectorGraph.set(
+				{
+					upstreamSelectorKey: dependency.key,
+					downstreamSelectorKey: selectorKey,
+				},
+				{
+					source: dependency.key,
+				},
+			)
+		}
+		updateSelectorAtoms(selectorKey, dependency, store)
+		return dependencyValue
+	},
+	set: (stateToken, newValue) => {
+		const state = withdraw(stateToken, store)
+		if (state === null) {
+			throw new Error(
+				`State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
+			)
+		}
+		setState__INTERNAL(state, newValue, store)
+	},
+})

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

@@ -0,0 +1,45 @@
+import type { AtomToken, ReadonlySelectorToken, StateToken } from "atom.io"
+
+import type { Store } from ".."
+import { lookupSelectorSources } from "./lookup-selector-sources"
+
+export const traceSelectorAtoms = (
+	selectorKey: string,
+	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	store: Store,
+): AtomToken<unknown>[] => {
+	const roots: AtomToken<unknown>[] = []
+
+	const sources = lookupSelectorSources(dependency.key, store)
+	let depth = 0
+	while (sources.length > 0) {
+		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
+		const source = sources.shift()!
+		++depth
+		if (depth > 999) {
+			throw new Error(
+				`Maximum selector dependency depth exceeded in selector "${selectorKey}".`,
+			)
+		}
+
+		if (source.type !== `atom`) {
+			sources.push(...lookupSelectorSources(source.key, store))
+		} else {
+			roots.push(source)
+		}
+	}
+
+	return roots
+}
+
+export const traceAllSelectorAtoms = (
+	selectorKey: string,
+	store: Store,
+): AtomToken<unknown>[] => {
+	const sources = lookupSelectorSources(selectorKey, store)
+	return sources.flatMap((source) =>
+		source.type === `atom`
+			? source
+			: traceSelectorAtoms(selectorKey, source, store),
+	)
+}

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

@@ -0,0 +1,34 @@
+import type { ReadonlySelectorToken, StateToken } from "atom.io"
+
+import type { Store } from "../store"
+import { target } from "../transaction"
+import { traceSelectorAtoms } from "./trace-selector-atoms"
+
+export const updateSelectorAtoms = (
+	selectorKey: string,
+	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	store: Store,
+): void => {
+	const core = target(store)
+	if (dependency.type === `atom`) {
+		core.selectorAtoms = core.selectorAtoms.set({
+			selectorKey,
+			atomKey: dependency.key,
+		})
+		store.config.logger?.info(
+			`   || adding root for "${selectorKey}": ${dependency.key}`,
+		)
+		return
+	}
+	const roots = traceSelectorAtoms(selectorKey, dependency, store)
+	store.config.logger?.info(
+		`   || adding roots for "${selectorKey}":`,
+		roots.map((r) => r.key),
+	)
+	for (const root of roots) {
+		core.selectorAtoms = core.selectorAtoms.set({
+			selectorKey,
+			atomKey: root.key,
+		})
+	}
+}

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

@@ -0,0 +1,10 @@
+export type Modify<T> = (thing: T) => T
+
+export const become =
+	<T>(nextVersionOfThing: Modify<T> | T) =>
+	(originalThing: T): T =>
+		nextVersionOfThing instanceof Function
+			? nextVersionOfThing(
+					originalThing instanceof Function ? originalThing() : originalThing,
+			  )
+			: nextVersionOfThing

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

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

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

@@ -0,0 +1,59 @@
+import type { AtomFamily } from "atom.io"
+import type { Json, JsonInterface } from "atom.io/json"
+import { getState__INTERNAL } from ".."
+import type { Store, StoreCore } from ".."
+import type { Atom } from "../atom"
+import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
+
+export function copyMutableIfWithinTransaction<T>(
+	atom: Atom<T> | (Atom<T> & JsonInterface<T, Json.Serializable>),
+	store: Store,
+): T {
+	if (
+		store.transactionStatus.phase === `building` ||
+		store.transactionStatus.phase === `applying`
+	) {
+		if (`toJson` in atom && `fromJson` in atom) {
+			store.config.logger?.info(
+				`📄 copyMutableIfWithinTransaction: ${atom.key} is mutable`,
+			)
+			const copiedValue = copyMutableIfNeeded(
+				atom,
+				atom,
+				store,
+				store.transactionStatus.core,
+			)
+			return copiedValue
+		}
+		if (`family` in atom) {
+			const family = store.transactionStatus.core.families.get(atom.family.key)
+			if (family && family.type === `atom_family`) {
+				const result = copyMutableFamilyMemberWithinTransaction<T>(
+					atom,
+					family,
+					store,
+					store.transactionStatus.core,
+				)
+				if (result) {
+					return result
+				}
+			}
+		}
+	}
+	return getState__INTERNAL(atom, store)
+}
+
+export function copyMutableFamilyMemberWithinTransaction<T>(
+	atom: Atom<T>,
+	family:
+		| AtomFamily<T, any>
+		| (AtomFamily<T, any> & JsonInterface<T, Json.Serializable>),
+	origin: Store,
+	target: StoreCore,
+): T | null {
+	if (`toJson` in family && `fromJson` in family) {
+		const copyCreated = copyMutableIfNeeded(atom, family, origin, target)
+		return copyCreated
+	}
+	return null
+}

package/internal/src/set-state/copy-mutable-into-new-store.ts

@@ -0,0 +1,34 @@
+import type { AtomFamily } from "atom.io"
+import type { Json, JsonInterface } from "atom.io/json"
+import type { Store, StoreCore } from ".."
+import type { Atom } from "../atom"
+import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
+
+export function copyMutableIntoNewStore<T>(
+	atom: Atom<T> | (Atom<T> & JsonInterface<T, Json.Serializable>),
+	origin: Store,
+	target: Store,
+): void {
+	if (`toJson` in atom && `fromJson` in atom) {
+		copyMutableIfNeeded(atom, atom, origin, target)
+	}
+	if (`family` in atom) {
+		const family = target.families.get(atom.family.key)
+		if (family && family.type === `atom_family`) {
+			copyMutableFamilyMemberIntoNewStore(atom, family, origin, target)
+		}
+	}
+}
+
+export function copyMutableFamilyMemberIntoNewStore<T>(
+	atom: Atom<T>,
+	family:
+		| AtomFamily<T, any>
+		| (AtomFamily<T, any> & JsonInterface<T, Json.Serializable>),
+	origin: Store,
+	target: Store,
+): void {
+	if (`toJson` in family && `fromJson` in family) {
+		copyMutableIfNeeded(atom, family, origin, target)
+	}
+}

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

@@ -0,0 +1,23 @@
+import type { StateUpdate } from "atom.io"
+import type { Store } from "atom.io/internal"
+
+import type { Atom } from "../atom"
+import type { ReadonlySelector, Selector } from "../selector"
+
+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,
+		`)`,
+	)
+	logger?.info(`📢 notifying subscribers:`, state.subject.subscribers)
+	state.subject.next(update)
+}

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

@@ -0,0 +1,39 @@
+import type { Atom } from "../atom"
+import { isDone, markDone } from "../operation"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { target } from "../transaction"
+
+export const evictDownStream = <T>(
+	state: Atom<T>,
+	store: Store = IMPLICIT.STORE,
+): void => {
+	const core = target(store)
+	const downstreamKeys = core.selectorAtoms.getRelatedKeys(state.key)
+	store.config.logger?.info(
+		`   || ${downstreamKeys?.size ?? `none`} downstream:`,
+		downstreamKeys,
+	)
+	if (core.operation.open) {
+		store.config.logger?.info(`   ||`, [...core.operation.done], `already done`)
+	}
+	if (downstreamKeys) {
+		for (const key of downstreamKeys) {
+			if (isDone(key, store)) {
+				store.config.logger?.info(`   || ${key} already done`)
+				continue
+			}
+			const state = core.selectors.get(key) ?? core.readonlySelectors.get(key)
+			if (!state) {
+				store.config.logger?.info(
+					`   || ${key} was not found in selectors or readonlySelectors`,
+				)
+				return
+			}
+			core.valueMap.delete(key)
+			store.config.logger?.info(`   xx evicted "${key}"`)
+
+			markDone(key, store)
+		}
+	}
+}

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

@@ -0,0 +1,2 @@
+export * from "./become"
+export * from "./set-state-internal"

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

@@ -0,0 +1,38 @@
+import type { Atom } from "../atom"
+import { isAtomDefault, markAtomAsNotDefault } from "../atom"
+import { cacheValue } from "../caching"
+import { getState__INTERNAL } from "../get-state-internal"
+import { markDone } from "../operation"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { become } from "./become"
+import { copyMutableIfWithinTransaction } from "./copy-mutable-in-transaction"
+import { emitUpdate } from "./emit-update"
+import { evictDownStream } from "./evict-downstream"
+import { stowUpdate } from "./stow-update"
+
+export const setAtomState = <T>(
+	atom: Atom<T>,
+	next: T | ((oldValue: T) => T),
+	store: Store = IMPLICIT.STORE,
+): void => {
+	const oldValue = getState__INTERNAL(atom, store)
+	let newValue = copyMutableIfWithinTransaction(atom, store)
+	newValue = become(next)(newValue)
+	store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
+	cacheValue(atom.key, newValue, atom.subject, 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)
+	}
+}

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

@@ -0,0 +1,19 @@
+import { getState__INTERNAL } from "../get-state-internal"
+import type { Selector } from "../selector"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { become } from "./become"
+
+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)
+}