atom.io 0.6.6 → 0.6.7

package/src/internal/atom-internal.ts

@@ -1,9 +1,7 @@
-import HAMT from "hamt_plus"
-
 import { Subject } from "."
 import { deposit } from "./get"
 import { markAtomAsDefault } from "./is-default"
-import { cacheValue, hasKeyBeenUsed } from "./operation"
+import { cacheValue } from "./operation"
 import type { Store } from "./store"
 import { IMPLICIT } from "./store"
 import { target } from "./transaction-internal"
@@ -25,11 +23,12 @@ export function atom__INTERNAL<T>(
 	store: Store = IMPLICIT.STORE,
 ): AtomToken<T> {
 	const core = target(store)
-	if (hasKeyBeenUsed(options.key, store)) {
+	const existing = core.atoms.get(options.key)
+	if (existing) {
 		store.config.logger?.error?.(
 			`Key "${options.key}" already exists in the store.`,
 		)
-		return deposit(core.atoms.get(options.key))
+		return deposit(existing)
 	}
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const newAtom = {
@@ -40,7 +39,7 @@ export function atom__INTERNAL<T>(
 	} as const
 	const initialValue =
 		options.default instanceof Function ? options.default() : options.default
-	core.atoms = HAMT.set(newAtom.key, newAtom, core.atoms)
+	core.atoms.set(newAtom.key, newAtom)
 	markAtomAsDefault(options.key, store)
 	cacheValue(options.key, initialValue, store)
 	const token = deposit(newAtom)

package/src/internal/get.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type {
@@ -29,9 +27,9 @@ export function lookup(
 	store: Store,
 ): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown> {
 	const core = target(store)
-	const type = HAMT.has(key, core.atoms)
+	const type = core.atoms.has(key)
 		? `atom`
-		: HAMT.has(key, core.selectors)
+		: core.selectors.has(key)
 		? `selector`
 		: `readonly_selector`
 	return { key, type } as any
@@ -75,11 +73,11 @@ export function withdraw<T>(
 	| null {
 	const core = target(store)
 	return (
-		HAMT.get(token.key, core.atoms) ??
-		HAMT.get(token.key, core.selectors) ??
-		HAMT.get(token.key, core.readonlySelectors) ??
-		HAMT.get(token.key, core.transactions) ??
-		HAMT.get(token.key, core.timelines) ??
+		core.atoms.get(token.key) ??
+		core.selectors.get(token.key) ??
+		core.readonlySelectors.get(token.key) ??
+		core.transactions.get(token.key) ??
+		core.timelines.get(token.key) ??
 		null
 	)
 }

package/src/internal/operation.ts

@@ -1,6 +1,3 @@
-import type { Hamt } from "hamt_plus"
-import HAMT from "hamt_plus"
-
 import type { Atom, ReadonlySelector, Selector } from "."
 import { target } from "."
 import type { Store } from "./store"
@@ -14,7 +11,7 @@ export type OperationProgress =
 	| {
 			open: true
 			done: Set<string>
-			prev: Hamt<any, string>
+			prev: Map<string, any>
 			time: number
 			token: StateToken<any>
 	  }
@@ -30,7 +27,7 @@ export const openOperation = (token: StateToken<any>, store: Store): void => {
 	core.operation = {
 		open: true,
 		done: new Set(),
-		prev: store.valueMap,
+		prev: new Map(store.valueMap),
 		time: Date.now(),
 		token,
 	}
@@ -74,9 +71,9 @@ export const recallState = <T>(
 		store.config.logger?.warn(
 			`recall called outside of an operation. This is probably a bug.`,
 		)
-		return HAMT.get(state.key, core.valueMap)
+		return core.valueMap.get(state.key)
 	}
-	return HAMT.get(state.key, core.operation.prev)
+	return core.operation.prev.get(state.key)
 }
 
 export const cacheValue = (
@@ -85,7 +82,7 @@ export const cacheValue = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.valueMap = HAMT.set(key, value, core.valueMap)
+	core.valueMap.set(key, value)
 }
 
 export const evictCachedValue = (
@@ -93,24 +90,24 @@ export const evictCachedValue = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.valueMap = HAMT.remove(key, core.valueMap)
+	core.valueMap.delete(key)
 }
 export const readCachedValue = <T>(
 	key: string,
 	store: Store = IMPLICIT.STORE,
-): T => HAMT.get(key, target(store).valueMap)
+): T => target(store).valueMap.get(key)
 
 export const isValueCached = (
 	key: string,
 	store: Store = IMPLICIT.STORE,
-): boolean => HAMT.has(key, target(store).valueMap)
+): boolean => target(store).valueMap.has(key)
 
 export const storeAtom = (
 	atom: Atom<any>,
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.atoms = HAMT.set(atom.key, atom, core.atoms)
+	core.atoms.set(atom.key, atom)
 }
 
 export const storeSelector = (
@@ -118,7 +115,7 @@ export const storeSelector = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.selectors = HAMT.set(selector.key, selector, core.selectors)
+	core.selectors.set(selector.key, selector)
 }
 
 export const storeReadonlySelector = (
@@ -126,11 +123,7 @@ export const storeReadonlySelector = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.readonlySelectors = HAMT.set(
-		selector.key,
-		selector,
-		core.readonlySelectors,
-	)
+	core.readonlySelectors.set(selector.key, selector)
 }
 
 export const hasKeyBeenUsed = (
@@ -139,8 +132,8 @@ export const hasKeyBeenUsed = (
 ): boolean => {
 	const core = target(store)
 	return (
-		HAMT.has(key, core.atoms) ||
-		HAMT.has(key, core.selectors) ||
-		HAMT.has(key, core.readonlySelectors)
+		core.atoms.has(key) ||
+		core.selectors.has(key) ||
+		core.readonlySelectors.has(key)
 	)
 }

package/src/internal/selector/create-read-write-selector.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { become } from "~/packages/anvl/src/function"
 
 import { Subject } from ".."
@@ -30,8 +28,14 @@ export const createReadWriteSelector = <T>(
 	}
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
-		store.config.logger?.info(`   <- "${options.key}" became`, next)
 		const oldValue = getSelf()
+		store.config.logger?.info(
+			`   <- "${options.key}" went (`,
+			oldValue,
+			`->`,
+			next,
+			`)`,
+		)
 		const newValue = become(next)(oldValue)
 		cacheValue(options.key, newValue, store)
 		markDone(options.key, store)
@@ -49,7 +53,7 @@ export const createReadWriteSelector = <T>(
 		type: `selector`,
 		...(family && { family }),
 	}
-	core.selectors = HAMT.set(options.key, mySelector, core.selectors)
+	core.selectors.set(options.key, mySelector)
 	const initialValue = getSelf()
 	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
 	const token: SelectorToken<T> = {

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

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { registerSelector } from "./register-selector"
 import { Subject } from ".."
 import type {
@@ -35,11 +33,7 @@ export const createReadonlySelector = <T>(
 		type: `readonly_selector`,
 		...(family && { family }),
 	}
-	core.readonlySelectors = HAMT.set(
-		options.key,
-		readonlySelector,
-		core.readonlySelectors,
-	)
+	core.readonlySelectors.set(options.key, readonlySelector)
 	const initialValue = getSelf()
 	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
 	const token: ReadonlySelectorToken<T> = {

package/src/internal/selector-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { target, IMPLICIT } from "."
 import type { Store, Subject } from "."
 import { createReadWriteSelector } from "./selector/create-read-write-selector"
@@ -47,7 +45,7 @@ export function selector__INTERNAL<T>(
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
 	const core = target(store)
 
-	if (HAMT.has(options.key, core.selectors)) {
+	if (core.selectors.has(options.key)) {
 		store.config.logger?.error(
 			`Key "${options.key}" already exists in the store.`,
 		)

package/src/internal/set.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { become } from "~/packages/anvl/src/function"
 
 import type { Atom, Selector, Store } from "."
@@ -37,8 +35,7 @@ export const evictDownStream = <T>(
 			return
 		}
 		const state =
-			HAMT.get(stateKey, core.selectors) ??
-			HAMT.get(stateKey, core.readonlySelectors)
+			core.selectors.get(stateKey) ?? core.readonlySelectors.get(stateKey)
 		if (!state) {
 			store.config.logger?.info(
 				`   || ${stateKey} is an atom, and can't be downstream`,

package/src/internal/store.ts

@@ -1,6 +1,3 @@
-import type { Hamt } from "hamt_plus"
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 import { doNothing } from "~/packages/anvl/src/function"
 import { Join } from "~/packages/anvl/src/join"
@@ -40,16 +37,16 @@ export type StoreCore = Pick<
 >
 
 export interface Store {
-	atoms: Hamt<Atom<any>, string>
+	atoms: Map<string, Atom<any>>
 	atomsThatAreDefault: Set<string>
-	readonlySelectors: Hamt<ReadonlySelector<any>, string>
+	readonlySelectors: Map<string, ReadonlySelector<any>>
 	selectorAtoms: Join<null, `selectorKey`, `atomKey`>
 	selectorGraph: Join<{ source: string }>
-	selectors: Hamt<Selector<any>, string>
+	selectors: Map<string, Selector<any>>
 	timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-	timelines: Hamt<Timeline, string>
-	transactions: Hamt<Transaction<any>, string>
-	valueMap: Hamt<any, string>
+	timelines: Map<string, Timeline>
+	transactions: Map<string, Transaction<any>>
+	valueMap: Map<string, any>
 
 	subject: {
 		atomCreation: Subject<AtomToken<unknown>>
@@ -71,7 +68,7 @@ export interface Store {
 }
 
 export const createStore = (name: string, store: Store | null = null): Store => {
-	const copiedStore = {
+	const created = {
 		...(store ??
 			(() => ({
 				atomsThatAreDefault: new Set(),
@@ -79,14 +76,14 @@ export const createStore = (name: string, store: Store | null = null): Store =>
 					.from(`selectorKey`)
 					.to(`atomKey`),
 				selectorGraph: new Join({ relationType: `n:n` }),
-				valueMap: HAMT.make<any, string>(),
 			}))()),
 
-		atoms: HAMT.make<Atom<any>, string>(),
-		readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
-		selectors: HAMT.make<Selector<any>, string>(),
-		transactions: HAMT.make<Transaction<any>, string>(),
-		timelines: HAMT.make<Timeline, string>(),
+		valueMap: new Map(store?.valueMap),
+		atoms: new Map(),
+		readonlySelectors: new Map(),
+		selectors: new Map(),
+		transactions: new Map(),
+		timelines: new Map(),
 
 		timelineAtoms: new Join({ relationType: `1:n` })
 			.from(`timelineKey`)
@@ -122,22 +119,22 @@ export const createStore = (name: string, store: Store | null = null): Store =>
 
 	store?.atoms.forEach((atom) => {
 		const copiedAtom = { ...atom, subject: new Subject() } satisfies Atom<any>
-		copiedStore.atoms = HAMT.set(atom.key, copiedAtom, copiedStore.atoms)
+		created.atoms.set(atom.key, copiedAtom)
 	})
 	store?.readonlySelectors.forEach((selector) => {
-		selector.install(copiedStore)
+		selector.install(created)
 	})
 	store?.selectors.forEach((selector) => {
-		selector.install(copiedStore)
+		selector.install(created)
 	})
 	store?.transactions.forEach((tx) => {
-		tx.install(copiedStore)
+		tx.install(created)
 	})
 	store?.timelines.forEach((timeline) => {
-		timeline.install(copiedStore)
+		timeline.install(created)
 	})
 
-	return copiedStore
+	return created
 }
 
 export const IMPLICIT = {

package/src/internal/subscribe-internal.ts

@@ -74,7 +74,13 @@ export const subscribeToRootAtoms = <T>(
 						)
 						const oldValue = recallState(state, store)
 						const newValue = getState__INTERNAL(state, store)
-						store.config.logger?.info(`   <- ${state.key} became`, newValue)
+						store.config.logger?.info(
+							`   <- "${state.key}" went (`,
+							oldValue,
+							`->`,
+							newValue,
+							`)`,
+						)
 						state.subject.next({ newValue, oldValue })
 					})
 			  })

package/src/internal/timeline-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store } from "."
@@ -99,7 +97,7 @@ export function timeline__INTERNAL(
 		})
 	}
 
-	store.timelines = HAMT.set(options.key, tl, store.timelines)
+	store.timelines.set(options.key, tl)
 	const token: TimelineToken = {
 		key: options.key,
 		type: `timeline`,

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

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store } from ".."
@@ -26,10 +24,15 @@ export const applyTransaction = <ƒ extends ƒn>(
 
 	for (const { key, newValue } of atomUpdates) {
 		const token: AtomToken<unknown> = { key, type: `atom` }
-		if (!HAMT.has(token.key, store.valueMap)) {
-			const newAtom = HAMT.get(token.key, store.transactionStatus.core.atoms)
-			store.atoms = HAMT.set(newAtom.key, newAtom, store.atoms)
-			store.valueMap = HAMT.set(newAtom.key, newAtom.default, store.valueMap)
+		if (!store.valueMap.has(token.key)) {
+			const newAtom = store.transactionStatus.core.atoms.get(token.key)
+			if (!newAtom) {
+				throw new Error(
+					`Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`,
+				)
+			}
+			store.atoms.set(newAtom.key, newAtom)
+			store.valueMap.set(newAtom.key, newAtom.default)
 			store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
 		}
 		setState(token, newValue, store)

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

@@ -10,17 +10,17 @@ export const buildTransaction = (
 		phase: `building`,
 		time: Date.now(),
 		core: {
-			atoms: store.atoms,
+			atoms: new Map(store.atoms),
 			atomsThatAreDefault: store.atomsThatAreDefault,
 			operation: { open: false },
-			readonlySelectors: store.readonlySelectors,
-			timelines: store.timelines,
+			readonlySelectors: new Map(store.readonlySelectors),
+			timelines: new Map(store.timelines),
 			timelineAtoms: store.timelineAtoms,
-			transactions: store.transactions,
+			transactions: new Map(store.transactions),
 			selectorAtoms: store.selectorAtoms,
 			selectorGraph: store.selectorGraph,
-			selectors: store.selectors,
-			valueMap: store.valueMap,
+			selectors: new Map(store.selectors),
+			valueMap: new Map(store.valueMap),
 		},
 		atomUpdates: [],
 		params,

package/src/internal/transaction-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store, StoreCore } from "."
@@ -51,11 +49,7 @@ export function transaction__INTERNAL<ƒ extends ƒn>(
 		subject: new Subject(),
 	}
 	const core = target(store)
-	core.transactions = HAMT.set(
-		newTransaction.key,
-		newTransaction,
-		core.transactions,
-	)
+	core.transactions.set(newTransaction.key, newTransaction)
 	const token = deposit(newTransaction)
 	store.subject.transactionCreation.next(token)
 	return token

package/src/introspection/attach-timeline-family.ts

@@ -1,7 +1,7 @@
 import type { ReadonlySelectorFamily, Store } from "atom.io"
-import { __INTERNAL__ } from "atom.io"
+import { __INTERNAL__, timeline } from "atom.io"
 
-import type { Timeline } from "../internal"
+import { withdraw, type Timeline, Subject } from "../internal"
 
 export const attachTimelineFamily = (
 	store: Store = __INTERNAL__.IMPLICIT.STORE,
@@ -12,11 +12,21 @@ export const attachTimelineFamily = (
 	>(
 		{
 			key: `👁‍🗨 Timeline Update Log (Internal)`,
-			default: (key) => store.timelines.get(key),
+			default: (key) =>
+				store.timelines.get(key) ?? {
+					key: ``,
+					at: 0,
+					timeTraveling: false,
+					history: [],
+					selectorTime: null,
+					transactionKey: null,
+					install: () => {},
+					subject: new Subject(),
+				},
 			effects: (key) => [
 				({ setSelf }) => {
 					const tl = store.timelines.get(key)
-					tl.subject.subscribe((_) => {
+					tl?.subject.subscribe((_) => {
 						if (store.operation.open === true) {
 							const subscription = store.subject.operationStatus.subscribe(
 								(operationStatus) => {

package/src/introspection/attach-transaction-logs.ts

@@ -16,7 +16,7 @@ export const attachTransactionLogs = (
 			effects: (key) => [
 				({ setSelf }) => {
 					const tx = store.transactions.get(key)
-					tx.subject.subscribe((transactionUpdate) => {
+					tx?.subject.subscribe((transactionUpdate) => {
 						if (transactionUpdate.key === key) {
 							setSelf((state) => [...state, transactionUpdate])
 						}

package/src/react-devtools/AtomIODevtools.tsx

@@ -1,7 +1,6 @@
 import { useO, useIO } from "atom.io/react"
 import { LayoutGroup, motion, spring } from "framer-motion"
 import { useRef } from "react"
-import type { FC } from "react"
 
 import {
 	atomIndex,
@@ -16,7 +15,7 @@ import { TransactionIndex } from "./TransactionIndex"
 
 import "./devtools.scss"
 
-export const AtomIODevtools: FC = () => {
+export const AtomIODevtools = (): JSX.Element => {
 	const constraintsRef = useRef(null)
 
 	const [devtoolsAreOpen, setDevtoolsAreOpen] = useIO(devtoolsAreOpenState)

package/src/react-explorer/AtomIOExplorer.tsx

@@ -3,7 +3,7 @@ import type { FC, ReactNode } from "react"
 import { useEffect } from "react"
 import { Link, MemoryRouter, useLocation } from "react-router-dom"
 
-import { ErrorBoundary } from "~/packages/hamr/src/react-error-boundary"
+import { RecoverableErrorBoundary } from "~/packages/hamr/src/react-error-boundary"
 import type { WC } from "~/packages/hamr/src/react-json-editor"
 
 import { attachExplorerState } from "./explorer-states"
@@ -132,14 +132,14 @@ export const composeExplorer = ({
 		const view = useO(findViewState(focusedViewId))
 		return (
 			<div className="space">
-				<ErrorBoundary>
+				<RecoverableErrorBoundary>
 					<MemoryRouter
 						initialEntries={view.location ? [view.location.pathname] : []}
 					>
 						<TabBar spaceId={spaceId} viewIds={viewIds} />
 						<View viewId={focusedViewId}>{children}</View>
 					</MemoryRouter>
-				</ErrorBoundary>
+				</RecoverableErrorBoundary>
 			</div>
 		)
 	}