atom.io 0.6.6 → 0.6.8

package/src/realtime-react/realtime-hooks.ts

@@ -10,15 +10,15 @@ import { usePush } from "./use-push"
 import { useServerAction } from "./use-server-action"
 
 export type RealtimeHooks = {
-	usePull: <J extends Json>(token: AtomIO.StateToken<J>) => void
-	usePullFamily: <J extends Json>(
+	usePull: <J extends Json.Serializable>(token: AtomIO.StateToken<J>) => void
+	usePullFamily: <J extends Json.Serializable>(
 		family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
 	) => void
-	usePullFamilyMember: <J extends Json>(
+	usePullFamilyMember: <J extends Json.Serializable>(
 		family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
 		subKey: string,
 	) => void
-	usePush: <J extends Json>(token: AtomIO.StateToken<J>) => void
+	usePush: <J extends Json.Serializable>(token: AtomIO.StateToken<J>) => void
 	useServerAction: <ƒ extends ƒn>(
 		token: AtomIO.TransactionToken<ƒ>,
 	) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>

package/src/realtime-react/use-pull-family-member.ts

@@ -6,9 +6,9 @@ import type { Json } from "~/packages/anvl/src/json"
 import { RealtimeContext } from "./realtime-context"
 import { StoreContext } from "../react"
 
-export function usePullFamilyMember<J extends Json>(
+export function usePullFamilyMember<J extends Json.Serializable>(
 	family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
-	subKey: AtomIO.Serializable,
+	subKey: AtomIO.Json.Serializable,
 ): void {
 	const token = family(subKey)
 	const { socket } = React.useContext(RealtimeContext)

package/src/realtime-react/use-pull-family.ts

@@ -6,13 +6,13 @@ import type { Json } from "~/packages/anvl/src/json"
 import { RealtimeContext } from "./realtime-context"
 import { StoreContext } from "../react"
 
-export function usePullFamily<J extends Json>(
+export function usePullFamily<J extends Json.Serializable>(
 	family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
 ): void {
 	const { socket } = React.useContext(RealtimeContext)
 	const store = React.useContext(StoreContext)
 	React.useEffect(() => {
-		socket.on(`serve:${family.key}`, (key: Json, data: J) => {
+		socket.on(`serve:${family.key}`, (key: Json.Serializable, data: J) => {
 			AtomIO.setState(family(key), data, store)
 		})
 		socket?.emit(`sub:${family.key}`)

package/src/realtime-react/use-pull.ts

@@ -6,7 +6,9 @@ import type { Json } from "~/packages/anvl/src/json"
 import { RealtimeContext } from "./realtime-context"
 import { StoreContext } from "../react"
 
-export function usePull<J extends Json>(token: AtomIO.StateToken<J>): void {
+export function usePull<J extends Json.Serializable>(
+	token: AtomIO.StateToken<J>,
+): void {
 	const { socket } = React.useContext(RealtimeContext)
 	const store = React.useContext(StoreContext)
 	React.useEffect(() => {

package/src/realtime-react/use-push.ts

@@ -6,7 +6,9 @@ import type { Json } from "~/packages/anvl/src/json"
 import { RealtimeContext } from "./realtime-context"
 import { StoreContext } from "../react"
 
-export function usePush<J extends Json>(token: AtomIO.StateToken<J>): void {
+export function usePush<J extends Json.Serializable>(
+	token: AtomIO.StateToken<J>,
+): void {
 	const { socket } = React.useContext(RealtimeContext)
 	const store = React.useContext(StoreContext)
 	React.useEffect(() => {

package/src/selector.ts

@@ -1,4 +1,4 @@
-import type { Serializable } from "~/packages/anvl/src/json"
+import type { Json } from "~/packages/anvl/src/json"
 
 import type { ReadonlySelectorToken, SelectorToken } from "."
 import type { Subject } from "./internal"
@@ -25,39 +25,41 @@ export function selector<T>(
 	return selector__INTERNAL(options)
 }
 
-export type SelectorFamilyOptions<T, K extends Serializable> = {
+export type SelectorFamilyOptions<T, K extends Json.Serializable> = {
 	key: string
 	get: (key: K) => Read<() => T>
 	set: (key: K) => Write<(newValue: T) => void>
 }
-export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = {
+export type ReadonlySelectorFamilyOptions<T, K extends Json.Serializable> = {
 	key: string
 	get: (key: K) => Read<() => T>
 }
 
-export type SelectorFamily<T, K extends Serializable = Serializable> = ((
-	key: K,
-) => SelectorToken<T>) & {
+export type SelectorFamily<
+	T,
+	K extends Json.Serializable = Json.Serializable,
+> = ((key: K) => SelectorToken<T>) & {
 	key: string
 	type: `selector_family`
 	subject: Subject<SelectorToken<T>>
 }
 
-export type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((
-	key: K,
-) => ReadonlySelectorToken<T>) & {
+export type ReadonlySelectorFamily<
+	T,
+	K extends Json.Serializable = Json.Serializable,
+> = ((key: K) => ReadonlySelectorToken<T>) & {
 	key: string
 	type: `readonly_selector_family`
 	subject: Subject<ReadonlySelectorToken<T>>
 }
 
-export function selectorFamily<T, K extends Serializable>(
+export function selectorFamily<T, K extends Json.Serializable>(
 	options: SelectorFamilyOptions<T, K>,
 ): SelectorFamily<T, K>
-export function selectorFamily<T, K extends Serializable>(
+export function selectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamily<T, K>
-export function selectorFamily<T, K extends Serializable>(
+export function selectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
 	return selectorFamily__INTERNAL(options)

package/src/subscribe.ts

@@ -76,7 +76,7 @@ export const subscribeToTransaction = <ƒ extends ƒn>(
 
 export const subscribeToTimeline = (
 	token: TimelineToken,
-	handleUpdate: (update: TimelineUpdate) => void,
+	handleUpdate: (update: TimelineUpdate | `redo` | `undo`) => void,
 	store = IMPLICIT.STORE,
 ): (() => void) => {
 	const tl = withdraw(token, store)

package/src/tracker/index.ts

@@ -0,0 +1,3 @@
+export * from "./tracker"
+
+export * from "~/packages/anvl/reactivity/transceiver"

package/src/tracker/tracker.ts

@@ -0,0 +1,61 @@
+import * as AtomIO from "atom.io"
+
+import type { Transceiver } from "."
+
+export type CacheOptions<Core extends Transceiver<any>> = {
+	key: string
+	default: Core
+}
+
+export const tracker = <Core extends Transceiver<any>>(
+	coreState: AtomIO.AtomToken<Core>,
+	store: AtomIO.__INTERNAL__.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE,
+): AtomIO.AtomToken<
+	(Core extends Transceiver<infer Signal> ? Signal : never) | null
+> => {
+	const trackerKey = `${coreState.key}:signal`
+	const trackerState = AtomIO.atom<
+		(Core extends Transceiver<infer Signal> ? Signal : never) | null
+	>({
+		key: trackerKey,
+		default: null,
+		effects: [
+			({ setSelf }) => {
+				AtomIO.getState(coreState).observe((update) => setSelf(update))
+			},
+			({ onSet }) => {
+				onSet(({ newValue, oldValue }) => {
+					const timelineId = store.timelineAtoms.getRelatedId(trackerKey)
+					if (timelineId) {
+						const timelineData = store.timelines.get(timelineId)
+						if (timelineData?.timeTraveling) {
+							const unsubscribe = AtomIO.subscribeToTimeline(
+								{ key: timelineId, type: `timeline` },
+								(update) => {
+									unsubscribe()
+									AtomIO.setState(coreState, (core) => {
+										if (update === `redo` && newValue) {
+											core.do(newValue)
+										} else if (update === `undo` && oldValue) {
+											core.undo(oldValue)
+										}
+										return core
+									})
+								},
+							)
+							return
+						}
+					}
+
+					const { unsubscribe } = store.subject.operationStatus.subscribe(() => {
+						unsubscribe()
+						if (newValue) {
+							AtomIO.setState(coreState, (core) => (core.do(newValue), core))
+						}
+					})
+				})
+			},
+		],
+	})
+	return trackerState
+}

package/src/web-effects/storage.ts

@@ -25,6 +25,6 @@ export const persistAtom =
 		})
 	}
 
-export const lazyLocalStorageEffect: <J extends Json>(
+export const lazyLocalStorageEffect: <J extends Json.Serializable>(
 	key: string,
 ) => AtomEffect<J> = persistAtom(localStorage)(JSON)

package/src/internal/subject.ts

@@ -1,24 +0,0 @@
-type Subscriber<T> = (value: T) => void
-
-export class Subject<T> {
-	public subscribers: Subscriber<T>[] = []
-
-	public subscribe(subscriber: Subscriber<T>): { unsubscribe: () => void } {
-		this.subscribers.push(subscriber)
-		const unsubscribe = () => this.unsubscribe(subscriber)
-		return { unsubscribe }
-	}
-
-	private unsubscribe(subscriber: Subscriber<T>) {
-		const subscriberIndex = this.subscribers.indexOf(subscriber)
-		if (subscriberIndex !== -1) {
-			this.subscribers.splice(subscriberIndex, 1)
-		}
-	}
-
-	public next(value: T): void {
-		for (const subscriber of this.subscribers) {
-			subscriber(value)
-		}
-	}
-}