atom.io 0.6.1 → 0.6.3

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

@@ -5,97 +5,97 @@ import * as AtomIO from "atom.io"
 import type { ServerConfig } from ".."
 
 const subscribeToTokenCreation = <T>(
-  family: AtomIO.AtomFamily<T> | AtomIO.SelectorFamily<T>,
-  handleTokenCreation: (token: AtomIO.StateToken<T>) => void
+	family: AtomIO.AtomFamily<T> | AtomIO.SelectorFamily<T>,
+	handleTokenCreation: (token: AtomIO.StateToken<T>) => void,
 ): (() => void) => {
-  const subscription =
-    family.type === `atom_family`
-      ? family.subject.subscribe(handleTokenCreation)
-      : family.subject.subscribe(handleTokenCreation)
-  return () => subscription.unsubscribe()
+	const subscription =
+		family.type === `atom_family`
+			? family.subject.subscribe(handleTokenCreation)
+			: family.subject.subscribe(handleTokenCreation)
+	return () => subscription.unsubscribe()
 }
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useExposeFamily = ({ socket, store }: ServerConfig) => {
-  return function exposeFamily<J extends Json>(
-    family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
-    index: AtomIO.StateToken<Set<string>>
-  ): () => void {
-    const unsubSingleCallbacksByKey = new Map<string, () => void>()
-    const unsubFamilyCallbacksByKey = new Map<string, () => void>()
+	return function exposeFamily<J extends Json>(
+		family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
+		index: AtomIO.StateToken<Set<string>>,
+	): () => void {
+		const unsubSingleCallbacksByKey = new Map<string, () => void>()
+		const unsubFamilyCallbacksByKey = new Map<string, () => void>()
 
-    const fillFamilyUnsubRequest = () => {
-      unsubFamilyCallbacksByKey.forEach((unsub) => unsub())
-      unsubFamilyCallbacksByKey.clear()
-      socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest)
-    }
+		const fillFamilyUnsubRequest = () => {
+			unsubFamilyCallbacksByKey.forEach((unsub) => unsub())
+			unsubFamilyCallbacksByKey.clear()
+			socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest)
+		}
 
-    const fillSingleUnsubRequest = (key: string) => {
-      socket.off(`unsub:${key}`, fillSingleUnsubRequest)
-      const unsub = unsubSingleCallbacksByKey.get(key)
-      if (unsub) {
-        unsub()
-        unsubSingleCallbacksByKey.delete(key)
-      }
-    }
+		const fillSingleUnsubRequest = (key: string) => {
+			socket.off(`unsub:${key}`, fillSingleUnsubRequest)
+			const unsub = unsubSingleCallbacksByKey.get(key)
+			if (unsub) {
+				unsub()
+				unsubSingleCallbacksByKey.delete(key)
+			}
+		}
 
-    const fillSubRequest = (subKey?: AtomIO.Serializable) => {
-      if (subKey === undefined) {
-        const keys = AtomIO.getState(index, store)
-        keys.forEach((key) => {
-          const token = family(key)
-          socket.emit(
-            `serve:${family.key}`,
-            parseJson(token.family?.subKey || `null`),
-            AtomIO.getState(token, store)
-          )
-        })
+		const fillSubRequest = (subKey?: AtomIO.Serializable) => {
+			if (subKey === undefined) {
+				const keys = AtomIO.getState(index, store)
+				keys.forEach((key) => {
+					const token = family(key)
+					socket.emit(
+						`serve:${family.key}`,
+						parseJson(token.family?.subKey || `null`),
+						AtomIO.getState(token, store),
+					)
+				})
 
-        const unsubscribeFromTokenCreation = subscribeToTokenCreation(
-          family,
-          (token) => {
-            const unsub = AtomIO.subscribe(
-              token,
-              ({ newValue }) => {
-                socket.emit(
-                  `serve:${family.key}`,
-                  parseJson(token.family?.subKey || `null`),
-                  newValue
-                )
-              },
-              store
-            )
-            unsubFamilyCallbacksByKey.set(token.key, unsub)
-          }
-        )
-        unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation)
+				const unsubscribeFromTokenCreation = subscribeToTokenCreation(
+					family,
+					(token) => {
+						const unsub = AtomIO.subscribe(
+							token,
+							({ newValue }) => {
+								socket.emit(
+									`serve:${family.key}`,
+									parseJson(token.family?.subKey || `null`),
+									newValue,
+								)
+							},
+							store,
+						)
+						unsubFamilyCallbacksByKey.set(token.key, unsub)
+					},
+				)
+				unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation)
 
-        socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest)
-      } else {
-        const token = family(subKey)
-        socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
-        const unsubscribe = AtomIO.subscribe(
-          token,
-          ({ newValue }) => {
-            socket.emit(`serve:${token.key}`, newValue)
-          },
-          store
-        )
-        unsubSingleCallbacksByKey.set(token.key, unsubscribe)
-        socket.on(`unsub:${token.key}`, () => {
-          fillSingleUnsubRequest(token.key)
-        })
-      }
-    }
+				socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest)
+			} else {
+				const token = family(subKey)
+				socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
+				const unsubscribe = AtomIO.subscribe(
+					token,
+					({ newValue }) => {
+						socket.emit(`serve:${token.key}`, newValue)
+					},
+					store,
+				)
+				unsubSingleCallbacksByKey.set(token.key, unsubscribe)
+				socket.on(`unsub:${token.key}`, () => {
+					fillSingleUnsubRequest(token.key)
+				})
+			}
+		}
 
