@splitsoftware/splitio-commons 2.4.2-rc.3 → 11.5.0-rc.0

package/esm/storages/pluggable/inMemoryWrapper.js

@@ -1,137 +0,0 @@
-import { startsWith, toNumber } from '../../utils/lang';
-import { setToArray } from '../../utils/lang/sets';
-/**
- * Creates a IPluggableStorageWrapper implementation that stores items in memory.
- * The `_cache` property is the object were items are stored.
- * Intended for testing purposes.
- *
- * @param connDelay - delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
- */
-export function inMemoryWrapperFactory(connDelay) {
-    var _cache = {};
-    var _connDelay = connDelay;
-    return {
-        /** Holds items (for key-value operations), list of items (for list operations) and set of items (for set operations) */
-        _cache: _cache,
-        get: function (key) {
-            return Promise.resolve(key in _cache ? _cache[key] : null);
-        },
-        set: function (key, value) {
-            var result = key in _cache;
-            _cache[key] = value;
-            return Promise.resolve(result);
-        },
-        getAndSet: function (key, value) {
-            var result = key in _cache ? _cache[key] : null;
-            _cache[key] = value;
-            return Promise.resolve(result);
-        },
-        del: function (key) {
-            var result = key in _cache;
-            delete _cache[key];
-            return Promise.resolve(result);
-        },
-        getKeysByPrefix: function (prefix) {
-            return Promise.resolve(Object.keys(_cache).filter(function (key) { return startsWith(key, prefix); }));
-        },
-        incr: function (key, increment) {
-            if (increment === void 0) { increment = 1; }
-            if (key in _cache) {
-                var count = toNumber(_cache[key]) + increment;
-                if (isNaN(count))
-                    return Promise.reject('Given key is not a number');
-                _cache[key] = count + '';
-                return Promise.resolve(count);
-            }
-            else {
-                _cache[key] = '' + increment;
-                return Promise.resolve(1);
-            }
-        },
-        decr: function (key, decrement) {
-            if (decrement === void 0) { decrement = 1; }
-            if (key in _cache) {
-                var count = toNumber(_cache[key]) - decrement;
-                if (isNaN(count))
-                    return Promise.reject('Given key is not a number');
-                _cache[key] = count + '';
-                return Promise.resolve(count);
-            }
-            else {
-                _cache[key] = '-' + decrement;
-                return Promise.resolve(-1);
-            }
-        },
-        getMany: function (keys) {
-            return Promise.resolve(keys.map(function (key) { return _cache[key] ? _cache[key] : null; }));
-        },
-        pushItems: function (key, items) {
-            if (!(key in _cache))
-                _cache[key] = [];
-            var list = _cache[key];
-            if (Array.isArray(list)) {
-                list.push.apply(list, items);
-                return Promise.resolve();
-            }
-            return Promise.reject('key is not a list');
-        },
-        popItems: function (key, count) {
-            var list = _cache[key];
-            return Promise.resolve(Array.isArray(list) ? list.splice(0, count) : []);
-        },
-        getItemsCount: function (key) {
-            var list = _cache[key];
-            return Promise.resolve(Array.isArray(list) ? list.length : 0);
-        },
-        itemContains: function (key, item) {
-            var set = _cache[key];
-            if (!set)
-                return Promise.resolve(false);
-            if (set instanceof Set)
-                return Promise.resolve(set.has(item));
-            return Promise.reject('key is not a set');
-        },
-        addItems: function (key, items) {
-            if (!(key in _cache))
-                _cache[key] = new Set();
-            var set = _cache[key];
-            if (set instanceof Set) {
-                items.forEach(function (item) { return set.add(item); });
-                return Promise.resolve();
-            }
-            return Promise.reject('key is not a set');
-        },
-        removeItems: function (key, items) {
-            if (!(key in _cache))
-                _cache[key] = new Set();
-            var set = _cache[key];
-            if (set instanceof Set) {
-                items.forEach(function (item) { return set.delete(item); });
-                return Promise.resolve();
-            }
-            return Promise.reject('key is not a set');
-        },
-        getItems: function (key) {
-            var set = _cache[key];
-            if (!set)
-                return Promise.resolve([]);
-            if (set instanceof Set)
-                return Promise.resolve(setToArray(set));
-            return Promise.reject('key is not a set');
-        },
-        // always connects and disconnects
-        connect: function () {
-            if (typeof _connDelay === 'number') {
-                return new Promise(function (res) { return setTimeout(res, _connDelay); });
-            }
-            else {
-                return Promise.resolve();
-            }
-        },
-        disconnect: function () { return Promise.resolve(); },
-        // for testing
-        _setConnDelay: function (connDelay) {
-            _connDelay = connDelay;
-        }
-    };
-}

