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

package/esm/settings/runtime/node.js

@@ -0,0 +1,17 @@
+import osFunction from 'os';
+import { address } from '../../utils/ip';
+import { UNKNOWN, NA, CONSUMER_MODE } from '@splitsoftware/splitio-commons/esm/utils/constants';
+export function validateRuntime(settings) {
+    var isIPAddressesEnabled = settings.core.IPAddressesEnabled === true;
+    var isConsumerMode = settings.mode === 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 = address() || (isConsumerMode ? UNKNOWN : false);
+    var hostname = osFunction.hostname() || (isConsumerMode ? 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 ? NA : false;
+    }
+    return {
+        ip: ip,
+        hostname: hostname
+    };
+}

package/esm/settings/storage/browser.js

@@ -0,0 +1,31 @@
+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, expirationDays = _b.expirationDays, clearOnInit = _b.clearOnInit;
+    var __originalType;
+    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. Fallback into MEMORY storage');
+    }
+    return {
+        type: type,
+        options: options,
+        prefix: prefix,
+        expirationDays: expirationDays,
+        clearOnInit: clearOnInit,
+        __originalType: __originalType
+    };
+}

package/esm/settings/storage/node.js

@@ -0,0 +1,63 @@
+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;
+    // 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. Fallback 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, 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 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. Fallback into default MEMORY storage.");
+            return {
+                type: STORAGE_MEMORY,
+                prefix: prefix
+            };
+        }
+    }
+}

package/esm/sync/offline/LocalhostFromFile.js

@@ -0,0 +1,5 @@
+import { splitsParserFromFileFactory } from './splitsParserFromFile';
+import { syncManagerOfflineFactory } from '@splitsoftware/splitio-commons/esm/sync/offline/syncManagerOffline';
+// Singleton instance of the factory function for offline SyncManager from YAML file
+// It uses Node.js APIs.
+export var localhostFromFileFactory = syncManagerOfflineFactory(splitsParserFromFileFactory);

package/esm/sync/offline/splitsParserFromFile.js

@@ -0,0 +1,143 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { isString, endsWith, find, forOwn, uniq, } from '@splitsoftware/splitio-commons/esm/utils/lang';
+import { parseCondition } from '@splitsoftware/splitio-commons/esm/sync/offline/splitsParser/parseCondition';
+var logPrefix = 'sync:offline:fetcher: ';
+var DEFAULT_FILENAME = '.split';
+function configFilesPath(configFilePath) {
+    if (configFilePath === DEFAULT_FILENAME || !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.join(root, DEFAULT_FILENAME);
+    }
+    // Validate the extensions
+    if (!(endsWith(configFilePath, '.yaml', true) || endsWith(configFilePath, '.yml', true) || 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.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
+    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 = find(conditions, function (cond) { return cond.conditionType === 'ROLLOUT'; });
+        // Malformed mocks may have
+        var treatments = 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;
+    });
+}
+export 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.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 = 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.readFileSync(filePath, 'utf8');
+            if (data === previousMock)
+                return false;
+            previousMock = data;
+            yamldoc = yaml.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 || !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 = 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 (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;
+    };
+}

package/esm/umd.js

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

package/esm/utils/ip.js

@@ -0,0 +1,109 @@
+/* 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.
+*/
+import os from '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`.
+//
+export function address(name, family) {
+    var interfaces = os.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];
+}

package/package.json

@@ -1,83 +1,124 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.5.0-rc.0",
-  "description": "Split JavaScript SDK common components",
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
-  "types": "types",
+  "version": "11.5.0-rc.0",
+  "description": "Split SDK",
   "files": [
     "README.md",
     "CONTRIBUTORS-GUIDE.md",
     "LICENSE",
     "CHANGES.txt",
     "cjs",
+    "types",
     "esm",
     "src",
-    "types"
+    "client",
+    "server"
+  ],
+  "repository": "splitio/javascript-client",
+  "homepage": "https://github.com/splitio/javascript-client#readme",
+  "bugs": "https://github.com/splitio/javascript-client/issues",
+  "license": "Apache-2.0",
+  "author": "Facundo Cabrera <facundo@split.io>",
+  "contributors": [
+    {
+      "name": "Nico Zelaya",
+      "email": "nicolas.zelaya@split.io",
+      "url": "https://github.com/NicoZelaya"
+    }
   ],
-  "scripts": {
-    "check": "npm run check:lint && npm run check:types",
-    "check:lint": "eslint src types --ext .js,.ts",
-    "check:types": "tsc --noEmit",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:esm": "rimraf esm && tsc -m es2015 --outDir esm",
-    "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
-    "test": "jest",
-    "test:coverage": "jest --coverage",
-    "all": "npm run check && npm run build && npm run test",
-    "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
-    "publish:stable": "npm run check && npm run test && npm run build && npm publish"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/splitio/javascript-commons.git"
-  },
   "keywords": [
     "splitio",
     "sdk",
     "javascript"
   ],
