atom.io 0.19.0 → 0.19.2

package/internal/dist/index.js

@@ -1,4 +1,4 @@
-import { Junction } from '../../dist/chunk-WX2NCOZR.js';
+import { Junction } from '../../dist/chunk-FTONNX2R.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-U2IICNHQ.js';
 import { stringifyJson, selectJson, parseJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
@@ -30,7 +30,9 @@ var Subject = class {
   }
   subscribe(key, subscriber) {
     this.subscribers.set(key, subscriber);
-    const unsubscribe = () => this.unsubscribe(key);
+    const unsubscribe = () => {
+      this.unsubscribe(key);
+    };
     return unsubscribe;
   }
   unsubscribe(key) {
@@ -263,8 +265,12 @@ function withdrawOrCreate(token, store) {
 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);
+      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 {
@@ -286,7 +292,7 @@ function copyMutableIfNeeded(atom, origin, target) {
     if (originValue === void 0) {
       return typeof atom.default === `function` ? atom.default() : atom.default;
     }
-    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
+    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);
@@ -391,7 +397,7 @@ function createRegularAtomFamily(options, store) {
       key: options.key,
       type: `atom_family`,
       subject,
-      install: (store2) => createRegularAtomFamily(options, store2)
+      install: (s) => createRegularAtomFamily(options, s)
     }
   );
   const target = newest(store);
@@ -432,7 +438,7 @@ function createReadonlySelectorFamily(options, store) {
       key: options.key,
       type: `readonly_selector_family`,
       subject,
-      install: (store2) => createReadonlySelectorFamily(options, store2)
+      install: (s) => createReadonlySelectorFamily(options, s)
     }
   );
   store.families.set(options.key, readonlySelectorFamily);
@@ -465,7 +471,7 @@ function createWritableSelectorFamily(options, store) {
       key: options.key,
       type: `selector_family`,
       subject,
-      install: (store2) => createWritableSelectorFamily(options, store2)
+      install: (s) => createWritableSelectorFamily(options, s)
     }
   );
   store.families.set(options.key, selectorFamily);
@@ -974,7 +980,7 @@ function deleteSelector(selectorToken, store) {
     }
   }
   target.selectorGraph.delete(key);
-  store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
+  store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
 }
 
 // internal/src/subscribe/recall-state.ts