-    socket.on(`sub:${family.key}`, fillSubRequest)
+		socket.on(`sub:${family.key}`, fillSubRequest)
 
-    return () => {
-      socket.off(`sub:${family.key}`, fillSubRequest)
-      unsubFamilyCallbacksByKey.forEach((unsub) => unsub())
-      unsubSingleCallbacksByKey.forEach((unsub) => unsub())
-      unsubFamilyCallbacksByKey.clear()
-      unsubSingleCallbacksByKey.clear()
-    }
-  }
+		return () => {
+			socket.off(`sub:${family.key}`, fillSubRequest)
+			unsubFamilyCallbacksByKey.forEach((unsub) => unsub())
+			unsubSingleCallbacksByKey.forEach((unsub) => unsub())
+			unsubFamilyCallbacksByKey.clear()
+			unsubSingleCallbacksByKey.clear()
+		}
+	}
 }

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

@@ -5,34 +5,34 @@ import type { ServerConfig } from ".."
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useExposeSingle = ({ socket, store }: ServerConfig) => {
-  return function exposeSingle<J extends Json>(
-    token: AtomIO.StateToken<J>
-  ): () => void {
-    let unsubscribeFromStateUpdates: (() => void) | null = null
+	return function exposeSingle<J extends Json>(
+		token: AtomIO.StateToken<J>,
+	): () => void {
+		let unsubscribeFromStateUpdates: (() => void) | null = null
 
-    const fillUnsubRequest = () => {
-      socket.off(`unsub:${token.key}`, fillUnsubRequest)
-      unsubscribeFromStateUpdates?.()
-      unsubscribeFromStateUpdates = null
-    }
+		const fillUnsubRequest = () => {
+			socket.off(`unsub:${token.key}`, fillUnsubRequest)
+			unsubscribeFromStateUpdates?.()
+			unsubscribeFromStateUpdates = null
+		}
 
-    const fillSubRequest = () => {
-      socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
-      unsubscribeFromStateUpdates = AtomIO.subscribe(
-        token,
-        ({ newValue }) => {
-          socket.emit(`serve:${token.key}`, newValue)
-        },
-        store
-      )
-      socket.on(`unsub:${token.key}`, fillUnsubRequest)
-    }
+		const fillSubRequest = () => {
+			socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
+			unsubscribeFromStateUpdates = AtomIO.subscribe(
+				token,
+				({ newValue }) => {
+					socket.emit(`serve:${token.key}`, newValue)
+				},
+				store,
+			)
+			socket.on(`unsub:${token.key}`, fillUnsubRequest)
+		}
 
-    socket.on(`sub:${token.key}`, fillSubRequest)
+		socket.on(`sub:${token.key}`, fillSubRequest)
 
-    return () => {
-      socket.off(`sub:${token.key}`, fillSubRequest)
-      unsubscribeFromStateUpdates?.()
-    }
-  }
+		return () => {
+			socket.off(`sub:${token.key}`, fillSubRequest)
+			unsubscribeFromStateUpdates?.()
+		}
+	}
 }

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

