atom.io 0.6.8 → 0.7.0

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

@@ -1,101 +0,0 @@
-import type { Json } from "anvl/json"
-import { parseJson } from "anvl/json"
-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,
-): (() => void) => {
-	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.Serializable>(
-		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 fillSingleUnsubRequest = (key: string) => {
-			socket.off(`unsub:${key}`, fillSingleUnsubRequest)
-			const unsub = unsubSingleCallbacksByKey.get(key)
-			if (unsub) {
-				unsub()
-				unsubSingleCallbacksByKey.delete(key)
-			}
-		}
-
-		const fillSubRequest = (subKey?: AtomIO.Json.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)
-
-				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)
-
-		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

@@ -1,38 +0,0 @@
-import type { Json } from "anvl/json"
-import * as AtomIO from "atom.io"
-
-import type { ServerConfig } from ".."
-
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-export const useExposeSingle = ({ socket, store }: ServerConfig) => {
-	return function exposeSingle<J extends Json.Serializable>(
-		token: AtomIO.StateToken<J>,
-	): () => void {
-		let unsubscribeFromStateUpdates: (() => void) | null = 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)
-		}
-
-		socket.on(`sub:${token.key}`, fillSubRequest)
-
-		return () => {
-			socket.off(`sub:${token.key}`, fillSubRequest)
-			unsubscribeFromStateUpdates?.()
-		}
-	}
-}

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

@@ -1,60 +0,0 @@
-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

@@ -1,12 +0,0 @@
-import type * as AtomIO from "atom.io"
-import type * as SocketIO from "socket.io"
-
-export * from "./expose-single"
-export * from "./expose-family"
-export * from "./receive-transaction"
-export * from "./receive-state"
-
-export type ServerConfig = {
-	socket: SocketIO.Socket
-	store?: AtomIO.__INTERNAL__.Store
-}

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

@@ -1,29 +0,0 @@
-import type { Json } from "anvl/json"
-import * as AtomIO from "atom.io"
-
-import type { ServerConfig } from ".."
-
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-export const useReceiveState = ({ socket, store }: ServerConfig) => {
-	return function receiveState<J extends Json.Serializable>(
-		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)
-		}
-
-		socket.on(`claim:${token.key}`, fillPubClaim)
-
-		return () => {
-			socket.off(`claim:${token.key}`, fillPubClaim)
-			socket.off(`pub:${token.key}`, publish)
-		}
-	}
-}

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

@@ -1,18 +0,0 @@
-import * as AtomIO from "atom.io"
-
-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)
-
-		socket.on(`tx:${tx.key}`, fillTransactionRequest)
-
-		return () => socket.off(`tx:${tx.key}`, fillTransactionRequest)
-	}
-}

package/src/realtime/index.ts

@@ -1 +0,0 @@
-export * from "./hook-composition"

package/src/realtime-react/index.ts

@@ -1,3 +0,0 @@
-export * from "./realtime-context"
-export * from "./realtime-hooks"
-export * from "./realtime-state"

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

@@ -1,39 +0,0 @@
-import type * as AtomIO from "atom.io"
-
-import type { ƒn } from "~/packages/anvl/src/function"
-import type { Json } from "~/packages/anvl/src/json"
-
-import { usePull } from "./use-pull"
-import { usePullFamily } from "./use-pull-family"
-import { usePullFamilyMember } from "./use-pull-family-member"
-import { usePush } from "./use-push"
-import { useServerAction } from "./use-server-action"
-
-export type RealtimeHooks = {
-	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.Serializable>(
-		family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
-		subKey: string,
-	) => void
-	usePush: <J extends Json.Serializable>(token: AtomIO.StateToken<J>) => void
-	useServerAction: <ƒ extends ƒn>(
-		token: AtomIO.TransactionToken<ƒ>,
-	) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
-}
-
-export const realtimeHooks: RealtimeHooks = {
-	usePull,
-	usePullFamily,
-	usePullFamilyMember,
-	usePush,
-	useServerAction,
-}
-
-export * from "./use-pull"
-export * from "./use-pull-family"
-export * from "./use-pull-family-member"
-export * from "./use-push"
-export * from "./use-server-action"

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

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

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

