atom.io 0.30.7 → 0.31.1

package/internal/src/molecule/make-molecule-in-store.ts

@@ -1,191 +0,0 @@
-import type {
-	CtorToolkit,
-	getState,
-	MoleculeConstructor,
-	MoleculeCreationClassic,
-	MoleculeFamilyToken,
-	MoleculeKey,
-	MoleculeParams,
-	MoleculeToken,
-	ReadableFamilyToken,
-	setState,
-} from "atom.io"
-import { findRelations, getJoin, type JoinToken } from "atom.io/data"
-import type { seekState } from "atom.io/immortal"
-import { stringifyJson } from "atom.io/json"
-
-import { arbitrary } from "../arbitrary"
-import { disposeFromStore, seekInStore } from "../families"
-import { getEnvironmentData } from "../get-environment-data"
-import { getFromStore } from "../get-state"
-import { eldest, newest } from "../lineage"
-import { getJsonToken } from "../mutable"
-import { setIntoStore } from "../set-state"
-import type { Store } from "../store"
-import { withdraw } from "../store"
-import { actUponStore, isChildStore, isRootStore } from "../transaction"
-import { growMoleculeInStore } from "./grow-molecule-in-store"
-import { Molecule } from "./molecule-internal"
-
-function capitalize<S extends string>(string: S): Capitalize<S> {
-	return (string[0].toUpperCase() + string.slice(1)) as Capitalize<S>
-}
-
-export function makeMoleculeInStore<M extends MoleculeConstructor>(
-	store: Store,
-	context: MoleculeToken<M> | MoleculeToken<M>[],
-	familyToken: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-	...params: MoleculeParams<M>
-): MoleculeToken<M> {
-	const rootStore = eldest(store)
-	const target = newest(store)
-	const stringKey = stringifyJson(key)
-
-	target.moleculeInProgress = stringKey
-
-	const contextArray = Array.isArray(context) ? context : [context]
-	const owners = contextArray.map<Molecule<M>>((ctx) => {
-		if (ctx instanceof Molecule) {
-			return ctx
-		}
-		const ctxStringKey = stringifyJson(ctx.key)
-		const molecule = store.molecules.get(ctxStringKey)
-
-		if (!molecule) {
-			throw new Error(
-				`Molecule ${ctxStringKey} not found in store "${store.config.name}"`,
-			)
-		}
-		return molecule
-	})
-
-	const molecule = new Molecule(owners, key, familyToken)
-	target.molecules.set(stringKey, molecule)
-	for (const owner of owners) {
-		owner.below.set(molecule.stringKey, molecule)
-	}
-
-	const toolkit = {
-		get: ((...ps: Parameters<typeof getState>) =>
-			getFromStore(newest(rootStore), ...ps)) as typeof getState,
-		set: ((...ps: Parameters<typeof setState>) => {
-			setIntoStore(newest(rootStore), ...ps)
-		}) as typeof setState,
-		seek: ((t, k) => seekInStore(newest(rootStore), t, k)) as typeof seekState,
-		json: (t) => getJsonToken(newest(rootStore), t),
-		run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
-		make: (ctx, f, k, ...args) =>
-			makeMoleculeInStore(newest(rootStore), ctx, f, k, ...args),
-		dispose: (t) => {
-			disposeFromStore(newest(rootStore), t)
-		},
-		env: () => getEnvironmentData(newest(rootStore)),
-		bond: ((
-			token:
-				| JoinToken<any, any, any, any, any, any>
-				| ReadableFamilyToken<any, any>,
-			maybeRole,
-		) => {
-			if (token.type === `join`) {
-				const { as: role } = maybeRole
-				const join = getJoin(token, rootStore)
-				join.molecules.set(stringKey, molecule)
-				molecule.joins.set(token.key, join)
-				const unsubFromFamily = family.subject.subscribe(
-					`join:${token.key}-${stringKey}`,
-					(event) => {
-						if (event.type === `molecule_disposal`) {
-							if (stringifyJson(event.token.key) === stringKey) {
-								unsubFromFamily()
-								join.molecules.delete(stringKey)
-							}
-						}
-					},
-				)
-
-				if (role === null) {
-					return
-				}
-				const otherRole = token.a === role ? token.b : token.a
-				const relations = findRelations(token, key)
-				const relatedKeys =
-					relations[
-						`${otherRole}KeysOf${capitalize(role)}` as keyof typeof relations
-					]
-				const relatedEntries =
-					relations[
-						`${otherRole}EntriesOf${capitalize(role)}` as keyof typeof relations
-					]
-				let tokens = { relatedKeys }
-				if (relatedEntries) {
-					tokens = Object.assign(tokens, { relatedEntries })
-				}
-				return tokens
-			}
-			return growMoleculeInStore(
-				molecule,
-				withdraw(token, rootStore),
-				newest(rootStore),
-			)
-		}) as CtorToolkit<MoleculeKey<M>>[`bond`],
-		claim: (below, options) => {
-			const { exclusive } = options
-			const belowMolecule = newest(store).molecules.get(stringifyJson(below.key))
-			if (belowMolecule) {
-				if (exclusive) {
-					for (const value of belowMolecule.above.values()) {
-						value.below.delete(belowMolecule.stringKey)
-					}
-					belowMolecule.above.clear()
-					belowMolecule.above.set(molecule.stringKey, molecule)
-					molecule.below.set(belowMolecule.stringKey, belowMolecule)
-				} else {
-					belowMolecule.above.set(molecule.stringKey, molecule)
-					molecule.below.set(belowMolecule.stringKey, belowMolecule)
-				}
-			}
-		},
-		spawn: (f: MoleculeFamilyToken<any>, k: any, ...p: any[]) =>
-			makeMoleculeInStore(
-				newest(store),
-				[molecule],
-				withdraw(f, store),
-				k,
-				...p,
-			),
-	} satisfies CtorToolkit<MoleculeKey<M>>
-
-	const family = withdraw(familyToken, store)
-	const Constructor = family.new
-
-	molecule.instance = new Constructor(toolkit, key, ...params)
-
-	const token = {
-		type: `molecule`,
-		key,
-		family: familyToken,
-	} as const satisfies MoleculeToken<M>
-
-	const update = {
-		type: `molecule_creation`,
-		subType: `classic`,
-		token,
-		family: familyToken,
-		context: contextArray,
-		params,
-	} satisfies MoleculeCreationClassic<M>
-
-	if (isRootStore(target)) {
-		family.subject.next(update)
-	} else if (
-		isChildStore(target) &&
-		target.on.transactionApplying.state === null
-	) {
-		target.transactionMeta.update.updates.push(update)
-	}
-
-	target.moleculeInProgress = null
-
-	return token
-}

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