@@ -0,0 +1,60 @@
+import * as AtomIO from "atom.io"
+
+import { Join } from "~/packages/anvl/src/join"
+
+import type { ServerConfig } from "."
+import type { TimelineTransactionUpdate } from "../../internal"
+
+export type TransactionRequest = {
+	key: string
+	params: unknown[]
+	transactionId: string
+}
+
+export const useExposeTimeline__UNSTABLE = ({
+	socket,
+	store,
+}: ServerConfig): ((tl: AtomIO.TimelineToken) => () => void) => {
+	const timestampsOfTransactionsState = AtomIO.__INTERNAL__.atom__INTERNAL(
+		{
+			key: `timestampsOfTransactions`,
+			default: new Join<null, `transactionId`, `timestamp`>({
+				relationType: `1:1`,
+			})
+				.from(`transactionId`)
+				.to(`timestamp`),
+		},
+		undefined,
+		store,
+	)
+	return function exposeTimeline(tl: AtomIO.TimelineToken): () => void {
+		const handleTransactionRequest = (update: TransactionRequest) => {
+			AtomIO.runTransaction(
+				{ key: update.key, type: `transaction` },
+				store,
+			)(...update.params)
+		}
+
+		socket.on(`txr:${tl.key}`, handleTransactionRequest)
+
+		const unsubscribeFromTimeline = AtomIO.subscribeToTimeline(
+			tl,
+			(update: TimelineTransactionUpdate) => {
+				// const timestamp = update.timestamp.toString()
+				// AtomIO.setState(
+				//   timestampsOfTransactionsState,
+				//   (j) => j.set(update),
+				//   store
+				// )
+				if (update.type === `transaction_update`) {
+					socket.emit(`tl:${tl.key}`, update)
+				}
+			},
+		)
+
+		return () => {
+			socket.off(`tlu:${tl.key}`, handleTransactionRequest)
+			unsubscribeFromTimeline()
+		}
+	}
+}

package/src/realtime/hook-composition/index.ts

@@ -7,6 +7,6 @@ export * from "./receive-transaction"
 export * from "./receive-state"
 
 export type ServerConfig = {
-  socket: SocketIO.Socket
-  store?: AtomIO.__INTERNAL__.Store
+	socket: SocketIO.Socket
+	store?: AtomIO.__INTERNAL__.Store
 }

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

@@ -5,25 +5,25 @@ import type { ServerConfig } from ".."
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useReceiveState = ({ socket, store }: ServerConfig) => {
-  return function receiveState<J extends Json>(
-    token: AtomIO.StateToken<J>
-  ): () => void {
-    const publish = (newValue: J) => AtomIO.setState(token, newValue, store)
+	return function receiveState<J extends Json>(
+		token: AtomIO.StateToken<J>,
+	): () => void {
+		const publish = (newValue: J) => AtomIO.setState(token, newValue, store)
 
-    const fillPubUnclaim = () => {
-      socket.off(`pub:${token.key}`, publish)
-      socket.off(`unclaim:${token.key}`, fillPubUnclaim)
-    }
-    const fillPubClaim = () => {
-      socket.on(`pub:${token.key}`, publish)
-      socket.on(`unclaim:${token.key}`, fillPubUnclaim)
-    }
+		const fillPubUnclaim = () => {
+			socket.off(`pub:${token.key}`, publish)
+			socket.off(`unclaim:${token.key}`, fillPubUnclaim)
+		}
+		const fillPubClaim = () => {
+			socket.on(`pub:${token.key}`, publish)
+			socket.on(`unclaim:${token.key}`, fillPubUnclaim)
+		}
 
-    socket.on(`claim:${token.key}`, fillPubClaim)
+		socket.on(`claim:${token.key}`, fillPubClaim)
 
-    return () => {
-      socket.off(`claim:${token.key}`, fillPubClaim)
-      socket.off(`pub:${token.key}`, publish)
-    }
-  }
+		return () => {
+			socket.off(`claim:${token.key}`, fillPubClaim)
+			socket.off(`pub:${token.key}`, publish)
+		}
+	}
 }

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

