atom.io 0.31.1 → 0.32.0

package/{data/src/join.ts → internal/src/join/join-internal.ts}

@@ -1,67 +1,39 @@
 import type {
 	CompoundTypedKey,
+	findState,
 	getState,
-	Hierarchy,
+	JoinOptions,
 	MutableAtomFamilyToken,
 	Read,
 	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
 	RegularAtomFamilyToken,
 	setState,
 	SetterToolkit,
-	SingularTypedKey,
 	Write,
 } from "atom.io"
-import { Anarchy, Realm } from "atom.io"
-import type { findState } from "atom.io/ephemeral"
-import type { seekState } from "atom.io/immortal"
-import type {
-	BaseExternalStoreConfiguration,
-	ExternalStoreConfiguration,
-	JunctionEntriesBase,
-	JunctionSchemaBase,
-	Molecule,
-	Refinement,
-	Store,
-} from "atom.io/internal"
-import {
-	createMutableAtomFamily,
-	createReadonlySelectorFamily,
-	createRegularAtomFamily,
-	findInStore,
-	getFromStore,
-	getJsonFamily,
-	getJsonToken,
-	IMPLICIT,
-	isChildStore,
-	Junction,
-	newest,
-	seekInStore,
-	setIntoStore,
-} from "atom.io/internal"
+import { Anarchy } from "atom.io"
 import type { Canonical, Json, stringified } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
-function capitalize<S extends string>(string: S): Capitalize<S> {
-	return (string[0].toUpperCase() + string.slice(1)) as Capitalize<S>
-}
-
-export interface JoinOptions<
-	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,
-> extends JunctionSchemaBase<ASide, BSide>,
-		Partial<JunctionEntriesBase<AType, BType, Content>> {
-	readonly key: string
-	readonly cardinality: Cardinality
-	readonly isAType: Refinement<string, AType>
-	readonly isBType: Refinement<string, BType>
-}
+import { capitalize } from "../capitalize"
+import {
+	createReadonlySelectorFamily,
+	createRegularAtomFamily,
+	findInStore,
+} from "../families"
+import { getFromStore } from "../get-state"
+import type {
+	BaseExternalStoreConfiguration,
+	ExternalStoreConfiguration,
+} from "../junction"
+import { Junction } from "../junction"
+import type { Molecule } from "../molecule"
+import { createMutableAtomFamily, getJsonFamily, getJsonToken } from "../mutable"
+import { setIntoStore } from "../set-state"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
 
 export type JoinStateFamilies<
 	ASide extends string,
@@ -144,23 +116,6 @@ export type JoinStateFamilies<
 				}
 			: never
 
-export type JoinHierarchy<
-	AType extends SingularTypedKey,
-	BType extends SingularTypedKey,
-> = Hierarchy<
-	[
-		{
-			above: `root`
-			below: [AType, BType]
-		},
-		{
-			above: [AType, BType]
-			style: `all`
-			below: CompoundTypedKey<`content`, AType, BType>
-		},
-	]
->
-
 export class Join<
 	const ASide extends string,
 	const AType extends string,
@@ -233,8 +188,6 @@ export class Join<
 			}) as typeof setState,
 			find: ((...ps: Parameters<typeof findState>) =>
 				findInStore(store, ...ps)) as typeof findState,
-			seek: ((...ps: Parameters<typeof seekState>) =>
-				seekInStore(store, ...ps)) as typeof seekState,
 			json: (token) => getJsonToken(store, token),
 		}
 
@@ -647,365 +600,3 @@ export class Join<
 		}
 	}
 }
