atom.io 0.6.2 → 0.6.3

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

package/src/internal/operation.ts

@@ -8,138 +8,138 @@ import { IMPLICIT } from "./store"
 import type { StateToken } from ".."
 
 export type OperationProgress =
-  | {
-      open: false
-    }
-  | {
-      open: true
-      done: Set<string>
-      prev: Hamt<any, string>
-      time: number
-      token: StateToken<any>
-    }
+	| {
+			open: false
+	  }
+	| {
+			open: true
+			done: Set<string>
+			prev: Hamt<any, string>
+			time: number
+			token: StateToken<any>
+	  }
 
 export const openOperation = (token: StateToken<any>, store: Store): void => {
-  const core = target(store)
-  if (core.operation.open) {
-    store.config.logger?.error(
-      `❌ failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`
-    )
-    throw Symbol(`violation`)
-  }
-  core.operation = {
-    open: true,
-    done: new Set(),
-    prev: store.valueMap,
-    time: Date.now(),
-    token,
-  }
-  store.config.logger?.info(
-    `⭕ operation start from "${token.key}" in store "${store.config.name}"`
-  )
+	const core = target(store)
+	if (core.operation.open) {
+		store.config.logger?.error(
+			`❌ failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`,
+		)
+		throw Symbol(`violation`)
+	}
+	core.operation = {
+		open: true,
+		done: new Set(),
+		prev: store.valueMap,
+		time: Date.now(),
+		token,
+	}
+	store.config.logger?.info(
+		`⭕ operation start from "${token.key}" in store "${store.config.name}"`,
+	)
 }
 export const closeOperation = (store: Store): void => {
-  const core = target(store)
-  core.operation = { open: false }
-  store.config.logger?.info(`🔴 operation done`)
+	const core = target(store)
+	core.operation = { open: false }
+	store.config.logger?.info(`🔴 operation done`)
 }
 
 export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
-  const core = target(store)
-  if (!core.operation.open) {
-    store.config.logger?.warn(
-      `isDone called outside of an operation. This is probably a bug.`
-    )
-    return true
-  }
-  return core.operation.done.has(key)
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`isDone called outside of an operation. This is probably a bug.`,
+		)
+		return true
+	}
+	return core.operation.done.has(key)
 }
 export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
-  const core = target(store)
-  if (!core.operation.open) {
-    store.config.logger?.warn(
-      `markDone called outside of an operation. This is probably a bug.`
-    )
-    return
-  }
-  core.operation.done.add(key)
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`markDone called outside of an operation. This is probably a bug.`,
+		)
+		return
+	}
+	core.operation.done.add(key)
 }
 export const recallState = <T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-  store: Store = IMPLICIT.STORE
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	store: Store = IMPLICIT.STORE,
 ): T => {
-  const core = target(store)
-  if (!core.operation.open) {
-    store.config.logger?.warn(
-      `recall called outside of an operation. This is probably a bug.`
-    )
-    return HAMT.get(state.key, core.valueMap)
-  }
-  return HAMT.get(state.key, core.operation.prev)
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`recall called outside of an operation. This is probably a bug.`,
+		)
+		return HAMT.get(state.key, core.valueMap)
+	}
+	return HAMT.get(state.key, core.operation.prev)
 }
 
 export const cacheValue = (
-  key: string,
-  value: unknown,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	value: unknown,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.valueMap = HAMT.set(key, value, core.valueMap)
+	const core = target(store)
+	core.valueMap = HAMT.set(key, value, core.valueMap)
 }
 
 export const evictCachedValue = (
-  key: string,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.valueMap = HAMT.remove(key, core.valueMap)
+	const core = target(store)
+	core.valueMap = HAMT.remove(key, core.valueMap)
 }
 export const readCachedValue = <T>(
-  key: string,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	store: Store = IMPLICIT.STORE,
 ): T => HAMT.get(key, target(store).valueMap)
 
 export const isValueCached = (
-  key: string,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	store: Store = IMPLICIT.STORE,
 ): boolean => HAMT.has(key, target(store).valueMap)
 
 export const storeAtom = (
-  atom: Atom<any>,
-  store: Store = IMPLICIT.STORE
+	atom: Atom<any>,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.atoms = HAMT.set(atom.key, atom, core.atoms)
+	const core = target(store)
+	core.atoms = HAMT.set(atom.key, atom, core.atoms)
 }
 
 export const storeSelector = (
-  selector: Selector<any>,
-  store: Store = IMPLICIT.STORE
+	selector: Selector<any>,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.selectors = HAMT.set(selector.key, selector, core.selectors)
+	const core = target(store)
+	core.selectors = HAMT.set(selector.key, selector, core.selectors)
 }
 
 export const storeReadonlySelector = (
-  selector: ReadonlySelector<any>,
-  store: Store = IMPLICIT.STORE
+	selector: ReadonlySelector<any>,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.readonlySelectors = HAMT.set(
-    selector.key,
-    selector,
-    core.readonlySelectors
-  )
+	const core = target(store)
+	core.readonlySelectors = HAMT.set(
+		selector.key,
+		selector,
+		core.readonlySelectors,
+	)
 }
 
 export const hasKeyBeenUsed = (
-  key: string,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	store: Store = IMPLICIT.STORE,
 ): boolean => {
-  const core = target(store)
-  return (
-    HAMT.has(key, core.atoms) ||
-    HAMT.has(key, core.selectors) ||
-    HAMT.has(key, core.readonlySelectors)
-  )
+	const core = target(store)
+	return (
+		HAMT.has(key, core.atoms) ||
+		HAMT.has(key, core.selectors) ||
+		HAMT.has(key, core.readonlySelectors)
+	)
 }

