atom.io 0.6.8 → 0.6.9

package/src/silo.ts

@@ -1,53 +1,50 @@
-import type { redo, timeline, undo } from "."
-import { getState, setState, subscribe } from "."
-import type { atom, atomFamily } from "./atom"
-import type { Store } from "./internal"
 import {
+	Store,
 	atomFamily__INTERNAL,
 	atom__INTERNAL,
-	createStore,
 	redo__INTERNAL,
 	selectorFamily__INTERNAL,
 	selector__INTERNAL,
 	timeline__INTERNAL,
 	transaction__INTERNAL,
 	undo__INTERNAL,
-} from "./internal"
+} from "atom.io/internal"
+
+import type { redo, timeline, undo } from "."
+import { getState, setState, subscribe } from "."
+import type { atom, atomFamily } from "./atom"
 import type { selector, selectorFamily } from "./selector"
 import type { transaction } from "./transaction"
 
-export type Silo = ReturnType<typeof silo>
-
-export const silo = (
-	name: string,
-	fromStore: Store | null = null,
-): {
-	store: Store
-	atom: typeof atom
-	atomFamily: typeof atomFamily
-	selector: typeof selector
-	selectorFamily: typeof selectorFamily
-	transaction: typeof transaction
-	timeline: typeof timeline
-	getState: typeof getState
-	setState: typeof setState
-	subscribe: typeof subscribe
-	undo: typeof undo
-	redo: typeof redo
-} => {
-	const store = createStore(name, fromStore)
-	return {
-		store,
-		atom: (options) => atom__INTERNAL(options, undefined, store),
-		atomFamily: (options) => atomFamily__INTERNAL(options, store),
-		selector: (options) => selector__INTERNAL(options, undefined, store) as any,
-		selectorFamily: (options) => selectorFamily__INTERNAL(options, store) as any,
-		transaction: (options) => transaction__INTERNAL(options, store),
-		timeline: (options) => timeline__INTERNAL(options, store),
-		getState: (token) => getState(token, store),
-		setState: (token, newValue) => setState(token, newValue, store),
-		subscribe: (token, handler) => subscribe(token, handler, store),
-		undo: (token) => undo__INTERNAL(token, store),
-		redo: (token) => redo__INTERNAL(token, store),
+export class Silo {
+	public store: Store
+	public atom: typeof atom
+	public atomFamily: typeof atomFamily
+	public selector: typeof selector
+	public selectorFamily: typeof selectorFamily
+	public transaction: typeof transaction
+	public timeline: typeof timeline
+	public getState: typeof getState
+	public setState: typeof setState
+	public subscribe: typeof subscribe
+	public undo: typeof undo
+	public redo: typeof redo
+	public constructor(name: string, fromStore: Store | null = null) {
+		const store = new Store(name, fromStore)
+		this.store = store
+		this.atom = (options) => atom__INTERNAL(options, undefined, store)
+		this.atomFamily = (options) => atomFamily__INTERNAL(options, store)
+		this.selector = (options) =>
+			selector__INTERNAL(options, undefined, store) as any
+		this.selectorFamily = (options) =>
+			selectorFamily__INTERNAL(options, store) as any
+		this.transaction = (options) => transaction__INTERNAL(options, store)
+		this.timeline = (options) => timeline__INTERNAL(options, store)
+		this.getState = (token) => getState(token, store)
+		this.setState = (token, newValue) => setState(token, newValue, store)
+		;(this.subscribe = (token, handler, key) =>
+			subscribe(token, handler, key, store)),
+			(this.undo = (token) => undo__INTERNAL(token, store))
+		this.redo = (token) => redo__INTERNAL(token, store)
 	}
 }

package/src/subscribe.ts

@@ -1,23 +1,28 @@
-import type { ƒn } from "~/packages/anvl/src/function"
+import type { Store } from "atom.io/internal"
+import { IMPLICIT, subscribeToRootAtoms, withdraw } from "atom.io/internal"
 
 import type {
+	FamilyMetadata,
 	ReadonlySelectorToken,
 	StateToken,
 	TimelineToken,
 	TimelineUpdate,
 	TransactionToken,
 	TransactionUpdate,
+	ƒn,
 } from "."
-import type { Store } from "./internal"
-import { IMPLICIT, subscribeToRootAtoms, withdraw } from "./internal"
 
 export type StateUpdate<T> = { newValue: T; oldValue: T }
-export type KeyedStateUpdate<T> = StateUpdate<T> & { key: string }
+export type KeyedStateUpdate<T> = StateUpdate<T> & {
+	key: string
+	family?: FamilyMetadata
+}
 export type UpdateHandler<T> = (update: StateUpdate<T>) => void
 
 export const subscribe = <T>(
 	token: ReadonlySelectorToken<T> | StateToken<T>,
 	handleUpdate: UpdateHandler<T>,
+	key: string = Math.random().toString(36).slice(2),
 	store: Store = IMPLICIT.STORE,
 ): (() => void) => {
 	const state = withdraw<T>(token, store)
@@ -26,24 +31,24 @@ export const subscribe = <T>(
 			`State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
 		)
 	}
-	const subscription = state.subject.subscribe(handleUpdate)
+	const unsubFunction = state.subject.subscribe(key, handleUpdate)
 	store.config.logger?.info(`👀 subscribe to "${state.key}"`)
-	const dependencySubscriptions =
+	const dependencyUnsubFunctions =
 		state.type !== `atom` ? subscribeToRootAtoms(state, store) : null
 
 	const unsubscribe =
-		dependencySubscriptions === null
+		dependencyUnsubFunctions === null
 			? () => {
 					store.config.logger?.info(`🙈 unsubscribe from "${state.key}"`)
-					subscription.unsubscribe()
+					unsubFunction()
 			  }
 			: () => {
 					store.config.logger?.info(
 						`🙈 unsubscribe from "${state.key}" and its dependencies`,
 					)
-					subscription.unsubscribe()
-					for (const dependencySubscription of dependencySubscriptions) {
-						dependencySubscription.unsubscribe()
+					unsubFunction()
+					for (const unsubFromDependency of dependencyUnsubFunctions) {
+						unsubFromDependency()
 					}
 			  }
 
@@ -57,6 +62,7 @@ export type TransactionUpdateHandler<ƒ extends ƒn> = (
 export const subscribeToTransaction = <ƒ extends ƒn>(
 	token: TransactionToken<ƒ>,
 	handleUpdate: TransactionUpdateHandler<ƒ>,
+	key: string = Math.random().toString(36).slice(2),
 	store = IMPLICIT.STORE,
 ): (() => void) => {
 	const tx = withdraw(token, store)
@@ -66,17 +72,17 @@ export const subscribeToTransaction = <ƒ extends ƒn>(
 		)
 	}
 	store.config.logger?.info(`👀 subscribe to transaction "${token.key}"`)
-	const subscription = tx.subject.subscribe(handleUpdate)
-	const unsubscribe = () => {
+	const unsubscribe = tx.subject.subscribe(key, handleUpdate)
+	return () => {
 		store.config.logger?.info(`🙈 unsubscribe from transaction "${token.key}"`)
-		subscription.unsubscribe()
+		unsubscribe()
 	}
-	return unsubscribe
 }
 
 export const subscribeToTimeline = (
 	token: TimelineToken,
 	handleUpdate: (update: TimelineUpdate | `redo` | `undo`) => void,
+	key: string = Math.random().toString(36).slice(2),
 	store = IMPLICIT.STORE,
 ): (() => void) => {
 	const tl = withdraw(token, store)
@@ -86,10 +92,9 @@ export const subscribeToTimeline = (
 		)
 	}
 	store.config.logger?.info(`👀 subscribe to timeline "${token.key}"`)
-	const subscription = tl.subject.subscribe(handleUpdate)
-	const unsubscribe = () => {
+	const unsubscribe = tl.subject.subscribe(key, handleUpdate)
+	return () => {
 		store.config.logger?.info(`🙈 unsubscribe from timeline "${token.key}"`)
-		subscription.unsubscribe()
+		unsubscribe()
 	}
-	return unsubscribe
 }

package/src/timeline.ts

@@ -1,11 +1,16 @@
-import type { AtomFamily, AtomToken } from "."
 import type {
 	TimelineAtomUpdate,
 	TimelineSelectorUpdate,
 	TimelineTransactionUpdate,
-} from "./internal"
-import { IMPLICIT } from "./internal"
-import { redo__INTERNAL, timeline__INTERNAL, undo__INTERNAL } from "./internal/"
+} from "atom.io/internal"
+import { IMPLICIT } from "atom.io/internal"
+import {
+	redo__INTERNAL,
+	timeline__INTERNAL,
+	undo__INTERNAL,
+} from "atom.io/internal/"
+
+import type { AtomFamily, AtomToken } from "."
 
 export type TimelineToken = {
 	key: string

package/src/transaction.ts

@@ -1,8 +1,7 @@
-import type { ƒn } from "~/packages/anvl/src/function"
+import type { Store } from "atom.io/internal"
+import { IMPLICIT, transaction__INTERNAL, withdraw } from "atom.io/internal"
 
-import type { KeyedStateUpdate, ReadonlySelectorToken, StateToken } from "."
-import type { Store } from "./internal"
-import { IMPLICIT, transaction__INTERNAL, withdraw } from "./internal"
+import type { KeyedStateUpdate, ReadonlySelectorToken, StateToken, ƒn } from "."
 
 export type TransactionToken<_> = {
 	key: string

package/src/internal/atom-internal.ts

@@ -1,54 +0,0 @@
-import { Subject } from "."
-import { deposit } from "./get"
-import { markAtomAsDefault } from "./is-default"
-import { cacheValue } from "./operation"
-import type { Store } from "./store"
-import { IMPLICIT } from "./store"
-import { target } from "./transaction-internal"
-import type { AtomToken, FamilyMetadata, UpdateHandler } from ".."
-import { setState, subscribe } from ".."
-import type { AtomOptions } from "../atom"
-
-export type Atom<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,
-): AtomToken<T> {
-	const core = target(store)
-	const existing = core.atoms.get(options.key)
-	if (existing) {
-		store.config.logger?.error?.(
-			`Key "${options.key}" already exists in the store.`,
-		)
-		return deposit(existing)
-	}
-	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.set(newAtom.key, newAtom)
-	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,144 +0,0 @@
-import type { Json } from "~/packages/anvl/src/json"
-import { stringifyJson } from "~/packages/anvl/src/json"
-
-import type { Store } from "."
-import {
-	Subject,
-	atom__INTERNAL,
-	withdraw,
-	selector__INTERNAL,
-	target,
-	deposit,
-	IMPLICIT,
-} from "."
-import type {
-	AtomFamily,
-	AtomFamilyOptions,
-	AtomOptions,
-	AtomToken,
-	FamilyMetadata,
-	ReadonlySelectorFamily,
-	ReadonlySelectorFamilyOptions,
-	ReadonlySelectorToken,
-	SelectorFamily,
-	SelectorFamilyOptions,
-	SelectorToken,
-} from ".."
-
-export function atomFamily__INTERNAL<T, K extends Json.Serializable>(
-	options: AtomFamilyOptions<T, K>,
-	store: Store = IMPLICIT.STORE,
-): AtomFamily<T, K> {
-	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)
-			let token: AtomToken<any>
-			if (existing) {
-				token = deposit(existing)
-			} else {
-				const individualOptions: AtomOptions<any> = {
-					key: fullKey,
-					default:
-						options.default instanceof Function
-							? options.default(key)
-							: options.default,
-				}
-				if (options.effects) {
-					individualOptions.effects = options.effects(key)
-				}
-				token = atom__INTERNAL<T>(individualOptions, family, store)
-			}
-			subject.next(token)
-			return token
-		},
-		{
-			key: options.key,
-			type: `atom_family`,
-			subject,
-		} as const,
-	)
-}
-
-export function readonlySelectorFamily__INTERNAL<T, K extends Json.Serializable>(
-	options: ReadonlySelectorFamilyOptions<T, K>,
-	store?: Store,
-): 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 Json.Serializable>(
-	options: SelectorFamilyOptions<T, K>,
-	store?: Store,
-): SelectorFamily<T, K>
-export function selectorFamily__INTERNAL<T, K extends Json.Serializable>(
-	options: ReadonlySelectorFamilyOptions<T, K>,
-	store?: Store,
-): ReadonlySelectorFamily<T, K>
-export function selectorFamily__INTERNAL<T, K extends Json.Serializable>(
-	options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
-	store: Store = IMPLICIT.STORE,
-): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
-	const isReadonly = !(`set` in options)
-
-	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>
-}

package/src/internal/get.ts

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

package/src/internal/index.ts

@@ -1,15 +0,0 @@
-export * from "./atom-internal"
-export * from "./families-internal"
-export * from "./get"
-export * from "./is-default"
-export * from "./operation"
-export * from "./selector-internal"
-export * from "./selector"
-export * from "./set"
-export * from "./store"
-export * from "../../../anvl/reactivity/subject"
-export * from "./subscribe-internal"
-export * from "./time-travel-internal"
-export * from "./timeline-internal"
-export * from "./transaction-internal"
-export * from "./transaction"

package/src/internal/is-default.ts

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