atom.io 0.27.2 → 0.27.4

package/internal/src/families/create-atom-family.ts

@@ -1,8 +1,9 @@
 import type {
-	MutableAtomFamily,
+	AtomFamilyToken,
 	MutableAtomFamilyOptions,
-	RegularAtomFamily,
+	MutableAtomFamilyToken,
 	RegularAtomFamilyOptions,
+	RegularAtomFamilyToken,
 } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
 
@@ -17,17 +18,17 @@ export function createAtomFamily<
 >(
 	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
-): MutableAtomFamily<T, J, K>
+): MutableAtomFamilyToken<T, J, K>
 export function createAtomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): RegularAtomFamily<T, K>
+): RegularAtomFamilyToken<T, K>
 export function createAtomFamily<T, K extends Canonical>(
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): MutableAtomFamily<any, any, any> | RegularAtomFamily<T, K> {
+): AtomFamilyToken<any, any> {
 	const isMutable = `mutable` in options
 
 	if (isMutable) {

package/internal/src/families/create-readonly-selector-family.ts

@@ -1,54 +1,80 @@
 import type {
 	FamilyMetadata,
-	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyOptions,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { seekState } from "atom.io/immortal"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	type ReadonlySelectorFamily,
+	seekInStore,
+} from ".."
 import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createReadonlySelectorFamily<T, K extends Canonical>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
-): ReadonlySelectorFamily<T, K> {
+	internalRoles?: string[],
+): ReadonlySelectorFamilyToken<T, K> {
+	const familyToken = {
+		key: options.key,
+		type: `readonly_selector_family`,
+	} as const satisfies ReadonlySelectorFamilyToken<T, K>
+
+	throwInCaseOfConflictingFamily(familyToken, store)
+
 	const subject = new Subject<
 		| StateCreation<ReadonlySelectorToken<T>>
 		| StateDisposal<ReadonlySelectorToken<T>>
 	>()
 
-	const readonlySelectorFamily = Object.assign(
-		(key: K): ReadonlySelectorToken<T> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const target = newest(store)
-
-			const token = createReadonlySelector(
-				{
-					key: fullKey,
-					get: options.get(key),
-				},
-				family,
-				target,
-			)
-
-			subject.next({ type: `state_creation`, token })
-			return token
+	const familyFunction = (key: K): ReadonlySelectorToken<T> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: options.key, subKey }
+		const fullKey = `${options.key}(${subKey})`
+		const target = newest(store)
+
+		const token = createReadonlySelector(
+			{
+				key: fullKey,
+				get: options.get(key),
+			},
+			family,
+			target,
+		)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s: Store) => createReadonlySelectorFamily(options, s),
+		default: (key: K) => {
+			const getFn = options.get(key)
+			return getFn({
+				get: (token) => getFromStore(token, store),
+				find: ((token, k) => findInStore(token, k, store)) as typeof findState,
+				seek: ((token, k) => seekInStore(token, k, store)) as typeof seekState,
+				json: (token) => getJsonToken(token, store),
+			})
 		},
-		{
-			key: options.key,
-			type: `readonly_selector_family`,
-			subject,
-			install: (s: Store) => createReadonlySelectorFamily(options, s),
-		} as const,
-	) satisfies ReadonlySelectorFamily<T, K>
+	}) satisfies ReadonlySelectorFamily<T, K>
+
 	store.families.set(options.key, readonlySelectorFamily)
-	return readonlySelectorFamily
+	return familyToken
 }

package/internal/src/families/create-regular-atom-family.ts

