atom.io 0.6.7 → 0.6.9

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>(
-		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.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>(
-		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>(
-		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-context.tsx

@@ -1,30 +0,0 @@
-import * as AR from "atom.io/react"
-import * as React from "react"
-import type { Socket } from "socket.io-client"
-import { io } from "socket.io-client"
-
-import { myIdState__INTERNAL } from "./realtime-state"
-
-export const RealtimeContext = React.createContext<{ socket: Socket }>({
-	socket: io(),
-})
-
-export const RealtimeProvider: React.FC<{
-	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>
-	)
-}

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>(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,
-}
-
-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>(
-	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])
-}

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

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

@@ -1,22 +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>(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,25 +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>(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/realtime-testing/index.ts

@@ -1 +0,0 @@
-export * from "./setup-realtime-test"

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

@@ -1,159 +0,0 @@
-import * as http from "http"
-
-import { prettyDOM, render, type RenderResult } from "@testing-library/react"
-import * as AtomIO from "atom.io"
-import * as AR from "atom.io/react"
-import * as RTC from "atom.io/realtime-react"
-import * as RR from "fp-ts/ReadonlyRecord"
-import * as Happy from "happy-dom"
-import * as React from "react"
-import * as SocketIO from "socket.io"
-import type { Socket as ClientSocket } from "socket.io-client"
-import { io } from "socket.io-client"
-
-export type TestSetupOptions = {
-	server: (tools: { socket: SocketIO.Socket; silo: AtomIO.Silo }) => void
-}
-export type TestSetupOptions__SingleClient = TestSetupOptions & {
-	client: React.FC
-}
-export type TestSetupOptions__MultiClient<ClientNames extends string> =
-	TestSetupOptions & {
-		clients: {
-			[K in ClientNames]: React.FC
-		}
-	}
-
-export type RealtimeTestTools = {
-	name: string
-	silo: AtomIO.Silo
-	dispose: () => void
-}
-export type RealtimeTestClient = RealtimeTestTools & {
-	renderResult: RenderResult
-	prettyPrint: () => void
-	reconnect: () => void
-	disconnect: () => void
-}
-export type RealtimeTestServer = RealtimeTestTools & {
-	port: number
-}
-
-export type RealtimeTestAPI = {
-	server: RealtimeTestServer
-	teardown: () => void
-}
-export type RealtimeTestAPI__SingleClient = RealtimeTestAPI & {
-	client: RealtimeTestClient
-}
-export type RealtimeTestAPI__MultiClient<ClientNames extends string> =
-	RealtimeTestAPI & {
-		clients: Record<ClientNames, RealtimeTestClient>
-	}
-
-export const setupRealtimeTestServer = (
-	options: TestSetupOptions,
-): RealtimeTestServer => {
-	const httpServer = http.createServer((_, res) => res.end(`Hello World!`))
-	const address = httpServer.listen().address()
-	const port =
-		typeof address === `string` ? 80 : address === null ? null : address.port
-	if (port === null) throw new Error(`Could not determine port for test server`)
-	const server = new SocketIO.Server(httpServer)
-	const silo = AtomIO.silo(`SERVER`, AtomIO.__INTERNAL__.IMPLICIT.STORE)
-
-	server.on(`connection`, (socket: SocketIO.Socket) => {
-		options.server({ socket, silo })
-	})
-
-	const dispose = () => {
-		server.close()
-		AtomIO.__INTERNAL__.clearStore(silo.store)
-	}
-
-	return {
-		name: `SERVER`,
-		silo,
-		dispose,
-		port,
-	}
-}
-export const setupRealtimeTestClient = (
-	options: TestSetupOptions__SingleClient,
-	name: string,
-	port: number,
-): RealtimeTestClient => {
-	const socket: ClientSocket = io(`http://localhost:${port}/`)
-	const silo = AtomIO.silo(name, AtomIO.__INTERNAL__.IMPLICIT.STORE)
-
-	const { document } = new Happy.Window()
-	document.body.innerHTML = `<div id="app"></div>`
-	const renderResult = render(
-		<AR.StoreProvider store={silo.store}>
-			<RTC.RealtimeProvider socket={socket}>
-				<options.client />
-			</RTC.RealtimeProvider>
-		</AR.StoreProvider>,
-		{
-			container: document.querySelector(`#app`) as unknown as HTMLElement,
-		},
-	)
-
-	const prettyPrint = () => console.log(prettyDOM(renderResult.container))
-
-	const disconnect = () => socket.disconnect()
-	const reconnect = () => socket.connect()
-
-	const dispose = () => {
-		socket.disconnect()
-		AtomIO.__INTERNAL__.clearStore(silo.store)
-	}
-
-	return {
-		name,
-		silo,
-		renderResult,
-		prettyPrint,
-		disconnect,
-		reconnect,
-		dispose,
-	}
-}
-
-export const singleClient = (
-	options: TestSetupOptions__SingleClient,
-): RealtimeTestAPI__SingleClient => {
-	const server = setupRealtimeTestServer(options)
-	const client = setupRealtimeTestClient(options, `CLIENT`, server.port)
-
-	return {
-		client,
-		server,
-		teardown: () => {
-			client.dispose()
-			server.dispose()
-		},
-	}
-}
-
-export const multiClient = <ClientNames extends string>(
-	options: TestSetupOptions__MultiClient<ClientNames>,
-): RealtimeTestAPI__MultiClient<ClientNames> => {
-	const server = setupRealtimeTestServer(options)
-	const clients = RR.toEntries(options.clients).reduce(
-		(clients, [name, client]) => ({
-			...clients,
-			[name]: setupRealtimeTestClient({ ...options, client }, name, server.port),
-		}),
-		{} as Record<ClientNames, RealtimeTestClient>,
-	)
-
-	return {
-		clients,
-		server,
-		teardown: () => {
-			RR.toEntries(clients).forEach(([, client]) => client.dispose())
-			server.dispose()
-		},
-	}
-}

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>(
-	key: string,
-) => AtomEffect<J> = persistAtom(localStorage)(JSON)