atom.io 0.38.1 → 0.39.0

package/src/internal/overlays/set-overlay.ts

@@ -0,0 +1,55 @@
+export class SetOverlay<T> extends Set<T> {
+	public deleted: Set<T> = new Set()
+	public source: Set<T>
+
+	public constructor(source: Set<T>) {
+		super()
+		this.source = source
+	}
+
+	public add(value: T): this {
+		if (this.source.has(value)) {
+			this.deleted.delete(value)
+			return this
+		}
+		return super.add(value)
+	}
+
+	public hasOwn(member: T): boolean {
+		return super.has(member)
+	}
+
+	public has(key: T): boolean {
+		return !this.deleted.has(key) && (super.has(key) || this.source.has(key))
+	}
+
+	public delete(key: T): boolean {
+		if (this.source.has(key)) {
+			this.deleted.add(key)
+			return true
+		}
+		return super.delete(key)
+	}
+
+	public clear(): void {
+		this.deleted = new Set(this.source)
+		super.clear()
+	}
+
+	public *[Symbol.iterator](): SetIterator<T> {
+		yield* super[Symbol.iterator]()
+		for (const value of this.source) {
+			if (!this.deleted.has(value)) {
+				yield value
+			}
+		}
+	}
+
+	public *iterateOwn(): SetIterator<T> {
+		yield* super[Symbol.iterator]()
+	}
+
+	public get size(): number {
+		return super.size + this.source.size - this.deleted.size
+	}
+}

package/src/internal/selector/create-readonly-held-selector.ts

