Added COUNTER mode for saga injectors

docs/api.md

@@ -203,6 +203,10 @@ An enum of all the possible saga injection behaviours
 -   `DAEMON` **[String][26]** Causes the saga to be started on component instantiation and never canceled
     or started again.
 -   `ONCE_TILL_UNMOUNT` **[String][26]** Behaves like 'RESTART_ON_REMOUNT' but never runs it again.
+-   `COUNTER` **[String][26]** The saga will be mounted similar to 'RESTART_ON_REMOUNT', only difference is that
+    saga will be mounted only once on first inject, and ejected when all injectors are unmounted.
+    So this enables you to have multiple injectors with same saga and key, only one instance of saga will run
+    and enables you to have system that are more similar to widgets
 
 [1]: #setup
 

index.d.ts

@@ -65,14 +65,19 @@ export function createInjectorsEnhancer(options: {
  * @property {String} DAEMON Causes the saga to be started on component instantiation and never canceled
  * or started again.
  * @property {String} ONCE_TILL_UNMOUNT Behaves like 'RESTART_ON_REMOUNT' but never runs it again.
+ * @property {String} COUNTER The saga will be mounted similar to 'RESTART_ON_REMOUNT', only difference is that
+ * saga will be mounted only once on first inject, and ejected when all injectors are unmounted.
+ * So this enables you to have multiple injectors with same saga and key, only one instance of saga will run
+ * and enables you to have system that are more similar to widgets
  *
  * @enum
  * @public
  */
 export enum SagaInjectionModes {
   RESTART_ON_REMOUNT = "@@saga-injector/restart-on-remount",
   DAEMON = "@@saga-injector/daemon",
-  ONCE_TILL_UNMOUNT = "@@saga-injector/once-till-unmount"
+  ONCE_TILL_UNMOUNT = "@@saga-injector/once-till-unmount",
+  COUNTER = "@@saga-injector/counter"
 }
 
 /**

src/constants.js

@@ -1,6 +1,9 @@
 export const RESTART_ON_REMOUNT = '@@saga-injector/restart-on-remount';
 export const DAEMON = '@@saga-injector/daemon';
 export const ONCE_TILL_UNMOUNT = '@@saga-injector/once-till-unmount';
+export const COUNTER = '@@saga-injector/counter';
+
+export const COUNTER_PROP = `${COUNTER}:value`;
 
 /**
  * An enum of all the possible saga injection behaviours
@@ -10,6 +13,10 @@ export const ONCE_TILL_UNMOUNT = '@@saga-injector/once-till-unmount';
  * @property {String} DAEMON Causes the saga to be started on component instantiation and never canceled
  * or started again.
  * @property {String} ONCE_TILL_UNMOUNT Behaves like 'RESTART_ON_REMOUNT' but never runs it again.
+ * @property {String} COUNTER The saga will be mounted similar to 'RESTART_ON_REMOUNT', only difference is that
+ * saga will be mounted only once on first inject, and ejected when all injectors are unmounted.
+ * So this enables you to have multiple injectors with same saga and key, only one instance of saga will run
+ * and enables you to have system that are more similar to widgets
  *
  * @enum
  * @public
@@ -18,4 +25,5 @@ export const SagaInjectionModes = {
   RESTART_ON_REMOUNT,
   DAEMON,
   ONCE_TILL_UNMOUNT,
+  COUNTER,
 };

src/sagaInjectors.js

@@ -2,12 +2,19 @@ import invariant from 'invariant';
 import isEmpty from 'lodash/isEmpty';
 import isFunction from 'lodash/isFunction';
 import isString from 'lodash/isString';
+import isNumber from 'lodash/isNumber';
 import conformsTo from 'lodash/conformsTo';
 
 import checkStore from './checkStore';
-import { DAEMON, ONCE_TILL_UNMOUNT, RESTART_ON_REMOUNT } from './constants';
+import {
+  DAEMON,
+  ONCE_TILL_UNMOUNT,
+  RESTART_ON_REMOUNT,
+  COUNTER,
+  COUNTER_PROP,
+} from './constants';
 
-const allowedModes = [RESTART_ON_REMOUNT, DAEMON, ONCE_TILL_UNMOUNT];
+const allowedModes = [RESTART_ON_REMOUNT, DAEMON, ONCE_TILL_UNMOUNT, COUNTER];
 
 const checkKey = key =>
   invariant(
@@ -19,6 +26,7 @@ const checkDescriptor = descriptor => {
   const shape = {
     saga: isFunction,
     mode: mode => isString(mode) && allowedModes.includes(mode),
+    [COUNTER_PROP]: isNumber,
   };
   invariant(
     conformsTo(descriptor, shape),
@@ -33,6 +41,7 @@ export function injectSagaFactory(store, isValid) {
     const newDescriptor = {
       ...descriptor,
       mode: descriptor.mode || DAEMON,
+      [COUNTER_PROP]: 0,
     };
     const { saga, mode } = newDescriptor;
 
@@ -50,16 +59,36 @@ export function injectSagaFactory(store, isValid) {
       }
     }
 
+    if (mode === COUNTER) {
+      // COUNTER must be added if saga is done
+      if (store.injectedSagas[key] === 'done') hasSaga = false;
+      let oldCounterValue = 0;
+      if (hasSaga) {
+        oldCounterValue = Math.max(
+          store.injectedSagas[key][COUNTER_PROP] || 0,
+          0,
+        );
+      }
+      newDescriptor[COUNTER_PROP] = oldCounterValue + 1;
+    }
+
     if (
       !hasSaga ||
-      (hasSaga && mode !== DAEMON && mode !== ONCE_TILL_UNMOUNT)
+      (hasSaga &&
+        mode !== DAEMON &&
+        mode !== ONCE_TILL_UNMOUNT &&
+        mode !== COUNTER)
     ) {
       /* eslint-disable no-param-reassign */
       store.injectedSagas[key] = {
         ...newDescriptor,
         task: store.runSaga(saga),
       };
       /* eslint-enable no-param-reassign */
+    } else if (hasSaga && mode === COUNTER) {
+      // increment num of sagas that wants to be injected
+      /* eslint-disable no-param-reassign */
+      store.injectedSagas[key][COUNTER_PROP] = newDescriptor[COUNTER_PROP];
     }
   };
 }