@@ -5,14 +5,14 @@ import type { ƒn } from "~/packages/anvl/src/function"
 import type { ServerConfig } from "."
 
 export const useReceiveTransaction = ({ socket, store }: ServerConfig) => {
-  return function receiveTransaction<ƒ extends ƒn>(
-    tx: AtomIO.TransactionToken<ƒ>
-  ): () => void {
-    const fillTransactionRequest = (update: AtomIO.TransactionUpdate<ƒ>) =>
-      AtomIO.runTransaction<ƒ>(tx, store)(...update.params)
+	return function receiveTransaction<ƒ extends ƒn>(
+		tx: AtomIO.TransactionToken<ƒ>,
+	): () => void {
+		const fillTransactionRequest = (update: AtomIO.TransactionUpdate<ƒ>) =>
+			AtomIO.runTransaction<ƒ>(tx, store)(...update.params)
 
-    socket.on(`tx:${tx.key}`, fillTransactionRequest)
+		socket.on(`tx:${tx.key}`, fillTransactionRequest)
 
-    return () => socket.off(`tx:${tx.key}`, fillTransactionRequest)
-  }
+		return () => socket.off(`tx:${tx.key}`, fillTransactionRequest)
+	}
 }

package/src/realtime-react/realtime-context.tsx

@@ -7,25 +7,25 @@ import { io } from "socket.io-client"
 import { myIdState__INTERNAL } from "./realtime-state"
 
 export const RealtimeContext = React.createContext<{ socket: Socket }>({
-  socket: io(),
+	socket: io(),
 })
 
 export const RealtimeProvider: React.FC<{
-  children: React.ReactNode
-  socket: Socket
+	children: React.ReactNode
+	socket: Socket
 }> = ({ children, socket }) => {
-  const setMyId = AR.useI(myIdState__INTERNAL)
-  React.useEffect(() => {
-    socket.on(`connect`, () => {
-      setMyId(socket.id)
-    })
-    socket.on(`disconnect`, () => {
-      setMyId(null)
-    })
-  }, [socket, setMyId])
-  return (
-    <RealtimeContext.Provider value={{ socket }}>
-      {children}
-    </RealtimeContext.Provider>
-  )
+	const setMyId = AR.useI(myIdState__INTERNAL)
+	React.useEffect(() => {
+		socket.on(`connect`, () => {
+			setMyId(socket.id)
+		})
+		socket.on(`disconnect`, () => {
+			setMyId(null)
+		})
+	}, [socket, setMyId])
+	return (
+		<RealtimeContext.Provider value={{ socket }}>
+			{children}
+		</RealtimeContext.Provider>
+	)
 }

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

@@ -10,26 +10,26 @@ 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>(
-    family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>
-  ) => void
-  usePullFamilyMember: <J extends Json>(
-    family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
-    subKey: string
-  ) => void
-  usePush: <J extends Json>(token: AtomIO.StateToken<J>) => void
-  useServerAction: <ƒ extends ƒn>(
-    token: AtomIO.TransactionToken<ƒ>
-  ) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
+	usePull: <J extends Json>(token: AtomIO.StateToken<J>) => void
+	usePullFamily: <J extends Json>(
+		family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
+	) => void
+	usePullFamilyMember: <J extends Json>(
+		family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
+		subKey: string,
+	) => void
+	usePush: <J extends Json>(token: AtomIO.StateToken<J>) => void
+	useServerAction: <ƒ extends ƒn>(
+		token: AtomIO.TransactionToken<ƒ>,
+	) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
 }
 
 export const realtimeHooks: RealtimeHooks = {
-  usePull,
-  usePullFamily,
-  usePullFamilyMember,
-  usePush,
-  useServerAction,
+	usePull,
+	usePullFamily,
+	usePullFamilyMember,
+	usePush,
+	useServerAction,
 }
 
 export * from "./use-pull"

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

@@ -1,10 +1,10 @@
 import * as AtomIO from "atom.io"
 
 export const myIdState__INTERNAL = AtomIO.atom<string | null>({
-  key: `myId__INTERNAL`,
-  default: null,
+	key: `myId__INTERNAL`,
+	default: null,
 })
 export const myIdState = AtomIO.selector<string | null>({
-  key: `myId`,
-  get: ({ get }) => get(myIdState__INTERNAL),
+	key: `myId`,
+	get: ({ get }) => get(myIdState__INTERNAL),
 })

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

