atom.io 0.6.8 → 0.6.9

package/src/internal/transaction/build-transaction.ts

@@ -1,33 +0,0 @@
-import type { Store } from ".."
-
-export const buildTransaction = (
-	key: string,
-	params: any[],
-	store: Store,
-): void => {
-	store.transactionStatus = {
-		key,
-		phase: `building`,
-		time: Date.now(),
-		core: {
-			atoms: new Map(store.atoms),
-			atomsThatAreDefault: store.atomsThatAreDefault,
-			operation: { open: false },
-			readonlySelectors: new Map(store.readonlySelectors),
-			timelines: new Map(store.timelines),
-			timelineAtoms: store.timelineAtoms,
-			transactions: new Map(store.transactions),
-			selectorAtoms: store.selectorAtoms,
-			selectorGraph: store.selectorGraph,
-			selectors: new Map(store.selectors),
-			valueMap: new Map(store.valueMap),
-		},
-		atomUpdates: [],
-		params,
-		output: undefined,
-	}
-	store.config.logger?.info(
-		`🛫`,
-		`transaction "${key}" started in store "${store.config.name}"`,
-	)
-}

package/src/internal/transaction/index.ts

@@ -1,25 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { StoreCore } from ".."
-import type { StateUpdate, TransactionUpdate } from "../.."
-
-export * from "./abort-transaction"
-export * from "./apply-transaction"
-export * from "./build-transaction"
-export * from "./redo-transaction"
-export * from "./undo-transaction"
-
-export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
-export type TransactionPhase = typeof TRANSACTION_PHASES[number]
-
-export type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
-	phase: `applying` | `building`
-	time: number
-	core: StoreCore
-}
-export type TransactionIdle = {
-	phase: `idle`
-}
-export type TransactionStatus<ƒ extends ƒn> =
-	| TransactionIdle
-	| TransactionUpdateInProgress<ƒ>

package/src/internal/transaction/redo-transaction.ts

@@ -1,23 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken, TransactionUpdate } from "../.."
-import { setState } from "../.."
-
-export const redoTransactionUpdate = <ƒ extends ƒn>(
-	update: TransactionUpdate<ƒ>,
-	store: Store,
-): void => {
-	store.config.logger?.info(` ⏭ redo transaction "${update.key}" (redo)`)
-	for (const { key, newValue } of update.atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		const state = withdraw(token, store)
-		if (state === null) {
-			throw new Error(
-				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
-			)
-		}
-		setState(state, newValue, store)
-	}
-}

package/src/internal/transaction/undo-transaction.ts

@@ -1,23 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken, TransactionUpdate } from "../.."
-import { setState } from "../.."
-
-export const undoTransactionUpdate = <ƒ extends ƒn>(
-	update: TransactionUpdate<ƒ>,
-	store: Store,
-): void => {
-	store.config.logger?.info(` ⏮ undo transaction "${update.key}" (undo)`)
-	for (const { key, oldValue } of update.atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		const state = withdraw(token, store)
-		if (state === null) {
-			throw new Error(
-				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
-			)
-		}
-		setState(state, oldValue, store)
-	}
-}

package/src/internal/transaction-internal.ts

@@ -1,61 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store, StoreCore } from "."
-import {
-	Subject,
-	abortTransaction,
-	applyTransaction,
-	buildTransaction,
-	deposit,
-	IMPLICIT,
-} from "."
-import type { TransactionOptions, TransactionToken, TransactionUpdate } from ".."
-import { getState, setState } from ".."
-
-export type Transaction<ƒ extends ƒn> = {
-	key: string
-	type: `transaction`
-	install: (store: Store) => void
-	subject: Subject<TransactionUpdate<ƒ>>
-	run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
-}
-
-export function transaction__INTERNAL<ƒ extends ƒn>(
-	options: TransactionOptions<ƒ>,
-	store: Store = IMPLICIT.STORE,
-): TransactionToken<ƒ> {
-	const newTransaction: Transaction<ƒ> = {
-		key: options.key,
-		type: `transaction`,
-		run: (...params: Parameters<ƒ>) => {
-			buildTransaction(options.key, params, store)
-			try {
-				const output = options.do(
-					{
-						get: (token) => getState(token, store),
-						set: (token, value) => setState(token, value, store),
-					},
-					...params,
-				)
-				applyTransaction(output, store)
-				return output
-			} catch (thrown) {
-				abortTransaction(store)
-				store.config.logger?.error(`Transaction ${options.key} failed`, thrown)
-				throw thrown
-			}
-		},
-		install: (store) => transaction__INTERNAL(options, store),
-		subject: new Subject(),
-	}
-	const core = target(store)
-	core.transactions.set(newTransaction.key, newTransaction)
-	const token = deposit(newTransaction)
-	store.subject.transactionCreation.next(token)
-	return token
-}
-
-export const target = (store: Store = IMPLICIT.STORE): StoreCore =>
-	store.transactionStatus.phase === `building`
-		? store.transactionStatus.core
-		: store

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