package/esm/storages/pluggable/index.js

@@ -1,131 +0,0 @@
-import { __assign } from "tslib";
-import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCachePluggable } from './SplitsCachePluggable';
-import { SegmentsCachePluggable } from './SegmentsCachePluggable';
-import { ImpressionsCachePluggable } from './ImpressionsCachePluggable';
-import { EventsCachePluggable } from './EventsCachePluggable';
-import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
-import { isObject } from '../../utils/lang';
-import { getStorageHash, validatePrefix } from '../KeyBuilder';
-import { CONSUMER_PARTIAL_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
-import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
-import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
-import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
-import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { TelemetryCachePluggable } from './TelemetryCachePluggable';
-import { ImpressionCountsCachePluggable } from './ImpressionCountsCachePluggable';
-import { UniqueKeysCachePluggable } from './UniqueKeysCachePluggable';
-import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
-import { metadataBuilder } from '../utils';
-import { LOG_PREFIX } from '../pluggable/constants';
-import { RBSegmentsCachePluggable } from './RBSegmentsCachePluggable';
-var NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
-var NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
-/**
- * Validate pluggable storage factory options.
- *
- * @param options - user options
- * @throws Will throw an error if the options are invalid. Example: wrapper is not provided or doesn't have some methods.
- */
-function validatePluggableStorageOptions(options) {
-    if (!isObject(options) || !isObject(options.wrapper))
-        throw new Error(NO_VALID_WRAPPER);
-    var wrapper = options.wrapper;
-    var missingMethods = METHODS_TO_PROMISE_WRAP.filter(function (method) { return typeof wrapper[method] !== 'function'; });
-    if (missingMethods.length)
-        throw new Error(NO_VALID_WRAPPER_INTERFACE + " The following methods are missing or invalid: " + missingMethods);
-}
-// Async return type in `client.track` method on consumer partial mode
-// No need to promisify impressions cache
-function promisifyEventsTrack(events) {
-    var origTrack = events.track;
-    events.track = function () {
-        return Promise.resolve(origTrack.apply(this, arguments));
-    };
-    return events;
-}
-/**
- * Pluggable storage factory for consumer server-side & client-side SplitFactory.
- */
-export function PluggableStorage(options) {
-    validatePluggableStorageOptions(options);
-    var prefix = validatePrefix(options.prefix);
-    function PluggableStorageFactory(params) {
-        var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, mode = _a.mode, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
-        var metadata = metadataBuilder(settings);
-        var keys = new KeyBuilderSS(prefix, metadata);
-        var wrapper = wrapperAdapter(log, options.wrapper);
-        var isSynchronizer = mode === undefined; // If mode is not defined, the synchronizer is running
-        var isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
-        var telemetry = shouldRecordTelemetry(params) || isSynchronizer ?
-            isPartialConsumer ?
-                new TelemetryCacheInMemory() :
-                new TelemetryCachePluggable(log, keys, wrapper) :
-            undefined;
-        var impressionCountsCache = isPartialConsumer ?
-            new ImpressionCountsCacheInMemory() :
-            new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper);
-        var uniqueKeysCache = isPartialConsumer ?
-            settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
-            new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper);
-        // Connects to wrapper and emits SDK_READY event on main client
-        var connectPromise = wrapper.connect().then(function () {
-            if (isSynchronizer) {
-                // @TODO reuse InLocalStorage::validateCache logic
-                // In standalone or producer mode, clear storage if SDK key, flags filter criteria or flags spec version was modified
-                return wrapper.get(keys.buildHashKey()).then(function (hash) {
-                    var currentHash = getStorageHash(settings);
-                    if (hash !== currentHash) {
-                        log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
-                            return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
-                        }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
-                    }
-                }).then(function () {
-                    onReadyCb();
-                });
-            }
-            else {
-                // Start periodic flush of async storages if not running synchronizer (producer mode)
-                if (impressionCountsCache.start)
-                    impressionCountsCache.start();
-                if (uniqueKeysCache.start)
-                    uniqueKeysCache.start();
-                if (telemetry && telemetry.recordConfig)
-                    telemetry.recordConfig();
-                onReadyCb();
-            }
-        }).catch(function (e) {
-            e = e || new Error('Error connecting wrapper');
-            onReadyCb(e);
-            return e; // Propagate error for shared clients
-        });
-        return {
-            splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
-            rbSegments: new RBSegmentsCachePluggable(log, keys, wrapper),
-            segments: new SegmentsCachePluggable(log, keys, wrapper),
-            impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
-            impressionCounts: impressionCountsCache,
-            events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-            telemetry: telemetry,
-            uniqueKeys: uniqueKeysCache,
-            // Stop periodic flush and disconnect the underlying storage
-            destroy: function () {
-                return Promise.all(isSynchronizer ? [] : [
-                    impressionCountsCache.stop && impressionCountsCache.stop(),
-                    uniqueKeysCache.stop && uniqueKeysCache.stop(),
-                ]).then(function () { return wrapper.disconnect(); });
-            },
-            // emits SDK_READY event on shared clients and returns a reference to the storage
-            shared: function (_, onReadyCb) {
-                connectPromise.then(onReadyCb);
-                return __assign(__assign({}, this), { 
-                    // no-op destroy, to disconnect the wrapper only when the main client is destroyed
-                    destroy: function () { } });
-            }
-        };
-    }
-    PluggableStorageFactory.type = STORAGE_PLUGGABLE;
-    return PluggableStorageFactory;
-}

