Added retryFulfilled and retryRejected

README.md

@@ -68,7 +68,7 @@ unsubscribe();
 ```ts
 useExecutor(`order-${orderId}`, initialValue, [
   // Persists the executor value in the synchronous storage.
-  syncStorage(localStorage),
+  synchronizeStorage(localStorage),
 
   // Instantly aborts pending task when executor is deactivated (has no active consumers). 
   abortDeactivated(),

src/main/ExecutorImpl.ts

@@ -150,6 +150,7 @@ export class ExecutorImpl<Value = any> implements Executor {
     if (this.isSettled) {
       this.isFulfilled = this.isRejected = this.isStale = false;
       this.value = this.reason = undefined;
+      this.timestamp = 0;
       this._pubSub.publish({ type: 'cleared', target: this });
     }
     return this;
@@ -185,7 +186,6 @@ export class ExecutorImpl<Value = any> implements Executor {
     this.isFulfilled = true;
     this.isRejected = this.isStale = false;
     this.value = value;
-    this.reason = undefined;
     this.timestamp = timestamp;
 
     this._pubSub.publish({ type: 'fulfilled', target: this });
@@ -203,7 +203,6 @@ export class ExecutorImpl<Value = any> implements Executor {
 
     this.isFulfilled = this.isStale = false;
     this.isRejected = true;
-    this.value = undefined;
     this.reason = reason;
     this.timestamp = timestamp;
 

src/main/plugin/abortDeactivated.ts

@@ -11,18 +11,17 @@ export default function abortDeactivated(ms = 0): ExecutorPlugin {
 
     executor.subscribe(event => {
       switch (event.type) {
-        case 'activated':
-        case 'disposed':
-          clearTimeout(timer);
-          break;
-
         case 'deactivated':
           clearTimeout(timer);
 
           timer = setTimeout(() => {
             executor.abort();
           }, ms);
           break;
+
+        case 'activated':
+          clearTimeout(timer);
+          break;
       }
     });
   };

src/main/plugin/disposeDeactivated.ts

@@ -5,24 +5,23 @@ import type { ExecutorPlugin } from '../types';
  *
  * @param ms The timeout in milliseconds after which the executor is disposed.
  */
-export default function disposeDeactivated(ms = 0): ExecutorPlugin {
+export default function disposeDeactivated(ms = 5_000): ExecutorPlugin {
   return executor => {
     let timer: NodeJS.Timeout;
 
     executor.subscribe(event => {
       switch (event.type) {
-        case 'activated':
-        case 'disposed':
-          clearTimeout(timer);
-          break;
-
         case 'deactivated':
           clearTimeout(timer);
 
           timer = setTimeout(() => {
             executor.manager.dispose(executor.key);
           }, ms);
           break;
+
+        case 'activated':
+          clearTimeout(timer);
+          break;
       }
     });
   };

src/main/plugin/invalidateAfter.ts

@@ -11,19 +11,22 @@ export default function invalidateAfter(ms: number): ExecutorPlugin {
 
     executor.subscribe(event => {
       switch (event.type) {
+        case 'activated':
         case 'fulfilled':
         case 'rejected':
           clearTimeout(timer);
 
-          timer = setTimeout(
-            () => {
-              executor.invalidate();
-            },
-            ms - Date.now() + executor.timestamp
-          );
+          if (!executor.isPending && executor.isActive && executor.isSettled) {
+            timer = setTimeout(
+              () => {
+                executor.invalidate();
+              },
+              ms - Date.now() + executor.timestamp
+            );
+          }
           break;
 
-        case 'disposed':
+        case 'deactivated':
           clearTimeout(timer);
           break;
       }

src/main/plugin/invalidateByPeers.ts

@@ -8,11 +8,11 @@ import type { ExecutorPlugin } from '../types';
 export default function invalidateByPeers(keys: Array<RegExp | string>): ExecutorPlugin {
   return executor => {
     const unsubscribe = executor.manager.subscribe(event => {
-      const targetKey = event.target.key;
+      const peerKey = event.target.key;
 
       if (
         (event.type === 'invalidated' || event.type === 'fulfilled') &&
-        keys.some(key => (typeof key === 'string' ? key === targetKey : key.test(targetKey)))
+        keys.some(key => (typeof key === 'string' ? key === peerKey : key.test(peerKey)))
       ) {
         executor.invalidate();
       }

src/main/plugin/retryFocused.ts

@@ -13,18 +13,22 @@ const plugin: ExecutorPlugin = executor => {
   }
 
   const handleFocus = () => {
-    if (window.document.visibilityState === 'visible' && executor.isActive) {
+    if (window.document.visibilityState === 'visible') {
       executor.retry();
     }
   };
 
-  window.addEventListener('visibilitychange', handleFocus, false);
-  window.addEventListener('focus', handleFocus, false);
-
   executor.subscribe(event => {
-    if (event.type === 'disposed') {
-      window.removeEventListener('visibilitychange', handleFocus, false);
-      window.removeEventListener('focus', handleFocus, false);
+    switch (event.type) {
+      case 'activated':
+        window.addEventListener('visibilitychange', handleFocus, false);
+        window.addEventListener('focus', handleFocus, false);
+        break;
+
+      case 'deactivated':
+        window.removeEventListener('visibilitychange', handleFocus, false);
+        window.removeEventListener('focus', handleFocus, false);
+        break;
     }
   });
 };

src/main/plugin/retryFulfilled.ts

@@ -0,0 +1,44 @@
+import type { Executor, ExecutorPlugin } from '../types';
+
+/**
+ * Repeats the last task after the execution was fulfilled.
+ *
+ * @param count The number of repetitions.
+ * @param ms The delay in milliseconds after which the repetition is scheduled.
+ * @template Value The value stored by the executor.
+ */
+export default function retryFulfilled<Value = any>(
+  count = Infinity,
+  ms: number | ((index: number, executor: Executor<Value>) => number) = 5_000
+): ExecutorPlugin<Value> {
+  return executor => {
+    let timer: NodeJS.Timeout;
+    let index = 0;
+
+    executor.subscribe(event => {
+      switch (event.type) {
+        case 'activated':
+        case 'fulfilled':
+          clearTimeout(timer);
+
+          if (!executor.isPending && executor.isActive && executor.isFulfilled && index < count) {
+            timer = setTimeout(
+              () => {
+                index++;
+                executor.retry();
+              },
+              (typeof ms === 'function' ? ms(index, executor) : ms) - Date.now() + executor.timestamp
+            );
+          }
+          break;
+
+        case 'rejected':
+        case 'aborted':
+        case 'deactivated':
+          index = 0;
+          clearTimeout(timer);
+          break;
+      }
+    });
+  };
+}

src/main/plugin/retryRejected.ts

@@ -0,0 +1,48 @@
+import type { Executor, ExecutorPlugin } from '../types';
+
+/**
+ * Retries the last task after the execution has failed.
+ *
+ * @param count The number of times the task must be repeated if rejected.
+ * @param ms The delay in milliseconds after which the retry is scheduled.
+ * @template Value The value stored by the executor.
+ */
+export default function retryRejected<Value = any>(
+  count = 3,
+  ms: number | ((index: number, executor: Executor<Value>) => number) = exponentialDelay
+): ExecutorPlugin<Value> {
+  return executor => {
+    let timer: NodeJS.Timeout;
+    let index = 0;
+
+    executor.subscribe(event => {
+      switch (event.type) {
+        case 'activated':
+        case 'rejected':
+          clearTimeout(timer);
+
+          if (!executor.isPending && executor.isActive && executor.isRejected && index < count) {
+            timer = setTimeout(
+              () => {
+                index++;
+                executor.retry();
+              },
+              (typeof ms === 'function' ? ms(index, executor) : ms) - Date.now() + executor.timestamp
+            );
+          }
+          break;
+
+        case 'fulfilled':
+        case 'aborted':
+        case 'deactivated':
+          index = 0;
+          clearTimeout(timer);
+          break;
+      }
+    });
+  };
+}
+
+function exponentialDelay(index: number): number {
+  return 1000 * 1.8 ** index;
+}

src/main/plugin/retryStale.ts

@@ -8,10 +8,6 @@ export default function retryStale(): ExecutorPlugin {
 }
 
 const plugin: ExecutorPlugin = executor => {
-  if (executor.isStale) {
-    executor.retry();
-  }
-
   executor.subscribe(event => {
     if ((event.type === 'invalidated' && executor.isActive) || (event.type === 'activated' && executor.isStale)) {
       executor.retry();