atom.io 0.6.7 → 0.6.8

package/src/internal/timeline-internal.ts

@@ -31,7 +31,7 @@ export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 export type Timeline = {
 	key: string
 	at: number
-	timeTraveling: boolean
+	timeTraveling: `into_future` | `into_past` | null
 	history: TimelineUpdate[]
 	selectorTime: number | null
 	transactionKey: string | null
@@ -53,7 +53,7 @@ export function timeline__INTERNAL(
 	const tl: Timeline = {
 		key: options.key,
 		at: 0,
-		timeTraveling: false,
+		timeTraveling: null,
 		selectorTime: null,
 		transactionKey: null,
 		...data,

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

@@ -16,7 +16,7 @@ export const attachTimelineFamily = (
 				store.timelines.get(key) ?? {
 					key: ``,
 					at: 0,
-					timeTraveling: false,
+					timeTraveling: null,
 					history: [],
 					selectorTime: null,
 					transactionKey: null,

package/src/json/select-json.ts

@@ -2,7 +2,7 @@ import * as AtomIO from "atom.io"
 
 import type { Json, JsonInterface } from "~/packages/anvl/src/json"
 
-export const selectJson = <T, J extends Json>(
+export const selectJson = <T, J extends Json.Serializable>(
 	atom: AtomIO.AtomToken<T>,
 	transform: JsonInterface<T, J>,
 	store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE,

package/src/react-devtools/StateEditor.tsx

@@ -3,7 +3,9 @@ import { useO, useIO } from "atom.io/react"
 import type { FC } from "react"
 
 import { fallback } from "~/packages/anvl/src/function"
-import { isJson } from "~/packages/anvl/src/json"
+import { Join } from "~/packages/anvl/src/join"
+import { isJson } from "~/packages/anvl/src/refinement/refine-json"
+import { RelationEditor } from "~/packages/hamr/src/react-data-designer"
 import { ElasticInput } from "~/packages/hamr/src/react-elastic-input"
 import { JsonEditor } from "~/packages/hamr/src/react-json-editor"
 
@@ -13,6 +15,8 @@ export const StateEditor: FC<{
 	const [data, set] = useIO(token)
 	return isJson(data) ? (
 		<JsonEditor data={data} set={set} schema={true} />
+	) : data instanceof Join ? (
+		<RelationEditor data={data} set={set} />
 	) : (
 		<div className="json_editor">
 			<ElasticInput

package/src/react-devtools/StateIndex.tsx

@@ -3,7 +3,10 @@ import { getState, selectorFamily } from "atom.io"
 import { useO, useIO } from "atom.io/react"
 import type { FC } from "react"
 
-import { isJson, refineJsonType } from "~/packages/anvl/src/json"
+import {
+	isJson,
+	refineJsonType,
+} from "~/packages/anvl/src/refinement/refine-json"
 
 import { findViewIsOpenState, primitiveRefinery } from "."
 import { button } from "./Button"

package/src/react-devtools/devtools.scss

@@ -241,7 +241,6 @@ main.atom_io_devtools {
 
   .json_editor {
     input {
-      // font-size: 20px;
       font-family: theia;
       border: none;
       border-bottom: 1px solid;

package/src/realtime/hook-composition/expose-family.ts

@@ -17,7 +17,7 @@ const subscribeToTokenCreation = <T>(
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useExposeFamily = ({ socket, store }: ServerConfig) => {
-	return function exposeFamily<J extends Json>(
+	return function exposeFamily<J extends Json.Serializable>(
 		family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
 		index: AtomIO.StateToken<Set<string>>,
 	): () => void {
@@ -39,7 +39,7 @@ export const useExposeFamily = ({ socket, store }: ServerConfig) => {
 			}
 		}
 
-		const fillSubRequest = (subKey?: AtomIO.Serializable) => {
+		const fillSubRequest = (subKey?: AtomIO.Json.Serializable) => {
 			if (subKey === undefined) {
 				const keys = AtomIO.getState(index, store)
 				keys.forEach((key) => {

package/src/realtime/hook-composition/expose-single.ts

@@ -5,7 +5,7 @@ import type { ServerConfig } from ".."
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useExposeSingle = ({ socket, store }: ServerConfig) => {
-	return function exposeSingle<J extends Json>(
+	return function exposeSingle<J extends Json.Serializable>(
 		token: AtomIO.StateToken<J>,
 	): () => void {
 		let unsubscribeFromStateUpdates: (() => void) | null = null

package/src/realtime/hook-composition/receive-state.ts

@@ -5,7 +5,7 @@ import type { ServerConfig } from ".."
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useReceiveState = ({ socket, store }: ServerConfig) => {
-	return function receiveState<J extends Json>(
+	return function receiveState<J extends Json.Serializable>(
 		token: AtomIO.StateToken<J>,
 	): () => void {
 		const publish = (newValue: J) => AtomIO.setState(token, newValue, store)

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)
-		}
-	}
-}