@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/cjs/settings/integrations/browser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateIntegrations = void 0;
+var browser_1 = require("@splitsoftware/splitio-commons/cjs/utils/constants/browser");
+var configurable_1 = require("@splitsoftware/splitio-commons/cjs/utils/settingsValidation/integrations/configurable");
+function validateIntegrations(settings) {
+    return (0, configurable_1.validateConfigurableIntegrations)(settings, [browser_1.GOOGLE_ANALYTICS_TO_SPLIT, browser_1.SPLIT_TO_GOOGLE_ANALYTICS]);
+}
+exports.validateIntegrations = validateIntegrations;

package/cjs/settings/node.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settingsFactory = void 0;
+var settingsValidation_1 = require("@splitsoftware/splitio-commons/cjs/utils/settingsValidation");
+var builtinLogger_1 = require("@splitsoftware/splitio-commons/cjs/utils/settingsValidation/logger/builtinLogger");
+var node_1 = require("./defaults/node");
+var node_2 = require("./storage/node");
+var node_3 = require("./runtime/node");
+var params = {
+    defaults: node_1.defaults,
+    runtime: node_3.validateRuntime,
+    storage: node_2.validateStorage,
+    logger: builtinLogger_1.validateLogger,
+};
+function settingsFactory(config) {
+    var settings = (0, settingsValidation_1.settingsValidation)(config, params);
+    // if provided, keeps reference to the `requestOptions` object
+    if (settings.sync.requestOptions)
+        settings.sync.requestOptions = config.sync.requestOptions;
+    return settings;
+}
+exports.settingsFactory = settingsFactory;

package/cjs/settings/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/cjs/settings/runtime/node.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRuntime = void 0;
+var tslib_1 = require("tslib");
+var os_1 = (0, tslib_1.__importDefault)(require("os"));
+var ip_1 = require("../../utils/ip");
+var constants_1 = require("@splitsoftware/splitio-commons/cjs/utils/constants");
+function validateRuntime(settings) {
+    var isIPAddressesEnabled = settings.core.IPAddressesEnabled === true;
+    var isConsumerMode = settings.mode === constants_1.CONSUMER_MODE;
+    // If the values are not available, default to false (for standalone) or "unknown" (for consumer mode, to be used on Redis keys)
+    var ip = (0, ip_1.address)() || (isConsumerMode ? constants_1.UNKNOWN : false);
+    var hostname = os_1.default.hostname() || (isConsumerMode ? constants_1.UNKNOWN : false);
+    if (!isIPAddressesEnabled) { // If IPAddresses setting is not enabled, set as false (for standalone) or "NA" (for consumer mode, to  be used on Redis keys)
+        ip = hostname = isConsumerMode ? constants_1.NA : false;
+    }
+    return {
+        ip: ip,
+        hostname: hostname
+    };
+}
+exports.validateRuntime = validateRuntime;

package/cjs/settings/storage/browser.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStorage = void 0;
+var isLocalStorageAvailable_1 = require("@splitsoftware/splitio-commons/cjs/utils/env/isLocalStorageAvailable");
+var constants_1 = require("@splitsoftware/splitio-commons/cjs/utils/constants");
+var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
+function validateStorage(settings) {
+    var log = settings.log, mode = settings.mode, _a = settings.storage, _b = _a === void 0 ? { type: constants_1.STORAGE_MEMORY } : _a, type = _b.type, _c = _b.options, options = _c === void 0 ? {} : _c, prefix = _b.prefix, expirationDays = _b.expirationDays, clearOnInit = _b.clearOnInit;
+    var __originalType;
+    var fallbackToMemory = function () {
+        __originalType = type;
+        type = constants_1.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 === constants_1.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 !== constants_1.STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE ||
+        type === STORAGE_LOCALSTORAGE && !(0, isLocalStorageAvailable_1.isLocalStorageAvailable)()) {
+        fallbackToMemory();
+        log.error('Invalid or unavailable storage. Fallback into MEMORY storage');
+    }
+    return {
+        type: type,
+        options: options,
+        prefix: prefix,
+        expirationDays: expirationDays,
+        clearOnInit: clearOnInit,
+        __originalType: __originalType
+    };
+}
+exports.validateStorage = validateStorage;

