atom.io 0.30.7 → 0.31.0

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

@@ -1,98 +1,41 @@
-import type {
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeKey,
-	MoleculeToken,
-	ReadableFamilyToken,
-	ReadableToken,
-} from "atom.io"
-import { type Canonical, parseJson } from "atom.io/json"
+import type { ReadableFamilyToken, ReadableToken } from "atom.io"
+import type { Canonical } from "atom.io/json"
 
-import { findInStore, seekInStore } from "../families"
-import { getFamilyOfToken } from "../families/get-family-of-token"
-import { NotFoundError } from "../not-found-error"
+import { findInStore } from "../families"
 import type { Store } from "../store"
-import { counterfeit, withdraw } from "../store"
+import { withdraw } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
 export function getFromStore<T>(store: Store, token: ReadableToken<T>): T
 
-export function getFromStore<M extends MoleculeConstructor>(
-	store: Store,
-	token: MoleculeToken<M>,
-): InstanceType<M>
-
 export function getFromStore<T, K extends Canonical>(
 	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: K,
 ): T
 
-export function getFromStore<M extends MoleculeConstructor>(
-	store: Store,
-	token: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-): InstanceType<M>
-
-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> | 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<any>
-	let family:
-		| MoleculeFamilyToken<any>
-		| ReadableFamilyToken<any, Canonical>
-		| null
+	let token: ReadableToken<any>
+	let family: ReadableFamilyToken<any, Canonical> | null
 	let key: Canonical | null
 	if (params.length === 1) {
 		token = params[0]
-		if (token.type !== `molecule`) {
-			family = getFamilyOfToken(store, token) ?? null
-			if (family) {
-				key = token.family ? parseJson(token.family.subKey) : null
-				token = findInStore(store, family, key)
-			}
-		}
 	} else {
 		family = params[0]
 		key = params[1]
-		let maybeToken: MoleculeToken<any> | ReadableToken<any>
-		if (family.type === `molecule_family`) {
-			maybeToken = seekInStore(store, family, key) ?? counterfeit(family, key)
-		} else {
-			maybeToken = findInStore(store, family, key)
-		}
-		token = maybeToken
+		token = findInStore(store, family, key)
 	}
 	if (`counterfeit` in token && `family` in token) {
-		family =
-			token.type === `molecule`
-				? withdraw(token.family, store)
-				: // biome-ignore lint/style/noNonNullAssertion: family must be present
-					store.families.get(token.family.key)!
-		const subKey = token.type === `molecule` ? token.key : token.family.subKey
+		// biome-ignore lint/style/noNonNullAssertion: family must be present
+		family = store.families.get(token.family.key)!
+		const subKey = token.family.subKey
 		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === token.key,
+			(item) => item?.key === subKey,
 		)
 		store.logger.error(
 			`❌`,
@@ -116,17 +59,8 @@ export function getFromStore(
 				store.defaults.set(family.key, defaultValue)
 				return defaultValue
 			}
-			case `molecule_family`:
-				throw new NotFoundError(family, subKey, store)
 		}
 	}
-	switch (token.type) {
-		case `atom`:
-		case `mutable_atom`:
-		case `selector`:
-		case `readonly_selector`:
-			return readOrComputeValue(withdraw(token, store), store)
-		case `molecule`:
-			return withdraw(token, store).instance
-	}
+
+	return readOrComputeValue(withdraw(token, store), store)
 }

package/internal/src/get-trace.ts

@@ -0,0 +1,7 @@
+export function getTrace(error: Error): string {
+	const { stack } = error
+	if (stack) {
+		return `\n` + stack.split(`\n`)?.slice(1)?.join(`\n`)
+	}
+	return ``
+}

package/internal/src/index.ts

@@ -25,12 +25,13 @@ export * from "./families"
 export * from "./future"
 export * from "./get-environment-data"
 export * from "./get-state"