@@ -1,7 +1,7 @@
 import type {
 	FamilyMetadata,
-	RegularAtomFamily,
 	RegularAtomFamilyOptions,
+	RegularAtomFamilyToken,
 	RegularAtomOptions,
 	RegularAtomToken,
 	StateCreation,
@@ -10,47 +10,57 @@ import type {
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import type { RegularAtomFamily } from ".."
 import { createRegularAtom } from "../atom"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createRegularAtomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): RegularAtomFamily<T, K> {
+	internalRoles?: string[],
+): RegularAtomFamilyToken<T, K> {
+	const familyToken = {
+		key: options.key,
+		type: `atom_family`,
+	} as const satisfies RegularAtomFamilyToken<T, K>
+
+	throwInCaseOfConflictingFamily(familyToken, store)
+
 	const subject = new Subject<
 		StateCreation<RegularAtomToken<T>> | StateDisposal<RegularAtomToken<T>>
 	>()
 
-	const atomFamily: RegularAtomFamily<T, K> = Object.assign(
-		(key: K): RegularAtomToken<any> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const target = newest(store)
-
-			const def = options.default
-			const individualOptions: RegularAtomOptions<T> = {
-				key: fullKey,
-				default: def instanceof Function ? def(key) : def,
-			}
-			if (options.effects) {
-				individualOptions.effects = options.effects(key)
-			}
-
-			const token = createRegularAtom(individualOptions, family, target)
-
-			subject.next({ type: `state_creation`, token })
-			return token
-		},
-		{
-			key: options.key,
-			type: `atom_family`,
-			subject,
-			install: (s: Store) => createRegularAtomFamily(options, s),
-		} as const,
-	) satisfies RegularAtomFamily<T, K>
+	const familyFunction = (key: K): RegularAtomToken<any> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: options.key, subKey }
+		const fullKey = `${options.key}(${subKey})`
+		const target = newest(store)
+
+		const def = options.default
+		const individualOptions: RegularAtomOptions<T> = {
+			key: fullKey,
+			default: def instanceof Function ? def(key) : def,
+		}
+		if (options.effects) {
+			individualOptions.effects = options.effects(key)
+		}
+
+		const token = createRegularAtom(individualOptions, family, target)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const atomFamily = Object.assign(familyFunction, familyToken, {
+		subject,
+		install: (s: Store) => createRegularAtomFamily(options, s),
+		internalRoles,
+	}) satisfies RegularAtomFamily<T, K>
+
 	store.families.set(options.key, atomFamily)
-	return atomFamily
+	store.defaults.set(options.key, options.default)
+	return familyToken
 }

package/internal/src/families/create-selector-family.ts

@@ -1,8 +1,9 @@
 import type {
-	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyOptions,
-	WritableSelectorFamily,
+	ReadonlySelectorFamilyToken,
+	SelectorFamilyToken,
 	WritableSelectorFamilyOptions,
+	WritableSelectorFamilyToken,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
@@ -13,17 +14,17 @@ import { createWritableSelectorFamily } from "./create-writable-selector-family"
 export function createSelectorFamily<T, K extends Canonical>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
-): WritableSelectorFamily<T, K>
+): WritableSelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
-): ReadonlySelectorFamily<T, K>
+): ReadonlySelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
 	options:
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
 	store: Store,
-): ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K> {
+): SelectorFamilyToken<T, K> {
 	const isWritable = `set` in options
 
 	if (isWritable) {

package/internal/src/families/create-writable-selector-family.ts

@@ -2,54 +2,80 @@ import type {
 	FamilyMetadata,
 	StateCreation,
 	StateDisposal,
-	WritableSelectorFamily,
 	WritableSelectorFamilyOptions,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 } from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { seekState } from "atom.io/immortal"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	seekInStore,
+	type WritableSelectorFamily,
+} from ".."
 import { newest } from "../lineage"
 import { createWritableSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createWritableSelectorFamily<T, K extends Canonical>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
-): WritableSelectorFamily<T, K> {
+	internalRoles?: string[],
+): WritableSelectorFamilyToken<T, K> {
+	const familyToken = {
+		key: options.key,
+		type: `selector_family`,
+	} as const satisfies WritableSelectorFamilyToken<T, K>
+
+	throwInCaseOfConflictingFamily(familyToken, store)
+
 	const subject = new Subject<
 		| StateCreation<WritableSelectorToken<T>>
 		| StateDisposal<WritableSelectorToken<T>>
 	>()
 
-	const selectorFamily = Object.assign(
-		(key: K): WritableSelectorToken<T> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const target = newest(store)
-
-			const token = createWritableSelector(
-				{
-					key: fullKey,
-					get: options.get(key),
-					set: options.set(key),
-				},
-				family,
-				target,
-			)
-
-			subject.next({ type: `state_creation`, token })
-			return token
+	const familyFunction = (key: K): WritableSelectorToken<T> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: options.key, subKey }
+		const fullKey = `${options.key}(${subKey})`
+		const target = newest(store)
+
+		const token = createWritableSelector(
+			{
+				key: fullKey,
+				get: options.get(key),
+				set: options.set(key),
+			},
+			family,
+			target,
+		)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const selectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s: Store) => createWritableSelectorFamily(options, s),
+		default: (key: K) => {
+			const getFn = options.get(key)
+			return getFn({
+				get: (...params: [any]) => getFromStore(...params, store), // TODO: make store zero-arg
+				find: ((token, k) => findInStore(token, k, store)) as typeof findState,
+				seek: ((token, k) => seekInStore(token, k, store)) as typeof seekState,
+				json: (token) => getJsonToken(token, store),
+			})
 		},
-		{
-			key: options.key,
-			type: `selector_family`,
-			subject,
-			install: (s: Store) => createWritableSelectorFamily(options, s),
-		} as const,
-	) satisfies WritableSelectorFamily<T, K>
+	}) satisfies WritableSelectorFamily<T, K>
+
 	store.families.set(options.key, selectorFamily)
