atom.io 0.6.8 → 0.6.9

package/src/react-explorer/explorer-states.ts

@@ -1,217 +0,0 @@
-import { lastOf } from "~/packages/anvl/src/array"
-import { now } from "~/packages/anvl/src/id"
-import { Join } from "~/packages/anvl/src/join"
-import type { Entries } from "~/packages/anvl/src/object"
-
-import { addToIndex, removeFromIndex } from "."
-import {
-	makeSpaceLayoutNodeFamily,
-	makeSpaceFamily,
-	makeSpaceIndex,
-	makeSpaceLayoutState,
-} from "./space-states"
-import type { View } from "./view-states"
-import {
-	makeViewFocusedFamily,
-	makeViewFamily,
-	makeViewIndex,
-} from "./view-states"
-import type {
-	AtomFamily,
-	AtomToken,
-	ReadonlySelectorFamily,
-	SelectorFamily,
-	Write,
-} from ".."
-import { selectorFamily, selector, transaction, atom } from ".."
-import { persistAtom } from "../web-effects"
-
-export const makeViewsPerSpaceState = (
-	key: string,
-): AtomToken<Join<null, `viewId`, `spaceId`>> =>
-	atom<Join<null, `viewId`, `spaceId`>>({
-		key: `${key}:views_per_space`,
-		default: new Join({ relationType: `1:n` }).from(`viewId`).to(`spaceId`),
-		effects: [
-			persistAtom<Join<null, `viewId`, `spaceId`>>(localStorage)({
-				stringify: (index) => JSON.stringify(index.toJSON()),
-				parse: (json) =>
-					Join.fromJSON(JSON.parse(json), {
-						from: `viewId`,
-						to: `spaceId`,
-					}),
-			})(`${key}:views_per_space`),
-		],
-	})
-
-export const makeSpaceViewsFamily = (
-	key: string,
-	viewsPerSpaceState: AtomToken<Join<null, `viewId`, `spaceId`>>,
-): ReadonlySelectorFamily<string[], string> =>
-	selectorFamily<string[], string>({
-		key: `${key}:space_views`,
-		get: (spaceId) => ({ get }) => {
-			const join = get(viewsPerSpaceState)
-			const viewIds = join.getRelatedIds(spaceId)
-			return viewIds
-		},
-	})
-
-export const makeSpaceFocusedViewFamily = (
-	key: string,
-	findSpaceViewsState: ReadonlySelectorFamily<string[], string>,
-	findViewFocusedState: AtomFamily<number, string>,
-): SelectorFamily<string | null, string> =>
-	selectorFamily<string | null, string>({
-		key: `${key}:space_focused_view`,
-		get: (spaceKey) => ({ get }) => {
-			const views = get(findSpaceViewsState(spaceKey))
-			const viewsLastFocused = views.map((viewKey): [string, number] => [
-				viewKey,
-				get(findViewFocusedState(viewKey)),
-			])
-			const lastFocused = lastOf(viewsLastFocused.sort((a, b) => b[1] - a[1]))
-			return lastFocused ? lastFocused[0] : null
-		},
-		set: (spaceKey) => ({ get, set }, viewKey) => {
-			if (viewKey === null) {
-				return
-			}
-			const views = get(findSpaceViewsState(spaceKey))
-			if (views.includes(viewKey)) {
-				set(findViewFocusedState(viewKey), Date.now())
-			} else {
-				console.warn(`View ${viewKey} not found in space ${spaceKey}`)
-			}
-		},
-	})
-
-type AddViewOptions = { spaceId?: string; path?: string }
-type SplitSpaceOptions = { parentId?: string }
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export const attachExplorerState = (key: string) => {
-	const findSpaceState = makeSpaceFamily(key)
-	const findViewState = makeViewFamily(key)
-	const findViewFocusedState = makeViewFocusedFamily(key)
-	const spaceIndexState = makeSpaceIndex(key)
-	const spaceLayoutState = makeSpaceLayoutState(key)
-	const viewIndexState = makeViewIndex(key)
-	const viewsPerSpaceState = makeViewsPerSpaceState(key)
-
-	const findSpaceLayoutNode = makeSpaceLayoutNodeFamily(key, spaceLayoutState)
-	const findSpaceViewsState = makeSpaceViewsFamily(key, viewsPerSpaceState)
-	const findSpaceFocusedViewState = makeSpaceFocusedViewFamily(
-		key,
-		findSpaceViewsState,
-		findViewFocusedState,
-	)
-
-	const allViewsState = selector<Entries<string, View>>({
-		key: `${key}:all_views`,
-		get: ({ get }) => {
-			const viewIndex = get(viewIndexState)
-			return [...viewIndex].map((id) => [id, get(findViewState(id))])
-		},
-	})
-
-	const writeOperationAddSpace: Write<(options?: SplitSpaceOptions) => string> =
-		(transactors, { parentId = `root` } = {}) => {
-			const { set } = transactors
-			const key = `s-${now()}`
-			addToIndex(transactors, { indexAtom: spaceIndexState, id: key })
-			set(spaceLayoutState, (current) =>
-				current.set({ parent: `parent:${parentId}`, child: key }, { size: 1 }),
-			)
-			set(findSpaceState(key), 1)
-			return key
-		}
-
-	const writeOperationRemoveSpace: Write<(id: string) => void> = (
-		transactors,
-		id,
-	) => {
-		removeFromIndex(transactors, { indexAtom: spaceIndexState, id })
-		transactors.set(findSpaceState(id), null)
-	}
-
-	const writeOperationAddView: Write<(options?: AddViewOptions) => void> = (
-		transactors,
-		{ spaceId: maybeSpaceId, path } = {},
-	) => {
-		const { get, set } = transactors
-		const id = `v-${now()}`
-
-		addToIndex(transactors, { indexAtom: viewIndexState, id })
-		set(
-			findViewState(id),
-			(current): View => ({
-				...current,
-				location: {
-					...current.location,
-					pathname: path ?? `/`,
-				},
-			}),
-		)
-		const spaceId =
-			maybeSpaceId ??
-			lastOf([...get(spaceIndexState)]) ??
-			writeOperationAddSpace(transactors)
-		set(findViewFocusedState(id), Date.now())
-
-		set(viewsPerSpaceState, (current) => current.set({ spaceId, viewId: id }))
-		set(findViewFocusedState(id), Date.now())
-	}
-
-	const writeOperationRemoveView: Write<(viewId: string) => void> = (
-		transactors,
-		viewId,
-	) => {
-		const { set } = transactors
-		removeFromIndex(transactors, { indexAtom: viewIndexState, id: viewId })
-		set(viewsPerSpaceState, (current) => current.remove({ viewId }))
-		set(findViewState(viewId), null)
-	}
-
-	const addView = transaction<(options?: AddViewOptions) => void>({
-		key: `${key}:add_view`,
-		do: writeOperationAddView,
-	})
-
-	const removeView = transaction({
-		key: `${key}:remove_view`,
-		do: writeOperationRemoveView,
-	})
-
-	const addSpace = transaction({
-		key: `${key}:add_space`,
-		do: writeOperationAddSpace,
-	})
-
-	const removeSpace = transaction({
-		key: `${key}:remove_space`,
-		do: writeOperationRemoveSpace,
-	})
-
-	return {
-		addSpace,
-		addView,
-		allViewsState,
-		findSpaceLayoutNode,
-		findSpaceFocusedViewState,
-		findSpaceState,
-		findSpaceViewsState,
-		findViewState,
-		findViewFocusedState,
-		removeSpace,
-		removeView,
-		spaceIndexState,
-		spaceLayoutState,
-		viewIndexState,
-		viewsPerSpaceState,
-		writeOperationAddSpace,
-		writeOperationAddView,
-		writeOperationRemoveSpace,
-		writeOperationRemoveView,
-	}
-}

