atom.io 0.42.1 → 0.43.0

package/src/react/use-json.ts

@@ -2,7 +2,7 @@ import type { MutableAtomFamilyToken, MutableAtomToken } from "atom.io"
 import type { AsJSON, Transceiver } from "atom.io/internal"
 import { findInStore, getJsonToken } from "atom.io/internal"
 import type { Canonical, Json } from "atom.io/json"
-import * as React from "react"
+import { useContext } from "react"
 
 import { StoreContext } from "./store-context"
 import { useO } from "./use-o"
@@ -20,7 +20,7 @@ export function useJSON(
 	token: MutableAtomFamilyToken<any, any> | MutableAtomToken<any>,
 	key?: Canonical,
 ): Json.Serializable {
-	const store = React.useContext(StoreContext)
+	const store = useContext(StoreContext)
 	const stateToken: MutableAtomToken<any> =
 		token.type === `mutable_atom_family` ? findInStore(store, token, key) : token
 	const jsonToken = getJsonToken(store, stateToken)

package/src/react/use-loadable.ts

@@ -3,7 +3,7 @@ import type { Loadable, ReadableFamilyToken, ReadableToken } from "atom.io"
 import { findInStore, type ReadableState, withdraw } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
-import React from "react"
+import { useContext, useRef } from "react"
 
 export function useLoadable<T, E>(
 	token: ReadableToken<Loadable<T>, any, E>,
@@ -32,7 +32,7 @@ export function useLoadable(
 		| readonly [ReadableToken<any, any, any>, unknown]
 		| readonly [ReadableToken<any, any, any>]
 ): `LOADING` | { loading: boolean; value: unknown; error?: unknown } {
-	const store = React.useContext(StoreContext)
+	const store = useContext(StoreContext)
 
 	let value: unknown
 	let state: ReadableState<any, any>
@@ -65,12 +65,12 @@ export function useLoadable(
 
 	const isErr = `catch` in state && state.catch.some((E) => value instanceof E)
 
-	const wrapperRef = React.useRef<{
+	const wrapperRef = useRef<{
 		loading: boolean
 		value: unknown
 		error?: unknown
 	}>({ loading: false, value: null as unknown })
-	const lastLoadedRef = React.useRef(
+	const lastLoadedRef = useRef(
 		fallback ?? (value instanceof Promise ? `LOADING` : value),
 	)
 

package/src/react/use-o.ts

@@ -1,7 +1,7 @@
 import type { ReadableFamilyToken, ReadableToken } from "atom.io"
 import { getFromStore, subscribeToState } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
-import * as React from "react"
+import { useContext, useId, useSyncExternalStore } from "react"
 
 import { parseStateOverloads } from "./parse-state-overloads"
 import { StoreContext } from "./store-context"
@@ -18,10 +18,10 @@ export function useO<T, K extends Canonical, E>(
 		| [ReadableFamilyToken<T, K, E>, NoInfer<K>]
 		| [ReadableToken<T, any, E>]
 ): E | T {
-	const store = React.useContext(StoreContext)
+	const store = useContext(StoreContext)
 	const token = parseStateOverloads(store, ...params)
-	const id = React.useId()
-	return React.useSyncExternalStore<E | T>(
+	const id = useId()
+	return useSyncExternalStore<E | T>(
 		(dispatch) => subscribeToState(store, token, `use-o:${id}`, dispatch),
 		() => getFromStore(store, token),
 		() => getFromStore(store, token),

package/src/react/use-tl.ts

@@ -1,7 +1,7 @@
 import type { TimelineToken } from "atom.io"
 import { redo, undo } from "atom.io"
 import { subscribeToTimeline, withdraw } from "atom.io/internal"
-import * as React from "react"
+import { useContext, useId, useRef, useSyncExternalStore } from "react"
 
 import { StoreContext } from "./store-context"
 
@@ -13,10 +13,10 @@ export type TimelineMeta = {
 }
 
 export function useTL(token: TimelineToken<any>): TimelineMeta {
-	const store = React.useContext(StoreContext)
-	const id = React.useId()
+	const store = useContext(StoreContext)
+	const id = useId()
 	const timeline = withdraw(store, token)
-	const tokenRef = React.useRef(token)
+	const tokenRef = useRef(token)
 	const rebuildMeta = () => {
 		return {
 			at: timeline.at,
@@ -29,7 +29,7 @@ export function useTL(token: TimelineToken<any>): TimelineMeta {
 			},
 		}
 	}
-	const meta = React.useRef<TimelineMeta>(rebuildMeta())
+	const meta = useRef<TimelineMeta>(rebuildMeta())
 	const retrieve = () => {
 		if (
 			meta.current.at !== timeline?.at ||
@@ -41,7 +41,7 @@ export function useTL(token: TimelineToken<any>): TimelineMeta {
 		}
 		return meta.current
 	}
-	return React.useSyncExternalStore<TimelineMeta>(
+	return useSyncExternalStore<TimelineMeta>(
 		(dispatch) => subscribeToTimeline(store, token, `use-tl:${id}`, dispatch),
 		retrieve,
 		retrieve,

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

@@ -125,6 +125,7 @@ export const setupRealtimeTestServer = (
 		{
 			name: `SERVER-${testNumber}`,
 			lifespan: options.immortal?.server ? `immortal` : `ephemeral`,
+			isProduction: false,
 		},
 		IMPLICIT.STORE,
 	)
@@ -229,7 +230,10 @@ export const setupRealtimeTestClient = (
 		const socket: ClientSocket = io(`http://localhost:${port}/`, {
 			auth: { token: `test`, username: `${name}-${testNumber}` },
 		})
-		const silo = new AtomIO.Silo({ name, lifespan: `ephemeral` }, IMPLICIT.STORE)
+		const silo = new AtomIO.Silo(
+			{ name, lifespan: `ephemeral`, isProduction: false },
+			IMPLICIT.STORE,
+		)
 		silo.setState(RTC.myUsernameState, `${name}-${testNumber}`)
 
 		const { document } = new Happy.Window()

package/src/transceivers/o-list/index.ts

@@ -1 +1,2 @@
 export * from "./o-list"
+export * from "./o-list-disposed-key-cleanup-effect"

package/src/transceivers/o-list/o-list-disposed-key-cleanup-effect.ts

@@ -0,0 +1,153 @@
+import type { AtomEffect } from "atom.io"
+import { getFromStore, getUpdateToken, subscribeInStore } from "atom.io/internal"
+import { type primitive, stringifyJson } from "atom.io/json"
+
+import { OList } from "./o-list"
+
+export function filterOutInPlace<T>(arr: T[], toRemove: T): T[] {
+	let writeIndex = 0
+
+	// eslint-disable-next-line @typescript-eslint/prefer-for-of
+	for (let readIndex = 0; readIndex < arr.length; readIndex++) {
+		if (toRemove !== arr[readIndex]) {
+			arr[writeIndex] = arr[readIndex]
+			writeIndex++
+		}
+	}
+
+	arr.length = writeIndex
+	return arr
+}
+
+export const oListDisposedKeyCleanupEffect: AtomEffect<OList<primitive>> = ({
+	token,
+	setSelf,
+	store,
+}) => {
+	const disposalSubscriptions = new Map<primitive, () => void>()
+	const updateToken = getUpdateToken(token)
+
+	const addedValues = new Set<primitive>()
+	const removedValues = new Set<primitive>()
+	function updateSubscriptions() {
+		for (const addedValue of addedValues) {
+			const molecule = store.molecules.get(stringifyJson(addedValue))
+			if (molecule) {
+				disposalSubscriptions.set(
+					addedValue,
+					molecule.subject.subscribe(token.key, () => {
+						disposalSubscriptions.get(addedValue)?.()
+						disposalSubscriptions.delete(addedValue)
+						setSelf((self) => {
+							filterOutInPlace(self, addedValue)
+							return self
+						})
+					}),
+				)
+			} else {
+				store.logger.warn(
+					`❌`,
+					token.type,
+					token.key,
+					`Added "${addedValue}" to ${token.key} but it has not been allocated.`,
+				)
+			}
+		}
+		for (const removedValue of removedValues) {
+			if (disposalSubscriptions.has(removedValue)) {
+				disposalSubscriptions.get(removedValue)?.()
+				disposalSubscriptions.delete(removedValue)
+			}
+		}
+	}
+	subscribeInStore(
+		store,
+		updateToken,
+		function manageAutoDeletionTriggers({ newValue }) {
+			const currentList = getFromStore(store, token)
+			const unpacked = OList.unpackUpdate(newValue)
+			switch (unpacked.type) {
+				case `extend`:
+				case `reverse`:
+				case `sort`:
+					break // these don't change what values are present in the list
+
+				case `set`:
+					{
+						const { next } = unpacked
+						if (`prev` in unpacked && !currentList.includes(unpacked.prev)) {
+							removedValues.add(unpacked.prev)
+						}
+						if (!disposalSubscriptions.has(next)) {
+							addedValues.add(next)
+						}
+					}
+					break
+				case `truncate`:
+					{
+						for (const item of unpacked.items) {
+							if (!currentList.includes(item)) {
+								removedValues.add(item)
+							}
+						}
+					}
+					break
+				case `shift`:
+				case `pop`:
+					{
+						const { value } = unpacked
+						if (value !== undefined && !currentList.includes(value)) {
+							removedValues.add(value)
+						}
+					}
+					break
+				case `push`:
+				case `unshift`:
+					for (const item of unpacked.items) {
+						if (!disposalSubscriptions.has(item)) {
+							addedValues.add(item)
+						}
+					}
+					break
+				case `copyWithin`:
+					for (const item of unpacked.prev) {
+						if (!currentList.includes(item)) {
+							removedValues.add(item)
+						}
+					}
+					break
+				case `fill`:
+					{
+						const { value } = unpacked
+						if (value !== undefined) {
+							if (!disposalSubscriptions.has(value)) {
+								addedValues.add(value)
+							}
+						}
+						for (const item of unpacked.prev) {
+							if (!currentList.includes(item)) {
+								removedValues.add(item)
+							}
+						}
+					}
+					break
+				case `splice`:
+					for (const item of unpacked.deleted) {
+						if (!currentList.includes(item)) {
+							removedValues.add(item)
+						}
+					}
+					for (const addedItem of unpacked.items) {
+						if (!disposalSubscriptions.has(addedItem)) {
+							addedValues.add(addedItem)
+						}
+					}
+					break
+			}
+			updateSubscriptions()
+			addedValues.clear()
+			removedValues.clear()
+		},
+		`set-auto-deletion-triggers`,
+	)
+}