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

package/esm/sdkClient/sdkClientMethodCS.js

@@ -1,62 +0,0 @@
-import { clientCSDecorator } from './clientCS';
-import { validateKey } from '../utils/inputValidation/key';
-import { getMatching, keyParser } from '../utils/key';
-import { sdkClientFactory } from './sdkClient';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
-import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
-import { buildInstanceId } from './identity';
-/**
- * Factory of client method for the client-side API variant where TT is ignored.
- * Therefore, clients don't have a bound TT for the track method.
- */
-export function sdkClientMethodCSFactory(params) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
-    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key);
-    var parsedDefaultKey = keyParser(key);
-    var defaultInstanceId = buildInstanceId(parsedDefaultKey);
-    // Cache instances created per factory.
-    clients[defaultInstanceId] = mainClientInstance;
-    return function client(key) {
-        if (key === undefined) {
-            log.debug(RETRIEVE_CLIENT_DEFAULT);
-            return mainClientInstance;
-        }
-        // Validate the key value
-        var validKey = validateKey(log, key, LOG_PREFIX_CLIENT_INSTANTIATION);
-        if (validKey === false) {
-            throw new Error('Shared Client needs a valid key.');
-        }
-        var instanceId = buildInstanceId(validKey);
-        if (!clients[instanceId]) {
-            var matchingKey = getMatching(validKey);
-            var sharedSdkReadiness_1 = sdkReadinessManager.shared();
-            var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
-                if (err) {
-                    sharedSdkReadiness_1.readinessManager.timeout();
-                    return;
-                }
-                // Emit SDK_READY in consumer mode for shared clients
-                sharedSdkReadiness_1.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
-            });
-            // 3 possibilities:
-            // - Standalone mode: both syncManager and sharedSyncManager are defined
-            // - Consumer mode: both syncManager and sharedSyncManager are undefined
-            // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
-            // @ts-ignore
-            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
-            // 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.
-            clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
-                sdkReadinessManager: sharedSdkReadiness_1,
-                storage: sharedStorage || storage,
-                syncManager: sharedSyncManager,
-            }), true), validKey);
-            log.info(NEW_SHARED_CLIENT);
-        }
-        else {
-            log.debug(RETRIEVE_CLIENT_EXISTING);
-        }
-        return clients[instanceId];
-    };
-}

package/esm/sdkFactory/index.js

@@ -1,104 +0,0 @@
-import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
-import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
-import { eventTrackerFactory } from '../trackers/eventTracker';
-import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
-import { createLoggerAPI } from '../logger/sdkLogger';
-import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
-import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
-import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
-import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { DEBUG, OPTIMIZED } from '../utils/constants';
-/**
- * Modular SDK factory
- */
-export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
-    var log = settings.log, impressionsMode = settings.sync.impressionsMode;
-    // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
-    // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-    // initialization
-    var hasInit = false;
-    var initCallbacks = [];
-    function whenInit(cb) {
-        if (hasInit)
-            cb();
-        else
-            initCallbacks.push(cb);
-    }
-    var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
-    var readiness = sdkReadinessManager.readinessManager;
-    var storage = storageFactory({
-        settings: settings,
-        onReadyCb: function (error) {
-            if (error) {
-                // If storage fails to connect, SDK_READY_TIMED_OUT event is emitted immediately. Review when timeout and non-recoverable errors are reworked
-                readiness.timeout();
-                return;
-            }
-            readiness.splits.emit(SDK_SPLITS_ARRIVED);
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-        },
-        onReadyFromCacheCb: function () {
-            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-        }
-    });
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
-    var clients = {};
-    var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
-    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
-    var observer = impressionsObserverFactory();
-    var uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
-    var noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
-    var strategy = impressionsMode === OPTIMIZED ?
-        strategyOptimizedFactory(observer, storage.impressionCounts) :
-        impressionsMode === DEBUG ?
-            strategyDebugFactory(observer) :
-            noneStrategy;
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
-    var eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
-    // splitApi is used by SyncManager and Browser signal listener
-    var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
-    var syncManager = syncManagerFactory && syncManagerFactory(ctx);
-    ctx.syncManager = syncManager;
-    var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
-    ctx.signalListener = signalListener;
-    // SDK client and manager
-    var clientMethod = sdkClientMethodFactory(ctx);
-    var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-    function init() {
-        if (hasInit)
-            return;
-        hasInit = true;
-        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-        validateAndTrackApiKey(log, settings.core.authorizationKey);
-        readiness.init();
-        uniqueKeysTracker.start();
-        syncManager && syncManager.start();
-        signalListener && signalListener.start();
-        initCallbacks.forEach(function (cb) { return cb(); });
-        initCallbacks.length = 0;
-    }
-    log.info(NEW_FACTORY);
-    // @ts-ignore
-    return objectAssign({
-        // Split evaluation and event tracking engine
-        client: clientMethod,
-        // Manager API to explore available information
-        manager: function () {
-            log.debug(RETRIEVE_MANAGER);
-            return managerInstance;
-        },
-        // Logger wrapper API
-        Logger: createLoggerAPI(log),
-        settings: settings,
-        destroy: function () {
-            hasInit = false;
-            return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
-        }
-    }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());
-}

