@splitsoftware/splitio-commons 0.1.1-canary.9 → 0.1.1-rc.18

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

@@ -1,6 +1,5 @@
 import { isObject, forOwn } from '../../../utils/lang';
 import parseCondition from './parseCondition';
-var previousMock = { 'emptyMock': '1' };
 function hasTreatmentChanged(prev, curr) {
     if (typeof prev !== typeof curr)
         return true;
@@ -11,46 +10,49 @@ function hasTreatmentChanged(prev, curr) {
         return prev.treatment !== curr.treatment || prev.config !== curr.config;
     }
 }
-function mockUpdated(currentData) {
-    var names = Object.keys(currentData);
-    // Different amount of items
-    if (names.length !== Object.keys(previousMock).length) {
-        previousMock = 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)
+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 = currentData;
-        return changed;
-    });
-}
-/**
- *
- * @param features validated object with mocked features mapping.
- */
-export default 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;
+            return true;
         }
-        var configurations = {};
-        if (config !== null)
-            configurations[treatment] = config;
-        splitObjects[splitName] = {
-            trafficTypeName: 'localhost',
-            conditions: [parseCondition({ treatment: treatment })],
-            configurations: configurations
-        };
-    });
-    return splitObjects;
+        return names.some(function (name) {
+            var newSplit = !previousMock[name];
+            var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
+            var changed = newSplit || newTreatment;
+            if (changed)
+                previousMock = 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/syncTasks/fromObjectSyncTask.js

@@ -1,13 +1,14 @@
 import { forOwn } from '../../../utils/lang';
 import syncTaskFactory from '../../syncTask';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../../readiness/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;
+    var log = settings.log, splitsCache = storage.splits;
+    var startingUp = true;
     return function objectUpdater() {
         var splits = [];
         var loadError = null;
@@ -37,11 +38,20 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 ]);
             });
             return Promise.all([
-                storage.splits.clear(),
-                storage.splits.addSplits(splits)
+                splitsCache.clear(),
+                splitsCache.addSplits(splits)
             ]).then(function () {
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
-                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                if (startingUp) {
+                    startingUp = false;
+                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
+                        // Emits SDK_READY_FROM_CACHE
+                        if (cacheReady)
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                        // Emits SDK_READY
+                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                    });
+                }
                 return true;
             });
         }

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -20,19 +20,36 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
         // mySegmentsPromise = tracker.start(tracker.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise);
     }
     // @TODO if allowing custom storages, handle async execution
-    function updateSegments(segments) {
-        // Update the list of segment names available
-        var shouldNotifyUpdate = mySegmentsCache.resetSegments(segments);
+    function updateSegments(segmentsData) {
+        var shouldNotifyUpdate;
+        if (Array.isArray(segmentsData)) {
+            // Update the list of segment names available
+            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+        }
+        else {
+            // Add/Delete the segment
+            var name_1 = segmentsData.name, add = segmentsData.add;
+            if (mySegmentsCache.isInSegment(name_1) !== add) {
+                shouldNotifyUpdate = true;
+                if (add)
+                    mySegmentsCache.addToSegment(name_1);
+                else
+                    mySegmentsCache.removeFromSegment(name_1);
+            }
+            else {
+                shouldNotifyUpdate = false;
+            }
+        }
         // Notify update if required
         if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
         }
     }
