atom.io 0.6.8 → 0.6.9

package/src/internal/operation.ts

@@ -1,139 +0,0 @@
-import type { Atom, ReadonlySelector, Selector } from "."
-import { target } from "."
-import type { Store } from "./store"
-import { IMPLICIT } from "./store"
-import type { StateToken } from ".."
-
-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}"`,
-	)
-}
-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)
-}
-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)
-}
-
-export const cacheValue = (
-	key: string,
-	value: unknown,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const core = target(store)
-	core.valueMap.set(key, value)
-}
-
-export const evictCachedValue = (
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const core = target(store)
-	core.valueMap.delete(key)
-}
-export const readCachedValue = <T>(
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): T => target(store).valueMap.get(key)
-
-export const isValueCached = (
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): boolean => target(store).valueMap.has(key)
-
-export const storeAtom = (
-	atom: Atom<any>,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const core = target(store)
-	core.atoms.set(atom.key, atom)
-}
-
-export const storeSelector = (
-	selector: Selector<any>,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const core = target(store)
-	core.selectors.set(selector.key, selector)
-}
-
-export const storeReadonlySelector = (
-	selector: ReadonlySelector<any>,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const core = target(store)
-	core.readonlySelectors.set(selector.key, selector)
-}
-
-export const hasKeyBeenUsed = (
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): boolean => {
-	const core = target(store)
-	return (
-		core.atoms.has(key) ||
-		core.selectors.has(key) ||
-		core.readonlySelectors.has(key)
-	)
-}

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

@@ -1,68 +0,0 @@
-import { become } from "~/packages/anvl/src/function"
-
-import { Subject } from ".."
-import {
-	type Store,
-	type Selector,
-	type StoreCore,
-	registerSelector,
-	selector__INTERNAL,
-} from ".."
-import type { FamilyMetadata, SelectorToken } from "../.."
-import type { SelectorOptions } from "../../selector"
-import { cacheValue, markDone } from "../operation"
-
-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, 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, 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) => selector__INTERNAL(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/src/internal/selector/create-readonly-selector.ts

@@ -1,48 +0,0 @@
-import { registerSelector } from "./register-selector"
-import { Subject } from ".."
-import type {
-	FamilyMetadata,
-	ReadonlySelectorOptions,
-	ReadonlySelectorToken,
-	Store,
-} from "../.."
-import { cacheValue } from "../operation"
-import { selector__INTERNAL, type ReadonlySelector } from "../selector-internal"
-import type { StoreCore } from "../store"
-
-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, store)
-		return value
-	}
-
-	const readonlySelector: ReadonlySelector<T> = {
-		...options,
-		subject,
-		install: (s: Store) => selector__INTERNAL(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/src/internal/selector/index.ts

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

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

@@ -1,16 +0,0 @@
-import type { Store } from ".."
-import { target, lookup } from ".."
-import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "../.."
-
-export const lookupSelectorSources = (
-	key: string,
-	store: Store,
-): (
-	| AtomToken<unknown>
-	| ReadonlySelectorToken<unknown>
-	| SelectorToken<unknown>
-)[] =>
-	target(store)
-		.selectorGraph.getRelations(key)
-		.filter(({ source }) => source !== key)
-		.map(({ source }) => lookup(source, store))

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

@@ -1,57 +0,0 @@
-import { updateSelectorAtoms } from "./update-selector-atoms"
-import type { Transactors } from "../../transaction"
-import { getState__INTERNAL, withdraw } from "../get"
-import { setState__INTERNAL } from "../set"
-import type { Store } from "../store"
-import { IMPLICIT } from "../store"
-import { target } from "../transaction-internal"
-
-export const registerSelector = (
-	selectorKey: string,
-	store: Store = IMPLICIT.STORE,
-): Transactors => ({
-	get: (dependency) => {
-		const core = target(store)
-		const alreadyRegistered = core.selectorGraph
-			.getRelations(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(
-				{ from: dependency.key, to: 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/src/internal/selector/trace-selector-atoms.ts

@@ -1,43 +0,0 @@
-import { lookupSelectorSources } from "./lookup-selector-sources"
-import type { Store, AtomToken, ReadonlySelectorToken, StateToken } from "../.."
-
-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) {
-		// rome-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/src/internal/selector/update-selector-atoms.ts

@@ -1,33 +0,0 @@
-import { traceSelectorAtoms } from "./trace-selector-atoms"
-import type { Store } from ".."
-import { target } from ".."
-import type { ReadonlySelectorToken, StateToken } from "../.."
-
-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/src/internal/selector-internal.ts

@@ -1,58 +0,0 @@
-import { target, IMPLICIT } from "."
-import type { Store, Subject } from "."
-import { createReadWriteSelector } from "./selector/create-read-write-selector"
-import { createReadonlySelector } from "./selector/create-readonly-selector"
-import type {
-	FamilyMetadata,
-	ReadonlySelectorOptions,
-	ReadonlySelectorToken,
-	SelectorOptions,
-	SelectorToken,
-} from ".."
-
-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 selector__INTERNAL<T>(
-	options: SelectorOptions<T>,
-	family?: FamilyMetadata,
-	store?: Store,
-): SelectorToken<T>
-export function selector__INTERNAL<T>(
-	options: ReadonlySelectorOptions<T>,
-	family?: FamilyMetadata,
-	store?: Store,
-): ReadonlySelectorToken<T>
-export function selector__INTERNAL<T>(
-	options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
-	family?: FamilyMetadata,
-	store: Store = IMPLICIT.STORE,
-): ReadonlySelectorToken<T> | SelectorToken<T> {
-	const core = target(store)
-
-	if (core.selectors.has(options.key)) {
-		store.config.logger?.error(
-			`Key "${options.key}" already exists in the store.`,
-		)
-	}
-
-	if (!(`set` in options)) {
-		return createReadonlySelector(options, family, store, core)
-	}
-	return createReadWriteSelector(options, family, store, core)
-}

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