atom.io 0.6.1 → 0.6.3

package/src/transaction.ts

@@ -5,56 +5,56 @@ import type { Store } from "./internal"
 import { IMPLICIT, transaction__INTERNAL, withdraw } from "./internal"
 
 export type TransactionToken<_> = {
-  key: string
-  type: `transaction`
-  __brand?: _
+	key: string
+	type: `transaction`
+	__brand?: _
 }
 
 export type TransactionUpdate<ƒ extends ƒn> = {
-  key: string
-  atomUpdates: KeyedStateUpdate<unknown>[]
-  params: Parameters<ƒ>
-  output: ReturnType<ƒ>
+	key: string
+	atomUpdates: KeyedStateUpdate<unknown>[]
+	params: Parameters<ƒ>
+	output: ReturnType<ƒ>
 }
 
 export type Transactors = {
-  get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S
-  set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void
+	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 Read<ƒ extends ƒn> = (
-  transactors: ReadonlyTransactors,
-  ...parameters: Parameters<ƒ>
+	transactors: ReadonlyTransactors,
+	...parameters: Parameters<ƒ>
 ) => ReturnType<ƒ>
 
 export type Write<ƒ extends ƒn> = (
-  transactors: Transactors,
-  ...parameters: Parameters<ƒ>
+	transactors: Transactors,
+	...parameters: Parameters<ƒ>
 ) => ReturnType<ƒ>
 
 export type TransactionOptions<ƒ extends ƒn> = {
-  key: string
-  do: Write<ƒ>
+	key: string
+	do: Write<ƒ>
 }
 
 export type TransactionIO<Token extends TransactionToken<any>> =
-  Token extends TransactionToken<infer ƒ> ? ƒ : never
+	Token extends TransactionToken<infer ƒ> ? ƒ : never
 
 export function transaction<ƒ extends ƒn>(
-  options: TransactionOptions<ƒ>
+	options: TransactionOptions<ƒ>,
 ): TransactionToken<ƒ> {
-  return transaction__INTERNAL(options)
+	return transaction__INTERNAL(options)
 }
 
 export const runTransaction =
-  <ƒ extends ƒn>(token: TransactionToken<ƒ>, store: Store = IMPLICIT.STORE) =>
-  (...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
-    const tx = withdraw(token, store)
-    if (tx) {
-      return tx.run(...parameters)
-    }
-    throw new Error(
-      `Cannot run transaction "${token.key}": transaction not found in store "${store.config.name}".`
-    )
-  }
+	<ƒ extends ƒn>(token: TransactionToken<ƒ>, store: Store = IMPLICIT.STORE) =>
+	(...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
+		const tx = withdraw(token, store)
+		if (tx) {
+			return tx.run(...parameters)
+		}
+		throw new Error(
+			`Cannot run transaction "${token.key}": transaction not found in store "${store.config.name}".`,
+		)
+	}

package/src/web-effects/storage.ts

@@ -3,28 +3,28 @@ 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
+	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)
+	<T>(storage: Storage) =>
+	({ stringify, parse }: StringInterface<T>) =>
+	(key: string): AtomEffect<T> =>
+	({ setSelf, onSet }) => {
+		const savedValue = storage.getItem(key)
 
-    if (savedValue != null) setSelf(parse(savedValue))
+		if (savedValue != null) setSelf(parse(savedValue))
 
-    onSet(({ newValue }) => {
-      if (newValue == null) {
-        storage.removeItem(key)
-        return
-      }
-      storage.setItem(key, stringify(newValue))
-    })
-  }
+		onSet(({ newValue }) => {
+			if (newValue == null) {
+				storage.removeItem(key)
+				return
+			}
+			storage.setItem(key, stringify(newValue))
+		})
+	}
 
 export const lazyLocalStorageEffect: <J extends Json>(
-  key: string
+	key: string,
 ) => AtomEffect<J> = persistAtom(localStorage)(JSON)