+export * from "./get-trace"
 export * from "./ingest-updates"
 export * from "./junction"
 export * from "./keys"
 export * from "./lazy-map"
 export * from "./lineage"
-export * from "./molecule"
+export type * from "./molecule"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"

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

@@ -1,6 +1,7 @@
 import type {
 	MoleculeCreation,
 	MoleculeDisposal,
+	MoleculeTransfer,
 	ReadableToken,
 	StateCreation,
 	StateDisposal,
@@ -9,12 +10,12 @@ import { parseJson, stringifyJson } from "atom.io/json"
 
 import {
 	allocateIntoStore,
+	claimWithinStore,
 	deallocateFromStore,
 } from "~/packages/atom.io/src/allocate"
 
 import { disposeFromStore, findInStore } from "../families"
-import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
-import { type Store, withdraw } from "../store"
+import type { Store } from "../store"
 
 export function ingestCreationEvent(
 	update: StateCreation<any>,
@@ -45,7 +46,9 @@ export function ingestDisposalEvent(
 		}
 		case `oldValue`: {
 			createInStore(update, store)
-			store.valueMap.set(update.token.key, update.value)
+			if (update.subType === `atom`) {
+				store.valueMap.set(update.token.key, update.value)
+			}
 			break
 		}
 	}
@@ -65,36 +68,17 @@ function createInStore(
 }
 
 export function ingestMoleculeCreationEvent(
-	update: MoleculeCreation<any>,
+	update: MoleculeCreation,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {
 	switch (applying) {
 		case `newValue`:
-			switch (update.subType) {
-				case `classic`:
-					makeMoleculeInStore(
-						store,
-						update.context,
-						update.family,
-						update.token.key,
-						...update.params,
-					)
-					break
-				case `modern`:
-					allocateIntoStore<any, any, any>(store, update.provenance, update.key)
-					break
-			}
+			allocateIntoStore<any, any, any>(store, update.provenance, update.key)
 			break
+
 		case `oldValue`:
-			switch (update.subType) {
-				case `classic`:
-					disposeFromStore(store, update.token)
-					break
-				case `modern`:
-					deallocateFromStore<any, any, any>(store, update.key)
-					break
-			}
+			deallocateFromStore<any, any>(store, update.key)
 			break
 	}
 }
@@ -105,56 +89,65 @@ export function ingestMoleculeDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`:
-			switch (update.subType) {
-				case `classic`:
-					disposeFromStore(store, update.token)
-					break
-				case `modern`:
-					deallocateFromStore<any, any, any>(store, update.key)
-					break
-			}
+			deallocateFromStore<any, any>(store, update.key)
 			break
+
 		case `oldValue`:
 			{
-				// TODO: Handle classic vs modern molecules
-				switch (update.subType) {
-					case `classic`:
-						{
-							const moleculeToken = makeMoleculeInStore(
-								store,
-								update.context,
-								update.family,
-								update.token.key,
-							)
-							for (const [familyKey, value] of update.values) {
-								const memberKey = `${familyKey}(${stringifyJson(moleculeToken.key)})`
-								const molecule = withdraw(moleculeToken, store)
-								const alreadyCreated = molecule.tokens.has(memberKey)
-								const family = store.families.get(familyKey)
-								if (family && !alreadyCreated) {
-									growMoleculeInStore(molecule, family, store)
-								}
-								store.valueMap.set(memberKey, value)
-							}
-						}
-						break
-					case `modern`: {
-						allocateIntoStore<any, any, any>(
-							store,
-							update.provenance,
-							update.key,
-						)
-						for (const [familyKey, value] of update.values) {
-							const family = store.families.get(familyKey)
-							if (family) {
-								findInStore(store, family, update.key)
-								const memberKey = `${familyKey}(${stringifyJson(update.key)})`
-								store.valueMap.set(memberKey, value)
-							}
-						}
+				// let first = t rue
+				// for (const ownerString of update.provenance) {
+				// 	// const owner = parseJson(ownerString)
+				// 	// if (first) {
+				// 	// 	first = false
+				// 	// 	allocateIntoStore<any, any, any>(store, owner, update.key)
+				// 	// 	continue
+				// 	// }
+
+				// 	// claimWithinStore<any, any, any>(store, owner, update.key)
+
+				// }
+				const provenanceJson = update.provenance.map(parseJson)
+				allocateIntoStore<any, any, any>(store, provenanceJson, update.key)
+				for (const [familyKey, value] of update.values) {
+					const family = store.families.get(familyKey)
+					if (family) {
+						findInStore(store, family, update.key)
+						const memberKey = `${familyKey}(${stringifyJson(update.key)})`
+						store.valueMap.set(memberKey, value)
 					}
 				}
 			}
 			break
 	}
 }
+export function ingestMoleculeTransferEvent(
+	update: MoleculeTransfer,
+	applying: `newValue` | `oldValue`,
+	store: Store,
+): void {
+	switch (applying) {
+		case `newValue`:
+			{
+				const provenance = update.to.length === 1 ? update.to[0] : update.to
+				claimWithinStore<any, any, any>(
+					store,
+					provenance,
+					update.key,
+					`exclusive`,
+				)
+			}
+			break
+		case `oldValue`:
+			{
+				const provenance =
+					update.from.length === 1 ? update.from[0] : update.from
+				claimWithinStore<any, any, any>(
+					store,
+					provenance,
+					update.key,
+					`exclusive`,
+				)
+			}
+			break
+	}
+}

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

@@ -7,6 +7,7 @@ import {
 	ingestDisposalEvent,
 	ingestMoleculeCreationEvent,
 	ingestMoleculeDisposalEvent,
+	ingestMoleculeTransferEvent,
 } from "./ingest-creation-disposal"
 
 export function ingestTransactionUpdate(
@@ -36,6 +37,9 @@ export function ingestTransactionUpdate(
 			case `molecule_disposal`:
 				ingestMoleculeDisposalEvent(updateFromTransaction, applying, store)
 				break
+			case `molecule_transfer`:
+				ingestMoleculeTransferEvent(updateFromTransaction, applying, store)
+				break
 			case `transaction_update`:
 				ingestTransactionUpdate(applying, updateFromTransaction, store)
 				break

package/internal/src/junction.ts

@@ -1,6 +1,7 @@
-import type { Refinement } from "atom.io/introspection"
 import type { Json } from "atom.io/json"
 
+import type { Refinement } from "./utility-types"
+
 export type JunctionEntriesBase<
 	AType extends string,
 	BType extends string,
@@ -279,18 +280,57 @@ export class Junction<
 		...rest: Content extends null ? [] | [void?: undefined] : [content: Content]
 	): this
 	public set(
-		a: AType | ({ [Key in ASide]: AType } & { [Key in BSide]: BType }),
-		...rest: Content extends null
-			? [] | [b?: BType | undefined]
-			: [b: BType, content: Content] | [content: Content]
+		// a: AType | ({ [Key in ASide]: AType } & { [Key in BSide]: BType }),
+		// ...rest: Content extends null
+		// 	? [] | [b?: BType | undefined]
+		// 	: [b: BType, content: Content] | [content: Content]
+		...params:
+			| [
+					a: AType,
+					...rest: Content extends null
+						? [b: BType]
+						: [b: BType, content: Content],
+			  ]
+			| [
+					relation: { [Key in ASide]: AType } & { [Key in BSide]: BType },
+					...rest: Content extends null
+						? [] | [void?: undefined]
+						: [content: Content],
+			  ]
+		// | [{ [Key in ASide]: AType } & { [Key in BSide]: BType }, content: Content]
+		// | [{ [Key in ASide]: AType } & { [Key in BSide]: BType }]
+		// | [a: AType, b: BType, content: Content]
+		// | [a: AType, b: BType]
 	): this {
-		const b: BType =
-			typeof rest[0] === `string`
-				? rest[0]
-				: (a[this.b as keyof typeof a] as BType)
-		const content: Content | undefined =
-			(rest[1] ?? typeof rest[0] === `string`) ? undefined : (rest[0] as Content)
-		a = typeof a === `string` ? a : a[this.a]
+		let a: AType
+		let b: BType
+		let content: Content | undefined
+		switch (params.length) {
+			case 1: {
+				const relation = params[0] as Record<ASide, AType> & Record<BSide, BType>
+				a = relation[this.a]
+				b = relation[this.b]
+				content = undefined
+				break
+			}
+			case 2: {
+				const zeroth = params[0]
+				if (typeof zeroth === `string`) {
+					;[a, b] = params as unknown as [AType, BType]
+				} else {
+					a = zeroth[this.a]
+					b = zeroth[this.b]
+					content = params[1] as Content
+				}
+				break
+			}
+			default: {
+				a = params[0] as AType
+				b = params[1] as BType
+				content = params[2] as Content
+				break
+			}
+		}
 		switch (this.cardinality) {
 			// biome-ignore lint/suspicious/noFallthroughSwitchClause: perfect here
 			case `1:1`: {

package/internal/src/lineage.ts

@@ -10,10 +10,3 @@ export function newest<T extends Lineage>(scion: T): T {
 	}
 	return scion
 }
-
-export function eldest<T extends Lineage>(scion: T): T {
-	while (scion.parent !== null) {
-		scion = scion.parent
-	}
-	return scion
-}

package/internal/src/molecule.ts

@@ -0,0 +1,7 @@
+import type { Canonical, stringified } from "atom.io/json"
+
+export type Molecule<K extends Canonical> = {
+	readonly key: K
+	readonly stringKey: stringified<K>
+	readonly dependsOn: `all` | `any`
+}

package/internal/src/mutable/transceiver.ts

@@ -1,11 +1,11 @@
 import type { Json } from "atom.io/json"
 
-export interface Transceiver<Signal extends Json.Serializable> {
-	do: (update: Signal) => number | `OUT_OF_RANGE` | null
-	undo: (update: Signal) => void
-	subscribe: (key: string, fn: (update: Signal) => void) => () => void
+export interface Transceiver<S extends Json.Serializable> {
+	do: (update: S) => number | `OUT_OF_RANGE` | null
+	undo: (update: S) => void
+	subscribe: (key: string, fn: (update: S) => void) => () => void
 	cacheUpdateNumber: number
-	getUpdateNumber: (update: Signal) => number
+	getUpdateNumber: (update: S) => number
 }
 
 export function isTransceiver(

package/internal/src/pretty-print.ts

@@ -1,6 +1,4 @@
 import type {
-	MoleculeFamilyToken,
-	MoleculeToken,
 	ReadableFamilyToken,
 	ReadableToken,
 	TimelineToken,
@@ -10,8 +8,6 @@ import type {
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
 
 export type AtomIOToken =
-	| MoleculeFamilyToken<any>
-	| MoleculeToken<any>
 	| ReadableFamilyToken<any, any>
 	| ReadableToken<any>
 	| TimelineToken<any>

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

@@ -20,7 +20,7 @@ export function disposeSelector(
 	} else {
 		const molecule = target.molecules.get(selector.family.subKey)
 		if (molecule) {
-			molecule.tokens.delete(key)
+			target.moleculeData.delete(selector.family.subKey, selector.family.key)
 		}
 		switch (selectorToken.type) {
 			case `selector`:
@@ -30,10 +30,6 @@ export function disposeSelector(
 						{ key: selector.family.key, type: `selector_family` },
 						store,
 					)
-					family.subject.next({
-						type: `state_disposal`,
-						token: selectorToken,
-					})
 				}
 				break
 			case `readonly_selector`:
@@ -45,6 +41,7 @@ export function disposeSelector(
 					)
 					family.subject.next({
 						type: `state_disposal`,
+						subType: `selector`,
 						token: selectorToken,
 					})
 				}
@@ -57,6 +54,7 @@ export function disposeSelector(
 		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
 			target.transactionMeta.update.updates.push({
 				type: `state_disposal`,
+				subType: `selector`,
 				token: selectorToken,
 			})
 		} else {

package/internal/src/selector/register-selector.ts

@@ -1,7 +1,4 @@
 import type {
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeToken,
 	ReadableFamilyToken,
 	ReadableToken,
 	setState,
@@ -14,7 +11,6 @@ import type { seekState } from "atom.io/immortal"
 import type { Json } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
-import { getFromStore } from "../get-state"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
@@ -31,39 +27,19 @@ export const registerSelector = (
 ): SetterToolkit => ({
 	get: (
 		...params:
-			| [MoleculeFamilyToken<any>, Json.Serializable]
-			| [MoleculeToken<MoleculeConstructor>]
 			| [ReadableFamilyToken<any, any>, Json.Serializable]
 			| [ReadableToken<any>]
 	) => {
 		const target = newest(store)
-		let dependency: MoleculeToken<MoleculeConstructor> | ReadableToken<any>
+		let dependency: ReadableToken<any>
 
 		if (params.length === 2) {
 			const [family, key] = params
-			switch (family.type) {
-				case `molecule_family`:
-					return getFromStore(store, family, key)
-				default:
-					if (store.config.lifespan === `ephemeral`) {
-						dependency = findInStore(store, family, key)
-					} else {
-						const maybeDependency = seekInStore(store, family, key)
-						if (maybeDependency) {
-							dependency = maybeDependency
-						} else {
-							throw new NotFoundError(family, key, store)
-						}
-					}
-			}
+			dependency = findInStore(store, family, key)
 		} else {
 			;[dependency] = params
 		}
 
-		if (dependency.type === `molecule`) {
-			return getFromStore(store, dependency)
-		}
-
 		const dependencyState = withdraw(dependency, store)
 		const dependencyValue = readOrComputeValue(dependencyState, store)
 

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

@@ -50,9 +50,10 @@ export function setIntoStore<T, New extends T>(
 		token = findInStore(store, family, key)
 	}
 
-	if (`counterfeit` in token) {
+	if (`counterfeit` in token && `family` in token) {
+		const subKey = token.family.subKey
 		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === token.key,
+			(item) => item?.key === subKey,
 		)
 		store.logger.error(
 			`❌`,

package/internal/src/store/counterfeit.ts

@@ -1,10 +1,6 @@
 import type {
 	AtomFamilyToken,
 	AtomToken,
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeKey,
-	MoleculeToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -75,35 +71,25 @@ export function counterfeit<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): ReadableToken<T>
 
-export function counterfeit<M extends MoleculeConstructor>(
-	token: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-): MoleculeKey<M>
-
 export function counterfeit(
-	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+	token: ReadableFamilyToken<any, any>,
 	key: Canonical,
-): MoleculeToken<any> | ReadableToken<any> {
+): ReadableToken<any> {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type]
 	const stateToken = {
 		key: fullKey,
 		type,
-	} satisfies MoleculeToken<any> | ReadableToken<any>
-	if (type === `molecule`) {
-		Object.assign(stateToken, {
-			key,
-			family: token,
-		})
-	} else {
-		Object.assign(stateToken, {
-			family: {
-				key: token.key,
-				subKey,
-			},
-		})
-	}
+	} satisfies ReadableToken<any>
+
+	Object.assign(stateToken, {
+		family: {
+			key: token.key,
+			subKey,
+		},
+	})
+
 	Object.assign(stateToken, { counterfeit: true })
 	return stateToken
 }