atom.io 0.31.1 → 0.32.1

package/internal/src/atom/is-default.ts

@@ -1,17 +1,17 @@
 import { newest } from "../lineage"
 import type { Store } from "../store"
 
-export const isAtomDefault = (key: string, store: Store): boolean => {
+export const isAtomDefault = (store: Store, key: string): boolean => {
 	const core = newest(store)
 	return core.atomsThatAreDefault.has(key)
 }
 
-export const markAtomAsDefault = (key: string, store: Store): void => {
+export const markAtomAsDefault = (store: Store, key: string): void => {
 	const core = newest(store)
 	core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key)
 }
 
-export const markAtomAsNotDefault = (key: string, store: Store): void => {
+export const markAtomAsNotDefault = (store: Store, key: string): void => {
 	const core = newest(store)
 	core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault)
 	core.atomsThatAreDefault.delete(key)

package/internal/src/caching.ts

@@ -8,22 +8,22 @@ import type { Store } from "./store"
 import type { Subject } from "./subject"
 
 export function cacheValue<T>(
+	store: Store,
 	key: string,
 	value: T,
 	subject: Subject<StateUpdate<unknown>>,
-	store: Store,
 ): T
 export function cacheValue<T extends Promise<any>>(
+	store: Store,
 	key: string,
 	value: T,
 	subject: Subject<StateUpdate<unknown>>,
-	store: Store,
 ): Future<T>
 export function cacheValue<T>(
+	target: Store,
 	key: string,
 	value: T,
 	subject: Subject<StateUpdate<unknown>>,
-	target: Store,
 ): Future<T> | T {
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future) {
@@ -35,7 +35,7 @@ export function cacheValue<T>(
 		target.valueMap.set(key, future)
 		future
 			.then((resolved) => {
-				cacheValue(key, resolved, subject, target)
+				cacheValue(target, key, resolved, subject)
 				subject.next({ newValue: resolved, oldValue: future })
 			})
 			.catch((thrown) => {
@@ -54,7 +54,7 @@ export const readCachedValue = <T>(
 	let value = target.valueMap.get(token.key) as T
 	if (token.type === `mutable_atom` && isChildStore(target)) {
 		const { parent } = target
-		const copiedValue = copyMutableIfNeeded(token, parent, target)
+		const copiedValue = copyMutableIfNeeded(target, token, parent)
 		value = copiedValue
 	}
 	return value

package/internal/src/capitalize.ts

@@ -0,0 +1,3 @@
+export function capitalize<S extends string>(string: S): Capitalize<S> {
+	return (string[0].toUpperCase() + string.slice(1)) as Capitalize<S>
+}

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

@@ -1,5 +1,6 @@
 import type {
 	FamilyMetadata,
+	findState,
 	getState,
 	ReadonlySelectorFamilyOptions,
 	ReadonlySelectorFamilyToken,
@@ -7,8 +8,6 @@ import type {
 	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"
 
@@ -18,7 +17,6 @@ import {
 	getJsonToken,
 	prettyPrintTokenType,
 	type ReadonlySelectorFamily,
-	seekInStore,
 } from ".."
 import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
@@ -78,9 +76,10 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 		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,
+				get: ((...args: Parameters<typeof getState>) =>
+					getFromStore(store, ...args)) as typeof getState,
+				find: ((...args: Parameters<typeof findState>) =>
+					findInStore(store, ...args)) as typeof findState,
 				json: (token) => getJsonToken(store, token),
 			})
 		},

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

@@ -1,5 +1,6 @@
 import type {
 	FamilyMetadata,
+	findState,
 	getState,
 	StateCreation,
 	StateDisposal,
@@ -7,8 +8,6 @@ import type {
 	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"
 
@@ -17,7 +16,6 @@ import {
 	getFromStore,
 	getJsonToken,
 	prettyPrintTokenType,
-	seekInStore,
 	type WritableSelectorFamily,
 } from ".."
 import { newest } from "../lineage"
@@ -80,7 +78,6 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 			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),
 			})
 		},

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

@@ -2,7 +2,6 @@ import type { ReadableFamilyToken, ReadableToken } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
-import { getTrace } from "../get-trace"
 import { disposeSelector } from "../selector"
 import { type Store, withdraw } from "../store"
 import { findInStore } from "./find-in-store"
@@ -31,33 +30,24 @@ export function disposeFromStore(
 		token = maybeToken
 	}
 	try {
-		withdraw(token, store)
+		withdraw(store, token)
 	} catch (thrown) {
-		// const disposal = store.disposalTraces.buffer.find(
-		// 	(item) => item?.key === token.key,
-		// )
 		store.logger.error(
 			`❌`,
 			token.type,
 			token.key,
 			`could not be disposed because it was not found in the store "${store.config.name}".`,
-			// disposal
-			// 	? `\n   This state was most recently disposed\n${disposal.trace}`
-			// 	: `No previous disposal trace was found.`,
 		)
 		return
 	}
 	switch (token.type) {
 		case `atom`:
 		case `mutable_atom`:
-			disposeAtom(token, store)
+			disposeAtom(store, token)
 			break
 		case `selector`:
 		case `readonly_selector`:
-			disposeSelector(token, store)
+			disposeSelector(store, token)
 			break
 	}
-
-	// const trace = getTrace(new Error())
-	// store.disposalTraces.add({ key: token.key, trace })
 }

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

@@ -55,12 +55,12 @@ export function getFromStore(
 				if (store.defaults.has(family.key)) {
 					return store.defaults.get(token.family.key)
 				}
-				const defaultValue = withdraw(family, store).default(subKey)
+				const defaultValue = withdraw(store, family).default(subKey)
 				store.defaults.set(family.key, defaultValue)
 				return defaultValue
 			}
 		}
 	}
 
-	return readOrComputeValue(withdraw(token, store), store)
+	return readOrComputeValue(store, withdraw(store, token))
 }

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