@@ -1153,18 +1159,18 @@ var Tracker = class {
           this.unsubscribeFromInnerValue();
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
-            (update2) => {
+            (transceiverUpdate) => {
               if (target.operation.open) {
                 const unsubscribe = target.on.operationClose.subscribe(
                   subscriptionKey,
                   () => {
                     unsubscribe();
-                    setIntoStore(latestUpdateState, update2, target);
+                    setIntoStore(latestUpdateState, transceiverUpdate, target);
                   }
                 );
               } else {
                 setIntoStore(mutableState, (current) => current, target);
-                setIntoStore(latestUpdateState, update2, target);
+                setIntoStore(latestUpdateState, transceiverUpdate, target);
               }
             }
           );
@@ -1273,14 +1279,14 @@ function createMutableAtom(options, family, store) {
   const subject = new Subject();
   const newAtom = __spreadProps(__spreadValues({}, options), {
     type: `mutable_atom`,
-    install: (store2) => {
-      store2.logger.info(
+    install: (s) => {
+      s.logger.info(
         `\u{1F6E0}\uFE0F`,
         `atom`,
         options.key,
-        `installing in store "${store2.config.name}"`
+        `installing in store "${s.config.name}"`
       );
-      return createMutableAtom(options, family, store2);
+      return createMutableAtom(options, family, s);
     },
     subject
   });
@@ -1297,7 +1303,9 @@ function createMutableAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => setIntoStore(token, next, store),
+        setSelf: (next) => {
+          setIntoStore(token, next, store);
+        },
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1382,7 +1390,7 @@ function createMutableAtomFamily(options, store) {
       key: options.key,
       type: `mutable_atom_family`,
       subject,
-      install: (store2) => createMutableAtomFamily(options, store2),
+      install: (s) => createMutableAtomFamily(options, s),
       toJson: options.toJson,
       fromJson: options.fromJson
     }
@@ -1478,14 +1486,14 @@ function createRegularAtom(options, family, store) {
   const subject = new Subject();
   const newAtom = __spreadProps(__spreadValues({}, options), {
     type: `atom`,
-    install: (store2) => {
-      store2.logger.info(
+    install: (s) => {
+      s.logger.info(
         `\u{1F6E0}\uFE0F`,
         `atom`,
         options.key,
-        `installing in store "${store2.config.name}"`
+        `installing in store "${s.config.name}"`
       );
-      return createRegularAtom(options, family, store2);
+      return createRegularAtom(options, family, s);
     },
     subject
   });
@@ -1505,7 +1513,9 @@ function createRegularAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => setIntoStore(token, next, store),
+        setSelf: (next) => {
+          setIntoStore(token, next, store);
+        },
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1542,7 +1552,7 @@ function deleteAtom(atomToken, store) {
     store.logger.error(
       `\u274C`,
       `atom`,
-      `${key}`,
+      key,
       `Tried to delete atom, but it does not exist in the store.`
     );
   }
@@ -1565,7 +1575,7 @@ function deleteAtom(atomToken, store) {
     const updateToken = getUpdateToken(atomToken);
     deleteAtom(updateToken, store);
   }
-  store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
+  store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
 }
 
 // internal/src/arbitrary.ts
@@ -1709,7 +1719,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
           tl.transactionKey = currentTransactionKey;
           const unsubscribe = currentTransaction.subject.subscribe(
             `timeline:${tl.key}`,
-            (update2) => {
+            (transactionUpdate) => {
               var _a2, _b2;
               unsubscribe();
               if (tl.timeTraveling === null && currentTransactionInstanceId) {
@@ -1717,11 +1727,11 @@ var addAtomToTimeline = (atomToken, tl, store) => {
                   tl.history.splice(tl.at);
                 }
                 const filterUpdates = (updates2) => updates2.filter((updateFromTx) => {
-                  const target2 = newest(store);
+                  const newestStore = newest(store);
                   if (`updates` in updateFromTx) {
                     return true;
                   }
-                  const atomOrFamilyKeys = target2.timelineAtoms.getRelatedKeys(tl.key);
+                  const atomOrFamilyKeys = newestStore.timelineAtoms.getRelatedKeys(tl.key);
                   return atomOrFamilyKeys ? [...atomOrFamilyKeys].some(
                     (key) => {
                       var _a3;
@@ -1736,11 +1746,11 @@ var addAtomToTimeline = (atomToken, tl, store) => {
                   }
                   return updateFromTx;
                 });
-                const updates = filterUpdates(update2.updates);
+                const updates = filterUpdates(transactionUpdate.updates);
                 const timelineTransactionUpdate = __spreadProps(__spreadValues({
                   type: `transaction_update`,
                   timestamp: Date.now()
-                }, update2), {
+                }, transactionUpdate), {
                   updates
                 });
                 const willCapture = (_b2 = (_a2 = tl.shouldCapture) == null ? void 0 : _a2.call(tl, timelineTransactionUpdate, tl)) != null ? _b2 : true;
@@ -1755,7 +1765,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
                 `\u231B`,
                 `timeline`,
                 tl.key,
-                `got a transaction_update "${update2.key}"`
+                `got a transaction_update "${transactionUpdate.key}"`
               );
             }
           );
@@ -1855,7 +1865,7 @@ function createTimeline(options, store, data) {
     transactionKey: null
   }, data), {
     history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
-    install: (store2) => createTimeline(options, store2, tl),
+    install: (s) => createTimeline(options, s, tl),
     subject: new Subject()
   });
   if (options.shouldCapture) {
@@ -2146,16 +2156,18 @@ var buildTransaction = (key, params, store, id) => {
     update: {
       key,
       id,
-      epoch: epoch === void 0 ? NaN : epoch + 1,
+      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
       updates: [],
       params,
       output: void 0
     },
     transactors: {
       get: (token) => getFromStore(token, child),
-      set: (token, value) => setIntoStore(token, value, child),
-      run: (token, id2 = arbitrary()) => actUponStore(token, id2, child),
-      find: (token, key2) => findInStore(token, key2, child),
+      set: (token, value) => {
+        setIntoStore(token, value, child);
+      },
+      run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
+      find: (token, k) => findInStore(token, k, child),
       env: () => getEnvironmentData(child)
     }
   };
@@ -2192,7 +2204,7 @@ function createTransaction(options, store) {
         throw thrown;
       }
     },
-    install: (store2) => createTransaction(options, store2),
+    install: (s) => createTransaction(options, s),
     subject: new Subject()
   };
   const target = newest(store);

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

@@ -41,14 +41,14 @@ export function createRegularAtom<T>(
 	const newAtom: RegularAtom<T> = {
 		...options,
 		type: `atom`,
-		install: (store: Store) => {
-			store.logger.info(
+		install: (s: Store) => {
+			s.logger.info(
 				`🛠️`,
 				`atom`,
 				options.key,
-				`installing in store "${store.config.name}"`,
+				`installing in store "${s.config.name}"`,
 			)
-			return createRegularAtom(options, family, store)
+			return createRegularAtom(options, family, s)
 		},
 		subject,
 	} as const
@@ -68,7 +68,9 @@ export function createRegularAtom<T>(
 		const cleanupFunctions: (() => void)[] = []
 		for (const effect of options.effects) {
 			const cleanup = effect({
-				setSelf: (next) => setIntoStore(token, next, store),
+				setSelf: (next) => {
+					setIntoStore(token, next, store)
+				},
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
 			})

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

@@ -11,7 +11,7 @@ export function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		store.logger.error(
 			`❌`,
 			`atom`,
-			`${key}`,
+			key,
 			`Tried to delete atom, but it does not exist in the store.`,
 		)
 	}
@@ -36,5 +36,5 @@ export function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		const updateToken = getUpdateToken(atomToken)
 		deleteAtom(updateToken, store)
 	}
-	store.logger.info(`🔥`, `atom`, `${key}`, `deleted`)
+	store.logger.info(`🔥`, `atom`, key, `deleted`)
 }

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

@@ -35,13 +35,13 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 				},
 				family,
 				store,
-			) as ReadonlySelectorToken<T>
+			)
 		},
 		{
 			key: options.key,
 			type: `readonly_selector_family`,
 			subject,
-			install: (store: Store) => createReadonlySelectorFamily(options, store),
+			install: (s: Store) => createReadonlySelectorFamily(options, s),
 		} as const,
 	) as ReadonlySelectorFamily<T, K>
 	store.families.set(options.key, readonlySelectorFamily)

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

@@ -48,7 +48,7 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 			key: options.key,
 			type: `atom_family`,
 			subject,
-			install: (store: Store) => createRegularAtomFamily(options, store),
+			install: (s: Store) => createRegularAtomFamily(options, s),
 		} as const,
 	)
 	const target = newest(store)

