@splitsoftware/splitio 10.17.2 → 10.17.3-rc.3

package/es/platform/browser.js

@@ -0,0 +1,10 @@
+import { EventEmitter } from './EventEmitter';
+import { getFetch } from '../platform/getFetch/browser';
+import { getEventSource } from '../platform/getEventSource/browser';
+import { BrowserSignalListener } from '@splitsoftware/splitio-commons/esm/listeners/browser';
+export var platform = {
+    getFetch: getFetch,
+    getEventSource: getEventSource,
+    EventEmitter: EventEmitter
+};
+export var SignalListener = BrowserSignalListener;

package/es/platform/getEventSource/browser.js

@@ -0,0 +1,3 @@
+export function getEventSource() {
+    return typeof EventSource === 'function' ? EventSource : undefined;
+}

package/es/platform/getEventSource/node.js

@@ -0,0 +1,19 @@
+var __isCustom = false;
+var __eventSource = undefined;
+// This function is only exposed for testing purposes.
+export function __setEventSource(eventSource) {
+    __eventSource = eventSource;
+    __isCustom = true;
+}
+export function __restore() {
+    __isCustom = false;
+}
+export function getEventSource() {
+    // returns EventSource at `eventsource` package. If not available, return global EventSource or undefined
+    try {
+        return __isCustom ? __eventSource : require('eventsource');
+    }
+    catch (error) {
+        return typeof EventSource === 'function' ? EventSource : undefined;
+    }
+}

package/es/platform/getFetch/browser.js

@@ -0,0 +1,4 @@
+import unfetch from 'unfetch';
+export function getFetch() {
+    return typeof fetch === 'function' ? fetch : unfetch;
+}

package/es/platform/getFetch/node.js

@@ -0,0 +1,18 @@
+var nodeFetch;
+try {
+    nodeFetch = require('node-fetch');
+    // Handle node-fetch issue https://github.com/node-fetch/node-fetch/issues/1037
+    if (typeof nodeFetch !== 'function')
+        nodeFetch = nodeFetch.default;
+}
+catch (error) {
+    // Try to access global fetch if `node-fetch` package couldn't be imported (e.g., not in a Node environment)
+    nodeFetch = typeof fetch === 'function' ? fetch : undefined;
+}
+// This function is only exposed for testing purposes.
+export function __setFetch(fetch) {
+    nodeFetch = fetch;
+}
+export function getFetch() {
+    return nodeFetch;
+}

package/es/platform/node.js

@@ -0,0 +1,12 @@
+import EventEmitter from 'events';
+import { getFetch } from '../platform/getFetch/node';
+import { getEventSource } from '../platform/getEventSource/node';
+import { getOptions } from '../platform/request/options/node';
+import { NodeSignalListener } from '@splitsoftware/splitio-commons/esm/listeners/node';
+export var platform = {
+    getOptions: getOptions,
+    getFetch: getFetch,
+    getEventSource: getEventSource,
+    EventEmitter: EventEmitter
+};
+export var SignalListener = NodeSignalListener;

package/es/platform/request/options/node.js

@@ -0,0 +1,13 @@
+// @TODO
+// 1- handle multiple protocols automatically
+// 2- destroy it once the sdk is destroyed
+import https from 'https';
+var agent = new https.Agent({
+    keepAlive: true,
+    keepAliveMsecs: 1500
+});
+export function getOptions() {
+    return {
+        agent: agent
+    };
+}

package/es/settings/browser.js

@@ -0,0 +1,18 @@
+import { settingsValidation } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation';
+import { defaults } from './defaults/browser';
+import { validateRuntime } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/runtime/browser';
+import { validateStorage } from './storage/browser';
+import { validateIntegrations } from './integrations/browser';
+import { validateLogger } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/logger/builtinLogger';
+import { LocalhostFromObject } from '@splitsoftware/splitio-commons/esm/sync/offline/LocalhostFromObject';
+var params = {
+    defaults: defaults,
+    runtime: validateRuntime,
+    storage: validateStorage,
+    integrations: validateIntegrations,
+    logger: validateLogger,
+    localhost: function () { return LocalhostFromObject(); },
+};
+export function settingsFactory(config) {
+    return settingsValidation(config, params);
+}

package/es/settings/defaults/browser.js

