atom.io 0.30.7 → 0.31.1

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

@@ -17,6 +17,8 @@ import type { Canonical, Json, JsonInterface } from "atom.io/json"
 import type { Transceiver } from "./mutable"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
+import type { Timeline } from "./timeline"
+import type { Transaction } from "./transaction"
 
 export * from "./arbitrary"
 export * from "./atom"
@@ -25,6 +27,7 @@ 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"
@@ -99,14 +102,14 @@ 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
-	}
+	& 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>
@@ -144,3 +147,9 @@ export type WritableFamily<T, K extends Canonical> =
 export type ReadableFamily<T, K extends Canonical> =
 	| AtomFamily<T, K>
 	| SelectorFamily<T, K>
+
+export type AtomIOInternalResource =
+	| ReadableFamily<any, any>
+	| ReadableState<any>
+	| Timeline<any>
+	| Transaction<any>

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

@@ -1,20 +1,20 @@
 import type {
 	MoleculeCreation,
 	MoleculeDisposal,
+	MoleculeTransfer,
 	ReadableToken,
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
 import { parseJson, stringifyJson } from "atom.io/json"
 
+import { disposeFromStore, findInStore } from "../families"
 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"
+} from "../molecule"
+import type { Store } from "../store"
 
 export function ingestCreationEvent(
 	update: StateCreation<any>,
@@ -45,7 +45,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 +67,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 +88,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/install-into-store.ts

@@ -0,0 +1,48 @@
+import type { AtomIOToken } from "atom.io"
+
+import { newest } from "./lineage"
+import { type Store, withdraw } from "./store"
+import { isChildStore } from "./transaction"
+
+/**
+ * @public
+ * Install the given tokens into the target store
+ * @param tokens - States, families, transactions, and timelines to install into the target store
+ * @param target - The store to install the tokens into
+ * @param source - The store to install the tokens from
+ *
+ */
+export function installIntoStore(
+	tokens: AtomIOToken[],
+	target: Store,
+	source: Store,
+): void {
+	const sourceNewest = newest(source)
+	if (isChildStore(sourceNewest)) {
+		source.logger.error(
+			`❌`,
+			`transaction`,
+			sourceNewest.transactionMeta.update.key,
+			`could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+			tokens,
+			`${sourceNewest.config.name} is undergoing a transaction.`,
+		)
+		return
+	}
+	const targetNewest = newest(target)
+	if (isChildStore(targetNewest)) {
+		target.logger.error(
+			`❌`,
+			`transaction`,
+			targetNewest.transactionMeta.update.key,
+			`could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+			tokens,
+			`${targetNewest.config.name} is undergoing a transaction.`,
+		)
+		return
+	}
+	for (const token of tokens) {
+		const resource = withdraw(token, source)
+		resource.install(target)
+	}
+}

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
-}