package/src/internal/selector/create-read-write-selector.ts

@@ -4,59 +4,59 @@ import * as Rx from "rxjs"
 import { become } from "~/packages/anvl/src/function"
 
 import {
-  type Store,
-  type Selector,
-  type StoreCore,
-  registerSelector,
-  selector__INTERNAL,
+	type Store,
+	type Selector,
+	type StoreCore,
+	registerSelector,
+	selector__INTERNAL,
 } from ".."
 import type { FamilyMetadata, SelectorToken } from "../.."
 import type { SelectorOptions } from "../../selector"
 import { cacheValue, markDone } from "../operation"
 
 export const createReadWriteSelector = <T>(
-  options: SelectorOptions<T>,
-  family: FamilyMetadata | undefined,
-  store: Store,
-  core: StoreCore
+	options: SelectorOptions<T>,
+	family: FamilyMetadata | undefined,
+	store: Store,
+	core: StoreCore,
 ): SelectorToken<T> => {
-  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
+	const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
 
-  const { get, set } = registerSelector(options.key, store)
-  const getSelf = () => {
-    const value = options.get({ get })
-    cacheValue(options.key, value, store)
-    return value
-  }
+	const { get, set } = registerSelector(options.key, store)
+	const getSelf = () => {
+		const value = options.get({ get })
+		cacheValue(options.key, value, store)
+		return value
+	}
 
-  const setSelf = (next: T | ((oldValue: T) => T)): void => {
-    store.config.logger?.info(`   <- "${options.key}" became`, next)
-    const oldValue = getSelf()
-    const newValue = become(next)(oldValue)
-    cacheValue(options.key, newValue, store)
-    markDone(options.key, store)
-    if (store.transactionStatus.phase === `idle`) {
-      subject.next({ newValue, oldValue })
-    }
-    options.set({ get, set }, newValue)
-  }
-  const mySelector: Selector<T> = {
-    ...options,
-    subject,
-    install: (s: Store) => selector__INTERNAL(options, family, s),
-    get: getSelf,
-    set: setSelf,
-    type: `selector`,
-    ...(family && { family }),
-  }
-  core.selectors = HAMT.set(options.key, mySelector, core.selectors)
-  const initialValue = getSelf()
-  store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-  const token: SelectorToken<T> = {
-    key: options.key,
-    type: `selector`,
-    family,
-  }
-  store.subject.selectorCreation.next(token)
-  return token
+	const setSelf = (next: T | ((oldValue: T) => T)): void => {
+		store.config.logger?.info(`   <- "${options.key}" became`, next)
+		const oldValue = getSelf()
+		const newValue = become(next)(oldValue)
+		cacheValue(options.key, newValue, store)
+		markDone(options.key, store)
+		if (store.transactionStatus.phase === `idle`) {
+			subject.next({ newValue, oldValue })
+		}
+		options.set({ get, set }, newValue)
+	}
+	const mySelector: Selector<T> = {
+		...options,
+		subject,
+		install: (s: Store) => selector__INTERNAL(options, family, s),
+		get: getSelf,
+		set: setSelf,
+		type: `selector`,
+		...(family && { family }),
+	}
+	core.selectors = HAMT.set(options.key, mySelector, core.selectors)
+	const initialValue = getSelf()
+	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
+	const token: SelectorToken<T> = {
+		key: options.key,
+		type: `selector`,
+		family,
+	}
+	store.subject.selectorCreation.next(token)
+	return token
 }