@splitsoftware/splitio-commons 1.4.1 → 1.4.2-rc.2

package/src/storages/inMemory/InMemoryStorage.ts

@@ -6,6 +6,8 @@ import { IStorageFactoryParams, IStorageSync } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { SplitIO } from '../../types';
+import { setToArray, ISet } from '../../utils/lang/sets';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -29,7 +31,20 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
-    }
+    },
+
+    // @ts-ignore, private method, for POC
+    getSnapshot(): SplitIO.PreloadedData {
+      return {
+        lastUpdated: Date.now(), // @ts-ignore accessing private prop
+        since: this.splits.changeNumber, // @ts-ignore accessing private prop
+        splitsData: this.splits.splitsCache, // @ts-ignore accessing private prop
+        segmentsData: Object.keys(this.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
+          prev[cur] = setToArray(this.segments.segmentCache[cur] as ISet<string>);
+          return prev;
+        }, {})
+      };
+    },
   };
 }
 

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -6,6 +6,7 @@ import { IStorageSync, IStorageFactoryParams } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { SplitIO } from '../../types';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -31,6 +32,18 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       this.events.clear();
     },
 
+    // @ts-ignore, private method, for POC
+    getSnapshot(): SplitIO.PreloadedData {
+      return {
+        lastUpdated: Date.now(), // @ts-ignore accessing private prop
+        since: this.splits.changeNumber, // @ts-ignore accessing private prop
+        splitsData: this.splits.splitsCache,
+        mySegmentsData: { // @ts-ignore accessing private prop
+          [params.matchingKey as string]: Object.keys(this.segments.segmentCache)
+        }
+      };
+    },
+
     // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
     shared() {
       return {

package/src/sync/submitters/submitterManager.ts

@@ -1,11 +1,11 @@
-import { syncTaskComposite } from '../syncTaskComposite';
 import { eventsSubmitterFactory } from './eventsSubmitter';
 import { impressionsSubmitterFactory } from './impressionsSubmitter';
 import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { ISubmitterManager } from './types';
 
-export function submitterManagerFactory(params: ISdkFactoryContextSync) {
+export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager {
 
   const submitters = [
     impressionsSubmitterFactory(params),
@@ -15,7 +15,33 @@ export function submitterManagerFactory(params: ISdkFactoryContextSync) {
   const impressionCountsSubmitter = impressionCountsSubmitterFactory(params);
   if (impressionCountsSubmitter) submitters.push(impressionCountsSubmitter);
   const telemetrySubmitter = telemetrySubmitterFactory(params);
-  if (telemetrySubmitter) submitters.push(telemetrySubmitter);
 
-  return syncTaskComposite(submitters);
+  return {
+    // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
+    start(onlyTelemetry?: boolean) {
+      if (!onlyTelemetry) submitters.forEach(submitter => submitter.start());
+      if (telemetrySubmitter) telemetrySubmitter.start();
+    },
+
+    // `allExceptTelemetry` true if userConsent is changed to DECLINED
+    stop(allExceptTelemetry?: boolean) {
+      submitters.forEach(submitter => submitter.stop());
+      if (!allExceptTelemetry && telemetrySubmitter) telemetrySubmitter.stop();
+    },
+
+    isRunning() {
+      return submitters.some(submitter => submitter.isRunning());
+    },
+
+    // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
+    execute(onlyTelemetry?: boolean) {
+      const promises = onlyTelemetry ? [] : submitters.map(submitter => submitter.execute());
+      if (telemetrySubmitter) promises.push(telemetrySubmitter.execute());
+      return Promise.all(promises);
+    },
+
+    isExecuting() {
+      return submitters.some(submitter => submitter.isExecuting());
+    }
+  };
 }

package/src/sync/submitters/types.ts

@@ -1,5 +1,6 @@
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
+import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
   /** Split name */
@@ -191,3 +192,9 @@ export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
   i?: Array<string>, // integrations
   uC: number, // userConsent
 }
+
+export interface ISubmitterManager extends ISyncTask {
+  start(onlyTelemetry?: boolean): void,
+  stop(allExceptTelemetry?: boolean): void,
+  execute(onlyTelemetry?: boolean): Promise<any>
+}

package/src/sync/syncManagerOnline.ts

@@ -28,19 +28,19 @@ export function syncManagerOnlineFactory(
    */
   return function (params: ISdkFactoryContextSync): ISyncManagerCS {
 
-    const { settings, settings: { log, streamingEnabled }, telemetryTracker } = params;
+    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled, onlySubmitters } },  telemetryTracker } = params;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
+    const pollingManager = onlySubmitters ? undefined : pollingManagerFactory && pollingManagerFactory(params);
 
     /** Push Manager */
-    const pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+    const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
       pushManagerFactory(params, pollingManager) :
       undefined;
 
     /** Submitter Manager */
     // It is not inyected as push and polling managers, because at the moment it is required
-    const submitter = submitterManagerFactory(params);
+    const submitterManager = submitterManagerFactory(params);
 
     /** Sync Manager logic */
 
@@ -79,7 +79,7 @@ export function syncManagerOnlineFactory(
       // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).
       pollingManager,
       pushManager,
-      submitter,
+      submitterManager,
 
       /**
        * Method used to start the syncManager for the first time, or resume it after being stopped.
@@ -89,20 +89,29 @@ export function syncManagerOnlineFactory(
 
         // start syncing splits and segments
         if (pollingManager) {
-          if (pushManager) {
-            // Doesn't call `syncAll` when the syncManager is resuming
+
+          // If synchronization is disabled pushManager and pollingManager should not start
+          if (syncEnabled) {
+            if (pushManager) {
+              // Doesn't call `syncAll` when the syncManager is resuming
+              if (startFirstTime) {
+                pollingManager.syncAll();
+                startFirstTime = false;
+              }
+              pushManager.start();
+            } else {
+              pollingManager.start();
+            }
+          } else {
             if (startFirstTime) {
               pollingManager.syncAll();
               startFirstTime = false;
             }
-            pushManager.start();
-          } else {
-            pollingManager.start();
           }
         }
 
         // start periodic data recording (events, impressions, telemetry).
-        if (isConsentGranted(settings)) submitter.start();
+        submitterManager.start(!isConsentGranted(settings));
       },
 
       /**
@@ -116,7 +125,7 @@ export function syncManagerOnlineFactory(
         if (pollingManager && pollingManager.isRunning()) pollingManager.stop();
 
         // stop periodic data recording (events, impressions, telemetry).
-        submitter.stop();
+        submitterManager.stop();
       },
 
       isRunning() {
@@ -124,8 +133,7 @@ export function syncManagerOnlineFactory(
       },
 
       flush() {
-        if (isConsentGranted(settings)) return submitter.execute();
-        else return Promise.resolve();
+        return submitterManager.execute(!isConsentGranted(settings));
       },
 
       // [Only used for client-side]
@@ -138,18 +146,22 @@ export function syncManagerOnlineFactory(
         return {
           isRunning: mySegmentsSyncTask.isRunning,
           start() {
-            if (pushManager) {
-              if (pollingManager!.isRunning()) {
-                // if doing polling, we must start the periodic fetch of data
-                if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
+            if (syncEnabled) {
+              if (pushManager) {
+                if (pollingManager!.isRunning()) {
+                  // if doing polling, we must start the periodic fetch of data
+                  if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
+                } else {
+                  // if not polling, we must execute the sync task for the initial fetch
+                  // of segments since `syncAll` was already executed when starting the main client
+                  mySegmentsSyncTask.execute();
+                }
+                pushManager.add(matchingKey, mySegmentsSyncTask);
               } else {
-                // if not polling, we must execute the sync task for the initial fetch
-                // of segments since `syncAll` was already executed when starting the main client
-                mySegmentsSyncTask.execute();
+                if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
               }
-              pushManager.add(matchingKey, mySegmentsSyncTask);
             } else {
-              if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
+              if (!readinessManager.isReady()) mySegmentsSyncTask.execute();
             }
           },
           stop() {

package/src/sync/syncTask.ts

@@ -4,8 +4,8 @@ import { ISyncTask } from './types';
 
 /**
  * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
- * The task can be executed once calling the "execute" method.
- * NOTE: Multiple calls to "execute" are not queued. Use "isExecuting" method to handle synchronization.
+ * The task can be also executed by calling the "execute" method. Multiple execute calls are chained to run secuentially and avoid race conditions.
+ * For example, submitters executed on SDK destroy or full queue, while periodic execution is pending.
  *
  * @param log  Logger instance.
  * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
@@ -15,8 +15,8 @@ import { ISyncTask } from './types';
  */
 export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName = 'task'): ISyncTask<Input, Output> {
 
-  // Flag that indicates if the task is being executed
-  let executing = false;
+  // Task promise while it is pending. Undefined once the promise is resolved
+  let pendingTask: Promise<Output> | undefined;
   // flag that indicates if the task periodic execution has been started/stopped.
   let running = false;
   // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
@@ -26,14 +26,21 @@ export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger,
   // Id of the periodic call timeout
   let timeoutID: any;
 
-  function execute(...args: Input) {
-    executing = true;
+  function execute(...args: Input): Promise<Output> {
+    // If task is executing, chain the new execution
+    if (pendingTask) {
+      return pendingTask.then(() => {
+        return execute(...args);
+      });
+    }
+
+    // Execute task
     log.debug(SYNC_TASK_EXECUTE, [taskName]);
-    return task(...args).then(result => {
-      executing = false;
+    pendingTask = task(...args).then(result => {
+      pendingTask = undefined;
       return result;
     });
-    // No need to handle promise rejection because it is a pre-condition that provided task never rejects.
+    return pendingTask;
   }
 
   function periodicExecute(currentRunningId: number) {
@@ -46,11 +53,10 @@ export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger,
   }
 
   return {
-    // @TODO check if we need to queued `execute` calls, to avoid possible race conditions on submitters and updaters with streaming.
     execute,
 
     isExecuting() {
-      return executing;
+      return pendingTask !== undefined;
     },
 
     start(...args: Input) {

package/src/sync/types.ts

@@ -2,6 +2,7 @@ import { IReadinessManager } from '../readiness/types';
 import { IStorageSync } from '../storages/types';
 import { IPollingManager } from './polling/types';
 import { IPushManager } from './streaming/types';
+import { ISubmitterManager } from './submitters/types';
 
 export interface ITask<Input extends any[] = []> {
   /**
@@ -39,7 +40,7 @@ export interface ISyncManager extends ITask {
   flush(): Promise<any>,
   pushManager?: IPushManager,
   pollingManager?: IPollingManager,
-  submitter?: ISyncTask
+  submitterManager?: ISubmitterManager
 }
 
 export interface ISyncManagerCS extends ISyncManager {

package/src/trackers/impressionObserver/impressionObserverCS.ts

@@ -4,7 +4,7 @@ import { buildKey } from './buildKey';
 import { ImpressionDTO } from '../../types';
 
 export function hashImpression32(impression: ImpressionDTO) {
-  return hash(buildKey(impression));
+  return hash(buildKey(impression)).toString();
 }
 
 const LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes

package/src/types.ts

@@ -4,7 +4,7 @@ import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
 /* eslint-disable no-use-before-define */
 
-import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
+import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory, DataLoader } from './storages/types';
 import { ISyncManagerCS } from './sync/types';
 
 /**
@@ -98,6 +98,7 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
+  readonly dataLoader?: DataLoader,
   readonly integrations: Array<{
     readonly type: string,
     (params: IIntegrationFactoryParams): IIntegration | void
@@ -117,7 +118,9 @@ export interface ISettings {
     splitFilters: SplitIO.SplitFilter[],
     impressionsMode: SplitIO.ImpressionsMode,
     __splitFiltersValidation: ISplitFiltersValidation,
-    localhostMode?: SplitIO.LocalhostFactory
+    localhostMode?: SplitIO.LocalhostFactory,
+    enabled: boolean,
+    onlySubmitters: boolean
   },
   readonly runtime: {
     ip: string | false
@@ -214,6 +217,11 @@ interface ISharedSettings {
      * @default 'OPTIMIZED'
      */
     impressionsMode?: SplitIO.ImpressionsMode,
+    /**
+     * Enables synchronization.
+     * @property {boolean} enabled
+     */
+    enabled: boolean
   }
 }
 /**
@@ -746,7 +754,7 @@ export namespace SplitIO {
      * This property is ignored if `mySegmentsData` was provided.
      */
     segmentsData?: {
-      [segmentName: string]: string
+      [segmentName: string]: string[]
     },
   }
   /**

package/src/utils/settingsValidation/index.ts

@@ -83,7 +83,8 @@ export const base = {
     splitFilters: undefined,
     // impressions collection mode
     impressionsMode: OPTIMIZED,
-    localhostMode: undefined
+    localhostMode: undefined,
+    enabled: true
   },
 
   // Logger
@@ -146,6 +147,9 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // ensure a valid SDK mode
   // @ts-ignore, modify readonly prop
   withDefaults.mode = mode(withDefaults.core.authorizationKey, withDefaults.mode);
+  if (withDefaults.sync.onlySubmitters && withDefaults.mode === STANDALONE_MODE && !withDefaults.dataLoader) {
+    throw new Error('To use `onlySubmitters` param in standalone mode, DataLoader is required to preload data into the storage');
+  }
 
   // ensure a valid Storage based on mode defined.
   // @ts-ignore, modify readonly prop
@@ -191,6 +195,16 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
     scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);
   }
 
+  // validate sync enabled
+  if (withDefaults.sync.enabled !== false) {
+    withDefaults.sync.enabled = true;
+  }
+
+  // validate sync onlySubmitters
+  if (withDefaults.sync.onlySubmitters !== true) {
+    withDefaults.sync.onlySubmitters = false;
+  }
+
   // validate the `splitFilters` settings and parse splits query
   const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
   withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;

package/types/integrations/ga/autoRequire.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Auto-require script to use with GaToSplit integration
+ */
+export declare function autoRequire(): void;

package/types/storages/dataLoader.d.ts

@@ -1,10 +1,10 @@
 import { SplitIO } from '../types';
 import { DataLoader } from './types';
 /**
- * Factory of client-side storage loader
+ * Factory of storage loader
  *
  * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
  * and extended with a `mySegmentsData` property.
  * @returns function to preload the storage
  */
-export declare function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;
+export declare function DataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;

package/types/sync/submitters/submitterManager.d.ts

@@ -1,2 +1,3 @@
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-export declare function submitterManagerFactory(params: ISdkFactoryContextSync): import("../types").ISyncTask<[], any>;
+import { ISubmitterManager } from './types';
+export declare function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager;

package/types/sync/submitters/types.d.ts

@@ -1,5 +1,6 @@
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
+import { ISyncTask } from '../types';
 export declare type ImpressionsPayload = {
     /** Split name */
     f: string;
@@ -169,3 +170,8 @@ export declare type TelemetryConfigStatsPayload = TelemetryConfigStats & {
     i?: Array<string>;
     uC: number;
 };
+export interface ISubmitterManager extends ISyncTask {
+    start(onlyTelemetry?: boolean): void;
+    stop(allExceptTelemetry?: boolean): void;
+    execute(onlyTelemetry?: boolean): Promise<any>;
+}

package/types/sync/syncTask.d.ts

@@ -2,8 +2,8 @@ import { ILogger } from '../logger/types';
 import { ISyncTask } from './types';
 /**
  * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
- * The task can be executed once calling the "execute" method.
- * NOTE: Multiple calls to "execute" are not queued. Use "isExecuting" method to handle synchronization.
+ * The task can be also executed by calling the "execute" method. Multiple execute calls are chained to run secuentially and avoid race conditions.
+ * For example, submitters executed on SDK destroy or full queue, while periodic execution is pending.
  *
  * @param log  Logger instance.
  * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.

package/types/sync/types.d.ts

@@ -2,6 +2,7 @@ import { IReadinessManager } from '../readiness/types';
 import { IStorageSync } from '../storages/types';
 import { IPollingManager } from './polling/types';
 import { IPushManager } from './streaming/types';
+import { ISubmitterManager } from './submitters/types';
 export interface ITask<Input extends any[] = []> {
     /**
      * Start periodic execution of the task
@@ -35,7 +36,7 @@ export interface ISyncManager extends ITask {
     flush(): Promise<any>;
     pushManager?: IPushManager;
     pollingManager?: IPollingManager;
-    submitter?: ISyncTask;
+    submitterManager?: ISubmitterManager;
 }
 export interface ISyncManagerCS extends ISyncManager {
     shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined;

package/types/trackers/impressionObserver/impressionObserverCS.d.ts

@@ -1,4 +1,4 @@
 import { ImpressionObserver } from './ImpressionObserver';
 import { ImpressionDTO } from '../../types';
-export declare function hashImpression32(impression: ImpressionDTO): number;
-export declare function impressionObserverCSFactory(): ImpressionObserver<number>;
+export declare function hashImpression32(impression: ImpressionDTO): string;
+export declare function impressionObserverCSFactory(): ImpressionObserver<string>;

package/types/types.d.ts

@@ -2,7 +2,7 @@ import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
-import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
+import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory, DataLoader } from './storages/types';
 import { ISyncManagerCS } from './sync/types';
 /**
  * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
@@ -92,6 +92,7 @@ export interface ISettings {
         eventsFirstPushWindow: number;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
+    readonly dataLoader?: DataLoader;
     readonly integrations: Array<{
         readonly type: string;
         (params: IIntegrationFactoryParams): IIntegration | void;
@@ -112,6 +113,8 @@ export interface ISettings {
         impressionsMode: SplitIO.ImpressionsMode;
         __splitFiltersValidation: ISplitFiltersValidation;
         localhostMode?: SplitIO.LocalhostFactory;
+        enabled: boolean;
+        onlySubmitters: boolean;
     };
     readonly runtime: {
         ip: string | false;
@@ -208,6 +211,11 @@ interface ISharedSettings {
          * @default 'OPTIMIZED'
          */
         impressionsMode?: SplitIO.ImpressionsMode;
+        /**
+         * Enables synchronization.
+         * @property {boolean} enabled
+         */
+        enabled: boolean;
     };
 }
 /**
@@ -743,7 +751,7 @@ export declare namespace SplitIO {
          * This property is ignored if `mySegmentsData` was provided.
          */
         segmentsData?: {
-            [segmentName: string]: string;
+            [segmentName: string]: string[];
         };
     }
     /**

package/types/utils/settingsValidation/index.d.ts

@@ -37,6 +37,7 @@ export declare const base: {
         splitFilters: undefined;
         impressionsMode: string;
         localhostMode: undefined;
+        enabled: boolean;
     };
     log: undefined;
 };

package/cjs/sync/syncTaskComposite.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncTaskComposite = void 0;
-/**
- * Composite Sync Task: group of sync tasks that are treated as a single one.
- */
-function syncTaskComposite(syncTasks) {
-    return {
-        start: function () {
-            syncTasks.forEach(function (syncTask) { return syncTask.start(); });
-        },
-        stop: function () {
-            syncTasks.forEach(function (syncTask) { return syncTask.stop(); });
-        },
-        isRunning: function () {
-            return syncTasks.some(function (syncTask) { return syncTask.isRunning(); });
-        },
-        execute: function () {
-            return Promise.all(syncTasks.map(function (syncTask) { return syncTask.execute(); }));
-        },
-        isExecuting: function () {
-            return syncTasks.some(function (syncTask) { return syncTask.isExecuting(); });
-        }
-    };
-}
-exports.syncTaskComposite = syncTaskComposite;

package/esm/sync/syncTaskComposite.js

@@ -1,22 +0,0 @@
-/**
- * Composite Sync Task: group of sync tasks that are treated as a single one.
- */
-export function syncTaskComposite(syncTasks) {
-    return {
-        start: function () {
-            syncTasks.forEach(function (syncTask) { return syncTask.start(); });
-        },
-        stop: function () {
-            syncTasks.forEach(function (syncTask) { return syncTask.stop(); });
-        },
-        isRunning: function () {
-            return syncTasks.some(function (syncTask) { return syncTask.isRunning(); });
-        },
-        execute: function () {
-            return Promise.all(syncTasks.map(function (syncTask) { return syncTask.execute(); }));
-        },
-        isExecuting: function () {
-            return syncTasks.some(function (syncTask) { return syncTask.isExecuting(); });
-        }
-    };
-}

package/src/sync/syncTaskComposite.ts

@@ -1,26 +0,0 @@
-import { ISyncTask } from './types';
-
-/**
- * Composite Sync Task: group of sync tasks that are treated as a single one.
- */
-export function syncTaskComposite(syncTasks: ISyncTask[]): ISyncTask {
-
-  return {
-    start() {
-      syncTasks.forEach(syncTask => syncTask.start());
-    },
-    stop() {
-      syncTasks.forEach(syncTask => syncTask.stop());
-    },
-    isRunning() {
-      return syncTasks.some(syncTask => syncTask.isRunning());
-    },
-    execute() {
-      return Promise.all(syncTasks.map(syncTask => syncTask.execute()));
-    },
-    isExecuting() {
-      return syncTasks.some(syncTask => syncTask.isExecuting());
-    }
-  };
-
-}