@splitsoftware/splitio 10.17.2 → 10.17.3-rc.3

package/src/storage/browser.js

@@ -1,110 +0,0 @@
-import SplitCacheInMemory from './SplitCache/InMemory';
-import SplitCacheInLocalStorage from './SplitCache/InLocalStorage';
-import SegmentCacheInMemory from './SegmentCache/InMemory';
-import SegmentCacheInLocalStorage from './SegmentCache/InLocalStorage';
-import ImpressionsCacheInMemory from './ImpressionsCache/InMemory';
-import LatencyCacheInMemory from './LatencyCache/InMemory';
-import CountCacheInMemory from './CountCache/InMemory';
-import EventsCacheInMemory from './EventsCache/InMemory';
-import KeyBuilder from './Keys';
-import KeyBuilderLocalStorage from './KeysLocalStorage';
-import { STORAGE_MEMORY, STORAGE_LOCALSTORAGE } from '../utils/constants';
-
-// This value might be eventually set via a config parameter
-export const DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
-
-const BrowserStorageFactory = context => {
-  const settings = context.get(context.constants.SETTINGS);
-  const { storage } = settings;
-
-  switch (storage.type) {
-    case STORAGE_MEMORY: {
-      const keys = new KeyBuilder(settings);
-
-      return {
-        splits: new SplitCacheInMemory,
-        segments: new SegmentCacheInMemory(keys),
-        impressions: new ImpressionsCacheInMemory,
-        metrics: new LatencyCacheInMemory,
-        count: new CountCacheInMemory,
-        events: new EventsCacheInMemory(context),
-
-        // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
-        shared(settings) {
-          const childKeyBuilder = new KeyBuilder(settings);
-
-          return {
-            splits: this.splits,
-            segments: new SegmentCacheInMemory(childKeyBuilder),
-            impressions: this.impressions,
-            metrics: this.metrics,
-            count: this.count,
-            events: this.events,
-
-            destroy() {
-              this.splits = new SplitCacheInMemory;
-              this.segments.flush();
-            }
-          };
-        },
-
-        destroy() {
-          this.splits.flush();
-          this.segments.flush();
-          this.impressions.clear();
-          this.metrics.clear();
-          this.count.clear();
-          this.events.clear();
-        }
-      };
-    }
-
-    case STORAGE_LOCALSTORAGE: {
-      const keys = new KeyBuilderLocalStorage(settings);
-      const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-
-      return {
-        splits: new SplitCacheInLocalStorage(keys, expirationTimestamp, settings.sync.__splitFiltersValidation),
-        segments: new SegmentCacheInLocalStorage(keys),
-        impressions: new ImpressionsCacheInMemory,
-        metrics: new LatencyCacheInMemory,
-        count: new CountCacheInMemory,
-        events: new EventsCacheInMemory(context),
-
-        // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
-        shared(settings) {
-          const childKeysBuilder = new KeyBuilderLocalStorage(settings);
-
-          return {
-            splits: this.splits,
-            segments: new SegmentCacheInLocalStorage(childKeysBuilder),
-            impressions: this.impressions,
-            metrics: this.metrics,
-            count: this.count,
-            events: this.events,
-
-            destroy() {
-              this.splits = new SplitCacheInMemory;
-              this.segments = new SegmentCacheInMemory(childKeysBuilder);
-            }
-          };
-        },
-
-        destroy() {
-          this.splits = new SplitCacheInMemory;
-          this.segments = new SegmentCacheInMemory(new KeyBuilder(settings));
-          this.impressions.clear();
-          this.metrics.clear();
-          this.count.clear();
-          this.events.clear();
-        }
-      };
-    }
-
-    default:
-      throw new Error('Unsupported storage type');
-  }
-
-};
-
-export default BrowserStorageFactory;

package/src/storage/node.js