package/esm/sdkFactory/types.js

@@ -1 +0,0 @@
-export {};

package/esm/sdkManager/index.js

@@ -1,92 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { thenable } from '../utils/promise/thenable';
-import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
-import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
-function collectTreatments(splitObject) {
-    var conditions = splitObject.conditions;
-    // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
-    var allTreatmentsCondition = find(conditions, function (cond) { return cond.conditionType === 'ROLLOUT'; });
-    // Localstorage mode could fall into a no rollout conditions state. Take the first condition in that case.
-    if (!allTreatmentsCondition)
-        allTreatmentsCondition = conditions[0];
-    // Then extract the treatments from the partitions
-    return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(function (v) { return v.treatment; }) : [];
-}
-function objectToView(splitObject) {
-    if (!splitObject)
-        return null;
-    return {
-        name: splitObject.name,
-        trafficType: splitObject.trafficTypeName,
-        killed: splitObject.killed,
-        changeNumber: splitObject.changeNumber || 0,
-        treatments: collectTreatments(splitObject),
-        configs: splitObject.configurations || {},
-        sets: splitObject.sets || [],
-        defaultTreatment: splitObject.defaultTreatment,
-        impressionsDisabled: splitObject.impressionsDisabled === true,
-        prerequisites: (splitObject.prerequisites || []).map(function (p) { return ({ flagName: p.n, treatments: p.ts }); }),
-    };
-}
-function objectsToViews(splitObjects) {
-    var views = [];
-    splitObjects.forEach(function (split) {
-        var view = objectToView(split);
-        if (view)
-            views.push(view);
-    });
-    return views;
-}
-export function sdkManagerFactory(settings, splits, _a) {
-    var readinessManager = _a.readinessManager, sdkStatus = _a.sdkStatus;
-    var log = settings.log, mode = settings.mode;
-    var isAsync = isConsumerMode(mode);
-    return objectAssign(
-    // Proto-linkage of the readiness Event Emitter
-    Object.create(sdkStatus), {
-        /**
-         * Get the feature flag object corresponding to the given feature flag name if valid
-         */
-        split: function (featureFlagName) {
-            var splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
-            if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
-                return isAsync ? Promise.resolve(null) : null;
-            }
-            var split = splits.getSplit(splitName);
-            if (thenable(split)) {
-                return split.catch(function () { return null; }).then(function (result) {
-                    validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
-                    return objectToView(result);
-                });
-            }
-            validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
-            return objectToView(split);
-        },
-        /**
-         * Get the feature flag objects present on the factory storage
-         */
-        splits: function () {
-            if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
-                return isAsync ? Promise.resolve([]) : [];
-            }
-            var currentSplits = splits.getAll();
-            return thenable(currentSplits) ?
-                currentSplits.catch(function () { return []; }).then(objectsToViews) : // handle possible rejections when using pluggable storage
-                objectsToViews(currentSplits);
-        },
-        /**
-         * Get the feature flag names present on the factory storage
-         */
-        names: function () {
-            if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
-                return isAsync ? Promise.resolve([]) : [];
-            }
-            var splitNames = splits.getSplitNames();
-            return thenable(splitNames) ?
-                splitNames.catch(function () { return []; }) : // handle possible rejections when using pluggable storage
-                splitNames;
-        }
-    });
-}

