@splitsoftware/splitio-commons 1.4.2-rc.3 → 1.4.2-rc.4

package/CHANGES.txt

@@ -1,7 +1,7 @@
-1.5.0 (June 24, 2022)
-- Added a new config option to control the tasks that listen or poll for updates on feature flags and segments, via the new config sync.enabled . Running online Split will always pull the most recent updates upon initialization, this only affects updates fetching on a running instance. Useful when a consistent session experience is a must or to save resources when updates are not being used.
-- Updated telemetry logic to track the anonymous config for user consent flag set to declined or unknown.
-- Updated submitters logic, to avoid duplicating the post of impressions to Split cloud when the SDK is destroyed while its periodic post of impressions is running.
+1.4.2 (June XX, 2022)
+ - Added `sync.enabled` property to SDK configuration to allow synchronize splits and segments only once.
+ - Updated telemetry to submit data even if user consent is not granted.
+ - Updated submitters logic, to avoid duplicating the post of impressions to Split cloud when the SDK is destroyed while performing its periodic post of impressions.
 
 1.4.1 (June 13, 2022)
  - Bugfixing - Updated submitters logic, to avoid dropping impressions and events that are being tracked while POST request is pending.

package/cjs/listeners/browser.js

@@ -8,11 +8,12 @@ var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
 var telemetrySubmitter_1 = require("../sync/submitters/telemetrySubmitter");