-  "author": "Emiliano Sanchez <emiliano.sanchez@split.io> (https://github.com/EmilianoSanchez)",
-  "contributors": [
-    "Nicolas Zelaya <nicolas.zelaya@split.io> (https://github.com/NicoZelaya)"
-  ],
-  "license": "Apache-2.0",
-  "bugs": "https://github.com/splitio/javascript-commons/issues",
-  "homepage": "https://github.com/splitio/javascript-commons#readme",
-  "dependencies": {
-    "@types/ioredis": "^4.28.0",
-    "tslib": "^2.3.1"
-  },
-  "peerDependencies": {
-    "ioredis": "^4.28.0"
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "types",
+  "engines": {
+    "node": ">=14.0.0"
   },
-  "peerDependenciesMeta": {
-    "ioredis": {
-      "optional": true
-    }
+  "dependencies": {
+    "@splitsoftware/splitio-commons": "2.5.0-rc.0",
+    "bloom-filters": "^3.0.4",
+    "ioredis": "^4.28.0",
+    "js-yaml": "^3.13.1",
+    "node-fetch": "^2.7.0",
+    "tslib": "^2.3.1",
+    "unfetch": "^4.2.0"
   },
   "devDependencies": {
-    "@types/google.analytics": "0.0.40",
-    "@types/ioredis": "^4.28.0",
-    "@types/jest": "^27.0.0",
-    "@types/lodash": "^4.14.162",
-    "@typescript-eslint/eslint-plugin": "^6.6.0",
-    "@typescript-eslint/parser": "^6.6.0",
-    "cross-env": "^7.0.2",
+    "@types/node-fetch": "^2.6.10",
+    "@types/seedrandom": "^3.0.2",
+    "copyfiles": "^2.4.1",
+    "cross-env": "^7.0.3",
+    "csv-streamify": "4.0.0",
     "eslint": "^8.48.0",
-    "eslint-plugin-compat": "^6.0.1",
-    "eslint-plugin-import": "^2.25.3",
-    "eslint-plugin-tsdoc": "^0.3.0",
-    "fetch-mock": "^9.11.0",
-    "ioredis": "^4.28.0",
-    "jest": "^27.2.3",
-    "jest-localstorage-mock": "^2.4.3",
+    "eslint-plugin-compat": "^4.2.0",
+    "eslint-plugin-import": "^2.25.4",
+    "fetch-mock": "^11.1.5",
+    "karma": "^6.3.16",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-tap": "^4.2.0",
+    "karma-webpack": "^5.0.0",
     "lodash": "^4.17.21",
-    "node-fetch": "^2.7.0",
+    "node-polyfill-webpack-plugin": "^1.1.4",
+    "proxyquire": "^2.1.3",
+    "puppeteer": "^3.3.0",
+    "redis-dumpz": "0.1.12",
     "redis-server": "1.2.2",
+    "replace": "^1.2.1",
     "rimraf": "^3.0.2",
-    "ts-jest": "^27.0.5",
-    "typescript": "4.4.4"
+    "sinon": "^9.2.4",
+    "tap-min": "^2.0.0",
+    "tape": "4.13.2",
+    "tape-catch": "1.0.6",
+    "ts-loader": "^9.2.6",
+    "ts-node": "^10.5.0",
+    "typescript": "4.4.4",
+    "webpack": "^5.53.0",
+    "webpack-cli": "^4.8.0",
+    "webpack-merge": "^5.8.0"
+  },
+  "scripts": {
+    "build-esm": "rimraf esm && tsc -outDir esm",
+    "postbuild-esm": "cross-env NODE_ENV=esm node scripts/copy.packages.json.js && ./scripts/build_esm_replace_imports.sh",
+    "build-umd:stats": "webpack --progress --env production --json > ./stats/stat_results.json",
+    "build-cjs": "rimraf cjs && tsc -outDir cjs -m CommonJS",
+    "postbuild-cjs": "cross-env NODE_ENV=cjs node scripts/copy.packages.json.js && ./scripts/build_cjs_replace_imports.sh",
+    "build-umd": "rimraf umd && webpack --config webpack.dev.js --env branch=$BUILD_BRANCH && webpack --config webpack.prod.js --env branch=$BUILD_BRANCH && ./scripts/clean_umd_build.sh",
+    "build:npm": "npm run build-cjs && npm run build-esm",
+    "build": "npm run build-cjs && npm run build-esm && npm run build-umd",
+    "check": "npm run check:lint && npm run check:version",
+    "check:lint": "eslint src",
+    "check:version": "cross-env NODE_ENV=test tape -r ./ts-node.register src/settings/__tests__/defaults.spec.js",
+    "test-browser": "npm run test-browser-unit && npm run test-browser-e2e",
+    "test-browser-unit": "cross-env NODE_ENV=test karma start karma/unit.karma.conf.js",
+    "test-browser-e2e": "npm run test-browser-e2e-online && npm run test-browser-e2e-offline && npm run test-browser-e2e-destroy && npm run test-browser-e2e-errorCatching && npm run test-browser-e2e-push",
+    "test-browser-e2e-online": "cross-env NODE_ENV=test karma start karma/e2e.online.karma.conf.js",
+    "test-browser-e2e-offline": "cross-env NODE_ENV=test karma start karma/e2e.offline.karma.conf.js",
+    "test-browser-e2e-destroy": "cross-env NODE_ENV=test karma start karma/e2e.destroy.karma.conf.js",
+    "test-browser-e2e-errorCatching": "cross-env NODE_ENV=test karma start karma/e2e.errorCatching.karma.conf.js",
+    "test-browser-e2e-push": "cross-env NODE_ENV=test karma start karma/e2e.push.karma.conf.js",
+    "test-node": "npm run test-node-unit && npm run test-node-e2e",
+    "test-node-unit": "cross-env NODE_ENV=test tape -r ./ts-node.register \"src/*/**/__tests__/**/!(browser).spec.js\" | tap-min",
+    "test-node-e2e": "npm run test-node-e2e-online && npm run test-node-e2e-offline && npm run test-node-e2e-destroy && npm run test-node-e2e-errorCatching && npm run test-node-e2e-push && npm run test-node-e2e-redis",
+    "test-node-e2e-online": "cross-env NODE_ENV=test tape -r ./ts-node.register src/__tests__/online/node.spec.js | tap-min",
+    "test-node-e2e-offline": "cross-env NODE_ENV=test tape -r ./ts-node.register src/__tests__/offline/node.spec.js | tap-min",
+    "test-node-e2e-destroy": "cross-env NODE_ENV=test tape -r ./ts-node.register src/__tests__/destroy/node.spec.js | tap-min",
+    "test-node-e2e-errorCatching": "cross-env NODE_ENV=test tape -r ./ts-node.register src/__tests__/errorCatching/node.spec.js | tap-min",
+    "test-node-e2e-push": "cross-env NODE_ENV=test tape -r ./ts-node.register src/__tests__/push/node.spec.js | tap-min",
+    "test-node-e2e-redis": "cross-env NODE_ENV=test tape -r ./ts-node.register src/__tests__/consumer/node_redis.spec.js | tap-min",
+    "test-ts-decls": "tsc --build ts-tests",
+    "test": "npm run test-node && npm run test-browser",
+    "all": "npm run check && npm run build && npm run test-ts-decls && npm run test",
+    "publish:rc": "npm run check && npm run build && npm publish --tag canary",
+    "publish:stable": "npm run check && npm run build && npm publish"
   },
-  "sideEffects": false
+  "greenkeeper": {
+    "ignore": [
+      "karma",
+      "karma-tap",
+      "karma-webpack"
+    ]
+  }
 }

package/server/package.json

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

package/src/factory/browser.js

@@ -0,0 +1,85 @@
+import { splitApiFactory } from '@splitsoftware/splitio-commons/src/services/splitApi';
+import { syncManagerOnlineFactory } from '@splitsoftware/splitio-commons/src/sync/syncManagerOnline';
+import { pushManagerFactory } from '@splitsoftware/splitio-commons/src/sync/streaming/pushManager';
+import { pollingManagerCSFactory } from '@splitsoftware/splitio-commons/src/sync/polling/pollingManagerCS';
+import { InLocalStorage } from '@splitsoftware/splitio-commons/src/storages/inLocalStorage';
+import { InMemoryStorageCSFactory } from '@splitsoftware/splitio-commons/src/storages/inMemory/InMemoryStorageCS';
+import { sdkManagerFactory } from '@splitsoftware/splitio-commons/src/sdkManager';
+import { sdkClientMethodCSFactory } from '@splitsoftware/splitio-commons/src/sdkClient/sdkClientMethodCS';
+import { impressionObserverCSFactory } from '@splitsoftware/splitio-commons/src/trackers/impressionObserver/impressionObserverCS';
+import { __InLocalStorageMockFactory } from '@splitsoftware/splitio-commons/src/utils/settingsValidation/storage/storageCS';
+import { sdkFactory } from '@splitsoftware/splitio-commons/src/sdkFactory';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '@splitsoftware/splitio-commons/src/utils/constants';
+import { createUserConsentAPI } from '@splitsoftware/splitio-commons/src/consent/sdkUserConsent';
+import { localhostFromObjectFactory } from '@splitsoftware/splitio-commons/src/sync/offline/LocalhostFromObject';
+
+import { settingsFactory } from '../settings/browser';
+import { platform, SignalListener } from '../platform';
+
+const 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) {
+
+  const modules = {
+    settings,
+
+    platform,
+
+    storageFactory: getStorage(settings),
+
+    splitApiFactory,
+
+    syncManagerFactory: syncManagerOnlineCSFactory,
+
+    sdkManagerFactory,
+
+    sdkClientMethodFactory: sdkClientMethodCSFactory,
+
+    SignalListener,
+
+    impressionsObserverFactory: impressionObserverCSFactory,
+
+    extraProps: (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) {
+  const settings = settingsFactory(config);
+  const modules = getModules(settings);
+  if (__updateModules) __updateModules(modules);
+  return sdkFactory(modules);
+}