atom.io 0.6.7 → 0.6.9

package/src/index.ts

@@ -1,17 +1,20 @@
-import { capitalize } from "~/packages/anvl/src/string/capitalize"
-
 import {
 	IMPLICIT,
 	closeOperation,
-	openOperation,
 	getState__INTERNAL,
-	setState__INTERNAL,
 	isAtomDefault,
 	isSelectorDefault,
+	openOperation,
+	setState__INTERNAL,
 	withdraw,
-} from "./internal"
-import * as __INTERNAL__ from "./internal"
-import type { Store } from "./internal/store"
+} from "atom.io/internal"
+import * as __INTERNAL__ from "atom.io/internal"
+import type { Store } from "atom.io/internal"
+
+import type { ƒn } from "~/packages/anvl/src/function"
+import { capitalize } from "~/packages/anvl/src/string/capitalize"
+
+export { ƒn }
 
 export * from "./atom"
 export * from "./logger"
@@ -21,8 +24,8 @@ export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
 export { __INTERNAL__ }
-export type { Store } from "./internal/store"
-export type { Serializable } from "~/packages/anvl/src/json"
+export type { Store } from "atom.io/internal"
+export type { Json } from "atom.io/json"
 
 export type AtomToken<_> = {
 	key: string

package/src/logger.ts

@@ -1,7 +1,7 @@
-import { doNothing } from "~/packages/anvl/src/function"
+import { IMPLICIT } from "atom.io/internal"
+import type { Store } from "atom.io/internal"
 
-import type { Store } from "./internal/store"
-import { IMPLICIT } from "./internal/store"
+import { doNothing } from "~/packages/anvl/src/function"
 
 export type Logger = Pick<Console, `error` | `info` | `warn`>
 export const LOG_LEVELS: ReadonlyArray<keyof Logger> = [
@@ -21,10 +21,10 @@ export const setLogLevel = (
 		store.config.logger = { ...console }
 		LOG_LEVELS.forEach((logLevel) => {
 			if (LOG_LEVELS.indexOf(logLevel) < LOG_LEVELS.indexOf(preferredLevel)) {
-				// rome-ignore lint/style/noNonNullAssertion: we just set it
+				// biome-ignore lint/style/noNonNullAssertion: we just set it
 				store.config.logger![logLevel] = doNothing
 			} else {
-				// rome-ignore lint/style/noNonNullAssertion: we just set it
+				// biome-ignore lint/style/noNonNullAssertion: we just set it
 				store.config.logger![logLevel] = logger__INTERNAL[logLevel]
 			}
 		})

package/src/selector.ts

@@ -1,8 +1,8 @@
-import type { Serializable } from "~/packages/anvl/src/json"
+import type { Subject } from "atom.io/internal"
+import { selectorFamily__INTERNAL, selector__INTERNAL } from "atom.io/internal"
+import type { Json } from "atom.io/json"
 
 import type { ReadonlySelectorToken, SelectorToken } from "."
-import type { Subject } from "./internal"
-import { selectorFamily__INTERNAL, selector__INTERNAL } from "./internal"
 import type { Read, Write } from "./transaction"
 
 export type SelectorOptions<T> = {
@@ -25,39 +25,41 @@ export function selector<T>(
 	return selector__INTERNAL(options)
 }
 
-export type SelectorFamilyOptions<T, K extends Serializable> = {
+export type SelectorFamilyOptions<T, K extends Json.Serializable> = {
 	key: string
 	get: (key: K) => Read<() => T>
 	set: (key: K) => Write<(newValue: T) => void>
 }
-export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = {
+export type ReadonlySelectorFamilyOptions<T, K extends Json.Serializable> = {
 	key: string
 	get: (key: K) => Read<() => T>
 }
 
-export type SelectorFamily<T, K extends Serializable = Serializable> = ((
-	key: K,
-) => SelectorToken<T>) & {
+export type SelectorFamily<
+	T,
+	K extends Json.Serializable = Json.Serializable,
+> = ((key: K) => SelectorToken<T>) & {
 	key: string
 	type: `selector_family`
 	subject: Subject<SelectorToken<T>>
 }
 
-export type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((
-	key: K,
-) => ReadonlySelectorToken<T>) & {
+export type ReadonlySelectorFamily<
+	T,
+	K extends Json.Serializable = Json.Serializable,
+> = ((key: K) => ReadonlySelectorToken<T>) & {
 	key: string
 	type: `readonly_selector_family`
 	subject: Subject<ReadonlySelectorToken<T>>
 }
 
-export function selectorFamily<T, K extends Serializable>(
+export function selectorFamily<T, K extends Json.Serializable>(
 	options: SelectorFamilyOptions<T, K>,
 ): SelectorFamily<T, K>
-export function selectorFamily<T, K extends Serializable>(
+export function selectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamily<T, K>
-export function selectorFamily<T, K extends Serializable>(
+export function selectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
 	return selectorFamily__INTERNAL(options)

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) => void,
+	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,141 +0,0 @@
-import type { Serializable } 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,
-	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,
-): 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)
-			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,
-): 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,
-): SelectorFamily<T, K>
-export function selectorFamily__INTERNAL<T, K extends Serializable>(
-	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,
-): 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>
-}