atom.io 0.27.2 → 0.27.4

package/internal/src/molecule/grow-molecule-in-store.ts

@@ -1,23 +1,33 @@
 import type {
-	AtomFamily,
+	AtomFamilyToken,
 	AtomToken,
-	MutableAtomFamily,
+	MutableAtomFamilyToken,
 	MutableAtomToken,
-	ReadableFamily,
+	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamily,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
-	RegularAtomFamily,
+	RegularAtomFamilyToken,
 	RegularAtomToken,
-	SelectorFamily,
+	SelectorFamilyToken,
 	SelectorToken,
-	WritableFamily,
-	WritableSelectorFamily,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
 
+import type {
+	AtomFamily,
+	MutableAtomFamily,
+	ReadableFamily,
+	ReadonlySelectorFamily,
+	RegularAtomFamily,
+	SelectorFamily,
+	WritableFamily,
+	WritableSelectorFamily,
+} from ".."
 import { initFamilyMemberInStore } from "../families"
 import type { Transceiver } from "../mutable"
 import type { Store } from "../store"
@@ -30,47 +40,47 @@ export function growMoleculeInStore<
 	K extends Canonical,
 >(
 	molecule: Molecule<any>,
-	family: MutableAtomFamily<T, J, K>,
+	family: MutableAtomFamilyToken<T, J, K>,
 	store: Store,
 ): MutableAtomToken<T, J>
 export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
-	family: RegularAtomFamily<T, K>,
+	family: RegularAtomFamilyToken<T, K>,
 	store: Store,
 ): RegularAtomToken<T>
 export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
-	family: AtomFamily<T, K>,
+	family: AtomFamilyToken<T, K>,
 	store: Store,
 ): AtomToken<T>
 export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
-	family: WritableSelectorFamily<T, K>,
+	family: WritableSelectorFamilyToken<T, K>,
 	store: Store,
 ): WritableSelectorToken<T>
 export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
-	family: ReadonlySelectorFamily<T, K>,
+	family: ReadonlySelectorFamilyToken<T, K>,
 	store: Store,
 ): ReadonlySelectorToken<T>
 export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
-	family: SelectorFamily<T, K>,
+	family: SelectorFamilyToken<T, K>,
 	store: Store,
 ): SelectorToken<T>
 export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
-	family: WritableFamily<T, K>,
+	family: WritableFamilyToken<T, K>,
 	store: Store,
 ): WritableToken<T>
 export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
