@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/cjs/trackers/uniqueKeysTracker.js

@@ -22,7 +22,7 @@ function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
-                log.debug(constants_1.LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The feature " + featureName + " and key " + key + " exist in the filter");
+                log.debug("".concat(constants_1.LOG_PREFIX_UNIQUE_KEYS_TRACKER, "The feature ").concat(featureName, " and key ").concat(key, " exist in the filter"));
                 return;
             }
             uniqueKeysCache.track(key, featureName);

package/cjs/utils/Backoff.js

@@ -27,6 +27,26 @@ var Backoff = /** @class */ (function () {
         this.attempts++;
         return delayInMillis;
     };
+    /**
+     * Schedule a delayed call to `cb`
+     * @returns a promise that resolves/rejects with the result of the `cb` function, which must return a promise.
+     */
+    Backoff.prototype.scheduleCallAsync = function () {
+        var _this = this;
+        var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
+        if (this.timeoutID)
+            clearTimeout(this.timeoutID);
+        this.attempts++;
+        return new Promise(function (resolve, reject) {
+            _this.timeoutID = setTimeout(function () {
+                _this.timeoutID = undefined;
+                _this.cb().then(resolve, reject);
+            }, delayInMillis);
+        });
+    };
+    /**
+     * Reset the backoff attempts
+     */
     Backoff.prototype.reset = function () {
         this.attempts = 0;
         if (this.timeoutID) {

package/cjs/utils/EventEmitter.js

@@ -0,0 +1,391 @@
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+// Adaptation of "events" library (https://www.npmjs.com/package/events)
+// exported as an ES module instead of CommonJS, to avoid extra configuration steps when using
+// the ESM build of the SDK with tools that doesn't support CommonJS by default (e.g. Rollup).
+var R = typeof Reflect === 'object' ? Reflect : null;
+var ReflectApply = R && typeof R.apply === 'function'
+    ? R.apply
+    : function ReflectApply(target, receiver, args) {
+        return Function.prototype.apply.call(target, receiver, args);
+    };
+var ReflectOwnKeys;
+if (R && typeof R.ownKeys === 'function') {
+    ReflectOwnKeys = R.ownKeys;
+}
+else if (Object.getOwnPropertySymbols) {
+    ReflectOwnKeys = function ReflectOwnKeys(target) {
+        return Object.getOwnPropertyNames(target)
+            .concat(Object.getOwnPropertySymbols(target));
+    };
+}
+else {
+    ReflectOwnKeys = function ReflectOwnKeys(target) {
+        return Object.getOwnPropertyNames(target);
+    };
+}
+function ProcessEmitWarning(warning) {
+    if (console && console.warn)
+        console.warn(warning);
+}
+// eslint-disable-next-line compat/compat
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+    return value !== value;
+};
+function EventEmitter() {
+    EventEmitter.init.call(this);
+}
+exports.EventEmitter = EventEmitter;
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+function checkListener(listener) {
+    if (typeof listener !== 'function') {
+        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+    }
+}
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+    enumerable: true,
+    get: function () {
+        return defaultMaxListeners;
+    },
+    set: function (arg) {
+        if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+            throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+        }
+        defaultMaxListeners = arg;
+    }
+});
+EventEmitter.init = function () {
+    if (this._events === undefined ||
+        this._events === Object.getPrototypeOf(this)._events) {
+        this._events = Object.create(null);
+        this._eventsCount = 0;
+    }
+    this._maxListeners = this._maxListeners || undefined;
+};
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+    if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+    }
+    this._maxListeners = n;
+    return this;
+};
+function _getMaxListeners(that) {
+    if (that._maxListeners === undefined)
+        return EventEmitter.defaultMaxListeners;
+    return that._maxListeners;
+}
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+    return _getMaxListeners(this);
+};
+EventEmitter.prototype.emit = function emit(type) {
+    var args = [];
+    for (var i = 1; i < arguments.length; i++)
+        args.push(arguments[i]);
+    var doError = (type === 'error');
+    var events = this._events;
+    if (events !== undefined)
+        doError = (doError && events.error === undefined);
+    else if (!doError)
+        return false;
+    // If there is no 'error' event listener then throw.
+    if (doError) {
+        var er;
+        if (args.length > 0)
+            er = args[0];
+        if (er instanceof Error) {
+            // Note: The comments on the `throw` lines are intentional, they show
+            // up in Node.js output if this results in an unhandled exception.
+            throw er; // Unhandled 'error' event
+        }
+        // At least give some kind of context to the user
+        var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+        err.context = er;
+        throw err; // Unhandled 'error' event
+    }
+    var handler = events[type];
+    if (handler === undefined)
+        return false;
+    if (typeof handler === 'function') {
+        ReflectApply(handler, this, args);
+    }
+    else {
+        var len = handler.length;
+        var listeners = arrayClone(handler, len); // eslint-disable-next-line no-redeclare
+        for (var i = 0; i < len; ++i)
+            ReflectApply(listeners[i], this, args);
+    }
+    return true;
+};
+function _addListener(target, type, listener, prepend) {
+    var m;
+    var events;
+    var existing;
+    checkListener(listener);
+    events = target._events;
+    if (events === undefined) {
+        events = target._events = Object.create(null);
+        target._eventsCount = 0;
+    }
+    else {
+        // To avoid recursion in the case that type === "newListener"! Before
+        // adding it to the listeners, first emit "newListener".
+        if (events.newListener !== undefined) {
+            target.emit('newListener', type, listener.listener ? listener.listener : listener);
+            // Re-assign `events` because a newListener handler could have caused the
+            // this._events to be assigned to a new object
+            events = target._events;
+        }
+        existing = events[type];
+    }
+    if (existing === undefined) {
+        // Optimize the case of one listener. Don't need the extra array object.
+        existing = events[type] = listener;
+        ++target._eventsCount;
+    }
+    else {
+        if (typeof existing === 'function') {
+            // Adding the second element, need to change to array.
+            existing = events[type] =
+                prepend ? [listener, existing] : [existing, listener];
+            // If we've already got an array, just append.
+        }
+        else if (prepend) {
+            existing.unshift(listener);
+        }
+        else {
+            existing.push(listener);
+        }
+        // Check for listener leak
+        m = _getMaxListeners(target);
+        if (m > 0 && existing.length > m && !existing.warned) {
+            existing.warned = true;
+            // No error code for this since it is a Warning
+            // eslint-disable-next-line no-restricted-syntax
+            var w = new Error('Possible EventEmitter memory leak detected. ' +
+                existing.length + ' ' + String(type) + ' listeners ' +
+                'added. Use emitter.setMaxListeners() to ' +
+                'increase limit');
+            w.name = 'MaxListenersExceededWarning';
+            w.emitter = target;
+            w.type = type;
+            w.count = existing.length;
+            ProcessEmitWarning(w);
+        }
+    }
+    return target;
+}
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+    return _addListener(this, type, listener, false);
+};
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+EventEmitter.prototype.prependListener =
+    function prependListener(type, listener) {
+        return _addListener(this, type, listener, true);
+    };
+function onceWrapper() {
+    if (!this.fired) {
+        this.target.removeListener(this.type, this.wrapFn);
+        this.fired = true;
+        if (arguments.length === 0)
+            return this.listener.call(this.target);
+        return this.listener.apply(this.target, arguments);
+    }
+}
+function _onceWrap(target, type, listener) {
+    var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+    var wrapped = onceWrapper.bind(state);
+    wrapped.listener = listener;
+    state.wrapFn = wrapped;
+    return wrapped;
+}
+EventEmitter.prototype.once = function once(type, listener) {
+    checkListener(listener);
+    this.on(type, _onceWrap(this, type, listener));
+    return this;
+};
+EventEmitter.prototype.prependOnceListener =
+    function prependOnceListener(type, listener) {
+        checkListener(listener);
+        this.prependListener(type, _onceWrap(this, type, listener));
+        return this;
+    };
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+    function removeListener(type, listener) {
+        var list, events, position, i, originalListener;
+        checkListener(listener);
+        events = this._events;
+        if (events === undefined)
+            return this;
+        list = events[type];
+        if (list === undefined)
+            return this;
+        if (list === listener || list.listener === listener) {
+            if (--this._eventsCount === 0)
+                this._events = Object.create(null);
+            else {
+                delete events[type];
+                if (events.removeListener)
+                    this.emit('removeListener', type, list.listener || listener);
+            }
+        }
+        else if (typeof list !== 'function') {
+            position = -1;
+            for (i = list.length - 1; i >= 0; i--) {
+                if (list[i] === listener || list[i].listener === listener) {
+                    originalListener = list[i].listener;
+                    position = i;
+                    break;
+                }
+            }
+            if (position < 0)
+                return this;
+            if (position === 0)
+                list.shift();
+            else {
+                spliceOne(list, position);
+            }
+            if (list.length === 1)
+                events[type] = list[0];
+            if (events.removeListener !== undefined)
+                this.emit('removeListener', type, originalListener || listener);
+        }
+        return this;
+    };
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.removeAllListeners =
+    function removeAllListeners(type) {
+        var listeners, events, i;
+        events = this._events;
+        if (events === undefined)
+            return this;
+        // not listening for removeListener, no need to emit
+        if (events.removeListener === undefined) {
+            if (arguments.length === 0) {
+                this._events = Object.create(null);
+                this._eventsCount = 0;
+            }
+            else if (events[type] !== undefined) {
+                if (--this._eventsCount === 0)
+                    this._events = Object.create(null);
+                else
+                    delete events[type];
+            }
+            return this;
+        }
+        // emit removeListener for all listeners on all events
+        if (arguments.length === 0) {
+            var keys = Object.keys(events);
+            var key;
+            for (i = 0; i < keys.length; ++i) {
+                key = keys[i];
+                if (key === 'removeListener')
+                    continue;
+                this.removeAllListeners(key);
+            }
+            this.removeAllListeners('removeListener');
+            this._events = Object.create(null);
+            this._eventsCount = 0;
+            return this;
+        }
+        listeners = events[type];
+        if (typeof listeners === 'function') {
+            this.removeListener(type, listeners);
+        }
+        else if (listeners !== undefined) {
+            // LIFO order
+            for (i = listeners.length - 1; i >= 0; i--) {
+                this.removeListener(type, listeners[i]);
+            }
+        }
+        return this;
+    };
+function _listeners(target, type, unwrap) {
+    var events = target._events;
+    if (events === undefined)
+        return [];
+    var evlistener = events[type];
+    if (evlistener === undefined)
+        return [];
+    if (typeof evlistener === 'function')
+        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+    return unwrap ?
+        unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+EventEmitter.prototype.listeners = function listeners(type) {
+    return _listeners(this, type, true);
+};
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+    return _listeners(this, type, false);
+};
+EventEmitter.listenerCount = function (emitter, type) {
+    if (typeof emitter.listenerCount === 'function') {
+        return emitter.listenerCount(type);
+    }
+    else {
+        return listenerCount.call(emitter, type);
+    }
+};
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+    var events = this._events;
+    if (events !== undefined) {
+        var evlistener = events[type];
+        if (typeof evlistener === 'function') {
+            return 1;
+        }
+        else if (evlistener !== undefined) {
+            return evlistener.length;
+        }
+    }
+    return 0;
+}
+EventEmitter.prototype.eventNames = function eventNames() {
+    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+function arrayClone(arr, n) {
+    var copy = new Array(n);
+    for (var i = 0; i < n; ++i)
+        copy[i] = arr[i];
+    return copy;
+}
+function spliceOne(list, index) {
+    for (; index + 1 < list.length; index++)
+        list[index] = list[index + 1];
+    list.pop();
+}
+function unwrapListeners(arr) {
+    var ret = new Array(arr.length);
+    for (var i = 0; i < ret.length; ++i) {
+        ret[i] = arr[i].listener || arr[i];
+    }
+    return ret;
+}

package/cjs/utils/filter/bloomFilter.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bloomFilterFactory = void 0;
+// bloom-filters is supported on the following platforms:
+// - Node.js: v4.0.0 or higher
+// - Google Chrome: v41 or higher
+// - Mozilla Firefox: v34 or higher
+// - Microsoft Edge: v12 or higher
+var bloom_filters_1 = require("bloom-filters");
+var EXPECTED_INSERTIONS = 10000000;
+var ERROR_RATE = 0.01;
+var REFRESH_RATE = 24 * 60 * 60000; // 24HS
+function bloomFilterFactory(expectedInsertions, errorRate, refreshRate) {
+    if (expectedInsertions === void 0) { expectedInsertions = EXPECTED_INSERTIONS; }
+    if (errorRate === void 0) { errorRate = ERROR_RATE; }
+    if (refreshRate === void 0) { refreshRate = REFRESH_RATE; }
+    var filter = bloom_filters_1.BloomFilter.create(expectedInsertions, errorRate);
+    return {
+        refreshRate: refreshRate,
+        add: function (key, value) {
+            var data = "".concat(key, ":").concat(value);
+            if (filter.has(data)) {
+                return false;
+            }
+            filter.add(data);
+            return true;
+        },
+        contains: function (key, value) {
+            var data = "".concat(key, ":").concat(value);
+            return filter.has(data);
+        },
+        clear: function () {
+            filter = bloom_filters_1.BloomFilter.create(expectedInsertions, errorRate);
+        }
+    };
+}
+exports.bloomFilterFactory = bloomFilterFactory;

package/cjs/utils/inputValidation/apiKey.js

@@ -38,7 +38,7 @@ function validateAndTrackApiKey(log, maybeSdkKey) {
             }
         }
         else {
-            log.warn(constants_1.WARN_SDK_KEY, [exports.usedKeysMap[sdkKey] + " factory/ies with this SDK Key"]);
+            log.warn(constants_1.WARN_SDK_KEY, ["".concat(exports.usedKeysMap[sdkKey], " factory/ies with this SDK Key")]);
             exports.usedKeysMap[sdkKey]++;
         }
     }

