atom.io 0.6.2 → 0.6.4

package/src/internal/timeline-internal.ts

@@ -1,106 +1,105 @@
 import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
 
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store } from "."
-import { target, IMPLICIT } from "."
+import { Subject, target, IMPLICIT } from "."
 import { addAtomToTimeline } from "./timeline/add-atom-to-timeline"
 import type {
-  StateUpdate,
-  TimelineOptions,
-  TimelineToken,
-  TimelineUpdate,
-  TransactionUpdate,
+	StateUpdate,
+	TimelineOptions,
+	TimelineToken,
+	TimelineUpdate,
+	TransactionUpdate,
 } from ".."
 
 export type TimelineAtomUpdate = StateUpdate<unknown> & {
-  key: string
-  type: `atom_update`
-  timestamp: number
+	key: string
+	type: `atom_update`
+	timestamp: number
 }
 export type TimelineSelectorUpdate = {
-  key: string
-  type: `selector_update`
-  timestamp: number
-  atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[]
+	key: string
+	type: `selector_update`
+	timestamp: number
+	atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[]
 }
 export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
-  key: string
-  type: `transaction_update`
-  timestamp: number
+	key: string
+	type: `transaction_update`
+	timestamp: number
 }
 
 export type Timeline = {
-  key: string
-  at: number
-  timeTraveling: boolean
-  history: TimelineUpdate[]
-  selectorTime: number | null
-  transactionKey: string | null
-  install: (store: Store) => void
-  subject: Rx.Subject<
-    TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate
-  >
+	key: string
+	at: number
+	timeTraveling: boolean
+	history: TimelineUpdate[]
+	selectorTime: number | null
+	transactionKey: string | null
+	install: (store: Store) => void
+	subject: Subject<
+		TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate
+	>
 }
 
 export function timeline__INTERNAL(
-  options: TimelineOptions,
-  store: Store = IMPLICIT.STORE,
-  data: Timeline | null = null
+	options: TimelineOptions,
+	store: Store = IMPLICIT.STORE,
+	data: Timeline | null = null,
 ): TimelineToken {
-  const tl: Timeline = {
-    key: options.key,
-    at: 0,
-    timeTraveling: false,
-    selectorTime: null,
-    transactionKey: null,
-    ...data,
-    history: data?.history.map((update) => ({ ...update })) ?? [],
-    install: (store) => timeline__INTERNAL(options, store, tl),
-    subject: new Rx.Subject(),
-  }
+	const tl: Timeline = {
+		key: options.key,
+		at: 0,
+		timeTraveling: false,
+		selectorTime: null,
+		transactionKey: null,
+		...data,
+		history: data?.history.map((update) => ({ ...update })) ?? [],
+		install: (store) => timeline__INTERNAL(options, store, tl),
+		subject: new Subject(),
+	}
 
-  const core = target(store)
-  for (const tokenOrFamily of options.atoms) {
-    const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
-    if (timelineKey) {
-      store.config.logger?.error(
-        `❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`
-      )
-      continue
-    }
-    if (tokenOrFamily.type === `atom_family`) {
-      const family = tokenOrFamily
-      family.subject.subscribe((token) =>
-        addAtomToTimeline(token, options.atoms, tl, store)
-      )
-    } else {
-      const token = tokenOrFamily
-      if (`family` in token && token.family) {
-        const familyTimelineKey = core.timelineAtoms.getRelatedId(
-          token.family.key
-        )
-        if (familyTimelineKey) {
-          store.config.logger?.error(
-            `❌ Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`
-          )
-          continue
-        }
-      }
-      addAtomToTimeline(token, options.atoms, tl, store)
-    }
-    core.timelineAtoms = core.timelineAtoms.set({
-      atomKey: tokenOrFamily.key,
-      timelineKey: options.key,
-    })
-  }
+	const core = target(store)
+	for (const tokenOrFamily of options.atoms) {
+		const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
+		if (timelineKey) {
+			store.config.logger?.error(
+				`❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`,
+			)
+			continue
+		}
+		if (tokenOrFamily.type === `atom_family`) {
+			const family = tokenOrFamily
+			family.subject.subscribe((token) =>
+				addAtomToTimeline(token, options.atoms, tl, store),
+			)
+		} else {
+			const token = tokenOrFamily
+			if (`family` in token && token.family) {
+				const familyTimelineKey = core.timelineAtoms.getRelatedId(
+					token.family.key,
+				)
+				if (familyTimelineKey) {
+					store.config.logger?.error(
+						`❌ Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`,
+					)
+					continue
+				}
+			}
+			addAtomToTimeline(token, options.atoms, tl, store)
+		}
+		core.timelineAtoms = core.timelineAtoms.set({
+			atomKey: tokenOrFamily.key,
+			timelineKey: options.key,
+		})
+	}
 
-  store.timelines = HAMT.set(options.key, tl, store.timelines)
-  const token: TimelineToken = {
-    key: options.key,
-    type: `timeline`,
-  }
-  store.subject.timelineCreation.next(token)
-  return token
+	store.timelines = HAMT.set(options.key, tl, store.timelines)
+	const token: TimelineToken = {
+		key: options.key,
+		type: `timeline`,
+	}
+	store.subject.timelineCreation.next(token)
+	return token
 }

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

@@ -1,12 +1,12 @@
 import type { Store } from ".."
 
 export const abortTransaction = (store: Store): void => {
-  if (store.transactionStatus.phase === `idle`) {
-    store.config.logger?.warn(
-      `abortTransaction called outside of a transaction. This is probably a bug.`
-    )
-    return
-  }
-  store.transactionStatus = { phase: `idle` }
-  store.config.logger?.info(`🪂`, `transaction fail`)
+	if (store.transactionStatus.phase === `idle`) {
+		store.config.logger?.warn(
+			`abortTransaction called outside of a transaction. This is probably a bug.`,
+		)
+		return
+	}
+	store.transactionStatus = { phase: `idle` }
+	store.config.logger?.info(`🪂`, `transaction fail`)
 }

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

