atom.io 0.34.2 → 0.36.0

package/src/internal/atom/index.ts

@@ -1,3 +1,2 @@
 export * from "./create-regular-atom"
-export * from "./create-standalone-atom"
 export * from "./dispose-atom"

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

@@ -16,7 +16,7 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import { type Canonical, type Json, stringifyJson } from "atom.io/json"
+import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
@@ -25,15 +25,14 @@ import { initFamilyMemberInStore } from "./init-family-member"
 import { seekInStore } from "./seek-in-store"
 
 export function findInStore<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
 >(
 	store: Store,
-	token: MutableAtomFamilyToken<T, J, K>,
+	token: MutableAtomFamilyToken<T, K>,
 	key: Key,
-): MutableAtomToken<T, J, K>
+): MutableAtomToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,

package/src/internal/families/get-family-of-token.ts

@@ -12,19 +12,18 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
 import type { Store } from "../store"
 
 export function getFamilyOfToken<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 >(
 	store: Store,
-	token: MutableAtomToken<T, J, K>,
-): MutableAtomFamilyToken<T, J, K> | undefined
+	token: MutableAtomToken<T, K>,
+): MutableAtomFamilyToken<T, K> | undefined
 
 export function getFamilyOfToken<T, K extends Canonical>(
 	store: Store,

package/src/internal/families/index.ts

@@ -1,4 +1,3 @@
-export * from "./create-atom-family"
 export * from "./create-readonly-pure-selector-family"
 export * from "./create-readonly-pure-selector-family"
 export * from "./create-regular-atom-family"

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

@@ -25,15 +25,14 @@ import type { Store } from "../store"
 import { isChildStore, isRootStore } from "../transaction"
 
 export function initFamilyMemberInStore<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
 >(
 	store: Store,
-	token: MutableAtomFamilyToken<T, J, K>,
+	token: MutableAtomFamilyToken<T, K>,
 	key: Key,
-): MutableAtomToken<T, J, K>
+): MutableAtomToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,

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

@@ -16,7 +16,7 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { Molecule, ReadableState } from ".."
@@ -25,15 +25,14 @@ import type { Transceiver } from "../mutable"
 import { deposit, type Store } from "../store"
 
 export function seekInStore<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
 >(
 	store: Store,
-	token: MutableAtomFamilyToken<T, J, K>,
+	token: MutableAtomFamilyToken<T, K>,
 	key: Key,
-): MutableAtomToken<T, J, K> | undefined
+): MutableAtomToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,

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

@@ -16,8 +16,7 @@ export const readOrComputeValue = <T>(
 		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, state.key, `computing value`)
 			return state.get()
-		case `atom`:
-		case `mutable_atom`: {
+		case `atom`: {
 			const def = state.default
 			let defaultValue: T
 			if (def instanceof Function) {
@@ -40,5 +39,18 @@ export const readOrComputeValue = <T>(
 			)
 			return cachedValue
 		}
+		case `mutable_atom`: {
+			const Ctor = state.class
+			const instance = new Ctor()
+			const cachedValue = cacheValue(target, state.key, instance, state.subject)
+			target.logger.info(
+				`💁`,
+				`mutable_atom`,
+				state.key,
+				`could not find cached value; using default`,
+				instance,
+			)
+			return cachedValue
+		}
 	}
 }

package/src/internal/index.ts

@@ -16,13 +16,14 @@ import type {
 	WritablePureSelectorFamilyToken,
 	WritablePureSelectorToken,
 } from "atom.io"
-import type { Canonical, Json, JsonInterface } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
-import type { Transceiver } from "./mutable"
+import type { ConstructorOf, Transceiver } from "./mutable"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
 import type { Timeline } from "./timeline"
 import type { Transaction } from "./transaction"
+import type { Flat } from "./utility-types"
 
 export * from "./arbitrary"
 export * from "./atom"
@@ -61,45 +62,52 @@ export type AtomIOState = {
 	install: (store: Store) => void
 	subject: Subject<{ newValue: any; oldValue: any }>
 }