-
-export type JoinToken<
-	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 = null,
-> = {
-	key: string
-	type: `join`
-	cardinality: Cardinality
-	a: ASide
-	b: BSide
-	__aType?: AType
-	__bType?: BType
-	__content?: Content
-}
-
-export function join<
-	const ASide extends string,
-	const AType extends string,
-	const BSide extends string,
-	const BType extends string,
-	const Cardinality extends `1:1` | `1:n` | `n:n`,
->(
-	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>,
-	defaultContent?: undefined,
-	store?: Store,
-): JoinToken<ASide, AType, BSide, BType, Cardinality, null>
-export function join<
-	const ASide extends string,
-	const AType extends string,
-	const BSide extends string,
-	const BType extends string,
-	const Cardinality extends `1:1` | `1:n` | `n:n`,
-	const Content extends Json.Object,
->(
-	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
-	defaultContent: Content,
-	store?: Store,
-): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>
-export function join<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
-	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object,
->(
-	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
-	defaultContent: Content | undefined,
-	store: Store = IMPLICIT.STORE,
-): JoinToken<ASide, AType, BSide, BType, Cardinality, Content> {
-	store.joins.set(options.key, new Join(options, defaultContent, store))
-	const token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content> = {
-		key: options.key,
-		type: `join`,
-		a: options.between[0],
-		b: options.between[1],
-		cardinality: options.cardinality,
-	}
-	return token
-}
-
-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
-}
-
-export type JoinStates<
-	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,
-> = Cardinality extends `1:1`
-	? (Content extends Json.Object
-			? {
-					readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
-						[AType, Content] | null,
-						BType
-					>
-				} & {
-					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
-						[BType, Content] | null,
-						AType
-					>
-				}
-			: {}) & {
-			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
-				AType | null,
-				BType
-			>
-		} & {
-			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
-				BType | null,
-				AType
-			>
-		}
-	: Cardinality extends `1:n`
-		? (Content extends Json.Object
-				? {
-						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
-							[AType, Content] | null,
-							BType
-						>
-					} & {
-						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
-							[BType, Content][],
-							AType
-						>
-					}
-				: {}) & {
-				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
-					AType | null,
-					BType
-				>
-			} & {
-				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
-					BType[],
-					AType
-				>
-			}
-		: Cardinality extends `n:n`
-			? (Content extends Json.Object
-					? {
-							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
-								[AType, Content][],
-								BType
-							>
-						} & {
-							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
-								[BType, Content][],
-								AType
-							>
-						}
-					: {}) & {
-					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
-						AType[],
-						BType
-					>
-				} & {
-					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
-						BType[],
-						AType
-					>
-				}
-			: never
-
-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
-}
-
-export function findRelations<
-	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,
-): JoinStates<ASide, AType, BSide, BType, Cardinality, Content> {
-	return findRelationsInStore(token, key, IMPLICIT.STORE)
-}
-
-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)
-	}
-}
-
-export function editRelations<
-	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,
-): void {
-	editRelationsInStore(token, change, IMPLICIT.STORE)
-}
-
-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
-}
-
-export function getInternalRelations<
-	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>,
-): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string> {
-	return getInternalRelationsFromStore(token, IMPLICIT.STORE)
-}

package/internal/src/keys.ts

@@ -8,23 +8,23 @@ export type ReadonlySelectorKey<T> = string & {
 	__brand?: T
 }
 
-export const isAtomKey = (key: string, store: Store): key is AtomKey<unknown> =>
+export const isAtomKey = (store: Store, key: string): key is AtomKey<unknown> =>
 	newest(store).atoms.has(key)
 export const isSelectorKey = (
-	key: string,
 	store: Store,
+	key: string,
 ): key is SelectorKey<unknown> => newest(store).selectors.has(key)
 export const isReadonlySelectorKey = (
-	key: string,
 	store: Store,
+	key: string,
 ): key is ReadonlySelectorKey<unknown> =>
 	newest(store).readonlySelectors.has(key)
 
 export type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>
 export const isStateKey = (
-	key: string,
 	store: Store,
+	key: string,
 ): key is StateKey<unknown> =>
-	isAtomKey(key, store) ||
-	isSelectorKey(key, store) ||
-	isReadonlySelectorKey(key, store)
+	isAtomKey(store, key) ||
+	isSelectorKey(store, key) ||
+	isReadonlySelectorKey(store, key)

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

@@ -80,7 +80,7 @@ export function createMutableAtomFamily<
 	}) satisfies MutableAtomFamily<T, J, K>
 
 	store.families.set(options.key, atomFamily)
-	selectJsonFamily(atomFamily, options, store)
+	selectJsonFamily(store, atomFamily, options)
 	new FamilyTracker(atomFamily, store)
 	return familyToken
 }

package/internal/src/mutable/create-mutable-atom.ts

@@ -61,8 +61,8 @@ export function createMutableAtom<
 	}
 	const initialValue = options.default()
 	target.atoms.set(newAtom.key, newAtom)
-	markAtomAsDefault(options.key, store)
-	cacheValue(options.key, initialValue, subject, target)
+	markAtomAsDefault(store, options.key)
+	cacheValue(target, options.key, initialValue, subject)
 	const token = deposit(newAtom)
 	if (options.effects) {
 		let effectIndex = 0
@@ -73,7 +73,7 @@ export function createMutableAtom<
 					setIntoStore(store, token, next)
 				},
 				onSet: (handle: UpdateHandler<T>) =>
-					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
+					subscribeToState(store, token, `effect[${effectIndex}]`, handle),
 			})
 			if (cleanup) {
 				cleanupFunctions.push(cleanup)

package/internal/src/mutable/get-json-token.ts

@@ -27,7 +27,7 @@ export const getJsonToken = <
 			key: jsonFamilyKey,
 			type: `selector_family`,
 		}