@@ -8,20 +8,20 @@ import { RealtimeContext } from "./realtime-context"
 import { StoreContext } from "../react"
 
 export function usePullFamilyMember<J extends Json>(
-  family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
-  subKey: AtomIO.Serializable
+	family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
+	subKey: AtomIO.Serializable,
 ): void {
-  const token = family(subKey)
-  const { socket } = React.useContext(RealtimeContext)
-  const store = React.useContext(StoreContext)
-  React.useEffect(() => {
-    socket?.on(`serve:${token.key}`, (data: J) => {
-      AtomIO.setState(family(subKey), data, store)
-    })
-    socket?.emit(`sub:${family.key}`, subKey)
-    return () => {
-      socket?.off(`serve:${token.key}`)
-      socket?.emit(`unsub:${token.key}`)
-    }
-  }, [family.key])
+	const token = family(subKey)
+	const { socket } = React.useContext(RealtimeContext)
+	const store = React.useContext(StoreContext)
+	React.useEffect(() => {
+		socket?.on(`serve:${token.key}`, (data: J) => {
+			AtomIO.setState(family(subKey), data, store)
+		})
+		socket?.emit(`sub:${family.key}`, subKey)
+		return () => {
+			socket?.off(`serve:${token.key}`)
+			socket?.emit(`unsub:${token.key}`)
+		}
+	}, [family.key])
 }

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

@@ -8,18 +8,18 @@ import { RealtimeContext } from "./realtime-context"
 import { StoreContext } from "../react"
 
 export function usePullFamily<J extends Json>(
-  family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>
+	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) => {
-      AtomIO.setState(family(key), data, store)
-    })
-    socket?.emit(`sub:${family.key}`)
-    return () => {
-      socket?.off(`serve:${family.key}`)
-      socket?.emit(`unsub:${family.key}`)
-    }
-  }, [family.key])
+	const { socket } = React.useContext(RealtimeContext)
+	const store = React.useContext(StoreContext)
+	React.useEffect(() => {
+		socket.on(`serve:${family.key}`, (key: Json, data: J) => {
+			AtomIO.setState(family(key), data, store)
+		})
+		socket?.emit(`sub:${family.key}`)
+		return () => {
+			socket?.off(`serve:${family.key}`)
+			socket?.emit(`unsub:${family.key}`)
+		}
+	}, [family.key])
 }

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

@@ -8,16 +8,16 @@ import { RealtimeContext } from "./realtime-context"
 import { StoreContext } from "../react"
 
 export function usePull<J extends Json>(token: AtomIO.StateToken<J>): void {
-  const { socket } = React.useContext(RealtimeContext)
-  const store = React.useContext(StoreContext)
-  React.useEffect(() => {
-    socket.on(`serve:${token.key}`, (data: J) => {
-      AtomIO.setState(token, data, store)
-    })
-    socket.emit(`sub:${token.key}`)
-    return () => {
-      socket.off(`serve:${token.key}`)
-      socket.emit(`unsub:${token.key}`)
-    }
-  }, [token.key])
+	const { socket } = React.useContext(RealtimeContext)
+	const store = React.useContext(StoreContext)
+	React.useEffect(() => {
+		socket.on(`serve:${token.key}`, (data: J) => {
+			AtomIO.setState(token, data, store)
+		})
+		socket.emit(`sub:${token.key}`)
+		return () => {
+			socket.off(`serve:${token.key}`)
+			socket.emit(`unsub:${token.key}`)
+		}
+	}, [token.key])
 }

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

@@ -8,19 +8,19 @@ import { RealtimeContext } from "./realtime-context"
 import { StoreContext } from "../react"
 
 export function usePush<J extends Json>(token: AtomIO.StateToken<J>): void {
-  const { socket } = React.useContext(RealtimeContext)
-  const store = React.useContext(StoreContext)
-  React.useEffect(() => {
-    socket.emit(`claim:${token.key}`)
-    AtomIO.subscribe(
-      token,
-      ({ newValue }) => {
-        socket.emit(`pub:${token.key}`, newValue)
-      },
-      store
-    )
-    return () => {
-      socket.emit(`unclaim:${token.key}`)
-    }
-  }, [token.key])
+	const { socket } = React.useContext(RealtimeContext)
+	const store = React.useContext(StoreContext)
+	React.useEffect(() => {
+		socket.emit(`claim:${token.key}`)
+		AtomIO.subscribe(
+			token,
+			({ newValue }) => {
+				socket.emit(`pub:${token.key}`, newValue)
+			},
+			store,
+		)
+		return () => {
+			socket.emit(`unclaim:${token.key}`)
+		}
+	}, [token.key])
 }