atom.io 0.6.9 → 0.8.0

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

@@ -0,0 +1,18 @@
+import type { Atom } from "../atom"
+import type { Selector } from "../selector"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { setAtomState } from "./set-atom-state"
+import { setSelectorState } from "./set-selector-state"
+
+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/internal/src/set-state/stow-update.ts

@@ -0,0 +1,42 @@
+import type { KeyedStateUpdate, StateUpdate } from "atom.io"
+
+import type { Atom } from "../atom"
+import { isTransceiver } from "../mutable"
+import type { Store } from "../store"
+
+function shouldUpdateBeStowed(key: string, update: StateUpdate<any>): boolean {
+	// do not stow updates that aren't json, unless they're not equal by reference
+	if (isTransceiver(update.newValue)) {
+		return false
+	}
+	// do not stow updates where the key contains 👁‍🗨
+	if (key.includes(`👁‍🗨`)) {
+		return false
+	}
+	return true
+}
+
+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
+	}
+	const shouldStow = shouldUpdateBeStowed(key, update)
+	if (!shouldStow) {
+		return
+	}
+	const atomUpdate: KeyedStateUpdate<T> = { key, ...update }
+	if (state.family) {
+		atomUpdate.family = state.family
+	}
+	store.transactionStatus.atomUpdates.push(atomUpdate)
+	logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
+}

package/internal/src/store/deposit.ts

@@ -0,0 +1,43 @@
+import type {
+	AtomToken,
+	ReadonlySelectorToken,
+	SelectorToken,
+	StateToken,
+	TransactionToken,
+	ƒn,
+} from "atom.io"
+
+import type { Atom } from "../atom"
+import type { ReadonlySelector, Selector } from "../selector"
+import type { Transaction } from "../transaction"
+
+export function deposit<T>(state: Atom<T>): AtomToken<T>
+export function deposit<T>(state: Selector<T>): SelectorToken<T>
+export function deposit<T>(state: Atom<T> | Selector<T>): StateToken<T>
+export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
+export function deposit<T>(
+	state: Transaction<T extends ƒn ? T : never>,
+): TransactionToken<T>
+export function deposit<T>(
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+): ReadonlySelectorToken<T> | StateToken<T>
+export function deposit<T>(
+	state:
+		| Atom<T>
+		| ReadonlySelector<T>
+		| Selector<T>
+		| Transaction<T extends ƒn ? T : never>,
+):
+	| AtomToken<T>
+	| ReadonlySelectorToken<T>
+	| SelectorToken<T>
+	| TransactionToken<T> {
+	const token = {
+		key: state.key,
+		type: state.type,
+	} as any
+	if (`family` in state) {
+		token.family = state.family
+	}
+	return token
+}

package/internal/src/store/index.ts

@@ -0,0 +1,5 @@
+export * from "./deposit"
+export * from "./lookup"
+export * from "./store"
+export * from "./withdraw"
+export * from "./withdraw-new-family-member"

package/internal/src/store/lookup.ts

@@ -0,0 +1,26 @@
+import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "atom.io"
+
+import { target } from "../transaction"
+import type { Store } from "./store"
+
+export function lookup(
+	key: string,
+	store: Store,
+): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown> {
+	const core = target(store)
+	let type: string = core.atoms.has(key)
+		? `atom`
+		: core.selectors.has(key)
+		? `selector`
+		: core.readonlySelectors.has(key)
+		? `readonly_selector`
+		: ``
+	if (!type) {
+		const errorId = Math.random().toString(36)
+		type = `🚨 This state could not be found by lookup! Check the console for "${errorId}"`
+		store.config.logger?.error(
+			`${errorId}: Key "${key}" does not exist in the store.`,
+		)
+	}
+	return { key, type } as any
+}

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
+}