package/esm/storages/pluggable/wrapperAdapter.js

@@ -1,49 +0,0 @@
-import { LOG_PREFIX } from './constants';
-export var METHODS_TO_PROMISE_WRAP = [
-    'get',
-    'set',
-    'getAndSet',
-    'del',
-    'getKeysByPrefix',
-    'incr',
-    'decr',
-    'getMany',
-    'pushItems',
-    'popItems',
-    'getItemsCount',
-    'itemContains',
-    'addItems',
-    'removeItems',
-    'getItems',
-    'connect',
-    'disconnect'
-];
-/**
- * Adapter of the Pluggable Storage Wrapper.
- * Used to handle exceptions as rejected promises, in order to simplify the error handling on storages.
- *
- * @param log - logger instance
- * @param wrapper - storage wrapper to adapt
- * @returns an adapted version of the given storage wrapper
- */
-export function wrapperAdapter(log, wrapper) {
-    var wrapperAdapter = {};
-    METHODS_TO_PROMISE_WRAP.forEach(function (method) {
-        // Logs error and wraps it into a rejected promise.
-        function handleError(e) {
-            log.error(LOG_PREFIX + " Wrapper '" + method + "' operation threw an error. Message: " + e);
-            return Promise.reject(e);
-        }
-        wrapperAdapter[method] = function () {
-            try {
-                // @ts-ignore
-                return wrapper[method].apply(wrapper, arguments).then(function (value) { return value; }).catch(handleError);
-            }
-            catch (e) {
-                return handleError(e);
-            }
-        };
-    });
-    // @ts-ignore
-    return wrapperAdapter;
-}

