atom.io 0.6.7 → 0.6.9

package/src/internal/get.ts

@@ -1,129 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type {
-	Atom,
-	ReadonlySelector,
-	Selector,
-	Store,
-	Timeline,
-	Transaction,
-} from "."
-import { target, isValueCached, readCachedValue, IMPLICIT } from "."
-import type {
-	AtomToken,
-	ReadonlySelectorToken,
-	SelectorToken,
-	StateToken,
-	TimelineToken,
-	TransactionToken,
-} from ".."
-
-export const computeSelectorState = <T>(
-	selector: ReadonlySelector<T> | Selector<T>,
-): T => selector.get()
-
-export function lookup(
-	key: string,
-	store: Store,
-): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown> {
-	const core = target(store)
-	const type = core.atoms.has(key)
-		? `atom`
-		: core.selectors.has(key)
-		? `selector`
-		: `readonly_selector`
-	return { key, type } as any
-}
-
-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 {
-	const core = target(store)
-	return (
-		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) ??
-		null
-	)
-}
-
-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> {
-	return {
-		key: state.key,
-		type: state.type,
-		...(`family` in state && { family: state.family }),
-	} as any
-}
-
-export const getState__INTERNAL = <T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	store: Store = IMPLICIT.STORE,
-): T => {
-	if (isValueCached(state.key, store)) {
-		store.config.logger?.info(`>> read "${state.key}"`)
-		return readCachedValue(state.key, store)
-	}
-	if (state.type !== `atom`) {
-		store.config.logger?.info(`-> calc "${state.key}"`)
-		return computeSelectorState(state)
-	}
-	store.config.logger?.error(
-		`Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`,
-	)
-	return state.default
-}

package/src/internal/index.ts

@@ -1,15 +0,0 @@
-export * from "./atom-internal"
-export * from "./families-internal"
-export * from "./get"
-export * from "./is-default"
-export * from "./operation"
-export * from "./selector-internal"
-export * from "./selector"
-export * from "./set"
-export * from "./store"
-export * from "./subject"
-export * from "./subscribe-internal"
-export * from "./time-travel-internal"
-export * from "./timeline-internal"
-export * from "./transaction-internal"
-export * from "./transaction"

package/src/internal/is-default.ts

@@ -1,35 +0,0 @@
-import type { Store } from "."
-import { target, IMPLICIT, traceAllSelectorAtoms } from "."
-
-export const isAtomDefault = (
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): boolean => {
-	const core = target(store)
-	return core.atomsThatAreDefault.has(key)
-}
-
-export const markAtomAsDefault = (
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const core = target(store)
-	core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key)
-}
-
-export const markAtomAsNotDefault = (
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	const core = target(store)
-	core.atomsThatAreDefault = new Set(target(store).atomsThatAreDefault)
-	core.atomsThatAreDefault.delete(key)
-}
-
-export const isSelectorDefault = (
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): boolean => {
-	const roots = traceAllSelectorAtoms(key, store)
-	return roots.every((root) => isAtomDefault(root.key, store))
-}

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,66 +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`,
-		family,
-	}
-	store.subject.selectorCreation.next(token)
-	return token
-}

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

@@ -1,46 +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`,
-		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)
-}