atom.io 0.27.1 → 0.27.3

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

@@ -1,8 +1,9 @@
 import type {
-	MutableAtomFamily,
+	AtomFamilyToken,
 	MutableAtomFamilyOptions,
-	RegularAtomFamily,
+	MutableAtomFamilyToken,
 	RegularAtomFamilyOptions,
+	RegularAtomFamilyToken,
 } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
 
@@ -17,17 +18,17 @@ export function createAtomFamily<
 >(
 	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
-): MutableAtomFamily<T, J, K>
+): MutableAtomFamilyToken<T, J, K>
 export function createAtomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): RegularAtomFamily<T, K>
+): RegularAtomFamilyToken<T, K>
 export function createAtomFamily<T, K extends Canonical>(
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): MutableAtomFamily<any, any, any> | RegularAtomFamily<T, K> {
+): AtomFamilyToken<any, any> {
 	const isMutable = `mutable` in options
 
 	if (isMutable) {

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

@@ -1,7 +1,7 @@
 import type {
 	FamilyMetadata,
-	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyOptions,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	StateCreation,
 	StateDisposal,
@@ -9,46 +9,55 @@ import type {
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import type { ReadonlySelectorFamily } from ".."
 import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createReadonlySelectorFamily<T, K extends Canonical>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
-): ReadonlySelectorFamily<T, K> {
+	internalRoles?: string[],
+): ReadonlySelectorFamilyToken<T, K> {
+	const familyToken = {
+		key: options.key,
+		type: `readonly_selector_family`,
+	} as const satisfies ReadonlySelectorFamilyToken<T, K>
+
+	throwInCaseOfConflictingFamily(familyToken, store)
+
 	const subject = new Subject<
 		| StateCreation<ReadonlySelectorToken<T>>
 		| StateDisposal<ReadonlySelectorToken<T>>
 	>()
 
-	const readonlySelectorFamily = Object.assign(
-		(key: K): ReadonlySelectorToken<T> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const target = newest(store)
-
-			const token = createReadonlySelector(
-				{
-					key: fullKey,
-					get: options.get(key),
-				},
-				family,
-				target,
-			)
-
-			subject.next({ type: `state_creation`, token })
-			return token
-		},
-		{
-			key: options.key,
-			type: `readonly_selector_family`,
-			subject,
-			install: (s: Store) => createReadonlySelectorFamily(options, s),
-		} as const,
-	) satisfies ReadonlySelectorFamily<T, K>
+	const familyFunction = (key: K): ReadonlySelectorToken<T> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: options.key, subKey }
+		const fullKey = `${options.key}(${subKey})`
+		const target = newest(store)
+
+		const token = createReadonlySelector(
+			{
+				key: fullKey,
+				get: options.get(key),
+			},
+			family,
+			target,
+		)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+		subject,
+		install: (s: Store) => createReadonlySelectorFamily(options, s),
+		internalRoles,
+	}) satisfies ReadonlySelectorFamily<T, K>
+
 	store.families.set(options.key, readonlySelectorFamily)
-	return readonlySelectorFamily
+	return familyToken
 }

package/internal/src/families/create-regular-atom-family.ts

