atom.io 0.7.0 → 0.8.0

package/internal/src/atom/create-atom.ts

@@ -61,7 +61,7 @@ export function createAtom<T>(
 		options.default instanceof Function ? options.default() : options.default
 	core.atoms.set(newAtom.key, newAtom)
 	markAtomAsDefault(options.key, store)
-	cacheValue(options.key, initialValue, store)
+	cacheValue(options.key, initialValue, subject, store)
 	const token = deposit(newAtom)
 	for (const effect of options.effects ?? []) {
 		effect({

package/internal/src/caching.ts

@@ -1,13 +1,30 @@
+import type { StateUpdate } from "../../src"
+import { Future } from "./future"
 import type { Store } from "./store"
 import { IMPLICIT } from "./store"
+import type { Subject } from "./subject"
 import { target } from "./transaction"
 
 export const cacheValue = (
 	key: string,
 	value: unknown,
+	subject: Subject<StateUpdate<unknown>>,
 	store: Store = IMPLICIT.STORE,
 ): void => {
-	target(store).valueMap.set(key, value)
+	const currentValue = target(store).valueMap.get(key)
+	if (currentValue instanceof Future) {
+		currentValue.cancel()
+	}
+	if (value instanceof Promise) {
+		const future = new Future(value)
+		target(store).valueMap.set(key, future)
+		future.then((value) => {
+			cacheValue(key, value, subject, store)
+			subject.next({ newValue: value, oldValue: value })
+		})
+	} else {
+		target(store).valueMap.set(key, value)
+	}
 }
 
 export const readCachedValue = <T>(

package/internal/src/future.ts

@@ -0,0 +1,39 @@
+import { E } from "vitest/dist/reporters-5f784f42"
+
+export type Eventual<T> = Promise<T> | T
+export type Fated<T, E extends Error = Error> = Eventual<E | T>
+
+/**
+ * A Promise that can be canceled.
+ * @internal
+ * @private
+ * @typeParam T The type of the value that the promise will resolve to.
+ *
+ * @remarks
+ * Can be constructed like a Promise, or from an existing Promise.
+ */
+export class Future<T> extends Promise<T> {
+	private isCanceled = false
+
+	public constructor(
+		executor:
+			| Promise<T>
+			| ((resolve: (value: T) => void, reject: (reason?: any) => void) => void),
+	) {
+		super((resolve, reject) => {
+			const pass = (value: T) =>
+				this.isCanceled ? reject(`canceled`) : resolve(value)
+			const fail = (reason: any) =>
+				this.isCanceled ? reject(`canceled`) : reject(reason)
+			if (typeof executor === `function`) {
+				executor(pass, fail)
+			} else {
+				executor.then(pass, fail)
+			}
+		})
+	}
+
+	public cancel(): void {
+		this.isCanceled = true
+	}
+}

package/internal/src/index.ts

@@ -1,6 +1,7 @@
 export * from "./atom"
 export * from "./caching"
 export * from "./families"
+export * from "./future"
 export * from "./get-state-internal"
 export * from "./operation"
 export * from "./mutable"

package/internal/src/selector/create-read-write-selector.ts

@@ -20,7 +20,7 @@ export const createReadWriteSelector = <T>(
 	const { get, set } = registerSelector(options.key, store)
 	const getSelf = () => {
 		const value = options.get({ get })
-		cacheValue(options.key, value, store)
+		cacheValue(options.key, value, subject, store)
 		return value
 	}
 
@@ -34,7 +34,7 @@ export const createReadWriteSelector = <T>(
 			`)`,
 		)
 		const newValue = become(next)(oldValue)
-		cacheValue(options.key, newValue, store)
+		cacheValue(options.key, newValue, subject, store)
 		markDone(options.key, store)
 		if (store.transactionStatus.phase === `idle`) {
 			subject.next({ newValue, oldValue })

package/internal/src/selector/create-readonly-selector.ts

@@ -22,7 +22,7 @@ export const createReadonlySelector = <T>(
 	const { get } = registerSelector(options.key, store)
 	const getSelf = () => {
 		const value = options.get({ get })
-		cacheValue(options.key, value, store)
+		cacheValue(options.key, value, subject, store)
 		return value
 	}
 

package/internal/src/set-state/set-atom-state.ts

@@ -20,7 +20,7 @@ export const setAtomState = <T>(
 	let newValue = copyMutableIfWithinTransaction(atom, store)
 	newValue = become(next)(newValue)
 	store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
-	cacheValue(atom.key, newValue, store)
+	cacheValue(atom.key, newValue, atom.subject, store)
 	if (isAtomDefault(atom.key, store)) {
 		markAtomAsNotDefault(atom.key, store)
 	}

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "atom.io",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Reactive state graph for React, Preact, and vanilla",
-  "dependencies": {},
   "peerDependencies": {
-    "@testing-library/react": ">=14.0.0",
     "@floating-ui/react": ">=0.25.0",
     "@floating-ui/react-dom": ">=2.0.0",
+    "@testing-library/react": ">=14.0.0",
     "framer-motion": ">=10.0.0",
     "react": ">=18.0.0",
     "socket.io": ">=4.0.0",
@@ -38,14 +37,15 @@
   "devDependencies": {
     "@emotion/react": "11.11.1",
     "@testing-library/react": "14.0.0",
-    "@types/mock-fs": "4.13.1",
-    "@types/react": "18.2.21",
+    "@types/mock-fs": "4.13.2",
+    "@types/react": "18.2.25",
     "@types/tmp": "0.2.4",
+    "@vitest/coverage-v8": "0.34.6",
     "concurrently": "8.2.1",
     "eslint": "8.50.0",
     "framer-motion": "10.16.4",
-    "happy-dom": "12.1.6",
-    "preact": "10.17.1",
+    "happy-dom": "12.8.0",
+    "preact": "10.18.1",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "react-router-dom": "6.16.0",
@@ -54,9 +54,9 @@
     "tmp": "0.2.1",
     "tsup": "7.2.0",
     "typescript": "5.2.2",
-    "vite": "4.4.9",
+    "vite": "4.4.11",
     "vite-tsconfig-paths": "4.2.1",
-    "vitest": "0.34.5"
+    "vitest": "0.34.6"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/react-devtools/dist/index.js

@@ -2,7 +2,6 @@
 
 var atom_io = require('atom.io');
 var introspection = require('atom.io/introspection');
-var webEffects = require('atom.io/web-effects');
 var react = require('atom.io/react');
 var framerMotion = require('framer-motion');
 var React = require('react');
@@ -62,6 +61,21 @@ var __objRest = (source, exclude) => {
   return target;
 };
 
+// ../__unstable__/web-effects/src/storage.ts
+var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ 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));
+  });
+};
+var lazyLocalStorageEffect = persistAtom(localStorage)(JSON);
+
 // ../../anvl/src/function/pipe.ts
 function pipe(a2, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
@@ -2765,22 +2779,22 @@ var {
 var devtoolsAreOpenState = atom_io.atom({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools Are Open`,
   default: true,
-  effects: [webEffects.lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools Are Open`)]
+  effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools Are Open`)]
 });
 var devtoolsViewSelectionState = atom_io.atom({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools View Selection`,
   default: `atoms`,
-  effects: [webEffects.lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View`)]
+  effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View`)]
 });
 var devtoolsViewOptionsState = atom_io.atom({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools View Options`,
   default: [`atoms`, `selectors`, `transactions`, `timelines`],
-  effects: [webEffects.lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View Options`)]
+  effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View Options`)]
 });
 var findViewIsOpenState = atom_io.atomFamily({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools View Is Open`,
   default: false,
-  effects: (key) => [webEffects.lazyLocalStorageEffect(key + `:view-is-open`)]
+  effects: (key) => [lazyLocalStorageEffect(key + `:view-is-open`)]
 });
 var primitiveRefinery = new Refinery({
   number: (input) => typeof input === `number`,