package/src/react-explorer/index.ts

@@ -1,23 +0,0 @@
-import type { AtomToken, Write } from "atom.io"
-
-export * from "./AtomIOExplorer"
-
-export type AtomicIndexOptions = {
-	indexAtom: AtomToken<Set<string>>
-	id: string
-}
-
-export const addToIndex: Write<(options: AtomicIndexOptions) => void> = (
-	{ set },
-	{ indexAtom, id },
-): void => set(indexAtom, (currentSet) => new Set(currentSet).add(id))
-
-export const removeFromIndex: Write<(options: AtomicIndexOptions) => void> = (
-	{ set },
-	{ indexAtom, id },
-): void =>
-	set(indexAtom, (currentSet) => {
-		const newSet = new Set(currentSet)
-		newSet.delete(id)
-		return newSet
-	})

package/src/react-explorer/space-states.ts

@@ -1,72 +0,0 @@
-import { Join } from "~/packages/anvl/src/join"
-import { parseJson, stringifyJson } from "~/packages/anvl/src/json"
-import { hasExactProperties } from "~/packages/anvl/src/object"
-
-import { persistStringSetAtom } from "./explorer-effects"
-import type { AtomToken, ReadonlySelectorFamily } from ".."
-import { SelectorFamily, selectorFamily } from ".."
-import type { AtomFamily } from "../atom"
-import { atom, atomFamily } from "../atom"
-import { lazyLocalStorageEffect, persistAtom } from "../web-effects"
-
-export const makeSpaceIndex = (key: string): AtomToken<Set<string>> =>
-	atom<Set<string>>({
-		key: `${key}:space_index`,
-		default: new Set([`root`]),
-		effects: [persistStringSetAtom(`${key}:space_index`)],
-	})
-
-export const makeSpaceLayoutState = (
-	key: string,
-): AtomToken<Join<{ size: number }, `parent`, `child`>> =>
-	atom({
-		key: `${key}:space_layout`,
-		default: new Join<{ size: number }>({ relationType: `1:n` })
-			.from(`parent`)
-			.to(`child`),
-		effects: [
-			persistAtom<Join<{ size: number }, `parent`, `child`>>(localStorage)({
-				stringify: (join) => stringifyJson(join.toJSON()),
-				parse: (string) => {
-					try {
-						const json = parseJson(string)
-						const join = Join.fromJSON(json, {
-							isContent: hasExactProperties({
-								size: (v): v is number => typeof v === `number`,
-							}),
-							from: `parent`,
-							to: `child`,
-						})
-						return join
-					} catch (thrown) {
-						console.error(`Error parsing spaceLayoutState from localStorage`)
-						return new Join({ relationType: `1:n` })
-					}
-				},
-			})(`${key}:space_layout`),
-		],
-	})
-
-export const makeSpaceLayoutNodeFamily = (
-	key: string,
-	spaceLayoutState: AtomToken<Join<{ size: number }, `parent`, `child`>>,
-): ReadonlySelectorFamily<{ childSpaceIds: string[]; size: number }, string> =>
-	selectorFamily<{ childSpaceIds: string[]; size: number }, string>({
-		key: `${key}:explorer_space`,
-		get: (me) => ({ get }) => {
-			const join = get(spaceLayoutState)
-			const myFollowers = join.getRelatedIds(`parent:${me}`)
-			const myLeader = join.getRelatedId(me)
-			const { size } = myLeader
-				? join.getContent(myLeader, me) ?? { size: NaN }
-				: { size: NaN }
-			return { childSpaceIds: myFollowers, size }
-		},
-	})
-
-export const makeSpaceFamily = (key: string): AtomFamily<number, string> =>
-	atomFamily<number, string>({
-		key: `${key}:space`,
-		default: 1,
-		effects: (subKey) => [lazyLocalStorageEffect(`${key}:${subKey}`)],
-	})