package/cjs/utils/inputValidation/attribute.js

@@ -4,7 +4,7 @@ exports.validateAttribute = void 0;
 var lang_1 = require("../../utils/lang");
 function validateAttribute(log, attributeKey, attributeValue, method) {
     if (!(0, lang_1.isString)(attributeKey) || attributeKey.length === 0) {
-        log.warn(method + ": you passed an invalid attribute name, attribute name must be a non-empty string.");
+        log.warn("".concat(method, ": you passed an invalid attribute name, attribute name must be a non-empty string."));
         return false;
     }
     var isStringVal = (0, lang_1.isString)(attributeValue);
@@ -12,7 +12,7 @@ function validateAttribute(log, attributeKey, attributeValue, method) {
     var isBoolVal = (0, lang_1.isBoolean)(attributeValue);
     var isArrayVal = Array.isArray(attributeValue);
     if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
-        log.warn(method + ": you passed an invalid attribute value for " + attributeKey + ". Acceptable types are: string, number, boolean and array of strings.");
+        log.warn("".concat(method, ": you passed an invalid attribute value for ").concat(attributeKey, ". Acceptable types are: string, number, boolean and array of strings."));
         return false;
     }
     return true;

package/cjs/utils/inputValidation/{split.js → definition.js}

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplit = void 0;
+exports.validateDefinition = void 0;
 var constants_1 = require("../../logger/constants");
 var lang_1 = require("../lang");
 // include BOM and nbsp
 var TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
-function validateSplit(log, maybeSplit, method, item) {
+function validateDefinition(log, maybeDefinition, method, item) {
     if (item === void 0) { item = 'feature flag name'; }
-    if (maybeSplit == undefined) { // eslint-disable-line eqeqeq
+    if (maybeDefinition == undefined) { // eslint-disable-line eqeqeq
         log.error(constants_1.ERROR_NULL, [method, item]);
     }
-    else if (!(0, lang_1.isString)(maybeSplit)) {
+    else if (!(0, lang_1.isString)(maybeDefinition)) {
         log.error(constants_1.ERROR_INVALID, [method, item]);
     }
     else {
-        if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {
-            log.warn(constants_1.WARN_TRIMMING, [method, item, maybeSplit]);
-            maybeSplit = maybeSplit.trim();
+        if (TRIMMABLE_SPACES_REGEX.test(maybeDefinition)) {
+            log.warn(constants_1.WARN_TRIMMING, [method, item, maybeDefinition]);
+            maybeDefinition = maybeDefinition.trim();
         }
-        if (maybeSplit.length > 0) {
-            return maybeSplit;
+        if (maybeDefinition.length > 0) {
+            return maybeDefinition;
         }
         else {
             log.error(constants_1.ERROR_EMPTY, [method, item]);
@@ -27,4 +27,4 @@ function validateSplit(log, maybeSplit, method, item) {
     }
     return false;
 }
-exports.validateSplit = validateSplit;
+exports.validateDefinition = validateDefinition;

package/cjs/utils/inputValidation/{splitExistence.js → definitionExistence.js}

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplitExistence = void 0;
+exports.validateDefinitionExistence = void 0;
 var labels_1 = require("../labels");
 var constants_1 = require("../../logger/constants");
 /**
  * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
+ * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a definition twice.
  */
-function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
+function validateDefinitionExistence(log, readinessManager, definitionName, labelOrDefinitionObj, method) {
     if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
-        if (labelOrSplitObj === labels_1.SPLIT_NOT_FOUND || labelOrSplitObj === labels_1.FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
-            log.warn(constants_1.WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
+        if (labelOrDefinitionObj === labels_1.DEFINITION_NOT_FOUND || labelOrDefinitionObj === labels_1.FALLBACK_DEFINITION_NOT_FOUND || labelOrDefinitionObj == null) {
+            log.warn(constants_1.WARN_NOT_EXISTENT_DEFINITION, [method, definitionName]);
             return false;
         }
     }
     return true;
 }
-exports.validateSplitExistence = validateSplitExistence;
+exports.validateDefinitionExistence = validateDefinitionExistence;

package/cjs/utils/inputValidation/definitions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDefinitions = void 0;
+var constants_1 = require("../../logger/constants");
+var lang_1 = require("../lang");
+var definition_1 = require("./definition");
+function validateDefinitions(log, maybeDefinitions, method, listName, item) {
+    if (listName === void 0) { listName = 'feature flag names'; }
+    if (item === void 0) { item = 'feature flag name'; }
+    if (Array.isArray(maybeDefinitions) && maybeDefinitions.length > 0) {
+        var validatedArray_1 = [];
+        // Remove invalid values
+        maybeDefinitions.forEach(function (maybeDefinition) {
+            var definitionName = (0, definition_1.validateDefinition)(log, maybeDefinition, method, item);
+            if (definitionName)
+                validatedArray_1.push(definitionName);
+        });
+        // Strip off duplicated values if we have valid definition names then return
+        if (validatedArray_1.length)
+            return (0, lang_1.uniq)(validatedArray_1);
+    }
+    log.error(constants_1.ERROR_EMPTY_ARRAY, [method, listName]);
+    return false;
+}
+exports.validateDefinitions = validateDefinitions;

package/cjs/utils/inputValidation/eventProperties.js

@@ -70,7 +70,7 @@ function validateEvaluationOptions(log, maybeOptions, method) {
         if (!impressionsDisabled)
             return options;
         // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-        return options ? (0, tslib_1.__assign)((0, tslib_1.__assign)({}, options), { impressionsDisabled: impressionsDisabled }) : { impressionsDisabled: impressionsDisabled };
+        return options ? tslib_1.__assign(tslib_1.__assign({}, options), { impressionsDisabled: impressionsDisabled }) : { impressionsDisabled: impressionsDisabled };
     }
     else if (maybeOptions) {
         log.error(constants_1.ERROR_NOT_PLAIN_OBJECT, [method, 'evaluation options']);

package/cjs/utils/inputValidation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateEvaluationOptions = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfReadyFromCache = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
+exports.validateEvaluationOptions = exports.validateTrafficTypeExistence = exports.validateDefinitionExistence = exports.validateIfOperational = exports.validateIfReadyFromCache = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateDefinitions = exports.validateDefinition = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
 var apiKey_1 = require("./apiKey");
 Object.defineProperty(exports, "validateApiKey", { enumerable: true, get: function () { return apiKey_1.validateApiKey; } });
 Object.defineProperty(exports, "validateAndTrackApiKey", { enumerable: true, get: function () { return apiKey_1.validateAndTrackApiKey; } });
@@ -15,18 +15,18 @@ var eventProperties_1 = require("./eventProperties");
 Object.defineProperty(exports, "validateEventProperties", { enumerable: true, get: function () { return eventProperties_1.validateEventProperties; } });
 var key_1 = require("./key");
 Object.defineProperty(exports, "validateKey", { enumerable: true, get: function () { return key_1.validateKey; } });
-var split_1 = require("./split");
-Object.defineProperty(exports, "validateSplit", { enumerable: true, get: function () { return split_1.validateSplit; } });
-var splits_1 = require("./splits");
-Object.defineProperty(exports, "validateSplits", { enumerable: true, get: function () { return splits_1.validateSplits; } });
+var definition_1 = require("./definition");
+Object.defineProperty(exports, "validateDefinition", { enumerable: true, get: function () { return definition_1.validateDefinition; } });
+var definitions_1 = require("./definitions");
+Object.defineProperty(exports, "validateDefinitions", { enumerable: true, get: function () { return definitions_1.validateDefinitions; } });
 var trafficType_1 = require("./trafficType");
 Object.defineProperty(exports, "validateTrafficType", { enumerable: true, get: function () { return trafficType_1.validateTrafficType; } });
 var isOperational_1 = require("./isOperational");
 Object.defineProperty(exports, "validateIfNotDestroyed", { enumerable: true, get: function () { return isOperational_1.validateIfNotDestroyed; } });
 Object.defineProperty(exports, "validateIfReadyFromCache", { enumerable: true, get: function () { return isOperational_1.validateIfReadyFromCache; } });
 Object.defineProperty(exports, "validateIfOperational", { enumerable: true, get: function () { return isOperational_1.validateIfOperational; } });
-var splitExistence_1 = require("./splitExistence");
-Object.defineProperty(exports, "validateSplitExistence", { enumerable: true, get: function () { return splitExistence_1.validateSplitExistence; } });
+var definitionExistence_1 = require("./definitionExistence");
+Object.defineProperty(exports, "validateDefinitionExistence", { enumerable: true, get: function () { return definitionExistence_1.validateDefinitionExistence; } });
 var trafficTypeExistence_1 = require("./trafficTypeExistence");
 Object.defineProperty(exports, "validateTrafficTypeExistence", { enumerable: true, get: function () { return trafficTypeExistence_1.validateTrafficTypeExistence; } });
 var eventProperties_2 = require("./eventProperties");

package/cjs/utils/inputValidation/isOperational.js

@@ -9,15 +9,15 @@ function validateIfNotDestroyed(log, readinessManager, method) {
     return false;
 }
 exports.validateIfNotDestroyed = validateIfNotDestroyed;
-function validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames) {
+function validateIfReadyFromCache(log, readinessManager, method) {
     if (readinessManager.isReadyFromCache())
         return true;
-    log.warn(constants_1.CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? " for feature flag " + featureFlagNameOrNames.toString() : '']);
+    log.warn(constants_1.CLIENT_NOT_READY_FROM_CACHE, [method]);
     return false;
 }
 exports.validateIfReadyFromCache = validateIfReadyFromCache;
 // Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
-function validateIfOperational(log, readinessManager, method, featureFlagNameOrNames) {
-    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
+function validateIfOperational(log, readinessManager, method) {
+    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method);
 }
 exports.validateIfOperational = validateIfOperational;