@@ -3,8 +3,8 @@ import { readCachedValue } from "../caching"
 import type { Store } from "../store"
 
 export const readOrComputeValue = <T>(
-	state: ReadableState<T>,
 	target: Store,
+	state: ReadableState<T>,
 ): T => {
 	if (target.valueMap.has(state.key)) {
 		target.logger.info(`📖`, state.type, state.key, `reading cached value`)

package/internal/src/index.ts

@@ -23,12 +23,14 @@ import type { Transaction } from "./transaction"
 export * from "./arbitrary"
 export * from "./atom"
 export * from "./caching"
+export * from "./capitalize"
 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 "./join"
 export * from "./junction"
 export * from "./keys"
 export * from "./lazy-map"

package/internal/src/install-into-store.ts

@@ -42,7 +42,7 @@ export function installIntoStore(
 		return
 	}
 	for (const token of tokens) {
-		const resource = withdraw(token, source)
+		const resource = withdraw(source, token)
 		resource.install(target)
 	}
 }

package/internal/src/join/edit-relations-in-store.ts

@@ -0,0 +1,32 @@
+import type { JoinToken } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import type { Junction } from "../junction"
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import { isChildStore } from "../transaction"
+import { getJoin } from "./get-join"
+
+export function editRelationsInStore<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+	change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void,
+	store: Store,
+): void {
+	const myJoin = getJoin(token, store)
+	const target = newest(store)
+	if (isChildStore(target)) {
+		const { toolkit } = target.transactionMeta
+		myJoin.transact(toolkit, ({ relations }) => {
+			change(relations)
+		})
+	} else {
+		change(myJoin.relations)
+	}
+}

package/internal/src/join/find-relations-in-store.ts