@@ -1,83 +0,0 @@
-import RedisAdapter from './RedisAdapter';
-import SplitCacheInMemory from './SplitCache/InMemory';
-import SplitCacheInRedis from './SplitCache/InRedis';
-import SegmentCacheInMemory from './SegmentCache/InMemory';
-import SegmentCacheInRedis from './SegmentCache/InRedis';
-import ImpressionsCacheInMemory from './ImpressionsCache/InMemory';
-import ImpressionsCacheInRedis from './ImpressionsCache/InRedis';
-import LatencyCacheInMemory from './LatencyCache/InMemory';
-import LatencyCacheInRedis from './LatencyCache/InRedis';
-import CountCacheInMemory from './CountCache/InMemory';
-import CountCacheInRedis from './CountCache/InRedis';
-import EventsCacheInMemory from './EventsCache/InMemory';
-import EventsCacheInRedis from './EventsCache/InRedis';
-import KeyBuilder from './Keys';
-import MetaBuilder from './Meta';
-import { STORAGE_MEMORY, STORAGE_REDIS } from '../utils/constants';
-
-const NodeStorageFactory = context => {
-  const settings = context.get(context.constants.SETTINGS);
-  const { storage } = settings;
-  const keys = new KeyBuilder(settings);
-
-  switch (storage.type) {
-    case STORAGE_REDIS: {
-      const redis = new RedisAdapter(storage.options);
-      const meta = MetaBuilder(settings);
-
-      // subscription to Redis connect event in order to emit SDK_READY
-      const { splits, segments } = context.get(context.constants.READINESS);
-      redis.on('connect', () => {
-        splits.emit(splits.SDK_SPLITS_ARRIVED);
-        segments.emit(segments.SDK_SEGMENTS_ARRIVED);
-      });
-
-      return {
-        splits: new SplitCacheInRedis(keys, redis),
-        segments: new SegmentCacheInRedis(keys, redis),
-        impressions: new ImpressionsCacheInRedis(keys, redis, meta),
-        metrics: new LatencyCacheInRedis(keys, redis),
-        count: new CountCacheInRedis(keys, redis),
-        events: new EventsCacheInRedis(keys, redis, meta),
-
-        // When using REDIS we should:
-        // 1- Disconnect from the storage
-        // 2- Stop sending data to Redis and instance using empty in memory implementation
-        destroy() {
-          redis.disconnect();
-
-          this.splits = new SplitCacheInMemory;
-          this.segments = new SegmentCacheInMemory(keys);
-          this.impressions = new ImpressionsCacheInMemory;
-          this.metrics = new LatencyCacheInMemory;
-          this.count = new CountCacheInMemory;
-          this.events = new EventsCacheInMemory(context);
-        }
-      };
-    }
-
-    case STORAGE_MEMORY:
-    default:
-      return {
-        splits: new SplitCacheInMemory,
-        segments: new SegmentCacheInMemory(keys),
-        impressions: new ImpressionsCacheInMemory,
-        metrics: new LatencyCacheInMemory,
-        count: new CountCacheInMemory,
-        events: new EventsCacheInMemory(context),
-
-        // When using MEMORY we should flush all the storages and leave them empty
-        destroy() {
-          this.splits.flush();
-          this.segments.flush();
-          this.impressions.clear();
-          this.metrics.clear();
-          this.count.clear();
-          this.events.clear();
-        }
-      };
-  }
-
-};
-
-export default NodeStorageFactory;

package/src/storage/package.json

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

package/src/sync/AuthClient/index.js

@@ -1,31 +0,0 @@
-import objectAssign from 'object-assign';
-import authService from '../../services/auth';
-import authRequest from '../../services/auth/auth';
-import { decodeJWTtoken } from '../../utils/jwt';
-
-/**
- * Run authentication requests to Auth Server, and handle response decoding the JTW token.
- * Precondition:
- *
- * @param {Object} settings Split factory config, used to get authorizationKey and other params required by authRequest.
- * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for Node.
- * @throws {ReferenceError} if `atob` function is not defined
- */
-export default function authenticate(settings, userKeys) {
-  let authPromise = authService(authRequest(settings, userKeys)); // errors handled by authService
-  return authPromise
-    // no need to handle json parsing errors as SplitError, since no user callbacks are executed after this promise is resolved
-    .then(resp => resp.json())
-    .then(json => {
-      if (json.token) { // empty token when `"pushEnabled": false`
-        const decodedToken = decodeJWTtoken(json.token);
-        if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number') throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
-        const channels = JSON.parse(decodedToken['x-ably-capability']);
-        return objectAssign({
-          decodedToken,
-          channels
-        }, json);
-      }
-      return json;
-    });
-}