@@ -1,73 +0,0 @@
-import type { AtomToken, ReadonlySelectorToken } from "atom.io"
-import { __INTERNAL__ } from "atom.io"
-
-import type { StateTokenIndex } from "."
-
-export type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>
-
-export const attachAtomIndex = (
-	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
-): ReadonlySelectorToken<AtomTokenIndex> => {
-	const atomTokenIndexState__INTERNAL =
-		__INTERNAL__.atom__INTERNAL<AtomTokenIndex>(
-			{
-				key: `👁‍🗨 Atom Token Index (Internal)`,
-				default: () =>
-					[...store.atoms]
-						.filter(([key]) => !key.includes(`👁‍🗨`))
-						.reduce<AtomTokenIndex>((acc, [key]) => {
-							acc[key] = { key, type: `atom` }
-							return acc
-						}, {}),
-				effects: [
-					({ setSelf }) => {
-						store.subject.atomCreation.subscribe((atomToken) => {
-							if (store.operation.open) {
-								return
-							}
-							if (atomToken.key.includes(`👁‍🗨`)) {
-								return
-							}
-							setSelf((state) => {
-								const { key, family } = atomToken
-								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]: atomToken,
-												},
-											},
-										}
-									}
-								}
-								return {
-									...state,
-									[key]: atomToken,
-								}
-							})
-						})
-					},
-				],
-			},
-			undefined,
-			store,
-		)
-	return __INTERNAL__.selector__INTERNAL(
-		{
-			key: `👁‍🗨 Atom Token Index`,
-			get: ({ get }) => get(atomTokenIndexState__INTERNAL),
-		},
-		undefined,
-		store,
-	)
-}

package/src/introspection/attach-introspection-states.ts

@@ -1,42 +0,0 @@
-import { __INTERNAL__ } from "atom.io"
-import type {
-	ReadonlySelectorFamily,
-	ReadonlySelectorToken,
-	TimelineToken,
-	TimelineUpdate,
-	TransactionToken,
-	TransactionUpdate,
-} from "atom.io"
-
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import { attachAtomIndex, type AtomTokenIndex } from "./attach-atom-index"
-import {
-	attachSelectorIndex,
-	type SelectorTokenIndex,
-} from "./attach-selector-index"
-import { attachTimelineFamily } from "./attach-timeline-family"
-import { attachTimelineIndex } from "./attach-timeline-index"
-import { attachTransactionIndex } from "./attach-transaction-index"
-import { attachTransactionLogs } from "./attach-transaction-logs"
-import type { Timeline } from "../internal"
-
-export const attachIntrospectionStates = (
-	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
-): {
-	atomIndex: ReadonlySelectorToken<AtomTokenIndex>
-	selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>
-	transactionIndex: ReadonlySelectorToken<TransactionToken<ƒn>[]>
-	findTransactionLogState: ReadonlySelectorFamily<TransactionUpdate<ƒn>[]>
-	timelineIndex: ReadonlySelectorToken<TimelineToken[]>
-	findTimelineState: ReadonlySelectorFamily<Timeline>
-} => {
-	return {
-		atomIndex: attachAtomIndex(store),
-		selectorIndex: attachSelectorIndex(store),
-		transactionIndex: attachTransactionIndex(store),
-		findTransactionLogState: attachTransactionLogs(store),
-		timelineIndex: attachTimelineIndex(store),
-		findTimelineState: attachTimelineFamily(store),
-	}
-}

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-family.ts

