atom.io 0.19.4 → 0.20.0

package/data/dist/index.js

@@ -1,4 +1,4 @@
-export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-MSCJWACE.js';
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-SMZRGPN6.js';
 import '../../dist/chunk-FTONNX2R.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';

package/data/src/dict.ts

@@ -1,9 +1,9 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createStandaloneSelector,
 	findInStore,
+	IMPLICIT,
 } from "atom.io/internal"
 import type { Json, Stringified } from "atom.io/json"
 

package/data/src/join.ts

@@ -13,13 +13,13 @@ import type {
 import { dispose, findState, getState, setState } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createMutableAtomFamily,
 	createRegularAtomFamily,
 	createSelectorFamily,
 	findInStore,
 	getFromStore,
 	getJsonFamily,
+	IMPLICIT,
 	isChildStore,
 	newest,
 	setIntoStore,

package/data/src/struct-family.ts

@@ -1,8 +1,8 @@
 import type * as AtomIO from "atom.io"
 import {
-	IMPLICIT,
 	createRegularAtomFamily,
 	createSelectorFamily,
+	IMPLICIT,
 } from "atom.io/internal"
 
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)

package/data/src/struct.ts

@@ -1,8 +1,10 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
-import { IMPLICIT } from "atom.io/internal"
-
-import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
+import {
+	createRegularAtom,
+	createStandaloneSelector,
+	IMPLICIT,
+} from "atom.io/internal"
 
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
 

package/internal/dist/index.cjs

@@ -23,6 +23,67 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
+// 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) {
@@ -539,93 +600,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)) {
@@ -1727,6 +1701,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);
@@ -1856,11 +1896,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/dist/index.d.ts

@@ -315,21 +315,21 @@ declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey exten
     constructor(findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>, store: Store);
 }
 
-declare function createStandaloneAtom<T>(options: RegularAtomOptions<T>, store: Store): RegularAtomToken<T>;
-declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>;
+declare function arbitrary(random?: () => number): string;
 
 declare function createRegularAtom<T>(options: MutableAtomOptions<any, any> | RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
 
+declare function createStandaloneAtom<T>(options: RegularAtomOptions<T>, store: Store): RegularAtomToken<T>;
+declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>;
+
 declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
 declare const isAtomDefault: (key: string, store: Store) => boolean;
 declare const markAtomAsDefault: (key: string, store: Store) => void;
 declare const markAtomAsNotDefault: (key: string, store: Store) => void;
 
-declare function arbitrary(random?: () => number): string;
-
 /**
- * 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.
@@ -338,9 +338,13 @@ declare function arbitrary(random?: () => number): string;
  * Can be constructed like a Promise, or from an existing Promise.
  */
 declare class Future<T> extends Promise<T> {
-    isCanceled: boolean;
+    private destiny;
+    private resolve;
+    private reject;
     constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => void));
-    cancel(): void;
+    private pass;
+    private fail;
+    use(value: Promise<T> | T): void;
 }
 
 declare function cacheValue<T>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): T;
@@ -351,10 +355,10 @@ declare const evictCachedValue: (key: string, target: Store) => void;
 declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
 declare function createAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
 
-declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
-
 declare function createReadonlySelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
+declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
+
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 

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"