-
-export type RegularAtom<T> = AtomIOState & {
-	type: `atom`
-	default: T | (() => T)
-	cleanup?: () => void
-}
-export type MutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-> = AtomIOState &
-	JsonInterface<T, J> & {
+export type RegularAtom<T> = Flat<
+	AtomIOState & {
+		type: `atom`
+		default: T | (() => T)
+		cleanup?: () => void
+	}
+>
+export type MutableAtom<T extends Transceiver<any, any>> = Flat<
+	AtomIOState & {
 		type: `mutable_atom`
-		default: () => T
+		class: ConstructorOf<T>
 		cleanup?: () => void
 	}
+>
 export type Atom<T> =
 	| RegularAtom<T>
-	| (T extends Transceiver<any> ? MutableAtom<T, any> : never)
+	| (T extends Transceiver<any, any> ? MutableAtom<T> : never)
 
-export type WritableHeldSelector<T> = AtomIOState & {
-	type: `writable_held_selector`
-	const: T
-	get: () => T
-	set: (newValue: T | ((oldValue: T) => T)) => void
-}
-export type ReadonlyHeldSelector<T> = AtomIOState & {
-	type: `readonly_held_selector`
-	const: T
-	get: () => T
-}
-export type WritablePureSelector<T> = AtomIOState & {
-	type: `writable_pure_selector`
-	get: () => T
-	set: (newValue: T | ((oldValue: T) => T)) => void
-}
-export type ReadonlyPureSelector<T> = AtomIOState & {
-	type: `readonly_pure_selector`
-	get: () => T
-}
+export type WritableHeldSelector<T> = Flat<
+	AtomIOState & {
+		type: `writable_held_selector`
+		const: T
+		get: () => T
+		set: (newValue: T | ((oldValue: T) => T)) => void
+	}
+>
+export type ReadonlyHeldSelector<T> = Flat<
+	AtomIOState & {
+		type: `readonly_held_selector`
+		const: T
+		get: () => T
+	}
+>
+export type WritablePureSelector<T> = Flat<
+	AtomIOState & {
+		type: `writable_pure_selector`
+		get: () => T
+		set: (newValue: T | ((oldValue: T) => T)) => void
+	}
+>
+export type ReadonlyPureSelector<T> = Flat<
+	AtomIOState & {
+		type: `readonly_pure_selector`
+		get: () => T
+	}
+>
 export type ReadonlySelector<T> =
 	| ReadonlyHeldSelector<T>
 	| ReadonlyPureSelector<T>
@@ -118,89 +126,101 @@ 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> = 
+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
+		subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>
 	}
 
 // 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
-		}
+	// C extends TransceiverConstructor<any,any>,
+	T extends Transceiver<any,any>,
+	K extends Canonical,
+> =
+	& Flat<
+		& MutableAtomFamilyToken<T, K>
+		& {
+				install: (store: Store) => void
+				internalRoles: string[] | undefined
+				subject: Subject<
+					| StateCreation<MutableAtomToken<T>>
+					| StateDisposal<MutableAtomToken<T>>
+				>
+			}
+	>
+	& ((key: K) => MutableAtomToken<T>)
 
 export type AtomFamily<T, K extends Canonical = Canonical> =
-	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
+	| MutableAtomFamily<T extends Transceiver<any, any> ? T : never, K>
 	| RegularAtomFamily<T, K>
 
 // biome-ignore format: intersection