package/esm/storages/types.js

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

package/esm/storages/utils.js

@@ -1,66 +0,0 @@
-// Shared utils for Redis and Pluggable storage
-import { UNKNOWN } from '../utils/constants';
-import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
-import { METHOD_NAMES } from './KeyBuilderSS';
-export function metadataBuilder(settings) {
-    return {
-        s: settings.version,
-        i: settings.runtime.ip || UNKNOWN,
-        n: settings.runtime.hostname || UNKNOWN,
-    };
-}
-// Converts impressions to be stored in Redis or pluggable storage.
-export function impressionsToJSON(impressions, metadata) {
-    return impressions.map(function (impression) {
-        var impressionWithMetadata = {
-            m: metadata,
-            i: {
-                k: impression.keyName,
-                b: impression.bucketingKey,
-                f: impression.feature,
-                t: impression.treatment,
-                r: impression.label,
-                c: impression.changeNumber,
-                m: impression.time,
-                pt: impression.pt,
-                properties: impression.properties
-            }
-        };
-        return JSON.stringify(impressionWithMetadata);
-    });
-}
-// Utilities used by TelemetryCacheInRedis and TelemetryCachePluggable
-var REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce(function (acc, key) {
-    acc[METHOD_NAMES[key]] = key;
-    return acc;
-}, {});
-export function parseMetadata(field) {
-    var parts = field.split('/');
-    if (parts.length !== 3)
-        return "invalid subsection count. Expected 3, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
-    return [JSON.stringify({ s: s, n: n, i: i })];
-}
-export function parseExceptionField(field) {
-    var parts = field.split('/');
-    if (parts.length !== 4)
-        return "invalid subsection count. Expected 4, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
-    var method = REVERSE_METHOD_NAMES[m];
-    if (!method)
-        return "unknown method '" + m + "'";
-    return [JSON.stringify({ s: s, n: n, i: i }), method];
-}
-export function parseLatencyField(field) {
-    var parts = field.split('/');
-    if (parts.length !== 5)
-        return "invalid subsection count. Expected 5, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
-    var method = REVERSE_METHOD_NAMES[m];
-    if (!method)
-        return "unknown method '" + m + "'";
-    var bucket = parseInt(b);
-    if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT)
-        return "invalid bucket. Expected a number between 0 and " + (MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
-    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
-}

package/esm/sync/offline/LocalhostFromObject.js

@@ -1,5 +0,0 @@
-import { splitsParserFromSettingsFactory } from './splitsParser/splitsParserFromSettings';
-import { syncManagerOfflineFactory } from './syncManagerOffline';
-// Singleton instance of the factory function for offline SyncManager from object
-// SDK instances instantiate their SyncManagers with the same factory
-export var localhostFromObjectFactory = syncManagerOfflineFactory(splitsParserFromSettingsFactory);

package/esm/sync/offline/splitsParser/parseCondition.js

@@ -1,51 +0,0 @@
-import { isString } from '../../../utils/lang';
-export function parseCondition(data) {
-    var treatment = data.treatment;
-    if (data.keys) {
-        return {
-            conditionType: 'WHITELIST',
-            matcherGroup: {
-                combiner: 'AND',
-                matchers: [
-                    {
-                        keySelector: null,
-                        matcherType: 'WHITELIST',
-                        negate: false,
-                        whitelistMatcherData: {
-                            whitelist: isString(data.keys) ? [data.keys] : data.keys
-                        }
-                    }
-                ]
-            },
-            partitions: [
-                {
-                    treatment: treatment,
-                    size: 100
-                }
-            ],
-            label: "whitelisted " + treatment
-        };
-    }
-    else {
-        return {
-            conditionType: 'ROLLOUT',
-            matcherGroup: {
-                combiner: 'AND',
-                matchers: [
-                    {
-                        keySelector: null,
-                        matcherType: 'ALL_KEYS',
-                        negate: false
-                    }
-                ]
-            },
-            partitions: [
-                {
-                    treatment: treatment,
-                    size: 100
-                }
-            ],
-            label: 'default rule'
-        };
-    }
-}