-	return selectorFamily
+	return familyToken
 }

package/internal/src/families/dispose-from-store.ts

@@ -6,7 +6,7 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
 import { disposeMolecule } from "../molecule/dispose-molecule"
@@ -55,7 +55,16 @@ export function disposeFromStore(
 					? seekInStore(family, key, store)
 					: findInStore(family, key, store)
 		if (!maybeToken) {
-			throw new NotFoundError(family, key, store)
+			store.logger.error(
+				`❗`,
+				family.type,
+				family.key,
+				`tried to dispose of member`,
+				stringifyJson(key),
+				`but it was not found in store`,
+				store.config.name,
+			)
+			return
 		}
 		token = maybeToken
 	}

package/internal/src/families/seek-in-store.ts

@@ -109,9 +109,6 @@ export function seekInStore(
 			break
 		case `molecule_family`:
 			state = target.molecules.get(stringifyJson(key))
-			if (state) {
-				return deposit(state)
-			}
 	}
 	if (state) {
 		return deposit(state)

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

@@ -0,0 +1,18 @@
+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,
+			)}`,
+		)
+	}
+}

package/internal/src/get-state/get-from-store.ts

@@ -6,7 +6,7 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
 import { NotFoundError } from "../not-found-error"
@@ -56,7 +56,31 @@ export function getFromStore<T>(
 					? seekInStore(family, key, store)
 					: findInStore(family, key, store)
 		if (!maybeToken) {
-			throw new NotFoundError(family, key, store)
+			store.logger.error(
+				`❗`,
+				family.type,
+				family.key,
+				`tried to get member`,
+				stringifyJson(key),
+				`but it was not found in store`,
+				store.config.name,
+			)
+			switch (family.type) {
+				case `atom_family`:
+				case `mutable_atom_family`:
+					return store.defaults.get(family.key)
+				case `selector_family`:
+				case `readonly_selector_family`: {
+					if (store.defaults.has(family.key)) {
+						return store.defaults.get(family.key)
+					}
+					const defaultValue = withdraw(family, store).default(key)
+					store.defaults.set(family.key, defaultValue)
+					return defaultValue
+				}
+				case `molecule_family`:
+					throw new NotFoundError(family, key, store)
+			}
 		}
 		token = maybeToken
 	}

package/internal/src/get-state/read-or-compute-value.ts

@@ -10,7 +10,7 @@ export const readOrComputeValue = <T>(
 		target.logger.info(`📖`, state.type, state.key, `reading cached value`)
 		return readCachedValue(state, target)
 	}
-	if (state.type !== `atom` && state.type !== `mutable_atom`) {
+	if (state.type === `selector` || state.type === `readonly_selector`) {
 		target.logger.info(`🧮`, state.type, state.key, `computing value`)
 		return state.get()
 	}

package/internal/src/index.ts

@@ -1,5 +1,18 @@
-import type { FamilyMetadata } from "atom.io"
-import type { Json, JsonInterface } from "atom.io/json"
+import type {
+	AtomToken,
+	FamilyMetadata,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	StateCreation,
+	StateDisposal,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+} from "atom.io"
+import type { Canonical, Json, JsonInterface } from "atom.io/json"
 
 import type { Transceiver } from "./mutable"
 import type { Store } from "./store"
@@ -20,6 +33,7 @@ export * from "./molecule"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
+export * from "./pretty-print"
 export * from "./selector"
 export * from "./set-state"
 export * from "./store"
@@ -67,3 +81,65 @@ export type Selector<T> = ReadonlySelector<T> | WritableSelector<T>
 
 export type WritableState<T> = Atom<T> | WritableSelector<T>
 export type ReadableState<T> = Atom<T> | Selector<T>
+
+// biome-ignore format: intersection
+export type RegularAtomFamily<T, K extends Canonical> = 
+	& RegularAtomFamilyToken<T, K>
+	& {
+		(key: K): RegularAtomToken<T>
+		subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>
+		install: (store: Store) => void
+		internalRoles: string[] | undefined
+	}
+
+// biome-ignore format: intersection
+export type MutableAtomFamily<
+T extends Transceiver<any>,
+J extends Json.Serializable,
+K extends Canonical,
+> = 
+& JsonInterface<T, J>
+& MutableAtomFamilyToken<T, J, K>
+& {
+		(key: K): MutableAtomToken<T, J>
+		subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>
+		install: (store: Store) => void
+		internalRoles: string[] | undefined
+	}
+
+export type AtomFamily<T, K extends Canonical = Canonical> =
+	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
+	| RegularAtomFamily<T, K>
+
+// biome-ignore format: intersection
+export type WritableSelectorFamily<T, K extends Canonical> = 
+	& WritableSelectorFamilyToken<T, K> 
+	& ((key: K) => WritableSelectorToken<T>)
+	& {
+		default: (key: K) => T,
+		subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>
+		install: (store: Store) => void
+		internalRoles : string[] | undefined
+	}
+
+// biome-ignore format: intersection
+export type ReadonlySelectorFamily<T, K extends Canonical> = 
+	& ReadonlySelectorFamilyToken<T, K>
+	& ((key: K) => ReadonlySelectorToken<T>)
+	& {
+		default: (key: K) => T,
+		subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>
+		install: (store: Store) => void
+		internalRoles : string[] | undefined
+	}
+
+export type SelectorFamily<T, K extends Canonical> =
+	| ReadonlySelectorFamily<T, K>
+	| WritableSelectorFamily<T, K>
+
+export type WritableFamily<T, K extends Canonical> =
+	| AtomFamily<T, K>
+	| WritableSelectorFamily<T, K>
+export type ReadableFamily<T, K extends Canonical> =
+	| AtomFamily<T, K>
+	| SelectorFamily<T, K>

package/internal/src/ingest-updates/ingest-creation-disposal.ts

@@ -9,7 +9,6 @@ import { parseJson, stringifyJson } from "atom.io/json"
 
 import { disposeFromStore, initFamilyMemberInStore } from "../families"
 import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
-import { setIntoStore } from "../set-state"
 import { type Store, withdraw } from "../store"
 
 export function ingestCreationEvent(

package/internal/src/ingest-updates/ingest-selector-update.ts

@@ -10,7 +10,7 @@ export function ingestSelectorUpdate(
 	const updates =
 		applying === `newValue`
 			? selectorUpdate.atomUpdates
-			: [...selectorUpdate.atomUpdates].reverse()
+			: selectorUpdate.atomUpdates.toReversed()
 	for (const atomUpdate of updates) {
 		ingestAtomUpdate(applying, atomUpdate, store)
 	}

package/internal/src/molecule/dispose-molecule.ts

@@ -1,4 +1,3 @@
-import { stringifyJson } from "anvl/json"
 import type {
 	MoleculeConstructor,
 	MoleculeDisposal,