@splitsoftware/splitio-commons 1.13.2-rc.2 → 1.13.2-rc.4

package/esm/evaluator/matchers/semver_gte.js

@@ -0,0 +1,9 @@
+import { Semver } from '../../utils/Semver';
+export function greaterThanEqualToSemverMatcherContext(log, ruleAttr) {
+    var ruleSemver = new Semver(ruleAttr);
+    return function greaterThanEqualToSemverMatcher(runtimeAttr) {
+        var runtimeSemver = new Semver(runtimeAttr);
+        var isGreaterThanEqual = runtimeSemver.compare(ruleSemver) >= 0;
+        return isGreaterThanEqual;
+    };
+}

package/esm/evaluator/matchers/semver_inlist.js

@@ -0,0 +1,10 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+import { Semver } from '../../utils/Semver';
+export function inListSemverMatcherContext(log, ruleAttr) {
+    var listOfSemvers = new _Set(setToArray(ruleAttr).map(function (version) { return new Semver(version).version; }));
+    return function inListSemverMatcher(runtimeAttr) {
+        var runtimeSemver = new Semver(runtimeAttr).version;
+        var isInList = listOfSemvers.has(runtimeSemver);
+        return isInList;
+    };
+}

package/esm/evaluator/matchers/semver_lte.js

@@ -0,0 +1,9 @@
+import { Semver } from '../../utils/Semver';
+export function lessThanEqualToSemverMatcherContext(log, ruleAttr) {
+    var ruleSemver = new Semver(ruleAttr);
+    return function lessThanEqualToSemverMatcher(runtimeAttr) {
+        var runtimeSemver = new Semver(runtimeAttr);
+        var isLessThenEqual = runtimeSemver.compare(ruleSemver) <= 0;
+        return isLessThenEqual;
+    };
+}

package/esm/evaluator/matchers/string.js