-		const family = withdraw(jsonFamilyToken, target)
+		const family = withdraw(target, jsonFamilyToken)
 		const subKey = JSON.parse(mutableAtomToken.family.subKey)
 		const jsonToken = findInStore(store, family, subKey)
 		return jsonToken

package/internal/src/mutable/tracker-family.ts

@@ -2,7 +2,7 @@ import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
 import type { MutableAtomFamily, RegularAtomFamily } from ".."
-import { createRegularAtomFamily, seekInStore } from "../families"
+import { createRegularAtomFamily } from "../families"
 import { type Store, withdraw } from "../store"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
@@ -11,6 +11,7 @@ export class FamilyTracker<
 	Core extends Transceiver<any>,
 	FamilyMemberKey extends Canonical,
 > {
+	private trackers: Map<FamilyMemberKey, Tracker<Core>> = new Map()
 	private readonly Update: Core extends Transceiver<infer Signal>
 		? Signal
 		: never
@@ -36,26 +37,27 @@ export class FamilyTracker<
 			},
 			[`mutable`, `updates`],
 		)
-		this.latestUpdateAtoms = withdraw(updateAtoms, store)
+		this.latestUpdateAtoms = withdraw(store, updateAtoms)
 		this.mutableAtoms = mutableAtoms
 		this.mutableAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,
 			(event) => {
-				if (event.token.family) {
-					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
-					seekInStore(store, this.latestUpdateAtoms, key)
-					new Tracker<Core>(event.token, store)
-				}
-			},
-		)
-		this.latestUpdateAtoms.subject.subscribe(
-			`store=${store.config.name}::tracker-atom-family`,
-			(event) => {
-				if (event.token.family) {
-					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
-					const mutableAtomToken = seekInStore(store, this.mutableAtoms, key)
-					if (mutableAtomToken) {
-						new Tracker<Core>(mutableAtomToken, store)
+				const { type, token } = event
+				if (token.family) {
+					const key = parseJson(token.family.subKey)
+					switch (type) {
+						case `state_creation`:
+							this.trackers.set(key, new Tracker<Core>(token, store))
+							break
+						case `state_disposal`:
+							{
+								const tracker = this.trackers.get(key)
+								if (tracker) {
+									tracker[Symbol.dispose]()
+									this.trackers.delete(key)
+								}
+							}
+							break
 					}
 				}
 			},

package/internal/src/mutable/tracker.ts

@@ -70,7 +70,9 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			},
 		)
 		this.unsubscribeFromState = subscribeToState(
+			target,
 			mutableState,
+			subscriptionKey,
 			(update) => {
 				if (update.newValue !== update.oldValue) {
 					this.unsubscribeFromInnerValue()
@@ -82,8 +84,6 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					)
 				}
 			},
-			subscriptionKey,
-			target,
 		)
 	}
 
@@ -96,7 +96,9 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
 		subscribeToState(
+			target,
 			latestUpdateState,
+			subscriptionKey,
 			({ newValue, oldValue }) => {
 				const timelineId = target.timelineTopics.getRelatedKey(
 					latestUpdateState.key,
@@ -106,7 +108,9 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					const timelineData = target.timelines.get(timelineId)
 					if (timelineData?.timeTraveling) {
 						const unsubscribe = subscribeToTimeline(
+							target,
 							{ key: timelineId, type: `timeline` },
+							subscriptionKey,
 							(update) => {
 								unsubscribe()
 								setIntoStore(target, mutableState, (transceiver) => {
@@ -118,8 +122,6 @@ export class Tracker<Mutable extends Transceiver<any>> {
 									return transceiver
 								})
 							},
-							subscriptionKey,
-							target,
 						)
 						return
 					}
@@ -152,15 +154,13 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					},
 				)
 			},
-			subscriptionKey,
-			target,
 		)
 	}
 
 	public mutableState: MutableAtomToken<Mutable, Json.Serializable>
 	public latestUpdateState: RegularAtomToken<typeof this.Update | null>
 
-	public dispose: () => void
+	public [Symbol.dispose]: () => void
 
 	public constructor(
 		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
@@ -172,7 +172,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		this.observeCore(mutableState, this.latestUpdateState, target)
 		this.updateCore(mutableState, this.latestUpdateState, target)
 		target.trackers.set(mutableState.key, this)
-		this.dispose = () => {
+		this[Symbol.dispose] = () => {
 			this.unsubscribeFromInnerValue()
 			this.unsubscribeFromState()
 			target.trackers.delete(mutableState.key)

package/internal/src/pretty-print.ts

@@ -1,6 +1,6 @@
 import type { AtomIOToken } from "atom.io"
 
-const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
+import { capitalize } from "./capitalize"
 
 export function prettyPrintTokenType(token: AtomIOToken): string {
 	return token.type.split(`_`).map(capitalize).join(` `)