package/esm/services/decorateHeaders.js

@@ -1,35 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-var FORBIDDEN_HEADERS = new Set([
-    'splitsdkclientkey',
-    'splitsdkversion',
-    'splitsdkmachineip',
-    'splitsdkmachinename',
-    'splitsdkimpressionsmode',
-    'host',
-    'referrer',
-    'content-type',
-    'content-length',
-    'content-encoding',
-    'accept',
-    'keep-alive',
-    'x-fastly-debug'
-]);
-export function decorateHeaders(settings, headers) {
-    var _a;
-    if ((_a = settings.sync.requestOptions) === null || _a === void 0 ? void 0 : _a.getHeaderOverrides) {
-        try {
-            var headerOverrides_1 = settings.sync.requestOptions.getHeaderOverrides({ headers: objectAssign({}, headers) });
-            Object.keys(headerOverrides_1)
-                .filter(function (key) { return !FORBIDDEN_HEADERS.has(key.toLowerCase()); })
-                .forEach(function (key) { return headers[key] = headerOverrides_1[key]; });
-        }
-        catch (e) {
-            settings.log.error('Problem adding custom headers to request decorator: ' + e);
-        }
-    }
-    return headers;
-}
-export function removeNonISO88591(input) {
-    // eslint-disable-next-line no-control-regex
-    return input.replace(/[^\x00-\xFF]/g, '');
-}

package/esm/services/splitApi.js