@@ -0,0 +1,15 @@
+import { packageVersion } from './version';
+export var defaults = {
+    startup: {
+        // Stress the request time used while starting up the SDK.
+        requestTimeoutBeforeReady: 5,
+        // How many quick retries we will do while starting up the SDK.
+        retriesOnFailureBeforeReady: 1,
+        // Maximum amount of time used before notifies me a timeout.
+        readyTimeout: 10,
+        // Amount of time we will wait before the first push of events.
+        eventsFirstPushWindow: 10
+    },
+    // Instance version.
+    version: "javascript-" + packageVersion,
+};

package/es/settings/defaults/node.js

@@ -0,0 +1,24 @@
+import { packageVersion } from './version';
+export var defaults = {
+    core: {
+        // Default is true.
+        IPAddressesEnabled: true
+    },
+    startup: {
+        // Stress the request time used while starting up the SDK.
+        requestTimeoutBeforeReady: 15,
+        // How many quick retries we will do while starting up the SDK.
+        retriesOnFailureBeforeReady: 1,
+        // Maximum amount of time used before notifies me a timeout.
+        readyTimeout: 15,
+        // Don't wait a specific time for first flush on Node, no page load here.
+        eventsFirstPushWindow: 0
+    },
+    scheduler: {
+        featuresRefreshRate: 5,
+        impressionsRefreshRate: 300
+    },
+    features: '.split',
+    // Instance version.
+    version: "nodejs-" + packageVersion,
+};

package/es/settings/defaults/version.js

@@ -0,0 +1 @@
+export var packageVersion = '10.17.3-rc.3';

package/es/settings/integrations/browser.js

@@ -0,0 +1,5 @@
+import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS } from '@splitsoftware/splitio-commons/esm/utils/constants/browser';
+import { validateConfigurableIntegrations } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/integrations/configurable';
+export function validateIntegrations(settings) {
+    return validateConfigurableIntegrations(settings, [GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS]);
+}

package/es/settings/node.js

@@ -0,0 +1,17 @@
+import { settingsValidation } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation';
+import { defaults } from './defaults/node';
+import { validateRuntime } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/runtime/node';
+import { validateStorage } from './storage/node';
+import { validateLogger } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/logger/builtinLogger';
+import { LocalhostFromFile } from '@splitsoftware/splitio-commons/esm/sync/offline/LocalhostFromFile';
+var params = {
+    defaults: defaults,
+    runtime: validateRuntime,
+    storage: validateStorage,
+    logger: validateLogger,
+    localhost: function () { return LocalhostFromFile(); },
+    // For now, Node SDK ignores settings.integrations, so no integration validator is passed
+};
+export function settingsFactory(config) {
+    return settingsValidation(config, params);
+}

package/es/settings/storage/browser.js

