atom.io 0.27.3 → 0.27.5

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

@@ -1,24 +1,33 @@
 import type {
 	FamilyMetadata,
+	getState,
 	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 type { ReadonlySelectorFamily } from ".."
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	prettyPrintTokenType,
+	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,
+	options: ReadonlySelectorFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): ReadonlySelectorFamilyToken<T, K> {
 	const familyToken = {
@@ -26,7 +35,17 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 		type: `readonly_selector_family`,
 	} as const satisfies ReadonlySelectorFamilyToken<T, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`readonly_selector_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 
 	const subject = new Subject<
 		| StateCreation<ReadonlySelectorToken<T>>
@@ -40,12 +59,12 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 		const target = newest(store)
 
 		const token = createReadonlySelector(
+			target,
 			{
 				key: fullKey,
 				get: options.get(key),
 			},
 			family,
-			target,
 		)
 
 		subject.next({ type: `state_creation`, token })
@@ -53,9 +72,18 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 	}
 
 	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
-		subject,
-		install: (s: Store) => createReadonlySelectorFamily(options, s),
 		internalRoles,
+		subject,
+		install: (s: Store) => createReadonlySelectorFamily(s, options),
+		default: (key: K) => {
+			const getFn = options.get(key)
+			return getFn({
+				get: ((...ps: [any]) => getFromStore(store, ...ps)) as typeof getState,
+				find: ((token, k) => findInStore(store, token, k)) as typeof findState,
+				seek: ((token, k) => seekInStore(store, token, k)) as typeof seekState,
+				json: (token) => getJsonToken(store, token),
+			})
+		},
 	}) satisfies ReadonlySelectorFamily<T, K>
 
 	store.families.set(options.key, readonlySelectorFamily)

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

@@ -10,16 +10,15 @@ import type {
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { RegularAtomFamily } from ".."
+import { prettyPrintTokenType, 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,
+	options: RegularAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): RegularAtomFamilyToken<T, K> {
 	const familyToken = {
@@ -27,7 +26,17 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 		type: `atom_family`,
 	} as const satisfies RegularAtomFamilyToken<T, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`atom_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 
 	const subject = new Subject<
 		StateCreation<RegularAtomToken<T>> | StateDisposal<RegularAtomToken<T>>
@@ -48,7 +57,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 			individualOptions.effects = options.effects(key)
 		}
 
-		const token = createRegularAtom(individualOptions, family, target)
+		const token = createRegularAtom(target, individualOptions, family)
 
 		subject.next({ type: `state_creation`, token })
 		return token
@@ -56,10 +65,11 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		subject,
-		install: (s: Store) => createRegularAtomFamily(options, s),
+		install: (s: Store) => createRegularAtomFamily(s, options),
 		internalRoles,
 	}) satisfies RegularAtomFamily<T, K>
 
 	store.families.set(options.key, atomFamily)
+	store.defaults.set(options.key, options.default)
 	return familyToken
 }

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

@@ -12,23 +12,23 @@ import { createReadonlySelectorFamily } from "./create-readonly-selector-family"
 import { createWritableSelectorFamily } from "./create-writable-selector-family"
 
 export function createSelectorFamily<T, K extends Canonical>(
-	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
+	options: WritableSelectorFamilyOptions<T, K>,
 ): WritableSelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
-	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
+	options: ReadonlySelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
+	store: Store,
 	options:
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
-	store: Store,
 ): SelectorFamilyToken<T, K> {
 	const isWritable = `set` in options
 
 	if (isWritable) {
-		return createWritableSelectorFamily(options, store)
+		return createWritableSelectorFamily(store, options)
 	}
-	return createReadonlySelectorFamily(options, store)
+	return createReadonlySelectorFamily(store, options)
 }

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