package/src/sync/PushManager/index.js

@@ -1,328 +0,0 @@
-import EventEmitter from 'events';
-import objectAssign from 'object-assign';
-
-import authenticate from '../AuthClient';
-import { checkPushRequirements } from './pushRequirements';
-import SegmentUpdateWorker from '../SegmentUpdateWorker';
-import SplitUpdateWorker from '../SplitUpdateWorker';
-import SSEClient from '../SSEClient';
-import SSEHandlerFactory from '../SSEHandler';
-
-import Backoff from '../../utils/backoff';
-import { hashUserKey } from '../../utils/jwt/hashUserKey';
-import logFactory from '../../utils/logger';
-import { SECONDS_BEFORE_EXPIRATION, PUSH_SUBSYSTEM_DOWN, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_RETRYABLE_ERROR, SPLIT_KILL, SPLIT_UPDATE, SEGMENT_UPDATE, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, ControlTypes } from '../constants';
-import { parseBitmap, parseKeyList, isInBitmap } from './mySegmentsV2utils';
-import { forOwn } from '../../utils/lang';
-import { _Set } from '../../utils/lang/Sets';
-import { hash64 } from '../../engine/engine/murmur3/murmur3_64';
-
-const log = logFactory('splitio-sync:push-manager');
-
-// const UnboundedFetchRequest = 0;
-const BoundedFetchRequest = 1;
-const KeyList = 2;
-const SegmentRemoval = 3;
-
-function fallbackWarning(notificationType, e) {
-  return `Fetching MySegments due to an error processing ${notificationType} notification: ${e}`;
-}
-
-/**
- * Factory of the push mode manager.
- *
- * @param {Object} context context of main client.
- * @param {Object | undefined} clientContexts map of user keys to client contexts to handle sync of MySegments. undefined for node.
- */
-export default function PushManagerFactory(context, clientContexts /* undefined for node */) {
-
-  // No return a PushManager if PUSH mode is not supported.
-  if (!checkPushRequirements(log)) return;
-
-  const pushEmitter = new EventEmitter();
-  const { splits: splitsEventEmitter } = context.get(context.constants.READINESS);
-  const settings = context.get(context.constants.SETTINGS);
-  const storage = context.get(context.constants.STORAGE);
-  const sseClient = SSEClient.getInstance(settings, clientContexts ? false : true);
-  const sseHandler = SSEHandlerFactory(pushEmitter);
-  sseClient.setEventHandler(sseHandler);
-
-  // map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
-  const userKeyHashes = {};
-  // map of user keys to their corresponding hash64 and MySegmentsUpdateWorker.
-  // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding worker.
-  const clients = {};
-
-  // variable used on browser to reconnect only when a new client was added, saving some authentication and sse connections.
-  let connectForNewClient = false;
-  // flag that indicates if `disconnectPush` was called, either by the SyncManager (when the client is destroyed) or by a PUSH_NONRETRYABLE_ERROR error
-  let disconnected;
-
-  /** PushManager functions related to initialization */
-
-  const connectPushRetryBackoff = new Backoff(connectPush, settings.scheduler.pushRetryBackoffBase);
-
-  let timeoutIdTokenRefresh;
-  let timeoutIdSseOpen;
-
-  function scheduleTokenRefreshAndSse(authData) {
-    // clear scheduled tasks if exist
-    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
-    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
-
-    // Set token refresh 10 minutes before expirationTime - issuedAt
-    const decodedToken = authData.decodedToken;
-    const refreshTokenDelay = decodedToken.exp - decodedToken.iat - SECONDS_BEFORE_EXPIRATION;
-    // Default connDelay of 60 secs
-    const connDelay = typeof authData.connDelay === 'number' && authData.connDelay >= 0 ? authData.connDelay : 60;
-
-    log.info(`Refreshing streaming token in ${refreshTokenDelay} seconds, and connecting streaming in ${connDelay} seconds`);
-
-    timeoutIdTokenRefresh = setTimeout(connectPush, refreshTokenDelay * 1000);
-
-    timeoutIdSseOpen = setTimeout(() => {
-      // halt if disconnected
-      if (disconnected) return;
-      sseClient.open(authData);
-    }, connDelay * 1000);
-  }
-
-  function connectPush() {
-    // Halt connecting in case `stop/disconnectPush` has been called
-    if (disconnected) return;
-    log.info(`${disconnected === undefined ? 'Connecting' : 'Re-connecting'} to push streaming.`);
-    disconnected = false;
-
-    const userKeys = clientContexts ? Object.keys(clientContexts) : undefined;
-    authenticate(settings, userKeys).then(
-      function (authData) {
-        if (disconnected) return;
-
-        // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
-        // close the sseClient in case the org has been bloqued while the instance was connected to streaming
-        if (!authData.pushEnabled) {
-          log.info('Streaming is not available. Switching to polling mode.');
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-          return;
-        }
-
-        // don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
-        if (userKeys && userKeys.length < Object.keys(clientContexts).length) return;
-
-        // Schedule SSE connection and refresh token
-        scheduleTokenRefreshAndSse(authData);
-      }
-    ).catch(
-      function (error) {
-        if (disconnected) return;
-
-        log.error(`Failed to authenticate for streaming. Error: ${error.message}.`);
-
-        // Handle 4XX HTTP errors: 401 (invalid API Key) or 400 (using incorrect API Key, i.e., client-side API Key on server-side)
-        if (error.statusCode >= 400 && error.statusCode < 500) {
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
-          return;
-        }
-
-        // Handle other HTTP and network errors as recoverable errors
-        pushEmitter.emit(PUSH_RETRYABLE_ERROR);
-      }
-    );
-  }
-
-  // close SSE connection and cancel scheduled tasks
-  function disconnectPush() {
-    // Halt disconnecting, just to avoid redundant logs if called multiple times
-    if (disconnected) return;
-    disconnected = true;
-
-    sseClient.close();
-    log.info('Disconnecting from push streaming.');
-
-    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
-    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
-    connectPushRetryBackoff.reset();
-
-    stopWorkers();
-  }
-
-  pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
-
-  // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
-  // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
-  pushEmitter.on(PUSH_SUBSYSTEM_UP, () => {
-    connectPushRetryBackoff.reset();
-    stopWorkers();
-  });
-
-  /** Fallbacking without retry due to STREAMING_DISABLED control event, 'pushEnabled: false', and non-recoverable SSE and Authentication errors */
-
-  pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
-    // Note: `stopWorkers` is been called twice, but it is not harmful
-    disconnectPush();
-    pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already
-  });
-
-  /** Fallbacking with retry due to recoverable SSE and Authentication errors */
-
-  pushEmitter.on(PUSH_RETRYABLE_ERROR, function handleRetryableError() { // HTTP or network error in SSE connection
-    // SSE connection is closed to avoid repeated errors due to retries
-    sseClient.close();
-
-    // retry streaming reconnect with backoff algorithm
-    let delayInMillis = connectPushRetryBackoff.scheduleCall();
-
-    log.info(`Attempting to reconnect in ${delayInMillis / 1000} seconds.`);
-
-    pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already
-  });
-
-  /** STREAMING_RESET notification. Unlike a PUSH_RETRYABLE_ERROR, it doesn't emit PUSH_SUBSYSTEM_DOWN to fallback polling */
-
-  pushEmitter.on(ControlTypes.STREAMING_RESET, function handleStreamingReset() {
-    if (disconnected) return; // should never happen
-
-    // Minimum required clean-up.
-    // `disconnectPush` cannot be called because it sets `disconnected` and thus `connectPush` will not execute
-    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
-
-    connectPush();
-  });
-
-  /** Functions related to synchronization (Queues and Workers in the spec) */
-
-  const producer = context.get(context.constants.PRODUCER);
-  const splitUpdateWorker = new SplitUpdateWorker(storage.splits, producer, splitsEventEmitter);
-  let segmentUpdateWorker; // used in Node
-
-  // cancel scheduled fetch retries of Split, Segment, and MySegment Update Workers
-  function stopWorkers() {
-    splitUpdateWorker.backoff.reset();
-    if (segmentUpdateWorker) segmentUpdateWorker.backoff.reset();
-    forOwn(clients, ({ worker }) => worker.backoff.reset());
-  }
-
-  pushEmitter.on(SPLIT_KILL, splitUpdateWorker.killSplit);
-  pushEmitter.on(SPLIT_UPDATE, splitUpdateWorker.put);
-
-  if (clientContexts) { // browser
-    pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-      const userKeyHash = channel.split('_')[2];
-      const userKey = userKeyHashes[userKeyHash];
-      if (userKey && clientContexts[userKey]) { // check context since it can be undefined if client has been destroyed
-        const mySegmentSync = clientContexts[userKey].get(context.constants.MY_SEGMENTS_CHANGE_WORKER, true);
-        mySegmentSync && mySegmentSync.put(
-          parsedData.changeNumber,
-          parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
-      }
-    });
-
-    pushEmitter.on(MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
-      switch (parsedData.u) {
-        case BoundedFetchRequest: {
-          let bitmap;
-          try {
-            bitmap = parseBitmap(parsedData.d, parsedData.c);
-          } catch (e) {
-            log.warn(fallbackWarning('BoundedFetchRequest', e));
-            break;
-          }
-
-          forOwn(clients, ({ hash64, worker }) => {
-            if (isInBitmap(bitmap, hash64.hex)) {
-              worker.put(parsedData.changeNumber); // fetch mySegments
-            }
-          });
-          return;
-        }
-        case KeyList: {
-          let keyList, added, removed;
-          try {
-            keyList = parseKeyList(parsedData.d, parsedData.c);
-            added = new _Set(keyList.a);
-            removed = new _Set(keyList.r);
-          } catch (e) {
-            log.warn(fallbackWarning('KeyList', e));
-            break;
-          }
-
-          forOwn(clients, ({ hash64, worker }) => {
-            const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
-            if (add !== undefined) {
-              worker.put(parsedData.changeNumber, {
-                name: parsedData.segmentName,
-                add
-              });
-            }
-          });
-          return;
-        }
-        case SegmentRemoval:
-          if (!parsedData.segmentName) {
-            log.warn(fallbackWarning('SegmentRemoval', 'No segment name was provided'));
-            break;
-          }
-
-          forOwn(clients, ({ worker }) => {
-            worker.put(parsedData.changeNumber, {
-              name: parsedData.segmentName,
-              add: false
-            });
-          });
-          return;
-      }
-
-      // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-      forOwn(clients, ({ worker }) => {
-        worker.put(parsedData.changeNumber);
-      });
-    });
-
-  } else { // node
-    segmentUpdateWorker = new SegmentUpdateWorker(storage.segments, producer);
-    pushEmitter.on(SEGMENT_UPDATE, segmentUpdateWorker.put);
-  }
-
-  return objectAssign(
-    // Expose Event Emitter functionality and Event constants
-    Object.create(pushEmitter),
-    {
-      // Expose functionality for starting and stoping push mode:
-      stop: disconnectPush, // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which start polling.
-
-      // used in node
-      start: connectPush,
-
-      // used in browser
-      startNewClient(userKey, context) {
-        const hash = hashUserKey(userKey);
-        const storage = context.get(context.constants.STORAGE);
-        const producer = context.get(context.constants.PRODUCER);
-
-        if (!userKeyHashes[hash]) {
-          userKeyHashes[hash] = userKey;
-          connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
-        }
-        const mySegmentSync = new SegmentUpdateWorker(storage.segments, producer);
-        clients[userKey] = { worker: mySegmentSync, hash64: hash64(userKey) };
-        context.put(context.constants.MY_SEGMENTS_CHANGE_WORKER, mySegmentSync);
-
-        // Reconnects in case of a new client.
-        // Run in next event-loop cycle to save authentication calls
-        // in case the user is creating several clients in the current cycle.
-        setTimeout(function checkForReconnect() {
-          if (connectForNewClient) {
-            connectForNewClient = false;
-            connectPush();
-          }
-        }, 0);
-
-      },
-      removeClient(userKey) {
-        const hash = hashUserKey(userKey);
-        delete userKeyHashes[hash];
-        delete clients[userKey];
-      }
-    }
-  );
-}