-	family: ReadableFamily<T, K>,
+	family: ReadableFamilyToken<T, K>,
 	store: Store,
 ): ReadableToken<T>
 export function growMoleculeInStore(
 	molecule: Molecule<any>,
-	family: ReadableFamily<any, any>,
+	family: ReadableFamilyToken<any, any>,
 	store: Store,
 ): ReadableToken<any> {
 	const stateToken = initFamilyMemberInStore(family, molecule.key, store)

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

@@ -1,7 +1,7 @@
 import type {
 	FamilyMetadata,
-	MutableAtomFamily,
 	MutableAtomFamilyOptions,
+	MutableAtomFamilyToken,
 	MutableAtomOptions,
 	MutableAtomToken,
 	StateCreation,
@@ -10,6 +10,8 @@ import type {
 import type { Json } from "atom.io/json"
 import { selectJsonFamily, stringifyJson } from "atom.io/json"
 
+import type { MutableAtomFamily } from ".."
+import { throwInCaseOfConflictingFamily } from "../families/throw-in-case-of-conflicting-family"
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
@@ -24,45 +26,52 @@ export function createMutableAtomFamily<
 >(
 	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
-): MutableAtomFamily<T, J, K> {
+	internalRoles?: string[],
+): MutableAtomFamilyToken<T, J, K> {
+	const familyToken = {
+		key: options.key,
+		type: `mutable_atom_family`,
+	} as const satisfies MutableAtomFamilyToken<T, J, K>
+
+	throwInCaseOfConflictingFamily(familyToken, store)
+
 	const subject = new Subject<
 		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
 	>()
 
-	const atomFamily = Object.assign(
-		(key: K): MutableAtomToken<T, J> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const target = newest(store)
-
-			const individualOptions: MutableAtomOptions<T, J> = {
-				key: fullKey,
-				default: () => options.default(key),
-				toJson: options.toJson,
-				fromJson: options.fromJson,
-				mutable: true,
-			}
-			if (options.effects) {
-				individualOptions.effects = options.effects(key)
-			}
-
-			const token = createMutableAtom(individualOptions, family, target)
+	const familyFunction = (key: K): MutableAtomToken<T, J> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: options.key, subKey }
+		const fullKey = `${options.key}(${subKey})`
+		const target = newest(store)
 
-			subject.next({ type: `state_creation`, token })
-			return token
-		},
-		{
-			key: options.key,
-			type: `mutable_atom_family`,
-			subject,
-			install: (s: Store) => createMutableAtomFamily(options, s),
+		const individualOptions: MutableAtomOptions<T, J> = {
+			key: fullKey,
+			default: () => options.default(key),
 			toJson: options.toJson,
 			fromJson: options.fromJson,
-		} as const,
-	) satisfies MutableAtomFamily<T, J, K>
+			mutable: true,
+		}
+		if (options.effects) {
+			individualOptions.effects = options.effects(key)
+		}
+
+		const token = createMutableAtom(individualOptions, family, target)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const atomFamily = Object.assign(familyFunction, familyToken, {
+		subject,
+		install: (s: Store) => createMutableAtomFamily(options, s),
+		toJson: options.toJson,
+		fromJson: options.fromJson,
+		internalRoles,
+	}) satisfies MutableAtomFamily<T, J, K>
+
 	store.families.set(options.key, atomFamily)
 	selectJsonFamily(atomFamily, options, store)
 	new FamilyTracker(atomFamily, store)
-	return atomFamily
+	return familyToken
 }

package/internal/src/mutable/get-json-family.ts

@@ -1,6 +1,7 @@
-import type { MutableAtomFamilyToken, WritableSelectorFamily } from "atom.io"
+import type { MutableAtomFamilyToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
+import type { WritableSelectorFamily } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import type { Transceiver } from "./transceiver"

package/internal/src/mutable/get-update-family.ts

@@ -0,0 +1,23 @@
+import type { MutableAtomFamilyToken } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import type { AtomFamily } from ".."
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import type { Signal, Transceiver } from "./transceiver"
+
+export const getUpdateFamily = <
+	Core extends Transceiver<Json.Serializable>,
+	SerializableCore extends Json.Serializable,
+	Key extends string,
+>(
+	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
+	store: Store,
+): AtomFamily<Signal<Core>, Key> => {
+	const target = newest(store)
+	const key = `*${mutableAtomFamily.key}`
+	const updateFamily: AtomFamily<Signal<Core>, Key> = target.families.get(
+		key,
+	) as AtomFamily<Signal<Core>, Key>
+	return updateFamily
+}

package/internal/src/mutable/index.ts

@@ -2,6 +2,7 @@ export * from "./create-mutable-atom"
 export * from "./create-mutable-atom-family"
 export * from "./get-json-family"
 export * from "./get-json-token"
+export * from "./get-update-family"
 export * from "./get-update-token"
 export * from "./tracker"
 export * from "./tracker-family"

package/internal/src/mutable/tracker-family.ts

@@ -1,9 +1,9 @@
-import type { MutableAtomFamily, RegularAtomFamily } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
+import type { MutableAtomFamily, RegularAtomFamily } from ".."
 import { createRegularAtomFamily, seekInStore } from "../families"
-import type { Store } from "../store"
+import { type Store, withdraw } from "../store"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
@@ -25,7 +25,7 @@ export class FamilyTracker<
 		mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>,
 		store: Store,
 	) {
-		this.latestUpdateAtoms = createRegularAtomFamily<
+		const updateAtoms = createRegularAtomFamily<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(
@@ -34,7 +34,9 @@ export class FamilyTracker<
 				default: null,
 			},
 			store,
+			[`mutable`, `updates`],
 		)
+		this.latestUpdateAtoms = withdraw(updateAtoms, store)
 		this.mutableAtoms = mutableAtoms
 		this.mutableAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,

package/internal/src/not-found-error.ts

@@ -1,42 +1,9 @@
-import type {
-	MoleculeFamilyToken,
-	MoleculeToken,
-	ReadableFamilyToken,
-	ReadableToken,
-	TimelineToken,
-	TransactionToken,
-} from "atom.io"
 import { type Json, stringifyJson } from "atom.io/json"
 
+import type { AtomIOToken } from "./pretty-print"
+import { prettyPrintTokenType } from "./pretty-print"
 import type { Store } from "./store"
 
-const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
-
-type AtomIOToken =
-	| MoleculeFamilyToken<any>
-	| MoleculeToken<any>
-	| ReadableFamilyToken<any, any>
-	| ReadableToken<any>
-	| TimelineToken<any>
-	| TransactionToken<any>
-
-function prettyPrintTokenType(token: AtomIOToken) {
-	switch (token.type) {
-		case `atom_family`:
-			return `Atom Family`
-		case `molecule_family`:
-			return `Molecule Family`
-		case `readonly_selector`:
-			return `Readonly Selector`
-		case `readonly_selector_family`:
-			return `Readonly Selector Family`
-		case `selector_family`:
-			return `Selector Family`
-		default:
-			return capitalize(token.type)
-	}
-}
-
 export class NotFoundError extends Error {
 	public constructor(token: AtomIOToken, store: Store)
 	public constructor(

package/internal/src/pretty-print.ts

@@ -0,0 +1,37 @@
+import type {
+	MoleculeFamilyToken,
+	MoleculeToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	TimelineToken,
+	TransactionToken,
+} from "atom.io"
+
+const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
+
+export type AtomIOToken =
+	| MoleculeFamilyToken<any>
+	| MoleculeToken<any>
+	| ReadableFamilyToken<any, any>
+	| ReadableToken<any>
+	| TimelineToken<any>
+	| TransactionToken<any>
+
+export function prettyPrintTokenType(token: AtomIOToken): string {
+	switch (token.type) {
+		case `atom_family`:
+			return `Atom Family`
+		case `molecule_family`:
+			return `Molecule Family`
+		case `mutable_atom_family`:
+			return `Mutable Atom Family`
+		case `readonly_selector`:
+			return `Readonly Selector`
+		case `readonly_selector_family`:
+			return `Readonly Selector Family`
+		case `selector_family`:
+			return `Selector Family`
+		default:
+			return capitalize(token.type)
+	}
+}

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

@@ -22,12 +22,12 @@ export const createWritableSelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
-	const toolkit = registerSelector(options.key, covered, target)
-	const { find, get, seek, json } = toolkit
+	const setterToolkit = registerSelector(options.key, covered, target)
+	const { find, get, seek, json } = setterToolkit
 	const getterToolkit = { find, get, seek, json }
 
-	const getSelf = (innerTarget = newest(store)): T => {
-		const value = options.get(getterToolkit)
+	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
+		const value = getFn(getterToolkit)
 		cacheValue(options.key, value, subject, innerTarget)
 		covered.clear()
 		return value
@@ -35,7 +35,7 @@ export const createWritableSelector = <T>(
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
 		const innerTarget = newest(store)
-		const oldValue = getSelf(innerTarget)
+		const oldValue = getSelf(options.get, innerTarget)
 		const newValue = become(next)(oldValue)
 		store.logger.info(
 			`📝`,
@@ -52,7 +52,7 @@ export const createWritableSelector = <T>(
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })
 		}
-		options.set(toolkit, newValue)
+		options.set(setterToolkit, newValue)
 	}
 	const mySelector: WritableSelector<T> = {
 		...options,

package/internal/src/set-state/set-into-store.ts

@@ -1,5 +1,5 @@
 import type { WritableFamilyToken, WritableToken } 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"
@@ -52,7 +52,18 @@ export function setIntoStore<T, New extends T>(
 				? findInStore(family, key, store)
 				: seekInStore(family, key, store)
 		if (!maybeToken) {
-			throw new NotFoundError(family, key, store)
+			store.logger.error(
+				`❗`,
+				family.type,
+				family.key,
+				`tried to set member`,
+				stringifyJson(key),
+				`to`,
+				value,
+				`but it was not found in store`,
+				store.config.name,
+			)
+			return
 		}
 		token = maybeToken
 	}

package/internal/src/store/deposit.ts

@@ -1,5 +1,6 @@
 import type {
 	AtomToken,
+	MoleculeConstructor,
 	MoleculeFamily,
 	MoleculeFamilyToken,
 	MoleculeToken,
@@ -38,20 +39,20 @@ export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
 export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
-export function deposit<
-	K extends Canonical,
-	S extends { [key: string]: any },
-	P extends any[],
->(state: Molecule<any>): MoleculeToken<any>
-export function deposit<
-	K extends Canonical,
-	S extends { [key: string]: any },
-	P extends any[],
->(state: MoleculeFamily<any>): MoleculeFamilyToken<any>
+export function deposit<M extends MoleculeConstructor>(
+	state: MoleculeFamily<M>,
+): MoleculeFamilyToken<M>
+export function deposit<M extends MoleculeConstructor>(
+	state: Molecule<M>,
+): MoleculeToken<M>
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
 export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
+export function deposit(
+	state: Molecule<any> | ReadableState<any>,
+): MoleculeToken<any> | ReadableToken<any>
+
 export function deposit<T>(
 	state:
 		| Molecule<any>

package/internal/src/store/store.ts

@@ -3,13 +3,9 @@ import type {
 	Logger,
 	MoleculeFamily,
 	MoleculeToken,
-	MutableAtomFamily,
-	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
-	RegularAtomFamily,
 	TimelineToken,
 	TransactionToken,
-	WritableSelectorFamily,
 	WritableSelectorToken,
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
@@ -20,10 +16,14 @@ import type {
 	Atom,
 	Func,
 	Molecule,
+	MutableAtomFamily,
 	ReadonlySelector,
+	ReadonlySelectorFamily,
+	RegularAtomFamily,
 	Tracker,
 	Transceiver,
 	WritableSelector,
+	WritableSelectorFamily,
 } from ".."
 import type { Lineage } from "../lineage"
 import { getJsonToken, getUpdateToken } from "../mutable"
@@ -42,6 +42,7 @@ export class Store implements Lineage {
 	public child: Store | null = null
 
 	public valueMap = new Map<string, any>()
+	public defaults = new Map<string, any>()
 
 	public atoms = new Map<string, Atom<any>>()
 	public selectors = new Map<string, WritableSelector<any>>()
@@ -160,6 +161,12 @@ export class Store implements Lineage {
 			}
 
 			for (const [, family] of store.families) {
+				if (
+					family.internalRoles?.includes(`mutable`) ||
+					family.internalRoles?.includes(`join`)
+				) {
+					continue
+				}
 				family.install(this)
 			}
 			const mutableHelpers = new Set<string>()

package/internal/src/store/withdraw.ts

@@ -1,32 +1,24 @@
 import type {
-	AtomFamily,
 	AtomFamilyToken,
 	AtomToken,
 	MoleculeConstructor,
 	MoleculeFamily,
 	MoleculeFamilyToken,
 	MoleculeToken,
-	MutableAtomFamily,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
-	ReadableFamily,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
-	RegularAtomFamily,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
-	SelectorFamily,
 	SelectorFamilyToken,
 	SelectorToken,
 	TimelineManageable,
 	TimelineToken,
 	TransactionToken,
-	WritableFamily,
 	WritableFamilyToken,
-	WritableSelectorFamily,
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
@@ -36,15 +28,23 @@ import { stringifyJson } from "atom.io/json"
 
 import type {
 	Atom,
+	AtomFamily,
 	Func,
 	Molecule,
 	MutableAtom,
+	MutableAtomFamily,
+	ReadableFamily,
 	ReadableState,
 	ReadonlySelector,
+	ReadonlySelectorFamily,
 	RegularAtom,
+	RegularAtomFamily,
 	Selector,
+	SelectorFamily,
 	Transceiver,
+	WritableFamily,
 	WritableSelector,
+	WritableSelectorFamily,
 	WritableState,
 } from ".."
 import { NotFoundError } from ".."

package/internal/src/transaction/build-transaction.ts

@@ -48,6 +48,7 @@ export const buildTransaction = (
 		}),
 		selectors: new LazyMap(parent.selectors),
 		valueMap: new LazyMap(parent.valueMap),
+		defaults: parent.defaults,
 		molecules: new LazyMap(parent.molecules),
 		moleculeFamilies: new LazyMap(parent.moleculeFamilies),
 		moleculeInProgress: parent.moleculeInProgress,

package/introspection/dist/index.js

@@ -204,7 +204,7 @@ var attachTimelineFamily = (store = IMPLICIT.STORE) => {
   const findTimelineLogState = createSelectorFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log`,
-      get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL(key))
+      get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL, key)
     },
     store
   );
@@ -271,7 +271,7 @@ var attachTransactionIndex = (store = IMPLICIT.STORE) => {
   return transactionTokenIndex;
 };
 var attachTransactionLogs = (store = IMPLICIT.STORE) => {
-  const findTransactionUpdateLog = createRegularAtomFamily(
+  const transactionUpdateLogAtoms = createRegularAtomFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log (Internal)`,
       default: () => [],
@@ -291,7 +291,7 @@ var attachTransactionLogs = (store = IMPLICIT.STORE) => {
   const findTransactionUpdateLogState = createSelectorFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log`,
-      get: (key) => ({ get }) => get(findTransactionUpdateLog(key))
+      get: (key) => ({ get }) => get(transactionUpdateLogAtoms, key)
     },
     store
   );

package/introspection/src/attach-timeline-family.ts

@@ -46,7 +46,7 @@ export const attachTimelineFamily = (
 			get:
 				(key) =>
 				({ get }) =>
-					get(findTimelineLogState__INTERNAL(key)),
+					get(findTimelineLogState__INTERNAL, key),
 		},
 		store,
 	)

package/introspection/src/attach-transaction-logs.ts

@@ -9,7 +9,7 @@ import {
 export const attachTransactionLogs = (
 	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string> => {
-	const findTransactionUpdateLog = createRegularAtomFamily<
+	const transactionUpdateLogAtoms = createRegularAtomFamily<
 		TransactionUpdate<Func>[],
 		string
 	>(
@@ -38,7 +38,7 @@ export const attachTransactionLogs = (
 			get:
 				(key) =>
 				({ get }) =>
-					get(findTransactionUpdateLog(key)),
+					get(transactionUpdateLogAtoms, key),
 		},
 		store,
 	)

package/json/dist/index.d.ts

@@ -38,8 +38,8 @@ declare function fromEntries<E extends Entries>(entries: E): FromEntries<E>;
 
 declare const selectJson: <T, J extends Serializable>(atom: AtomIO.AtomToken<T>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.WritableSelectorToken<J>;
 
-declare function selectJsonFamily<T extends Transceiver<any>, J extends Serializable, K extends Canonical>(atomFamily: AtomIO.MutableAtomFamily<T, J, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
-declare function selectJsonFamily<T, J extends Serializable, K extends Canonical>(atomFamily: AtomIO.RegularAtomFamily<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
+declare function selectJsonFamily<T extends Transceiver<any>, J extends Serializable, K extends Canonical>(atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
+declare function selectJsonFamily<T, J extends Serializable, K extends Canonical>(atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
 
 type Canonical = primitive | ReadonlyArray<Canonical>;
 type JsonIO = (...params: Serializable[]) => Serializable | void;