@@ -1,26 +0,0 @@
-import * as AtomIO from "atom.io"
-import * as React from "react"
-
-import type { Json } from "~/packages/anvl/src/json"
-
-import { RealtimeContext } from "./realtime-context"
-import { StoreContext } from "../react"
-
-export function usePullFamilyMember<J extends Json.Serializable>(
-	family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
-	subKey: AtomIO.Json.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])
-}

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

@@ -1,24 +0,0 @@
-import * as AtomIO from "atom.io"
-import * as React from "react"
-
-import type { Json } from "~/packages/anvl/src/json"
-
-import { RealtimeContext } from "./realtime-context"
-import { StoreContext } from "../react"
-
-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.Serializable, 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

@@ -1,24 +0,0 @@
-import * as AtomIO from "atom.io"
-import * as React from "react"
-
-import type { Json } from "~/packages/anvl/src/json"
-
-import { RealtimeContext } from "./realtime-context"
-import { StoreContext } from "../react"
-
-export function usePull<J extends Json.Serializable>(
-	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])
-}

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

@@ -1,27 +0,0 @@
-import * as AtomIO from "atom.io"
-import * as React from "react"
-
-import type { Json } from "~/packages/anvl/src/json"
-
-import { RealtimeContext } from "./realtime-context"
-import { StoreContext } from "../react"
-
-export function usePush<J extends Json.Serializable>(
-	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])
-}

package/src/realtime-react/use-server-action.ts

@@ -1,33 +0,0 @@
-import * as AtomIO from "atom.io"
-import { StoreContext } from "atom.io/react"
-import * as React from "react"
-
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import { RealtimeContext } from "./realtime-context"
-
-const TX_SUBS = new Map<string, number>()
-export function useServerAction<ƒ extends ƒn>(
-	token: AtomIO.TransactionToken<ƒ>,
-): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
-	const store = React.useContext(StoreContext)
-	const { socket } = React.useContext(RealtimeContext)
-	React.useEffect(() => {
-		const count = TX_SUBS.get(token.key) ?? 0
-		TX_SUBS.set(token.key, count + 1)
-		const unsubscribe =
-			count === 0
-				? AtomIO.subscribeToTransaction(
-						token,
-						(update) => socket.emit(`tx:${token.key}`, update),
-						store,
-				  )
-				: () => null
-		return () => {
-			const newCount = TX_SUBS.get(token.key) ?? 0
-			TX_SUBS.set(token.key, newCount - 1)
-			unsubscribe()
-		}
-	}, [token.key])
-	return AtomIO.runTransaction(token, store)
-}

package/src/tracker/index.ts

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

package/src/tracker/tracker.ts

@@ -1,61 +0,0 @@
-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/index.ts

@@ -1 +0,0 @@
-export * from "./storage"

package/src/web-effects/storage.ts

@@ -1,30 +0,0 @@
-import type { Json } from "~/packages/anvl/src/json"
-
-import type { AtomEffect } from "../index"
-
-export type StringInterface<T> = {
-	stringify: (t: T) => string
-	parse: (s: string) => T
-}
-
-export const persistAtom =
-	<T>(storage: Storage) =>
-	({ stringify, parse }: StringInterface<T>) =>
-	(key: string): AtomEffect<T> =>
-	({ setSelf, onSet }) => {
-		const savedValue = storage.getItem(key)
-
-		if (savedValue != null) setSelf(parse(savedValue))
-
-		onSet(({ newValue }) => {
-			if (newValue == null) {
-				storage.removeItem(key)
-				return
-			}
-			storage.setItem(key, stringify(newValue))
-		})
-	}
-
-export const lazyLocalStorageEffect: <J extends Json.Serializable>(
-	key: string,
-) => AtomEffect<J> = persistAtom(localStorage)(JSON)