Fixed tests

src/main/ExecutorImpl.ts

@@ -1,7 +1,7 @@
 import { AbortablePromise, PubSub } from 'parallel-universe';
 import type { ExecutorManager } from './ExecutorManager';
 import type { Executor, ExecutorEvent, ExecutorState, ExecutorTask } from './types';
-import { AbortError, definePrivateProperty } from './utils';
+import { AbortError } from './utils';
 
 /**
  * The {@link Executor} implementation returned by the {@link ExecutorManager}.
@@ -21,17 +21,17 @@ export class ExecutorImpl<Value = any> implements Executor {
   /**
    * The promise of the pending task execution, or `null` if there's no pending task execution.
    */
-  declare _promise: AbortablePromise<Value> | null;
+  _promise: AbortablePromise<Value> | null = null;
 
   /**
    * The number times the executor was activated.
    */
-  declare _activeCount: number;
+  _activeCount: number = 0;
 
   /**
    * The pubsub that handles the executor subscriptions.
    */
-  declare _pubSub: PubSub<ExecutorEvent>;
+  _pubSub = new PubSub<ExecutorEvent>();
 
   get isSettled(): boolean {
     return this.isFulfilled || this.isRejected;
@@ -48,11 +48,7 @@ export class ExecutorImpl<Value = any> implements Executor {
   constructor(
     public readonly key: string,
     public readonly manager: ExecutorManager
-  ) {
-    definePrivateProperty(this, '_promise', null);
-    definePrivateProperty(this, '_activeCount', 0);
-    definePrivateProperty(this, '_pubSub', new PubSub());
-  }
+  ) {}
 
   get(): Value {
     if (this.isFulfilled) {
@@ -101,8 +97,9 @@ export class ExecutorImpl<Value = any> implements Executor {
       signal.addEventListener('abort', () => {
         if (this._promise === promise) {
           this._promise = null;
+          this.version++;
         }
-        notify(this, 'aborted');
+        this._publish('aborted');
       });
 
       new Promise<Value>(resolve => {
@@ -134,11 +131,13 @@ export class ExecutorImpl<Value = any> implements Executor {
 
     if (prevPromise !== null) {
       prevPromise.abort(AbortError('The task was replaced: ' + this.key));
+    } else {
+      this.version++;
     }
 
     if (this._promise === promise) {
       this.latestTask = task;
-      notify(this, 'pending');
+      this._publish('pending');
     }
 
     return promise;
@@ -155,7 +154,8 @@ export class ExecutorImpl<Value = any> implements Executor {
       this.isFulfilled = this.isRejected = this.isStale = false;
       this.value = this.reason = undefined;
       this.timestamp = 0;
-      notify(this, 'cleared');
+      this.version++;
+      this._publish('cleared');
     }
   }
 
@@ -167,7 +167,8 @@ export class ExecutorImpl<Value = any> implements Executor {
 
   invalidate(): void {
     if (this.isStale !== (this.isStale = this.isSettled)) {
-      notify(this, 'invalidated');
+      this.version++;
+      this._publish('invalidated');
     }
   }
 
@@ -189,7 +190,8 @@ export class ExecutorImpl<Value = any> implements Executor {
     this.value = value;
     this.timestamp = timestamp;
 
-    notify(this, 'fulfilled');
+    this.version++;
+    this._publish('fulfilled');
   }
 
   reject(reason: any, timestamp = Date.now()): void {
@@ -205,22 +207,23 @@ export class ExecutorImpl<Value = any> implements Executor {
     this.reason = reason;
     this.timestamp = timestamp;
 
-    notify(this, 'rejected');
+    this.version++;
+    this._publish('rejected');
   }
 
   activate(): () => void {
     let isActive = true;
 
     if (this._activeCount++ === 0) {
-      notify(this, 'activated');
+      this._publish('activated');
     }
 
     return () => {
       if (isActive) {
         isActive = false;
 
         if (--this._activeCount === 0) {
-          notify(this, 'deactivated');
+          this._publish('deactivated');
         }
       }
     };
@@ -241,9 +244,8 @@ export class ExecutorImpl<Value = any> implements Executor {
       timestamp: this.timestamp,
     };
   }
-}
 
-function notify(executor: ExecutorImpl, eventType: ExecutorEvent['type']): void {
-  executor.version++;
-  executor._pubSub.publish({ type: eventType, target: executor });
+  _publish(eventType: ExecutorEvent['type']): void {
+    this._pubSub.publish({ type: eventType, target: this, version: this.version });
+  }
 }

src/main/ExecutorManager.ts

@@ -93,7 +93,7 @@ export class ExecutorManager implements Iterable<Executor> {
 
     this._executors.set(key, executor);
 
-    executor._pubSub.publish({ type: 'configured', target: executor });
+    executor._publish('configured');
 
     if (initialValue === undefined || executor.isSettled || executor.isPending) {
       return executor;
@@ -149,7 +149,7 @@ export class ExecutorManager implements Iterable<Executor> {
 
     this._executors.delete(key);
 
-    executor._pubSub.publish({ type: 'disposed', target: executor });
+    executor._publish('disposed');
     executor._pubSub.unsubscribeAll();
 
     return true;

src/main/types.ts

@@ -108,6 +108,11 @@ export interface ExecutorEvent<Value = any> {
    * The executor for which the lifecycle event has occurred.
    */
   target: Executor<Value>;
+
+  /**
+   * The version of the executor for which this event was published.
+   */
+  version: number;
 }
 
 /**
@@ -204,7 +209,8 @@ export interface Executor<Value = any> extends ExecutorState<Value> {
   readonly latestTask: ExecutorTask<Value> | null;
 
   /**
-   * The integer version that is incremented every time the executor is mutated.
+   * The integer version of {@link ExecutorState the state of this executor} that is incremented every time it is
+   * mutated.
    */
   readonly version: number;
 

src/main/utils.ts

@@ -12,7 +12,3 @@ export function isMatchingPeerKey(keys: Array<RegExp | string>, peerKey: string)
   }
   return false;
 }
-
-export function definePrivateProperty<T, K extends keyof T>(executor: T, key: K, value: T[K]): void {
-  Object.defineProperty(executor, key, { value, configurable: true, writable: true });
-}