@@ -1,127 +0,0 @@
-import { splitHttpClientFactory } from './splitHttpClient';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
-import { ERROR_TOO_MANY_SETS } from '../logger/constants';
-var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
-function userKeyToQueryParam(userKey) {
-    return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
-}
-/**
- * Factory of SplitApi objects, which group the collection of Split HTTP endpoints used by the SDK
- *
- * @param settings - validated settings object
- * @param platform - object containing environment-specific dependencies
- * @param telemetryTracker - telemetry tracker
- */
-export function splitApiFactory(settings, platform, telemetryTracker) {
-    var urls = settings.urls;
-    var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
-    var SplitSDKImpressionsMode = settings.sync.impressionsMode;
-    var splitHttpClient = splitHttpClientFactory(settings, platform);
-    return {
-        // @TODO throw errors if health check requests fail, to log them in the Synchronizer
-        getSdkAPIHealthCheck: function () {
-            var url = urls.sdk + "/version";
-            return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
-        },
-        getEventsAPIHealthCheck: function () {
-            var url = urls.events + "/version";
-            return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
-        },
-        fetchAuth: function (userMatchingKeys) {
-            var url = urls.auth + "/v2/auth?s=" + settings.sync.flagSpecVersion;
-            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-                if (queryParams)
-                    url += '&' + queryParams;
-            }
-            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-        },
-        fetchSplitChanges: function (since, noCache, till, rbSince) {
-            var url = urls.sdk + "/splitChanges?s=" + settings.sync.flagSpecVersion + "&since=" + since + (rbSince ? '&rbSince=' + rbSince : '') + (filterQueryString || '') + (till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
-                .catch(function (err) {
-                if (err.statusCode === 414)
-                    settings.log.error(ERROR_TOO_MANY_SETS);
-                throw err;
-            });
-        },
-        fetchSegmentChanges: function (since, segmentName, noCache, till) {
-            var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
-        },
-        fetchMemberships: function (userMatchingKey, noCache, till) {
-            /**
-             * URI encoding of user keys in order to:
-             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
-             *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
-             *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
-             */
-            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey) + (till ? '?till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
-        },
-        /**
-         * Post events.
-         *
-         * @param body -  Events bulk payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postEventsBulk: function (body, headers) {
-            var url = urls.events + "/events/bulk";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));
-        },
-        /**
-         * Post impressions.
-         *
-         * @param body -  Impressions bulk payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postTestImpressionsBulk: function (body, headers) {
-            var url = urls.events + "/testImpressions/bulk";
-            return splitHttpClient(url, {
-                // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
-                method: 'POST',
-                body: body,
-                headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
-            }, telemetryTracker.trackHttp(IMPRESSIONS));
-        },
-        /**
-         * Post impressions counts.
-         *
-         * @param body -  Impressions counts payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postTestImpressionsCount: function (body, headers) {
-            var url = urls.events + "/testImpressions/count";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
-        },
-        /**
-         * Post unique keys for client side.
-         *
-         * @param body -  unique keys payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postUniqueKeysBulkCs: function (body, headers) {
-            var url = urls.telemetry + "/v1/keys/cs";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
-        },
-        /**
-         * Post unique keys for server side.
-         *
-         * @param body -  unique keys payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postUniqueKeysBulkSs: function (body, headers) {
-            var url = urls.telemetry + "/v1/keys/ss";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
-        },
-        postMetricsConfig: function (body, headers) {
-            var url = urls.telemetry + "/v1/metrics/config";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
-        },
-        postMetricsUsage: function (body, headers) {
-            var url = urls.telemetry + "/v1/metrics/usage";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
-        }
-    };
-}

package/esm/services/splitHttpClient.js

@@ -1,78 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
-import { decorateHeaders, removeNonISO88591 } from './decorateHeaders';
-import { timeout } from '../utils/promise/timeout';
-var PENDING_FETCH_ERROR_TIMEOUT = 100;
-var messageNoFetch = 'Global fetch API is not available.';
-/**
- * Factory of Split HTTP clients, which are HTTP clients with predefined headers for Split endpoints.
- *
- * @param settings - SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers
- * @param platform - object containing environment-specific dependencies
- */
-export function splitHttpClientFactory(settings, _a) {
-    var getOptions = _a.getOptions, getFetch = _a.getFetch;
-    var log = settings.log, authorizationKey = settings.core.authorizationKey, version = settings.version, _b = settings.runtime, ip = _b.ip, hostname = _b.hostname;
-    var options = getOptions && getOptions(settings);
-    var fetch = getFetch && getFetch(settings);
-    // if fetch is not available, log Error
-    if (!fetch)
-        log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
-    var commonHeaders = {
-        'Accept': 'application/json',
-        'Content-Type': 'application/json',
-        'Authorization': "Bearer " + authorizationKey,
-        'SplitSDKVersion': version
-    };
-    if (ip)
-        commonHeaders['SplitSDKMachineIP'] = ip;
-    if (hostname)
-        commonHeaders['SplitSDKMachineName'] = removeNonISO88591(hostname);
-    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
-        if (reqOpts === void 0) { reqOpts = {}; }
-        if (latencyTracker === void 0) { latencyTracker = function () { }; }
-        if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
-        var request = objectAssign({
-            headers: decorateHeaders(settings, objectAssign({}, commonHeaders, reqOpts.headers || {})),
-            method: reqOpts.method || 'GET',
-            body: reqOpts.body
-        }, options);
-        // using `fetch(url, options)` signature to work with unfetch, a lightweight ponyfill of fetch API.
-        return fetch ? fetch(url, request)
-            // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
-            .then(function (response) {
-            if (!response.ok) {
-                // timeout since `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
-                return timeout(PENDING_FETCH_ERROR_TIMEOUT, response.text()).then(function (message) { return Promise.reject({ response: response, message: message }); }, function () { return Promise.reject({ response: response }); });
-            }
-            latencyTracker();
-            return response;
-        })
-            .catch(function (error) {
-            var resp = error && error.response;
-            var msg = '';
-            if (resp) { // An HTTP error
-                switch (resp.status) {
-                    case 404:
-                        msg = 'Invalid SDK key or resource not found.';
-                        break;
-                    // Don't use resp.statusText since reason phrase is removed in HTTP/2
-                    default:
-                        msg = error.message;
-                        break;
-                }
-            }
-            else { // Something else, either an error making the request or a Network error.
-                msg = error.message || 'Network Error';
-            }
-            if (!resp || resp.status !== 403) { // 403's log we'll be handled somewhere else.
-                log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? 'status code ' + resp.status : 'no status code', url, msg]);
-            }
-            var networkError = new Error(msg);
-            // passes `undefined` as statusCode if not an HTTP error (resp === undefined)
-            networkError.statusCode = resp && resp.status;
-            latencyTracker(networkError);
-            throw networkError;
-        }) : Promise.reject(new Error(messageNoFetch));
-    };
-}