-export type WritablePureSelectorFamily<T, K extends Canonical> = 
-	& WritablePureSelectorFamilyToken<T, K> 
-	& ((key: K) => WritablePureSelectorToken<T>)
-	& {
-		default: (key: K) => T,
-		subject: Subject<
-			| StateCreation<WritablePureSelectorToken<T>>
-			| StateDisposal<WritablePureSelectorToken<T>>
-		>
-		install: (store: Store) => void
-		internalRoles : string[] | undefined
-	}
+export type WritablePureSelectorFamily<T, K extends Canonical> =
+	& Flat<
+		& WritablePureSelectorFamilyToken<T, K>
+		& {
+			default: (key: K) => T,
+			install: (store: Store) => void
+			internalRoles: string[] | undefined
+			subject: Subject<
+				| StateCreation<WritablePureSelectorToken<T>>
+				| StateDisposal<WritablePureSelectorToken<T>>
+			>
+		}
+	>
+  & ((key: K) => WritablePureSelectorToken<T>)
 
 // biome-ignore format: intersection
-export type WritableHeldSelectorFamily<T , K extends Canonical> = 
-	& WritableHeldSelectorFamilyToken<T, K> 
-	& ((key: K) => WritableHeldSelectorToken<T>)
-	& {
-		default: (key: K) => T,
-		subject: Subject<
-			| StateCreation<WritableHeldSelectorToken<T>>
-			| StateDisposal<WritableHeldSelectorToken<T>>
-		>
-		install: (store: Store) => void
-		internalRoles : string[] | undefined
-	}
+export type WritableHeldSelectorFamily<T , K extends Canonical> =
+	& Flat<
+		& WritableHeldSelectorFamilyToken<T, K>
+		& {
+			default: (key: K) => T,
+			install: (store: Store) => void
+			internalRoles: string[] | undefined
+			subject: Subject<
+				| StateCreation<WritableHeldSelectorToken<T>>
+				| StateDisposal<WritableHeldSelectorToken<T>>
+			>
+		}
+	>
+  & ((key: K) => WritableHeldSelectorToken<T>)
 
 // biome-ignore format: intersection
-export type ReadonlyPureSelectorFamily<T, K extends Canonical> = 
-	& ReadonlyPureSelectorFamilyToken<T, K>
+export type ReadonlyPureSelectorFamily<T, K extends Canonical> =
+	& Flat<
+		& ReadonlyPureSelectorFamilyToken<T, K>
+		& {
+			default: (key: K) => T,
+			install: (store: Store) => void
+			internalRoles: string[] | undefined
+			subject: Subject<
+				| StateCreation<ReadonlyPureSelectorToken<T>>
+				| StateDisposal<ReadonlyPureSelectorToken<T>>
+			>
+		}
+	>
 	& ((key: K) => ReadonlyPureSelectorToken<T>)
-	& {
-		default: (key: K) => T,
-		subject: Subject<
-			| StateCreation<ReadonlyPureSelectorToken<T>>
-			| StateDisposal<ReadonlyPureSelectorToken<T>>
-		>
-		install: (store: Store) => void
-		internalRoles : string[] | undefined
-	}
 
 // biome-ignore format: intersection
-export type ReadonlyHeldSelectorFamily<T , K extends Canonical> = 
-	& ReadonlyHeldSelectorFamilyToken<T, K>
+export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
+	& Flat<
+		& ReadonlyHeldSelectorFamilyToken<T, K>
+		& {
+			default: (key: K) => T,
+			install: (store: Store) => void
+			internalRoles: string[] | undefined
+			subject: Subject<
+				| StateCreation<ReadonlyHeldSelectorToken<T>>
+				| StateDisposal<ReadonlyHeldSelectorToken<T>>
+			>
+		}
+	>
 	& ((key: K) => ReadonlyHeldSelectorToken<T>)
-	& {
-		default: (key: K) => T,
-		subject: Subject<
-			| StateCreation<ReadonlyHeldSelectorToken<T>> 
-			| StateDisposal<ReadonlyHeldSelectorToken<T>>
-		>
-		install: (store: Store) => void
-		internalRoles : string[] | undefined
-	}
 
 export type PureSelectorFamily<T, K extends Canonical> =
 	| ReadonlyPureSelectorFamily<T, K>

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