@@ -1,52 +0,0 @@
-import type {
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeKey,
-	MoleculeToken,
-	ReadableToken,
-	StateCreation,
-	StateDisposal,
-} from "atom.io"
-import type { Join } from "atom.io/data"
-import { stringifyJson } from "atom.io/json"
-
-import { Subject } from "../subject"
-
-export class Molecule<M extends MoleculeConstructor>
-	implements MoleculeToken<M>
-{
-	public readonly type = `molecule`
-	public stringKey: string
-	public family?: MoleculeFamilyToken<M>
-	public _dependsOn: `all` | `any`
-	public get dependsOn(): `all` | `any` {
-		if (this.family) {
-			return this.family.dependsOn
-		}
-		return this._dependsOn
-	}
-	public readonly subject = new Subject<
-		StateCreation<any> | StateDisposal<any>
-	>()
-	public tokens = new Map<string, ReadableToken<any>>()
-	public above = new Map<string, Molecule<any>>()
-	public below = new Map<string, Molecule<any>>()
-	public joins = new Map<string, Join<any, any, any, any, any, any>>()
-	public instance: InstanceType<M>
-	public constructor(
-		ctx: Molecule<any>[] | undefined,
-		public readonly key: MoleculeKey<M>,
-		family?: MoleculeFamilyToken<M>,
-	) {
-		this.stringKey = stringifyJson(key)
-		if (family) {
-			this.family = family
-			this._dependsOn = family.dependsOn
-		}
-		if (ctx) {
-			for (const molecule of ctx) {
-				this.above.set(molecule.stringKey, molecule)
-			}
-		}
-	}
-}

package/src/allocate.ts

