@convertcom/js-sdk-rules 0.0.1 → 1.0.0

package/lib/index.js

@@ -1,8 +1,235 @@
 'use strict';
 
+var jsSdkUtils = require('@convertcom/js-sdk-utils');
+var jsSdkEnums = require('@convertcom/js-sdk-enums');
+
 /*!
  * Convert JS SDK
  * Version 1.0.0
  * Copyright(c) 2020 Convert Insights, Inc
  * License Apache-2.0
  */
+const DEFAULT_KEYS_CASE_SENSITIVE = true;
+const DEFAULT_NEGATION = '!';
+/**
+ * Provides rule processing calculations with corresponding comparisons methods
+ * @category Modules
+ * @constructor
+ * @implements {RuleManagerInterface}
+ */
+class RuleManager {
+    /**
+     * @param {Config=} config
+     * @param {Object=} dependencies
+     * @param {LogManagerInterface=} dependencies.loggerManager
+     */
+    constructor(config, { loggerManager } = {}) {
+        var _a, _b;
+        this._comparisonProcessor = jsSdkUtils.Comparisons;
+        this._negation = DEFAULT_NEGATION;
+        this._keys_case_sensitive = DEFAULT_KEYS_CASE_SENSITIVE;
+        this._loggerManager = loggerManager;
+        this._comparisonProcessor = jsSdkUtils.objectDeepValue(config, 'rules.comparisonProcessor', jsSdkUtils.Comparisons);
+        this._negation = String(jsSdkUtils.objectDeepValue(config, 'rules.negation', DEFAULT_NEGATION)).valueOf();
+        this._keys_case_sensitive = jsSdkUtils.objectDeepValue(config, 'rules.keys_case_sensitive', DEFAULT_KEYS_CASE_SENSITIVE, true);
+        (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.trace) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager()', jsSdkEnums.MESSAGES.RULE_CONSTRUCTOR, this);
+    }
+    /**
+     * Setter for comparison processor
+     * @param {Record<string, any>} comparisonProcessor
+     */
+    set comparisonProcessor(comparisonProcessor) {
+        this._comparisonProcessor = comparisonProcessor;
+    }
+    /**
+     * Getter for comparison processor
+     */
+    get comparisonProcessor() {
+        return this._comparisonProcessor;
+    }
+    /**
+     * Retrieve comparison methods from comparison processor
+     * @return {Array<string>} List of methods of comparison processor
+     */
+    getComparisonProcessorMethods() {
+        return Object.getOwnPropertyNames(this._comparisonProcessor).filter((name) => typeof this._comparisonProcessor[name] === 'function');
+    }
+    /**
+     * Check input data matching to rule set
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleSet} ruleSet
+     * @return {boolean | RuleError}
+     */
+    isRuleMatched(data, ruleSet, logEntry) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.trace) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager.isRuleMatched()', {
+            data: data,
+            ruleSet: ruleSet
+        });
+        if (logEntry) {
+            (_d = (_c = this._loggerManager) === null || _c === void 0 ? void 0 : _c.info) === null || _d === void 0 ? void 0 : _d.call(_c, 'RuleManager.isRuleMatched()', jsSdkEnums.MESSAGES.PROCESSING_ENTITY.replace('#', logEntry));
+        }
+        // Top OR level
+        let match;
+        if (Object.prototype.hasOwnProperty.call(ruleSet, 'OR') &&
+            jsSdkUtils.arrayNotEmpty(ruleSet === null || ruleSet === void 0 ? void 0 : ruleSet.OR)) {
+            for (let i = 0, l = ruleSet.OR.length; i < l; i++) {
+                match = this._processAND(data, ruleSet.OR[i]);
+                if (Object.values(jsSdkEnums.RuleError).includes(match)) {
+                    (_f = (_e = this._loggerManager) === null || _e === void 0 ? void 0 : _e.info) === null || _f === void 0 ? void 0 : _f.call(_e, 'RuleManager.isRuleMatched()', logEntry || '', jsSdkEnums.ERROR_MESSAGES.RULE_ERROR);
+                }
+                else {
+                    (_h = (_g = this._loggerManager) === null || _g === void 0 ? void 0 : _g.info) === null || _h === void 0 ? void 0 : _h.call(_g, 'RuleManager.isRuleMatched()', logEntry || '', match === false
+                        ? jsSdkEnums.MESSAGES.RULE_NOT_MATCH
+                        : jsSdkEnums.MESSAGES.RULE_MATCH.replace('#', String(i)));
+                }
+                if (match !== false) {
+                    return match;
+                }
+            }
+        }
+        else {
+            (_k = (_j = this._loggerManager) === null || _j === void 0 ? void 0 : _j.warn) === null || _k === void 0 ? void 0 : _k.call(_j, 'RuleManager.isRuleMatched()', logEntry || '', jsSdkEnums.ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    }
+    /**
+     * Check is rule object valid
+     * @param {Rule} rule
+     * @return {boolean}
+     */
+    isValidRule(rule) {
+        var _a, _b;
+        (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.trace) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager.isValidRule()', {
+            rule: rule
+        });
+        return (Object.prototype.hasOwnProperty.call(rule, 'matching') &&
+            typeof rule.matching === 'object' &&
+            Object.prototype.hasOwnProperty.call(rule.matching, 'match_type') &&
+            typeof rule.matching.match_type === 'string' &&
+            Object.prototype.hasOwnProperty.call(rule.matching, 'negated') &&
+            typeof rule.matching.negated === 'boolean' &&
+            Object.prototype.hasOwnProperty.call(rule, 'value'));
+    }
+    /**
+     * Process AND block of rule set. Return first false if found
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleAnd} rulesSubset
+     * @return {boolean | RuleError}
+     * @private
+     */
+    _processAND(data, rulesSubset) {
+        var _a, _b, _c, _d;
+        // Second AND level
+        let match;
+        if (Object.prototype.hasOwnProperty.call(rulesSubset, 'AND') &&
+            jsSdkUtils.arrayNotEmpty(rulesSubset === null || rulesSubset === void 0 ? void 0 : rulesSubset.AND)) {
+            for (let i = 0, l = rulesSubset.AND.length; i < l; i++) {
+                match = this._processORWHEN(data, rulesSubset.AND[i]);
+                if (match === false) {
+                    return false;
+                }
+            }
+            if (match !== false) {
+                (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.info) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager._processAND()', jsSdkEnums.MESSAGES.RULE_MATCH_AND);
+            }
+            return match;
+        }
+        else {
+            (_d = (_c = this._loggerManager) === null || _c === void 0 ? void 0 : _c.warn) === null || _d === void 0 ? void 0 : _d.call(_c, 'RuleManager._processAND()', jsSdkEnums.ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    }
+    /**
+     * Process OR block of rule set. Return first true if found
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleOrWhen} rulesSubset
+     * @return {boolean | RuleError}
+     * @private
+     */
+    _processORWHEN(data, rulesSubset) {
+        var _a, _b;
+        // Third OR level. Called OR_WHEN.
+        let match;
+        if (Object.prototype.hasOwnProperty.call(rulesSubset, 'OR_WHEN') &&
+            jsSdkUtils.arrayNotEmpty(rulesSubset === null || rulesSubset === void 0 ? void 0 : rulesSubset.OR_WHEN)) {
+            for (let i = 0, l = rulesSubset.OR_WHEN.length; i < l; i++) {
+                match = this._processRuleItem(data, rulesSubset.OR_WHEN[i]);
+                if (match !== false) {
+                    return match;
+                }
+            }
+        }
+        else {
+            (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.warn) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager._processORWHEN()', jsSdkEnums.ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    }
+    /**
+     * Process single rule item
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {Rule} rule A single rule to compare
+     * @return {boolean | RuleError} Comparison result
+     * @private
+     */
+    _processRuleItem(data, rule) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (this.isValidRule(rule)) {
+            try {
+                const negation = rule.matching.negated || false;
+                const matching = rule.matching.match_type;
+                if (this.getComparisonProcessorMethods().indexOf(matching) !== -1) {
+                    if (typeof data === 'object') {
+                        // Validate data key-value set.
+                        if (data.constructor === Object) {
+                            // Rule object has to have `key` field
+                            for (const key of Object.keys(data)) {
+                                const k = this._keys_case_sensitive ? key : key.toLowerCase();
+                                const rule_k = this._keys_case_sensitive
+                                    ? rule.key
+                                    : rule.key.toLowerCase();
+                                if (k === rule_k) {
+                                    return this._comparisonProcessor[matching](data[key], rule.value, negation);
+                                }
+                            }
+                        }
+                        else if (rule === null || rule === void 0 ? void 0 : rule.rule_type) {
+                            // Rule object has to have `rule_type` field
+                            (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.info) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager._processRuleItem()', jsSdkEnums.MESSAGES.RULE_MATCH_START.replace('#', rule.rule_type));
+                            for (const method of Object.getOwnPropertyNames(data.constructor.prototype)) {
+                                if (method === 'constructor')
+                                    continue;
+                                const rule_method = jsSdkUtils.camelCase(`get ${rule.rule_type.replace(/_/g, ' ')}`);
+                                if (method === rule_method) {
+                                    const dataValue = data[method](rule);
+                                    if (Object.values(jsSdkEnums.RuleError).includes(dataValue))
+                                        return dataValue;
+                                    if (rule.rule_type === 'js_condition')
+                                        return dataValue;
+                                    return this._comparisonProcessor[matching](dataValue, rule.value, negation);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        (_d = (_c = this._loggerManager) === null || _c === void 0 ? void 0 : _c.warn) === null || _d === void 0 ? void 0 : _d.call(_c, 'RuleManager._processRuleItem()', {
+                            warn: jsSdkEnums.ERROR_MESSAGES.RULE_DATA_NOT_VALID
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                (_f = (_e = this._loggerManager) === null || _e === void 0 ? void 0 : _e.error) === null || _f === void 0 ? void 0 : _f.call(_e, 'RuleManager._processRuleItem()', {
+                    error: error.message
+                });
+            }
+        }
+        else {
+            (_h = (_g = this._loggerManager) === null || _g === void 0 ? void 0 : _g.warn) === null || _h === void 0 ? void 0 : _h.call(_g, 'RuleManager._processRuleItem()', jsSdkEnums.ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    }
+}
+
+exports.RuleManager = RuleManager;
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/index.min.js

@@ -4,3 +4,5 @@
  * Copyright(c) 2020-2022 Convert Insights, Inc
  * License Apache-2.0
  */
+"use strict";var e=require("@convertcom/js-sdk-utils"),r=require("@convertcom/js-sdk-enums");exports.RuleManager=class{constructor(o,{loggerManager:l}={}){var t,s;this._comparisonProcessor=e.Comparisons,this._negation="!",this._keys_case_sensitive=true,this._loggerManager=l,this._comparisonProcessor=e.objectDeepValue(o,"rules.comparisonProcessor",e.Comparisons),this._negation=String(e.objectDeepValue(o,"rules.negation","!")).valueOf(),this._keys_case_sensitive=e.objectDeepValue(o,"rules.keys_case_sensitive",true,!0),null===(s=null===(t=this._loggerManager)||void 0===t?void 0:t.trace)||void 0===s||s.call(t,"RuleManager()",r.MESSAGES.RULE_CONSTRUCTOR,this)}set comparisonProcessor(e){this._comparisonProcessor=e}get comparisonProcessor(){return this._comparisonProcessor}getComparisonProcessorMethods(){return Object.getOwnPropertyNames(this._comparisonProcessor).filter((e=>"function"==typeof this._comparisonProcessor[e]))}isRuleMatched(o,l,t){var s,a,i,n,c,u,_,g,R,p;let d;if(null===(a=null===(s=this._loggerManager)||void 0===s?void 0:s.trace)||void 0===a||a.call(s,"RuleManager.isRuleMatched()",{data:o,ruleSet:l}),t&&(null===(n=null===(i=this._loggerManager)||void 0===i?void 0:i.info)||void 0===n||n.call(i,"RuleManager.isRuleMatched()",r.MESSAGES.PROCESSING_ENTITY.replace("#",t))),Object.prototype.hasOwnProperty.call(l,"OR")&&e.arrayNotEmpty(null==l?void 0:l.OR)){for(let e=0,s=l.OR.length;e<s;e++)if(d=this._processAND(o,l.OR[e]),Object.values(r.RuleError).includes(d)?null===(u=null===(c=this._loggerManager)||void 0===c?void 0:c.info)||void 0===u||u.call(c,"RuleManager.isRuleMatched()",t||"",r.ERROR_MESSAGES.RULE_ERROR):null===(g=null===(_=this._loggerManager)||void 0===_?void 0:_.info)||void 0===g||g.call(_,"RuleManager.isRuleMatched()",t||"",!1===d?r.MESSAGES.RULE_NOT_MATCH:r.MESSAGES.RULE_MATCH.replace("#",String(e))),!1!==d)return d}else null===(p=null===(R=this._loggerManager)||void 0===R?void 0:R.warn)||void 0===p||p.call(R,"RuleManager.isRuleMatched()",t||"",r.ERROR_MESSAGES.RULE_NOT_VALID);return!1}isValidRule(e){var r,o;return null===(o=null===(r=this._loggerManager)||void 0===r?void 0:r.trace)||void 0===o||o.call(r,"RuleManager.isValidRule()",{rule:e}),Object.prototype.hasOwnProperty.call(e,"matching")&&"object"==typeof e.matching&&Object.prototype.hasOwnProperty.call(e.matching,"match_type")&&"string"==typeof e.matching.match_type&&Object.prototype.hasOwnProperty.call(e.matching,"negated")&&"boolean"==typeof e.matching.negated&&Object.prototype.hasOwnProperty.call(e,"value")}_processAND(o,l){var t,s,a,i;let n;if(Object.prototype.hasOwnProperty.call(l,"AND")&&e.arrayNotEmpty(null==l?void 0:l.AND)){for(let e=0,r=l.AND.length;e<r;e++)if(n=this._processORWHEN(o,l.AND[e]),!1===n)return!1;return!1!==n&&(null===(s=null===(t=this._loggerManager)||void 0===t?void 0:t.info)||void 0===s||s.call(t,"RuleManager._processAND()",r.MESSAGES.RULE_MATCH_AND)),n}return null===(i=null===(a=this._loggerManager)||void 0===a?void 0:a.warn)||void 0===i||i.call(a,"RuleManager._processAND()",r.ERROR_MESSAGES.RULE_NOT_VALID),!1}_processORWHEN(o,l){var t,s;let a;if(Object.prototype.hasOwnProperty.call(l,"OR_WHEN")&&e.arrayNotEmpty(null==l?void 0:l.OR_WHEN)){for(let e=0,r=l.OR_WHEN.length;e<r;e++)if(a=this._processRuleItem(o,l.OR_WHEN[e]),!1!==a)return a}else null===(s=null===(t=this._loggerManager)||void 0===t?void 0:t.warn)||void 0===s||s.call(t,"RuleManager._processORWHEN()",r.ERROR_MESSAGES.RULE_NOT_VALID);return!1}_processRuleItem(o,l){var t,s,a,i,n,c,u,_;if(this.isValidRule(l))try{const n=l.matching.negated||!1,c=l.matching.match_type;if(-1!==this.getComparisonProcessorMethods().indexOf(c))if("object"==typeof o){if(o.constructor===Object)for(const e of Object.keys(o)){const r=this._keys_case_sensitive?e:e.toLowerCase();if(r===(this._keys_case_sensitive?l.key:l.key.toLowerCase()))return this._comparisonProcessor[c](o[e],l.value,n)}else if(null==l?void 0:l.rule_type){null===(s=null===(t=this._loggerManager)||void 0===t?void 0:t.info)||void 0===s||s.call(t,"RuleManager._processRuleItem()",r.MESSAGES.RULE_MATCH_START.replace("#",l.rule_type));for(const t of Object.getOwnPropertyNames(o.constructor.prototype)){if("constructor"===t)continue;if(t===e.camelCase(`get ${l.rule_type.replace(/_/g," ")}`)){const e=o[t](l);return Object.values(r.RuleError).includes(e)||"js_condition"===l.rule_type?e:this._comparisonProcessor[c](e,l.value,n)}}}}else null===(i=null===(a=this._loggerManager)||void 0===a?void 0:a.warn)||void 0===i||i.call(a,"RuleManager._processRuleItem()",{warn:r.ERROR_MESSAGES.RULE_DATA_NOT_VALID})}catch(e){null===(c=null===(n=this._loggerManager)||void 0===n?void 0:n.error)||void 0===c||c.call(n,"RuleManager._processRuleItem()",{error:e.message})}else null===(_=null===(u=this._loggerManager)||void 0===u?void 0:u.warn)||void 0===_||_.call(u,"RuleManager._processRuleItem()",r.ERROR_MESSAGES.RULE_NOT_VALID);return!1}};
+//# sourceMappingURL=index.min.js.map

package/lib/index.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.min.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/lib/index.min.mjs

@@ -4,4 +4,5 @@
  * Copyright(c) 2020-2022 Convert Insights, Inc
  * License Apache-2.0
  */
+import{Comparisons as e,objectDeepValue as r,arrayNotEmpty as o,camelCase as l}from"@convertcom/js-sdk-utils";import{MESSAGES as t,RuleError as s,ERROR_MESSAGES as a}from"@convertcom/js-sdk-enums";class i{constructor(o,{loggerManager:l}={}){var s,a;this._comparisonProcessor=e,this._negation="!",this._keys_case_sensitive=true,this._loggerManager=l,this._comparisonProcessor=r(o,"rules.comparisonProcessor",e),this._negation=String(r(o,"rules.negation","!")).valueOf(),this._keys_case_sensitive=r(o,"rules.keys_case_sensitive",true,!0),null===(a=null===(s=this._loggerManager)||void 0===s?void 0:s.trace)||void 0===a||a.call(s,"RuleManager()",t.RULE_CONSTRUCTOR,this)}set comparisonProcessor(e){this._comparisonProcessor=e}get comparisonProcessor(){return this._comparisonProcessor}getComparisonProcessorMethods(){return Object.getOwnPropertyNames(this._comparisonProcessor).filter((e=>"function"==typeof this._comparisonProcessor[e]))}isRuleMatched(e,r,l){var i,n,c,u,g,_,p,d,h,v;let R;if(null===(n=null===(i=this._loggerManager)||void 0===i?void 0:i.trace)||void 0===n||n.call(i,"RuleManager.isRuleMatched()",{data:e,ruleSet:r}),l&&(null===(u=null===(c=this._loggerManager)||void 0===c?void 0:c.info)||void 0===u||u.call(c,"RuleManager.isRuleMatched()",t.PROCESSING_ENTITY.replace("#",l))),Object.prototype.hasOwnProperty.call(r,"OR")&&o(null==r?void 0:r.OR)){for(let o=0,i=r.OR.length;o<i;o++)if(R=this._processAND(e,r.OR[o]),Object.values(s).includes(R)?null===(_=null===(g=this._loggerManager)||void 0===g?void 0:g.info)||void 0===_||_.call(g,"RuleManager.isRuleMatched()",l||"",a.RULE_ERROR):null===(d=null===(p=this._loggerManager)||void 0===p?void 0:p.info)||void 0===d||d.call(p,"RuleManager.isRuleMatched()",l||"",!1===R?t.RULE_NOT_MATCH:t.RULE_MATCH.replace("#",String(o))),!1!==R)return R}else null===(v=null===(h=this._loggerManager)||void 0===h?void 0:h.warn)||void 0===v||v.call(h,"RuleManager.isRuleMatched()",l||"",a.RULE_NOT_VALID);return!1}isValidRule(e){var r,o;return null===(o=null===(r=this._loggerManager)||void 0===r?void 0:r.trace)||void 0===o||o.call(r,"RuleManager.isValidRule()",{rule:e}),Object.prototype.hasOwnProperty.call(e,"matching")&&"object"==typeof e.matching&&Object.prototype.hasOwnProperty.call(e.matching,"match_type")&&"string"==typeof e.matching.match_type&&Object.prototype.hasOwnProperty.call(e.matching,"negated")&&"boolean"==typeof e.matching.negated&&Object.prototype.hasOwnProperty.call(e,"value")}_processAND(e,r){var l,s,i,n;let c;if(Object.prototype.hasOwnProperty.call(r,"AND")&&o(null==r?void 0:r.AND)){for(let o=0,l=r.AND.length;o<l;o++)if(c=this._processORWHEN(e,r.AND[o]),!1===c)return!1;return!1!==c&&(null===(s=null===(l=this._loggerManager)||void 0===l?void 0:l.info)||void 0===s||s.call(l,"RuleManager._processAND()",t.RULE_MATCH_AND)),c}return null===(n=null===(i=this._loggerManager)||void 0===i?void 0:i.warn)||void 0===n||n.call(i,"RuleManager._processAND()",a.RULE_NOT_VALID),!1}_processORWHEN(e,r){var l,t;let s;if(Object.prototype.hasOwnProperty.call(r,"OR_WHEN")&&o(null==r?void 0:r.OR_WHEN)){for(let o=0,l=r.OR_WHEN.length;o<l;o++)if(s=this._processRuleItem(e,r.OR_WHEN[o]),!1!==s)return s}else null===(t=null===(l=this._loggerManager)||void 0===l?void 0:l.warn)||void 0===t||t.call(l,"RuleManager._processORWHEN()",a.RULE_NOT_VALID);return!1}_processRuleItem(e,r){var o,i,n,c,u,g,_,p;if(this.isValidRule(r))try{const u=r.matching.negated||!1,g=r.matching.match_type;if(-1!==this.getComparisonProcessorMethods().indexOf(g))if("object"==typeof e){if(e.constructor===Object)for(const o of Object.keys(e)){const l=this._keys_case_sensitive?o:o.toLowerCase();if(l===(this._keys_case_sensitive?r.key:r.key.toLowerCase()))return this._comparisonProcessor[g](e[o],r.value,u)}else if(null==r?void 0:r.rule_type){null===(i=null===(o=this._loggerManager)||void 0===o?void 0:o.info)||void 0===i||i.call(o,"RuleManager._processRuleItem()",t.RULE_MATCH_START.replace("#",r.rule_type));for(const o of Object.getOwnPropertyNames(e.constructor.prototype)){if("constructor"===o)continue;if(o===l(`get ${r.rule_type.replace(/_/g," ")}`)){const l=e[o](r);return Object.values(s).includes(l)||"js_condition"===r.rule_type?l:this._comparisonProcessor[g](l,r.value,u)}}}}else null===(c=null===(n=this._loggerManager)||void 0===n?void 0:n.warn)||void 0===c||c.call(n,"RuleManager._processRuleItem()",{warn:a.RULE_DATA_NOT_VALID})}catch(e){null===(g=null===(u=this._loggerManager)||void 0===u?void 0:u.error)||void 0===g||g.call(u,"RuleManager._processRuleItem()",{error:e.message})}else null===(p=null===(_=this._loggerManager)||void 0===_?void 0:_.warn)||void 0===p||p.call(_,"RuleManager._processRuleItem()",a.RULE_NOT_VALID);return!1}}export{i as RuleManager};
 //# sourceMappingURL=index.min.mjs.map

package/lib/index.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.min.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/lib/index.mjs

@@ -1,6 +1,233 @@
+import { Comparisons, objectDeepValue, arrayNotEmpty, camelCase } from '@convertcom/js-sdk-utils';
+import { MESSAGES, RuleError, ERROR_MESSAGES } from '@convertcom/js-sdk-enums';
+
 /*!
  * Convert JS SDK
  * Version 1.0.0
  * Copyright(c) 2020 Convert Insights, Inc
  * License Apache-2.0
  */
+const DEFAULT_KEYS_CASE_SENSITIVE = true;
+const DEFAULT_NEGATION = '!';
+/**
+ * Provides rule processing calculations with corresponding comparisons methods
+ * @category Modules
+ * @constructor
+ * @implements {RuleManagerInterface}
+ */
+class RuleManager {
+    /**
+     * @param {Config=} config
+     * @param {Object=} dependencies
+     * @param {LogManagerInterface=} dependencies.loggerManager
+     */
+    constructor(config, { loggerManager } = {}) {
+        var _a, _b;
+        this._comparisonProcessor = Comparisons;
+        this._negation = DEFAULT_NEGATION;
+        this._keys_case_sensitive = DEFAULT_KEYS_CASE_SENSITIVE;
+        this._loggerManager = loggerManager;
+        this._comparisonProcessor = objectDeepValue(config, 'rules.comparisonProcessor', Comparisons);
+        this._negation = String(objectDeepValue(config, 'rules.negation', DEFAULT_NEGATION)).valueOf();
+        this._keys_case_sensitive = objectDeepValue(config, 'rules.keys_case_sensitive', DEFAULT_KEYS_CASE_SENSITIVE, true);
+        (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.trace) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager()', MESSAGES.RULE_CONSTRUCTOR, this);
+    }
+    /**
+     * Setter for comparison processor
+     * @param {Record<string, any>} comparisonProcessor
+     */
+    set comparisonProcessor(comparisonProcessor) {
+        this._comparisonProcessor = comparisonProcessor;
+    }
+    /**
+     * Getter for comparison processor
+     */
+    get comparisonProcessor() {
+        return this._comparisonProcessor;
+    }
+    /**
+     * Retrieve comparison methods from comparison processor
+     * @return {Array<string>} List of methods of comparison processor
+     */
+    getComparisonProcessorMethods() {
+        return Object.getOwnPropertyNames(this._comparisonProcessor).filter((name) => typeof this._comparisonProcessor[name] === 'function');
+    }
+    /**
+     * Check input data matching to rule set
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleSet} ruleSet
+     * @return {boolean | RuleError}
+     */
+    isRuleMatched(data, ruleSet, logEntry) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.trace) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager.isRuleMatched()', {
+            data: data,
+            ruleSet: ruleSet
+        });
+        if (logEntry) {
+            (_d = (_c = this._loggerManager) === null || _c === void 0 ? void 0 : _c.info) === null || _d === void 0 ? void 0 : _d.call(_c, 'RuleManager.isRuleMatched()', MESSAGES.PROCESSING_ENTITY.replace('#', logEntry));
+        }
+        // Top OR level
+        let match;
+        if (Object.prototype.hasOwnProperty.call(ruleSet, 'OR') &&
+            arrayNotEmpty(ruleSet === null || ruleSet === void 0 ? void 0 : ruleSet.OR)) {
+            for (let i = 0, l = ruleSet.OR.length; i < l; i++) {
+                match = this._processAND(data, ruleSet.OR[i]);
+                if (Object.values(RuleError).includes(match)) {
+                    (_f = (_e = this._loggerManager) === null || _e === void 0 ? void 0 : _e.info) === null || _f === void 0 ? void 0 : _f.call(_e, 'RuleManager.isRuleMatched()', logEntry || '', ERROR_MESSAGES.RULE_ERROR);
+                }
+                else {
+                    (_h = (_g = this._loggerManager) === null || _g === void 0 ? void 0 : _g.info) === null || _h === void 0 ? void 0 : _h.call(_g, 'RuleManager.isRuleMatched()', logEntry || '', match === false
+                        ? MESSAGES.RULE_NOT_MATCH
+                        : MESSAGES.RULE_MATCH.replace('#', String(i)));
+                }
+                if (match !== false) {
+                    return match;
+                }
+            }
+        }
+        else {
+            (_k = (_j = this._loggerManager) === null || _j === void 0 ? void 0 : _j.warn) === null || _k === void 0 ? void 0 : _k.call(_j, 'RuleManager.isRuleMatched()', logEntry || '', ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    }
+    /**
+     * Check is rule object valid
+     * @param {Rule} rule
+     * @return {boolean}
+     */
+    isValidRule(rule) {
+        var _a, _b;
+        (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.trace) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager.isValidRule()', {
+            rule: rule
+        });
+        return (Object.prototype.hasOwnProperty.call(rule, 'matching') &&
+            typeof rule.matching === 'object' &&
+            Object.prototype.hasOwnProperty.call(rule.matching, 'match_type') &&
+            typeof rule.matching.match_type === 'string' &&
+            Object.prototype.hasOwnProperty.call(rule.matching, 'negated') &&
+            typeof rule.matching.negated === 'boolean' &&
+            Object.prototype.hasOwnProperty.call(rule, 'value'));
+    }
+    /**
+     * Process AND block of rule set. Return first false if found
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleAnd} rulesSubset
+     * @return {boolean | RuleError}
+     * @private
+     */
+    _processAND(data, rulesSubset) {
+        var _a, _b, _c, _d;
+        // Second AND level
+        let match;
+        if (Object.prototype.hasOwnProperty.call(rulesSubset, 'AND') &&
+            arrayNotEmpty(rulesSubset === null || rulesSubset === void 0 ? void 0 : rulesSubset.AND)) {
+            for (let i = 0, l = rulesSubset.AND.length; i < l; i++) {
+                match = this._processORWHEN(data, rulesSubset.AND[i]);
+                if (match === false) {
+                    return false;
+                }
+            }
+            if (match !== false) {
+                (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.info) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager._processAND()', MESSAGES.RULE_MATCH_AND);
+            }
+            return match;
+        }
+        else {
+            (_d = (_c = this._loggerManager) === null || _c === void 0 ? void 0 : _c.warn) === null || _d === void 0 ? void 0 : _d.call(_c, 'RuleManager._processAND()', ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    }
+    /**
+     * Process OR block of rule set. Return first true if found
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {RuleOrWhen} rulesSubset
+     * @return {boolean | RuleError}
+     * @private
+     */
+    _processORWHEN(data, rulesSubset) {
+        var _a, _b;
+        // Third OR level. Called OR_WHEN.
+        let match;
+        if (Object.prototype.hasOwnProperty.call(rulesSubset, 'OR_WHEN') &&
+            arrayNotEmpty(rulesSubset === null || rulesSubset === void 0 ? void 0 : rulesSubset.OR_WHEN)) {
+            for (let i = 0, l = rulesSubset.OR_WHEN.length; i < l; i++) {
+                match = this._processRuleItem(data, rulesSubset.OR_WHEN[i]);
+                if (match !== false) {
+                    return match;
+                }
+            }
+        }
+        else {
+            (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.warn) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager._processORWHEN()', ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    }
+    /**
+     * Process single rule item
+     * @param {Record<string, any>} data Single value or key-value data set to compare
+     * @param {Rule} rule A single rule to compare
+     * @return {boolean | RuleError} Comparison result
+     * @private
+     */
+    _processRuleItem(data, rule) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (this.isValidRule(rule)) {
+            try {
+                const negation = rule.matching.negated || false;
+                const matching = rule.matching.match_type;
+                if (this.getComparisonProcessorMethods().indexOf(matching) !== -1) {
+                    if (typeof data === 'object') {
+                        // Validate data key-value set.
+                        if (data.constructor === Object) {
+                            // Rule object has to have `key` field
+                            for (const key of Object.keys(data)) {
+                                const k = this._keys_case_sensitive ? key : key.toLowerCase();
+                                const rule_k = this._keys_case_sensitive
+                                    ? rule.key
+                                    : rule.key.toLowerCase();
+                                if (k === rule_k) {
+                                    return this._comparisonProcessor[matching](data[key], rule.value, negation);
+                                }
+                            }
+                        }
+                        else if (rule === null || rule === void 0 ? void 0 : rule.rule_type) {
+                            // Rule object has to have `rule_type` field
+                            (_b = (_a = this._loggerManager) === null || _a === void 0 ? void 0 : _a.info) === null || _b === void 0 ? void 0 : _b.call(_a, 'RuleManager._processRuleItem()', MESSAGES.RULE_MATCH_START.replace('#', rule.rule_type));
+                            for (const method of Object.getOwnPropertyNames(data.constructor.prototype)) {
+                                if (method === 'constructor')
+                                    continue;
+                                const rule_method = camelCase(`get ${rule.rule_type.replace(/_/g, ' ')}`);
+                                if (method === rule_method) {
+                                    const dataValue = data[method](rule);
+                                    if (Object.values(RuleError).includes(dataValue))
+                                        return dataValue;
+                                    if (rule.rule_type === 'js_condition')
+                                        return dataValue;
+                                    return this._comparisonProcessor[matching](dataValue, rule.value, negation);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        (_d = (_c = this._loggerManager) === null || _c === void 0 ? void 0 : _c.warn) === null || _d === void 0 ? void 0 : _d.call(_c, 'RuleManager._processRuleItem()', {
+                            warn: ERROR_MESSAGES.RULE_DATA_NOT_VALID
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                (_f = (_e = this._loggerManager) === null || _e === void 0 ? void 0 : _e.error) === null || _f === void 0 ? void 0 : _f.call(_e, 'RuleManager._processRuleItem()', {
+                    error: error.message
+                });
+            }
+        }
+        else {
+            (_h = (_g = this._loggerManager) === null || _g === void 0 ? void 0 : _g.warn) === null || _h === void 0 ? void 0 : _h.call(_g, 'RuleManager._processRuleItem()', ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    }
+}
+
+export { RuleManager };
+//# sourceMappingURL=index.mjs.map

package/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/legacy/enums/index.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Convert JS SDK test
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export * from './src/audience-type';
+export * from './src/data-enitites';
+export * from './src/dictionary';
+export * from './src/do-not-track';
+export * from './src/event-type';
+export * from './src/experience-type';
+export * from './src/feature-status';
+export * from './src/ga-type';
+export * from './src/goal-data-key';
+export * from './src/goal-type';
+export * from './src/integration-provider';
+export * from './src/log-level';
+export * from './src/log-method';
+export * from './src/project-type';
+export * from './src/rule-error';
+export * from './src/system-events';
+export * from './src/variable-types';
+export * from './src/variation-change-type';
+export * from './src/segments/browser-type';
+export * from './src/segments/device-type';
+export * from './src/segments/segments-keys';
+export * from './src/segments/source-type';
+export * from './src/segments/visitor-type';

package/lib/legacy/enums/src/audience-type.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum AudienceType {
+    PERMANENT = "permanent",
+    SEGMENTATION = "segmentation",
+    TRANSIENT = "transient"
+}

package/lib/legacy/enums/src/data-enitites.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare const DATA_ENTITIES: string[];

package/lib/legacy/enums/src/dictionary.d.ts

@@ -0,0 +1,60 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare const ERROR_MESSAGES: {
+    SDK_KEY_MISSING: string;
+    DATA_OBJECT_MISSING: string;
+    CONFIG_DATA_NOT_VALID: string;
+    SDK_OR_DATA_OBJECT_REQUIRED: string;
+    RULE_NOT_VALID: string;
+    RULE_DATA_NOT_VALID: string;
+    RULE_ERROR: string;
+    DATA_STORE_NOT_VALID: string;
+    VISITOR_ID_REQUIRED: string;
+    GOAL_DATA_NOT_VALID: string;
+    UNABLE_TO_SELECT_BUCKET_FOR_VISITOR: string;
+    UNABLE_TO_PERFORM_NETWORK_REQUEST: string;
+    UNSUPPORTED_RESPONSE_TYPE: string;
+};
+export declare const MESSAGES: {
+    CONFIG_DATA_UPDATED: string;
+    CORE_CONSTRUCTOR: string;
+    CORE_INITIALIZED: string;
+    EXPERIENCE_CONSTRUCTOR: string;
+    EXPERIENCE_NOT_FOUND: string;
+    EXPERIENCE_RULES_MATCHED: string;
+    VARIATIONS_NOT_FOUND: string;
+    VARIATION_CHANGE_NOT_SUPPORTED: string;
+    FEATURE_CONSTRUCTOR: string;
+    FEATURE_NOT_FOUND: string;
+    FEATURE_VARIABLES_NOT_FOUND: string;
+    FEATURE_VARIABLES_TYPE_NOT_FOUND: string;
+    BUCKETING_CONSTRUCTOR: string;
+    DATA_CONSTRUCTOR: string;
+    RULE_CONSTRUCTOR: string;
+    PROCESSING_ENTITY: string;
+    LOCATION_MATCH: string;
+    LOCATION_NOT_MATCH: string;
+    AUDIENCE_MATCH: string;
+    AUDIENCE_NOT_MATCH: string;
+    AUDIENCE_NOT_RESTRICTED: string;
+    SEGMENTATION_MATCH: string;
+    RULE_NOT_MATCH: string;
+    RULE_MATCH: string;
+    RULE_MATCH_AND: string;
+    RULE_MATCH_START: string;
+    LOCATION_ACTIVATED: string;
+    LOCATION_DEACTIVATED: string;
+    BUCKETED_VISITOR_FOUND: string;
+    BUCKETED_VISITOR: string;
+    GOAL_NOT_FOUND: string;
+    GOAL_RULE_NOT_MATCH: string;
+    GOAL_FOUND: string;
+    SEGMENTS_NOT_FOUND: string;
+    SEGMENTS_RULE_NOT_MATCH: string;
+    CUSTOM_SEGMENTS_KEY_FOUND: string;
+    SEND_BEACON_SUCCESS: string;
+};

package/lib/legacy/enums/src/do-not-track.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum DoNotTrack {
+    OFF = "OFF",
+    EU_ONLY = "EU ONLY",
+    EEA_ONLY = "EEA ONLY",
+    WORLDWIDE = "Worldwide"
+}

package/lib/legacy/enums/src/event-type.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum EventType {
+    BUCKETING = "bucketing",
+    CONVERSION = "conversion"
+}