package/esm/services/types.js

@@ -1 +0,0 @@
-export {};

package/esm/storages/AbstractMySegmentsCacheSync.js

@@ -1,57 +0,0 @@
-/**
- * This class provides a skeletal implementation of the ISegmentsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractMySegmentsCacheSync = /** @class */ (function () {
-    function AbstractMySegmentsCacheSync() {
-    }
-    /**
-     * clear the cache.
-     */
-    AbstractMySegmentsCacheSync.prototype.clear = function () {
-        this.resetSegments({});
-    };
-    // No-op. Not used in client-side.
-    AbstractMySegmentsCacheSync.prototype.registerSegments = function () { return false; };
-    AbstractMySegmentsCacheSync.prototype.update = function () { return false; };
-    /**
-     * For server-side synchronizer: the method is not used.
-     * For client-side synchronizer: it resets or updates the cache.
-     */
-    AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
-        var _this = this;
-        this.setChangeNumber(segmentsData.cn);
-        var _a = segmentsData, added = _a.added, removed = _a.removed;
-        if (added && removed) {
-            var isDiff_1 = false;
-            added.forEach(function (segment) {
-                isDiff_1 = _this.addSegment(segment) || isDiff_1;
-            });
-            removed.forEach(function (segment) {
-                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
-            });
-            return isDiff_1;
-        }
-        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
-        var storedSegmentKeys = this.getRegisteredSegments().sort();
-        // Extreme fast => everything is empty
-        if (!names.length && !storedSegmentKeys.length)
-            return false;
-        var index = 0;
-        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
-            index++;
-        // Quick path => no changes
-        if (index === names.length && index === storedSegmentKeys.length)
-            return false;
-        // Slowest path => add and/or remove segments
-        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-            this.removeSegment(storedSegmentKeys[removeIndex]);
-        }
-        for (var addIndex = index; addIndex < names.length; addIndex++) {
-            this.addSegment(names[addIndex]);
-        }
-        return true;
-    };
-    return AbstractMySegmentsCacheSync;
-}());
-export { AbstractMySegmentsCacheSync };

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -1,48 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheAsync = /** @class */ (function () {
-    function AbstractSplitsCacheAsync() {
-    }
-    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        return Promise.all([
-            this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
-            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }))
-        ]).then(function (_a) {
-            var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
-        });
-    };
-    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
-    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
-        return Promise.resolve(true);
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     * The promise will never be rejected.
-     */
-    AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-                var newSplit = objectAssign({}, split);
-                newSplit.killed = true;
-                newSplit.defaultTreatment = defaultTreatment;
-                newSplit.changeNumber = changeNumber;
-                return _this.addSplit(newSplit);
-            }
-            return false;
-        }).catch(function () { return false; });
-    };
-    return AbstractSplitsCacheAsync;
-}());
-export { AbstractSplitsCacheAsync };