package/internal/src/families/create-writable-selector-family.ts

@@ -43,7 +43,7 @@ export function createWritableSelectorFamily<T, K extends Json.Serializable>(
 			key: options.key,
 			type: `selector_family`,
 			subject,
-			install: (store: Store) => createWritableSelectorFamily(options, store),
+			install: (s: Store) => createWritableSelectorFamily(options, s),
 		} as const,
 	) as WritableSelectorFamily<T, K>
 	store.families.set(options.key, selectorFamily)

package/internal/src/future.ts

@@ -16,10 +16,12 @@ export class Future<T> extends Promise<T> {
 			| ((resolve: (value: T) => void, reject: (reason?: any) => void) => void),
 	) {
 		super((resolve, reject) => {
-			const pass = (value: T) =>
+			const pass = (value: T) => {
 				this.isCanceled ? reject(`canceled`) : resolve(value)
-			const fail = (reason: any) =>
+			}
+			const fail = (reason: any) => {
 				this.isCanceled ? reject(`canceled`) : reject(reason)
+			}
 			if (typeof executor === `function`) {
 				executor(pass, fail)
 			} else {

package/internal/src/lineage.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 export interface Lineage {
 	parent: typeof this | null
 	child: typeof this | null

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

@@ -57,7 +57,7 @@ export function createMutableAtomFamily<
 			key: options.key,
 			type: `mutable_atom_family`,
 			subject,
-			install: (store: Store) => createMutableAtomFamily(options, store),
+			install: (s: Store) => createMutableAtomFamily(options, s),
 			toJson: options.toJson,
 			fromJson: options.fromJson,
 		} as const,

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

@@ -45,14 +45,14 @@ export function createMutableAtom<
 	const newAtom: MutableAtom<T, J> = {
 		...options,
 		type: `mutable_atom`,
-		install: (store: Store) => {
-			store.logger.info(
+		install: (s: Store) => {
+			s.logger.info(
 				`🛠️`,
 				`atom`,
 				options.key,
-				`installing in store "${store.config.name}"`,
+				`installing in store "${s.config.name}"`,
 			)
-			return createMutableAtom(options, family, store)
+			return createMutableAtom(options, family, s)
 		},
 		subject,
 	} as const
@@ -69,7 +69,9 @@ export function createMutableAtom<
 		const cleanupFunctions: (() => void)[] = []
 		for (const effect of options.effects) {
 			const cleanup = effect({
-				setSelf: (next) => setIntoStore(token, next, store),
+				setSelf: (next) => {
+					setIntoStore(token, next, store)
+				},
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
 			})

package/internal/src/mutable/tracker.ts

@@ -32,7 +32,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			? {
 					key: `*${mutableState.family.key}`,
 					subKey: mutableState.family.subKey,
-			  }
+				}
 			: undefined
 		const latestUpdateState = createRegularAtom<
 			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
@@ -87,18 +87,18 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					this.unsubscribeFromInnerValue()
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
-						(update) => {
+						(transceiverUpdate) => {
 							if (target.operation.open) {
 								const unsubscribe = target.on.operationClose.subscribe(
 									subscriptionKey,
 									() => {
 										unsubscribe()
-										setIntoStore(latestUpdateState, update, target)
+										setIntoStore(latestUpdateState, transceiverUpdate, target)
 									},
 								)
 							} else {
 								setIntoStore(mutableState, (current) => current, target)
-								setIntoStore(latestUpdateState, update, target)
+								setIntoStore(latestUpdateState, transceiverUpdate, target)
 							}
 						},
 					)

package/internal/src/mutable/transceiver.ts

@@ -23,9 +23,9 @@ export function isTransceiver(
 export type TransceiverMode = `playback` | `record` | `transaction`
 
 export type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<
-	infer Signal
+	infer S
 >
-	? Signal
+	? S
 	: never
 
 /*

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

@@ -33,5 +33,5 @@ export function deleteSelector(
 		}
 	}
 	target.selectorGraph.delete(key)
-	store.logger.info(`🔥`, selectorToken.type, `${key}`, `deleted`)
+	store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
 }

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

@@ -6,5 +6,5 @@ export const become =
 		nextVersionOfThing instanceof Function
 			? nextVersionOfThing(
 					originalThing instanceof Function ? originalThing() : originalThing,
-			  )
+				)
 			: nextVersionOfThing

package/internal/src/set-state/copy-mutable-if-needed.ts

@@ -15,7 +15,7 @@ export function copyMutableIfNeeded<T extends Transceiver<any>>(
 			return typeof atom.default === `function` ? atom.default() : atom.default
 		}
 
-		origin.logger.info(`📃`, `atom`, `${atom.key}`, `copying`)
+		origin.logger.info(`📃`, `atom`, atom.key, `copying`)
 		const jsonValue = atom.toJson(originValue)
 		const copiedValue = atom.fromJson(jsonValue)
 		target.valueMap.set(atom.key, copiedValue)

package/internal/src/store/deposit.ts

@@ -7,7 +7,7 @@ import type {
 	TransactionToken,
 	WritableSelectorToken,
 	WritableToken,
-	ƒn,
+	Func,
 } from "atom.io"
 
 import type {
@@ -28,22 +28,22 @@ export function deposit<T extends Transceiver<any>>(
 export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
-export function deposit<T>(
-	state: Transaction<T extends ƒn ? T : never>,
+export function deposit<T extends Func>(
+	state: Transaction<T>,
 ): TransactionToken<T>
 export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
 export function deposit<T>(
 	state:
 		| ReadonlySelector<T>
 		| RegularAtom<T>
-		| Transaction<T extends ƒn ? T : never>
+		| Transaction<T extends Func ? T : never>
 		| WritableSelector<T>
 		| (T extends Transceiver<any> ? MutableAtom<T, any> : never),
 ):
 	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
 	| RegularAtomToken<T>
 	| SelectorToken<T>
-	| TransactionToken<T> {
+	| TransactionToken<T extends Func ? T : never> {
 	const token = {
 		key: state.key,
 		type: state.type,

package/internal/src/store/store.ts

@@ -10,7 +10,7 @@ import type {
 	TransactionToken,
 	WritableSelectorFamily,
 	WritableSelectorToken,
-	ƒn,
+	Func,
 } from "atom.io"
 
 import { Junction } from "~/packages/rel8/junction/src"
@@ -54,7 +54,7 @@ export class Store implements Lineage {
 	>()
 
 	public timelines = new Map<string, Timeline<any>>()
-	public transactions = new Map<string, Transaction<ƒn>>()
+	public transactions = new Map<string, Transaction<Func>>()
 
 	public atomsThatAreDefault = new Set<string>()
 
@@ -85,15 +85,15 @@ export class Store implements Lineage {
 		selectorCreation: new Subject<
 			ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
 		>(),
-		transactionCreation: new Subject<TransactionToken<ƒn>>(),
+		transactionCreation: new Subject<TransactionToken<Func>>(),
 		timelineCreation: new Subject<TimelineToken<unknown>>(),
-		transactionApplying: new StatefulSubject<TransactionProgress<ƒn> | null>(
+		transactionApplying: new StatefulSubject<TransactionProgress<Func> | null>(
 			null,
 		),
 		operationClose: new Subject<OperationProgress>(),
 	}
 	public operation: OperationProgress = { open: false }
-	public transactionMeta: TransactionEpoch | TransactionProgress<ƒn> = {
+	public transactionMeta: TransactionEpoch | TransactionProgress<Func> = {
 		epoch: new Map<string, number>(),
 		actionContinuities: new Junction({
 			between: [`continuity`, `action`],

package/internal/src/store/withdraw.ts

@@ -22,7 +22,7 @@ import type {
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
-	ƒn,
+	Func,
 } from "atom.io"
 
 import type { Json } from "atom.io/json"
@@ -49,7 +49,6 @@ export type Withdrawable =
 	| MutableAtom<any, any>
 	| MutableAtomFamily<any, any, any>
 	| ReadableState<any>
-	| ReadableState<any>
 	| ReadonlySelector<any>
 	| ReadonlySelectorFamily<any, any>
 	| RegularAtom<any>
@@ -118,10 +117,10 @@ export function withdraw<T, K extends Json.Serializable>(
 	store: Store,
 ): SelectorFamily<T, any>
 
-export function withdraw<T>(
+export function withdraw<T extends Func>(
 	token: TransactionToken<T>,
 	store: Store,
-): Transaction<T extends ƒn ? T : never>
+): Transaction<T extends Func ? T : never>
 export function withdraw<T>(
 	token: TimelineToken<T>,
 	store: Store,
@@ -133,7 +132,7 @@ export function withdraw<T>(
 		| SelectorFamilyToken<T, any>
 		| SelectorToken<T>
 		| TimelineToken<T>
-		| TransactionToken<T>
+		| TransactionToken<T extends Func ? T : never>
 		| (T extends Transceiver<any>
 				? MutableAtomFamilyToken<T, any, any> | MutableAtomToken<T, any>
 				: never),

package/internal/src/subject.ts

@@ -5,7 +5,9 @@ export class Subject<T> {
 
 	public subscribe(key: string, subscriber: this[`Subscriber`]): () => void {
 		this.subscribers.set(key, subscriber)
-		const unsubscribe = () => this.unsubscribe(key)
+		const unsubscribe = () => {
+			this.unsubscribe(key)
+		}
 		return unsubscribe
 	}
 

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

@@ -32,7 +32,7 @@ export function subscribeToState<T>(
 						`Removing subscription "${key}"`,
 					)
 					unsubFunction()
-			  }
+				}
 			: () => {
 					store.logger.info(
 						`🙈`,
@@ -44,7 +44,7 @@ export function subscribeToState<T>(
 					for (const unsubFromDependency of dependencyUnsubFunctions) {
 						unsubFromDependency()
 					}
-			  }
+				}
 
 	return unsubscribe
 }

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

@@ -1,10 +1,10 @@
-import type { TransactionToken, TransactionUpdateHandler, ƒn } from "atom.io"
+import type { TransactionToken, TransactionUpdateHandler, Func } from "atom.io"
 import type { Store } from ".."
 import { withdraw } from ".."
 
-export const subscribeToTransaction = <ƒ extends ƒn>(
-	token: TransactionToken<ƒ>,
-	handleUpdate: TransactionUpdateHandler<ƒ>,
+export const subscribeToTransaction = <F extends Func>(
+	token: TransactionToken<F>,
+	handleUpdate: TransactionUpdateHandler<F>,
 	key: string,
 	store: Store,
 ): (() => void) => {