atom.io 0.19.4 → 0.20.1

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/dist/index.d.ts

@@ -174,6 +174,7 @@ declare const LoggerIconDictionary: {
     readonly "\u23F9\uFE0F": "Time-travel complete";
     readonly "\u2705": "Realtime transaction success";
     readonly "\u2728": "Computation complete";
+    readonly "\u2757": "Must wait to proceed with attempted action";
     readonly "\u274C": "Conflict prevents attempted action";
     readonly "\u2B55": "Operation start";
     readonly "\uD83D\uDC1E": "Possible bug in AtomIO";

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)) {
@@ -800,11 +774,11 @@ var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing insta
 // internal/src/operation.ts
 var openOperation = (token, store) => {
   if (store.operation.open) {
-    store.logger.error(
-      `\u274C`,
+    store.logger.warn(
+      `\u2757`,
       token.type,
       token.key,
-      `failed to setState during a setState for "${store.operation.token.key}"`
+      `tried to setState, but must wait until setState for "${store.operation.token.key}" completes`
     );
     return `rejection`;
   }
@@ -1017,6 +991,13 @@ var setAtomOrSelector = (state, value, store) => {
 function setIntoStore(token, value, store) {
   const rejection = openOperation(token, store);
   if (rejection) {
+    const unsubscribe = store.on.operationClose.subscribe(
+      `waiting to set "${token.key}"`,
+      () => {
+        unsubscribe();
+        setIntoStore(token, value, store);
+      }
+    );
     return;
   }
   const state = withdrawOrCreate(token, store);
@@ -1727,6 +1708,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 +1903,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)) {
@@ -522,11 +496,11 @@ var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing insta
 // internal/src/operation.ts
 var openOperation = (token, store) => {
   if (store.operation.open) {
-    store.logger.error(
-      `\u274C`,
+    store.logger.warn(
+      `\u2757`,
       token.type,
       token.key,
-      `failed to setState during a setState for "${store.operation.token.key}"`
+      `tried to setState, but must wait until setState for "${store.operation.token.key}" completes`
     );
     return `rejection`;
   }
@@ -739,6 +713,13 @@ var setAtomOrSelector = (state, value, store) => {
 function setIntoStore(token, value, store) {
   const rejection = openOperation(token, store);
   if (rejection) {
+    const unsubscribe = store.on.operationClose.subscribe(
+      `waiting to set "${token.key}"`,
+      () => {
+        unsubscribe();
+        setIntoStore(token, value, store);
+      }
+    );
     return;
   }
   const state = withdrawOrCreate(token, store);
@@ -1449,6 +1430,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 +1625,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"