atom.io 0.6.2 → 0.6.3

package/src/internal/atom-internal.ts

@@ -12,44 +12,44 @@ import { setState, subscribe } from ".."
 import type { AtomOptions } from "../atom"
 
 export type Atom<T> = {
-  key: string
-  type: `atom`
-  family?: FamilyMetadata
-  subject: Rx.Subject<{ newValue: T; oldValue: T }>
-  default: T
+	key: string
+	type: `atom`
+	family?: FamilyMetadata
+	subject: Rx.Subject<{ newValue: T; oldValue: T }>
+	default: T
 }
 
 export function atom__INTERNAL<T>(
-  options: AtomOptions<T>,
-  family?: FamilyMetadata,
-  store: Store = IMPLICIT.STORE
+	options: AtomOptions<T>,
+	family?: FamilyMetadata,
+	store: Store = IMPLICIT.STORE,
 ): AtomToken<T> {
-  const core = target(store)
-  if (hasKeyBeenUsed(options.key, store)) {
-    store.config.logger?.error?.(
-      `Key "${options.key}" already exists in the store.`
-    )
-    return deposit(core.atoms.get(options.key))
-  }
-  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
-  const newAtom = {
-    ...options,
-    subject,
-    type: `atom`,
-    ...(family && { family }),
-  } as const
-  const initialValue =
-    options.default instanceof Function ? options.default() : options.default
-  core.atoms = HAMT.set(newAtom.key, newAtom, core.atoms)
-  markAtomAsDefault(options.key, store)
-  cacheValue(options.key, initialValue, store)
-  const token = deposit(newAtom)
-  options.effects?.forEach((effect) =>
-    effect({
-      setSelf: (next) => setState(token, next, store),
-      onSet: (handle: UpdateHandler<T>) => subscribe(token, handle, store),
-    })
-  )
-  store.subject.atomCreation.next(token)
-  return token as AtomToken<T>
+	const core = target(store)
+	if (hasKeyBeenUsed(options.key, store)) {
+		store.config.logger?.error?.(
+			`Key "${options.key}" already exists in the store.`,
+		)
+		return deposit(core.atoms.get(options.key))
+	}
+	const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
+	const newAtom = {
+		...options,
+		subject,
+		type: `atom`,
+		...(family && { family }),
+	} as const
+	const initialValue =
+		options.default instanceof Function ? options.default() : options.default
+	core.atoms = HAMT.set(newAtom.key, newAtom, core.atoms)
+	markAtomAsDefault(options.key, store)
+	cacheValue(options.key, initialValue, store)
+	const token = deposit(newAtom)
+	options.effects?.forEach((effect) =>
+		effect({
+			setSelf: (next) => setState(token, next, store),
+			onSet: (handle: UpdateHandler<T>) => subscribe(token, handle, store),
+		}),
+	)
+	store.subject.atomCreation.next(token)
+	return token as AtomToken<T>
 }

package/src/internal/families-internal.ts