@@ -1,7 +1,7 @@
 import type {
 	FamilyMetadata,
-	RegularAtomFamily,
 	RegularAtomFamilyOptions,
+	RegularAtomFamilyToken,
 	RegularAtomOptions,
 	RegularAtomToken,
 	StateCreation,
@@ -10,47 +10,56 @@ import type {
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import type { RegularAtomFamily } from ".."
 import { createRegularAtom } from "../atom"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createRegularAtomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): RegularAtomFamily<T, K> {
+	internalRoles?: string[],
+): RegularAtomFamilyToken<T, K> {
+	const familyToken = {
+		key: options.key,
+		type: `atom_family`,
+	} as const satisfies RegularAtomFamilyToken<T, K>
+
+	throwInCaseOfConflictingFamily(familyToken, store)
+
 	const subject = new Subject<
 		StateCreation<RegularAtomToken<T>> | StateDisposal<RegularAtomToken<T>>
 	>()
 
-	const atomFamily: RegularAtomFamily<T, K> = Object.assign(
-		(key: K): RegularAtomToken<any> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const target = newest(store)
-
-			const def = options.default
-			const individualOptions: RegularAtomOptions<T> = {
-				key: fullKey,
-				default: def instanceof Function ? def(key) : def,
-			}
-			if (options.effects) {
-				individualOptions.effects = options.effects(key)
-			}
-
-			const token = createRegularAtom(individualOptions, family, target)
-
-			subject.next({ type: `state_creation`, token })
-			return token
-		},
-		{
-			key: options.key,
-			type: `atom_family`,
-			subject,
-			install: (s: Store) => createRegularAtomFamily(options, s),
-		} as const,
-	) satisfies RegularAtomFamily<T, K>
+	const familyFunction = (key: K): RegularAtomToken<any> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: options.key, subKey }
+		const fullKey = `${options.key}(${subKey})`
+		const target = newest(store)
+
+		const def = options.default
+		const individualOptions: RegularAtomOptions<T> = {
+			key: fullKey,
+			default: def instanceof Function ? def(key) : def,
+		}
+		if (options.effects) {
+			individualOptions.effects = options.effects(key)
+		}
+
+		const token = createRegularAtom(individualOptions, family, target)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const atomFamily = Object.assign(familyFunction, familyToken, {
+		subject,
+		install: (s: Store) => createRegularAtomFamily(options, s),
+		internalRoles,
+	}) satisfies RegularAtomFamily<T, K>
+
 	store.families.set(options.key, atomFamily)
-	return atomFamily
+	return familyToken
 }

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

@@ -1,8 +1,9 @@
 import type {
-	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyOptions,
-	WritableSelectorFamily,
+	ReadonlySelectorFamilyToken,
+	SelectorFamilyToken,
 	WritableSelectorFamilyOptions,
+	WritableSelectorFamilyToken,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
@@ -13,17 +14,17 @@ import { createWritableSelectorFamily } from "./create-writable-selector-family"
 export function createSelectorFamily<T, K extends Canonical>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
-): WritableSelectorFamily<T, K>
+): WritableSelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
-): ReadonlySelectorFamily<T, K>
+): ReadonlySelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
 	options:
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
 	store: Store,
-): ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K> {
+): SelectorFamilyToken<T, K> {
 	const isWritable = `set` in options
 
 	if (isWritable) {

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

@@ -2,54 +2,63 @@ import type {
 	FamilyMetadata,
 	StateCreation,
 	StateDisposal,
-	WritableSelectorFamily,
 	WritableSelectorFamilyOptions,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import type { WritableSelectorFamily } from ".."
 import { newest } from "../lineage"
 import { createWritableSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createWritableSelectorFamily<T, K extends Canonical>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
-): WritableSelectorFamily<T, K> {
+	internalRoles?: string[],
+): WritableSelectorFamilyToken<T, K> {
+	const familyToken = {
+		key: options.key,
+		type: `selector_family`,
+	} as const satisfies WritableSelectorFamilyToken<T, K>
+
+	throwInCaseOfConflictingFamily(familyToken, store)
+
 	const subject = new Subject<
 		| StateCreation<WritableSelectorToken<T>>
 		| StateDisposal<WritableSelectorToken<T>>
 	>()
 
-	const selectorFamily = Object.assign(
-		(key: K): WritableSelectorToken<T> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const target = newest(store)
-
-			const token = createWritableSelector(
-				{
-					key: fullKey,
-					get: options.get(key),
-					set: options.set(key),
-				},
-				family,
-				target,
-			)
-
-			subject.next({ type: `state_creation`, token })
-			return token
-		},
-		{
-			key: options.key,
-			type: `selector_family`,
-			subject,
-			install: (s: Store) => createWritableSelectorFamily(options, s),
-		} as const,
-	) satisfies WritableSelectorFamily<T, K>
+	const familyFunction = (key: K): WritableSelectorToken<T> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: options.key, subKey }
+		const fullKey = `${options.key}(${subKey})`
+		const target = newest(store)
+
+		const token = createWritableSelector(
+			{
+				key: fullKey,
+				get: options.get(key),
+				set: options.set(key),
+			},
+			family,
+			target,
+		)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const selectorFamily = Object.assign(familyFunction, familyToken, {
+		subject,
+		install: (s: Store) => createWritableSelectorFamily(options, s),
+		internalRoles,
+	}) satisfies WritableSelectorFamily<T, K>
+
 	store.families.set(options.key, selectorFamily)
-	return selectorFamily
+	return familyToken
 }

package/internal/src/families/throw-in-case-of-conflicting-family.ts

@@ -0,0 +1,18 @@
+import type { AtomFamilyToken, SelectorFamilyToken } from "atom.io"
+
+import { prettyPrintTokenType } from "../pretty-print"
+import type { Store } from "../store"
+
+export function throwInCaseOfConflictingFamily(
+	family: AtomFamilyToken<any, any> | SelectorFamilyToken<any, any>,
+	store: Store,
+): void {
+	const existingFamily = store.families.get(family.key)
+	if (existingFamily) {
+		throw new Error(
+			`Tried to create ${family.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(family)} with key "${family.key}", but "${family.key}" already exists in store "${store.config.name}" as ${existingFamily.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(
+				existingFamily,
+			)}`,
+		)
+	}
+}

package/internal/src/index.ts

@@ -1,5 +1,17 @@
-import type { FamilyMetadata } from "atom.io"
-import type { Json, JsonInterface } from "atom.io/json"
+import type {
+	AtomToken,
+	FamilyMetadata,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	StateCreation,
+	StateDisposal,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+} from "atom.io"
+import type { Canonical, Json, JsonInterface } from "atom.io/json"
 
 import type { Transceiver } from "./mutable"
 import type { Store } from "./store"
@@ -20,6 +32,7 @@ export * from "./molecule"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
+export * from "./pretty-print"
 export * from "./selector"
 export * from "./set-state"
 export * from "./store"
@@ -67,3 +80,64 @@ export type Selector<T> = ReadonlySelector<T> | WritableSelector<T>
 
 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> = 
+	& RegularAtomFamilyToken<T, K>
+	& {
+		(key: K): RegularAtomToken<T>
+		subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>
+		install: (store: Store) => void
+		internalRoles: string[] | undefined
+	}
+
+// 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
+	}
+
+export type AtomFamily<T, K extends Canonical = Canonical> =
+	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
+	| RegularAtomFamily<T, K>
+
+// biome-ignore format: intersection
+export type WritableSelectorFamily<T, K extends Canonical> = 
+	& WritableSelectorFamilyToken<T, K> 
+	& {
+		(key: K): WritableSelectorToken<T>
+		subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>
+		install: (store: Store) => void
+		internalRoles : string[] | undefined
+	}
+
+// biome-ignore format: intersection
+export type ReadonlySelectorFamily<T, K extends Canonical> = 
+	& ((key: K) => ReadonlySelectorToken<T>)
+	& {
+		key: string
+		type: `readonly_selector_family`
+		subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>
+		install: (store: Store) => void
+		internalRoles : string[] | undefined
+	}
+
+export type SelectorFamily<T, K extends Canonical> =
+	| ReadonlySelectorFamily<T, K>
+	| WritableSelectorFamily<T, K>
+
+export type WritableFamily<T, K extends Canonical> =
+	| AtomFamily<T, K>
+	| WritableSelectorFamily<T, K>
+export type ReadableFamily<T, K extends Canonical> =
+	| AtomFamily<T, K>
+	| SelectorFamily<T, K>

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

@@ -9,7 +9,6 @@ import { parseJson, stringifyJson } from "atom.io/json"
 
 import { disposeFromStore, initFamilyMemberInStore } from "../families"
 import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
-import { setIntoStore } from "../set-state"
 import { type Store, withdraw } from "../store"
 
 export function ingestCreationEvent(

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

@@ -10,7 +10,7 @@ export function ingestSelectorUpdate(
 	const updates =
 		applying === `newValue`
 			? selectorUpdate.atomUpdates
-			: [...selectorUpdate.atomUpdates].reverse()
+			: selectorUpdate.atomUpdates.toReversed()
 	for (const atomUpdate of updates) {
 		ingestAtomUpdate(applying, atomUpdate, store)
 	}

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

@@ -1,4 +1,3 @@
-import { stringifyJson } from "anvl/json"
 import type {
 	MoleculeConstructor,
 	MoleculeDisposal,

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)