package/esm/sync/offline/splitsParser/splitsParserFromSettings.js

@@ -1,58 +0,0 @@
-import { isObject, forOwn, merge } from '../../../utils/lang';
-import { parseCondition } from './parseCondition';
-function hasTreatmentChanged(prev, curr) {
-    if (typeof prev !== typeof curr)
-        return true;
-    if (typeof prev === 'string') { // strings treatments, just compare
-        return prev !== curr;
-    }
-    else { // has treatment and config, compare both
-        return prev.treatment !== curr.treatment || prev.config !== curr.config;
-    }
-}
-export function splitsParserFromSettingsFactory() {
-    var previousMock = { 'emptyMock': '1' };
-    function mockUpdated(currentData) {
-        var names = Object.keys(currentData);
-        // Different amount of items
-        if (names.length !== Object.keys(previousMock).length) {
-            previousMock = merge({}, currentData);
-            return true;
-        }
-        return names.some(function (name) {
-            var newSplit = !previousMock[name];
-            var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
-            var changed = newSplit || newTreatment;
-            if (changed)
-                previousMock = merge({}, currentData);
-            return changed;
-        });
-    }
-    /**
-     *
-     * @param settings - validated object with mocked features mapping.
-     */
-    return function splitsParserFromSettings(settings) {
-        var features = settings.features || {};
-        if (!mockUpdated(features))
-            return false;
-        var splitObjects = {};
-        forOwn(features, function (data, splitName) {
-            var treatment = data;
-            var config = null;
-            if (isObject(data)) {
-                treatment = data.treatment;
-                config = data.config || config;
-            }
-            var configurations = {};
-            if (config !== null)
-                configurations[treatment] = config;
-            splitObjects[splitName] = {
-                trafficTypeName: 'localhost',
-                conditions: [parseCondition({ treatment: treatment })],
-                configurations: configurations
-            };
-        });
-        return splitObjects;
-    };
-}

package/esm/sync/offline/splitsParser/types.js

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

package/esm/sync/offline/syncManagerOffline.js