@@ -5,138 +5,138 @@ import { stringifyJson } from "~/packages/anvl/src/json"
 
 import type { Store } from "."
 import {
-  atom__INTERNAL,
-  withdraw,
-  selector__INTERNAL,
-  target,
-  deposit,
-  IMPLICIT,
+	atom__INTERNAL,
+	withdraw,
+	selector__INTERNAL,
+	target,
+	deposit,
+	IMPLICIT,
 } from "."
 import type {
-  AtomFamily,
-  AtomFamilyOptions,
-  AtomToken,
-  FamilyMetadata,
-  ReadonlySelectorFamily,
-  ReadonlySelectorFamilyOptions,
-  ReadonlySelectorToken,
-  SelectorFamily,
-  SelectorFamilyOptions,
-  SelectorToken,
+	AtomFamily,
+	AtomFamilyOptions,
+	AtomToken,
+	FamilyMetadata,
+	ReadonlySelectorFamily,
+	ReadonlySelectorFamilyOptions,
+	ReadonlySelectorToken,
+	SelectorFamily,
+	SelectorFamilyOptions,
+	SelectorToken,
 } from ".."
 
 export function atomFamily__INTERNAL<T, K extends Serializable>(
-  options: AtomFamilyOptions<T, K>,
-  store: Store = IMPLICIT.STORE
+	options: AtomFamilyOptions<T, K>,
+	store: Store = IMPLICIT.STORE,
 ): AtomFamily<T, K> {
-  const subject = new Rx.Subject<AtomToken<T>>()
-  return Object.assign(
-    (key: K): AtomToken<T> => {
-      const subKey = stringifyJson(key)
-      const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}(${subKey})`
-      const existing = withdraw({ key: fullKey, type: `atom` }, store)
-      const token: AtomToken<any> = existing
-        ? deposit(existing)
-        : atom__INTERNAL<T>(
-            {
-              key: fullKey,
-              default:
-                options.default instanceof Function
-                  ? options.default(key)
-                  : options.default,
-              effects: options.effects?.(key),
-            },
-            family,
-            store
-          )
-      subject.next(token)
-      return token
-    },
-    {
-      key: options.key,
-      type: `atom_family`,
-      subject,
-    } as const
-  )
+	const subject = new Rx.Subject<AtomToken<T>>()
+	return Object.assign(
+		(key: K): AtomToken<T> => {
+			const subKey = stringifyJson(key)
+			const family: FamilyMetadata = { key: options.key, subKey }
+			const fullKey = `${options.key}(${subKey})`
+			const existing = withdraw({ key: fullKey, type: `atom` }, store)
+			const token: AtomToken<any> = existing
+				? deposit(existing)
+				: atom__INTERNAL<T>(
+						{
+							key: fullKey,
+							default:
+								options.default instanceof Function
+									? options.default(key)
+									: options.default,
+							effects: options.effects?.(key),
+						},
+						family,
+						store,
+				  )
+			subject.next(token)
+			return token
+		},
+		{
+			key: options.key,
+			type: `atom_family`,
+			subject,
+		} as const,
+	)
 }
 
 export function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K>,
-  store?: Store
+	options: ReadonlySelectorFamilyOptions<T, K>,
+	store?: Store,
 ): ReadonlySelectorFamily<T, K> {
-  const core = target(store)
-  const subject = new Rx.Subject<ReadonlySelectorToken<T>>()
-  return Object.assign(
-    (key: K): ReadonlySelectorToken<T> => {
-      const subKey = stringifyJson(key)
-      const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}(${subKey})`
-      const existing = core.readonlySelectors.get(fullKey)
-      if (existing) {
-        return deposit(existing)
-      }
-      return selector__INTERNAL<T>(
-        {
-          key: fullKey,
-          get: options.get(key),
-        },
-        family,
-        store
-      ) as ReadonlySelectorToken<T>
-    },
-    {
-      key: options.key,
-      type: `readonly_selector_family`,
-      subject,
-    } as const
-  ) as ReadonlySelectorFamily<T, K>
+	const core = target(store)
+	const subject = new Rx.Subject<ReadonlySelectorToken<T>>()
+	return Object.assign(
+		(key: K): ReadonlySelectorToken<T> => {
+			const subKey = stringifyJson(key)
+			const family: FamilyMetadata = { key: options.key, subKey }
+			const fullKey = `${options.key}(${subKey})`
+			const existing = core.readonlySelectors.get(fullKey)
+			if (existing) {
+				return deposit(existing)
+			}
+			return selector__INTERNAL<T>(
+				{
+					key: fullKey,
+					get: options.get(key),
+				},
+				family,
+				store,
+			) as ReadonlySelectorToken<T>
+		},
+		{
+			key: options.key,
+			type: `readonly_selector_family`,
+			subject,
+		} as const,
+	) as ReadonlySelectorFamily<T, K>
 }
 
 export function selectorFamily__INTERNAL<T, K extends Serializable>(
-  options: SelectorFamilyOptions<T, K>,
-  store?: Store
+	options: SelectorFamilyOptions<T, K>,
+	store?: Store,
 ): SelectorFamily<T, K>
 export function selectorFamily__INTERNAL<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K>,
-  store?: Store
+	options: ReadonlySelectorFamilyOptions<T, K>,
+	store?: Store,
 ): ReadonlySelectorFamily<T, K>
 export function selectorFamily__INTERNAL<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
-  store: Store = IMPLICIT.STORE
+	options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
+	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
-  const isReadonly = !(`set` in options)
+	const isReadonly = !(`set` in options)
 
-  if (isReadonly) {
-    return readonlySelectorFamily__INTERNAL(options, store)
-  }
-  const core = target(store)
-  const subject = new Rx.Subject<SelectorToken<T>>()
+	if (isReadonly) {
+		return readonlySelectorFamily__INTERNAL(options, store)
+	}
+	const core = target(store)
+	const subject = new Rx.Subject<SelectorToken<T>>()
 