@@ -0,0 +1,124 @@
+import type { JoinStates, JoinToken } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import { capitalize } from "../capitalize"
+import { findInStore } from "../families"
+import type { Store } from "../store"
+import { getJoin } from "./get-join"
+
+export function findRelationsInStore<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+	key: AType | BType,
+	store: Store,
+): JoinStates<ASide, AType, BSide, BType, Cardinality, Content> {
+	const myJoin = getJoin(token, store)
+	let relations: JoinStates<ASide, AType, BSide, BType, Cardinality, Content>
+	switch (token.cardinality satisfies `1:1` | `1:n` | `n:n`) {
+		case `1:1`: {
+			const keyAB = `${token.a}KeyOf${capitalize(token.b)}`
+			const keyBA = `${token.b}KeyOf${capitalize(token.a)}`
+			relations = {
+				get [keyAB]() {
+					const familyAB = myJoin.states[keyAB as any]
+					const state = findInStore(store, familyAB, key)
+					return state
+				},
+				get [keyBA]() {
+					const familyBA = myJoin.states[keyBA as any]
+					const state = findInStore(store, familyBA, key)
+					return state
+				},
+			} as JoinStates<ASide, AType, BSide, BType, Cardinality, Content>
+			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`
+			if (entryAB in myJoin.states) {
+				const entryBA = `${token.b}EntryOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entryAB]() {
+						const familyAB = myJoin.states[entryAB as any]
+						const state = findInStore(store, familyAB, key)
+						return state
+					},
+					get [entryBA]() {
+						const familyBA = myJoin.states[entryBA as any]
+						const state = findInStore(store, familyBA, key)
+						return state
+					},
+				})
+			}
+			break
+		}
+		case `1:n`: {
+			const keyAB = `${token.a}KeyOf${capitalize(token.b)}`
+			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
+			relations = {
+				get [keyAB]() {
+					const familyAB = myJoin.states[keyAB as any]
+					const state = findInStore(store, familyAB, key)
+					return state
+				},
+				get [keysBA]() {
+					const familyBA = myJoin.states[keysBA as any]
+					const state = findInStore(store, familyBA, key)
+					return state
+				},
+			} as JoinStates<ASide, AType, BSide, BType, Cardinality, Content>
+			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`
+			if (entryAB in myJoin.states) {
+				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entryAB]() {
+						const familyAB = myJoin.states[entryAB as any]
+						const state = findInStore(store, familyAB, key)
+						return state
+					},
+					get [entriesBA]() {
+						const familyBA = myJoin.states[entriesBA as any]
+						const state = findInStore(store, familyBA, key)
+						return state
+					},
+				})
+			}
+			break
+		}
+		case `n:n`: {
+			const keysAB = `${token.a}KeysOf${capitalize(token.b)}`
+			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
+			relations = {
+				get [keysAB]() {
+					const familyAB = myJoin.states[keysAB as any]
+					const state = findInStore(store, familyAB, key)
+					return state
+				},
+				get [keysBA]() {
+					const familyBA = myJoin.states[keysBA as any]
+					const state = findInStore(store, familyBA, key)
+					return state
+				},
+			} as JoinStates<ASide, AType, BSide, BType, Cardinality, Content>
+			const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`
+			if (entriesAB in myJoin.states) {
+				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entriesAB]() {
+						const familyAB = myJoin.states[entriesAB as any]
+						const state = findInStore(store, familyAB, key)
+						return state
+					},
+					get [entriesBA]() {
+						const familyBA = myJoin.states[entriesBA as any]
+						const state = findInStore(store, familyBA, key)
+						return state
+					},
+				})
+			}
+		}
+	}
+	return relations
+}

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

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

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

@@ -0,0 +1,31 @@
+import type { JoinToken } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import { IMPLICIT, type Store } from "../store"
+import { Join } from "./join-internal"
+
+export function getJoin<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+	store: Store,
+): Join<ASide, AType, BSide, BType, Cardinality, Content> {
+	let myJoin = store.joins.get(token.key)
+	if (myJoin === undefined) {
+		const rootJoinMap = IMPLICIT.STORE.joins
+		const rootJoin = rootJoinMap.get(token.key)
+		if (rootJoin === undefined) {
+			throw new Error(
+				`Join "${token.key}" not found in store "${store.config.name}"`,
+			)
+		}
+		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store)
+		store.joins.set(token.key, myJoin)
+	}
+	return myJoin
+}

package/internal/src/join/index.ts

@@ -0,0 +1,5 @@
+export * from "./edit-relations-in-store"
+export * from "./find-relations-in-store"
+export * from "./get-internal-relations-from-store"
+export * from "./get-join"
+export * from "./join-internal"