@@ -1,48 +0,0 @@
-import { fromObjectSyncTaskFactory } from './syncTasks/fromObjectSyncTask';
-import { objectAssign } from '../../utils/lang/objectAssign';
-import { SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
-function flush() {
-    return Promise.resolve();
-}
-/**
- * Offline SyncManager factory.
- * Can be used for server-side API, and client-side API with or without multiple clients.
- *
- * @param splitsParser - e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
- */
-export function syncManagerOfflineFactory(splitsParserFactory) {
-    /**
-     * SyncManager factory for modular SDK
-     */
-    return function (_a) {
-        var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;
-        var mainSyncManager = fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings);
-        var mainStart = mainSyncManager.start;
-        var sharedStarts = [];
-        return objectAssign(mainSyncManager, {
-            start: function () {
-                mainStart();
-                sharedStarts.forEach(function (cb) { return cb(); });
-                sharedStarts.length = 0;
-            },
-            // fake flush, that resolves immediately
-            flush: flush,
-            // [Only used for client-side]
-            shared: function (matchingKey, readinessManager) {
-                // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-                // SDK_READY cannot be emitted directly because this will not update the readiness status
-                function emitSdkReady() {
-                    readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
-                }
-                if (mainSyncManager.isRunning())
-                    setTimeout(emitSdkReady);
-                else
-                    sharedStarts.push(emitSdkReady);
-                return {
-                    stop: function () { },
-                    flush: flush,
-                };
-            }
-        });
-    };
-}

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -1,66 +0,0 @@
-import { forOwn } from '../../../utils/lang';
-import { syncTaskFactory } from '../../syncTask';
-import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
-import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
-/**
- * Offline equivalent of `splitChangesUpdaterFactory`
- */
-export function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
-    var log = settings.log, splitsCache = storage.splits;
-    var startingUp = true;
-    return function objectUpdater() {
-        var splits = [];
-        var loadError = null;
-        var splitsMock = {};
-        try {
-            splitsMock = splitsParser(settings);
-        }
-        catch (err) {
-            loadError = err;
-            log.error(ERROR_SYNC_OFFLINE_LOADING, [err]);
-        }
-        if (!loadError && splitsMock) {
-            log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
-            forOwn(splitsMock, function (val, name) {
-                // @ts-ignore Split changeNumber and seed is undefined in localhost mode
-                splits.push({
-                    name: name,
-                    status: 'ACTIVE',
-                    killed: false,
-                    trafficAllocation: 100,
-                    defaultTreatment: CONTROL,
-                    conditions: val.conditions || [],
-                    configurations: val.configurations,
-                    trafficTypeName: val.trafficTypeName
-                });
-            });
-            return Promise.all([
-                splitsCache.clear(),
-                splitsCache.update(splits, [], Date.now())
-            ]).then(function () {
-                readiness.splits.emit(SDK_SPLITS_ARRIVED);
-                if (startingUp) {
-                    startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
-                        // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-                        // Emits SDK_READY
-                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-                    });
-                }
-                return true;
-            });
-        }
-        else {
-            return Promise.resolve(true);
-        }
-    };
-}
-/**
- * PollingManager in Offline mode
- */
-export function fromObjectSyncTaskFactory(splitsParser, storage, readiness, settings) {
-    return syncTaskFactory(settings.log, fromObjectUpdaterFactory(splitsParser, storage, readiness, settings), settings.scheduler.offlineRefreshRate, 'offlineUpdater');
-}

package/esm/sync/polling/fetchers/mySegmentsFetcher.js

@@ -1,14 +0,0 @@
-/**
- * Factory of MySegments fetcher.
- * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
- */
-export function mySegmentsFetcherFactory(fetchMemberships) {
-    return function mySegmentsFetcher(userMatchingKey, noCache, till, 
-    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
-    decorator) {
-        var mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
-        if (decorator)
-            mySegmentsPromise = decorator(mySegmentsPromise);
-        return mySegmentsPromise.then(function (resp) { return resp.json(); });
-    };
-}

package/esm/sync/polling/fetchers/segmentChangesFetcher.js

@@ -1,30 +0,0 @@
-import { __spreadArray } from "tslib";
-function greedyFetch(fetchSegmentChanges, since, segmentName, noCache, targetTill) {
-    return fetchSegmentChanges(since, segmentName, noCache, targetTill)
-        .then(function (resp) { return resp.json(); })
-        .then(function (json) {
-        var since = json.since, till = json.till;
-        if (since === till) {
-            return [json];
-        }
-        else {
-            return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache, targetTill)]).then(function (flatMe) {
-                return __spreadArray([flatMe[0]], flatMe[1], true);
-            });
-        }
-    });
-}
-/**
- * Factory of SegmentChanges fetcher.
- * SegmentChanges fetcher is a wrapper around `segmentChanges` API service that parses the response and handle errors and retries.
- */
-export function segmentChangesFetcherFactory(fetchSegmentChanges) {
-    return function segmentChangesFetcher(since, segmentName, noCache, till, 
-    // Optional decorator for `fetchSegmentChanges` promise, such as timeout or time tracker
-    decorator) {
-        var segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
-        if (decorator)
-            segmentsPromise = decorator(segmentsPromise);
-        return segmentsPromise;
-    };
-}