@@ -115,25 +115,28 @@ export function ingestMoleculeTransferEvent(
 	switch (applying) {
 		case `newValue`:
 			{
-				const provenance = update.to.length === 1 ? update.to[0] : update.to
-				claimWithinStore<any, any, any>(
-					store,
-					provenance,
-					update.key,
-					`exclusive`,
-				)
+				for (const newOwner of update.to) {
+					claimWithinStore<any, any, any>(
+						store,
+						newOwner,
+						update.key,
+						update.exclusive ? `exclusive` : undefined,
+					)
+				}
 			}
 			break
 		case `oldValue`:
 			{
-				const provenance =
-					update.from.length === 1 ? update.from[0] : update.from
-				claimWithinStore<any, any, any>(
-					store,
-					provenance,
-					update.key,
-					`exclusive`,
-				)
+				let exclusivity: `exclusive` | undefined = `exclusive`
+				for (const previousOwner of update.from) {
+					claimWithinStore<any, any, any>(
+						store,
+						previousOwner,
+						update.key,
+						exclusivity,
+					)
+					exclusivity = undefined
+				}
 			}
 			break
 	}

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

@@ -1,5 +1,7 @@
+import type { TimelineManageable } from "atom.io"
+
 import type { Store } from "../store"
-import type { TimelineSelectorUpdate } from "../timeline"
+import type { TimelineAtomUpdate, TimelineSelectorUpdate } from "../timeline"
 import { ingestAtomUpdate } from "./ingest-atom-update"
 
 export function ingestSelectorUpdate(
@@ -7,10 +9,12 @@ export function ingestSelectorUpdate(
 	selectorUpdate: TimelineSelectorUpdate<any>,
 	store: Store,
 ): void {
-	const updates =
-		applying === `newValue`
-			? selectorUpdate.atomUpdates
-			: selectorUpdate.atomUpdates.toReversed()
+	let updates: Omit<TimelineAtomUpdate<TimelineManageable>, `timestamp`>[]
+	if (applying === `newValue`) {
+		updates = selectorUpdate.atomUpdates
+	} else {
+		updates = selectorUpdate.atomUpdates.toReversed()
+	}
 	for (const atomUpdate of updates) {
 		ingestAtomUpdate(applying, atomUpdate, store)
 	}

package/src/internal/join/get-internal-relations-from-store.ts

@@ -1,5 +1,5 @@
 import type { JoinToken, MutableAtomFamilyToken } from "atom.io"
-import type { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx"
+import type { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import type { Store } from "../store"
 import { getJoin } from "./get-join"
@@ -7,7 +7,7 @@ import { getJoin } from "./get-join"
 export function getInternalRelationsFromStore(
 	token: JoinToken<any, any, any, any, any, any>,
 	store: Store,
-): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string> {
+): MutableAtomFamilyToken<SetRTX<string>, string> {
 	const myJoin = getJoin(token, store)
 	const family = myJoin.core.relatedKeysAtoms
 	return family

package/src/internal/join/join-internal.ts

@@ -8,13 +8,12 @@ import type {
 	ReadonlyPureSelectorFamilyToken,
 	RegularAtomFamilyToken,
 	setState,
-	SetterToolkit,
 	Write,
+	WriterToolkit,
 } from "atom.io"
 import { Anarchy } from "atom.io"
 import type { Canonical, Json, stringified } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
-import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import { capitalize } from "../capitalize"
@@ -129,7 +128,7 @@ export class Join<
 		BSide
 	> = CompoundTypedKey<`content`, ASide, BSide>,
 > {
-	private toolkit: SetterToolkit
+	private toolkit: WriterToolkit
 	public options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>
 	public defaultContent: Content | undefined
 	public molecules: Map<string, Molecule<any>> = new Map()
@@ -143,14 +142,10 @@ export class Join<
 		Content
 	>
 	public core: {
-		relatedKeysAtoms: MutableAtomFamilyToken<
-			SetRTX<string>,
-			SetRTXJson<string>,
-			string
-		>
+		relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, string>
 	}
 	public transact(
-		toolkit: SetterToolkit,
+		toolkit: WriterToolkit,
 		run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void,
 	): void {
 		const originalToolkit = this.toolkit
@@ -193,18 +188,11 @@ export class Join<
 
 		const aSide: ASide = options.between[0]
 		const bSide: BSide = options.between[1]
-		const relatedKeysAtoms = createMutableAtomFamily<
-			SetRTX<string>,
-			SetRTXJson<string>,
-			string
-		>(
+		const relatedKeysAtoms = createMutableAtomFamily<SetRTX<string>, string>(
 			store,
 			{
 				key: `${options.key}/relatedKeys`,
-				default: () => new SetRTX(),
-				mutable: true,
-				fromJson: (json) => SetRTX.fromJSON(json),
-				toJson: (set) => set.toJSON(),
+				class: SetRTX,
 			},
 			[`join`, `relations`],
 		)

package/src/internal/molecule.ts

@@ -293,6 +293,7 @@ export function claimWithinStore<
 	const transferEvent: MoleculeTransfer = {
 		type: `molecule_transfer`,
 		key: molecule.key,
+		exclusive: Boolean(exclusive),
 		from: priorProvenance,
 		to: [newProvenanceMolecule.key],
 	}

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

@@ -7,30 +7,33 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
-import { selectJsonFamily, stringifyJson } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
-import { type MutableAtomFamily, prettyPrintTokenType } from ".."
+import {
+	createWritablePureSelectorFamily,
+	type MutableAtomFamily,
+	prettyPrintTokenType,
+} from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 import { FamilyTracker } from "./tracker-family"
-import type { Transceiver } from "./transceiver"
+import type { AsJSON, Transceiver } from "./transceiver"
 
 export function createMutableAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 >(
 	store: Store,
-	options: MutableAtomFamilyOptions<T, J, K>,
+	options: MutableAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
-): MutableAtomFamilyToken<T, J, K> {
-	const familyToken = {
+): MutableAtomFamilyToken<T, K> {
+	const familyToken: MutableAtomFamilyToken<T & Transceiver<any, any>, K> = {
 		key: options.key,
 		type: `mutable_atom_family`,
-	} as const satisfies MutableAtomFamilyToken<T, J, K>
+	}
 
 	const existing = store.families.get(options.key)
 	if (existing) {
@@ -45,21 +48,18 @@ export function createMutableAtomFamily<
 	}
 
 	const subject = new Subject<
-		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
+		StateCreation<MutableAtomToken<T>> | StateDisposal<MutableAtomToken<T>>
 	>()
 
-	const familyFunction = (key: K): MutableAtomToken<T, J> => {
+	const familyFunction = (key: K): MutableAtomToken<T> => {
 		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> = {
+		const individualOptions: MutableAtomOptions<T> = {
 			key: fullKey,
-			default: () => options.default(key),
-			toJson: options.toJson,
-			fromJson: options.fromJson,
-			mutable: true,
+			class: options.class,
 		}
 		if (options.effects) {
 			individualOptions.effects = options.effects(key)
@@ -74,13 +74,29 @@ export function createMutableAtomFamily<
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		subject,
 		install: (s: Store) => createMutableAtomFamily(s, options),
-		toJson: options.toJson,
-		fromJson: options.fromJson,
 		internalRoles,
-	}) satisfies MutableAtomFamily<T, J, K>
+	}) satisfies MutableAtomFamily<T, K>
 
 	store.families.set(options.key, atomFamily)
-	selectJsonFamily(store, atomFamily, options)
+
+	createWritablePureSelectorFamily<AsJSON<T>, K>(
+		store,
+		{
+			key: `${options.key}:JSON`,
+			get:
+				(key) =>
+				({ get }) =>
+					get(familyToken, key).toJSON(),
+			set:
+				(key) =>
+				({ set }, newValue) => {
+					set(familyToken, key, options.class.fromJSON(newValue))
+				},
+		},
+		[`mutable`, `json`],
+	)
+
 	new FamilyTracker(atomFamily, store)
+
 	return familyToken
 }