atom.io 0.6.8 → 0.7.0

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

package/src/internal/store.ts

@@ -1,151 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-import { doNothing } from "~/packages/anvl/src/function"
-import { Join } from "~/packages/anvl/src/join"
-
-import { Subject } from "."
-import type {
-	Atom,
-	OperationProgress,
-	ReadonlySelector,
-	Selector,
-	TransactionStatus,
-	Timeline,
-	Transaction,
-} from "."
-import type {
-	AtomToken,
-	Logger,
-	ReadonlySelectorToken,
-	SelectorToken,
-	TimelineToken,
-	TransactionToken,
-} from ".."
-
-export type StoreCore = Pick<
-	Store,
-	| `atoms`
-	| `atomsThatAreDefault`
-	| `operation`
-	| `readonlySelectors`
-	| `selectorAtoms`
-	| `selectorGraph`
-	| `selectors`
-	| `timelineAtoms`
-	| `timelines`
-	| `transactions`
-	| `valueMap`
->
-
-export interface Store {
-	atoms: Map<string, Atom<any>>
-	atomsThatAreDefault: Set<string>
-	readonlySelectors: Map<string, ReadonlySelector<any>>
-	selectorAtoms: Join<null, `selectorKey`, `atomKey`>
-	selectorGraph: Join<{ source: string }>
-	selectors: Map<string, Selector<any>>
-	timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-	timelines: Map<string, Timeline>
-	transactions: Map<string, Transaction<any>>
-	valueMap: Map<string, any>
-
-	subject: {
-		atomCreation: Subject<AtomToken<unknown>>
-		selectorCreation: Subject<
-			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
-		>
-		transactionCreation: Subject<TransactionToken<ƒn>>
-		timelineCreation: Subject<TimelineToken>
-		operationStatus: Subject<OperationProgress>
-	}
-
-	operation: OperationProgress
-	transactionStatus: TransactionStatus<ƒn>
-	config: {
-		name: string
-		logger: Logger | null
-		logger__INTERNAL: Logger
-	}
-}
-
-export const createStore = (name: string, store: Store | null = null): Store => {
-	const created = {
-		...(store ??
-			(() => ({
-				atomsThatAreDefault: new Set(),
-				selectorAtoms: new Join({ relationType: `n:n` })
-					.from(`selectorKey`)
-					.to(`atomKey`),
-				selectorGraph: new Join({ relationType: `n:n` }),
-			}))()),
-
-		valueMap: new Map(store?.valueMap),
-		atoms: new Map(),
-		readonlySelectors: new Map(),
-		selectors: new Map(),
-		transactions: new Map(),
-		timelines: new Map(),
-
-		timelineAtoms: new Join({ relationType: `1:n` })
-			.from(`timelineKey`)
-			.to(`atomKey`),
-
-		subject: {
-			atomCreation: new Subject(),
-			selectorCreation: new Subject(),
-			transactionCreation: new Subject(),
-			timelineCreation: new Subject(),
-			operationStatus: new Subject(),
-		},
-
-		operation: {
-			open: false,
-			...store?.operation,
-		},
-		transactionStatus: {
-			phase: `idle`,
-			...store?.transactionStatus,
-		},
-		config: {
-			logger: {
-				...console,
-				info: doNothing,
-				...store?.config?.logger,
-			},
-			logger__INTERNAL: console,
-			...store?.config,
-			name,
-		},
-	} satisfies Store
-
-	store?.atoms.forEach((atom) => {
-		const copiedAtom = { ...atom, subject: new Subject() } satisfies Atom<any>
-		created.atoms.set(atom.key, copiedAtom)
-	})
-	store?.readonlySelectors.forEach((selector) => {
-		selector.install(created)
-	})
-	store?.selectors.forEach((selector) => {
-		selector.install(created)
-	})
-	store?.transactions.forEach((tx) => {
-		tx.install(created)
-	})
-	store?.timelines.forEach((timeline) => {
-		timeline.install(created)
-	})
-
-	return created
-}
-
-export const IMPLICIT = {
-	STORE_INTERNAL: undefined as Store | undefined,
-	get STORE(): Store {
-		return this.STORE_INTERNAL ?? (this.STORE_INTERNAL = createStore(`DEFAULT`))
-	},
-}
-
-export const clearStore = (store: Store = IMPLICIT.STORE): void => {
-	const { config } = store
-	Object.assign(store, createStore(config.name))
-	store.config = config
-}

package/src/internal/subscribe-internal.ts

