atom.io 0.6.1 → 0.6.3

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

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

@@ -4,132 +4,132 @@ import type { Store } from "../store"
 import { IMPLICIT } from "../store"
 
 export type StateTokenIndex<
-  Token extends
-    | AtomToken<unknown>
-    | ReadonlySelectorToken<unknown>
-    | SelectorToken<unknown>,
+	Token extends
+		| AtomToken<unknown>
+		| ReadonlySelectorToken<unknown>
+		| SelectorToken<unknown>,
 > = Record<
-  string,
-  | Token
-  | {
-      key: string
-      familyMembers: Record<string, Token>
-    }
+	string,
+	| Token
+	| {
+			key: string
+			familyMembers: Record<string, Token>
+	  }
 >
 
 export type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>
 export type SelectorTokenIndex = StateTokenIndex<
-  ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+	ReadonlySelectorToken<unknown> | SelectorToken<unknown>
 >
 
 export const attachMetaAtoms = (
-  store: Store = IMPLICIT.STORE
+	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorToken<AtomTokenIndex> => {
-  const atomTokenIndexState__INTERNAL = atom<AtomTokenIndex>({
-    key: `👁‍🗨_atom_token_index__INTERNAL`,
-    default: () =>
-      [...store.atoms].reduce<AtomTokenIndex>((acc, [key]) => {
-        acc[key] = { key, type: `atom` }
-        return acc
-      }, {}),
-    effects: [
-      ({ setSelf }) => {
-        store.subject.atomCreation.subscribe((atomToken) => {
-          if (store.operation.open) {
-            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,
-            }
-          })
-        })
-      },
-    ],
-  })
-  return selector({
-    key: `👁‍🗨_atom_token_index`,
-    get: ({ get }) => get(atomTokenIndexState__INTERNAL),
-  })
+	const atomTokenIndexState__INTERNAL = atom<AtomTokenIndex>({
+		key: `👁‍🗨_atom_token_index__INTERNAL`,
+		default: () =>
+			[...store.atoms].reduce<AtomTokenIndex>((acc, [key]) => {
+				acc[key] = { key, type: `atom` }
+				return acc
+			}, {}),
+		effects: [
+			({ setSelf }) => {
+				store.subject.atomCreation.subscribe((atomToken) => {
+					if (store.operation.open) {
+						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,
+						}
+					})
+				})
+			},
+		],
+	})
+	return selector({
+		key: `👁‍🗨_atom_token_index`,
+		get: ({ get }) => get(atomTokenIndexState__INTERNAL),
+	})
 }
 
 export const attachMetaSelectors = (
-  store: Store = IMPLICIT.STORE
+	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorToken<SelectorTokenIndex> => {
-  const readonlySelectorTokenIndexState__INTERNAL = atom<SelectorTokenIndex>({
-    key: `👁‍🗨_selector_token_index__INTERNAL`,
-    default: () =>
-      Object.assign(
-        [...store.readonlySelectors].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
-          }
-          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,
-            }
-          })
-        })
-      },
-    ],
-  })
-  return selector({
-    key: `👁‍🗨_selector_token_index`,
-    get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
-  })
+	const readonlySelectorTokenIndexState__INTERNAL = atom<SelectorTokenIndex>({
+		key: `👁‍🗨_selector_token_index__INTERNAL`,
+		default: () =>
+			Object.assign(
+				[...store.readonlySelectors].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
+					}
+					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,
+						}
+					})
+				})
+			},
+		],
+	})
+	return selector({
+		key: `👁‍🗨_selector_token_index`,
+		get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
+	})
 }