atom.io 0.16.1 → 0.16.3

package/src/find-state.ts

@@ -12,50 +12,42 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
-import { IMPLICIT } from "atom.io/internal"
+import type { Transceiver } from "atom.io/internal"
+import { IMPLICIT, findInStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
-export function findInStore(
-	token: ReadableFamilyToken<any, any>,
-	key: Json.Serializable,
-	store: Store,
-): ReadableToken<any> {
-	const familyKey = token.key
-	const family = store.families.get(familyKey)
-	if (family === undefined) {
-		throw new Error(`Family ${familyKey} not found`)
-	}
-	const state = family(key)
-	return state
-}
-
 export function findState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 	K extends Json.Serializable,
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
+
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T>
+
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritableSelectorToken<T>
+
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlySelectorToken<T>
+
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 ): WritableToken<T>
+
 export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
 ): ReadableToken<T>
+
 export function findState(
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,

package/src/logger.ts

@@ -39,21 +39,23 @@ const LoggerIconDictionary = {
 	"🚀": `Performance measure`,
 } as const
 export type LoggerIcon = keyof typeof LoggerIconDictionary
+export type TokenDenomination =
+	| `atom`
+	| `mutable_atom`
+	| `readonly_selector`
+	| `realtime_sync_group`
+	| `selector`
+	| `state`
+	| `timeline`
+	| `transaction`
+	| `unknown`
 
 export const LOG_LEVELS = [`info`, `warn`, `error`] as const
 export type LogLevel = (typeof LOG_LEVELS)[number]
 
 export type LogFn = (
 	icon: LoggerIcon,
-	tokenType:
-		| `atom`
-		| `mutable_atom`
-		| `readonly_selector`
-		| `selector`
-		| `state`
-		| `timeline`
-		| `transaction`
-		| `unknown`,
+	denomination: TokenDenomination,
 	tokenKey: string,
 	message: string,
 	...rest: unknown[]
@@ -64,8 +66,11 @@ export type Logger = Record<LogLevel, LogFn>
 
 export const simpleLog =
 	(logLevel: keyof Logger): LogFn =>
-	(icon, tokenType, tokenKey, message, ...rest) => {
-		console[logLevel](`${icon} ${tokenType} "${tokenKey}" ${message}`, ...rest)
+	(icon, denomination, tokenKey, message, ...rest) => {
+		console[logLevel](
+			`${icon} ${denomination} "${tokenKey}" ${message}`,
+			...rest,
+		)
 	}
 export const simpleLogger: Logger = {
 	error: simpleLog(`error`),

package/src/transaction.ts

@@ -1,6 +1,5 @@
 import type { EnvironmentData, Store } from "atom.io/internal"
 import { IMPLICIT, createTransaction, withdraw } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 
 import type {
 	KeyedStateUpdate,
@@ -10,10 +9,10 @@ import type {
 	ƒn,
 } from "."
 
-export type TransactionToken<_> = {
+export type TransactionToken<F> = {
 	key: string
 	type: `transaction`
-	__brand?: _
+	__F?: F
 }
 
 export type TransactionUpdateContent =
@@ -23,6 +22,7 @@ export type TransactionUpdateContent =
 export type TransactionUpdate<ƒ extends ƒn> = {
 	key: string
 	id: string
+	epoch: number
 	updates: TransactionUpdateContent[]
 	params: Parameters<ƒ>
 	output: ReturnType<ƒ>
@@ -80,8 +80,8 @@ export function transaction<ƒ extends ƒn>(
 export const runTransaction =
 	<ƒ extends ƒn>(
 		token: TransactionToken<ƒ>,
-		store: Store = IMPLICIT.STORE,
 		id?: string,
+		store: Store = IMPLICIT.STORE,
 	) =>
 	(...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
 		const tx = withdraw(token, store)

package/react/src/store-hooks.ts

@@ -1,87 +0,0 @@
-import * as React from "react"
-
-import { getState, redo, setState, undo } from "atom.io"
-import type {
-	MutableAtomToken,
-	ReadableToken,
-	TimelineToken,
-	WritableToken,
-} from "atom.io"
-
-import {
-	getJsonToken,
-	subscribeToState,
-	subscribeToTimeline,
-	withdraw,
-} from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import { StoreContext } from "./store-context"
-
-export function useI<T>(
-	token: WritableToken<T>,
-): <New extends T>(next: New | ((old: T) => New)) => void {
-	const store = React.useContext(StoreContext)
-	const setter: React.MutableRefObject<
-		(<New extends T>(next: New | ((old: T) => New)) => void) | null
-	> = React.useRef(null)
-	if (setter.current === null) {
-		setter.current = (next) => setState(token, next, store)
-	}
-	return setter.current
-}
-
-export function useO<T>(token: ReadableToken<T>): T {
-	const store = React.useContext(StoreContext)
-	const id = React.useId()
-	return React.useSyncExternalStore<T>(
-		(dispatch) => subscribeToState(token, dispatch, `use-o:${id}`, store),
-		() => getState(token, store),
-		() => getState(token, store),
-	)
-}
-
-export function useJSON<Serializable extends Json.Serializable>(
-	token: MutableAtomToken<any, Serializable>,
-): Serializable {
-	const jsonToken = getJsonToken(token)
-	return useO(jsonToken)
-}
-
-export type TimelineMeta = {
-	at: number
-	length: number
-	undo: () => void
-	redo: () => void
-}
-
-export function useTL(token: TimelineToken<any>): TimelineMeta {
-	const store = React.useContext(StoreContext)
-	const id = React.useId()
-	const timeline = withdraw(token, store)
-	const tokenRef = React.useRef(token)
-	const rebuildMeta = () => {
-		return {
-			at: timeline?.at ?? NaN,
-			length: timeline?.history.length ?? NaN,
-			undo: () => undo(token),
-			redo: () => redo(token),
-		}
-	}
-	const meta = React.useRef<TimelineMeta>(rebuildMeta())
-	const retrieve = () => {
-		if (
-			meta.current.at !== timeline?.at ||
-			meta.current.length !== timeline?.history.length ||
-			tokenRef.current !== token
-		) {
-			tokenRef.current = token
-			meta.current = rebuildMeta()
-		}
-		return meta.current
-	}
-	return React.useSyncExternalStore<TimelineMeta>(
-		(dispatch) => subscribeToTimeline(token, dispatch, `use-tl:${id}`, store),
-		retrieve,
-		retrieve,
-	)
-}

package/realtime-server/src/realtime-server-store.ts

@@ -1,39 +0,0 @@
-import * as AtomIO from "atom.io"
-
-export const completeUpdateAtoms = AtomIO.atomFamily<
-	AtomIO.TransactionUpdate<any> | null,
-	string
->({
-	key: `completeUpdate`,
-	default: null,
-})
-
-export const transactionRedactorAtoms = AtomIO.atomFamily<
-	{
-		filter: (
-			updates: AtomIO.TransactionUpdateContent[],
-		) => AtomIO.TransactionUpdateContent[]
-	},
-	string
->({
-	key: `transactionRedactor`,
-	default: { filter: (updates) => updates },
-})
-
-export const redactedUpdateSelectors = AtomIO.selectorFamily<
-	AtomIO.TransactionUpdate<any> | null,
-	[transactionKey: string, updateId: string]
->({
-	key: `redactedUpdate`,
-	get:
-		([transactionKey, updateId]) =>
-		({ get, find }) => {
-			const update = get(find(completeUpdateAtoms, updateId))
-			const { filter } = get(find(transactionRedactorAtoms, transactionKey))
-
-			if (update && filter) {
-				return { ...update, updates: filter(update.updates) }
-			}
-			return null
-		},
-})