atom.io 0.6.8 → 0.6.9

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