-  return Object.assign(
-    (key: K): SelectorToken<T> => {
-      const subKey = stringifyJson(key)
-      const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}(${subKey})`
-      const existing = core.selectors.get(fullKey)
-      if (existing) {
-        return deposit(existing)
-      }
-      const token = selector__INTERNAL<T>(
-        {
-          key: fullKey,
-          get: options.get(key),
-          set: options.set(key),
-        },
-        family,
-        store
-      )
-      subject.next(token)
-      return token
-    },
-    {
-      key: options.key,
-      type: `selector_family`,
-    } as const
-  ) as SelectorFamily<T, K>
+	return Object.assign(
+		(key: K): SelectorToken<T> => {
+			const subKey = stringifyJson(key)
+			const family: FamilyMetadata = { key: options.key, subKey }
+			const fullKey = `${options.key}(${subKey})`
+			const existing = core.selectors.get(fullKey)
+			if (existing) {
+				return deposit(existing)
+			}
+			const token = selector__INTERNAL<T>(
+				{
+					key: fullKey,
+					get: options.get(key),
+					set: options.set(key),
+				},
+				family,
+				store,
+			)
+			subject.next(token)
+			return token
+		},
+		{
+			key: options.key,
+			type: `selector_family`,
+		} as const,
+	) as SelectorFamily<T, K>
 }

package/src/internal/get.ts

@@ -3,85 +3,85 @@ import HAMT from "hamt_plus"
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type {
-  Atom,
-  ReadonlySelector,
-  Selector,
-  Store,
-  Timeline,
-  Transaction,
+	Atom,
+	ReadonlySelector,
+	Selector,
+	Store,
+	Timeline,
+	Transaction,
 } from "."
 import { target, isValueCached, readCachedValue, IMPLICIT } from "."
 import type {
-  AtomToken,
-  ReadonlySelectorToken,
-  SelectorToken,
-  StateToken,
-  TimelineToken,
-  TransactionToken,
+	AtomToken,
+	ReadonlySelectorToken,
+	SelectorToken,
+	StateToken,
+	TimelineToken,
+	TransactionToken,
 } from ".."
 
 export const computeSelectorState = <T>(
-  selector: ReadonlySelector<T> | Selector<T>
+	selector: ReadonlySelector<T> | Selector<T>,
 ): T => selector.get()
 
 export function lookup(
-  key: string,
-  store: Store
+	key: string,
+	store: Store,
 ): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown> {
-  const core = target(store)
-  const type = HAMT.has(key, core.atoms)
-    ? `atom`
-    : HAMT.has(key, core.selectors)
-    ? `selector`
-    : `readonly_selector`
-  return { key, type } as any
+	const core = target(store)
+	const type = HAMT.has(key, core.atoms)
+		? `atom`
+		: HAMT.has(key, core.selectors)
+		? `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
+	token: SelectorToken<T>,
+	store: Store,
 ): Selector<T> | null
 export function withdraw<T>(
-  token: StateToken<T>,
-  store: Store
+	token: StateToken<T>,
+	store: Store,
 ): Atom<T> | Selector<T> | null
 export function withdraw<T>(
-  token: ReadonlySelectorToken<T>,
-  store: Store
+	token: ReadonlySelectorToken<T>,
+	store: Store,
 ): ReadonlySelector<T> | null
 export function withdraw<T>(
-  token: TransactionToken<T>,
-  store: Store
+	token: TransactionToken<T>,
+	store: Store,
 ): Transaction<T extends ƒn ? T : never> | null
 export function withdraw<T>(
-  token: ReadonlySelectorToken<T> | StateToken<T>,
-  store: Store
+	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
+	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 (
-    HAMT.get(token.key, core.atoms) ??
-    HAMT.get(token.key, core.selectors) ??
-    HAMT.get(token.key, core.readonlySelectors) ??
-    HAMT.get(token.key, core.transactions) ??
-    HAMT.get(token.key, core.timelines) ??
-    null
-  )
+	| Atom<T>
+	| ReadonlySelector<T>
+	| Selector<T>
+	| Timeline
+	| Transaction<T extends ƒn ? T : never>
+	| null {
+	const core = target(store)
+	return (
+		HAMT.get(token.key, core.atoms) ??
+		HAMT.get(token.key, core.selectors) ??
+		HAMT.get(token.key, core.readonlySelectors) ??
+		HAMT.get(token.key, core.transactions) ??
+		HAMT.get(token.key, core.timelines) ??
+		null
+	)
 }
 
 export function deposit<T>(state: Atom<T>): AtomToken<T>
@@ -89,43 +89,43 @@ 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>
+	state: Transaction<T extends ƒn ? T : never>,
 ): TransactionToken<T>
 export function deposit<T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<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>
+	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
+	| 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
+	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
+	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/is-default.ts

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

package/src/internal/meta/attach-meta.ts

@@ -5,13 +5,13 @@ import type { Store } from "../store"
 import { IMPLICIT } from "../store"
 
 export const attachMetaState = (
-  store: Store = IMPLICIT.STORE
+	store: Store = IMPLICIT.STORE,
 ): {
-  atomTokenIndexState: ReadonlySelectorToken<AtomTokenIndex>
-  selectorTokenIndexState: ReadonlySelectorToken<SelectorTokenIndex>
+	atomTokenIndexState: ReadonlySelectorToken<AtomTokenIndex>
+	selectorTokenIndexState: ReadonlySelectorToken<SelectorTokenIndex>
 } => {
-  return {
-    atomTokenIndexState: attachMetaAtoms(store),
-    selectorTokenIndexState: attachMetaSelectors(store),
-  }
+	return {
+		atomTokenIndexState: attachMetaAtoms(store),
+		selectorTokenIndexState: attachMetaSelectors(store),
+	}
 }