atom.io 0.6.8 → 0.7.0

package/{src/internal → internal/src}/selector/create-read-write-selector.ts

@@ -1,16 +1,13 @@
-import { become } from "~/packages/anvl/src/function"
+import type { FamilyMetadata, SelectorOptions, SelectorToken } from "atom.io"
 
-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"
+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>,
@@ -47,7 +44,7 @@ export const createReadWriteSelector = <T>(
 	const mySelector: Selector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => selector__INTERNAL(options, family, s),
+		install: (s: Store) => createSelector(options, family, s),
 		get: getSelf,
 		set: setSelf,
 		type: `selector`,

package/{src/internal → internal/src}/selector/create-readonly-selector.ts

@@ -1,14 +1,15 @@
-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"
+} 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>,
@@ -28,7 +29,7 @@ export const createReadonlySelector = <T>(
 	const readonlySelector: ReadonlySelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => selector__INTERNAL(options, family, s),
+		install: (s: Store) => createSelector(options, family, s),
 		get: getSelf,
 		type: `readonly_selector`,
 		...(family && { family }),

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/{src/internal → internal/src}/selector/index.ts

@@ -1,4 +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/{src/internal → internal/src}/selector/register-selector.ts

@@ -1,10 +1,11 @@
-import { updateSelectorAtoms } from "./update-selector-atoms"
-import type { Transactors } from "../../transaction"
-import { getState__INTERNAL, withdraw } from "../get"
-import { setState__INTERNAL } from "../set"
+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 } from "../store"
-import { target } from "../transaction-internal"
+import { IMPLICIT, withdraw } from "../store"
+import { target } from "../transaction/transaction-internal"
+import { updateSelectorAtoms } from "./update-selector-atoms"
 
 export const registerSelector = (
 	selectorKey: string,
@@ -13,8 +14,8 @@ export const registerSelector = (
 	get: (dependency) => {
 		const core = target(store)
 		const alreadyRegistered = core.selectorGraph
-			.getRelations(selectorKey)
-			.some(({ source }) => source === dependency.key)
+			.getRelationEntries({ downstreamSelectorKey: selectorKey })
+			.some(([_, { source }]) => source === dependency.key)
 
 		const dependencyState = withdraw(dependency, store)
 		if (dependencyState === null) {
@@ -36,7 +37,10 @@ export const registerSelector = (
 				`)`,
 			)
 			core.selectorGraph = core.selectorGraph.set(
-				{ from: dependency.key, to: selectorKey },
+				{
+					upstreamSelectorKey: dependency.key,
+					downstreamSelectorKey: selectorKey,
+				},
 				{
 					source: dependency.key,
 				},

package/{src/internal → internal/src}/selector/trace-selector-atoms.ts

@@ -1,5 +1,7 @@
+import type { AtomToken, ReadonlySelectorToken, StateToken } from "atom.io"
+
+import type { Store } from ".."
 import { lookupSelectorSources } from "./lookup-selector-sources"
-import type { Store, AtomToken, ReadonlySelectorToken, StateToken } from "../.."
 
 export const traceSelectorAtoms = (
 	selectorKey: string,
@@ -11,7 +13,7 @@ export const traceSelectorAtoms = (
 	const sources = lookupSelectorSources(dependency.key, store)
 	let depth = 0
 	while (sources.length > 0) {
-		// rome-ignore lint/style/noNonNullAssertion: just checked length ^^^
+		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
 		const source = sources.shift()!
 		++depth
 		if (depth > 999) {

package/{src/internal → internal/src}/selector/update-selector-atoms.ts

@@ -1,7 +1,8 @@
+import type { ReadonlySelectorToken, StateToken } from "atom.io"
+
+import type { Store } from "../store"
+import { target } from "../transaction"
 import { traceSelectorAtoms } from "./trace-selector-atoms"
-import type { Store } from ".."
-import { target } from ".."
-import type { ReadonlySelectorToken, StateToken } from "../.."
 
 export const updateSelectorAtoms = (
 	selectorKey: string,

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

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