atom.io 0.3.0 → 0.4.0

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

@@ -0,0 +1,43 @@
+import type { Location } from "react-router-dom"
+
+import { key } from "~/packages/anvl/src/object"
+
+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/selector.ts

@@ -2,31 +2,31 @@ import type * as Rx from "rxjs"
 
 import type { Serializable } from "~/packages/anvl/src/json"
 
-import type { ReadonlyValueToken, SelectorToken } from "."
+import type { ReadonlySelectorToken, SelectorToken } from "."
 import { selectorFamily__INTERNAL, selector__INTERNAL } from "./internal"
-import type { ReadonlyTransactors, Transactors } from "./transaction"
+import type { Read, Write } from "./transaction"
 
 export type SelectorOptions<T> = {
   key: string
-  get: (readonlyTransactors: ReadonlyTransactors) => T
-  set: (transactors: Transactors, newValue: T) => void
+  get: Read<() => T>
+  set: Write<(newValue: T) => void>
 }
 export type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>
 
-export function selector<T>(options: SelectorOptions<T>): SelectorToken<T>
 export function selector<T>(
   options: ReadonlySelectorOptions<T>
-): ReadonlyValueToken<T>
+): ReadonlySelectorToken<T>
+export function selector<T>(options: SelectorOptions<T>): SelectorToken<T>
 export function selector<T>(
   options: ReadonlySelectorOptions<T> | SelectorOptions<T>
-): ReadonlyValueToken<T> | SelectorToken<T> {
+): ReadonlySelectorToken<T> | SelectorToken<T> {
   return selector__INTERNAL(options)
 }
 
 export type SelectorFamilyOptions<T, K extends Serializable> = {
   key: string
-  get: (key: K) => (readonlyTransactors: ReadonlyTransactors) => T
-  set: (key: K) => (transactors: Transactors, newValue: T) => void
+  get: (key: K) => Read<() => T>
+  set: (key: K) => Write<(newValue: T) => void>
 }
 export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<
   SelectorFamilyOptions<T, K>,
@@ -43,10 +43,10 @@ export type SelectorFamily<T, K extends Serializable = Serializable> = ((
 
 export type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((
   key: K
-) => ReadonlyValueToken<T>) & {
+) => ReadonlySelectorToken<T>) & {
   key: string
   type: `readonly_selector_family`
-  subject: Rx.Subject<ReadonlyValueToken<T>>
+  subject: Rx.Subject<ReadonlySelectorToken<T>>
 }
 
 export function selectorFamily<T, K extends Serializable>(

package/src/subscribe.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyValueToken, StateToken, TransactionToken, ƒn } from "."
+import type { ReadonlySelectorToken, StateToken, TransactionToken, ƒn } from "."
 import type { Store, TransactionUpdate } from "./internal"
 import { IMPLICIT, subscribeToRootAtoms, withdraw } from "./internal"
 
@@ -6,7 +6,7 @@ export type StateUpdate<T> = { newValue: T; oldValue: T }
 export type UpdateHandler<T> = (update: StateUpdate<T>) => void
 
 export const subscribe = <T>(
-  token: ReadonlyValueToken<T> | StateToken<T>,
+  token: ReadonlySelectorToken<T> | StateToken<T>,
   handleUpdate: UpdateHandler<T>,
   store: Store = IMPLICIT.STORE
 ): (() => void) => {
@@ -14,7 +14,7 @@ export const subscribe = <T>(
   const subscription = state.subject.subscribe(handleUpdate)
   store.config.logger?.info(`👀 subscribe to "${state.key}"`)
   const dependencySubscriptions =
-    `get` in state ? subscribeToRootAtoms(state, store) : null
+    state.type !== `atom` ? subscribeToRootAtoms(state, store) : null
 
   const unsubscribe =
     dependencySubscriptions === null

package/src/timeline.ts

@@ -1,15 +1,6 @@
-import HAMT from "hamt_plus"
-import type * as Rx from "rxjs"
-
-import type { AtomFamily, AtomToken, ƒn } from "."
-import { setState } from "."
-import type { Store, KeyedStateUpdate, TransactionUpdate } from "./internal"
-import { target, IMPLICIT, withdraw } from "./internal"
-import {
-  redo__INTERNAL,
-  timeline__INTERNAL,
-  undo__INTERNAL,
-} from "./internal/timeline-internal"
+import type { AtomFamily, AtomToken } from "."
+import { IMPLICIT } from "./internal"
+import { redo__INTERNAL, timeline__INTERNAL, undo__INTERNAL } from "./internal/"
 
 export type TimelineToken = {
   key: string

package/src/transaction.ts

@@ -1,25 +1,30 @@
 import type * as Rx from "rxjs"
 
-import type { ReadonlyValueToken, StateToken, TransactionToken } from "."
+import type { ReadonlySelectorToken, StateToken, TransactionToken } from "."
 import type { Store, TransactionUpdate } from "./internal"
 import { IMPLICIT, transaction__INTERNAL, withdraw } from "./internal"
 
 export type ƒn = (...parameters: any[]) => any
 
 export type Transactors = {
-  get: <S>(state: ReadonlyValueToken<S> | StateToken<S>) => S
+  get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S
   set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void
 }
 export type ReadonlyTransactors = Pick<Transactors, `get`>
 
-export type Action<ƒ extends ƒn> = (
+export type Read<ƒ extends ƒn> = (
+  transactors: ReadonlyTransactors,
+  ...parameters: Parameters<ƒ>
+) => ReturnType<ƒ>
+
+export type Write<ƒ extends ƒn> = (
   transactors: Transactors,
   ...parameters: Parameters<ƒ>
 ) => ReturnType<ƒ>
 
 export type TransactionOptions<ƒ extends ƒn> = {
   key: string
-  do: Action<ƒ>
+  do: Write<ƒ>
 }
 
 export type Transaction<ƒ extends ƒn> = {

package/src/web-effects/index.ts

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

package/src/web-effects/storage.ts

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