@@ -72,12 +101,31 @@ export function ejectSagaFactory(store, isValid) {
 
     if (Reflect.has(store.injectedSagas, key)) {
       const descriptor = store.injectedSagas[key];
-      if (descriptor.mode && descriptor.mode !== DAEMON) {
-        descriptor.task.cancel();
-        // Clean up in production; in development we need `descriptor.saga` for hot reloading
-        if (process.env.NODE_ENV === 'production') {
-          // Need some value to be able to detect `ONCE_TILL_UNMOUNT` sagas in `injectSaga`
-          store.injectedSagas[key] = 'done'; // eslint-disable-line no-param-reassign
+
+      if (descriptor.mode) {
+        if (descriptor.mode === COUNTER) {
+          descriptor[COUNTER_PROP] -= 1;
+
+          // don't cancel task if still not 0
+          if (descriptor[COUNTER_PROP] > 0) return;
+        }
+
+        if (descriptor.mode !== DAEMON) {
+          descriptor.task.cancel();
+          // Clean up in production; in development we need `descriptor.saga` for hot reloading
+          if (process.env.NODE_ENV === 'production') {
+            // Need some value to be able to detect `ONCE_TILL_UNMOUNT` sagas in `injectSaga`
+            store.injectedSagas[key] = 'done'; // eslint-disable-line no-param-reassign
+          }
+
+          // Clean up in development when mode is COUNTER
+          if (
+            process.env.NODE_ENV !== 'production' &&
+            descriptor.mode === COUNTER
+          ) {
+            delete store.injectedSagas[key];
+            // only problem with this approach is that in development will have 'undefined' value
+          }
         }
       }
     }

src/tests/sagaInjectors.test.js

@@ -10,7 +10,13 @@ import getInjectors, {
   injectSagaFactory,
   ejectSagaFactory,
 } from '../sagaInjectors';
-import { DAEMON, ONCE_TILL_UNMOUNT, RESTART_ON_REMOUNT } from '../constants';
+import {
+  COUNTER,
+  DAEMON,
+  ONCE_TILL_UNMOUNT,
+  RESTART_ON_REMOUNT,
+  COUNTER_PROP,
+} from '../constants';
 import { createInjectorsEnhancer } from '../createInjectorsEnhancer';
 
 function configureStore() {
@@ -174,6 +180,9 @@ describe('injectors', () => {
       expect(() =>
         injectSaga('test', { saga: testSaga, mode: ONCE_TILL_UNMOUNT }),
       ).not.toThrow();
+      expect(() =>
+        injectSaga('test', { saga: testSaga, mode: COUNTER }),
+      ).not.toThrow();
     });
 
     it('should not start daemon and once-till-unmount sagas if were started before', () => {
@@ -183,8 +192,11 @@ describe('injectors', () => {
       injectSaga('test1', { saga: testSaga, mode: DAEMON });
       injectSaga('test2', { saga: testSaga, mode: ONCE_TILL_UNMOUNT });
       injectSaga('test2', { saga: testSaga, mode: ONCE_TILL_UNMOUNT });
+      injectSaga('test3', { saga: testSaga, mode: COUNTER });
+      injectSaga('test3', { saga: testSaga, mode: COUNTER });
+      injectSaga('test3', { saga: testSaga, mode: COUNTER });
 
-      expect(store.runSaga).toHaveBeenCalledTimes(2);
+      expect(store.runSaga).toHaveBeenCalledTimes(3);
     });
 
     it('should start any saga that was not started before', () => {
@@ -235,5 +247,57 @@ describe('injectors', () => {
       injectSaga('test', { saga: testSaga, foo: 'bar' });
       expect(store.injectedSagas.test.foo).toBe('bar');
     });
+
+    it('should have correctly counter value in injectedSagas for COUNTER mode', () => {
+      function* testSaga1() {
+        yield put({ type: 'TEST', payload: 'yup' });
+      }
+
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      expect(store.injectedSagas.test[COUNTER_PROP]).toBe(1);
+
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      expect(store.injectedSagas.test[COUNTER_PROP]).toBe(2);
+
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      ejectSaga('test');
+      expect(store.injectedSagas.test[COUNTER_PROP]).toBe(2);
+
+      ejectSaga('test');
+      ejectSaga('test');
+      expect(store.injectedSagas.test).toBe(undefined);
+    });
+
+    it('should handle injection after ejecting all sagas', () => {
+      function* testSaga1() {
+        yield put({ type: 'TEST', payload: 'yup' });
+      }
+
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      ejectSaga('test');
+      ejectSaga('test');
+      expect(store.injectedSagas.test).toBe(undefined);
+
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      expect(store.injectedSagas.test[COUNTER_PROP]).toBe(1);
+    });
+
+    it('should not behave differently in production for COUNTER mode', () => {
+      process.env.NODE_ENV = 'production';
+      function* testSaga1() {
+        yield put({ type: 'TEST', payload: 'yup' });
+      }
+
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      ejectSaga('test');
+      ejectSaga('test');
+      expect(store.injectedSagas.test).toBe('done');
+
+      injectSaga('test', { saga: testSaga1, mode: COUNTER });
+      expect(store.injectedSagas.test[COUNTER_PROP]).toBe(1);
+      process.env.NODE_ENV = originalNodeEnv;
+    });
   });
 });