@@ -8,47 +8,47 @@ import type { AtomToken } from "../.."
 import { setState } from "../.."
 
 export const applyTransaction = <ƒ extends ƒn>(
-  output: ReturnType<ƒ>,
-  store: Store
+	output: ReturnType<ƒ>,
+	store: Store,
 ): void => {
-  if (store.transactionStatus.phase !== `building`) {
-    store.config.logger?.warn(
-      `abortTransaction called outside of a transaction. This is probably a bug.`
-    )
-    return
-  }
-  store.config.logger?.info(
-    `🛃 apply transaction "${store.transactionStatus.key}"`
-  )
-  store.transactionStatus.phase = `applying`
-  store.transactionStatus.output = output
-  const { atomUpdates } = store.transactionStatus
+	if (store.transactionStatus.phase !== `building`) {
+		store.config.logger?.warn(
+			`abortTransaction called outside of a transaction. This is probably a bug.`,
+		)
+		return
+	}
+	store.config.logger?.info(
+		`🛃 apply transaction "${store.transactionStatus.key}"`,
+	)
+	store.transactionStatus.phase = `applying`
+	store.transactionStatus.output = output
+	const { atomUpdates } = store.transactionStatus
 
-  for (const { key, newValue } of atomUpdates) {
-    const token: AtomToken<unknown> = { key, type: `atom` }
-    if (!HAMT.has(token.key, store.valueMap)) {
-      const newAtom = HAMT.get(token.key, store.transactionStatus.core.atoms)
-      store.atoms = HAMT.set(newAtom.key, newAtom, store.atoms)
-      store.valueMap = HAMT.set(newAtom.key, newAtom.default, store.valueMap)
-      store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
-    }
-    setState(token, newValue, store)
-  }
-  const myTransaction = withdraw<ƒ>(
-    { key: store.transactionStatus.key, type: `transaction` },
-    store
-  )
-  if (myTransaction === null) {
-    throw new Error(
-      `Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`
-    )
-  }
-  myTransaction.subject.next({
-    key: store.transactionStatus.key,
-    atomUpdates,
-    output,
-    params: store.transactionStatus.params as Parameters<ƒ>,
-  })
-  store.transactionStatus = { phase: `idle` }
-  store.config.logger?.info(`🛬`, `transaction done`)
+	for (const { key, newValue } of atomUpdates) {
+		const token: AtomToken<unknown> = { key, type: `atom` }
+		if (!HAMT.has(token.key, store.valueMap)) {
+			const newAtom = HAMT.get(token.key, store.transactionStatus.core.atoms)
+			store.atoms = HAMT.set(newAtom.key, newAtom, store.atoms)
+			store.valueMap = HAMT.set(newAtom.key, newAtom.default, store.valueMap)
+			store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
+		}
+		setState(token, newValue, store)
+	}
+	const myTransaction = withdraw<ƒ>(
+		{ key: store.transactionStatus.key, type: `transaction` },
+		store,
+	)
+	if (myTransaction === null) {
+		throw new Error(
+			`Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`,
+		)
+	}
+	myTransaction.subject.next({
+		key: store.transactionStatus.key,
+		atomUpdates,
+		output,
+		params: store.transactionStatus.params as Parameters<ƒ>,
+	})
+	store.transactionStatus = { phase: `idle` }
+	store.config.logger?.info(`🛬`, `transaction done`)
 }

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

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

package/src/internal/transaction/index.ts

@@ -10,16 +10,16 @@ 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 TransactionPhase = typeof TRANSACTION_PHASES[number]
 
 export type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
-  phase: `applying` | `building`
-  time: number
-  core: StoreCore
+	phase: `applying` | `building`
+	time: number
+	core: StoreCore
 }
 export type TransactionIdle = {
-  phase: `idle`
+	phase: `idle`
 }
 export type TransactionStatus<ƒ extends ƒn> =
-  | TransactionIdle
-  | TransactionUpdateInProgress<ƒ>
+	| TransactionIdle
+	| TransactionUpdateInProgress<ƒ>

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

@@ -6,18 +6,18 @@ import type { AtomToken, TransactionUpdate } from "../.."
 import { setState } from "../.."
 
 export const redoTransactionUpdate = <ƒ extends ƒn>(
-  update: TransactionUpdate<ƒ>,
-  store: Store
+	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)
-  }
+	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

@@ -6,18 +6,18 @@ import type { AtomToken, TransactionUpdate } from "../.."
 import { setState } from "../.."
 
 export const undoTransactionUpdate = <ƒ extends ƒn>(
-  update: TransactionUpdate<ƒ>,
-  store: Store
+	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)
-  }
+	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,67 +1,67 @@
 import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
 
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store, StoreCore } from "."
 import {
-  abortTransaction,
-  applyTransaction,
-  buildTransaction,
-  deposit,
-  IMPLICIT,
+	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: Rx.Subject<TransactionUpdate<ƒ>>
-  run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
+	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
+	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 Rx.Subject(),
-  }
-  const core = target(store)
-  core.transactions = HAMT.set(
-    newTransaction.key,
-    newTransaction,
-    core.transactions
-  )
-  const token = deposit(newTransaction)
-  store.subject.transactionCreation.next(token)
-  return token
+	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 = HAMT.set(
+		newTransaction.key,
+		newTransaction,
+		core.transactions,
+	)
+	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
+	store.transactionStatus.phase === `building`
+		? store.transactionStatus.core
+		: store

package/src/json/select-json.ts

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