@@ -1,24 +1,33 @@
 import type {
 	FamilyMetadata,
+	getState,
 	StateCreation,
 	StateDisposal,
 	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 type { WritableSelectorFamily } from ".."
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	prettyPrintTokenType,
+	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,
+	options: WritableSelectorFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): WritableSelectorFamilyToken<T, K> {
 	const familyToken = {
@@ -26,8 +35,17 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 		type: `selector_family`,
 	} as const satisfies WritableSelectorFamilyToken<T, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
-
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`selector_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 	const subject = new Subject<
 		| StateCreation<WritableSelectorToken<T>>
 		| StateDisposal<WritableSelectorToken<T>>
@@ -40,13 +58,13 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 		const target = newest(store)
 
 		const token = createWritableSelector(
+			target,
 			{
 				key: fullKey,
 				get: options.get(key),
 				set: options.set(key),
 			},
 			family,
-			target,
 		)
 
 		subject.next({ type: `state_creation`, token })
@@ -54,9 +72,18 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 	}
 
 	const selectorFamily = Object.assign(familyFunction, familyToken, {
-		subject,
-		install: (s: Store) => createWritableSelectorFamily(options, s),
 		internalRoles,
+		subject,
+		install: (s: Store) => createWritableSelectorFamily(s, options),
+		default: (key: K) => {
+			const getFn = options.get(key)
+			return getFn({
+				get: ((...ps: [any]) => getFromStore(store, ...ps)) as typeof getState,
+				find: ((token, k) => findInStore(store, token, k)) as typeof findState,
+				seek: ((token, k) => seekInStore(store, token, k)) as typeof seekState,
+				json: (token) => getJsonToken(store, token),
+			})
+		},
 	}) satisfies WritableSelectorFamily<T, K>
 
 	store.families.set(options.key, selectorFamily)

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

@@ -6,56 +6,62 @@ 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"
-import { NotFoundError } from "../not-found-error"
 import { disposeSelector } from "../selector"
 import type { Store } from "../store"
 import { findInStore } from "./find-in-store"
 import { seekInStore } from "./seek-in-store"
 
 export function disposeFromStore(
-	token: MoleculeToken<any> | ReadableToken<any>,
 	store: Store,
+	token: MoleculeToken<any> | ReadableToken<any>,
 ): void
 
 export function disposeFromStore<K extends Canonical>(
+	store: Store,
 	token: ReadableFamilyToken<any, K>,
 	key: K,
-	store: Store,
 ): void
 
 export function disposeFromStore<M extends MoleculeConstructor>(
+	store: Store,
 	token: MoleculeFamilyToken<M>,
 	key: MoleculeKey<M>,
-	store: Store,
 ): void
 
 export function disposeFromStore(
+	store: Store,
 	...params:
-		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
-		| [token: MoleculeToken<any> | ReadableToken<any>, store: Store]
-		| [token: ReadableFamilyToken<any, any>, key: Canonical, store: Store]
+		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>]
+		| [token: MoleculeToken<any> | ReadableToken<any>]
+		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 ): void {
 	let token: MoleculeToken<any> | ReadableToken<any>
-	let store: Store
-	if (params.length === 2) {
+	if (params.length === 1) {
 		token = params[0]
-		store = params[1]
 	} else {
 		const family = params[0]
 		const key = params[1]
-		store = params[2]
 		const maybeToken =
 			family.type === `molecule_family`
-				? seekInStore(family, key, store)
+				? seekInStore(store, family, key)
 				: store.config.lifespan === `immortal`
-					? seekInStore(family, key, store)
-					: findInStore(family, key, store)
+					? seekInStore(store, family, key)
+					: findInStore(store, family, key)
 		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/find-in-store.ts

@@ -29,67 +29,67 @@ export function findInStore<
 	K extends Canonical,
 	Key extends K,
 >(
+	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-	store: Store,
 ): MutableAtomToken<T, J>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): RegularAtomToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): AtomToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableSelectorToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadonlySelectorToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): SelectorToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadableToken<T>
 
 export function findInStore(
+	store: Store,
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
-	store: Store,
 ): ReadableToken<any> {
 	if (store.config.lifespan === `immortal`) {
 		throw new Error(
 			`Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`,
 		)
 	}
-	let state = seekInStore(token, key, store)
+	let state = seekInStore(store, token, key)
 	if (state) {
 		return state
 	}
-	state = initFamilyMemberInStore(token, key, store)
+	state = initFamilyMemberInStore(store, token, key)
 	return state
 }

package/internal/src/families/init-family-member.ts

@@ -30,57 +30,57 @@ export function initFamilyMemberInStore<
 	K extends Canonical,
 	Key extends K,
 >(
+	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-	store: Store,
 ): MutableAtomToken<T, J>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): RegularAtomToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): AtomToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableSelectorToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadonlySelectorToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): SelectorToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadableToken<T>
 
 export function initFamilyMemberInStore(
+	store: Store,
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
-	store: Store,
 ): ReadableToken<any> {
 	const familyKey = token.key
 	const family = store.families.get(familyKey)

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

@@ -34,63 +34,63 @@ export function seekInStore<
 	K extends Canonical,
 	Key extends K,
 >(
+	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-	store: Store,
 ): MutableAtomToken<T, J> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): RegularAtomToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): AtomToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableSelectorToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadonlySelectorToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): SelectorToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadableToken<T> | undefined
 
 export function seekInStore<M extends MoleculeConstructor>(
+	store: Store,
 	token: MoleculeFamilyToken<M>,
 	key: MoleculeKey<M>,
-	store: Store,
 ): MoleculeKey<M> | undefined
 
 export function seekInStore(
+	store: Store,
 	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
 	key: Canonical,
-	store: Store,
 ): MoleculeToken<any> | ReadableToken<any> | undefined {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
@@ -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/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"
@@ -14,49 +14,87 @@ import type { Store } from "../store"
 import { withdraw } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
-export function getFromStore<T>(token: ReadableToken<T>, store: Store): T
+export function getFromStore<T>(store: Store, token: ReadableToken<T>): T
 
 export function getFromStore<M extends MoleculeConstructor>(
-	token: MoleculeToken<M>,
 	store: Store,
-): InstanceType<M> | undefined
+	token: MoleculeToken<M>,
+): InstanceType<M>
 
 export function getFromStore<T, K extends Canonical>(
+	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: K,
-	store: Store,
 ): T
 
 export function getFromStore<M extends MoleculeConstructor>(
+	store: Store,
 	token: MoleculeFamilyToken<M>,
 	key: MoleculeKey<M>,
-	store: Store,
 ): InstanceType<M>
 
-export function getFromStore<T>(
+export function getFromStore(
+	store: Store,
+	token: MoleculeToken<any> | ReadableToken<any>,
+): any
+
+export function getFromStore(
+	store: Store,
+	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+	key: Canonical,
+): any
+
+export function getFromStore(
+	store: Store,
 	...params:
-		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
-		| [token: MoleculeToken<any>, store: Store]
-		| [token: ReadableFamilyToken<T, any>, key: Canonical, store: Store]
-		| [token: ReadableToken<T>, store: Store]
+		| [
+				token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+				key: Canonical,
+		  ]
+		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>]
+		| [token: MoleculeToken<any> | ReadableToken<any>]
+		| [token: MoleculeToken<any>]
+		| [token: ReadableFamilyToken<any, any>, key: Canonical]
+		| [token: ReadableToken<any>]
 ): any {
-	let token: MoleculeToken<any> | ReadableToken<T>
-	let store: Store
-	if (params.length === 2) {
+	let token: MoleculeToken<any> | ReadableToken<any>
+	if (params.length === 1) {
 		token = params[0]
-		store = params[1]
 	} else {
 		const family = params[0]
 		const key = params[1]
-		store = params[2]
 		const maybeToken =
 			family.type === `molecule_family`
-				? seekInStore(family, key, store)
+				? seekInStore(store, family, key)
 				: store.config.lifespan === `immortal`
-					? seekInStore(family, key, store)
-					: findInStore(family, key, store)
+					? seekInStore(store, family, key)
+					: findInStore(store, family, key)
 		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
 	}