package/cjs/settings/storage/node.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStorage = void 0;
+var constants_1 = require("@splitsoftware/splitio-commons/cjs/utils/constants");
+function validateStorage(settings) {
+    var log = settings.log, mode = settings.mode, _a = settings.storage, _b = _a === void 0 ? { type: constants_1.STORAGE_MEMORY } : _a, type = _b.type, _c = _b.options, options = _c === void 0 ? {} : _c, prefix = _b.prefix;
+    // We can have MEMORY, REDIS or an invalid storage type
+    switch (type) {
+        case constants_1.STORAGE_REDIS: {
+            // If passing REDIS storage in localhost or standalone mode, we log an error and fallback to MEMORY storage
+            if (mode === constants_1.STANDALONE_MODE || mode === constants_1.LOCALHOST_MODE) {
+                log.error('The provided REDIS storage is invalid for this mode. It requires consumer mode. Fallback into default MEMORY storage.');
+                return {
+                    type: constants_1.STORAGE_MEMORY,
+                    prefix: prefix
+                };
+            }
+            var host = options.host, port = options.port, db = options.db, pass = options.pass, url = options.url, tls = options.tls, 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;
+            }
+            if (tls) {
+                newOpts.tls = tls;
+            }
+            return {
+                type: type,
+                prefix: prefix,
+                options: newOpts
+            };
+        }
+        // For now, we don't have modifiers or settings for MEMORY in Node.js
+        case constants_1.STORAGE_MEMORY:
+        default: {
+            // If passing MEMORY storage in consumer mode, throw an error (no way to fallback to REDIS storage)
+            if (mode === constants_1.CONSUMER_MODE)
+                throw new Error('A REDIS storage is required on consumer mode');
+            // If passing an invalid storage type, log an error
+            if (type !== constants_1.STORAGE_MEMORY)
+                log.error("The provided '" + type + "' storage type is invalid. Fallback into default MEMORY storage.");
+            return {
+                type: constants_1.STORAGE_MEMORY,
+                prefix: prefix
+            };
+        }
+    }
+}
+exports.validateStorage = validateStorage;

package/cjs/sync/offline/LocalhostFromFile.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localhostFromFileFactory = void 0;
+var splitsParserFromFile_1 = require("./splitsParserFromFile");
+var syncManagerOffline_1 = require("@splitsoftware/splitio-commons/cjs/sync/offline/syncManagerOffline");
+// Singleton instance of the factory function for offline SyncManager from YAML file
+// It uses Node.js APIs.
+exports.localhostFromFileFactory = (0, syncManagerOffline_1.syncManagerOfflineFactory)(splitsParserFromFile_1.splitsParserFromFileFactory);