package/src/sync/PushManager/mySegmentsV2utils.js

@@ -1,76 +0,0 @@
-import { algorithms } from '../../utils/decompress';
-import { decodeFromBase64 } from '../../utils/base64';
-
-const GZIP = 1;
-const ZLIB = 2;
-
-function Uint8ArrayToString(myUint8Arr) {
-  return String.fromCharCode.apply(null, myUint8Arr);
-}
-
-function StringToUint8Array(myString) {
-  const charCodes = myString.split('').map((e) => e.charCodeAt());
-  return new Uint8Array(charCodes);
-}
-
-/**
- * Decode and decompress 'data' with 'compression' algorithm
- *
- * @param {string} data
- * @param {number} compression 1 GZIP, 2 ZLIB
- * @returns {Uint8Array}
- * @throws if data string cannot be decoded, decompressed or the provided compression value is invalid (not 1 or 2)
- */
-function decompress(data, compression) {
-  let compressData = decodeFromBase64(data);
-  const binData = StringToUint8Array(compressData);
-
-  if (typeof algorithms === 'string') throw new Error(algorithms);
-  if (compression === GZIP) return algorithms.gunzipSync(binData);
-  if (compression === ZLIB) return algorithms.unzlibSync(binData);
-  throw new Error(`Invalid compression algorithm #${compression}`);
-}
-
-/**
- * Decode, decompress and parse the provided 'data' into a KeyList object
- *
- * @param {string} data
- * @param {number} compression
- * @returns {{a?: string[], r?: string[] }}
- * @throws if data string cannot be decoded, decompressed or parsed
- */
-export function parseKeyList(data, compression) {
-  const binKeyList = decompress(data, compression);
-  const strKeyList = Uint8ArrayToString(binKeyList);
-
-  // replace numbers to strings, to avoid losing precision
-  return JSON.parse(strKeyList.replace(/\d+/g, '"$&"'));
-}
-
-/**
- * Decode, decompress and parse the provided 'data' into a Bitmap object
- *
- * @param {string} data
- * @param {number} compression
- * @returns {Uint8Array}
- * @throws if data string cannot be decoded or decompressed
- */
-export function parseBitmap(data, compression) {
-  return decompress(data, compression);
-}
-
-/**
- * Check if the 'bitmap' bit at 'hash64hex' position is 1
- *
- * @param {Uint8Array} bitmap
- * @param {string} hash64hex 16-chars string, representing a number in hexa
- * @returns {boolean}
- */
-export function isInBitmap(bitmap, hash64hex) {
-  // using the lowest 32 bits as index, to avoid losing precision when converting to number
-  const index = parseInt(hash64hex.slice(8), 16) % (bitmap.length * 8);
-
-  const internal = Math.floor(index / 8);
-  const offset = index % 8;
-  return (bitmap[internal] & 1 << offset) > 0;
-}