@@ -0,0 +1,35 @@
+import { isLocalStorageAvailable } from '@splitsoftware/splitio-commons/esm/utils/env/isLocalStorageAvailable';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '@splitsoftware/splitio-commons/esm/utils/constants';
+var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
+export function validateStorage(settings) {
+    var log = settings.log, mode = settings.mode, _a = settings.storage, _b = _a === void 0 ? { type: STORAGE_MEMORY } : _a, type = _b.type, _c = _b.options, options = _c === void 0 ? {} : _c, prefix = _b.prefix;
+    var __originalType;
+    if (prefix) {
+        prefix += '.SPLITIO';
+    }
+    else {
+        prefix = 'SPLITIO';
+    }
+    var fallbackToMemory = function () {
+        __originalType = type;
+        type = STORAGE_MEMORY;
+    };
+    // In localhost mode, fallback to Memory storage and track original type to emit SDK_READY_FROM_CACHE if corresponds.
+    // ATM, other mode settings (e.g., 'consumer') are ignored in client-side API, and so treated as standalone.
+    if (mode === LOCALHOST_MODE && type === STORAGE_LOCALSTORAGE) {
+        fallbackToMemory();
+    }
+    // If an invalid storage type is provided OR we want to use LOCALSTORAGE and
+    // it's not available, fallback into MEMORY
+    if (type !== STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE ||
+        type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {
+        fallbackToMemory();
+        log.error('Invalid or unavailable storage. Fallbacking into MEMORY storage');
+    }
+    return {
+        type: type,
+        options: options,
+        prefix: prefix,
+        __originalType: __originalType
+    };
+}

package/es/settings/storage/node.js

@@ -0,0 +1,66 @@
+import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS, CONSUMER_MODE, STANDALONE_MODE } from '@splitsoftware/splitio-commons/esm/utils/constants';
+export function validateStorage(settings) {
+    var log = settings.log, mode = settings.mode, _a = settings.storage, _b = _a === void 0 ? { type: STORAGE_MEMORY } : _a, type = _b.type, _c = _b.options, options = _c === void 0 ? {} : _c, prefix = _b.prefix;
+    if (prefix) {
+        prefix += '.SPLITIO';
+    }
+    else {
+        prefix = 'SPLITIO';
+    }
+    // We can have MEMORY, REDIS or an invalid storage type
+    switch (type) {
+        case STORAGE_REDIS: {
+            // If passing REDIS storage in localhost or standalone mode, we log an error and fallback to MEMORY storage
+            if (mode === STANDALONE_MODE || mode === LOCALHOST_MODE) {
+                log.error('The provided REDIS storage is invalid for this mode. It requires consumer mode. Fallbacking into default MEMORY storage.');
+                return {
+                    type: STORAGE_MEMORY,
+                    prefix: prefix
+                };
+            }
+            var host = options.host, port = options.port, db = options.db, pass = options.pass, url = options.url, connectionTimeout = options.connectionTimeout, operationTimeout = options.operationTimeout;
+            if (process.env.REDIS_HOST)
+                host = process.env.REDIS_HOST;
+            if (process.env.REDIS_PORT)
+                port = process.env.REDIS_PORT;
+            if (process.env.REDIS_DB)
+                db = process.env.REDIS_DB;
+            if (process.env.REDIS_PASS)
+                pass = process.env.REDIS_PASS;
+            if (process.env.REDIS_URL)
+                url = process.env.REDIS_URL;
+            var newOpts = {
+                connectionTimeout: connectionTimeout,
+                operationTimeout: operationTimeout
+            };
+            if (url) {
+                newOpts.url = url;
+            }
+            else {
+                newOpts.host = host;
+                newOpts.port = port;
+                newOpts.db = db;
+                newOpts.pass = pass;
+            }
+            return {
+                type: type,
+                prefix: prefix,
+                options: newOpts
+            };
+        }
+        // For now, we don't have modifiers or settings for MEMORY in NodeJS
+        case STORAGE_MEMORY:
+        default: {
+            // If passing MEMORY storage in consumer mode, throw an error (no way to fallback to REDIS storage)
+            if (mode === CONSUMER_MODE)
+                throw new Error('A REDIS storage is required on consumer mode');
+            // If passing an invalid storage type, log an error
+            if (type !== STORAGE_MEMORY)
+                log.error("The provided '" + type + "' storage type is invalid. Fallbacking into default MEMORY storage.");
+            return {
+                type: STORAGE_MEMORY,
+                prefix: prefix
+            };
+        }
+    }
+}

package/es/umd.js

@@ -1,2 +1,3 @@
 import { SplitFactory } from './index';
-export default SplitFactory;
+// eslint-disable-next-line import/no-default-export
+export default SplitFactory;