package/cjs/sync/offline/splitsParserFromFile.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitsParserFromFileFactory = void 0;
+var tslib_1 = require("tslib");
+var fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+var path_1 = (0, tslib_1.__importDefault)(require("path"));
+var js_yaml_1 = (0, tslib_1.__importDefault)(require("js-yaml"));
+var lang_1 = require("@splitsoftware/splitio-commons/cjs/utils/lang");
+var parseCondition_1 = require("@splitsoftware/splitio-commons/cjs/sync/offline/splitsParser/parseCondition");
+var logPrefix = 'sync:offline:fetcher: ';
+var DEFAULT_FILENAME = '.split';
+function configFilesPath(configFilePath) {
+    if (configFilePath === DEFAULT_FILENAME || !(0, lang_1.isString)(configFilePath)) {
+        var root = process.env.HOME;
+        // @TODO env var not documented in help center
+        if (process.env.SPLIT_CONFIG_ROOT)
+            root = process.env.SPLIT_CONFIG_ROOT;
+        if (!root)
+            throw new Error('Missing root of the feature flags mock file.');
+        configFilePath = path_1.default.join(root, DEFAULT_FILENAME);
+    }
+    // Validate the extensions
+    if (!((0, lang_1.endsWith)(configFilePath, '.yaml', true) || (0, lang_1.endsWith)(configFilePath, '.yml', true) || (0, lang_1.endsWith)(configFilePath, '.split', true)))
+        throw new Error("Invalid extension specified for feature flags mock file. Accepted extensions are \".yml\" and \".yaml\". Your specified file is " + configFilePath);
+    if (!fs_1.default.existsSync(configFilePath))
+        throw new Error("Feature flags mock file not found in " + configFilePath + " - Please review the file location.");
+    return configFilePath;
+}
+// This function is not pure nor meant to be. Here we apply modifications to cover
+// for behavior that's ensured by the BE.
+function arrangeConditions(mocksData) {
+    // Iterate through each feature flag data
+    (0, lang_1.forOwn)(mocksData, function (data) {
+        var conditions = data.conditions;
+        // On the manager, as feature flag JSONs come with all treatments on the partitions prop,
+        // we'll add all the treatments to the first condition.
+        var firstRolloutCondition = (0, lang_1.find)(conditions, function (cond) { return cond.conditionType === 'ROLLOUT'; });
+        // Malformed mocks may have
+        var treatments = (0, lang_1.uniq)(data.treatments);
+        // If they're only specifying a whitelist we add the treatments there.
+        var allTreatmentsCondition = firstRolloutCondition ? firstRolloutCondition : conditions[0];
+        var fullyAllocatedTreatment = allTreatmentsCondition.partitions[0].treatment;
+        treatments.forEach(function (treatment) {
+            if (treatment !== fullyAllocatedTreatment) {
+                allTreatmentsCondition.partitions.push({
+                    treatment: treatment,
+                    size: 0
+                });
+            }
+        });
+        // Don't need these anymore
+        delete data.treatments;
+    });
+}
+function splitsParserFromFileFactory() {
+    var previousMock = 'NO_MOCK_LOADED';
+    // Parse `.split` configuration file and return a map of feature flag objects
+    function readFeatureFlagConfigFile(log, filePath) {
+        var FEATURE_FLAG_POSITION = 0;
+        var TREATMENT_POSITION = 1;
+        var data;
+        try {
+            data = fs_1.default.readFileSync(filePath, 'utf-8');
+        }
+        catch (e) {
+            log.error(e && e.message);
+            return {};
+        }
+        if (data === previousMock)
+            return false;
+        previousMock = data;
+        var featureFlagObjects = data.split(/\r?\n/).reduce(function (accum, line, index) {
+            var tuple = line.trim();
+            if (tuple === '' || tuple.charAt(0) === '#') {
+                log.debug(logPrefix + ("Ignoring empty line or comment at #" + index));
+            }
+            else {
+                tuple = tuple.split(/\s+/);
+                if (tuple.length !== 2) {
+                    log.debug(logPrefix + ("Ignoring line since it does not have exactly two columns #" + index));
+                }
+                else {
+                    var featureFlagName = tuple[FEATURE_FLAG_POSITION];
+                    var condition = (0, parseCondition_1.parseCondition)({ treatment: tuple[TREATMENT_POSITION] });
+                    accum[featureFlagName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
+                }
+            }
+            return accum;
+        }, {});
+        return featureFlagObjects;
+    }
+    // Parse `.yml` or `.yaml` configuration files and return a map of feature flag objects
+    function readYAMLConfigFile(log, filePath) {
+        var data = '';
+        var yamldoc = null;
+        try {
+            data = fs_1.default.readFileSync(filePath, 'utf8');
+            if (data === previousMock)
+                return false;
+            previousMock = data;
+            yamldoc = js_yaml_1.default.safeLoad(data);
+        }
+        catch (e) {
+            log.error(e);
+            return {};
+        }
+        // Each entry will be mapped to a condition, but we'll also keep the configurations map.
+        var mocksData = (yamldoc).reduce(function (accum, featureFlagEntry) {
+            var featureFlagName = Object.keys(featureFlagEntry)[0];
+            if (!featureFlagName || !(0, lang_1.isString)(featureFlagEntry[featureFlagName].treatment))
+                log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
+            var mockData = featureFlagEntry[featureFlagName];
+            // "Template" for each feature flag accumulated data
+            if (!accum[featureFlagName]) {
+                accum[featureFlagName] = {
+                    configurations: {}, conditions: [], treatments: [], trafficTypeName: 'localhost'
+                };
+            }
+            // Assign the config if there is one on the mock
+            if (mockData.config)
+                accum[featureFlagName].configurations[mockData.treatment] = mockData.config;
+            // Parse the condition from the entry.
+            var condition = (0, parseCondition_1.parseCondition)(mockData);
+            accum[featureFlagName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition);
+            // Also keep track of the treatments, will be useful for manager functionality.
+            accum[featureFlagName].treatments.push(mockData.treatment);
+            return accum;
+        }, {});
+        arrangeConditions(mocksData);
+        return mocksData;
+    }
+    // Load the content of a configuration file into an Object
+    return function featureFlagsParserFromFile(_a) {
+        var features = _a.features, log = _a.log;
+        var filePath = configFilesPath(features);
+        var mockData;
+        // If we have a filePath, it means the extension is correct, choose the parser.
+        if ((0, lang_1.endsWith)(filePath, '.split')) {
+            log.warn(logPrefix + '.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
+            mockData = readFeatureFlagConfigFile(log, filePath);
+        }
+        else {
+            mockData = readYAMLConfigFile(log, filePath);
+        }
+        return mockData;
+    };
+}
+exports.splitsParserFromFileFactory = splitsParserFromFileFactory;

package/cjs/umd.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_1 = require("./index");
+// eslint-disable-next-line import/no-default-export
+exports.default = index_1.SplitFactory;

package/cjs/utils/ip.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.address = void 0;
+var tslib_1 = require("tslib");
+/* eslint-disable no-redeclare */
+/*
+Trimmed version of "ip" package (https://www.npmjs.com/package/ip) that fixes an error when running in Node.js v18.
+
+This software is licensed under the MIT License.
+
+Copyright Fedor Indutny, 2012.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+var os_1 = (0, tslib_1.__importDefault)(require("os"));
+function _resolveFamily(family) {
+    return typeof family === 'number' ? 'ipv' + family : family.toLowerCase();
+}
+function _normalizeFamily(family) {
+    return family ? _resolveFamily(family) : 'ipv4';
+}
+function isPrivate(addr) {
+    return /^(::f{4}:)?10\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i
+        .test(addr) ||
+        /^(::f{4}:)?192\.168\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+        /^(::f{4}:)?172\.(1[6-9]|2\d|30|31)\.([0-9]{1,3})\.([0-9]{1,3})$/i
+            .test(addr) ||
+        /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+        /^(::f{4}:)?169\.254\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+        /^f[cd][0-9a-f]{2}:/i.test(addr) ||
+        /^fe80:/i.test(addr) ||
+        /^::1$/.test(addr) ||
+        /^::$/.test(addr);
+}
+function isPublic(addr) {
+    return !isPrivate(addr);
+}
+function isLoopback(addr) {
+    return /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/
+        .test(addr) ||
+        /^fe80::1$/.test(addr) ||
+        /^::1$/.test(addr) ||
+        /^::$/.test(addr);
+}
+function loopback(family) {
+    //
+    // Default to `ipv4`
+    //
+    family = _normalizeFamily(family);
+    if (family !== 'ipv4' && family !== 'ipv6') {
+        throw new Error('family must be ipv4 or ipv6');
+    }
+    return family === 'ipv4' ? '127.0.0.1' : 'fe80::1';
+}
+//
+// ### function address (name, family)
+// #### @name {string|'public'|'private'} **Optional** Name or security
+//      of the network interface.
+// #### @family {ipv4|ipv6} **Optional** IP family of the address (defaults
+//      to ipv4).
+//
+// Returns the address for the network interface on the current system with
+// the specified `name`:
+//   * String: First `family` address of the interface.
+//             If not found see `undefined`.
+//   * 'public': the first public ip address of family.
+//   * 'private': the first private ip address of family.
+//   * undefined: First address with `ipv4` or loopback address `127.0.0.1`.
+//
+function address(name, family) {
+    var interfaces = os_1.default.networkInterfaces();
+    var all;
+    //
+    // Default to `ipv4`
+    //
+    family = _normalizeFamily(family);
+    //
+    // If a specific network interface has been named,
+    // return the address.
+    //
+    if (name && name !== 'private' && name !== 'public') {
+        var res = interfaces[name].filter(function (details) {
+            var itemFamily = _resolveFamily(details.family);
+            return itemFamily === family;
+        });
+        if (res.length === 0)
+            return undefined;
+        return res[0].address;
+    }
+    var all = Object.keys(interfaces).map(function (nic) {
+        //
+        // Note: name will only be `public` or `private`
+        // when this is called.
+        //
+        var addresses = interfaces[nic].filter(function (details) {
+            details.family = _resolveFamily(details.family);
+            if (details.family !== family || isLoopback(details.address)) {
+                return false;
+            }
+            else if (!name) {
+                return true;
+            }
+            return name === 'public' ? isPrivate(details.address) :
+                isPublic(details.address);
+        });
+        return addresses.length ? addresses[0].address : undefined;
+    }).filter(Boolean);
+    return !all.length ? loopback(family) : all[0];
+}
+exports.address = address;

package/client/package.json

@@ -0,0 +1,5 @@
+{
+  "main": "../cjs/factory/browser.js",
+  "module": "../esm/factory/browser.js",
+  "types": "../types/client/index.d.ts"
+}

package/esm/factory/browser.js

@@ -0,0 +1,69 @@
+import { splitApiFactory } from '@splitsoftware/splitio-commons/esm/services/splitApi';
+import { syncManagerOnlineFactory } from '@splitsoftware/splitio-commons/esm/sync/syncManagerOnline';
+import { pushManagerFactory } from '@splitsoftware/splitio-commons/esm/sync/streaming/pushManager';
+import { pollingManagerCSFactory } from '@splitsoftware/splitio-commons/esm/sync/polling/pollingManagerCS';
+import { InLocalStorage } from '@splitsoftware/splitio-commons/esm/storages/inLocalStorage';
+import { InMemoryStorageCSFactory } from '@splitsoftware/splitio-commons/esm/storages/inMemory/InMemoryStorageCS';
+import { sdkManagerFactory } from '@splitsoftware/splitio-commons/esm/sdkManager';
+import { sdkClientMethodCSFactory } from '@splitsoftware/splitio-commons/esm/sdkClient/sdkClientMethodCS';
+import { impressionObserverCSFactory } from '@splitsoftware/splitio-commons/esm/trackers/impressionObserver/impressionObserverCS';
+import { __InLocalStorageMockFactory } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/storage/storageCS';
+import { sdkFactory } from '@splitsoftware/splitio-commons/esm/sdkFactory';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '@splitsoftware/splitio-commons/esm/utils/constants';
+import { createUserConsentAPI } from '@splitsoftware/splitio-commons/esm/consent/sdkUserConsent';
+import { localhostFromObjectFactory } from '@splitsoftware/splitio-commons/esm/sync/offline/LocalhostFromObject';
+import { settingsFactory } from '../settings/browser';
+import { platform, SignalListener } from '../platform';
+var syncManagerOnlineCSFactory = syncManagerOnlineFactory(pollingManagerCSFactory, pushManagerFactory);
+function getStorage(settings) {
+    return settings.storage.type === STORAGE_LOCALSTORAGE ?
+        InLocalStorage(settings.storage) :
+        settings.storage.__originalType === STORAGE_LOCALSTORAGE ?
+            __InLocalStorageMockFactory :
+            InMemoryStorageCSFactory;
+}
+/**
+ *
+ * @param {import("@splitsoftware/splitio-commons/types/types").ISettings} settings
+ */
+function getModules(settings) {
+    var modules = {
+        settings: settings,
+        platform: platform,
+        storageFactory: getStorage(settings),
+        splitApiFactory: splitApiFactory,
+        syncManagerFactory: syncManagerOnlineCSFactory,
+        sdkManagerFactory: sdkManagerFactory,
+        sdkClientMethodFactory: sdkClientMethodCSFactory,
+        SignalListener: SignalListener,
+        impressionsObserverFactory: impressionObserverCSFactory,
+        extraProps: function (params) {
+            return {
+                UserConsent: createUserConsentAPI(params)
+            };
+        }
+    };
+    switch (settings.mode) {
+        case LOCALHOST_MODE:
+            modules.splitApiFactory = undefined;
+            modules.syncManagerFactory = localhostFromObjectFactory;
+            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.
+ */
+export function SplitFactory(config, __updateModules) {
+    var settings = settingsFactory(config);
+    var modules = getModules(settings);
+    if (__updateModules)
+        __updateModules(modules);
+    return sdkFactory(modules);
+}

package/esm/factory/node.js

@@ -0,0 +1,75 @@
+import { splitApiFactory } from '@splitsoftware/splitio-commons/esm/services/splitApi';
+import { syncManagerOnlineFactory } from '@splitsoftware/splitio-commons/esm/sync/syncManagerOnline';
+import { pushManagerFactory } from '@splitsoftware/splitio-commons/esm/sync/streaming/pushManager';
+import { pollingManagerSSFactory } from '@splitsoftware/splitio-commons/esm/sync/polling/pollingManagerSS';
+import { InRedisStorage } from '@splitsoftware/splitio-commons/esm/storages/inRedis';
+import { InMemoryStorageFactory } from '@splitsoftware/splitio-commons/esm/storages/inMemory/InMemoryStorage';
+import { getCache } from '@splitsoftware/splitio-commons/esm/storages/dataLoader';
+import { sdkManagerFactory } from '@splitsoftware/splitio-commons/esm/sdkManager';
+import { sdkClientMethodFactory } from '@splitsoftware/splitio-commons/esm/sdkClient/sdkClientMethod';
+import { impressionObserverSSFactory } from '@splitsoftware/splitio-commons/esm/trackers/impressionObserver/impressionObserverSS';
+import { sdkFactory } from '@splitsoftware/splitio-commons/esm/sdkFactory';
+import { CONSUMER_MODE, LOCALHOST_MODE } from '@splitsoftware/splitio-commons/esm/utils/constants';
+import { localhostFromFileFactory } from '../sync/offline/LocalhostFromFile';
+import { settingsFactory } from '../settings/node';
+import { platform, SignalListener } from '../platform';
+import { bloomFilterFactory } from '../platform/filter/bloomFilter';
+var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
+function getStorage(settings) {
+    return settings.storage.type === 'REDIS' ?
+        InRedisStorage(settings.storage) :
+        InMemoryStorageFactory;
+}
+/**
+ *
+ * @param {import("@splitsoftware/splitio-commons/types/types").ISettings} settings
+ */
+function getModules(settings) {
+    var modules = {
+        settings: settings,
+        platform: platform,
+        storageFactory: getStorage(settings),
+        splitApiFactory: splitApiFactory,
+        syncManagerFactory: syncManagerOnlineSSFactory,
+        sdkManagerFactory: sdkManagerFactory,
+        sdkClientMethodFactory: sdkClientMethodFactory,
+        SignalListener: SignalListener,
+        impressionsObserverFactory: impressionObserverSSFactory,
+        filterAdapterFactory: bloomFilterFactory,
+        extraProps: function (params) {
+            if (params.settings.mode !== CONSUMER_MODE) {
+                return {
+                    getCache: function (userKeys) {
+                        return getCache(params.settings.log, params.storage, userKeys);
+                    }
+                };
+            }
+        }
+    };
+    switch (settings.mode) {
+        case LOCALHOST_MODE:
+            modules.splitApiFactory = undefined;
+            modules.syncManagerFactory = localhostFromFileFactory;
+            modules.SignalListener = undefined;
+            break;
+        case 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.
+ */
+export function SplitFactory(config, __updateModules) {
+    var settings = settingsFactory(config);
+    var modules = getModules(settings);
+    if (__updateModules)
+        __updateModules(modules);
+    return sdkFactory(modules);
+}

package/esm/factory/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/esm/index.js

@@ -1,10 +1 @@
-// InMemory storage factory for standalone server-side SplitFactory
-export { InMemoryStorageFactory } from './storages/inMemory/InMemoryStorage';
-// InMemory storage factory for standalone client-side SplitFactory
-export { InMemoryStorageCSFactory } from './storages/inMemory/InMemoryStorageCS';
-// InLocalStorage factory for standalone client-side SplitFactory in Web browsers
-export { InLocalStorage } from './storages/inLocalStorage';
-// Pluggable storage factory for consumer/producer mode
-export { PluggableStorage } from './storages/pluggable';
-// Pluggable storage factory for consumer/producer mode
-export { InRedisStorage } from './storages/inRedis';
+export { SplitFactory } from './factory';