atom.io 0.27.3 → 0.27.5

package/src/logger.ts

@@ -52,12 +52,16 @@ const LoggerIconDictionary = {
 } as const
 export type LoggerIcon = keyof typeof LoggerIconDictionary
 export type TokenDenomination =
+	| `atom_family`
 	| `atom`
 	| `continuity`
 	| `molecule_family`
 	| `molecule`
+	| `mutable_atom_family`
 	| `mutable_atom`
+	| `readonly_selector_family`
 	| `readonly_selector`
+	| `selector_family`
 	| `selector`
 	| `state`
 	| `timeline`

package/src/molecule.ts

@@ -101,7 +101,7 @@ export type MoleculeToken<M extends MoleculeConstructor> = {
 export function moleculeFamily<M extends MoleculeConstructor>(
 	options: MoleculeFamilyOptions<M>,
 ): MoleculeFamilyToken<M> {
-	return createMoleculeFamily(options, IMPLICIT.STORE)
+	return createMoleculeFamily(IMPLICIT.STORE, options)
 }
 
 export function makeMolecule<M extends MoleculeConstructor>(

package/src/selector.ts

@@ -27,7 +27,7 @@ export function selector<T>(
 export function selector<T>(
 	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 ): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
-	return createStandaloneSelector(options, IMPLICIT.STORE)
+	return createStandaloneSelector(IMPLICIT.STORE, options)
 }
 
 export type WritableSelectorFamilyOptions<T, K extends Canonical> = {
@@ -69,5 +69,5 @@ export function selectorFamily<T, K extends Canonical>(
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K> {
-	return createSelectorFamily(options, IMPLICIT.STORE)
+	return createSelectorFamily(IMPLICIT.STORE, options)
 }

package/src/set-state.ts

@@ -1,6 +1,5 @@
 import * as Internal from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
-import type { Json } from "rel8"
 
 import type { WritableFamilyToken, WritableToken } from "."
 
@@ -32,13 +31,17 @@ export function setState<T, K extends Canonical, New extends T, Key extends K>(
 ): void
 
 export function setState<T, New extends T>(
-	token: WritableFamilyToken<T, Canonical> | WritableToken<T>,
-	p1: Json.Serializable | New | ((oldValue: T) => New),
-	p2?: New | ((oldValue: T) => New),
+	...params:
+		| [
+				token: WritableFamilyToken<T, Canonical>,
+				key: Canonical,
+				value: New | ((oldValue: T) => New),
+		  ]
+		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
-	if (p2) {
-		Internal.setIntoStore(token as any, p1 as any, p2, Internal.IMPLICIT.STORE)
+	if (params.length === 2) {
+		Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params)
 	} else {
-		Internal.setIntoStore(token as any, p1 as any, Internal.IMPLICIT.STORE)
+		Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params)
 	}
 }

package/src/silo.ts

@@ -1,5 +1,4 @@
 import type { findState } from "atom.io/ephemeral"
-import type { Transceiver } from "atom.io/internal"
 import {
 	createAtomFamily,
 	createMoleculeFamily,
@@ -14,30 +13,21 @@ import {
 	makeMoleculeInStore,
 	setIntoStore,
 	Store,
+	subscribeInStore,
 	timeTravel,
 } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
 
 import type {
-	AtomToken,
 	disposeState,
 	getState,
 	makeMolecule,
 	moleculeFamily,
-	MutableAtomFamilyOptions,
-	MutableAtomFamilyToken,
-	MutableAtomOptions,
-	MutableAtomToken,
 	redo,
-	RegularAtomFamilyOptions,
-	RegularAtomFamilyToken,
-	RegularAtomOptions,
-	RegularAtomToken,
 	setState,
+	subscribe,
 	timeline,
 	undo,
 } from "."
-import { subscribe } from "."
 import type { atom, atomFamily } from "./atom"
 import type { selector, selectorFamily } from "./selector"
 import type { transaction } from "./transaction"
@@ -61,60 +51,40 @@ export class Silo {
 	public makeMolecule: typeof makeMolecule
 	public constructor(config: Store[`config`], fromStore: Store | null = null) {
 		const s = new Store(config, fromStore)
-		function _atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
-		function _atom<T extends Transceiver<any>, J extends Json.Serializable>(
-			options: MutableAtomOptions<T, J>,
-		): MutableAtomToken<T, J>
-		function _atom<T>(
-			options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
-		): AtomToken<T> {
-			return createStandaloneAtom(options, s)
-		}
-		function _atomFamily<
-			T extends Transceiver<any>,
-			J extends Json.Serializable,
-			K extends Canonical,
-		>(
-			options: MutableAtomFamilyOptions<T, J, K>,
-		): MutableAtomFamilyToken<T, J, K>
-		function _atomFamily<T, K extends Canonical>(
-			options: RegularAtomFamilyOptions<T, K>,
-		): RegularAtomFamilyToken<T, K>
-		function _atomFamily<T, K extends Canonical>(
-			options:
-				| MutableAtomFamilyOptions<any, any, any>
-				| RegularAtomFamilyOptions<T, K>,
-		): MutableAtomFamilyToken<any, any, any> | RegularAtomFamilyToken<T, K> {
-			return createAtomFamily(options, s)
-		}
 		this.store = s
-		this.atom = _atom
-		this.atomFamily = _atomFamily
-		this.selector = (options) => createStandaloneSelector(options, s) as any
-		this.selectorFamily = (options) => createSelectorFamily(options, s) as any
+		this.atom = ((options: Parameters<typeof atom>[0]) =>
+			createStandaloneAtom(s, options)) as typeof atom
+		this.atomFamily = ((options: Parameters<typeof atomFamily>[0]) =>
+			createAtomFamily(s, options)) as typeof atomFamily
+		this.selector = ((options: Parameters<typeof selector>[0]) =>
+			createStandaloneSelector(s, options)) as typeof selector
+		this.selectorFamily = ((options: Parameters<typeof selectorFamily>[0]) =>
+			createSelectorFamily(s, options)) as typeof selectorFamily
 		this.transaction = (options) => createTransaction(options, s)
 		this.timeline = (options) => createTimeline(options, s)
-		this.findState = (token, key) => findInStore(token, key, s) as any
+		this.findState = ((...params: Parameters<typeof findState>) =>
+			findInStore(s, ...params)) as typeof findState
 		this.getState = ((...params: Parameters<typeof getState>) =>
-			getFromStore(...params, s)) as typeof getState
+			getFromStore(s, ...params)) as typeof getState
 		this.setState = ((...params: Parameters<typeof setState>) => {
-			setIntoStore(...params, s)
+			setIntoStore(s, ...params)
 		}) as typeof setState
 		this.disposeState = ((...params: Parameters<typeof disposeState>) => {
-			disposeFromStore(...params, s)
+			disposeFromStore(s, ...params)
 		}) as typeof disposeState
-		this.subscribe = (token, handler, key) => subscribe(token, handler, key, s)
+		this.subscribe = ((...params: Parameters<typeof subscribe>) =>
+			subscribeInStore(s, ...params)) as typeof subscribe
 		this.undo = (token) => {
-			timeTravel(`undo`, token, s)
+			timeTravel(s, `undo`, token)
 		}
 		this.redo = (token) => {
-			timeTravel(`redo`, token, s)
+			timeTravel(s, `redo`, token)
 		}
-		this.moleculeFamily = ((...params: Parameters<typeof moleculeFamily>) => {
-			return createMoleculeFamily(...params, s)
-		}) as any
+		this.moleculeFamily = ((options: Parameters<typeof moleculeFamily>[0]) => {
+			return createMoleculeFamily(s, options)
+		}) as typeof moleculeFamily
 		this.makeMolecule = ((...params: Parameters<typeof makeMolecule>) => {
 			return makeMoleculeInStore(s, ...params)
-		}) as any
+		}) as typeof makeMolecule
 	}
 }

package/src/subscribe.ts

@@ -1,11 +1,5 @@
-import type { Flat, Func, Store } from "atom.io/internal"
-import {
-	arbitrary,
-	IMPLICIT,
-	subscribeToState,
-	subscribeToTimeline,
-	subscribeToTransaction,
-} from "atom.io/internal"
+import type { Flat, Func } from "atom.io/internal"
+import { arbitrary, IMPLICIT, subscribeInStore } from "atom.io/internal"
 
 import type {
 	FamilyMetadata,
@@ -35,35 +29,21 @@ export function subscribe<T>(
 	token: ReadableToken<T>,
 	handleUpdate: UpdateHandler<T>,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe<F extends Func>(
 	token: TransactionToken<F>,
 	handleUpdate: TransactionUpdateHandler<F>,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe<M extends TimelineManageable>(
 	token: TimelineToken<M>,
 	handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe(
 	token: ReadableToken<any> | TimelineToken<any> | TransactionToken<any>,
 	handleUpdate: (update: any) => void,
 	key: string = arbitrary(),
-	store = IMPLICIT.STORE,
 ): () => void {
-	switch (token.type) {
-		case `atom`:
-		case `mutable_atom`:
-		case `readonly_selector`:
-		case `selector`:
-			return subscribeToState(token, handleUpdate, key, store)
-		case `transaction`:
-			return subscribeToTransaction(token, handleUpdate, key, store)
-		case `timeline`:
-			return subscribeToTimeline(token, handleUpdate, key, store)
-	}
+	return subscribeInStore(IMPLICIT.STORE, token, handleUpdate, key)
 }

package/src/timeline.ts

@@ -54,9 +54,9 @@ export const timeline = <ManagedAtom extends TimelineManageable>(
 }
 
 export const redo = (tl: TimelineToken<any>): void => {
-	timeTravel(`redo`, tl, IMPLICIT.STORE)
+	timeTravel(IMPLICIT.STORE, `redo`, tl)
 }
 
 export const undo = (tl: TimelineToken<any>): void => {
-	timeTravel(`undo`, tl, IMPLICIT.STORE)
+	timeTravel(IMPLICIT.STORE, `undo`, tl)
 }

package/internal/src/families/throw-in-case-of-conflicting-family.ts

@@ -1,18 +0,0 @@
-import type { AtomFamilyToken, SelectorFamilyToken } from "atom.io"
-
-import { prettyPrintTokenType } from "../pretty-print"
-import type { Store } from "../store"
-
-export function throwInCaseOfConflictingFamily(
-	family: AtomFamilyToken<any, any> | SelectorFamilyToken<any, any>,
-	store: Store,
-): void {
-	const existingFamily = store.families.get(family.key)
-	if (existingFamily) {
-		throw new Error(
-			`Tried to create ${family.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(family)} with key "${family.key}", but "${family.key}" already exists in store "${store.config.name}" as ${existingFamily.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(
-				existingFamily,
-			)}`,
-		)
-	}
-}