atom.io 0.19.1 → 0.19.3

package/internal/dist/index.cjs

@@ -212,16 +212,16 @@ var Junction = class {
     if (a === void 0 && typeof b === `string`) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
-        for (const a2 of bRelations) {
-          this.delete(a2, b);
+        for (const bRelation of bRelations) {
+          this.delete(bRelation, b);
         }
       }
     }
     if (typeof a === `string` && b === void 0) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
-        for (const b2 of aRelations) {
-          this.delete(a, b2);
+        for (const aRelation of aRelations) {
+          this.delete(a, aRelation);
         }
       }
     }
@@ -274,18 +274,18 @@ var Junction = class {
     if (a !== void 0 && b === void 0) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
-        return [...aRelations].map((b2) => {
+        return [...aRelations].map((aRelation) => {
           var _a;
-          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
+          return [aRelation, (_a = this.getContent(a, aRelation)) != null ? _a : null];
         });
       }
     }
     if (a === void 0 && b !== void 0) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
-        return [...bRelations].map((a2) => {
+        return [...bRelations].map((bRelation) => {
           var _a;
-          return [a2, (_a = this.getContent(a2, b)) != null ? _a : null];
+          return [bRelation, (_a = this.getContent(bRelation, b)) != null ? _a : null];
         });
       }
     }
@@ -308,7 +308,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) {
@@ -541,8 +543,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 {
@@ -564,7 +570,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);
@@ -669,7 +675,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);
@@ -710,7 +716,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);
@@ -743,7 +749,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);
@@ -1252,7 +1258,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
@@ -1431,18 +1437,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);
               }
             }
           );
@@ -1551,14 +1557,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
   });
@@ -1575,7 +1581,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) {
@@ -1660,7 +1668,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
     }
@@ -1756,14 +1764,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
   });
@@ -1783,7 +1791,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) {
@@ -1820,7 +1830,7 @@ function deleteAtom(atomToken, store) {
     store.logger.error(
       `\u274C`,
       `atom`,
-      `${key}`,
+      key,
       `Tried to delete atom, but it does not exist in the store.`
     );
   }
@@ -1843,7 +1853,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
@@ -1987,7 +1997,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) {
@@ -1995,11 +2005,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;
@@ -2014,11 +2024,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;
@@ -2033,7 +2043,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
                 `\u231B`,
                 `timeline`,
                 tl.key,
-                `got a transaction_update "${update2.key}"`
+                `got a transaction_update "${transactionUpdate.key}"`
               );
             }
           );
@@ -2133,7 +2143,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) {
@@ -2431,9 +2441,11 @@ var buildTransaction = (key, params, store, id) => {
     },
     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)
     }
   };
@@ -2470,7 +2482,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/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ƒn as _n, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, SelectorToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Func, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, SelectorToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, JsonInterface } from 'atom.io/json';
 
 type primitive = boolean | number | string | null;
@@ -77,9 +77,9 @@ declare class Junction<const ASide extends string, const BSide extends string, c
 
 declare const abortTransaction: (store: Store) => void;
 