package/lib/factory/browser.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitFactory = void 0;
+var splitApi_1 = require("@splitsoftware/splitio-commons/cjs/services/splitApi");
+var syncManagerOnline_1 = require("@splitsoftware/splitio-commons/cjs/sync/syncManagerOnline");
+var pushManager_1 = require("@splitsoftware/splitio-commons/cjs/sync/streaming/pushManager");
+var pollingManagerCS_1 = require("@splitsoftware/splitio-commons/cjs/sync/polling/pollingManagerCS");
+var inLocalStorage_1 = require("@splitsoftware/splitio-commons/cjs/storages/inLocalStorage");
+var InMemoryStorageCS_1 = require("@splitsoftware/splitio-commons/cjs/storages/inMemory/InMemoryStorageCS");
+var sdkManager_1 = require("@splitsoftware/splitio-commons/cjs/sdkManager");
+var sdkClientMethodCSWithTT_1 = require("@splitsoftware/splitio-commons/cjs/sdkClient/sdkClientMethodCSWithTT");
+var impressionObserverCS_1 = require("@splitsoftware/splitio-commons/cjs/trackers/impressionObserver/impressionObserverCS");
+var browser_1 = require("@splitsoftware/splitio-commons/cjs/integrations/browser");
+var storageCS_1 = require("@splitsoftware/splitio-commons/cjs/utils/settingsValidation/storage/storageCS");
+var sdkFactory_1 = require("@splitsoftware/splitio-commons/cjs/sdkFactory");
+var constants_1 = require("@splitsoftware/splitio-commons/cjs/utils/constants");
+var utils_1 = require("@splitsoftware/splitio-commons/cjs/trackers/impressionObserver/utils");
+var browser_2 = require("../settings/browser");
+var platform_1 = require("../platform");
+var syncManagerOnlineCSFactory = (0, syncManagerOnline_1.syncManagerOnlineFactory)(pollingManagerCS_1.pollingManagerCSFactory, pushManager_1.pushManagerFactory);
+function getStorage(settings) {
+    return settings.storage.type === constants_1.STORAGE_LOCALSTORAGE ?
+        (0, inLocalStorage_1.InLocalStorage)(settings.storage)
+        : settings.storage.__originalType === constants_1.STORAGE_LOCALSTORAGE ?
+            storageCS_1.__InLocalStorageMockFactory
+            : InMemoryStorageCS_1.InMemoryStorageCSFactory;
+}
+/**
+ *
+ * @param {import("@splitsoftware/splitio-commons/types/types").ISettings} settings
+ */
+function getModules(settings) {
+    var modules = {
+        settings: settings,
+        platform: platform_1.platform,
+        storageFactory: getStorage(settings),
+        splitApiFactory: splitApi_1.splitApiFactory,
+        syncManagerFactory: syncManagerOnlineCSFactory,
+        sdkManagerFactory: sdkManager_1.sdkManagerFactory,
+        sdkClientMethodFactory: sdkClientMethodCSWithTT_1.sdkClientMethodCSFactory,
+        SignalListener: platform_1.SignalListener,
+        impressionListener: settings.impressionListener,
+        integrationsManagerFactory: settings.integrations && settings.integrations.length > 0 ? browser_1.integrationsManagerFactory.bind(null, settings.integrations) : undefined,
+        impressionsObserverFactory: (0, utils_1.shouldAddPt)(settings) ? impressionObserverCS_1.impressionObserverCSFactory : undefined,
+    };
+    switch (settings.mode) {
+        case constants_1.LOCALHOST_MODE:
+            modules.splitApiFactory = undefined;
+            modules.syncManagerFactory = settings.sync.localhostMode;
+            modules.SignalListener = undefined;
+            break;
+    }
+    return modules;
+}
+/**
+ * SplitFactory for client-side.
+ *
+ * @param {SplitIO.IBrowserSettings} config configuration object used to instantiate the SDK
+ * @param {Function=} __updateModules optional function that lets redefine internal SDK modules. Use with
+ * caution since, unlike `config`, this param is not validated neither considered part of the public API.
+ * @throws Will throw an error if the provided config is invalid.
+ */
+function SplitFactory(config, __updateModules) {
+    var settings = (0, browser_2.settingsFactory)(config);
+    var modules = getModules(settings);
+    if (__updateModules)
+        __updateModules(modules);
+    return (0, sdkFactory_1.sdkFactory)(modules);
+}
+exports.SplitFactory = SplitFactory;

