atom.io 0.6.2 → 0.6.4

package/src/internal/selector/update-selector-atoms.ts

@@ -4,30 +4,30 @@ import { target } from ".."
 import type { ReadonlySelectorToken, StateToken } from "../.."
 
 export const updateSelectorAtoms = (
-  selectorKey: string,
-  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-  store: Store
+	selectorKey: string,
+	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	store: Store,
 ): void => {
-  const core = target(store)
-  if (dependency.type === `atom`) {
-    core.selectorAtoms = core.selectorAtoms.set({
-      selectorKey,
-      atomKey: dependency.key,
-    })
-    store.config.logger?.info(
-      `   || adding root for "${selectorKey}": ${dependency.key}`
-    )
-    return
-  }
-  const roots = traceSelectorAtoms(selectorKey, dependency, store)
-  store.config.logger?.info(
-    `   || adding roots for "${selectorKey}":`,
-    roots.map((r) => r.key)
-  )
-  for (const root of roots) {
-    core.selectorAtoms = core.selectorAtoms.set({
-      selectorKey,
-      atomKey: root.key,
-    })
-  }
+	const core = target(store)
+	if (dependency.type === `atom`) {
+		core.selectorAtoms = core.selectorAtoms.set({
+			selectorKey,
+			atomKey: dependency.key,
+		})
+		store.config.logger?.info(
+			`   || adding root for "${selectorKey}": ${dependency.key}`,
+		)
+		return
+	}
+	const roots = traceSelectorAtoms(selectorKey, dependency, store)
+	store.config.logger?.info(
+		`   || adding roots for "${selectorKey}":`,
+		roots.map((r) => r.key),
+	)
+	for (const root of roots) {
+		core.selectorAtoms = core.selectorAtoms.set({
+			selectorKey,
+			atomKey: root.key,
+		})
+	}
 }

package/src/internal/selector-internal.ts

@@ -1,61 +1,60 @@
 import HAMT from "hamt_plus"
-import type * as Rx from "rxjs"
 
-import type { Store } from "."
 import { target, IMPLICIT } from "."
+import type { Store, Subject } from "."
 import { createReadWriteSelector } from "./selector/create-read-write-selector"
 import { createReadonlySelector } from "./selector/create-readonly-selector"
 import type {
-  FamilyMetadata,
-  ReadonlySelectorOptions,
-  ReadonlySelectorToken,
-  SelectorOptions,
-  SelectorToken,
+	FamilyMetadata,
+	ReadonlySelectorOptions,
+	ReadonlySelectorToken,
+	SelectorOptions,
+	SelectorToken,
 } from ".."
 
 export type Selector<T> = {
-  key: string
-  type: `selector`
-  family?: FamilyMetadata
-  install: (store: Store) => void
-  subject: Rx.Subject<{ newValue: T; oldValue: T }>
-  get: () => T
-  set: (newValue: T | ((oldValue: T) => T)) => void
+	key: string
+	type: `selector`
+	family?: FamilyMetadata
+	install: (store: Store) => void
+	subject: Subject<{ newValue: T; oldValue: T }>
+	get: () => T
+	set: (newValue: T | ((oldValue: T) => T)) => void
 }
 export type ReadonlySelector<T> = {
-  key: string
-  type: `readonly_selector`
-  family?: FamilyMetadata
-  install: (store: Store) => void
-  subject: Rx.Subject<{ newValue: T; oldValue: T }>
-  get: () => T
+	key: string
+	type: `readonly_selector`
+	family?: FamilyMetadata
+	install: (store: Store) => void
+	subject: Subject<{ newValue: T; oldValue: T }>
+	get: () => T
 }
 
 export function selector__INTERNAL<T>(
-  options: SelectorOptions<T>,
-  family?: FamilyMetadata,
-  store?: Store
+	options: SelectorOptions<T>,
+	family?: FamilyMetadata,
+	store?: Store,
 ): SelectorToken<T>
 export function selector__INTERNAL<T>(
-  options: ReadonlySelectorOptions<T>,
-  family?: FamilyMetadata,
-  store?: Store
+	options: ReadonlySelectorOptions<T>,
+	family?: FamilyMetadata,
+	store?: Store,
 ): ReadonlySelectorToken<T>
 export function selector__INTERNAL<T>(
-  options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
-  family?: FamilyMetadata,
-  store: Store = IMPLICIT.STORE
+	options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
+	family?: FamilyMetadata,
+	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
-  const core = target(store)
+	const core = target(store)
 
-  if (HAMT.has(options.key, core.selectors)) {
-    store.config.logger?.error(
-      `Key "${options.key}" already exists in the store.`
-    )
-  }
+	if (HAMT.has(options.key, core.selectors)) {
+		store.config.logger?.error(
+			`Key "${options.key}" already exists in the store.`,
+		)
+	}
 
-  if (!(`set` in options)) {
-    return createReadonlySelector(options, family, store, core)
-  }
-  return createReadWriteSelector(options, family, store, core)
+	if (!(`set` in options)) {
+		return createReadonlySelector(options, family, store, core)
+	}
+	return createReadWriteSelector(options, family, store, core)
 }