@@ -1,15 +1,8 @@
-import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
+import { ENGINE_MATCHER_STRING } from '../../logger/constants';
 export function stringMatcherContext(log, ruleAttr) {
+    var regex = new RegExp(ruleAttr);
     return function stringMatcher(runtimeAttr) {
-        var re;
-        try {
-            re = new RegExp(ruleAttr);
-        }
-        catch (e) {
-            log.debug(ENGINE_MATCHER_STRING_INVALID, [ruleAttr]);
-            return false;
-        }
-        var regexMatches = re.test(runtimeAttr);
+        var regexMatches = regex.test(runtimeAttr);
         log.debug(ENGINE_MATCHER_STRING, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']);
         return regexMatches;
     };

package/esm/evaluator/matchersTransform/index.js

@@ -10,37 +10,38 @@ import { zeroSinceHH, zeroSinceSS } from '../convertions';
  */
 export function matchersTransform(matchers) {
     var parsedMatchers = matchers.map(function (matcher) {
-        var matcherType = matcher.matcherType /* string */, negate = matcher.negate /* boolean */, keySelector = matcher.keySelector /* keySelectorObject */, segmentObject = matcher.userDefinedSegmentMatcherData /* segmentObject */, whitelistObject = matcher.whitelistMatcherData /* whiteListObject, provided by 'WHITELIST', set and string matchers */, unaryNumericObject = matcher.unaryNumericMatcherData /* unaryNumericObject */, betweenObject = matcher.betweenMatcherData /* betweenObject */, dependencyObject = matcher.dependencyMatcherData /* dependencyObject */, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData;
+        var matcherType = matcher.matcherType, negate = matcher.negate, keySelector = matcher.keySelector, userDefinedSegmentMatcherData = matcher.userDefinedSegmentMatcherData, whitelistMatcherData = matcher.whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */ unaryNumericMatcherData = matcher.unaryNumericMatcherData, betweenMatcherData = matcher.betweenMatcherData, dependencyMatcherData = matcher.dependencyMatcherData, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData, betweenStringMatcherData = matcher.betweenStringMatcherData;
         var attribute = keySelector && keySelector.attribute;
         var type = matcherTypesMapper(matcherType);
         // As default input data type we use string (even for ALL_KEYS)
         var dataType = matcherDataTypes.STRING;
         var value = undefined;
         if (type === matcherTypes.IN_SEGMENT) {
-            value = segmentTransform(segmentObject);
+            value = segmentTransform(userDefinedSegmentMatcherData);
         }
-        else if (type === matcherTypes.WHITELIST) {
-            value = whitelistTransform(whitelistObject);
+        else if (type === matcherTypes.WHITELIST ||
+            type === matcherTypes.IN_LIST_SEMVER) {
+            value = whitelistTransform(whitelistMatcherData);
         }
         else if (type === matcherTypes.EQUAL_TO) {
-            value = numericTransform(unaryNumericObject);
+            value = numericTransform(unaryNumericMatcherData);
             dataType = matcherDataTypes.NUMBER;
-            if (unaryNumericObject.dataType === 'DATETIME') {
+            if (unaryNumericMatcherData.dataType === 'DATETIME') {
                 value = zeroSinceHH(value);
                 dataType = matcherDataTypes.DATETIME;
             }
         }
         else if (type === matcherTypes.GREATER_THAN_OR_EQUAL_TO ||
             type === matcherTypes.LESS_THAN_OR_EQUAL_TO) {
-            value = numericTransform(unaryNumericObject);
+            value = numericTransform(unaryNumericMatcherData);
             dataType = matcherDataTypes.NUMBER;
-            if (unaryNumericObject.dataType === 'DATETIME') {
+            if (unaryNumericMatcherData.dataType === 'DATETIME') {
                 value = zeroSinceSS(value);
                 dataType = matcherDataTypes.DATETIME;
             }
         }
         else if (type === matcherTypes.BETWEEN) {
-            value = betweenObject;
+            value = betweenMatcherData;
             dataType = matcherDataTypes.NUMBER;
             if (value.dataType === 'DATETIME') {
                 value.start = zeroSinceSS(value.start);
@@ -48,27 +49,33 @@ export function matchersTransform(matchers) {
                 dataType = matcherDataTypes.DATETIME;
             }
         }
+        else if (type === matcherTypes.BETWEEN_SEMVER) {
+            value = betweenStringMatcherData;
+        }
         else if (type === matcherTypes.EQUAL_TO_SET ||
             type === matcherTypes.CONTAINS_ANY_OF_SET ||
             type === matcherTypes.CONTAINS_ALL_OF_SET ||
             type === matcherTypes.PART_OF_SET) {
-            value = setTransform(whitelistObject);
+            value = setTransform(whitelistMatcherData);
             dataType = matcherDataTypes.SET;
         }
         else if (type === matcherTypes.STARTS_WITH ||
             type === matcherTypes.ENDS_WITH ||
             type === matcherTypes.CONTAINS_STRING) {
-            value = setTransform(whitelistObject);
+            value = setTransform(whitelistMatcherData);
         }
         else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
-            value = dependencyObject;
+            value = dependencyMatcherData;
             dataType = matcherDataTypes.NOT_SPECIFIED;
         }
         else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
             dataType = matcherDataTypes.BOOLEAN;
             value = booleanMatcherData;
         }
-        else if (type === matcherTypes.MATCHES_STRING) {
+        else if (type === matcherTypes.MATCHES_STRING ||
+            type === matcherTypes.EQUAL_TO_SEMVER ||
+            type === matcherTypes.GREATER_THAN_OR_EQUAL_TO_SEMVER ||
+            type === matcherTypes.LESS_THAN_OR_EQUAL_TO_SEMVER) {
             value = stringMatcherData;
         }
         return {

package/esm/evaluator/parser/index.js

@@ -6,24 +6,37 @@ import { conditionContext } from '../condition';
 import { ifElseIfCombinerContext } from '../combiners/ifelseif';
 import { andCombinerContext } from '../combiners/and';
 import { thenable } from '../../utils/promise/thenable';
+import { ENGINE_MATCHER_ERROR } from '../../logger/constants';
 export function parser(log, conditions, storage) {
     var predicates = [];
-    for (var i = 0; i < conditions.length; i++) {
+    var _loop_1 = function (i) {
         var _a = conditions[i], matcherGroup = _a.matcherGroup, partitions = _a.partitions, label = _a.label, conditionType = _a.conditionType;
         // transform data structure
         var matchers = matchersTransform(matcherGroup.matchers);
         // create a set of pure functions from the matcher's dto
-        var expressions = matchers.map(function (matcherDto) {
-            var matcher = matcherFactory(log, matcherDto, storage);
+        var expressions = matchers.map(function (matcherDto, index) {
+            var matcher;
+            try {
+                matcher = matcherFactory(log, matcherDto, storage);
+            }
+            catch (error) {
+                log.error(ENGINE_MATCHER_ERROR, [matcherGroup.matchers[index].matcherType, error]);
+            }
             // Evaluator function.
             return function (key, attributes, splitEvaluator) {
                 var value = sanitizeValue(log, key, matcherDto, attributes);
-                var result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;
-                if (thenable(result)) {
-                    // @ts-ignore
-                    return result.then(function (res) { return Boolean(res ^ matcherDto.negate); });
+                var result = false;
+                if (value !== undefined && matcher) {
+                    try {
+                        result = matcher(value, splitEvaluator);
+                    }
+                    catch (error) {
+                        log.error(ENGINE_MATCHER_ERROR, [matcherGroup.matchers[index].matcherType, error]);
+                    }
                 }
-                // @ts-ignore
+                if (thenable(result)) { // @ts-ignore
+                    return result.then(function (res) { return Boolean(res ^ matcherDto.negate); });
+                } // @ts-ignore
                 return Boolean(result ^ matcherDto.negate);
             };
         });
@@ -31,10 +44,14 @@ export function parser(log, conditions, storage) {
         if (expressions.length === 0) {
             // reset any data collected during parsing
             predicates = [];
-            // and break the loop
-            break;
+            return "break";
         }
         predicates.push(conditionContext(log, andCombinerContext(log, expressions), Treatments.parse(partitions), label, conditionType));
+    };
+    for (var i = 0; i < conditions.length; i++) {
+        var state_1 = _loop_1(i);
+        if (state_1 === "break")
+            break;
     }
     // Instanciate evaluator given the set of conditions using if else if logic
     return ifElseIfCombinerContext(log, predicates);

package/esm/logger/constants.js

@@ -25,7 +25,6 @@ export var ENGINE_MATCHER_LESS = 16;
 export var ENGINE_MATCHER_PART_OF = 17;
 export var ENGINE_MATCHER_SEGMENT = 18;
 export var ENGINE_MATCHER_STRING = 19;
-export var ENGINE_MATCHER_STRING_INVALID = 20;
 export var ENGINE_MATCHER_STARTS_WITH = 21;
 export var ENGINE_MATCHER_WHITELIST = 22;
 export var ENGINE_VALUE = 23;
@@ -128,6 +127,7 @@ export var ERROR_NOT_BOOLEAN = 325;
 export var ERROR_MIN_CONFIG_PARAM = 326;
 export var ERROR_TOO_MANY_SETS = 327;
 export var ERROR_SETS_FILTER_EXCLUSIVE = 328;
+export var ENGINE_MATCHER_ERROR = 329;
 // Log prefixes (a.k.a. tags or categories)
 export var LOG_PREFIX_SETTINGS = 'settings';
 export var LOG_PREFIX_INSTANTIATION = 'Factory instantiation';

package/esm/logger/messages/debug.js

@@ -22,7 +22,6 @@ export var codesDebug = codesInfo.concat([
     [c.ENGINE_MATCHER_PART_OF, c.LOG_PREFIX_ENGINE_MATCHER + '[partOfMatcher] %s is part of %s? %s'],
     [c.ENGINE_MATCHER_SEGMENT, c.LOG_PREFIX_ENGINE_MATCHER + '[segmentMatcher] evaluated %s / %s => %s'],
     [c.ENGINE_MATCHER_STRING, c.LOG_PREFIX_ENGINE_MATCHER + '[stringMatcher] does %s matches with %s? %s'],
-    [c.ENGINE_MATCHER_STRING_INVALID, c.LOG_PREFIX_ENGINE_MATCHER + '[stringMatcher] %s is an invalid regex'],
     [c.ENGINE_MATCHER_STARTS_WITH, c.LOG_PREFIX_ENGINE_MATCHER + '[startsWithMatcher] %s starts with %s? %s'],
     [c.ENGINE_MATCHER_WHITELIST, c.LOG_PREFIX_ENGINE_MATCHER + '[whitelistMatcher] evaluated %s in [%s] => %s'],
     [c.ENGINE_VALUE, c.LOG_PREFIX_ENGINE_VALUE + 'Extracted attribute [%s], [%s] will be used for matching.'],

package/esm/logger/messages/error.js

@@ -2,6 +2,7 @@ import * as c from '../constants';
 export var codesError = [
     // evaluator
     [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules or unsupported matcher type found'],
+    [c.ENGINE_MATCHER_ERROR, c.LOG_PREFIX_ENGINE_MATCHER + '[%s] %s'],
     // SDK
     [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],
     [c.ERROR_CLIENT_CANNOT_GET_READY, 'The SDK will not get ready. Reason: %s'],

package/esm/services/splitApi.js

@@ -1,6 +1,6 @@
 import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT, FLAGS_SPEC } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
@@ -29,16 +29,16 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
         fetchAuth: function (userMatchingKeys) {
-            var url = urls.auth + "/v2/auth?s=" + FLAGS_SPEC;
-            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
+            var url = urls.auth + "/v2/auth";
+            if (userMatchingKeys) { // accounting the possibility that `userMatchingKeys` is undefined (server-side API)
                 var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-                if (queryParams)
-                    url += '&' + queryParams;
+                if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty
+                    url += '?' + queryParams;
             }
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
         },
         fetchSplitChanges: function (since, noCache, till) {
-            var url = urls.sdk + "/splitChanges?s=" + FLAGS_SPEC + "&since=" + since + (till ? '&till=' + till : '') + (filterQueryString || '');
+            var url = urls.sdk + "/splitChanges?since=" + since + (till ? '&till=' + till : '') + (filterQueryString || '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
                 .catch(function (err) {
                 if (err.statusCode === 414)

package/esm/storages/KeyBuilder.js

@@ -1,4 +1,3 @@
-import { FLAGS_SPEC } from '../utils/constants';
 import { startsWith } from '../utils/lang';
 import { hash } from '../utils/murmur3/murmur3';
 var everythingAtTheEnd = /[^.]+$/;
@@ -63,9 +62,9 @@ var KeyBuilder = /** @class */ (function () {
 }());
 export { KeyBuilder };
 /**
- * Generates a murmur32 hash based on the authorization key, the feature flags filter query, and version of SplitChanges API.
+ * Generates a murmur32 hash based on the authorization key and the feature flags filter query.
  * The hash is in hexadecimal format (8 characters max, 32 bits).
  */
 export function getStorageHash(settings) {
-    return hash(settings.core.authorizationKey + "::" + settings.sync.__splitFiltersValidation.queryString + "::" + FLAGS_SPEC).toString(16);
+    return hash(settings.core.authorizationKey + "::" + settings.sync.__splitFiltersValidation.queryString).toString(16);
 }

package/esm/utils/Semver.js

@@ -0,0 +1,100 @@
+import { isString } from '../utils/lang';
+var NUMERIC_IDENTIFIER_REGEX = /^[0-9]+$/;
+var METADATA_DELIMITER = '+';
+var PRERELEASE_DELIMITER = '-';
+var VALUE_DELIMITER = '.';
+/**
+ * Compares two strings. If both strings are numeric identifiers, they are compared numerically. Otherwise, they are compared lexicographically.
+ * This could be implemented using `a.localeCompare(b, undefined, { numeric: true })` but locale options are not broadly supported.
+ */
+function compareStrings(a, b) {
+    if (NUMERIC_IDENTIFIER_REGEX.test(a) && NUMERIC_IDENTIFIER_REGEX.test(b)) {
+        var result = a.length - b.length;
+        if (result !== 0) {
+            return result;
+        }
+    }
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+// Sanitizes a numeric identifier by removing leading zeros
+function sanitizeNumericIdentifier(value) {
+    return value.replace(/^0+(?=\d)/, '');
+}
+function throwError(version) {
+    throw new Error('Unable to convert to Semver, incorrect format: ' + version);
+}
+var Semver = /** @class */ (function () {
+    function Semver(version) {
+        if (!isString(version))
+            throwError(version);
+        // Separate metadata if exists
+        var index = version.indexOf(METADATA_DELIMITER);
+        var _a = index === -1 ? [version] : [version.slice(0, index), version.slice(index + 1)], vWithoutMetadata = _a[0], metadata = _a[1];
+        if (metadata === '')
+            throwError(version);
+        // Set pre-release versions if exists
+        index = vWithoutMetadata.indexOf(PRERELEASE_DELIMITER);
+        if (index === -1) {
+            this._isStable = true;
+            this._preRelease = [];
+        }
+        else {
+            this._isStable = false;
+            this._preRelease = vWithoutMetadata.slice(index + 1).split(VALUE_DELIMITER).map(function (value) {
+                if (!value)
+                    throwError(version);
+                return NUMERIC_IDENTIFIER_REGEX.test(value) ?
+                    sanitizeNumericIdentifier(value) :
+                    value;
+            });
+            vWithoutMetadata = vWithoutMetadata.slice(0, index);
+        }
+        // Set major, minor, and patch versions
+        var vParts = vWithoutMetadata.split(VALUE_DELIMITER).map(function (value) {
+            if (!value || !NUMERIC_IDENTIFIER_REGEX.test(value))
+                throwError(version);
+            return sanitizeNumericIdentifier(value);
+        });
+        if (vParts.length !== 3)
+            throwError(version);
+        this._major = vParts[0];
+        this._minor = vParts[1];
+        this._patch = vParts[2];
+        // Set version string
+        this.version = vParts.join(VALUE_DELIMITER);
+        if (this._preRelease.length)
+            this.version += PRERELEASE_DELIMITER + this._preRelease.join(VALUE_DELIMITER);
+        if (metadata)
+            this.version += METADATA_DELIMITER + metadata;
+    }
+    /**
+     * Precedence comparision between 2 Semver objects.
+     *
+     * @return `0` if `this === toCompare`, `-1` if `this < toCompare`, and `1` if `this > toCompare`
+     */
+    Semver.prototype.compare = function (toCompare) {
+        if (this.version === toCompare.version)
+            return 0;
+        var result = compareStrings(this._major, toCompare._major);
+        if (result !== 0)
+            return result;
+        result = compareStrings(this._minor, toCompare._minor);
+        if (result !== 0)
+            return result;
+        result = compareStrings(this._patch, toCompare._patch);
+        if (result !== 0)
+            return result;
+        if (!this._isStable && toCompare._isStable)
+            return -1;
+        if (this._isStable && !toCompare._isStable)
+            return 1;
+        for (var i = 0, length_1 = Math.min(this._preRelease.length, toCompare._preRelease.length); i < length_1; i++) {
+            var result_1 = compareStrings(this._preRelease[i], toCompare._preRelease[i]);
+            if (result_1 !== 0)
+                return result_1;
+        }
+        return this._preRelease.length - toCompare._preRelease.length;
+    };
+    return Semver;
+}());
+export { Semver };

package/esm/utils/constants/index.js

@@ -86,4 +86,3 @@ export var NON_REQUESTED = 1;
 export var DISABLED = 0;
 export var ENABLED = 1;
 export var PAUSED = 2;
-export var FLAGS_SPEC = '1.1';

package/esm/utils/settingsValidation/logger/pluggableLogger.js

@@ -1,7 +1,7 @@
 import { Logger, LogLevels } from '../../../logger';
 import { getLogLevel } from './commons';
 function isLogger(log) {
-    return log && typeof log.debug === 'function' && typeof log.info === 'function' && typeof log.warn === 'function' && typeof log.error === 'function' && typeof log.setLogLevel === 'function';
+    return log !== null && typeof log === 'object' && typeof log.debug === 'function' && typeof log.info === 'function' && typeof log.warn === 'function' && typeof log.error === 'function' && typeof log.setLogLevel === 'function';
 }
 // By default it starts disabled.
 var initialLogLevel = LogLevels.NONE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.13.2-rc.2",
+  "version": "1.13.2-rc.4",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -63,7 +63,6 @@
     "@typescript-eslint/eslint-plugin": "^6.6.0",
     "@typescript-eslint/parser": "^6.6.0",
     "cross-env": "^7.0.2",
-    "csv-streamify": "^4.0.0",
     "eslint": "^8.48.0",
     "eslint-plugin-compat": "^4.2.0",
     "eslint-plugin-import": "^2.25.3",

package/src/dtos/types.ts

@@ -17,6 +17,11 @@ export interface IBetweenMatcherData {
   end: number
 }
 
+export interface IBetweenStringMatcherData {
+  start: string
+  end: string
+}
+
 export interface IWhitelistMatcherData {
   whitelist: string[]
 }
@@ -44,6 +49,7 @@ interface ISplitMatcherBase {
   dependencyMatcherData?: null | IDependencyMatcherData
   booleanMatcherData?: null | boolean
   stringMatcherData?: null | string
+  betweenStringMatcherData?: null | IBetweenStringMatcherData
 }
 
 interface IAllKeysMatcher extends ISplitMatcherBase {
@@ -130,9 +136,36 @@ interface IMatchesStringMatcher extends ISplitMatcherBase {
   stringMatcherData: string
 }
 
+interface IEqualToSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'EQUAL_TO_SEMVER',
+  stringMatcherData: string
+}
+
+interface IGreaterThanOrEqualToSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'GREATER_THAN_OR_EQUAL_TO_SEMVER',
+  stringMatcherData: string
+}
+
+
+interface ILessThanOrEqualToSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'LESS_THAN_OR_EQUAL_TO_SEMVER',
+  stringMatcherData: string
+}
+
+interface IBetweenSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'BETWEEN_SEMVER'
+  betweenStringMatcherData: IBetweenStringMatcherData
+}
+
+interface IInListSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'IN_LIST_SEMVER',
+  whitelistMatcherData: IWhitelistMatcherData
+}
+
 export type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher |
   ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher |
-  IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher
+  IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher |
+  IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher
 
 /** Split object */
 export interface ISplitPartition {

package/src/evaluator/matchers/between.ts

@@ -2,7 +2,7 @@ import { IBetweenMatcherData } from '../../dtos/types';
 import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) /*: Function */ {
+export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) {
   return function betweenMatcher(runtimeAttr: number): boolean {
 
     let isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;

package/src/evaluator/matchers/boolean.ts

@@ -1,7 +1,7 @@
 import { ENGINE_MATCHER_BOOLEAN } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export function booleanMatcherContext(log: ILogger, ruleAttr: boolean) /*: Function */ {
+export function booleanMatcherContext(log: ILogger, ruleAttr: boolean) {
   return function booleanMatcher(runtimeAttr: boolean): boolean {
     let booleanMatches = ruleAttr === runtimeAttr;
 

package/src/evaluator/matchers/cont_all.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_CONTAINS_ALL } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsAllMatcher(runtimeAttr: string[]): boolean {
     let containsAll = true;
 

package/src/evaluator/matchers/cont_any.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_CONTAINS_ANY } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsAnyMatcher(runtimeAttr: string[]): boolean {
     let containsAny = false;
 

package/src/evaluator/matchers/cont_str.ts

@@ -2,7 +2,7 @@ import { isString } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants';
 
-export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsStringMatcher(runtimeAttr: string): boolean {
     let contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
 

package/src/evaluator/matchers/eq.ts

@@ -1,7 +1,7 @@
 import { ENGINE_MATCHER_EQUAL } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export function equalToMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
+export function equalToMatcherContext(log: ILogger, ruleAttr: number) {
   return function equalToMatcher(runtimeAttr: number): boolean {
     let isEqual = runtimeAttr === ruleAttr;
 

package/src/evaluator/matchers/eq_set.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function equalToSetMatcher(runtimeAttr: string[]): boolean {
     // Length being the same is the first condition.
     let isEqual = runtimeAttr.length === ruleAttr.length;

package/src/evaluator/matchers/ew.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { endsWith } from '../../utils/lang';
 
-export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function endsWithMatcher(runtimeAttr: string): boolean {
     let strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
 

package/src/evaluator/matchers/gte.ts

@@ -1,12 +1,12 @@
 import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
+export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) {
   return function greaterThanEqualMatcher(runtimeAttr: number): boolean {
-    let isGreaterEqualThan = runtimeAttr >= ruleAttr;
+    let isGreaterThanEqual = runtimeAttr >= ruleAttr;
 
-    log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterEqualThan]);
+    log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterThanEqual]);
 
-    return isGreaterEqualThan;
+    return isGreaterThanEqual;
   };
 }

package/src/evaluator/matchers/index.ts

@@ -15,29 +15,39 @@ import { containsStringMatcherContext } from './cont_str';
 import { dependencyMatcherContext } from './dependency';
 import { booleanMatcherContext } from './boolean';
 import { stringMatcherContext } from './string';
+import { equalToSemverMatcherContext } from './semver_eq';
+import { greaterThanEqualToSemverMatcherContext } from './semver_gte';
+import { lessThanEqualToSemverMatcherContext } from './semver_lte';
+import { betweenSemverMatcherContext } from './semver_between';
+import { inListSemverMatcherContext } from './semver_inlist';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { IMatcher, IMatcherDto } from '../types';
 import { ILogger } from '../../logger/types';
 
 const matchers = [
-  undefined, // UNDEFINED: 0,
-  allMatcherContext, // ALL_KEYS: 1,
-  segmentMatcherContext, // IN_SEGMENT: 2,
-  whitelistMatcherContext, // WHITELIST: 3,
-  equalToMatcherContext, // EQUAL_TO: 4,
-  greaterThanEqualMatcherContext, // GREATER_THAN_OR_EQUAL_TO: 5,
-  lessThanEqualMatcherContext, // LESS_THAN_OR_EQUAL_TO: 6,
-  betweenMatcherContext, // BETWEEN: 7,
-  equalToSetMatcherContext, // EQUAL_TO_SET: 8,
-  containsAnySetMatcherContext, // CONTAINS_ANY_OF_SET: 9,
-  containsAllSetMatcherContext, // CONTAINS_ALL_OF_SET: 10,
-  partOfSetMatcherContext, // PART_OF_SET: 11,
-  endsWithMatcherContext, // ENDS_WITH: 12,
-  startsWithMatcherContext, // STARTS_WITH: 13,
-  containsStringMatcherContext, // CONTAINS_STRING: 14,
-  dependencyMatcherContext, // IN_SPLIT_TREATMENT: 15,
-  booleanMatcherContext, // EQUAL_TO_BOOLEAN: 16,
-  stringMatcherContext // MATCHES_STRING: 17
+  undefined, // UNDEFINED: 0
+  allMatcherContext, // ALL_KEYS: 1
+  segmentMatcherContext, // IN_SEGMENT: 2
+  whitelistMatcherContext, // WHITELIST: 3
+  equalToMatcherContext, // EQUAL_TO: 4
+  greaterThanEqualMatcherContext, // GREATER_THAN_OR_EQUAL_TO: 5
+  lessThanEqualMatcherContext, // LESS_THAN_OR_EQUAL_TO: 6
+  betweenMatcherContext, // BETWEEN: 7
+  equalToSetMatcherContext, // EQUAL_TO_SET: 8
+  containsAnySetMatcherContext, // CONTAINS_ANY_OF_SET: 9
+  containsAllSetMatcherContext, // CONTAINS_ALL_OF_SET: 10
+  partOfSetMatcherContext, // PART_OF_SET: 11
+  endsWithMatcherContext, // ENDS_WITH: 12
+  startsWithMatcherContext, // STARTS_WITH: 13
+  containsStringMatcherContext, // CONTAINS_STRING: 14
+  dependencyMatcherContext, // IN_SPLIT_TREATMENT: 15
+  booleanMatcherContext, // EQUAL_TO_BOOLEAN: 16
+  stringMatcherContext, // MATCHES_STRING: 17
+  equalToSemverMatcherContext, // EQUAL_TO_SEMVER: 18
+  greaterThanEqualToSemverMatcherContext, // GREATER_THAN_OR_EQUAL_TO_SEMVER: 19
+  lessThanEqualToSemverMatcherContext, // LESS_THAN_OR_EQUAL_TO_SEMVER: 20
+  betweenSemverMatcherContext, // BETWEEN_SEMVER: 21
+  inListSemverMatcherContext, // IN_LIST_SEMVER: 22
 ];
 
 /**