@@ -1,59 +0,0 @@
-import type { ReadonlySelectorFamily, Store } from "atom.io"
-import { __INTERNAL__, timeline } from "atom.io"
-
-import { withdraw, type Timeline, Subject } from "../internal"
-
-export const attachTimelineFamily = (
-	store: Store = __INTERNAL__.IMPLICIT.STORE,
-): ReadonlySelectorFamily<Timeline> => {
-	const findTimelineLogState__INTERNAL = __INTERNAL__.atomFamily__INTERNAL<
-		Timeline,
-		string
-	>(
-		{
-			key: `👁‍🗨 Timeline Update Log (Internal)`,
-			default: (key) =>
-				store.timelines.get(key) ?? {
-					key: ``,
-					at: 0,
-					timeTraveling: null,
-					history: [],
-					selectorTime: null,
-					transactionKey: null,
-					install: () => {},
-					subject: new Subject(),
-				},
-			effects: (key) => [
-				({ setSelf }) => {
-					const tl = store.timelines.get(key)
-					tl?.subject.subscribe((_) => {
-						if (store.operation.open === true) {
-							const subscription = store.subject.operationStatus.subscribe(
-								(operationStatus) => {
-									if (operationStatus.open === false) {
-										subscription.unsubscribe()
-										setSelf({ ...tl })
-									}
-								},
-							)
-						} else {
-							setSelf({ ...tl })
-						}
-					})
-				},
-			],
-		},
-		store,
-	)
-	const findTimelineLogState = __INTERNAL__.selectorFamily__INTERNAL<
-		Timeline,
-		string
-	>(
-		{
-			key: `👁‍🗨 Timeline Update Log`,
-			get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL(key)),
-		},
-		store,
-	)
-	return findTimelineLogState
-}

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/introspection/attach-transaction-logs.ts

@@ -1,40 +0,0 @@
-import type { ReadonlySelectorFamily, TransactionUpdate } from "atom.io"
-import { __INTERNAL__ } from "atom.io"
-
-import type { ƒn } from "~/packages/anvl/src/function"
-
-export const attachTransactionLogs = (
-	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
-): ReadonlySelectorFamily<TransactionUpdate<ƒn>[]> => {
-	const findTransactionUpdateLog = __INTERNAL__.atomFamily__INTERNAL<
-		TransactionUpdate<ƒn>[],
-		string
-	>(
-		{
-			key: `👁‍🗨 Transaction Update Log (Internal)`,
-			default: () => [],
-			effects: (key) => [
-				({ setSelf }) => {
-					const tx = store.transactions.get(key)
-					tx?.subject.subscribe((transactionUpdate) => {
-						if (transactionUpdate.key === key) {
-							setSelf((state) => [...state, transactionUpdate])
-						}
-					})
-				},
-			],
-		},
-		store,
-	)
-	const findTransactionUpdateLogState = __INTERNAL__.selectorFamily__INTERNAL<
-		TransactionUpdate<ƒn>[],
-		string
-	>(
-		{
-			key: `👁‍🗨 Transaction Update Log`,
-			get: (key) => ({ get }) => get(findTransactionUpdateLog(key)),
-		},
-		store,
-	)
-	return findTransactionUpdateLogState
-}

package/src/introspection/index.ts

@@ -1,20 +0,0 @@
-import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "atom.io"
-
-export * from "./attach-introspection-states"
-
-export type FamilyNode<
-	Token extends
-		| AtomToken<unknown>
-		| ReadonlySelectorToken<unknown>
-		| SelectorToken<unknown>,
-> = {
-	key: string
-	familyMembers: Record<string, Token>
-}
-
-export type StateTokenIndex<
-	Token extends
-		| AtomToken<unknown>
-		| ReadonlySelectorToken<unknown>
-		| SelectorToken<unknown>,
-> = Record<string, FamilyNode<Token> | Token>

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/index.ts

@@ -1,2 +0,0 @@
-export * from "./store-context"
-export * from "./store-hooks"

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