atom.io 0.15.3 → 0.15.4

package/internal/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { FamilyMetadata as FamilyMetadata$1, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, Transactors, StateToken, ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRun, AtomToken, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, SelectorFamily, AtomFamily, StateUpdate, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { FamilyMetadata as FamilyMetadata$1, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, Transactors, StateToken, ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRun, AtomToken, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, SelectorFamily, AtomFamily, TimelineManageable, StateUpdate, TokenType, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, AtomIOLogger, Logger, ReadableToken, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json } from 'atom.io/json';
 import { Store as Store$1 } from 'atom.io/internal';
 
@@ -253,40 +253,40 @@ declare const closeOperation: (store: Store) => void;
 declare const isDone: (key: string, store: Store) => boolean;
 declare const markDone: (key: string, store: Store) => void;
 
-type TimelineAtomUpdate = StateUpdate<unknown> & {
+type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = StateUpdate<TokenType<ManagedAtom>> & {
     key: string;
     type: `atom_update`;
     timestamp: number;
     family?: FamilyMetadata$1;
 };
-type TimelineSelectorUpdate = {
+type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
     key: string;
     type: `selector_update`;
     timestamp: number;
-    atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[];
+    atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
 };
 type TimelineTransactionUpdate = TransactionUpdate<_n> & {
     key: string;
     type: `transaction_update`;
     timestamp: number;
 };
-type Timeline = {
+type Timeline<ManagedAtom extends TimelineManageable> = {
     type: `timeline`;
     key: string;
     at: number;
-    shouldCapture?: (update: TimelineUpdate, timeline: Timeline) => boolean;
+    shouldCapture?: (update: TimelineUpdate<TimelineManageable>, timeline: Timeline<ManagedAtom>) => boolean;
     timeTraveling: `into_future` | `into_past` | null;
-    history: TimelineUpdate[];
+    history: TimelineUpdate<ManagedAtom>[];
     selectorTime: number | null;
     transactionKey: string | null;
     install: (store: Store) => void;
-    subject: Subject<TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate | `redo` | `undo`>;
+    subject: Subject<TimelineAtomUpdate<ManagedAtom> | TimelineSelectorUpdate<ManagedAtom> | TimelineTransactionUpdate | `redo` | `undo`>;
 };
-declare function createTimeline(options: TimelineOptions, store: Store, data?: Timeline): TimelineToken;
+declare function createTimeline<ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>, store: Store, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
 
-declare const addAtomToTimeline: (atomToken: AtomToken<any>, tl: Timeline, store: Store) => void;
+declare const addAtomToTimeline: (atomToken: AtomToken<any>, tl: Timeline<any>, store: Store) => void;
 
-declare const timeTravel: (direction: `backward` | `forward`, token: TimelineToken, store: Store) => void;
+declare const timeTravel: (direction: `backward` | `forward`, token: TimelineToken<any>, store: Store) => void;
 
 declare class Store implements Lineage {
     parent: Store | null;
@@ -297,7 +297,7 @@ declare class Store implements Lineage {
     readonlySelectors: Map<string, ReadonlySelector<any>>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
     families: Map<string, AtomFamily<any, any> | ReadonlySelectorFamily<any, any> | SelectorFamily<any, any>>;
-    timelines: Map<string, Timeline>;
+    timelines: Map<string, Timeline<any>>;
     transactions: Map<string, Transaction<_n>>;
     atomsThatAreDefault: Set<string>;
     timelineAtoms: Junction<"timelineKey", "atomKey", null>;
@@ -305,13 +305,13 @@ declare class Store implements Lineage {
     selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
         source: string;
     }>;
-    subject: {
+    on: {
         atomCreation: Subject<AtomToken<unknown>>;
         selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
         transactionCreation: Subject<TransactionToken<_n>>;
-        timelineCreation: Subject<TimelineToken>;
+        timelineCreation: Subject<TimelineToken<unknown>>;
         transactionApplying: StatefulSubject<TransactionMeta<_n> | null>;
-        operationStatus: Subject<OperationProgress>;
+        operationClose: Subject<OperationProgress>;
     };
     operation: OperationProgress;
     transactionMeta: TransactionMeta<_n> | null;
@@ -333,8 +333,8 @@ declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>
 declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
 declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
 declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never> | undefined;
-declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined;
-declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | undefined;
+declare function withdraw<T>(token: ReadableToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined;
+declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never> | undefined;
 
 declare function withdrawNewFamilyMember<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
 declare function withdrawNewFamilyMember<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
@@ -422,7 +422,7 @@ declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>
 
 declare function subscribeToState<T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
 
-declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update: TimelineUpdate | `redo` | `undo`) => void, key: string, store: Store$1) => (() => void);
+declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store$1) => (() => void);
 
 declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store$1) => (() => void);
 

package/internal/dist/index.js

@@ -1,4 +1,4 @@
-import { getState as getState$1, setState as setState$1, runTransaction } from '../../dist/chunk-K22LR3V6.js';
+import { getState as getState$1, setState as setState$1, runTransaction } from '../../dist/chunk-RLZQ6IIY.js';
 import { Junction } from '../../dist/chunk-NYTGCPHB.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
 import { selectJson, stringifyJson, parseJson, selectJsonFamily } from 'atom.io/json';
@@ -187,7 +187,7 @@ var closeOperation = (store) => {
     );
   }
   store.operation = { open: false };
-  store.subject.operationStatus.next(store.operation);
+  store.on.operationClose.next(store.operation);
 };
 var isDone = (key, store) => {
   if (!store.operation.open) {
@@ -413,13 +413,13 @@ var Store = class {
         makeContentKey: (...keys) => keys.sort().join(`:`)
       }
     );
-    this.subject = {
+    this.on = {
       atomCreation: new Subject(),
       selectorCreation: new Subject(),
       transactionCreation: new Subject(),
       timelineCreation: new Subject(),
       transactionApplying: new StatefulSubject(null),
-      operationStatus: new Subject()
+      operationClose: new Subject()
     };
     this.operation = { open: false };
     this.transactionMeta = null;
@@ -712,7 +712,7 @@ var createReadWriteSelector = (options, family, store) => {
   if (family) {
     token.family = family;
   }
-  store.subject.selectorCreation.next(token);
+  store.on.selectorCreation.next(token);
   return token;
 };
 
@@ -748,7 +748,7 @@ var createReadonlySelector = (options, family, store) => {
   if (family) {
     token.family = family;
   }
-  store.subject.selectorCreation.next(token);
+  store.on.selectorCreation.next(token);
   return token;
 };
 
@@ -959,7 +959,7 @@ var Tracker = class {
       `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
       (update) => {
         if (target.operation.open) {
-          const unsubscribe = target.subject.operationStatus.subscribe(
+          const unsubscribe = target.on.operationClose.subscribe(
             mutableState.key,
             () => {
               unsubscribe();
@@ -982,7 +982,7 @@ var Tracker = class {
             `tracker:${store.config.name}:${target2.transactionMeta === null ? `main` : target2.transactionMeta.update.key}`,
             (update2) => {
               if (target2.operation.open) {
-                const unsubscribe = target2.subject.operationStatus.subscribe(
+                const unsubscribe = target2.on.operationClose.subscribe(
                   mutableState.key,
                   () => {
                     unsubscribe();
@@ -1034,7 +1034,7 @@ var Tracker = class {
             return;
           }
         }
-        const unsubscribe = store.subject.operationStatus.subscribe(
+        const unsubscribe = store.on.operationClose.subscribe(
           latestUpdateState.key,
           () => {
             unsubscribe();
@@ -1392,7 +1392,7 @@ function createRegularAtom(options, family, store) {
       }
     };
   }
-  store.subject.atomCreation.next(token);
+  store.on.atomCreation.next(token);
   return token;
 }
 
@@ -1505,8 +1505,8 @@ var addAtomToTimeline = (atomToken, tl, store) => {
     const target = newest(store);
     const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
     const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
-    const currentTransactionKey = (_a = target.subject.transactionApplying.state) == null ? void 0 : _a.update.key;
-    const currentTransactionTime = (_b = target.subject.transactionApplying.state) == null ? void 0 : _b.time;
+    const currentTransactionKey = (_a = target.on.transactionApplying.state) == null ? void 0 : _a.update.key;
+    const currentTransactionTime = (_b = target.on.transactionApplying.state) == null ? void 0 : _b.time;
     store.logger.info(
       `\u23F3`,
       `timeline`,
@@ -1786,7 +1786,7 @@ function createTimeline(options, store, data) {
     key: timelineKey,
     type: `timeline`
   };
-  store.subject.timelineCreation.next(token);
+  store.on.timelineCreation.next(token);
   return token;
 }
 var timeTravel = (direction, token, store) => {
@@ -1940,7 +1940,7 @@ var applyTransaction = (output, store) => {
   child.transactionMeta.phase = `applying`;
   child.transactionMeta.update.output = output;
   parent.child = null;
-  parent.subject.transactionApplying.next(child.transactionMeta);
+  parent.on.transactionApplying.next(child.transactionMeta);
   const { updates } = child.transactionMeta.update;
   store.logger.info(
     `\u{1F6C4}`,
@@ -1985,7 +1985,7 @@ var applyTransaction = (output, store) => {
   } else {
     parent.transactionMeta.update.updates.push(child.transactionMeta.update);
   }
-  parent.subject.transactionApplying.next(null);
+  parent.on.transactionApplying.next(null);
 };
 
 // internal/src/transaction/build-transaction.ts
@@ -1994,7 +1994,7 @@ var buildTransaction = (key, params, store) => {
   const child = {
     parent,
     child: null,
-    subject: parent.subject,
+    on: parent.on,
     loggers: parent.loggers,
     logger: parent.logger,
     config: parent.config,
@@ -2065,7 +2065,7 @@ function createTransaction(options, store) {
   const target = newest(store);
   target.transactions.set(newTransaction.key, newTransaction);
   const token = deposit(newTransaction);
-  store.subject.transactionCreation.next(token);
+  store.on.transactionCreation.next(token);
   return token;
 }