package/src/internal/set.ts

@@ -4,99 +4,99 @@ import { become } from "~/packages/anvl/src/function"
 
 import type { Atom, Selector, Store } from "."
 import {
-  IMPLICIT,
-  cacheValue,
-  emitUpdate,
-  evictCachedValue,
-  getState__INTERNAL,
-  isAtomDefault,
-  isDone,
-  markAtomAsNotDefault,
-  markDone,
-  stowUpdate,
-  target,
+	IMPLICIT,
+	cacheValue,
+	emitUpdate,
+	evictCachedValue,
+	getState__INTERNAL,
+	isAtomDefault,
+	isDone,
+	markAtomAsNotDefault,
+	markDone,
+	stowUpdate,
+	target,
 } from "."
 
 export const evictDownStream = <T>(
-  state: Atom<T>,
-  store: Store = IMPLICIT.STORE
+	state: Atom<T>,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  const downstream = core.selectorAtoms.getRelations(state.key)
-  const downstreamKeys = downstream.map(({ id }) => id)
-  store.config.logger?.info(
-    `   || ${downstreamKeys.length} downstream:`,
-    downstreamKeys
-  )
-  if (core.operation.open) {
-    store.config.logger?.info(`   ||`, [...core.operation.done], `already done`)
-  }
-  downstream.forEach(({ id: stateKey }) => {
-    if (isDone(stateKey, store)) {
-      store.config.logger?.info(`   || ${stateKey} already done`)
-      return
-    }
-    const state =
-      HAMT.get(stateKey, core.selectors) ??
-      HAMT.get(stateKey, core.readonlySelectors)
-    if (!state) {
-      store.config.logger?.info(
-        `   || ${stateKey} is an atom, and can't be downstream`
-      )
-      return
-    }
-    evictCachedValue(stateKey, store)
-    store.config.logger?.info(`   xx evicted "${stateKey}"`)
+	const core = target(store)
+	const downstream = core.selectorAtoms.getRelations(state.key)
+	const downstreamKeys = downstream.map(({ id }) => id)
+	store.config.logger?.info(
+		`   || ${downstreamKeys.length} downstream:`,
+		downstreamKeys,
+	)
+	if (core.operation.open) {
+		store.config.logger?.info(`   ||`, [...core.operation.done], `already done`)
+	}
+	downstream.forEach(({ id: stateKey }) => {
+		if (isDone(stateKey, store)) {
+			store.config.logger?.info(`   || ${stateKey} already done`)
+			return
+		}
+		const state =
+			HAMT.get(stateKey, core.selectors) ??
+			HAMT.get(stateKey, core.readonlySelectors)
+		if (!state) {
+			store.config.logger?.info(
+				`   || ${stateKey} is an atom, and can't be downstream`,
+			)
+			return
+		}
+		evictCachedValue(stateKey, store)
+		store.config.logger?.info(`   xx evicted "${stateKey}"`)
 
-    markDone(stateKey, store)
-  })
+		markDone(stateKey, store)
+	})
 }
 
 export const setAtomState = <T>(
-  atom: Atom<T>,
-  next: T | ((oldValue: T) => T),
-  store: Store = IMPLICIT.STORE
+	atom: Atom<T>,
+	next: T | ((oldValue: T) => T),
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const oldValue = getState__INTERNAL(atom, store)
-  const newValue = become(next)(oldValue)
-  store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
-  cacheValue(atom.key, newValue, store)
-  if (isAtomDefault(atom.key, store)) {
-    markAtomAsNotDefault(atom.key, store)
-  }
-  markDone(atom.key, store)
-  store.config.logger?.info(
-    `   || evicting caches downstream from "${atom.key}"`
-  )
-  evictDownStream(atom, store)
-  const update = { oldValue, newValue }
-  if (store.transactionStatus.phase !== `building`) {
-    emitUpdate(atom, update, store)
-  } else {
-    stowUpdate(atom, update, store)
-  }
+	const oldValue = getState__INTERNAL(atom, store)
+	const newValue = become(next)(oldValue)
+	store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
+	cacheValue(atom.key, newValue, store)
+	if (isAtomDefault(atom.key, store)) {
+		markAtomAsNotDefault(atom.key, store)
+	}
+	markDone(atom.key, store)
+	store.config.logger?.info(
+		`   || evicting caches downstream from "${atom.key}"`,
+	)
+	evictDownStream(atom, store)
+	const update = { oldValue, newValue }
+	if (store.transactionStatus.phase !== `building`) {
+		emitUpdate(atom, update, store)
+	} else {
+		stowUpdate(atom, update, store)
+	}
 }
 export const setSelectorState = <T>(
-  selector: Selector<T>,
-  next: T | ((oldValue: T) => T),
-  store: Store = IMPLICIT.STORE
+	selector: Selector<T>,
+	next: T | ((oldValue: T) => T),
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const oldValue = getState__INTERNAL(selector, store)
-  const newValue = become(next)(oldValue)
+	const oldValue = getState__INTERNAL(selector, store)
+	const newValue = become(next)(oldValue)
 
-  store.config.logger?.info(`<< setting selector "${selector.key}" to`, newValue)
-  store.config.logger?.info(`   || propagating change made to "${selector.key}"`)
+	store.config.logger?.info(`<< setting selector "${selector.key}" to`, newValue)
+	store.config.logger?.info(`   || propagating change made to "${selector.key}"`)
 
-  selector.set(newValue)
+	selector.set(newValue)
 }
 export const setState__INTERNAL = <T>(
-  state: Atom<T> | Selector<T>,
-  value: T | ((oldValue: T) => T),
-  store: Store = IMPLICIT.STORE
+	state: Atom<T> | Selector<T>,
+	value: T | ((oldValue: T) => T),
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  if (`set` in state) {
-    setSelectorState(state, value, store)
-  } else {
-    setAtomState(state, value, store)
-  }
+	if (`set` in state) {
+		setSelectorState(state, value, store)
+	} else {
+		setAtomState(state, value, store)
+	}
 }

