atom.io 0.6.2 → 0.6.3

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

@@ -5,220 +5,213 @@ import type { Entries } from "~/packages/anvl/src/object"
 
 import { addToIndex, removeFromIndex } from "."
 import {
-  makeSpaceLayoutNodeFamily,
-  makeSpaceFamily,
-  makeSpaceIndex,
-  makeSpaceLayoutState,
+	makeSpaceLayoutNodeFamily,
+	makeSpaceFamily,
+	makeSpaceIndex,
+	makeSpaceLayoutState,
 } from "./space-states"
 import type { View } from "./view-states"
 import {
-  makeViewFocusedFamily,
-  makeViewFamily,
-  makeViewIndex,
+	makeViewFocusedFamily,
+	makeViewFamily,
+	makeViewIndex,
 } from "./view-states"
 import type {
-  AtomFamily,
-  AtomToken,
-  ReadonlySelectorFamily,
-  SelectorFamily,
-  Write,
+	AtomFamily,
+	AtomToken,
+	ReadonlySelectorFamily,
+	SelectorFamily,
+	Write,
 } from ".."
 import { selectorFamily, selector, transaction, atom } from ".."
 import { persistAtom } from "../web-effects"
 
 export const makeViewsPerSpaceState = (
-  key: string
+	key: string,
 ): AtomToken<Join<null, `viewId`, `spaceId`>> =>
-  atom<Join<null, `viewId`, `spaceId`>>({
-    key: `${key}:views_per_space`,
-    default: new Join({ relationType: `1:n` }),
-    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`),
-    ],
-  })
+	atom<Join<null, `viewId`, `spaceId`>>({
+		key: `${key}:views_per_space`,
+		default: new Join({ relationType: `1:n` }),
+		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`>>
+	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
-      },
-  })
+	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>
+	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}`)
-        }
-      },
-  })
+	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,
-  }
+	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

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

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

@@ -12,61 +12,59 @@ 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`)],
-  })
+	atom<Set<string>>({
+		key: `${key}:space_index`,
+		default: new Set([`root`]),
+		effects: [persistStringSetAtom(`${key}:space_index`)],
+	})
 
 export const makeSpaceLayoutState = (
-  key: string
+	key: string,
 ): AtomToken<Join<{ size: number }, `parent`, `child`>> =>
-  atom({
-    key: `${key}:space_layout`,
-    default: new Join({ relationType: `1:n` }),
-    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: isNumber }),
-              from: `parent`,
-              to: `child`,
-            })
-            return join
-          } catch (thrown) {
-            console.error(`Error parsing spaceLayoutState from localStorage`)
-            return new Join({ relationType: `1:n` })
-          }
-        },
-      })(`${key}:space_layout`),
-    ],
-  })
+	atom({
+		key: `${key}:space_layout`,
+		default: new Join({ relationType: `1:n` }),
+		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: isNumber }),
+							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`>>
+	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 }
-      },
-  })
+	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}`)],
-  })
+	atomFamily<number, string>({
+		key: `${key}:space`,
+		default: 1,
+		effects: (subKey) => [lazyLocalStorageEffect(`${key}:${subKey}`)],
+	})

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

@@ -9,35 +9,35 @@ import { atom, atomFamily } from "../atom"
 import { lazyLocalStorageEffect } from "../web-effects"
 
 export type View = {
-  title: string
-  location: Omit<Location, `state`>
+	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}`)],
-  })
+	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`)],
-  })
+	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}`)],
-  })
+	atomFamily<number, string>({
+		key: `${key}:view_focused`,
+		default: 0,
+		effects: (subKey) => [lazyLocalStorageEffect(`${key}:${subKey}`)],
+	})