atom.io 0.19.3 → 0.20.0

package/internal/dist/index.js

@@ -3,6 +3,67 @@ import { __spreadValues, __spreadProps } from '../../dist/chunk-F2X4B4VY.js';
 import { stringifyJson, selectJson, parseJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 
+// internal/src/arbitrary.ts
+function arbitrary(random = Math.random) {
+  return random().toString(36).slice(2);
+}
+
+// internal/src/future.ts
+var Future = class extends Promise {
+  constructor(executor) {
+    let promise;
+    let superResolve;
+    let superReject;
+    super((resolve, reject) => {
+      superResolve = resolve;
+      superReject = reject;
+      promise = executor instanceof Promise ? executor : new Promise(executor);
+      promise.then(
+        (value) => {
+          if (promise) {
+            this.pass(promise, value);
+          }
+        },
+        (reason) => {
+          if (promise) {
+            this.fail(promise, reason);
+          }
+        }
+      );
+    });
+    this.destiny = promise;
+    this.resolve = superResolve;
+    this.reject = superReject;
+  }
+  pass(promise, value) {
+    if (promise === this.destiny) {
+      this.resolve(value);
+    }
+  }
+  fail(promise, reason) {
+    if (promise === this.destiny) {
+      this.reject(reason);
+    }
+  }
+  use(value) {
+    if (value instanceof Promise) {
+      const promise = value;
+      this.destiny = promise;
+      promise.then(
+        (resolved) => {
+          this.pass(promise, resolved);
+        },
+        (reason) => {
+          this.fail(promise, reason);
+        }
+      );
+    } else {
+      this.resolve(value);
+      this.destiny = void 0;
+    }
+  }
+};
+
 // internal/src/lineage.ts
 function newest(scion) {
   while (scion.child !== null) {
@@ -261,93 +322,6 @@ function withdrawOrCreate(token, store) {
   }
 }
 
-// internal/src/future.ts
-var Future = class extends Promise {
-  constructor(executor) {
-    super((resolve, reject) => {
-      const pass = (value) => {
-        this.isCanceled ? reject(`canceled`) : resolve(value);
-      };
-      const fail = (reason) => {
-        this.isCanceled ? reject(`canceled`) : reject(reason);
-      };
-      if (typeof executor === `function`) {
-        executor(pass, fail);
-      } else {
-        executor.then(pass, fail);
-      }
-    });
-    this.isCanceled = false;
-  }
-  cancel() {
-    this.isCanceled = true;
-  }
-};
-
-// internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, origin, target) {
-  const originValue = origin.valueMap.get(atom.key);
-  const targetValue = target.valueMap.get(atom.key);
-  if (originValue === targetValue) {
-    if (originValue === void 0) {
-      return typeof atom.default === `function` ? atom.default() : atom.default;
-    }
-    origin.logger.info(`\u{1F4C3}`, `atom`, atom.key, `copying`);
-    const jsonValue = atom.toJson(originValue);
-    const copiedValue = atom.fromJson(jsonValue);
-    target.valueMap.set(atom.key, copiedValue);
-    new Tracker(atom, origin);
-    return copiedValue;
-  }
-  return targetValue;
-}
-
-// internal/src/caching.ts
-function cacheValue(key, value, subject, target) {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    currentValue.cancel();
-  }
-  if (value instanceof Promise) {
-    const future = new Future(value);
-    target.valueMap.set(key, future);
-    future.then((resolved) => {
-      if (future.isCanceled) {
-        return;
-      }
-      cacheValue(key, resolved, subject, target);
-      subject.next({ newValue: resolved, oldValue: future });
-    }).catch((thrown) => {
-      if (thrown !== `canceled`) {
-        target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
-      }
-    });
-    return future;
-  }
-  target.valueMap.set(key, value);
-  return value;
-}
-var readCachedValue = (token, target) => {
-  let value = target.valueMap.get(token.key);
-  if (token.type === `mutable_atom` && isChildStore(target)) {
-    const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(token, parent, target);
-    value = copiedValue;
-  }
-  return value;
-};
-var evictCachedValue = (key, target) => {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    currentValue.cancel();
-  }
-  if (target.operation.open) {
-    target.operation.prev.set(key, currentValue);
-  }
-  target.valueMap.delete(key);
-  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
-};
-
 // internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
   if (target.valueMap.has(state.key)) {
@@ -1449,6 +1423,72 @@ function isTransceiver(value) {
   return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
 }
 
+// internal/src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, origin, target) {
+  const originValue = origin.valueMap.get(atom.key);
+  const targetValue = target.valueMap.get(atom.key);
+  if (originValue === targetValue) {
+    if (originValue === void 0) {
+      return typeof atom.default === `function` ? atom.default() : atom.default;
+    }
+    origin.logger.info(`\u{1F4C3}`, `atom`, atom.key, `copying`);
+    const jsonValue = atom.toJson(originValue);
+    const copiedValue = atom.fromJson(jsonValue);
+    target.valueMap.set(atom.key, copiedValue);
+    new Tracker(atom, origin);
+    return copiedValue;
+  }
+  return targetValue;
+}
+
+// internal/src/caching.ts
+function cacheValue(key, value, subject, target) {
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    const future = currentValue;
+    future.use(value);
+  }
+  if (value instanceof Promise) {
+    const future = new Future(value);
+    target.valueMap.set(key, future);
+    future.then((resolved) => {
+      cacheValue(key, resolved, subject, target);
+      subject.next({ newValue: resolved, oldValue: future });
+    }).catch((thrown) => {
+      target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
+    });
+    return future;
+  }
+  target.valueMap.set(key, value);
+  return value;
+}
+var readCachedValue = (token, target) => {
+  let value = target.valueMap.get(token.key);
+  if (token.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(token, parent, target);
+    value = copiedValue;
+  }
+  return value;
+};
+var evictCachedValue = (key, target) => {
+  var _a;
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    const future = currentValue;
+    const selector = (_a = target.selectors.get(key)) != null ? _a : target.readonlySelectors.get(key);
+    if (selector) {
+      future.use(selector.get());
+    }
+    return;
+  }
+  if (target.operation.open) {
+    target.operation.prev.set(key, currentValue);
+  }
+  target.valueMap.delete(key);
+  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
+};
+
 // internal/src/atom/is-default.ts
 var isAtomDefault = (key, store) => {
   const core = newest(store);
@@ -1578,11 +1618,6 @@ function deleteAtom(atomToken, store) {
   store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
 }
 
-// internal/src/arbitrary.ts
-function arbitrary(random = Math.random) {
-  return random().toString(36).slice(2);
-}
-
 // internal/src/get-environment-data.ts
 function getEnvironmentData(store) {
   return {

package/internal/src/atom/index.ts

@@ -1,4 +1,4 @@
-export * from "./create-standalone-atom"
 export * from "./create-regular-atom"
+export * from "./create-standalone-atom"
 export * from "./delete-atom"
 export * from "./is-default"

package/internal/src/caching.ts

@@ -1,5 +1,7 @@
 import type { StateUpdate } from "atom.io"
-import { type ReadableState, isChildStore } from "."
+
+import type { ReadableState } from "."
+import { isChildStore } from "."
 import { Future } from "./future"
 import { copyMutableIfNeeded } from "./set-state/copy-mutable-if-needed"
 import type { Store } from "./store"
@@ -25,23 +27,19 @@ export function cacheValue<T>(
 ): Future<T> | T {
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future) {
-		currentValue.cancel()
+		const future = currentValue
+		future.use(value)
 	}
 	if (value instanceof Promise) {
 		const future = new Future<T>(value)
 		target.valueMap.set(key, future)
 		future
 			.then((resolved) => {
-				if (future.isCanceled) {
-					return
-				}
 				cacheValue(key, resolved, subject, target)
 				subject.next({ newValue: resolved, oldValue: future })
 			})
 			.catch((thrown) => {
-				if (thrown !== `canceled`) {
-					target.logger.error(`💥`, `state`, key, `rejected:`, thrown)
-				}
+				target.logger.error(`💥`, `state`, key, `rejected:`, thrown)
 			})
 		return future
 	}
@@ -65,7 +63,13 @@ export const readCachedValue = <T>(
 export const evictCachedValue = (key: string, target: Store): void => {
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future) {
-		currentValue.cancel()
+		const future = currentValue
+		const selector =
+			target.selectors.get(key) ?? target.readonlySelectors.get(key)
+		if (selector) {
+			future.use(selector.get())
+		}
+		return
 	}
 	if (target.operation.open) {
 		target.operation.prev.set(key, currentValue)

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

@@ -6,7 +6,7 @@ import type {
 } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import { type Transceiver, createMutableAtomFamily } from "../mutable"
+import { createMutableAtomFamily, type Transceiver } from "../mutable"
 import type { Store } from "../store"
 import { createRegularAtomFamily } from "./create-regular-atom-family"
 

package/internal/src/families/find-in-store.ts

@@ -1,5 +1,3 @@
-import type { Json } from "atom.io/json"
-
 import type {
 	AtomFamilyToken,
 	AtomToken,
@@ -18,6 +16,8 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
+import type { Json } from "atom.io/json"
+
 import type { Transceiver } from "../mutable"
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"

package/internal/src/families/index.ts

@@ -1,5 +1,5 @@
 export * from "./create-atom-family"
-export * from "./create-regular-atom-family"
 export * from "./create-readonly-selector-family"
+export * from "./create-regular-atom-family"
 export * from "./create-selector-family"
 export * from "./find-in-store"

package/internal/src/future.ts

@@ -1,5 +1,5 @@
 /**
- * A Promise that can be canceled.
+ * A Promise whose incoming value can be hot swapped.
  * @internal
  * @private
  * @typeParam T The type of the value that the promise will resolve to.
@@ -8,29 +8,66 @@
  * Can be constructed like a Promise, or from an existing Promise.
  */
 export class Future<T> extends Promise<T> {
-	public isCanceled = false
+	private destiny: Promise<T> | undefined
+	private resolve: (value: T) => void
+	private reject: (reason?: any) => void
 
 	public constructor(
 		executor:
 			| Promise<T>
 			| ((resolve: (value: T) => void, reject: (reason?: any) => void) => void),
 	) {
+		let promise: Promise<T> | undefined
+		let superResolve: ((value: T) => void) | undefined
+		let superReject: ((reason?: any) => void) | undefined
 		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)
-			}
+			superResolve = resolve
+			superReject = reject
+			promise = executor instanceof Promise ? executor : new Promise(executor)
+			promise.then(
+				(value) => {
+					if (promise) {
+						this.pass(promise, value)
+					}
+				},
+				(reason) => {
+					if (promise) {
+						this.fail(promise, reason)
+					}
+				},
+			)
 		})
+		this.destiny = promise
+		this.resolve = superResolve as (value: T) => void
+		this.reject = superReject as (reason?: any) => void
 	}
 
-	public cancel(): void {
-		this.isCanceled = true
+	private pass(promise: Promise<T>, value: T) {
+		if (promise === this.destiny) {
+			this.resolve(value)
+		}
+	}
+	private fail(promise: Promise<T>, reason: any) {
+		if (promise === this.destiny) {
+			this.reject(reason)
+		}
+	}
+
+	public use(value: Promise<T> | T): void {
+		if (value instanceof Promise) {
+			const promise = value
+			this.destiny = promise
+			promise.then(
+				(resolved) => {
+					this.pass(promise, resolved)
+				},
+				(reason) => {
+					this.fail(promise, reason)
+				},
+			)
+		} else {
+			this.resolve(value)
+			this.destiny = undefined
+		}
 	}
 }

package/internal/src/index.ts

@@ -5,10 +5,9 @@ import type { Transceiver } from "./mutable"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
 
-export * from "./atom"
 export * from "./arbitrary"
+export * from "./atom"
 export * from "./caching"
-export * from "./lineage"
 export * from "./families"
 export * from "./future"
 export * from "./get-environment-data"
@@ -16,6 +15,7 @@ export * from "./get-state"
 export * from "./ingest-updates"
 export * from "./keys"
 export * from "./lazy-map"
+export * from "./lineage"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"

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

@@ -1,13 +1,12 @@
 import type {
+	FamilyMetadata,
 	MutableAtomFamily,
 	MutableAtomFamilyOptions,
 	MutableAtomOptions,
 	MutableAtomToken,
 } from "atom.io"
-import type { FamilyMetadata } from "atom.io"
 import type { Json } from "atom.io/json"
-import { selectJsonFamily } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
+import { selectJsonFamily, stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"

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

@@ -1,16 +1,16 @@
-import type { UpdateHandler } from "atom.io"
 import type {
 	FamilyMetadata,
 	MutableAtomOptions,
 	MutableAtomToken,
+	UpdateHandler,
 } from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJson } from "atom.io/json"
 
-import { type MutableAtom, cacheValue, setIntoStore } from ".."
+import { cacheValue, type MutableAtom, setIntoStore } from ".."
 import { markAtomAsDefault } from "../atom"
 import { newest } from "../lineage"
-import { type Store, deposit } from "../store"
+import { deposit, type Store } from "../store"
 import { Subject } from "../subject"
 import { subscribeToState } from "../subscribe"
 import { Tracker } from "./tracker"

package/internal/src/mutable/get-update-token.ts

@@ -1,5 +1,6 @@
 import type { MutableAtomToken, RegularAtomToken } from "atom.io"
 import type { Json } from "atom.io/json"
+
 import type { Signal, Transceiver } from "./transceiver"
 
 export const getUpdateToken = <

package/internal/src/selector/delete-selector.ts

@@ -1,7 +1,7 @@
 import type { ReadonlySelectorToken, WritableSelectorToken } from "atom.io"
 
-import { newest } from ".."
 import type { Store } from ".."
+import { newest } from ".."
 
 export function deleteSelector(
 	selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>,

package/internal/src/selector/register-selector.ts

@@ -1,4 +1,4 @@
-import type { Transactors, findState } from "atom.io"
+import type { findState, Transactors } from "atom.io"
 
 import { findInStore } from "../families"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"

package/internal/src/store/deposit.ts

@@ -1,4 +1,5 @@
 import type {
+	Func,
 	MutableAtomToken,
 	ReadableToken,
 	ReadonlySelectorToken,
@@ -7,7 +8,6 @@ import type {
 	TransactionToken,
 	WritableSelectorToken,
 	WritableToken,
-	Func,
 } from "atom.io"
 
 import type {

package/internal/src/store/store.ts

@@ -1,6 +1,6 @@
-import { AtomIOLogger } from "atom.io"
 import type {
 	AtomToken,
+	Func,
 	Logger,
 	MutableAtomFamily,
 	ReadonlySelectorFamily,
@@ -10,8 +10,8 @@ import type {
 	TransactionToken,
 	WritableSelectorFamily,
 	WritableSelectorToken,
-	Func,
 } from "atom.io"
+import { AtomIOLogger } from "atom.io"
 
 import { Junction } from "~/packages/rel8/junction/src"
 

package/internal/src/store/withdraw-new-family-member.ts

@@ -14,7 +14,7 @@ import type {
 	WritableSelector,
 	WritableState,
 } from ".."
-import { NotFoundError, newest, withdraw } from ".."
+import { newest, NotFoundError, withdraw } from ".."
 
 export function withdrawOrCreate<T>(
 	token: RegularAtomToken<T>,

package/internal/src/store/withdraw.ts

@@ -2,6 +2,7 @@ import type {
 	AtomFamily,
 	AtomFamilyToken,
 	AtomToken,
+	Func,
 	MutableAtomFamily,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
@@ -22,10 +23,9 @@ import type {
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
-	Func,
 } from "atom.io"
-
 import type { Json } from "atom.io/json"
+
 import type {
 	Atom,
 	MutableAtom,
@@ -38,7 +38,6 @@ import type {
 	WritableState,
 } from ".."
 import { NotFoundError } from ".."
-
 import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"

package/internal/src/subscribe/subscribe-to-state.ts

@@ -1,4 +1,5 @@
 import type { ReadableToken, UpdateHandler } from "atom.io"
+
 import type { Store } from "../store"
 import { withdrawOrCreate } from "../store"
 import { subscribeToRootAtoms } from "./subscribe-to-root-atoms"

package/internal/src/subscribe/subscribe-to-timeline.ts

@@ -1,4 +1,5 @@
 import type { TimelineManageable, TimelineToken, TimelineUpdate } from "atom.io"
+
 import type { Store } from ".."
 import { withdraw } from ".."
 

package/internal/src/subscribe/subscribe-to-transaction.ts

@@ -1,4 +1,5 @@
-import type { TransactionToken, TransactionUpdateHandler, Func } from "atom.io"
+import type { Func, TransactionToken, TransactionUpdateHandler } from "atom.io"
+
 import type { Store } from ".."
 import { withdraw } from ".."
 

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -1,10 +1,10 @@
 import type {
 	AtomToken,
+	Func,
+	TimelineUpdate,
 	TransactionToken,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
-import type { TimelineUpdate } from "atom.io"
 
 import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"

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

@@ -1,6 +1,7 @@
 import type {
 	AtomFamilyToken,
 	FamilyMetadata,
+	Func,
 	StateUpdate,
 	TimelineManageable,
 	TimelineOptions,
@@ -8,7 +9,6 @@ import type {
 	TimelineUpdate,
 	TokenType,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
 
 import { newest } from "../lineage"

package/internal/src/transaction/act-upon-store.ts

@@ -1,4 +1,4 @@
-import type { TransactionToken, Func } from "atom.io"
+import type { Func, TransactionToken } from "atom.io"
 
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"

package/internal/src/transaction/apply-transaction.ts

@@ -2,8 +2,8 @@ import type { Func } from "atom.io"
 
 import { ingestTransactionUpdate } from "../ingest-updates"
 import { newest } from "../lineage"
-import { withdraw } from "../store"
 import type { Store } from "../store"
+import { withdraw } from "../store"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 

package/internal/src/transaction/build-transaction.ts

@@ -2,8 +2,6 @@ import type { findState, Func } from "atom.io"
 
 import { Junction } from "~/packages/rel8/junction/src"
 
-import type { TransactionProgress } from "."
-import { actUponStore, getEpochNumberOfAction } from "."
 import { arbitrary } from "../arbitrary"
 import { findInStore } from "../families"
 import { getEnvironmentData } from "../get-environment-data"
@@ -12,6 +10,8 @@ import { LazyMap } from "../lazy-map"
 import { newest } from "../lineage"
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
+import type { TransactionProgress } from "."
+import { actUponStore, getEpochNumberOfAction } from "."
 import type { ChildStore, RootStore } from "./is-root-store"
 
 export const buildTransaction = (