@@ -1,277 +0,0 @@
-import type { Each, Store } from "atom.io/internal"
-import {
-	disposeFromStore,
-	isChildStore,
-	Molecule,
-	newest,
-} from "atom.io/internal"
-import type { Canonical } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
-
-import { makeRootMoleculeInStore } from "./molecule"
-import type {
-	MoleculeCreationModern,
-	MoleculeDisposalModern,
-} from "./transaction"
-
-export const $provenance = Symbol(`provenance`)
-export type Claim<
-	H extends Hierarchy,
-	V extends Vassal<H>,
-	A extends Above<V, H>,
-> = V & {
-	[$provenance]?: A
-}
-
-export function allocateIntoStore<
-	H extends Hierarchy,
-	V extends Vassal<H>,
-	A extends Above<V, H>,
->(store: Store, provenance: A, key: V): Claim<H, V, A> {
-	const stringKey = stringifyJson(key)
-	try {
-		const above: Molecule<any>[] = []
-
-		let allocationAttachmentStyle: `all` | `any`
-		if (provenance === `root`) {
-			// biome-ignore lint/style/noNonNullAssertion: let's assume we made the root molecule to get here
-			above.push(store.molecules.get(`"root"`)!)
-			allocationAttachmentStyle = `all`
-		} else if (typeof provenance === `string` && provenance.startsWith(T$)) {
-			allocationAttachmentStyle = `any`
-			const provenanceKey = stringifyJson(provenance as Canonical)
-			const provenanceMolecule = store.molecules.get(provenanceKey)
-			if (!provenanceMolecule) {
-				throw new Error(
-					`Molecule ${provenanceKey} not found in store "${store.config.name}"`,
-				)
-			}
-			above.push(provenanceMolecule)
-		} else {
-			const allocationIsCompound = key.startsWith(`T$--`)
-			if (allocationIsCompound) {
-				allocationAttachmentStyle = `all`
-				for (const claim of provenance as SingularTypedKey[]) {
-					const provenanceKey = stringifyJson(claim)
-					const provenanceMolecule = store.molecules.get(provenanceKey)
-					if (!provenanceMolecule) {
-						throw new Error(
-							`Molecule ${provenanceKey} not found in store "${store.config.name}"`,
-						)
-					}
-					above.push(provenanceMolecule)
-				}
-			} else {
-				allocationAttachmentStyle = `any`
-				const provenanceKey = stringifyJson(provenance as Canonical)
-				const provenanceMolecule = store.molecules.get(provenanceKey)
-				if (!provenanceMolecule) {
-					throw new Error(
-						`Molecule ${provenanceKey} not found in store "${store.config.name}"`,
-					)
-				}
-				above.push(provenanceMolecule)
-			}
-		}
-
-		const molecule = new Molecule(above, key)
-		molecule._dependsOn = allocationAttachmentStyle
-
-		store.molecules.set(stringKey, molecule)
-
-		for (const aboveMolecule of above) {
-			aboveMolecule.below.set(molecule.stringKey, molecule)
-		}
-
-		const creationEvent: MoleculeCreationModern = {
-			type: `molecule_creation`,
-			subType: `modern`,
-			key: molecule.key,
-			provenance: provenance as Canonical,
-		}
-		const target = newest(store)
-		const isTransaction =
-			isChildStore(target) && target.transactionMeta.phase === `building`
-		if (isTransaction) {
-			target.transactionMeta.update.updates.push(creationEvent)
-		} else {
-			target.on.moleculeCreationStart.next(creationEvent)
-		}
-	} catch (thrown) {
-		if (thrown instanceof Error) {
-			store.logger.error(
-				`❌`,
-				`molecule`,
-				stringKey,
-				`allocation failed:`,
-				thrown.message,
-			)
-		}
-	}
-
-	return key as Claim<H, V, A>
-}
-
-export function deallocateFromStore<
-	H extends Hierarchy,
-	V extends Vassal<H>,
-	A extends Above<V, H>,
->(store: Store, claim: Claim<H, V, A>): void {
-	const stringKey = stringifyJson(claim)
-	const molecule = store.molecules.get(stringKey)
-	if (!molecule) {
-		throw new Error(
-			`Molecule ${stringKey} not found in store "${store.config.name}"`,
-		)
-	}
-
-	for (const join of molecule.joins.values()) {
-		join.relations.delete(molecule.key)
-		join.molecules.delete(molecule.stringKey)
-	}
-
-	let provenance: Canonical
-	if (molecule.above.size === 1) {
-		const above = molecule.above.values().next().value
-		provenance = above.key
-	} else {
-		provenance = [...molecule.above.values()].map(({ key }) => key)
-	}
-	const values: [string, any][] = []
-	for (const stateToken of molecule.tokens.values()) {
-		// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
-		const tokenFamily = stateToken.family!
-		values.push([tokenFamily.key, store.valueMap.get(stateToken.key)])
-	}
-
-	for (const state of molecule.tokens.values()) {
-		disposeFromStore(store, state)
-	}
-	for (const child of molecule.below.values()) {
-		if (child.dependsOn === `all`) {
-			deallocateFromStore<any, any, any>(store, child.key)
-		} else {
-			child.above.delete(molecule.stringKey)
-			if (child.above.size === 0) {
-				deallocateFromStore<any, any, any>(store, child.key)
-			}
-		}
-	}
-	molecule.below.clear()
-
-	const disposalEvent: MoleculeDisposalModern = {
-		type: `molecule_disposal`,
-		subType: `modern`,
-		key: molecule.key,
-		values,
-		provenance,
-	}
-	const target = newest(store)
-	const isTransaction =
-		isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.updates.push(disposalEvent)
-	} else {
-		target.on.moleculeDisposal.next(disposalEvent)
-	}
-	target.molecules.delete(molecule.stringKey)
-
-	for (const parent of molecule.above.values()) {
-		parent.below.delete(molecule.stringKey)
-	}
-}
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function realm<H extends Hierarchy>(store: Store) {
-	const root = makeRootMoleculeInStore(`root`, store)
-	return {
-		root,
-		allocate: <V extends Vassal<H>, A extends Above<V, H>>(
-			provenance: A,
-			key: V,
-		): Claim<H, V, A> => {
-			return allocateIntoStore(store, provenance, key)
-		},
-		deallocate: <V extends Vassal<H>, A extends Above<V, H>>(
-			claim: Claim<H, V, A>,
-		): void => {
-			deallocateFromStore(store, claim)
-		},
-	}
-}
-
-export const T$ = `T$`
-export type T$ = typeof T$
-export type TypeTag<T extends string> = `${T$}--${T}`
-export type SingularTypedKey<T extends string = string> = `${T}::${string}`
-export type CompoundTypedKey<
-	A extends string = string,
-	B extends string = string,
-	C extends string = string,
-> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`
-export type TypedKey<
-	A extends string = string,
-	B extends string = string,
-	C extends string = string,
-> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>
-type Scope = SingularTypedKey[]
-type MutualFealty = {
-	above: Scope
-	below: CompoundTypedKey
-	style: `all` | `any`
-}
-type ExclusiveFealty = {
-	above: TypedKey | `root`
-	below: Scope
-}
-type Fealty = ExclusiveFealty | MutualFealty
-
-export type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>
-
-export type Vassal<H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty
-		? H[K][`below`]
-		: H[K] extends { below: Array<infer V> }
-			? V extends TypedKey
-				? V
-				: never
-			: never
-}[keyof H]
-
-export type Above<TK extends TypedKey, H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty
-		? TK extends H[K][`below`]
-			? H[K][`above`]
-			: never
-		: H[K] extends { below: Array<infer V> }
-			? TK extends V
-				? H[K] extends ExclusiveFealty
-					? H[K][`above`]
-					: never
-				: never
-			: never
-}[keyof H]
-
-export type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty
-		? TK extends H[K][`above`]
-			? H[K][`below`]
-			: TK extends H[K][`above`][number]
-				? H[K][`below`]
-				: never
-		: H[K] extends { above: infer V }
-			? TK extends V
-				? H[K] extends ExclusiveFealty
-					? H[K][`below`][number]
-					: never
-				: never
-			: never
-}[keyof H]
-
-export type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty
-		? TK extends H[K][`above`][number]
-			? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]]
-			: never
-		: never
-}[keyof H]

package/src/molecule.ts

@@ -1,138 +0,0 @@
-import type {
-	ActorToolkit,
-	MoleculeCreation,
-	MoleculeCreationClassic,
-	MoleculeDisposal,
-	MoleculeDisposalClassic,
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadableFamilyToken,
-	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
-	RegularAtomFamilyToken,
-	RegularAtomToken,
-	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
-	WritableToken,
-} from "atom.io"
-import type { JoinToken } from "atom.io/data"
-import type { Flat, Store, Subject, Transceiver } from "atom.io/internal"
-import {
-	createMoleculeFamily,
-	IMPLICIT,
-	makeMoleculeInStore,
-	Molecule,
-} from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
-
-export type CtorToolkit<K extends Canonical> = Flat<
-	Omit<ActorToolkit, `find`> & {
-		bond<T extends Transceiver<any>, J extends Json.Serializable>(
-			family: MutableAtomFamilyToken<T, J, K>,
-		): MutableAtomToken<T, J>
-		bond<T>(family: RegularAtomFamilyToken<T, K>): RegularAtomToken<T>
-		bond<T>(family: WritableSelectorFamilyToken<T, K>): WritableSelectorToken<T>
-		bond<T>(family: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorToken<T>
-		bond<T>(family: WritableFamilyToken<T, K>): WritableToken<T>
-		bond<T>(family: ReadableFamilyToken<T, K>): ReadableToken<T>
-		bond<J extends JoinToken<any, any, any, any, any, any>>(
-			joinToken: J,
-			role: {
-				as: J extends JoinToken<infer A, string, infer B, string, any, any>
-					? A | B
-					: never
-			},
-		): J extends JoinToken<any, any, any, any, any, infer Content>
-			? Content extends null
-				? { relatedKeys: ReadonlySelectorToken<string[]> }
-				: {
-						relatedKeys: ReadonlySelectorToken<string[]>
-						relatedEntries: ReadonlySelectorToken<
-							[key: string, value: Content][]
-						>
-					}
-			: never
-
-		claim(below: MoleculeToken<any>, options: { exclusive: boolean }): void
-
-		spawn<Key extends Canonical, Ctor extends MoleculeConstructor>(
-			family: MoleculeFamilyToken<Ctor>,
-			key: Key,
-			...params: MoleculeParams<Ctor>
-		): MoleculeToken<Ctor>
-	}
->
-export type MoleculeConstructor = new (
-	toolkit: CtorToolkit<any>,
-	key: any,
-	...params: any
-) => any
-
-type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : any[]
-
-export type MoleculeParams<M extends MoleculeConstructor> = Tail<
-	Tail<ConstructorParameters<M>>
->
-
-export type MoleculeFamilyOptions<M extends MoleculeConstructor> = {
-	key: string
-	dependsOn?: `all` | `any`
-	new: M
-}
-export type MoleculeFamilyToken<M extends MoleculeConstructor> = {
-	key: string
-	type: `molecule_family`
-	dependsOn: `all` | `any`
-	__M?: M
-}
-export type MoleculeFamily<M extends MoleculeConstructor> = Flat<
-	MoleculeFamilyToken<M> & {
-		subject: Subject<MoleculeCreationClassic<M> | MoleculeDisposalClassic>
-		dependsOn: `all` | `any`
-		new: M
-	}
->
-export type MoleculeToken<M extends MoleculeConstructor> = {
-	key: MoleculeKey<M>
-	type: `molecule`
-	family?: MoleculeFamilyToken<M>
-	__M?: M
-}
-
-export function moleculeFamily<M extends MoleculeConstructor>(
-	options: MoleculeFamilyOptions<M>,
-): MoleculeFamilyToken<M> {
-	return createMoleculeFamily(IMPLICIT.STORE, options)
-}
-
-export function makeMolecule<M extends MoleculeConstructor>(
-	context: MoleculeToken<any> | MoleculeToken<any>[],
-	family: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-	...params: MoleculeParams<M>
-): MoleculeToken<M> {
-	return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params)
-}
-
-export type MoleculeType<T extends MoleculeFamilyToken<any>> =
-	T extends MoleculeFamilyToken<infer M>
-		? M
-		: T extends MoleculeToken<infer M>
-			? M
-			: never
-export type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`]
-
-export function makeRootMoleculeInStore(
-	key: string,
-	store: Store = IMPLICIT.STORE,
-): MoleculeToken<ObjectConstructor> {
-	const molecule = new Molecule(undefined, key)
-	store.molecules.set(stringifyJson(key), molecule)
-	return {
-		key,
-		type: `molecule`,
-	} as const
-}