package/src/internal/store.ts

@@ -1,153 +1,153 @@
 import type { Hamt } from "hamt_plus"
 import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
 
 import type { ƒn } from "~/packages/anvl/src/function"
 import { doNothing } from "~/packages/anvl/src/function"
 import { Join } from "~/packages/anvl/src/join"
 
+import { Subject } from "."
 import type {
-  Atom,
-  OperationProgress,
-  ReadonlySelector,
-  Selector,
-  TransactionStatus,
-  Timeline,
-  Transaction,
+	Atom,
+	OperationProgress,
+	ReadonlySelector,
+	Selector,
+	TransactionStatus,
+	Timeline,
+	Transaction,
 } from "."
 import type {
-  AtomToken,
-  Logger,
-  ReadonlySelectorToken,
-  SelectorToken,
-  TimelineToken,
-  TransactionToken,
+	AtomToken,
+	Logger,
+	ReadonlySelectorToken,
+	SelectorToken,
+	TimelineToken,
+	TransactionToken,
 } from ".."
 
 export type StoreCore = Pick<
-  Store,
-  | `atoms`
-  | `atomsThatAreDefault`
-  | `operation`
-  | `readonlySelectors`
-  | `selectorAtoms`
-  | `selectorGraph`
-  | `selectors`
-  | `timelineAtoms`
-  | `timelines`
-  | `transactions`
-  | `valueMap`
+	Store,
+	| `atoms`
+	| `atomsThatAreDefault`
+	| `operation`
+	| `readonlySelectors`
+	| `selectorAtoms`
+	| `selectorGraph`
+	| `selectors`
+	| `timelineAtoms`
+	| `timelines`
+	| `transactions`
+	| `valueMap`
 >
 
 export interface Store {
-  atoms: Hamt<Atom<any>, string>
-  atomsThatAreDefault: Set<string>
-  readonlySelectors: Hamt<ReadonlySelector<any>, string>
-  selectorAtoms: Join<null, `selectorKey`, `atomKey`>
-  selectorGraph: Join<{ source: string }>
-  selectors: Hamt<Selector<any>, string>
-  timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-  timelines: Hamt<Timeline, string>
-  transactions: Hamt<Transaction<any>, string>
-  valueMap: Hamt<any, string>
+	atoms: Hamt<Atom<any>, string>
+	atomsThatAreDefault: Set<string>
+	readonlySelectors: Hamt<ReadonlySelector<any>, string>
+	selectorAtoms: Join<null, `selectorKey`, `atomKey`>
+	selectorGraph: Join<{ source: string }>
+	selectors: Hamt<Selector<any>, string>
+	timelineAtoms: Join<null, `timelineKey`, `atomKey`>
+	timelines: Hamt<Timeline, string>
+	transactions: Hamt<Transaction<any>, string>
+	valueMap: Hamt<any, string>
 
-  subject: {
-    atomCreation: Rx.Subject<AtomToken<unknown>>
-    selectorCreation: Rx.Subject<
-      ReadonlySelectorToken<unknown> | SelectorToken<unknown>
-    >
-    transactionCreation: Rx.Subject<TransactionToken<unknown>>
-    timelineCreation: Rx.Subject<TimelineToken>
-  }
+	subject: {
+		atomCreation: Subject<AtomToken<unknown>>
+		selectorCreation: Subject<
+			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+		>
+		transactionCreation: Subject<TransactionToken<unknown>>
+		timelineCreation: Subject<TimelineToken>
+	}
 
-  operation: OperationProgress
-  transactionStatus: TransactionStatus<ƒn>
-  config: {
-    name: string
-    logger: Logger | null
-    logger__INTERNAL: Logger
-  }
+	operation: OperationProgress
+	transactionStatus: TransactionStatus<ƒn>
+	config: {
+		name: string
+		logger: Logger | null
+		logger__INTERNAL: Logger
+	}
 }
 
 export const createStore = (name: string, store: Store | null = null): Store => {
-  const copiedStore = {
-    ...(store ??
-      (() => ({
-        atomsThatAreDefault: new Set(),
-        selectorAtoms: new Join({ relationType: `n:n` })
-          .from(`selectorKey`)
-          .to(`atomKey`),
-        selectorGraph: new Join({ relationType: `n:n` }),
-        valueMap: HAMT.make<any, string>(),
-      }))()),
+	const copiedStore = {
+		...(store ??
+			(() => ({
+				atomsThatAreDefault: new Set(),
+				selectorAtoms: new Join({ relationType: `n:n` })
+					.from(`selectorKey`)
+					.to(`atomKey`),
+				selectorGraph: new Join({ relationType: `n:n` }),
+				valueMap: HAMT.make<any, string>(),
+			}))()),
 
-    atoms: HAMT.make<Atom<any>, string>(),
-    readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
-    selectors: HAMT.make<Selector<any>, string>(),
-    transactions: HAMT.make<Transaction<any>, string>(),
-    timelines: HAMT.make<Timeline, string>(),
+		atoms: HAMT.make<Atom<any>, string>(),
+		readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
+		selectors: HAMT.make<Selector<any>, string>(),
+		transactions: HAMT.make<Transaction<any>, string>(),
+		timelines: HAMT.make<Timeline, string>(),
 
-    timelineAtoms: new Join({ relationType: `1:n` })
-      .from(`timelineKey`)
-      .to(`atomKey`),
+		timelineAtoms: new Join({ relationType: `1:n` })
+			.from(`timelineKey`)
+			.to(`atomKey`),
 
-    subject: {
-      atomCreation: new Rx.Subject(),
-      selectorCreation: new Rx.Subject(),
-      transactionCreation: new Rx.Subject(),
-      timelineCreation: new Rx.Subject(),
-      ...store?.subject,
-    },
+		subject: {
+			atomCreation: new Subject(),
+			selectorCreation: new Subject(),
+			transactionCreation: new Subject(),
+			timelineCreation: new Subject(),
+			...store?.subject,
+		},
 
-    operation: {
-      open: false,
-      ...store?.operation,
-    },
-    transactionStatus: {
-      phase: `idle`,
-      ...store?.transactionStatus,
-    },
-    config: {
-      logger: {
-        ...console,
-        info: doNothing,
-        ...store?.config?.logger,
-      },
-      logger__INTERNAL: console,
-      ...store?.config,
-      name,
-    },
-  } satisfies Store
+		operation: {
+			open: false,
+			...store?.operation,
+		},
+		transactionStatus: {
+			phase: `idle`,
+			...store?.transactionStatus,
+		},
+		config: {
+			logger: {
+				...console,
+				info: doNothing,
+				...store?.config?.logger,
+			},
+			logger__INTERNAL: console,
+			...store?.config,
+			name,
+		},
+	} satisfies Store
 
-  store?.atoms.forEach((atom) => {
-    const copiedAtom = { ...atom, subject: new Rx.Subject() } satisfies Atom<any>
-    copiedStore.atoms = HAMT.set(atom.key, copiedAtom, copiedStore.atoms)
-  })
-  store?.readonlySelectors.forEach((selector) => {
-    selector.install(copiedStore)
-  })
-  store?.selectors.forEach((selector) => {
-    selector.install(copiedStore)
-  })
-  store?.transactions.forEach((tx) => {
-    tx.install(copiedStore)
-  })
-  store?.timelines.forEach((timeline) => {
-    timeline.install(copiedStore)
-  })
+	store?.atoms.forEach((atom) => {
+		const copiedAtom = { ...atom, subject: new Subject() } satisfies Atom<any>
+		copiedStore.atoms = HAMT.set(atom.key, copiedAtom, copiedStore.atoms)
+	})
+	store?.readonlySelectors.forEach((selector) => {
+		selector.install(copiedStore)
+	})
+	store?.selectors.forEach((selector) => {
+		selector.install(copiedStore)
+	})
+	store?.transactions.forEach((tx) => {
+		tx.install(copiedStore)
+	})
+	store?.timelines.forEach((timeline) => {
+		timeline.install(copiedStore)
+	})
 
-  return copiedStore
+	return copiedStore
 }
 
 export const IMPLICIT = {
-  STORE_INTERNAL: undefined as Store | undefined,
-  get STORE(): Store {
-    return this.STORE_INTERNAL ?? (this.STORE_INTERNAL = createStore(`DEFAULT`))
-  },
+	STORE_INTERNAL: undefined as Store | undefined,
+	get STORE(): Store {
+		return this.STORE_INTERNAL ?? (this.STORE_INTERNAL = createStore(`DEFAULT`))
+	},
 }
 
 export const clearStore = (store: Store = IMPLICIT.STORE): void => {
-  const { config } = store
-  Object.assign(store, createStore(config.name))
-  store.config = config
+	const { config } = store
+	Object.assign(store, createStore(config.name))
+	store.config = config
 }

package/src/internal/subject.ts

@@ -0,0 +1,24 @@
+type Subscriber<T> = (value: T) => void
+
+export class Subject<T> {
+	public subscribers: Subscriber<T>[] = []
+
+	public subscribe(subscriber: Subscriber<T>): { unsubscribe: () => void } {
+		this.subscribers.push(subscriber)
+		const unsubscribe = () => this.unsubscribe(subscriber)
+		return { unsubscribe }
+	}
+
+	private unsubscribe(subscriber: Subscriber<T>) {
+		const subscriberIndex = this.subscribers.indexOf(subscriber)
+		if (subscriberIndex !== -1) {
+			this.subscribers.splice(subscriberIndex, 1)
+		}
+	}
+
+	public next(value: T): void {
+		for (const subscriber of this.subscribers) {
+			subscriber(value)
+		}
+	}
+}