atom.io 0.19.4 → 0.20.1

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/operation.ts

@@ -21,11 +21,11 @@ export const openOperation = (
 	store: Store,
 ): `rejection` | undefined => {
 	if (store.operation.open) {
-		store.logger.error(
-			`❌`,
+		store.logger.warn(
+			`❗`,
 			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`
 	}

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/set-state/set-into-store.ts

@@ -1,6 +1,5 @@
 import type { WritableToken } from "atom.io"
 
-import { NotFoundError } from "../not-found-error"
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
 import { withdrawOrCreate } from "../store"
@@ -13,6 +12,13 @@ export function setIntoStore<T, New extends T>(
 ): void {
 	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)

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 = (

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

@@ -1,13 +1,13 @@
 import type {
+	Func,
 	TransactionOptions,
 	TransactionToken,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
 
 import { newest } from "../lineage"
-import { deposit } from "../store"
 import type { Store } from "../store"
+import { deposit } from "../store"
 import { Subject } from "../subject"
 import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"

package/internal/src/transaction/index.ts

@@ -1,4 +1,4 @@
-import type { TransactionUpdate, TransactorsWithRunAndEnv, Func } from "atom.io"
+import type { Func, TransactionUpdate, TransactorsWithRunAndEnv } from "atom.io"
 import type { Junction } from "rel8/junction"
 
 export * from "./abort-transaction"

package/internal/src/transaction/is-root-store.ts

@@ -1,7 +1,7 @@
 import type { Func } from "atom.io"
 
-import type { TransactionEpoch, TransactionProgress } from "."
 import type { Store } from "../store"
+import type { TransactionEpoch, TransactionProgress } from "."
 
 export interface RootStore extends Store {
 	transactionMeta: TransactionEpoch

package/introspection/src/attach-atom-index.ts

@@ -1,9 +1,9 @@
 import type { AtomToken, ReadonlySelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtom,
 	createStandaloneSelector,
+	IMPLICIT,
 	newest,
 } from "atom.io/internal"
 

package/introspection/src/attach-introspection-states.ts

@@ -1,14 +1,14 @@
 import type {
+	Func,
 	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	TimelineToken,
 	TransactionToken,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
-import * as Internal from "atom.io/internal"
 import type { Timeline } from "atom.io/internal"
+import * as Internal from "atom.io/internal"
 
 import { type AtomTokenIndex, attachAtomIndex } from "./attach-atom-index"
 import type { SelectorTokenIndex } from "./attach-selector-index"

package/introspection/src/attach-selector-index.ts

@@ -1,9 +1,9 @@
 import type { ReadonlySelectorToken, WritableSelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtom,
 	createStandaloneSelector,
+	IMPLICIT,
 	newest,
 } from "atom.io/internal"
 

package/introspection/src/attach-timeline-family.ts

@@ -4,10 +4,10 @@ import type {
 } from "atom.io"
 import type { Store, Timeline } from "atom.io/internal"
 import {
-	IMPLICIT,
-	Subject,
 	createRegularAtomFamily,
 	createSelectorFamily,
+	IMPLICIT,
+	Subject,
 } from "atom.io/internal"
 
 export const attachTimelineFamily = (

package/introspection/src/attach-timeline-index.ts

@@ -1,9 +1,9 @@
 import type { ReadonlySelectorToken, TimelineToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtom,
 	createStandaloneSelector,
+	IMPLICIT,
 } from "atom.io/internal"
 
 export const attachTimelineIndex = (

package/introspection/src/attach-transaction-index.ts

@@ -1,9 +1,9 @@
-import type { ReadonlySelectorToken, TransactionToken, Func } from "atom.io"
+import type { Func, ReadonlySelectorToken, TransactionToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtom,
 	createStandaloneSelector,
+	IMPLICIT,
 } from "atom.io/internal"
 
 export const attachTransactionIndex = (

package/introspection/src/attach-transaction-logs.ts

@@ -1,13 +1,13 @@
 import type {
+	Func,
 	ReadonlySelectorFamilyToken,
 	TransactionUpdate,
-	Func,
 } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createRegularAtomFamily,
 	createSelectorFamily,
+	IMPLICIT,
 } from "atom.io/internal"
 
 export const attachTransactionLogs = (

package/json/dist/index.cjs

@@ -2,6 +2,41 @@
 
 var internal = require('atom.io/internal');
 
+// json/src/select-json.ts
+var selectJson = (atom, transform, store = internal.IMPLICIT.STORE) => {
+  return internal.createStandaloneSelector(
+    {
+      key: `${atom.key}:JSON`,
+      get: ({ get }) => transform.toJson(get(atom)),
+      set: ({ set }, newValue) => {
+        set(atom, transform.fromJson(newValue));
+      }
+    },
+    store
+  );
+};
+function selectJsonFamily(family, transform, store = internal.IMPLICIT.STORE) {
+  const jsonFamily = internal.createSelectorFamily(
+    {
+      key: `${family.key}:JSON`,
+      get: (key) => ({ get }) => transform.toJson(get(family(key))),
+      set: (key) => ({ set }, newValue) => {
+        set(family(key), transform.fromJson(newValue));
+      }
+    },
+    store
+  );
+  family.subject.subscribe(
+    `store=${store.config.name}::json-selector-family`,
+    (token) => {
+      if (token.family) {
+        jsonFamily(parseJson(token.family.subKey));
+      }
+    }
+  );
+  return jsonFamily;
+}
+
 // ../anvl/src/json/json-interface.ts
 var stringSetJsonInterface = {
   toJson: (stringSet) => Array.from(stringSet),
@@ -44,39 +79,6 @@ var isNull = (input) => {
 var isPrimitive = (input) => {
   return isString(input) || isNumber(input) || isBoolean(input) || isNull(input);
 };
-var selectJson = (atom, transform, store = internal.IMPLICIT.STORE) => {
-  return internal.createStandaloneSelector(
-    {
-      key: `${atom.key}:JSON`,
-      get: ({ get }) => transform.toJson(get(atom)),
-      set: ({ set }, newValue) => {
-        set(atom, transform.fromJson(newValue));
-      }
-    },
-    store
-  );
-};
-function selectJsonFamily(family, transform, store = internal.IMPLICIT.STORE) {
-  const jsonFamily = internal.createSelectorFamily(
-    {
-      key: `${family.key}:JSON`,
-      get: (key) => ({ get }) => transform.toJson(get(family(key))),
-      set: (key) => ({ set }, newValue) => {
-        set(family(key), transform.fromJson(newValue));
-      }
-    },
-    store
-  );
-  family.subject.subscribe(
-    `store=${store.config.name}::json-selector-family`,
-    (token) => {
-      if (token.family) {
-        jsonFamily(parseJson(token.family.subKey));
-      }
-    }
-  );
-  return jsonFamily;
-}
 
 exports.JSON_DEFAULTS = JSON_DEFAULTS;
 exports.JSON_TYPE_NAMES = JSON_TYPE_NAMES;