-declare function actUponStore<ƒ extends _n>(token: TransactionToken<ƒ>, id: string, store: Store): (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+declare function actUponStore<F extends Func>(token: TransactionToken<F>, id: string, store: Store): (...parameters: Parameters<F>) => ReturnType<F>;
 
-declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
+declare const applyTransaction: <F extends Func>(output: ReturnType<F>, store: Store) => void;
 
 declare function assignTransactionToContinuity(continuityKey: string, transactionKey: string, store: Store): void;
 
@@ -89,7 +89,7 @@ interface RootStore extends Store {
     child: ChildStore | null;
 }
 interface ChildStore extends Store {
-    transactionMeta: TransactionProgress<_n>;
+    transactionMeta: TransactionProgress<Func>;
     parent: ChildStore | RootStore;
     child: ChildStore | null;
 }
@@ -111,14 +111,14 @@ declare class StatefulSubject<T> extends Subject<T> {
     next(value: T): void;
 }
 
-type Transaction<ƒ extends _n> = {
+type Transaction<F extends Func> = {
     key: string;
     type: `transaction`;
     install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<ƒ>>;
-    run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>;
+    subject: Subject<TransactionUpdate<F>>;
+    run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
 };
-declare function createTransaction<ƒ extends _n>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
+declare function createTransaction<F extends Func>(options: TransactionOptions<F>, store: Store): TransactionToken<F>;
 
 declare function getContinuityKey(transactionKey: string, store: Store): string | undefined;
 declare function getEpochNumberOfContinuity(continuityKey: string, store: Store): number | undefined;
@@ -129,9 +129,9 @@ declare function setEpochNumberOfAction(transactionKey: string, newEpoch: number
 
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
-type TransactionProgress<ƒ extends _n> = {
+type TransactionProgress<F extends Func> = {
     phase: `applying` | `building`;
-    update: TransactionUpdate<ƒ>;
+    update: TransactionUpdate<F>;
     transactors: TransactorsWithRunAndEnv;
 };
 type TransactionEpoch = {
@@ -144,7 +144,7 @@ declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>)
 declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
+declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 
 interface Lineage {
@@ -179,7 +179,7 @@ type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
     timestamp: number;
     atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
 };
-type TimelineTransactionUpdate = TransactionUpdate<_n> & {
+type TimelineTransactionUpdate = TransactionUpdate<Func> & {
     key: string;
     type: `transaction_update`;
     timestamp: number;
@@ -212,7 +212,7 @@ declare class Store implements Lineage {
     trackers: Map<string, Tracker<Transceiver<any>>>;
     families: Map<string, WritableSelectorFamily<any, any> | MutableAtomFamily<any, any, any> | RegularAtomFamily<any, any> | ReadonlySelectorFamily<any, any>>;
     timelines: Map<string, Timeline<any>>;
-    transactions: Map<string, Transaction<_n>>;
+    transactions: Map<string, Transaction<Func>>;
     atomsThatAreDefault: Set<string>;
     timelineAtoms: Junction<"timelineKey", "atomKey", null>;
     selectorAtoms: Junction<"selectorKey", "atomKey", null>;
@@ -222,13 +222,13 @@ declare class Store implements Lineage {
     on: {
         atomCreation: Subject<AtomToken<unknown>>;
         selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<_n>>;
+        transactionCreation: Subject<TransactionToken<Func>>;
         timelineCreation: Subject<TimelineToken<unknown>>;
-        transactionApplying: StatefulSubject<TransactionProgress<_n> | null>;
+        transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
         operationClose: Subject<OperationProgress>;
     };
     operation: OperationProgress;
-    transactionMeta: TransactionEpoch | TransactionProgress<_n>;
+    transactionMeta: TransactionEpoch | TransactionProgress<Func>;
     config: {
         name: string;
     };
@@ -242,7 +242,7 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
+type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
 declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
 declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
@@ -257,7 +257,7 @@ declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken
 declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
 declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
 declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
-declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never>;
+declare function withdraw<T extends Func>(token: TransactionToken<T>, store: Store): Transaction<T extends Func ? T : never>;
 declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never>;
 
 declare function withdrawOrCreate<T>(token: RegularAtomToken<T>, store: Store): Atom<T>;
@@ -275,7 +275,7 @@ interface Transceiver<Signal extends Json.Serializable> {
 }
 declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
 type TransceiverMode = `playback` | `record` | `transaction`;
-type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer Signal> ? Signal : never;
+type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S : never;
 
 declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined, store: Store): MutableAtomToken<T, J>;
 
@@ -449,7 +449,7 @@ declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: Upda
 
 declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store) => (() => void);
 
-declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store) => (() => void);
+declare const subscribeToTransaction: <F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key: string, store: Store) => (() => void);
 
 type AtomIOState = {
     key: string;