package/lib/factory/node.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitFactory = void 0;
+var splitApi_1 = require("@splitsoftware/splitio-commons/cjs/services/splitApi");
+var syncManagerOnline_1 = require("@splitsoftware/splitio-commons/cjs/sync/syncManagerOnline");
+var pushManager_1 = require("@splitsoftware/splitio-commons/cjs/sync/streaming/pushManager");
+var pollingManagerSS_1 = require("@splitsoftware/splitio-commons/cjs/sync/polling/pollingManagerSS");
+var inRedis_1 = require("@splitsoftware/splitio-commons/cjs/storages/inRedis");
+var InMemoryStorage_1 = require("@splitsoftware/splitio-commons/cjs/storages/inMemory/InMemoryStorage");
+var sdkManager_1 = require("@splitsoftware/splitio-commons/cjs/sdkManager");
+var sdkClientMethod_1 = require("@splitsoftware/splitio-commons/cjs/sdkClient/sdkClientMethod");
+var impressionObserverSS_1 = require("@splitsoftware/splitio-commons/cjs/trackers/impressionObserver/impressionObserverSS");
+var sdkFactory_1 = require("@splitsoftware/splitio-commons/cjs/sdkFactory");
+var constants_1 = require("@splitsoftware/splitio-commons/cjs/utils/constants");
+var utils_1 = require("@splitsoftware/splitio-commons/cjs/trackers/impressionObserver/utils");
+var node_1 = require("../settings/node");
+var platform_1 = require("../platform");
+var syncManagerOnlineSSFactory = (0, syncManagerOnline_1.syncManagerOnlineFactory)(pollingManagerSS_1.pollingManagerSSFactory, pushManager_1.pushManagerFactory);
+function getStorage(settings) {
+    return settings.storage.type === 'REDIS' ?
+        (0, inRedis_1.InRedisStorage)(settings.storage) :
+        InMemoryStorage_1.InMemoryStorageFactory;
+}
+/**
+ *
+ * @param {import("@splitsoftware/splitio-commons/types/types").ISettings} settings
+ */
+function getModules(settings) {
+    var modules = {
+        settings: settings,
+        platform: platform_1.platform,
+        storageFactory: getStorage(settings),
+        splitApiFactory: splitApi_1.splitApiFactory,
+        syncManagerFactory: syncManagerOnlineSSFactory,
+        sdkManagerFactory: sdkManager_1.sdkManagerFactory,
+        sdkClientMethodFactory: sdkClientMethod_1.sdkClientMethodFactory,
+        SignalListener: platform_1.SignalListener,
+        impressionListener: settings.impressionListener,
+        impressionsObserverFactory: (0, utils_1.shouldAddPt)(settings) ? impressionObserverSS_1.impressionObserverSSFactory : undefined,
+    };
+    switch (settings.mode) {
+        case constants_1.LOCALHOST_MODE:
+            modules.splitApiFactory = undefined;
+            modules.syncManagerFactory = settings.sync.localhostMode;
+            modules.SignalListener = undefined;
+            break;
+        case constants_1.CONSUMER_MODE:
+            modules.syncManagerFactory = undefined;
+            break;
+    }
+    return modules;
+}
+/**
+ * SplitFactory for server-side.
+ *
+ * @param {SplitIO.INodeSettings | SplitIO.INodeAsyncSettings} config configuration object used to instantiate the SDK
+ * @param {Function=} __updateModules optional function that lets redefine internal SDK modules. Use with
+ * caution since, unlike `config`, this param is not validated neither considered part of the public API.
+ * @throws Will throw an error if the provided config is invalid.
+ */
+function SplitFactory(config, __updateModules) {
+    var settings = (0, node_1.settingsFactory)(config);
+    var modules = getModules(settings);
+    if (__updateModules)
+        __updateModules(modules);
+    return (0, sdkFactory_1.sdkFactory)(modules);
+}
+exports.SplitFactory = SplitFactory;

package/lib/index.js

@@ -1,156 +1,20 @@
 "use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.SplitFactory = SplitFactory;
