atom.io 0.17.0 → 0.18.0

package/realtime-testing/src/setup-realtime-test.tsx

@@ -1,8 +1,15 @@
 import * as http from "http"
 
-import { type RenderResult, prettyDOM, render } from "@testing-library/react"
+import { prettyDOM, render } from "@testing-library/react"
+import type { RenderResult } from "@testing-library/react"
 import * as AtomIO from "atom.io"
-import * as Internal from "atom.io/internal"
+import {
+	IMPLICIT,
+	clearStore,
+	findInStore,
+	getFromStore,
+	setIntoStore,
+} from "atom.io/internal"
 import * as AR from "atom.io/react"
 import * as RTR from "atom.io/realtime-react"
 import * as RTS from "atom.io/realtime-server"
@@ -14,6 +21,8 @@ import { io } from "socket.io-client"
 
 import { recordToEntries } from "~/packages/anvl/src/object"
 
+let testNumber = 0
+
 export type TestSetupOptions = {
 	server: (tools: { socket: SocketIO.Socket; silo: AtomIO.Silo }) => void
 }
@@ -61,36 +70,24 @@ export type RealtimeTestAPI__MultiClient<ClientNames extends string> =
 export const setupRealtimeTestServer = (
 	options: TestSetupOptions,
 ): RealtimeTestServer => {
-	const silo = new AtomIO.Silo(`SERVER`, Internal.IMPLICIT.STORE)
+	++testNumber
+	const silo = new AtomIO.Silo(`SERVER-${testNumber}`, IMPLICIT.STORE)
 
 	const httpServer = http.createServer((_, res) => res.end(`Hello World!`))
 	const address = httpServer.listen().address()
 	const port =
 		typeof address === `string` ? 80 : address === null ? null : address.port
 	if (port === null) throw new Error(`Could not determine port for test server`)
+
 	const server = new SocketIO.Server(httpServer).use((socket, next) => {
 		const { token, username } = socket.handshake.auth
 		if (token === `test` && socket.id) {
-			const socketRelatedKeysState = Internal.findInStore(
-				RTS.usersOfSockets.core.findRelatedKeysState,
-				socket.id,
-				silo.store,
-			)
-			const clientRelatedKeysState = Internal.findInStore(
-				RTS.usersOfSockets.core.findRelatedKeysState,
-				username,
-				silo.store,
-			)
-			Internal.setIntoStore(
-				socketRelatedKeysState,
-				(keys) => (keys.clear(), keys.add(username)),
-				silo.store,
-			)
-			Internal.setIntoStore(
-				clientRelatedKeysState,
-				(keys) => (keys.clear(), keys.add(socket.id)),
-				silo.store,
-			)
+			const socketState = findInStore(RTS.socketAtoms, socket.id, silo.store)
+			setIntoStore(socketState, socket, silo.store)
+			const usersOfSockets = RTS.usersOfSockets.in(silo.store)
+			usersOfSockets.relations.set(socket.id, username)
+			setIntoStore(RTS.userIndex, (index) => index.add(username), silo.store)
+			setIntoStore(RTS.socketIndex, (index) => index.add(socket.id), silo.store)
 			console.log(`${username} connected on ${socket.id}`)
 			next()
 		} else {
@@ -104,7 +101,15 @@ export const setupRealtimeTestServer = (
 
 	const dispose = () => {
 		server.close()
-		Internal.clearStore(silo.store)
+		const roomKeys = getFromStore(RTS.roomIndex, silo.store)
+		for (const roomKey of roomKeys) {
+			const roomState = findInStore(RTS.roomSelectors, roomKey, silo.store)
+			const room = getFromStore(roomState, silo.store)
+			if (room && !(room instanceof Promise)) {
+				room.kill()
+			}
+		}
+		silo.store.valueMap.clear()
 	}
 
 	return {
@@ -122,9 +127,9 @@ export const setupRealtimeTestClient = (
 	const testClient = { dispose: () => {} }
 	const init = () => {
 		const socket: ClientSocket = io(`http://localhost:${port}/`, {
-			auth: { token: `test`, username: name },
+			auth: { token: `test`, username: `${name}-${testNumber}` },
 		})
-		const silo = new AtomIO.Silo(name, Internal.IMPLICIT.STORE)
+		const silo = new AtomIO.Silo(name, IMPLICIT.STORE)
 		for (const [key, value] of silo.store.valueMap.entries()) {
 			if (Array.isArray(value)) {
 				silo.store.valueMap.set(key, [...value])
@@ -147,8 +152,9 @@ export const setupRealtimeTestClient = (
 		const prettyPrint = () => console.log(prettyDOM(renderResult.container))
 
 		const dispose = () => {
+			renderResult.unmount()
 			socket.disconnect()
-			Internal.clearStore(silo.store)
+			clearStore(silo.store)
 		}
 		testClient.dispose = dispose
 
@@ -167,7 +173,11 @@ export const singleClient = (
 	options: TestSetupOptions__SingleClient,
 ): RealtimeTestAPI__SingleClient => {
 	const server = setupRealtimeTestServer(options)
-	const client = setupRealtimeTestClient(options, `CLIENT`, server.port)
+	const client = setupRealtimeTestClient(
+		options,
+		`CLIENT-${testNumber}`,
+		server.port,
+	)
 
 	return {
 		client,

package/src/atom.ts

@@ -45,23 +45,30 @@ export type RegularAtomFamilyOptions<T, K extends Json.Serializable> = {
 	effects?: (key: K) => AtomEffect<T>[]
 }
 
-export type RegularAtomFamily<
-	T,
-	K extends Json.Serializable = Json.Serializable,
-> = ((key: K) => RegularAtomToken<T>) & {
-	key: string
-	type: `atom_family`
-	subject: Subject<RegularAtomToken<T>>
-	install: (store: Store) => void
-	__T?: T
-	__K?: K
-}
 export type RegularAtomFamilyToken<T, K extends Json.Serializable> = {
 	key: string
 	type: `atom_family`
 	__T?: T
 	__K?: K
 }
+// biome-ignore format: intersection
+export type RegularAtomFamilyTokenWithCall<
+	T,
+	K extends Json.Serializable,
+> = 
+	& RegularAtomFamilyToken<T, K>
+	& {
+		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+		(key: K): RegularAtomToken<T>
+	}
+// biome-ignore format: intersection
+export type RegularAtomFamily<T, K extends Json.Serializable> = 
+	& RegularAtomFamilyToken<T, K>
+	& {
+		(key: K): RegularAtomToken<T>
+		subject: Subject<RegularAtomToken<T>>
+		install: (store: Store) => void
+	}
 
 // biome-ignore format: intersection
 export type MutableAtomFamilyOptions<
@@ -77,23 +84,6 @@ export type MutableAtomFamilyOptions<
 		mutable: true,
 	}
 
-// biome-ignore format: intersection
-export type MutableAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Json.Serializable,
-> = 
-	& JsonInterface<T, J>
-	& ((key: K) => MutableAtomToken<T, J>) 
-	& {
-			key: string
-			type: `mutable_atom_family`
-			subject: Subject<MutableAtomToken<T, J>>
-			install: (store: Store) => void
-			__T?: T
-			__J?: J
-			__K?: K
-		}
 export type MutableAtomFamilyToken<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
@@ -105,6 +95,30 @@ export type MutableAtomFamilyToken<
 	__J?: J
 	__K?: K
 }
+// biome-ignore format: intersection
+export type MutableAtomFamilyTokenWithCall<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+> = 
+	& MutableAtomFamilyToken<T, J, K>
+	& {
+		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+		(key: K): MutableAtomToken<T, J>
+	}
+// biome-ignore format: intersection
+export type MutableAtomFamily<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+> = 
+	& JsonInterface<T, J>
+	& MutableAtomFamilyToken<T, J, K>
+	& {
+			(key: K): MutableAtomToken<T, J>
+			subject: Subject<MutableAtomToken<T, J>>
+			install: (store: Store) => void
+		}
 
 export type AtomFamily<T, K extends Json.Serializable = Json.Serializable> =
 	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
@@ -117,14 +131,18 @@ export function atomFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 	K extends Json.Serializable,
->(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamily<T, J, K>
+>(
+	options: MutableAtomFamilyOptions<T, J, K>,
+): MutableAtomFamilyTokenWithCall<T, J, K>
 export function atomFamily<T, K extends Json.Serializable>(
 	options: RegularAtomFamilyOptions<T, K>,
-): RegularAtomFamily<T, K>
+): RegularAtomFamilyTokenWithCall<T, K>
 export function atomFamily<T, K extends Json.Serializable>(
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
-): MutableAtomFamily<any, any, any> | RegularAtomFamily<T, K> {
+):
+	| MutableAtomFamilyTokenWithCall<any, any, any>
+	| RegularAtomFamilyTokenWithCall<T, K> {
 	return createAtomFamily(options, IMPLICIT.STORE)
 }

package/src/logger.ts

@@ -6,20 +6,23 @@ const LoggerIconDictionary = {
 	"⏮️": `Transaction undo`,
 	"⏳": `Timeline event partially captured`,
 	"⏹️": `Time-travel complete`,
-	"💁": `Notice`,
-	"🔄": `Realtime transaction synchronized`,
 	"✅": `Realtime transaction success`,
 	"✨": `Computation complete`,
 	"❌": `Conflict prevents attempted action`,
 	"⭕": `Operation start`,
 	"🐞": `Possible bug in AtomIO`,
 	"👀": `Subscription added`,
+	"👋": `Greeting`,
+	"👍": `Realtime acknowledgment`,
 	"👪": `Family member added`,
+	"💁": `Notice`,
+	"💥": `Caught`,
 	"📁": `Stow update`,
 	"📃": `Copy mutable`,
 	"📖": `Read state`,
 	"📝": `Write state`,
 	"📢": `Notify subscribers`,
+	"🔄": `Realtime transaction synchronized`,
 	"🔌": `Register dependency`,
 	"🔍": `Discover root`,
 	"🔥": `Delete state`,
@@ -27,8 +30,8 @@ const LoggerIconDictionary = {
 	"🔨": `Create immutable atom`,
 	"🔴": `Operation complete`,
 	"🗑": `Evict cached value`,
-	"💥": `Caught`,
 	"🙈": `Subscription canceled`,
+	"🚀": `Performance measure`,
 	"🛄": `Apply transaction`,
 	"🛠️": `Install atom into store`,
 	"🛫": `Begin transaction`,
@@ -36,14 +39,16 @@ const LoggerIconDictionary = {
 	"🧮": `Computing selector`,
 	"🧹": `Prepare to evict`,
 	"🪂": `Abort transaction`,
-	"🚀": `Performance measure`,
+	"🤞": `Realtime optimistic update enqueued`,
+	"👈": `Realtime confirmed update enqueued`,
+	"⚖️": `Realtime update beginning reconciliation`,
 } as const
 export type LoggerIcon = keyof typeof LoggerIconDictionary
 export type TokenDenomination =
 	| `atom`
+	| `continuity`
 	| `mutable_atom`
 	| `readonly_selector`
-	| `realtime_sync_group`
 	| `selector`
 	| `state`
 	| `timeline`

package/src/selector.ts

@@ -41,41 +41,58 @@ export type ReadonlySelectorFamilyOptions<T, K extends Json.Serializable> = {
 	get: (key: K) => Read<() => T>
 }
 
-export type WritableSelectorFamily<
-	T,
-	K extends Json.Serializable = Json.Serializable,
-> = ((key: K) => WritableSelectorToken<T>) & {
-	key: string
-	type: `selector_family`
-	subject: Subject<WritableSelectorToken<T>>
-	install: (store: Store) => void
-	__T?: T
-	__K?: K
-}
 export type WritableSelectorFamilyToken<T, K extends Json.Serializable> = {
 	key: string
 	type: `selector_family`
 	__T?: T
 	__K?: K
 }
-
-export type ReadonlySelectorFamily<
+// biome-ignore format: intersection
+export type WritableSelectorFamilyTokenWithCall<
 	T,
-	K extends Json.Serializable = Json.Serializable,
-> = ((key: K) => ReadonlySelectorToken<T>) & {
-	key: string
-	type: `readonly_selector_family`
-	subject: Subject<ReadonlySelectorToken<T>>
-	install: (store: Store) => void
-	__T?: T
-	__K?: K
-}
+	K extends Json.Serializable,
+> = 
+	& WritableSelectorFamilyToken<T, K>
+	& {
+		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+		(key: K): WritableSelectorToken<T>
+	}
+// biome-ignore format: intersection
+export type WritableSelectorFamily<T, K extends Json.Serializable> = 
+	& WritableSelectorFamilyToken<T, K> 
+	& {
+		(key: K): WritableSelectorToken<T>
+		subject: Subject<WritableSelectorToken<T>>
+		install: (store: Store) => void
+	}
+
 export type ReadonlySelectorFamilyToken<T, K extends Json.Serializable> = {
 	key: string
 	type: `readonly_selector_family`
 	__T?: T
 	__K?: K
 }
+// biome-ignore format: intersection
+export type ReadonlySelectorFamilyTokenWithCall<
+	T,
+	K extends Json.Serializable,
+> = 
+	& ReadonlySelectorFamilyToken<T, K>
+	& {
+		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+		(key: K): ReadonlySelectorToken<T>
+	}
+// biome-ignore format: intersection
+export type ReadonlySelectorFamily<T, K extends Json.Serializable> = 
+	& ((key: K) => ReadonlySelectorToken<T>)
+	& {
+		key: string
+		type: `readonly_selector_family`
+		subject: Subject<ReadonlySelectorToken<T>>
+		install: (store: Store) => void
+		__T?: T
+		__K?: K
+	}
 
 export type SelectorFamily<T, K extends Json.Serializable> =
 	| ReadonlySelectorFamily<T, K>
@@ -86,14 +103,16 @@ export type SelectorFamilyToken<T, K extends Json.Serializable> =
 
 export function selectorFamily<T, K extends Json.Serializable>(
 	options: WritableSelectorFamilyOptions<T, K>,
-): WritableSelectorFamily<T, K>
+): WritableSelectorFamilyTokenWithCall<T, K>
 export function selectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
-): ReadonlySelectorFamily<T, K>
+): ReadonlySelectorFamilyTokenWithCall<T, K>
 export function selectorFamily<T, K extends Json.Serializable>(
 	options:
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
-): ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K> {
+):
+	| ReadonlySelectorFamilyTokenWithCall<T, K>
+	| WritableSelectorFamilyTokenWithCall<T, K> {
 	return createSelectorFamily(options, IMPLICIT.STORE)
 }

package/src/subscribe.ts

@@ -1,6 +1,7 @@
 import type { Store } from "atom.io/internal"
 import {
 	IMPLICIT,
+	arbitrary,
 	subscribeToState,
 	subscribeToTimeline,
 	subscribeToTransaction,
@@ -49,7 +50,7 @@ export function subscribe<M extends TimelineManageable>(
 export function subscribe(
 	token: ReadableToken<any> | TimelineToken<any> | TransactionToken<any>,
 	handleUpdate: (update: any) => void,
-	key: string = Math.random().toString(36).slice(2),
+	key: string = arbitrary(),
 	store = IMPLICIT.STORE,
 ): () => void {
 	switch (token.type) {

package/src/timeline.ts

@@ -6,14 +6,14 @@ import type {
 } from "atom.io/internal"
 import { IMPLICIT, createTimeline, timeTravel } from "atom.io/internal"
 
-import type { AtomFamily, AtomToken } from "."
+import type { AtomFamilyToken, AtomToken } from "."
 
-export type TimelineManageable = AtomFamily<any, any> | AtomToken<any>
+export type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>
 
-export type TimelineToken<_> = {
+export type TimelineToken<M> = {
 	key: string
 	type: `timeline`
-	__brand?: _
+	__M?: M
 }
 
 export type TimelineOptions<ManagedAtom extends TimelineManageable> = {

package/src/transaction.ts

@@ -1,5 +1,10 @@
-import type { EnvironmentData, Store } from "atom.io/internal"
-import { IMPLICIT, createTransaction, withdraw } from "atom.io/internal"
+import type { EnvironmentData } from "atom.io/internal"
+import {
+	IMPLICIT,
+	actUponStore,
+	arbitrary,
+	createTransaction,
+} from "atom.io/internal"
 
 import type {
 	KeyedStateUpdate,
@@ -77,18 +82,9 @@ export function transaction<ƒ extends ƒn>(
 	return createTransaction(options, IMPLICIT.STORE)
 }
 
-export const runTransaction =
-	<ƒ extends ƒn>(
-		token: TransactionToken<ƒ>,
-		id?: string,
-		store: Store = IMPLICIT.STORE,
-	) =>
-	(...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
-		const tx = withdraw(token, store)
-		if (tx) {
-			return tx.run(parameters, id)
-		}
-		throw new Error(
-			`Cannot run transaction "${token.key}": transaction not found in store "${store.config.name}".`,
-		)
-	}
+export function runTransaction<ƒ extends ƒn>(
+	token: TransactionToken<ƒ>,
+	id = arbitrary(),
+): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
+	return actUponStore(token, id, IMPLICIT.STORE)
+}

package/src/validators.ts

@@ -1,23 +1,29 @@
 import type {
 	MutableAtomFamily,
+	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamily,
+	ReadableFamilyToken,
 	ReadableToken,
 	ReadonlySelectorFamily,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	RegularAtomFamily,
+	RegularAtomFamilyToken,
 	RegularAtomToken,
 	WritableFamily,
+	WritableFamilyToken,
 	WritableSelectorFamily,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
 
 export type TokenType<
-	Comparison extends ReadableFamily<any, any> | ReadableToken<any>,
+	Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>,
 > = Comparison extends ReadableToken<infer RepresentedValue>
 	? RepresentedValue
-	: Comparison extends ReadableFamily<infer RepresentedValue, any>
+	: Comparison extends ReadableFamilyToken<infer RepresentedValue, any>
 	  ? RepresentedValue
 	  : never
 
@@ -52,31 +58,31 @@ export function isToken<KnownToken extends ReadableToken<any>>(
 	return knownToken.key === unknownToken.key
 }
 
-export function belongsTo<Family extends RegularAtomFamily<any, any>>(
+export function belongsTo<Family extends RegularAtomFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is RegularAtomToken<TokenType<Family>>
-export function belongsTo<Family extends MutableAtomFamily<any, any, any>>(
+export function belongsTo<Family extends MutableAtomFamilyToken<any, any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is MutableAtomToken<TokenType<Family>, any>
-export function belongsTo<Family extends WritableSelectorFamily<any, any>>(
+export function belongsTo<Family extends WritableSelectorFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is WritableSelectorToken<TokenType<Family>>
-export function belongsTo<Family extends ReadonlySelectorFamily<any, any>>(
+export function belongsTo<Family extends ReadonlySelectorFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadonlySelectorToken<TokenType<Family>>
-export function belongsTo<Family extends WritableFamily<any, any>>(
+export function belongsTo<Family extends WritableFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is WritableToken<TokenType<Family>>
-export function belongsTo<Family extends ReadableFamily<any, any>>(
+export function belongsTo<Family extends ReadableFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadableToken<TokenType<Family>>
-export function belongsTo<Family extends ReadableFamily<any, any>>(
+export function belongsTo<Family extends ReadableFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadableToken<TokenType<Family>> {

package/dist/chunk-H4Q5FTPZ.js

@@ -1,11 +0,0 @@
-// internal/src/transaction/is-root-store.ts
-function isRootStore(store) {
-  return `epoch` in store.transactionMeta;
-}
-function isChildStore(store) {
-  return `phase` in store.transactionMeta;
-}
-
-export { isChildStore, isRootStore };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-H4Q5FTPZ.js.map

package/dist/chunk-H4Q5FTPZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../internal/src/transaction/is-root-store.ts"],"names":[],"mappings":";AAgBO,SAAS,YAAY,OAAkC;AAC7D,SAAO,WAAW,MAAM;AACzB;AAEO,SAAS,aAAa,OAAmC;AAC/D,SAAO,WAAW,MAAM;AACzB","sourcesContent":["import type { ƒn } from \"atom.io\"\n\nimport type { TransactionEpoch, TransactionProgress } from \".\"\nimport type { Store } from \"../store\"\n\nexport interface RootStore extends Store {\n\ttransactionMeta: TransactionEpoch\n\tparent: null\n\tchild: ChildStore | null\n}\nexport interface ChildStore extends Store {\n\ttransactionMeta: TransactionProgress<ƒn>\n\tparent: ChildStore | RootStore\n\tchild: ChildStore | null\n}\n\nexport function isRootStore(store: Store): store is RootStore {\n\treturn `epoch` in store.transactionMeta\n}\n\nexport function isChildStore(store: Store): store is ChildStore {\n\treturn `phase` in store.transactionMeta\n}\n"]}

package/internal/src/set-state/copy-mutable-in-transaction.ts

@@ -1,19 +0,0 @@
-import { newest } from ".."
-import type { Atom, Store } from ".."
-import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
-
-export function copyMutableIfWithinTransaction<T>(
-	oldValue: T,
-	atom: Atom<T>,
-	store: Store,
-): T {
-	const target = newest(store)
-	const parent = target.parent
-	if (parent !== null) {
-		if (atom.type === `mutable_atom`) {
-			const copiedValue = copyMutableIfNeeded(atom, parent, target)
-			return copiedValue
-		}
-	}
-	return oldValue
-}