package/src/react-explorer/view-states.ts

@@ -1,41 +0,0 @@
-import type { Location } from "react-router-dom"
-
-import { persistStringSetAtom } from "./explorer-effects"
-import type { AtomToken } from ".."
-import type { AtomFamily } from "../atom"
-import { atom, atomFamily } from "../atom"
-import { lazyLocalStorageEffect } from "../web-effects"
-
-export type View = {
-	title: string
-	location: Omit<Location, `state`>
-}
-
-export const makeViewFamily = (key: string): AtomFamily<View, string> =>
-	atomFamily<View, string>({
-		key: `${key}:view`,
-		default: {
-			title: ``,
-			location: {
-				pathname: ``,
-				search: ``,
-				hash: ``,
-				key: ``,
-			},
-		},
-		effects: (subKey) => [lazyLocalStorageEffect(`${key}:${subKey}`)],
-	})
-
-export const makeViewIndex = (key: string): AtomToken<Set<string>> =>
-	atom<Set<string>>({
-		key: `${key}:view_index`,
-		default: new Set(),
-		effects: [persistStringSetAtom(`${key}:view_index`)],
-	})
-
-export const makeViewFocusedFamily = (key: string): AtomFamily<number, string> =>
-	atomFamily<number, string>({
-		key: `${key}:view_focused`,
-		default: 0,
-		effects: (subKey) => [lazyLocalStorageEffect(`${key}:${subKey}`)],
-	})

package/src/realtime/README.md

@@ -1,33 +0,0 @@
-# CLIENT ACTS AND REPORTS
-- [x] input event fires
-- [x] event handler runs transaction
-  - [x] client store updates optimistically
-- [ ] on success
-  - [ ] client generates transactionId and optimistic TransactionUpdate
-  - [ ] client pushes TransactionUpdate to TimelineData.history
-  - [ ] client sets TransactionUpdate in optimisticTransactions map by transactionId
-  - [ ] client emits TransactionRequest { key, params, transactionId }
-
-# SERVER VALIDATES, INTEGRATES, AND BROADCASTS
-## use
-- [x] server receives TransactionRequest
-  - `{ key, params, transactionId }`
-- [ ] verify `transactionId` is unique
-- [ ] server adds timestamp to `TransactionRequest`
-  - `{ key, params, transactionId, timestamp }`
-- [ ] server runs transaction, computing `TransactionUpdate` in the process
-  - [ ] emit `TransactionUpdate` 
-    - `{ key, params, transactionId, timestamp, atomUpdates, output }`
-- [ ] server adds `TransactionUpdate` to TimelineData.history
-
-# CLIENT BEHOLDS AND REACTS
-- [ ] client receives official TransactionUpdate
-  - [ ] client retrieves its own TransactionUpdate from optimisticTransactions map
-  - [ ] client compares official and optimistic TransactionUpdates
-    - [ ] (stringify atomUpdates and compare strict)
-  - [ ] if match, client removes TransactionUpdate from optimisticTransactions map
-  - [ ] if mismatch
-    - [ ] client undoes timeline until it finds its own TransactionUpdate
-    - [ ] client replaces its own TransactionUpdate with official TransactionUpdate
-    - [ ] client removes its own TransactionUpdate from optimisticTransactions map
-    - [ ] client redoes timeline until it reaches the "HEAD"

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