-
-var _manager = _interopRequireDefault(require("./manager"));
-
-var _storage = _interopRequireDefault(require("./storage"));
-
-var _readiness2 = _interopRequireDefault(require("./readiness"));
-
-var _settings = _interopRequireDefault(require("./utils/settings"));
-
-var _context = _interopRequireDefault(require("./utils/context"));
-
-var _parser = _interopRequireDefault(require("./utils/key/parser"));
-
-var _logger = _interopRequireWildcard(require("./utils/logger"));
-
-var _timeTracker = _interopRequireDefault(require("./utils/timeTracker"));
-
-var _online = _interopRequireDefault(require("./factory/online"));
-
-var _offline = _interopRequireDefault(require("./factory/offline"));
-
-var _statusManager = _interopRequireDefault(require("./readiness/statusManager"));
-
-var _constants = require("./utils/constants");
-
-var _inputValidation = require("./utils/inputValidation");
-
-var _integrations = _interopRequireDefault(require("./integrations"));
-
-var _counter = _interopRequireDefault(require("./impressions/counter"));
-
-var log = (0, _logger.default)('splitio');
-
-var buildInstanceId = function buildInstanceId(key, trafficType) {
-  return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType !== undefined ? trafficType : '');
-};
-
-function SplitFactory(config) {
-  // Cache instances created per factory.
-  var clientInstances = {}; // Tracking times. We need to do it here because we need the storage created.
-
-  var readyLatencyTrackers = {
-    splitsReadyTracker: _timeTracker.default.start(_timeTracker.default.TaskNames.SPLITS_READY),
-    segmentsReadyTracker: _timeTracker.default.start(_timeTracker.default.TaskNames.SEGMENTS_READY),
-    sdkReadyTracker: _timeTracker.default.start(_timeTracker.default.TaskNames.SDK_READY)
-  };
-  var context = new _context.default(); // Put settings config within context
-
-  var settings = (0, _settings.default)(config);
-  context.put(context.constants.SETTINGS, settings); // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-
-  (0, _inputValidation.validateApiKey)(settings.core.authorizationKey); // Put readiness and statusManager within context
-  // Done before adding storage, to let it access readiness gate synchronously
-
-  var gateFactory = (0, _readiness2.default)();
-  var readiness = gateFactory(settings.startup.readyTimeout);
-  context.put(context.constants.READINESS, readiness);
-  var statusManager = (0, _statusManager.default)(context);
-  context.put(context.constants.STATUS_MANAGER, statusManager); // Put storage config within context
-
-  var storage = (0, _storage.default)(context);
-  context.put(context.constants.STORAGE, storage); // Put counter
-
-  var impressionsCounter = new _counter.default(); // Instantiates new counter for Impressions
-
-  context.put(context.constants.IMPRESSIONS_COUNTER, impressionsCounter); // Put integrationsManager within context.
-  // It needs to access the storage, settings and potentially other pieces, so it's registered after them.
-
-  var integrationsManager = (0, _integrations.default)(context);
-  context.put(context.constants.INTEGRATIONS_MANAGER, integrationsManager); // Define which type of factory to use
-
-  var splitFactory = settings.mode === _constants.LOCALHOST_MODE ? _offline.default : _online.default;
-
-  var _splitFactory = splitFactory(context, readyLatencyTrackers),
-      mainClientInstance = _splitFactory.api,
-      mainClientMetricCollectors = _splitFactory.metricCollectors; // It makes no sense to have multiple instances of the manager.
-
-
-  var managerInstance = (0, _manager.default)(storage.splits, context);
-  var parsedDefaultKey = (0, _parser.default)(settings.core.key);
-  var defaultInstanceId = buildInstanceId(parsedDefaultKey, settings.core.trafficType);
-  clientInstances[defaultInstanceId] = mainClientInstance;
-  log.info('New Split SDK instance created.');
-  return {
-    // Split evaluation and event tracking engine
-    client: function client(key, trafficType) {
-      if (key === undefined) {
-        log.debug('Retrieving default SDK client.');
-        return mainClientInstance;
-      }
-
-      if (typeof storage.shared != 'function') {
-        throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');
-      } // Validate the key value
-
-
-      var validKey = (0, _inputValidation.validateKey)(key, 'Shared Client instantiation');
-
-      if (validKey === false) {
-        throw new Error('Shared Client needs a valid key.');
-      }
-
-      var validTrafficType;
-
-      if (trafficType !== undefined) {
-        validTrafficType = (0, _inputValidation.validateTrafficType)(trafficType, 'Shared Client instantiation');
-
-        if (validTrafficType === false) {
-          throw new Error('Shared Client needs a valid traffic type or no traffic type at all.');
-        }
-      }
-
-      var instanceId = buildInstanceId(validKey, validTrafficType);
-
-      if (!clientInstances[instanceId]) {
-        var sharedSettings = settings.overrideKeyAndTT(validKey, validTrafficType);
-        var sharedContext = new _context.default();
-
-        var _readiness = gateFactory(sharedSettings.startup.readyTimeout);
-
-        sharedContext.put(context.constants.READY_FROM_CACHE, context.get(context.constants.READY_FROM_CACHE, true));
-        sharedContext.put(context.constants.READINESS, _readiness); // for shared clients, the internal offset of added/removed SDK_READY callbacks is -1
-
-        sharedContext.put(context.constants.STATUS_MANAGER, (0, _statusManager.default)(sharedContext, -1));
-        sharedContext.put(context.constants.SETTINGS, sharedSettings);
-        sharedContext.put(context.constants.STORAGE, storage.shared(sharedSettings));
-        sharedContext.put(context.constants.IMPRESSIONS_COUNTER, impressionsCounter); // As shared clients reuse all the storage information, we don't need to check here if we
-        // will use offline or online mode. We should stick with the original decision.
-
-        clientInstances[instanceId] = splitFactory(sharedContext, false, mainClientMetricCollectors).api;
-        log.info('New shared client instance created.');
-      } else {
-        log.debug('Retrieving existing SDK client.');
-      }
-
-      return clientInstances[instanceId];
-    },
-    // Manager API to explore available information
-    manager: function manager() {
-      log.info('Manager instance retrieved.');
-      return managerInstance;
-    },
-    // Logger wrapper API
-    Logger: _logger.API,
-    // Expose SDK settings
-    settings: settings
-  };
-}
+/**
+Copyright 2022 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitFactory = void 0;
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "SplitFactory", { enumerable: true, get: function () { return factory_1.SplitFactory; } });