-    function _mySegmentsUpdater(retry, segmentList, noCache) {
-        var updaterPromise = segmentList ?
-            // If segmentList is provided, there is no need to fetch mySegments
-            new Promise(function (res) { updateSegments(segmentList); res(true); }) :
+    function _mySegmentsUpdater(retry, segmentsData, noCache) {
+        var updaterPromise = segmentsData ?
+            // If segmentsData is provided, there is no need to fetch mySegments
+            new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
             mySegmentsFetcher(noCache, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
@@ -56,10 +73,13 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
      * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
      * Returned promise will not be rejected.
      *
-     * @param {string[] | undefined} segmentList list of mySegments names to sync in the storage. If the list is `undefined`, it fetches them before syncing in the storage.
+     * @param {SegmentsData | undefined} segmentsData it can be:
+     *  (1) the list of mySegments names to sync in the storage,
+     *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
+     *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
      * @param {boolean | undefined} noCache true to revalidate data to fetch
      */
-    return function mySegmentsUpdater(segmentList, noCache) {
-        return _mySegmentsUpdater(0, segmentList, noCache);
+    return function mySegmentsUpdater(segmentsData, noCache) {
+        return _mySegmentsUpdater(0, segmentsData, noCache);
     };
 }

package/esm/sync/streaming/SSEClient/index.js

@@ -38,7 +38,6 @@ var SSEClient = /** @class */ (function () {
         if (!this.eventSource)
             throw new Error('EventSource API is not available. ');
         this.streamingUrl = settings.urls.streaming + '/sse';
-        this.reopen = this.reopen.bind(this);
         // @TODO get `useHeaders` flag from `getEventSource`, to use EventSource headers on client-side SDKs when possible.
         this.useHeaders = useHeaders;
         this.headers = buildSSEHeaders(settings);
@@ -54,7 +53,6 @@ var SSEClient = /** @class */ (function () {
      */
     SSEClient.prototype.open = function (authToken) {
         this.close(); // it closes connection if previously opened
-        this.authToken = authToken;
         var channelsQueryParam = Object.keys(authToken.channels).map(function (channel) {
             var params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
             return encodeURIComponent(params + channel);
@@ -77,15 +75,6 @@ var SSEClient = /** @class */ (function () {
         if (this.connection)
             this.connection.close();
     };
-    /**
-     * Re-open the connection with the last given authToken.
-     *
-     * @throws {TypeError} if `open` has not been previously called with an authToken
-     * @TODO this method is not used currently and could be removed.
-     */
-    SSEClient.prototype.reopen = function () {
-        this.open(this.authToken);
-    };
     return SSEClient;
 }());
 export default SSEClient;

package/esm/sync/streaming/SSEHandler/NotificationKeeper.js

@@ -52,6 +52,13 @@ export default function notificationKeeperFactory(pushEmitter) {
             }
         },
         handleControlEvent: function (controlType, channel, timestamp) {
+            /* STREAMING_RESET control event is handled by PushManager directly since it doesn't require
+             * tracking timestamp and state like OCCUPANCY or CONTROL. It also ignores previous
+             * OCCUPANCY and CONTROL notifications, and whether PUSH_SUBSYSTEM_DOWN has been emitted or not */
+            if (controlType === ControlType.STREAMING_RESET) {
+                pushEmitter.emit(controlType);
+                return;
+            }
             for (var i = 0; i < channels.length; i++) {
                 var c = channels[i];
                 if (c.regex.test(channel)) {

package/esm/sync/streaming/SSEHandler/NotificationParser.js

@@ -19,10 +19,13 @@ export function errorParser(error) {
  * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
  *
  * @param message
- * @returns parsed notification message
+ * @returns parsed notification message or undefined if the given event data is falsy (e.g, '' or undefined).
+ * For example, the EventSource implementation of React-Native for iOS emits a message event with empty data for Ably keepalive comments.
  * @throws {SyntaxError} if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
  */
 export function messageParser(message) {
+    if (!message.data)
+        return;
     var messageData = JSON.parse(message.data);
     messageData.parsedData = JSON.parse(messageData.data);
     // set the event type to OCCUPANCY, to handle all events uniformely

package/esm/sync/streaming/SSEHandler/index.js

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import notificationKeeperFactory from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 function isRetryableError(error) {
     if (error.parsedData && error.parsedData.code) {
@@ -36,7 +36,7 @@ export default function SSEHandlerFactory(log, pushEmitter) {
             catch (err) {
                 log.warn(STREAMING_PARSING_ERROR_FAILS, [err]);
             }
-            var errorMessage = errorWithParsedData.parsedData && errorWithParsedData.parsedData.message;
+            var errorMessage = (errorWithParsedData.parsedData && errorWithParsedData.parsedData.message) || errorWithParsedData.message;
             log.error(ERROR_STREAMING_SSE, [errorMessage]);
             if (isRetryableError(errorWithParsedData)) {
                 pushEmitter.emit(PUSH_RETRYABLE_ERROR);
@@ -50,6 +50,8 @@ export default function SSEHandlerFactory(log, pushEmitter) {
             var messageWithParsedData;
             try {
                 messageWithParsedData = messageParser(message);
+                if (!messageWithParsedData)
+                    return; // Messages with empty data are ignored
             }
             catch (err) {
                 log.warn(STREAMING_PARSING_MESSAGE_FAILS, [err]);
@@ -58,21 +60,18 @@ export default function SSEHandlerFactory(log, pushEmitter) {
             var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
             log.debug(STREAMING_NEW_MESSAGE, [data]);
             // we only handle update events if streaming is up.
-            if (!notificationKeeper.isStreamingUp() && parsedData.type !== OCCUPANCY && parsedData.type !== CONTROL)
+            if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
                 return;
             switch (parsedData.type) {
                 /* update events */
                 case SPLIT_UPDATE:
-                    pushEmitter.emit(SPLIT_UPDATE, parsedData.changeNumber);
-                    break;
                 case SEGMENT_UPDATE:
-                    pushEmitter.emit(SEGMENT_UPDATE, parsedData.changeNumber, parsedData.segmentName);
+                case MY_SEGMENTS_UPDATE_V2:
+                case SPLIT_KILL:
+                    pushEmitter.emit(parsedData.type, parsedData);
                     break;
                 case MY_SEGMENTS_UPDATE:
-                    pushEmitter.emit(MY_SEGMENTS_UPDATE, parsedData, channel);
-                    break;
-                case SPLIT_KILL:
-                    pushEmitter.emit(SPLIT_KILL, parsedData.changeNumber, parsedData.splitName, parsedData.defaultTreatment);
+                    pushEmitter.emit(parsedData.type, parsedData, channel);
                     break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case OCCUPANCY:

package/esm/sync/streaming/SSEHandler/types.js

@@ -1 +1,13 @@
-export {};
+export var Compression;
+(function (Compression) {
+    Compression[Compression["None"] = 0] = "None";
+    Compression[Compression["Gzip"] = 1] = "Gzip";
+    Compression[Compression["Zlib"] = 2] = "Zlib";
+})(Compression || (Compression = {}));
+export var UpdateStrategy;
+(function (UpdateStrategy) {
+    UpdateStrategy[UpdateStrategy["UnboundedFetchRequest"] = 0] = "UnboundedFetchRequest";
+    UpdateStrategy[UpdateStrategy["BoundedFetchRequest"] = 1] = "BoundedFetchRequest";
+    UpdateStrategy[UpdateStrategy["KeyList"] = 2] = "KeyList";
+    UpdateStrategy[UpdateStrategy["SegmentRemoval"] = 3] = "SegmentRemoval";
+})(UpdateStrategy || (UpdateStrategy = {}));

package/esm/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -10,7 +10,7 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
         this.mySegmentsSyncTask = mySegmentsSyncTask;
         this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
         this.handleNewEvent = false;
-        this.segmentList = undefined; // keeps the segmentList (if included in payload) from the queued event with maximum changeNumber
+        this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
         this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
         this.put = this.put.bind(this);
         this.__handleMySegmentsUpdateCall = this.__handleMySegmentsUpdateCall.bind(this);
@@ -24,7 +24,7 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
             this.handleNewEvent = false;
             var currentMaxChangeNumber_1 = this.maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            this.mySegmentsSyncTask.execute(this.segmentList, true).then(function (result) {
+            this.mySegmentsSyncTask.execute(this.segmentsData, true).then(function (result) {
                 if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
                     _this.currentChangeNumber = Math.max(_this.currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
                 if (_this.handleNewEvent) {
@@ -40,15 +40,15 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
      * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
      *
      * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {string[] | undefined} segmentList might be undefined
+     * @param {SegmentsData | undefined} segmentsData might be undefined
      */
-    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentList) {
+    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentsData) {
         if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber)
             return;
         this.maxChangeNumber = changeNumber;
         this.handleNewEvent = true;
         this.backoff.reset();
-        this.segmentList = segmentList;
+        this.segmentsData = segmentsData;
         if (this.mySegmentsSyncTask.isExecuting())
             return;
         this.__handleMySegmentsUpdateCall();

package/esm/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -54,7 +54,8 @@ var SegmentsUpdateWorker = /** @class */ (function () {
      * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
      * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
      */
-    SegmentsUpdateWorker.prototype.put = function (changeNumber, segmentName) {
+    SegmentsUpdateWorker.prototype.put = function (_a) {
+        var changeNumber = _a.changeNumber, segmentName = _a.segmentName;
         var currentChangeNumber = this.segmentsCache.getChangeNumber(segmentName);
         if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName])
             return;

package/esm/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js

@@ -46,7 +46,8 @@ var SplitsUpdateWorker = /** @class */ (function () {
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    SplitsUpdateWorker.prototype.put = function (changeNumber) {
+    SplitsUpdateWorker.prototype.put = function (_a) {
+        var changeNumber = _a.changeNumber;
         var currentChangeNumber = this.splitsCache.getChangeNumber();
         if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber)
             return;
@@ -64,14 +65,15 @@ var SplitsUpdateWorker = /** @class */ (function () {
      * @param {string} splitName name of split to kill
      * @param {string} defaultTreatment default treatment value
      */
-    SplitsUpdateWorker.prototype.killSplit = function (changeNumber, splitName, defaultTreatment) {
+    SplitsUpdateWorker.prototype.killSplit = function (_a) {
+        var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
         // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
         if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
             // trigger an SDK_UPDATE if Split was killed locally
             this.splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
         }
         // queues the SplitChanges fetch (only if changeNumber is newer)
-        this.put(changeNumber);
+        this.put({ changeNumber: changeNumber });
     };
     return SplitsUpdateWorker;
 }());

package/esm/sync/streaming/constants.js

@@ -23,6 +23,7 @@ export var PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 // Update-type push notifications, handled by NotificationProcessor
 export var MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+export var MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 export var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export var SPLIT_KILL = 'SPLIT_KILL';
 export var SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -34,4 +35,5 @@ export var ControlType;
     ControlType["STREAMING_DISABLED"] = "STREAMING_DISABLED";
     ControlType["STREAMING_PAUSED"] = "STREAMING_PAUSED";
     ControlType["STREAMING_RESUMED"] = "STREAMING_RESUMED";
+    ControlType["STREAMING_RESET"] = "STREAMING_RESET";
 })(ControlType || (ControlType = {}));

package/esm/sync/streaming/mySegmentsV2utils.js

@@ -0,0 +1,69 @@
+import { algorithms } from '../../utils/decompress';
+import { decodeFromBase64 } from '../../utils/base64';
+var GZIP = 1;
+var ZLIB = 2;
+function Uint8ArrayToString(myUint8Arr) {
+    return String.fromCharCode.apply(null, myUint8Arr);
+}
+function StringToUint8Array(myString) {
+    var charCodes = myString.split('').map(function (e) { return e.charCodeAt(0); });
+    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) {
+    var compressData = decodeFromBase64(data);
+    var 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) {
+    var binKeyList = decompress(data, compression);
+    var 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
+    var index = parseInt(hash64hex.slice(8), 16) % (bitmap.length * 8);
+    var internal = Math.floor(index / 8);
+    var offset = index % 8;
+    return (bitmap[internal] & 1 << offset) > 0;
+}