@@ -21,6 +21,8 @@ export function createReadonlyHeldSelector<T extends object>(
 	const covered = new Set<string>()
 	const { key, const: constant } = options
 	const type = `readonly_held_selector` as const
+	store.logger.info(`🔨`, type, key, `is being created`)
+
 	const { get, find, json } = registerSelector(target, type, key, covered)
 
 	const getFrom = (innerTarget: Store) => {
@@ -35,6 +37,7 @@ export function createReadonlyHeldSelector<T extends object>(
 		innerTarget.selectorAtoms.delete(key)
 		options.get({ get, find, json }, constant)
 		writeToCache(innerTarget, readonlySelector, constant)
+		store.logger.info(`✨`, type, key, `=`, constant)
 		covered.clear()
 		return constant
 	}
@@ -46,17 +49,11 @@ export function createReadonlyHeldSelector<T extends object>(
 		getFrom,
 		install: (s: Store) => createReadonlyHeldSelector(s, options, family),
 	}
-	if (family) {
-		readonlySelector.family = family
-	}
+	if (family) readonlySelector.family = family
+
 	target.readonlySelectors.set(key, readonlySelector)
-	store.logger.info(`✨`, type, key, `=`, constant)
-	const token: ReadonlyHeldSelectorToken<T> = {
-		key,
-		type,
-	}
-	if (family) {
-		token.family = family
-	}
+	const token: ReadonlyHeldSelectorToken<T> = { key, type }
+	if (family) token.family = family
+
 	return token
 }

package/src/internal/selector/create-readonly-pure-selector.ts

@@ -21,6 +21,8 @@ export function createReadonlyPureSelector<T>(
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `readonly_pure_selector` as const
+	store.logger.info(`🔨`, type, key, `is being created`)
+
 	const { get, find, json } = registerSelector(target, type, key, covered)
 
 	const getFrom = () => {
@@ -48,16 +50,12 @@ export function createReadonlyPureSelector<T>(
 		getFrom,
 		install: (s: Store) => createReadonlyPureSelector(s, options, family),
 	}
-	if (family) {
-		readonlySelector.family = family
-	}
+	if (family) readonlySelector.family = family
+
 	target.readonlySelectors.set(key, readonlySelector)
-	const token: ReadonlyPureSelectorToken<T> = {
-		key,
-		type,
-	}
-	if (family) {
-		token.family = family
-	}
+
+	const token: ReadonlyPureSelectorToken<T> = { key, type }
+	if (family) token.family = family
+
 	return token
 }

package/src/internal/selector/create-writable-held-selector.ts

@@ -21,6 +21,8 @@ export function createWritableHeldSelector<T extends object>(
 	const covered = new Set<string>()
 	const { key, const: constant } = options
 	const type = `writable_held_selector` as const
+	store.logger.info(`🔨`, type, key, `is being created`)
+
 	const setterToolkit = registerSelector(target, type, key, covered)
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
@@ -54,14 +56,12 @@ export function createWritableHeldSelector<T extends object>(
 		setSelf,
 		install: (s: Store) => createWritableHeldSelector(s, options, family),
 	}
-	if (family) {
-		mySelector.family = family
-	}
+	if (family) mySelector.family = family
+
 	target.writableSelectors.set(key, mySelector)
 
 	const token: WritableHeldSelectorToken<T> = { key, type }
-	if (family) {
-		token.family = family
-	}
+	if (family) token.family = family
+
 	return token
 }

package/src/internal/selector/create-writable-pure-selector.ts

@@ -21,6 +21,8 @@ export function createWritablePureSelector<T>(
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `writable_pure_selector` as const
+	store.logger.info(`🔨`, type, key, `is being created`)
+
 	const setterToolkit = registerSelector(target, type, key, covered)
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
@@ -57,8 +59,6 @@ export function createWritablePureSelector<T>(
 	if (family) mySelector.family = family
 
 	target.writableSelectors.set(key, mySelector)
-	const initialValue = getFrom(target)
-	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue)
 
 	const token: WritablePureSelectorToken<T> = { key, type }
 	if (family) token.family = family

package/src/internal/selector/register-selector.ts

@@ -37,11 +37,10 @@ export function registerSelector(
 				| [ReadableToken<any>]
 		) => {
 			const target = newest(store)
-			const { token, familyToken, subKey } = reduceReference(store, ...params)
+			const { token, family, subKey } = reduceReference(store, ...params)
 			let dependencyValue: unknown
-			if (`counterfeit` in token && familyToken && subKey) {
-				const dependencyFamily = withdraw(store, familyToken)
-				dependencyValue = getFallback(store, token, dependencyFamily, subKey)
+			if (`counterfeit` in token && family && subKey) {
+				dependencyValue = getFallback(store, token, family, subKey)
 			} else {
 				const dependency = withdraw(store, token)
 				dependencyValue = readOrComputeValue(store, dependency)

package/src/internal/set-state/dispatch-state-update.ts

@@ -1,11 +1,12 @@
-import type {
-	AtomToken,
-	AtomUpdateEvent,
-	StateUpdate,
-	WritableToken,
-} from "atom.io"
+import type { AtomUpdateEvent, StateCreationEvent, StateUpdate } from "atom.io"
 
-import type { MutableAtom, WritableState } from ".."
+import {
+	type MutableAtom,
+	newest,
+	type Subject,
+	type WritableFamily,
+	type WritableState,
+} from ".."
 import { hasRole } from "../atom"
 import { readOrComputeValue } from "../get-state"
 import type { Transceiver } from "../mutable"
@@ -19,8 +20,43 @@ export function dispatchOrDeferStateUpdate<T>(
 	target: Store & { operation: OpenOperation<any> },
 	state: WritableState<T>,
 	[oldValue, newValue]: [T, T],
-	_stateIsNewlyCreated: boolean,
+	stateIsNewlyCreated: boolean,
+	family?: WritableFamily<T, any>,
 ): void {
+	const token = deposit(state)
+	if (stateIsNewlyCreated && family) {
+		state.subject.next({ newValue })
+		const stateCreationEvent: StateCreationEvent<any> = {
+			type: `state_creation`,
+			subType: `writable`,
+			token,
+			timestamp: Date.now(),
+			value: newValue,
+		}
+		const familySubject = family.subject as Subject<StateCreationEvent<any>>
+		familySubject.next(stateCreationEvent)
+		const innerTarget = newest(target)
+		if (token.family) {
+			if (isRootStore(innerTarget)) {
+				switch (token.type) {
+					case `atom`:
+					case `mutable_atom`:
+						target.on.atomCreation.next(token)
+						break
+					case `writable_pure_selector`:
+					case `writable_held_selector`:
+						target.on.selectorCreation.next(token)
+						break
+				}
+			} else if (
+				isChildStore(innerTarget) &&
+				innerTarget.on.transactionApplying.state === null
+			) {
+				innerTarget.transactionMeta.update.subEvents.push(stateCreationEvent)
+			}
+		}
+		return /* bailing early here to avoid redundant update */
+	}
 	const { key, subject, type } = state
 
 	const update: StateUpdate<T> = {
@@ -61,13 +97,11 @@ export function dispatchOrDeferStateUpdate<T>(
 
 	if (isChildStore(target) && (type === `mutable_atom` || type === `atom`)) {
 		if (target.on.transactionApplying.state === null) {
-			const token: WritableToken<T> = deposit(state)
-
 			if (isTransceiver(newValue)) {
 				return
 			}
 			const { timestamp } = target.operation
-			const atomUpdate: AtomUpdateEvent<AtomToken<T>> = {
+			const atomUpdate: AtomUpdateEvent<any> = {
 				type: `atom_update`,
 				token,
 				timestamp,

package/src/internal/set-state/operate-on-store.ts

@@ -1,6 +1,7 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
 import { type Canonical, parseJson } from "atom.io/json"
 
+import type { WritableFamily } from ".."
 import { seekInStore } from "../families"
 import { getFamilyOfToken } from "../families/get-family-of-token"
 import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
@@ -32,7 +33,7 @@ export function operateOnStore<T, New extends T>(
 	let existingToken: WritableToken<T> | undefined
 	let brandNewToken: WritableToken<T> | undefined
 	let token: WritableToken<T>
-	let family: WritableFamilyToken<T, Canonical> | null
+	let family: WritableFamily<T, Canonical> | undefined
 	let key: Canonical | null
 	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
 	if (params.length === 2) {
@@ -43,20 +44,18 @@ export function operateOnStore<T, New extends T>(
 			key = parseJson(token.family.subKey)
 			existingToken = seekInStore(store, family, key)
 			if (!existingToken) {
-				brandNewToken = mintInStore(store, family, key, MUST_CREATE)
-				token = brandNewToken
+				token = brandNewToken = mintInStore(store, family, key, MUST_CREATE)
 			} else {
 				token = existingToken
 			}
 		}
 	} else {
-		family = params[0]
+		family = withdraw(store, params[0])
 		key = params[1]
 		value = params[2]
 		existingToken = seekInStore(store, family, key)
 		if (!existingToken) {
-			brandNewToken = mintInStore(store, family, key, MUST_CREATE)
-			token = brandNewToken
+			token = brandNewToken = mintInStore(store, family, key, MUST_CREATE)
 		} else {
 			token = existingToken
 		}
@@ -121,8 +120,9 @@ export function operateOnStore<T, New extends T>(
 	} else {
 		protoUpdate = setAtomOrSelector(target, state, value)
 	}
+
 	const isNewlyCreated = Boolean(brandNewToken)
-	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated)
+	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated, family)
 
 	if (opMode === OWN_OP) {
 		closeOperation(target)

package/src/internal/set-state/set-atom.ts

@@ -12,7 +12,7 @@ export const setAtom = <T>(
 ): [oldValue: T, newValue: T] => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)
 	let newValue = become(next)(oldValue)
-	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
+	target.logger.info(`⭐`, `atom`, atom.key, `setting value`, newValue)
 	newValue = writeToCache(target, atom, newValue)
 	markDone(target, atom.key)
 	evictDownstreamFromAtom(target, atom)

package/src/internal/set-state/set-selector.ts

@@ -28,7 +28,7 @@ export function setSelector<T>(
 			newValue = constant
 	}
 
-	target.logger.info(`📝`, type, key, `setting to`, newValue)
+	target.logger.info(`⭐`, type, key, `setting to`, newValue)
 	markDone(target, key)
 	selector.setSelf(newValue)
 	return [oldValue, newValue]

package/src/internal/store/withdraw.ts

@@ -171,14 +171,14 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: SelectorFamilyToken<T, K>,
 ): SelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
-	store: Store,
-	token: ReadableFamilyToken<T, K>,
-): ReadableFamily<T, K>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: WritableFamilyToken<T, K>,
 ): WritableFamily<T, K>
+export function withdraw<T, K extends Canonical>(
+	store: Store,
+	token: ReadableFamilyToken<T, K>,
+): ReadableFamily<T, K>
 
 export function withdraw<T extends Fn>(
 	store: Store,

package/src/internal/timeline/time-travel.ts

@@ -1,12 +1,12 @@
 import type { TimelineToken } from "atom.io"
 
 import {
-	ingestAtomUpdate,
+	ingestAtomUpdateEvent,
 	ingestCreationEvent,
 	ingestDisposalEvent,
-	ingestSelectorUpdate,
-	ingestTransactionUpdate,
-} from "../ingest-updates"
+	ingestSelectorUpdateEvent,
+	ingestTransactionOutcomeEvent,
+} from "../events"
 import type { Store } from "../store"
 
 export const timeTravel = (
@@ -50,28 +50,28 @@ export const timeTravel = (
 		--timelineData.at
 	}
 
-	const update = timelineData.history[timelineData.at]
+	const event = timelineData.history[timelineData.at]
 	const applying = action === `redo` ? `newValue` : `oldValue`
 
-	switch (update.type) {
+	switch (event.type) {
 		case `atom_update`: {
-			ingestAtomUpdate(applying, update, store)
+			ingestAtomUpdateEvent(store, event, applying)
 			break
 		}
 		case `selector_update`: {
-			ingestSelectorUpdate(applying, update, store)
+			ingestSelectorUpdateEvent(store, event, applying)
 			break
 		}
 		case `transaction_outcome`: {
-			ingestTransactionUpdate(applying, update, store)
+			ingestTransactionOutcomeEvent(store, event, applying)
 			break
 		}
 		case `state_creation`: {
-			ingestCreationEvent(update, applying, store)
+			ingestCreationEvent(store, event, applying)
 			break
 		}
 		case `state_disposal`: {
-			ingestDisposalEvent(update, applying, store)
+			ingestDisposalEvent(store, event, applying)
 			break
 		}
 		case `molecule_creation`:

package/src/internal/transaction/apply-transaction.ts

@@ -1,4 +1,4 @@
-import { ingestTransactionUpdate } from "../ingest-updates"
+import { ingestTransactionOutcomeEvent } from "../events"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { withdraw } from "../store"
@@ -6,10 +6,10 @@ import type { Fn } from "../utility-types"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 
-export const applyTransaction = <F extends Fn>(
-	output: ReturnType<F>,
+export function applyTransaction<F extends Fn>(
 	store: Store,
-): void => {
+	output: ReturnType<F>,
+): void {
 	const child = newest(store)
 	const { parent } = child
 	if (
@@ -38,7 +38,7 @@ export const applyTransaction = <F extends Fn>(
 		updates,
 	)
 
-	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent)
+	ingestTransactionOutcomeEvent(parent, child.transactionMeta.update, `newValue`)
 
 	if (isRootStore(parent)) {
 		setEpochNumberOfAction(

package/src/internal/transaction/build-transaction.ts

@@ -11,10 +11,9 @@ import { arbitrary } from "../arbitrary"
 import { disposeFromStore, findInStore } from "../families"
 import { getEnvironmentData } from "../get-environment-data"
 import { getFromStore } from "../get-state"
-import { Junction } from "../junction"
-import { LazyMap } from "../lazy-map"
 import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
+import { MapOverlay } from "../overlays/map-overlay"
 import { resetInStore, setIntoStore } from "../set-state"
 import type { Store } from "../store"
 import type { Fn } from "../utility-types"
@@ -36,35 +35,27 @@ export const buildTransaction = (
 		loggers: parent.loggers,
 		logger: parent.logger,
 		config: parent.config,
-		atoms: new LazyMap(parent.atoms),
+		atoms: new MapOverlay(parent.atoms),
 		atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
-		families: new LazyMap(parent.families),
-		joins: new LazyMap(parent.joins),
+		families: new MapOverlay(parent.families),
+		joins: new MapOverlay(parent.joins),
 		operation: { open: false },
-		readonlySelectors: new LazyMap(parent.readonlySelectors),
-		timelines: new LazyMap(parent.timelines),
-		timelineTopics: new Junction(parent.timelineTopics.toJSON()),
+		readonlySelectors: new MapOverlay(parent.readonlySelectors),
+		timelines: new MapOverlay(parent.timelines),
+		timelineTopics: parent.timelineTopics.overlay(),
 		trackers: new Map(),
-		transactions: new LazyMap(parent.transactions),
-		selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
-		selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
-			makeContentKey: (...keys) => keys.sort().join(`:`),
-		}),
-		writableSelectors: new LazyMap(parent.writableSelectors),
-		valueMap: new LazyMap(parent.valueMap),
+		transactions: new MapOverlay(parent.transactions),
+		selectorAtoms: parent.selectorAtoms.overlay(),
+		selectorGraph: parent.selectorGraph.overlay(),
+		writableSelectors: new MapOverlay(parent.writableSelectors),
+		valueMap: new MapOverlay(parent.valueMap),
 		defaults: parent.defaults,
 		disposalTraces: store.disposalTraces.copy(),
-		molecules: new LazyMap(parent.molecules),
-		moleculeGraph: new Junction(parent.moleculeGraph.toJSON(), {
-			makeContentKey: parent.moleculeGraph.makeContentKey,
-		}),
-		moleculeData: new Junction(parent.moleculeData.toJSON(), {
-			makeContentKey: parent.moleculeData.makeContentKey,
-		}),
-		moleculeJoins: new Junction(parent.moleculeJoins.toJSON(), {
-			makeContentKey: parent.moleculeJoins.makeContentKey,
-		}),
-		miscResources: new LazyMap(parent.miscResources),
+		molecules: new MapOverlay(parent.molecules),
+		moleculeGraph: parent.moleculeGraph.overlay(),
+		moleculeData: parent.moleculeData.overlay(),
+		moleculeJoins: parent.moleculeJoins.overlay(),
+		miscResources: new MapOverlay(parent.miscResources),
 	}
 	const epoch = getEpochNumberOfAction(store, token.key)
 	const transactionMeta: TransactionProgress<Fn> = {

package/src/internal/transaction/create-transaction.ts

@@ -37,7 +37,7 @@ export function createTransaction<F extends Fn>(
 				const target = newest(store)
 				const { toolkit } = childStore.transactionMeta
 				const output = options.do(toolkit, ...params)
-				applyTransaction(output, target)
+				applyTransaction<F>(target, output)
 				return output
 			} catch (thrown) {
 				abortTransaction(target)

package/src/internal/transaction/is-root-store.ts

@@ -1,4 +1,4 @@
-import type { LazyMap } from "../lazy-map"
+import type { MapOverlay } from "../overlays/map-overlay"
 import type { Store } from "../store"
 import type { Fn } from "../utility-types"
 import type { TransactionEpoch, TransactionProgress } from "."
@@ -12,7 +12,7 @@ export interface ChildStore extends Store {
 	transactionMeta: TransactionProgress<Fn>
 	parent: ChildStore | RootStore
 	child: ChildStore | null
-	valueMap: LazyMap<string, any>
+	valueMap: MapOverlay<string, any>
 }
 
 export function isRootStore(store: Store): store is RootStore {

package/src/main/events.ts

@@ -7,11 +7,12 @@ import type {
 	ReadableToken,
 	SelectorToken,
 	TransactionToken,
+	WritableToken,
 } from "./tokens"
 import type { TokenType } from "./validators"
 
 export type StateUpdate<T> = {
-	readonly oldValue: ViewOf<T>
+	readonly oldValue?: ViewOf<T>
 	readonly newValue: ViewOf<T>
 }
 
@@ -32,15 +33,25 @@ export type TimelineSelectorUpdateEvent<A extends TimelineManageable> = {
 export type StateLifecycleEvent<R extends ReadableToken<any>> =
 	| StateCreationEvent<R>
 	| StateDisposalEvent<R>
-export type StateCreationEvent<R extends ReadableToken<any>> = {
+export type StateCreationEvent<R extends ReadableToken<any>> =
+	| ReadableStateCreationEvent<R>
+	| (R extends WritableToken<any> ? WritableStateCreationEvent<R> : never)
+export type ReadableStateCreationEvent<R extends ReadableToken<any>> = {
 	type: `state_creation`
+	subType: `readable`
 	token: R
 	timestamp: number
 }
+export type WritableStateCreationEvent<W extends WritableToken<any>> = {
+	type: `state_creation`
+	subType: `writable`
+	token: W
+	timestamp: number
+	value?: TokenType<W>
+}
 export type StateDisposalEvent<R extends ReadableToken<any>> =
 	| AtomDisposalEvent<R>
 	| SelectorDisposalEvent<R>
-
 export type AtomDisposalEvent<R extends ReadableToken<any>> = {
 	type: `state_disposal`
 	subType: `atom`