@@ -1,88 +0,0 @@
-import type { Atom, ReadonlySelector, Selector, Store } from "."
-import {
-	getState__INTERNAL,
-	withdraw,
-	recallState,
-	traceAllSelectorAtoms,
-} from "."
-import type { StateUpdate } from ".."
-
-export const prepareUpdate = <T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	store: Store,
-): StateUpdate<T> => {
-	const oldValue = recallState(state, store)
-	const newValue = getState__INTERNAL(state, store)
-	return { newValue, oldValue }
-}
-
-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
-	}
-	store.transactionStatus.atomUpdates.push({ key, ...update })
-	logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
-}
-
-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,
-		`)`,
-	)
-	state.subject.next(update)
-}
-
-export const subscribeToRootAtoms = <T>(
-	state: ReadonlySelector<T> | Selector<T>,
-	store: Store,
-): { unsubscribe: () => 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((atomChange) => {
-						store.config.logger?.info(
-							`📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
-							atomChange.oldValue,
-							`->`,
-							atomChange.newValue,
-							`)`,
-						)
-						const oldValue = recallState(state, store)
-						const newValue = getState__INTERNAL(state, store)
-						store.config.logger?.info(
-							`   <- "${state.key}" went (`,
-							oldValue,
-							`->`,
-							newValue,
-							`)`,
-						)
-						state.subject.next({ newValue, oldValue })
-					})
-			  })
-	return dependencySubscriptions
-}

package/src/internal/timeline/index.ts

@@ -1 +0,0 @@
-export * from "./add-atom-to-timeline"

package/src/introspection/attach-selector-index.ts

@@ -1,77 +0,0 @@
-import { __INTERNAL__ } from "atom.io"
-import type { ReadonlySelectorToken, SelectorToken } from "atom.io"
-
-import type { StateTokenIndex } from "."
-
-export type SelectorTokenIndex = StateTokenIndex<
-	ReadonlySelectorToken<unknown> | SelectorToken<unknown>
->
-
-export const attachSelectorIndex = (
-	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
-): ReadonlySelectorToken<SelectorTokenIndex> => {
-	const readonlySelectorTokenIndexState__INTERNAL =
-		__INTERNAL__.atom__INTERNAL<SelectorTokenIndex>(
-			{
-				key: `👁‍🗨 Selector Token Index (Internal)`,
-				default: () =>
-					Object.assign(
-						[...store.readonlySelectors]
-							.filter(([key]) => !key.includes(`👁‍🗨`))
-							.reduce<SelectorTokenIndex>((acc, [key]) => {
-								acc[key] = { key, type: `readonly_selector` }
-								return acc
-							}, {}),
-						[...store.selectors].reduce<SelectorTokenIndex>((acc, [key]) => {
-							acc[key] = { key, type: `selector` }
-							return acc
-						}, {}),
-					),
-				effects: [
-					({ setSelf }) => {
-						store.subject.selectorCreation.subscribe((selectorToken) => {
-							if (store.operation.open) {
-								return
-							}
-							if (selectorToken.key.includes(`👁‍🗨`)) {
-								return
-							}
-							setSelf((state) => {
-								const { key, family } = selectorToken
-								if (family) {
-									const { key: familyKey, subKey } = family
-									const current = state[familyKey]
-									if (current === undefined || `familyMembers` in current) {
-										const familyKeyState = current || {
-											key: familyKey,
-											familyMembers: {},
-										}
-										return {
-											...state,
-											[familyKey]: {
-												...familyKeyState,
-												familyMembers: {
-													...familyKeyState.familyMembers,
-													[subKey]: selectorToken,
-												},
-											},
-										}
-									}
-								}
-								return {
-									...state,
-									[key]: selectorToken,
-								}
-							})
-						})
-					},
-				],
-			},
-			undefined,
-			store,
-		)
-	return __INTERNAL__.selector__INTERNAL({
-		key: `👁‍🗨 Selector Token Index`,
-		get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
-	})
-}

package/src/introspection/attach-timeline-index.ts

@@ -1,36 +0,0 @@
-import type { ReadonlySelectorToken, Store, TimelineToken } from "atom.io"
-import { __INTERNAL__ } from "atom.io"
-
-export const attachTimelineIndex = (
-	store: Store = __INTERNAL__.IMPLICIT.STORE,
-): ReadonlySelectorToken<TimelineToken[]> => {
-	const timelineTokenIndexState__INTERNAL = __INTERNAL__.atom__INTERNAL<
-		TimelineToken[]
-	>(
-		{
-			key: `👁‍🗨 Timeline Token Index (Internal)`,
-			default: () =>
-				[...store.timelines].map(([key]) => {
-					return { key, type: `timeline` }
-				}),
-			effects: [
-				({ setSelf }) => {
-					store.subject.timelineCreation.subscribe((timelineToken) => {
-						setSelf((state) => [...state, timelineToken])
-					})
-				},
-			],
-		},
-		undefined,
-		store,
-	)
-	const timelineTokenIndex = __INTERNAL__.selector__INTERNAL(
-		{
-			key: `👁‍🗨 Timeline Token Index`,
-			get: ({ get }) => get(timelineTokenIndexState__INTERNAL),
-		},
-		undefined,
-		store,
-	)
-	return timelineTokenIndex
-}

package/src/introspection/attach-transaction-index.ts

@@ -1,38 +0,0 @@
-import type { ReadonlySelectorToken, TransactionToken } from "atom.io"
-import { __INTERNAL__ } from "atom.io"
-
-import type { ƒn } from "~/packages/anvl/src/function"
-
-export const attachTransactionIndex = (
-	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
-): ReadonlySelectorToken<TransactionToken<ƒn>[]> => {
-	const transactionTokenIndexState__INTERNAL = __INTERNAL__.atom__INTERNAL<
-		TransactionToken<ƒn>[]
-	>(
-		{
-			key: `👁‍🗨 Transaction Token Index (Internal)`,
-			default: () =>
-				[...store.transactions].map(([key]) => {
-					return { key, type: `transaction` }
-				}),
-			effects: [
-				({ setSelf }) => {
-					store.subject.transactionCreation.subscribe((transactionToken) => {
-						setSelf((state) => [...state, transactionToken])
-					})
-				},
-			],
-		},
-		undefined,
-		store,
-	)
-	const transactionTokenIndex = __INTERNAL__.selector__INTERNAL(
-		{
-			key: `👁‍🗨 Transaction Token Index`,
-			get: ({ get }) => get(transactionTokenIndexState__INTERNAL),
-		},
-		undefined,
-		store,
-	)
-	return transactionTokenIndex
-}

package/src/json/index.ts

@@ -1 +0,0 @@
-export * from "./select-json"

package/src/json/select-json.ts

@@ -1,18 +0,0 @@
-import * as AtomIO from "atom.io"
-
-import type { Json, JsonInterface } from "~/packages/anvl/src/json"
-
-export const selectJson = <T, J extends Json.Serializable>(
-	atom: AtomIO.AtomToken<T>,
-	transform: JsonInterface<T, J>,
-	store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE,
-): AtomIO.SelectorToken<J> =>
-	AtomIO.__INTERNAL__.selector__INTERNAL(
-		{
-			key: `${atom.key}JSON`,
-			get: ({ get }) => transform.toJson(get(atom)),
-			set: ({ set }, newValue) => set(atom, transform.fromJson(newValue)),
-		},
-		undefined,
-		store,
-	)

package/src/react/store-context.tsx

@@ -1,13 +0,0 @@
-import * as AtomIO from "atom.io"
-import * as React from "react"
-
-export const StoreContext = React.createContext<AtomIO.Store>(
-	AtomIO.__INTERNAL__.IMPLICIT.STORE,
-)
-
-export const StoreProvider: React.FC<{
-	children: React.ReactNode
-	store?: AtomIO.Store
-}> = ({ children, store = AtomIO.__INTERNAL__.IMPLICIT.STORE }) => (
-	<StoreContext.Provider value={store}>{children}</StoreContext.Provider>
-)

package/src/react/store-hooks.ts

@@ -1,47 +0,0 @@
-import * as AtomIO from "atom.io"
-import * as React from "react"
-
-import type { Modifier } from "~/packages/anvl/src/function"
-
-import { StoreContext } from "./store-context"
-
-export type StoreHooks = {
-	useI: <T>(token: AtomIO.StateToken<T>) => (next: Modifier<T> | T) => void
-	useO: <T>(token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>) => T
-	useIO: <T>(token: AtomIO.StateToken<T>) => [T, (next: Modifier<T> | T) => void]
-}
-export const storeHooks: StoreHooks = { useI, useO, useIO }
-
-export function useI<T>(
-	token: AtomIO.StateToken<T>,
-): (next: Modifier<T> | T) => void {
-	const store = React.useContext(StoreContext)
-	const update = (next: Modifier<T> | T) => AtomIO.setState(token, next, store)
-	return update
-}
-
-export function useO<T>(
-	token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>,
-): T {
-	const store = React.useContext(StoreContext)
-	return React.useSyncExternalStore<T>(
-		(observe) => AtomIO.subscribe(token, observe, store),
-		() => AtomIO.getState(token, store),
-	)
-}
-
-export function useIO<T>(
-	token: AtomIO.StateToken<T>,
-): [T, (next: Modifier<T> | T) => void] {
-	return [useO(token), useI(token)]
-}
-
-export function useStore<T>(
-	token: AtomIO.StateToken<T>,
-): [T, (next: Modifier<T> | T) => void]
-export function useStore<T>(token: AtomIO.ReadonlySelectorToken<T>): T
-export function useStore<T>(
-	token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>,
-): T | [T, (next: Modifier<T> | T) => void] {
-	return token.type === `readonly_selector` ? useO(token) : useIO(token)
-}