package/src/sync/PushManager/pushRequirements/browser.js

@@ -1,20 +0,0 @@
-import getEventSource from '../../../services/getEventSource/browser';
-
-/**
- * Check if the JS environment has the necessary features to run in PUSH mode,
- * i.e., EventSource, base64 encoder and decoder.
- *
- * @return {boolean} if push is supported
- */
-export function checkPushRequirements(logger) {
-  const esReference = getEventSource();
-  if (!esReference) {
-    logger.warn('EventSource API is not available. Falling back to polling mode.');
-    return false;
-  }
-  if (typeof atob !== 'function' || typeof btoa !== 'function') {
-    logger.warn('"atob" and "btoa" functions for Base64 encoding are not available. Falling back to polling mode.');
-    return false;
-  }
-  return true;
-}

package/src/sync/PushManager/pushRequirements/node.js

@@ -1,16 +0,0 @@
-import getEventSource from '../../../services/getEventSource/node';
-
-/**
- * Check if the Node environment has the necessary features to run in PUSH mode,
- * i.e., EventSource, base64 encoder and decoder.
- *
- * @return {boolean} if push is supported
- */
-export function checkPushRequirements(logger) {
-  const esReference = getEventSource();
-  if (!esReference) {
-    logger.warn('EventSource API is not available. Falling back to polling mode.');
-    return false;
-  }
-  return true;
-}

package/src/sync/PushManager/pushRequirements/package.json

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