-// 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+var VISIBILITYCHANGE_EVENT = 'visibilitychange';
+var PAGEHIDE_EVENT = 'pagehide';
 var UNLOAD_DOM_EVENT = 'unload';
 var EVENT_NAME = 'for unload page event.';
 /**
- * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
+ * We'll listen for events over the window object.
  */
 var BrowserSignalListener = /** @class */ (function () {
     function BrowserSignalListener(syncManager, settings, storage, serviceApi) {
@@ -21,30 +22,43 @@ var BrowserSignalListener = /** @class */ (function () {
         this.storage = storage;
         this.serviceApi = serviceApi;
         this.flushData = this.flushData.bind(this);
+        this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
+        this.stopSync = this.stopSync.bind(this);
         this.fromImpressionsCollector = impressionsSubmitter_1.fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
     }
     /**
      * start method.
-     * Called when SplitFactory is initialized.
-     * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
+     * Called when SplitFactory is initialized, it adds event listeners to close streaming and flush impressions and events.
      */
     BrowserSignalListener.prototype.start = function () {
         if (typeof window !== 'undefined' && window.addEventListener) {
             this.settings.log.debug(constants_2.CLEANUP_REGISTERING, [EVENT_NAME]);
-            window.addEventListener(UNLOAD_DOM_EVENT, this.flushData);
+            // Flush data whenever the page is hidden or unloaded.
+            window.addEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+            // Some browsers like Safari does not fire the `visibilitychange` event when the page is being unloaded. So we also flush data in the `pagehide` event.
+            // If both events are triggered, the last one will find the storage empty, so no duplicated data will be submitted.
+            window.addEventListener(PAGEHIDE_EVENT, this.flushData);
+            // Stop streaming on 'unload' event. Used instead of 'beforeunload', because 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+            window.addEventListener(UNLOAD_DOM_EVENT, this.stopSync);
         }
     };
     /**
      * stop method.
-     * Called when client is destroyed.
-     * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
+     * Called when client is destroyed, it removes event listeners.
      */
     BrowserSignalListener.prototype.stop = function () {
         if (typeof window !== 'undefined' && window.removeEventListener) {
             this.settings.log.debug(constants_2.CLEANUP_DEREGISTERING, [EVENT_NAME]);
-            window.removeEventListener(UNLOAD_DOM_EVENT, this.flushData);
+            window.removeEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+            window.removeEventListener(PAGEHIDE_EVENT, this.flushData);
+            window.removeEventListener(UNLOAD_DOM_EVENT, this.stopSync);
         }
     };
+    BrowserSignalListener.prototype.stopSync = function () {
+        // Close streaming connection
+        if (this.syncManager && this.syncManager.pushManager)
+            this.syncManager.pushManager.stop();
+    };
     /**
      * flushData method.
      * Called when unload event is triggered. It flushed remaining impressions and events to the backend,
@@ -71,9 +85,10 @@ var BrowserSignalListener = /** @class */ (function () {
             var telemetryCacheAdapter = (0, telemetrySubmitter_1.telemetryCacheStatsAdapter)(this.storage.telemetry, this.storage.splits, this.storage.segments);
             this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
         }
-        // Close streaming connection
-        if (this.syncManager.pushManager)
-            this.syncManager.pushManager.stop();
+    };
+    BrowserSignalListener.prototype.flushDataIfHidden = function () {
+        if (typeof document !== 'undefined' && document.visibilityState === 'hidden')
+            this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
     };
     BrowserSignalListener.prototype._flushData = function (url, cache, postService, fromCacheToPayload, extraMetadata) {
         // if there is data in cache, send it to backend

package/esm/listeners/browser.js

@@ -5,11 +5,12 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
 import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
-// 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+var VISIBILITYCHANGE_EVENT = 'visibilitychange';
+var PAGEHIDE_EVENT = 'pagehide';
 var UNLOAD_DOM_EVENT = 'unload';
 var EVENT_NAME = 'for unload page event.';
 /**
- * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
+ * We'll listen for events over the window object.
  */
 var BrowserSignalListener = /** @class */ (function () {
     function BrowserSignalListener(syncManager, settings, storage, serviceApi) {
@@ -18,30 +19,43 @@ var BrowserSignalListener = /** @class */ (function () {
         this.storage = storage;
         this.serviceApi = serviceApi;
         this.flushData = this.flushData.bind(this);
+        this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
+        this.stopSync = this.stopSync.bind(this);
         this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
     }
     /**
      * start method.
-     * Called when SplitFactory is initialized.
-     * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
+     * Called when SplitFactory is initialized, it adds event listeners to close streaming and flush impressions and events.
      */
     BrowserSignalListener.prototype.start = function () {
         if (typeof window !== 'undefined' && window.addEventListener) {
             this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]);
-            window.addEventListener(UNLOAD_DOM_EVENT, this.flushData);
+            // Flush data whenever the page is hidden or unloaded.
+            window.addEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+            // Some browsers like Safari does not fire the `visibilitychange` event when the page is being unloaded. So we also flush data in the `pagehide` event.
+            // If both events are triggered, the last one will find the storage empty, so no duplicated data will be submitted.
+            window.addEventListener(PAGEHIDE_EVENT, this.flushData);
+            // Stop streaming on 'unload' event. Used instead of 'beforeunload', because 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+            window.addEventListener(UNLOAD_DOM_EVENT, this.stopSync);
         }
     };
     /**
      * stop method.
-     * Called when client is destroyed.
-     * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
+     * Called when client is destroyed, it removes event listeners.
      */
     BrowserSignalListener.prototype.stop = function () {
         if (typeof window !== 'undefined' && window.removeEventListener) {
             this.settings.log.debug(CLEANUP_DEREGISTERING, [EVENT_NAME]);
-            window.removeEventListener(UNLOAD_DOM_EVENT, this.flushData);
+            window.removeEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+            window.removeEventListener(PAGEHIDE_EVENT, this.flushData);
+            window.removeEventListener(UNLOAD_DOM_EVENT, this.stopSync);
         }
     };
+    BrowserSignalListener.prototype.stopSync = function () {
+        // Close streaming connection
+        if (this.syncManager && this.syncManager.pushManager)
+            this.syncManager.pushManager.stop();
+    };
     /**
      * flushData method.
      * Called when unload event is triggered. It flushed remaining impressions and events to the backend,
@@ -68,9 +82,10 @@ var BrowserSignalListener = /** @class */ (function () {
             var telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
             this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
         }
-        // Close streaming connection
-        if (this.syncManager.pushManager)
-            this.syncManager.pushManager.stop();
+    };
+    BrowserSignalListener.prototype.flushDataIfHidden = function () {
+        if (typeof document !== 'undefined' && document.visibilityState === 'hidden')
+            this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
     };
     BrowserSignalListener.prototype._flushData = function (url, cache, postService, fromCacheToPayload, extraMetadata) {
         // if there is data in cache, send it to backend

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.4.2-rc.3",
+  "version": "1.4.2-rc.4",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/listeners/browser.ts

@@ -14,12 +14,13 @@ import { ISyncManager } from '../sync/types';
 import { isConsentGranted } from '../consent';
 import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
 
-// 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+const VISIBILITYCHANGE_EVENT = 'visibilitychange';
+const PAGEHIDE_EVENT = 'pagehide';
 const UNLOAD_DOM_EVENT = 'unload';
 const EVENT_NAME = 'for unload page event.';
 
 /**
- * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
+ * We'll listen for events over the window object.
  */
 export class BrowserSignalListener implements ISignalListener {
 
@@ -32,33 +33,47 @@ export class BrowserSignalListener implements ISignalListener {
     private serviceApi: ISplitApi,
   ) {
     this.flushData = this.flushData.bind(this);
+    this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
+    this.stopSync = this.stopSync.bind(this);
     this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
   }
 
   /**
    * start method.
-   * Called when SplitFactory is initialized.
-   * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
+   * Called when SplitFactory is initialized, it adds event listeners to close streaming and flush impressions and events.
    */
   start() {
     if (typeof window !== 'undefined' && window.addEventListener) {
       this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]);
-      window.addEventListener(UNLOAD_DOM_EVENT, this.flushData);
+
+      // Flush data whenever the page is hidden or unloaded.
+      window.addEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+      // Some browsers like Safari does not fire the `visibilitychange` event when the page is being unloaded. So we also flush data in the `pagehide` event.
+      // If both events are triggered, the last one will find the storage empty, so no duplicated data will be submitted.
+      window.addEventListener(PAGEHIDE_EVENT, this.flushData);
+      // Stop streaming on 'unload' event. Used instead of 'beforeunload', because 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+      window.addEventListener(UNLOAD_DOM_EVENT, this.stopSync);
     }
   }
 
   /**
    * stop method.
-   * Called when client is destroyed.
-   * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
+   * Called when client is destroyed, it removes event listeners.
    */
   stop() {
     if (typeof window !== 'undefined' && window.removeEventListener) {
       this.settings.log.debug(CLEANUP_DEREGISTERING, [EVENT_NAME]);
-      window.removeEventListener(UNLOAD_DOM_EVENT, this.flushData);
+      window.removeEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+      window.removeEventListener(PAGEHIDE_EVENT, this.flushData);
+      window.removeEventListener(UNLOAD_DOM_EVENT, this.stopSync);
     }
   }
 
+  stopSync() {
+    // Close streaming connection
+    if (this.syncManager && this.syncManager.pushManager) this.syncManager.pushManager.stop();
+  }
+
   /**
    * flushData method.
    * Called when unload event is triggered. It flushed remaining impressions and events to the backend,
@@ -86,9 +101,10 @@ export class BrowserSignalListener implements ISignalListener {
       const telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
       this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
     }
+  }
 
-    // Close streaming connection
-    if (this.syncManager.pushManager) this.syncManager.pushManager.stop();
+  flushDataIfHidden() {
+    if (typeof document !== 'undefined' && document.visibilityState === 'hidden') this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
   }
 
   private _flushData<T>(url: string, cache: IRecorderCacheProducerSync<T>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: T) => any, extraMetadata?: {}) {

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

@@ -0,0 +1,3 @@
+import { IIntegrationFactoryParams } from '../types';
+import { GoogleAnalyticsToSplitOptions } from './types';
+export declare function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): (params: IIntegrationFactoryParams) => void;

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

@@ -0,0 +1,4 @@
+import { IIntegrationFactoryParams } from '../types';
+import SplitToGa from './SplitToGa';
+import { SplitToGoogleAnalyticsOptions } from './types';
+export declare function SplitToGoogleAnalytics(options?: SplitToGoogleAnalyticsOptions): (params: IIntegrationFactoryParams) => SplitToGa;

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/listeners/browser.d.ts

@@ -4,7 +4,7 @@ import { ISplitApi } from '../services/types';
 import { ISettings } from '../types';
 import { ISyncManager } from '../sync/types';
 /**
- * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
+ * We'll listen for events over the window object.
  */
 export declare class BrowserSignalListener implements ISignalListener {
     private syncManager;
@@ -15,22 +15,22 @@ export declare class BrowserSignalListener implements ISignalListener {
     constructor(syncManager: ISyncManager | undefined, settings: ISettings, storage: IStorageSync, serviceApi: ISplitApi);
     /**
      * start method.
-     * Called when SplitFactory is initialized.
-     * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
+     * Called when SplitFactory is initialized, it adds event listeners to close streaming and flush impressions and events.
      */
     start(): void;
     /**
      * stop method.
-     * Called when client is destroyed.
-     * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
+     * Called when client is destroyed, it removes event listeners.
      */
     stop(): void;
+    stopSync(): void;
     /**
      * flushData method.
      * Called when unload event is triggered. It flushed remaining impressions and events to the backend,
      * using beacon API if possible, or falling back to regular post transport.
      */
     flushData(): void;
+    flushDataIfHidden(): void;
     private _flushData;
     /**
      * _sendBeacon method.

package/types/logger/codes.d.ts

@@ -0,0 +1,2 @@
+import { ICodes } from './types';
+export declare const codes: ICodes;

package/types/logger/codesConstants.d.ts

@@ -0,0 +1,117 @@
+export declare const DEBUG_0 = 0;
+export declare const DEBUG_1 = 1;
+export declare const DEBUG_2 = 2;
+export declare const DEBUG_3 = 3;
+export declare const DEBUG_4 = 4;
+export declare const DEBUG_5 = 5;
+export declare const DEBUG_6 = 6;
+export declare const DEBUG_7 = 7;
+export declare const DEBUG_8 = 8;
+export declare const DEBUG_9 = 9;
+export declare const DEBUG_10 = 10;
+export declare const DEBUG_11 = 11;
+export declare const DEBUG_12 = 12;
+export declare const DEBUG_13 = 13;
+export declare const DEBUG_14 = 14;
+export declare const DEBUG_15 = 15;
+export declare const DEBUG_16 = 16;
+export declare const DEBUG_17 = 17;
+export declare const DEBUG_18 = 18;
+export declare const DEBUG_19 = 19;
+export declare const DEBUG_20 = 20;
+export declare const DEBUG_21 = 21;
+export declare const DEBUG_22 = 22;
+export declare const DEBUG_23 = 23;
+export declare const DEBUG_24 = 24;
+export declare const DEBUG_25 = 25;
+export declare const DEBUG_31 = 31;
+export declare const DEBUG_32 = 32;
+export declare const DEBUG_33 = 33;
+export declare const DEBUG_36 = 36;
+export declare const DEBUG_42 = 42;
+export declare const DEBUG_43 = 43;
+export declare const DEBUG_44 = 44;
+export declare const DEBUG_45 = 45;
+export declare const DEBUG_46 = 46;
+export declare const DEBUG_47 = 47;
+export declare const DEBUG_48 = 48;
+export declare const DEBUG_49 = 49;
+export declare const DEBUG_50 = 50;
+export declare const DEBUG_51 = 51;
+export declare const INFO_0 = 100;
+export declare const INFO_1 = 101;
+export declare const INFO_2 = 102;
+export declare const INFO_3 = 103;
+export declare const INFO_4 = 104;
+export declare const INFO_5 = 105;
+export declare const INFO_6 = 106;
+export declare const INFO_7 = 107;
+export declare const INFO_8 = 108;
+export declare const INFO_9 = 109;
+export declare const INFO_10 = 110;
+export declare const INFO_11 = 111;
+export declare const INFO_12 = 112;
+export declare const INFO_13 = 113;
+export declare const INFO_14 = 114;
+export declare const INFO_15 = 115;
+export declare const INFO_16 = 116;
+export declare const INFO_17 = 117;
+export declare const INFO_18 = 118;
+export declare const INFO_19 = 119;
+export declare const INFO_20 = 120;
+export declare const INFO_21 = 121;
+export declare const WARN_0 = 200;
+export declare const WARN_1 = 201;
+export declare const WARN_2 = 202;
+export declare const WARN_4 = 204;
+export declare const WARN_5 = 205;
+export declare const WARN_6 = 206;
+export declare const WARN_7 = 207;
+export declare const WARN_8 = 208;
+export declare const WARN_9 = 209;
+export declare const WARN_10 = 210;
+export declare const WARN_11 = 211;
+export declare const WARN_12 = 212;
+export declare const WARN_13 = 213;
+export declare const WARN_14 = 214;
+export declare const WARN_15 = 215;
+export declare const WARN_17 = 217;
+export declare const WARN_18 = 218;
+export declare const WARN_19 = 219;
+export declare const WARN_20 = 220;
+export declare const WARN_21 = 221;
+export declare const WARN_22 = 222;
+export declare const WARN_23 = 223;
+export declare const WARN_24 = 224;
+export declare const WARN_25 = 225;
+export declare const ERROR_0 = 300;
+export declare const ERROR_2 = 302;
+export declare const ERROR_3 = 303;
+export declare const ERROR_4 = 304;
+export declare const ERROR_5 = 305;
+export declare const ERROR_7 = 307;
+export declare const ERROR_9 = 309;
+export declare const ERROR_10 = 310;
+export declare const ERROR_11 = 311;
+export declare const ERROR_12 = 312;
+export declare const ERROR_13 = 313;
+export declare const ERROR_14 = 314;
+export declare const ERROR_15 = 315;
+export declare const ERROR_16 = 316;
+export declare const ERROR_17 = 317;
+export declare const ERROR_18 = 318;
+export declare const ERROR_19 = 319;
+export declare const ERROR_20 = 320;
+export declare const ERROR_21 = 321;
+export declare const ERROR_22 = 322;
+export declare const ERROR_23 = 323;
+export declare const ERROR_24 = 324;
+export declare const ERROR_25 = 325;
+export declare const ERROR_26 = 326;
+export declare const ERROR_32 = 332;
+export declare const ERROR_33 = 333;
+export declare const ERROR_34 = 334;
+export declare const ERROR_35 = 335;
+export declare const ERROR_36 = 336;
+export declare const ERROR_37 = 337;
+export declare const ERROR_38 = 338;

package/types/logger/codesConstantsBrowser.d.ts

@@ -0,0 +1,2 @@
+export declare const DEBUG_26 = 26;
+export declare const DEBUG_27 = 27;

package/types/logger/codesConstantsNode.d.ts

@@ -0,0 +1,14 @@
+export declare const DEBUG_28 = 28;
+export declare const DEBUG_29 = 29;
+export declare const DEBUG_30 = 30;
+export declare const ERROR_1 = 301;
+export declare const DEBUG_39 = 39;
+export declare const DEBUG_40 = 40;
+export declare const DEBUG_41 = 41;
+export declare const ERROR_8 = 308;
+export declare const DEBUG_34 = 34;
+export declare const DEBUG_35 = 35;
+export declare const ERROR_6 = 306;
+export declare const WARN_3 = 203;
+export declare const DEBUG_37 = 37;
+export declare const DEBUG_38 = 38;

package/types/logger/codesDebug.d.ts

@@ -0,0 +1 @@
+export declare const codesDebug: [number, string][];

package/types/logger/codesDebugBrowser.d.ts

@@ -0,0 +1 @@
+export declare const codesDebugBrowser: [number, string][];

package/types/logger/codesDebugNode.d.ts

@@ -0,0 +1 @@
+export declare const codesDebugNode: [number, string][];

package/types/logger/codesError.d.ts

@@ -0,0 +1 @@
+export declare const codesError: [number, string][];

package/types/logger/codesErrorNode.d.ts

@@ -0,0 +1 @@
+export declare const codesErrorNode: [number, string][];

package/types/logger/codesInfo.d.ts

@@ -0,0 +1 @@
+export declare const codesInfo: [number, string][];

package/types/logger/codesWarn.d.ts

@@ -0,0 +1 @@
+export declare const codesWarn: [number, string][];

package/types/logger/codesWarnNode.d.ts

@@ -0,0 +1 @@
+export declare const codesWarnNode: [number, string][];

package/types/logger/debugLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '.';
+export declare const debugLogger: Logger;

package/types/logger/errorLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '.';
+export declare const errorLogger: Logger;

package/types/logger/infoLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '.';
+export declare const infoLogger: Logger;

package/types/logger/messages/debugBrowser.d.ts

@@ -0,0 +1 @@
+export declare const codesDebugBrowser: [number, string][];

package/types/logger/messages/debugNode.d.ts

@@ -0,0 +1 @@
+export declare const codesDebugNode: [number, string][];

package/types/logger/messages/errorNode.d.ts

@@ -0,0 +1 @@
+export declare const codesErrorNode: [number, string][];

package/types/logger/messages/warnNode.d.ts

@@ -0,0 +1 @@
+export declare const codesWarnNode: [number, string][];

package/types/logger/noopLogger.d.ts

@@ -0,0 +1,2 @@
+import { ILogger } from './types';
+export declare const noopLogger: ILogger;

package/types/logger/warnLogger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '.';
+export declare const warnLogger: Logger;

package/types/sdkFactory/userConsentProps.d.ts

@@ -0,0 +1,6 @@
+import { ISyncManager } from '../sync/types';
+import { ISettings } from '../types';
+export declare function userConsentProps(settings: ISettings, syncManager?: ISyncManager): {
+    setUserConsent(consent: unknown): boolean;
+    getUserConsent(): import("../types").ConsentStatus | undefined;
+};

package/types/sdkManager/sdkManagerMethod.d.ts

@@ -0,0 +1,6 @@
+import { ISdkClientFactoryParams } from '../sdkClient/types';
+import { SplitIO } from '../types';
+/**
+ * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
+ */
+export declare function sdkManagerMethodFactory(params: ISdkClientFactoryParams): () => SplitIO.IManager | SplitIO.IAsyncManager;

package/types/storages/getRegisteredSegments.d.ts

@@ -0,0 +1,10 @@
+import { ISplit } from '../dtos/types';
+/**
+ * Collect segments from a raw split definition.
+ * Exported for testing purposes.
+ */
+export declare function _parseSegments({ conditions }: ISplit): import("../utils/lang/sets").ISet<string>;
+/**
+ * Computes the set of segments used by splits.
+ */
+export declare function getRegisteredSegments(splitDefs: string[]): string[];

package/types/storages/inMemory/index.d.ts

@@ -0,0 +1,10 @@
+import { IStorageFactoryParams, IStorageSync } from '../types';
+/**
+ * InMemory storage factory for standalone server-side SplitFactory
+ *
+ * @param params parameters required by EventsCacheSync
+ */
+export declare function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync;
+export declare namespace InMemoryStorageFactory {
+    var type: import("../types").StorageType;
+}

package/types/storages/parseSegments.d.ts

@@ -0,0 +1,6 @@
+import { ISplit } from '../dtos/types';
+import { ISet } from '../utils/lang/sets';
+/**
+ * Collect segments from a list of splits.
+ */
+export declare function parseSegments(splits: ISplit[]): ISet<string>;

package/types/sync/polling/syncTasks/splitsSyncTask.copy.d.ts

@@ -0,0 +1,35 @@
+import { ISet } from '../../../utils/lang/sets';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../storages/types';
+import { ISplitChangesFetcher } from '../fetchers/types';
+import { ISplit } from '../../../dtos/types';
+import { IReadinessManager, ISplitsEventEmitter } from '../../../readiness/types';
+import { ISplitsSyncTask } from '../types';
+import { IFetchSplitChanges } from '../../../services/types';
+import { ISettings } from '../../../types';
+declare type ISplitChangesUpdater = (noCache?: boolean) => Promise<boolean>;
+/**
+ * Collect segments from a raw split definition.
+ * Exported for testing purposes.
+ */
+export declare function parseSegments({ conditions }: ISplit): ISet<string>;
+interface ISplitMutations {
+    added: [string, string][];
+    removed: string[];
+    segments: string[];
+}
+/**
+ * Given the list of splits from /splitChanges endpoint, it returns the mutations,
+ * i.e., an object with added splits, removed splits and used segments.
+ * Exported for testing purposes.
+ */
+export declare function computeSplitsMutation(entries: ISplit[]): ISplitMutations;
+/**
+ * factory of SplitChanges updater (a.k.a, SplitsSyncTask), a task that:
+ *  - fetches split changes using `splitChangesFetcher`
+ *  - updates `splitsCache`
+ *  - uses `splitsEventEmitter` to emit events related to split data updates
+ * Exported for testing purposes.
+ */
+export declare function splitChangesUpdaterFactory(splitChangesFetcher: ISplitChangesFetcher, splitsCache: ISplitsCacheSync, segmentsCache: ISegmentsCacheSync, splitsEventEmitter: ISplitsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number): ISplitChangesUpdater;
+export default function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISplitsSyncTask;
+export {};

package/types/sync/polling/syncTasks/splitsSyncTask.morelikeoriginal.d.ts

@@ -0,0 +1,35 @@
+import { ISet } from '../../../utils/lang/sets';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from '../../../storages/types';
+import { ISplitChangesFetcher } from '../fetchers/types';
+import { ISplit } from '../../../dtos/types';
+import { IReadinessManager, ISplitsEventEmitter } from '../../../readiness/types';
+import { ISplitsSyncTask } from '../types';
+import { IFetchSplitChanges } from '../../../services/types';
+import { ISettings } from '../../../types';
+declare type ISplitChangesUpdater = (noCache?: boolean) => Promise<boolean>;
+/**
+ * Collect segments from a raw split definition.
+ * Exported for testing purposes.
+ */
+export declare function parseSegments({ conditions }: ISplit): ISet<string>;
+interface ISplitMutations {
+    added: [string, string][];
+    removed: string[];
+    segments: string[];
+}
+/**
+ * Given the list of splits from /splitChanges endpoint, it returns the mutations,
+ * i.e., an object with added splits, removed splits and used segments.
+ * Exported for testing purposes.
+ */
+export declare function computeSplitsMutation(entries: ISplit[]): ISplitMutations;
+/**
+ * factory of SplitChanges updater (a.k.a, SplitsSyncTask), a task that:
+ *  - fetches split changes using `splitChangesFetcher`
+ *  - updates `splitsCache`
+ *  - uses `splitsEventEmitter` to emit events related to split data updates
+ * Exported for testing purposes.
+ */
+export declare function splitChangesUpdaterFactory(splitChangesFetcher: ISplitChangesFetcher, splitsCache: ISplitsCacheSync, segmentsCache: ISegmentsCacheSync, splitsEventEmitter: ISplitsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number): ISplitChangesUpdater;
+export default function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISplitsSyncTask;
+export {};

package/types/sync/streaming/AuthClient/indexV1.d.ts

@@ -0,0 +1,12 @@
+import { IFetchAuth } from '../../../services/types';
+import { IAuthenticate } from './types';
+/**
+ * Factory of authentication function.
+ *
+ * @param fetchAuth `SplitAPI.fetchAuth` endpoint
+ */
+export declare function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate;
+/**
+ * Returns the hash of a given user key
+ */
+export declare function hashUserKey(userKey: string): string;

package/types/sync/streaming/AuthClient/indexV2.d.ts

@@ -0,0 +1,8 @@
+import { IFetchAuthV2 } from '../../../services/types';
+import { IAuthenticateV2 } from './types';
+/**
+ * Factory of authentication function.
+ *
+ * @param fetchAuth `SplitAPI.fetchAuth` endpoint
+ */
+export declare function authenticateFactory(fetchAuthV2: IFetchAuthV2): IAuthenticateV2;

package/types/sync/streaming/pushManagerCS.d.ts

@@ -0,0 +1 @@
+export declare const pushManagerCSFactory: (params: import("../types").ISyncManagerFactoryParams, pollingManager: import("../polling/types").IPollingManager) => import("./types").IPushManager | undefined;

package/types/sync/streaming/pushManagerNoUsers.d.ts

@@ -0,0 +1,13 @@
+import { IPushManagerCS } from './types';
+import { IStorageSync } from '../../storages/types';
+import { IReadinessManager } from '../../readiness/types';
+import { IPollingManager } from '../polling/types';
+import { IFetchAuthV2 } from '../../services/types';
+import { ISettings } from '../../types';
+import { IPlatform } from '../../sdkFactory/types';
+/**
+ * PushManager factory:
+ * - for server-side if key is not provided in settings.
+ * - for client-side, with support for multiple clients, if key is provided in settings
+ */
+export default function pushManagerFactory(pollingManager: IPollingManager, storage: IStorageSync, readiness: IReadinessManager, fetchAuthV2: IFetchAuthV2, platform: IPlatform, settings: ISettings): IPushManagerCS | undefined;

package/types/sync/streaming/pushManagerSS.d.ts

@@ -0,0 +1 @@
+export declare const pushManagerSSFactory: (params: import("../types").ISyncManagerFactoryParams, pollingManager: import("../polling/types").IPollingManager) => import("./types").IPushManager | undefined;

package/types/sync/syncManagerFromFile.d.ts

@@ -0,0 +1,2 @@
+import { SplitIO } from '../types';
+export declare function LocalhostFromFile(): SplitIO.LocalhostFactory;

package/types/sync/syncManagerFromObject.d.ts

@@ -0,0 +1,2 @@
+import { SplitIO } from '../types';
+export declare function LocalhostFromObject(): SplitIO.LocalhostFactory;

package/types/sync/syncManagerOffline.d.ts

@@ -0,0 +1,9 @@
+import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
+import { ISplitsParser } from './offline/splitsParser/types';
+/**
+ * Offline SyncManager factory.
+ * Can be used for server-side API, and client-side API with or without multiple clients.
+ *
+ * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
+ */
+export declare function syncManagerOfflineFactory(splitsParserFactory: () => ISplitsParser): (params: ISyncManagerFactoryParams) => ISyncManagerCS;

package/types/utils/EventEmitter.d.ts

@@ -0,0 +1,4 @@
+import { IEventEmitter } from '../types';
+export declare const EventEmitter: {
+    new (): IEventEmitter;
+};

package/types/utils/consent.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../types';
+export declare function isConsentGranted(settings: ISettings): boolean;

package/types/utils/lang/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class SplitError extends Error {
+    constructor(msg?: string);
+}
+export declare class SplitTimeoutError extends SplitError {
+    constructor(msg?: string);
+}
+export declare class SplitNetworkError extends SplitError {
+    statusCode?: number;
+    constructor(msg?: string, code?: number);
+}

package/types/utils/murmur3/commons.d.ts

@@ -0,0 +1,12 @@
+export declare function UTF16ToUTF8(key: string): string | undefined;
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+export declare function x86Multiply(m: number, n: number): number;
+export declare function x86Rotl(m: number, n: number): number;
+export declare function x86Fmix(h: number): number;

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

@@ -0,0 +1,3 @@
+import { IMetadata } from '../../dtos/types';
+import { ISettings } from '../../types';
+export default function buildMetadata(settings: ISettings): IMetadata;

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

@@ -0,0 +1,9 @@
+import { ISettings } from '../../../types';
+/**
+ * This function validates `settings.storage` object
+ *
+ * @param {any} settings config object provided by the user to initialize the sdk
+ *
+ * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
+ */
+export declare function validateLocalhost(settings: ISettings): import("../../../types").SplitIO.LocalhostFactory | undefined;

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

@@ -0,0 +1,11 @@
+import { ILogger } from '../../logger/types';
+/**
+ * Validates the `log` (logger) property at config.
+ *
+ * @param settings user config object
+ * @returns the provided logger or a no-op logger if no one is provided
+ * @throws throws an error if a logger was provided but is invalid
+ */
+export default function logger(settings: {
+    log: unknown;
+}): ILogger;

package/types/utils/settingsValidation/runtime/browser.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../../../types';
+export declare function validateRuntime(): ISettings['runtime'];

package/types/utils/settingsValidation/runtime/node.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../../../types';
+export declare function validateRuntime(settings: ISettings): ISettings['runtime'];

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

@@ -0,0 +1,5 @@
+import { ILogger } from '../../logger/types';
+export declare function validateUserConsent({ userConsent, log }: {
+    userConsent: any;
+    log: ILogger;
+}): any;

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

@@ -1,70 +1 @@
-import { ILogger } from '../../logger/types';
-import { IResponse } from '../../services/types';
-interface MetricsCollector {
-    countException(): void;
-    count(status: number): void;
-    latency(ms: number): void;
-    ready(ms: number): void;
-    getTreatment(ms: number): void;
-    getTreatments(ms: number): void;
-    getTreatmentWithConfig(ms: number): void;
-    getTreatmentsWithConfig(ms: number): void;
-    [method: string]: (ms: number) => void;
-}
-export declare const TrackerAPI: {
-    /**
-     * "Private" method, used to attach count/countException and stop callbacks to a promise.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {Promise} promise - The promise we want to attach the callbacks.
-     * @param {string} task - The name of the task.
-     * @param {number | string} modifier - (optional) The modifier for the task, if any.
-     */
-    __attachToPromise(log: ILogger, promise: Promise<IResponse>, task: string, collector: false | MetricsCollector, modifier?: string | number | undefined): Promise<IResponse>;
-    /**
-     * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
-     * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {Object} collectors - The collectors map.
-     * @param {Promise} promise - (optional) The promise we are tracking.
-     * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
-     */
-    start(log: ILogger, task: string, collectors?: Record<string, MetricsCollector> | undefined, promise?: Promise<IResponse> | undefined, now?: (() => number) | undefined): Promise<IResponse> | (() => number);
-    /**
-     * Setup the collector for a task that reports metrics.
-     *
-     * @param {string} task - The task name
-     * @param {number | string} taskUniqueId - The unique identifier for this task
-     * @param {Object} collectors - The collectors map.
-     */
-    setCollectorForTask(task: string, taskUniqueId: number | string, collectors: Record<string, MetricsCollector>): void;
-    /**
-     * Stops the tracking of a given task.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {number | string} modifier - (optional) The modifier for that specific task.
-     */
-    stop(log: ILogger, task: string, modifier?: string | number | undefined): number | undefined;
-    /**
-     * The constants shortcut for the task names.
-     */
-    TaskNames: {
-        SDK_READY: string;
-        SDK_GET_TREATMENT: string;
-        SDK_GET_TREATMENTS: string;
-        SDK_GET_TREATMENT_WITH_CONFIG: string;
-        SDK_GET_TREATMENTS_WITH_CONFIG: string;
-        SPLITS_READY: string;
-        SEGMENTS_READY: string;
-        METRICS_PUSH: string;
-        IMPRESSIONS_PUSH: string;
-        EVENTS_PUSH: string;
-        MY_SEGMENTS_FETCH: string;
-        SEGMENTS_FETCH: string;
-        SPLITS_FETCH: string;
-    };
-};
-export {};
+export declare function timeTracker(now: () => number): () => () => number;