atom.io 0.6.2 → 0.6.4

package/src/atom.ts

@@ -1,43 +1,42 @@
-import type * as Rx from "rxjs"
-
 import type { Serializable } from "~/packages/anvl/src/json"
 
 import type { AtomToken } from "."
+import type { Subject } from "./internal"
 import { atomFamily__INTERNAL, atom__INTERNAL } from "./internal"
 
 export type Effectors<T> = {
-  setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void
-  onSet: (callback: (options: { newValue: T; oldValue: T }) => void) => void
+	setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void
+	onSet: (callback: (options: { newValue: T; oldValue: T }) => void) => void
 }
 
 export type AtomEffect<T> = (tools: Effectors<T>) => void
 
 export type AtomOptions<T> = {
-  key: string
-  default: T | (() => T)
-  effects?: AtomEffect<T>[]
+	key: string
+	default: T | (() => T)
+	effects?: AtomEffect<T>[]
 }
 
 export function atom<T>(options: AtomOptions<T>): AtomToken<T> {
-  return atom__INTERNAL<T>(options)
+	return atom__INTERNAL<T>(options)
 }
 
 export type AtomFamilyOptions<T, K extends Serializable> = {
-  key: string
-  default: T | ((key: K) => T)
-  effects?: (key: K) => AtomEffect<T>[]
+	key: string
+	default: T | ((key: K) => T)
+	effects?: (key: K) => AtomEffect<T>[]
 }
 
 export type AtomFamily<T, K extends Serializable = Serializable> = ((
-  key: K
+	key: K,
 ) => AtomToken<T>) & {
-  key: string
-  type: `atom_family`
-  subject: Rx.Subject<AtomToken<T>>
+	key: string
+	type: `atom_family`
+	subject: Subject<AtomToken<T>>
 }
 
 export function atomFamily<T, K extends Serializable>(
-  options: AtomFamilyOptions<T, K>
+	options: AtomFamilyOptions<T, K>,
 ): AtomFamily<T, K> {
-  return atomFamily__INTERNAL<T, K>(options)
+	return atomFamily__INTERNAL<T, K>(options)
 }

package/src/index.ts

@@ -1,14 +1,14 @@
 import { capitalize } from "~/packages/anvl/src/string/capitalize"
 
 import {
-  IMPLICIT,
-  closeOperation,
-  openOperation,
-  getState__INTERNAL,
-  setState__INTERNAL,
-  isAtomDefault,
-  isSelectorDefault,
-  withdraw,
+	IMPLICIT,
+	closeOperation,
+	openOperation,
+	getState__INTERNAL,
+	setState__INTERNAL,
+	isAtomDefault,
+	isSelectorDefault,
+	withdraw,
 } from "./internal"
 import * as __INTERNAL__ from "./internal"
 import type { Store } from "./internal/store"
@@ -25,75 +25,75 @@ export type { Store } from "./internal/store"
 export type { Serializable } from "~/packages/anvl/src/json"
 
 export type AtomToken<_> = {
-  key: string
-  type: `atom`
-  family?: FamilyMetadata
-  __brand?: _
+	key: string
+	type: `atom`
+	family?: FamilyMetadata
+	__brand?: _
 }
 export type SelectorToken<_> = {
-  key: string
-  type: `selector`
-  family?: FamilyMetadata
-  __brand?: _
+	key: string
+	type: `selector`
+	family?: FamilyMetadata
+	__brand?: _
 }
 export type StateToken<T> = AtomToken<T> | SelectorToken<T>
 
 export type ReadonlySelectorToken<_> = {
-  key: string
-  type: `readonly_selector`
-  family?: FamilyMetadata
-  __brand?: _
+	key: string
+	type: `readonly_selector`
+	family?: FamilyMetadata
+	__brand?: _
 }
 
 export type FamilyMetadata = {
-  key: string
-  subKey: string
+	key: string
+	subKey: string
 }
 
 export const getState = <T>(
-  token: ReadonlySelectorToken<T> | StateToken<T>,
-  store: Store = IMPLICIT.STORE
+	token: ReadonlySelectorToken<T> | StateToken<T>,
+	store: Store = IMPLICIT.STORE,
 ): T => {
-  const state = withdraw<T>(token, store)
-  if (state === null) {
-    throw new Error(
-      `${capitalize(token.type)} "${token.key}" not found in store "${
-        store.config.name
-      }".`
-    )
-  }
-  return getState__INTERNAL(state, store)
+	const state = withdraw<T>(token, store)
+	if (state === null) {
+		throw new Error(
+			`${capitalize(token.type)} "${token.key}" not found in store "${
+				store.config.name
+			}".`,
+		)
+	}
+	return getState__INTERNAL(state, store)
 }
 
 export const setState = <T, New extends T>(
-  token: StateToken<T>,
-  value: New | ((oldValue: T) => New),
-  store: Store = IMPLICIT.STORE
+	token: StateToken<T>,
+	value: New | ((oldValue: T) => New),
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  try {
-    openOperation(token, store)
-  } catch (thrown) {
-    if (!(typeof thrown === `symbol`)) {
-      throw thrown
-    }
-    return
-  }
-  const state = withdraw(token, store)
-  if (state === null) {
-    throw new Error(
-      `${capitalize(token.type)} "${token.key}" not found in store "${
-        store.config.name
-      }".`
-    )
-  }
-  setState__INTERNAL(state, value, store)
-  closeOperation(store)
+	try {
+		openOperation(token, store)
+	} catch (thrown) {
+		if (!(typeof thrown === `symbol`)) {
+			throw thrown
+		}
+		return
+	}
+	const state = withdraw(token, store)
+	if (state === null) {
+		throw new Error(
+			`${capitalize(token.type)} "${token.key}" not found in store "${
+				store.config.name
+			}".`,
+		)
+	}
+	setState__INTERNAL(state, value, store)
+	closeOperation(store)
 }
 
 export const isDefault = (
-  token: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-  store: Store = IMPLICIT.STORE
+	token: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	store: Store = IMPLICIT.STORE,
 ): boolean =>
-  token.type === `atom`
-    ? isAtomDefault(token.key, store)
-    : isSelectorDefault(token.key, store)
+	token.type === `atom`
+		? isAtomDefault(token.key, store)
+		: isSelectorDefault(token.key, store)

package/src/internal/atom-internal.ts

@@ -1,6 +1,6 @@
 import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
 
+import { Subject } from "."
 import { deposit } from "./get"
 import { markAtomAsDefault } from "./is-default"
 import { cacheValue, hasKeyBeenUsed } from "./operation"
@@ -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: 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 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

@@ -1,142 +1,141 @@
-import * as Rx from "rxjs"
-
 import type { Serializable } from "~/packages/anvl/src/json"
 import { stringifyJson } from "~/packages/anvl/src/json"
 
 import type { Store } from "."
 import {
-  atom__INTERNAL,
-  withdraw,
-  selector__INTERNAL,
-  target,
-  deposit,
-  IMPLICIT,
+	Subject,
+	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 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 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 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>
 }