@convertcom/js-sdk-rules 0.0.1 → 1.0.1

package/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,11 @@
+# Convert Insights, Inc JavaScript SDK - Rules Manager
+
+[![license](https://img.shields.io/badge/license-Apache--2.0-green)](https://choosealicense.com/licenses/apache-2.0/)
+
+## About
+
+This repository contains the **Rules Manager** dependency for **JavaScript SDK** needed to integrate Convert.com's **Fullstack Product (feature tests, feature flags, feature rollouts)** inside third-party apps. This is maintained by the Convert.com team.
+
+## Credits
+
+Copyright(c) 2023 Convert Insights, Inc.

package/lib/index.d.ts

@@ -1,6 +1,92 @@
+import { RuleSet, Rule, Config } from '@convertcom/js-sdk-types';
+import { RuleError } from '@convertcom/js-sdk-enums';
+import { LogManagerInterface } from '@convertcom/js-sdk-logger';
+
 /*!
- * Convert JS SDK test
+ * Convert JS SDK
  * Version 1.0.0
  * Copyright(c) 2020 Convert Insights, Inc
  * License Apache-2.0
  */
+
+interface RuleManagerInterface {
+    comparisonProcessor: Record<string, any>;
+    getComparisonProcessorMethods(): Array<string>;
+    isRuleMatched(data: Record<string, any>, ruleSet: RuleSet, logEntry?: string): boolean | RuleError;
+    isValidRule(rule: Rule): boolean;
+}
+
+/**
+ * Provides rule processing calculations with corresponding comparisons methods
+ * @category Modules
+ * @constructor
+ * @implements {RuleManagerInterface}
+ */
+declare class RuleManager implements RuleManagerInterface {
+    private _comparisonProcessor;
+    private readonly _negation;
+    private readonly _keys_case_sensitive;
+    private _loggerManager;
+    private _mapper;
+    /**
+     * @param {Config=} config
+     * @param {Object=} dependencies
+     * @param {LogManagerInterface=} dependencies.loggerManager
+     */
+    constructor(config?: Config, { loggerManager }?: {
+        loggerManager?: LogManagerInterface;
+    });
+    /**
+     * Setter for comparison processor
+     * @param {Record<string, any>} comparisonProcessor
+     */
+    set comparisonProcessor(comparisonProcessor: Record<string, any>);
+    /**
+     * Getter for comparison processor
+     */
+    get comparisonProcessor(): Record<string, any>;
+    /**
+     * Retrieve comparison methods from comparison processor
+     * @return {Array<string>} List of methods of comparison processor
+     */
+    getComparisonProcessorMethods(): Array<string>;
+    /**
+     * 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: Record<string, any>, ruleSet: RuleSet, logEntry?: string): boolean | RuleError;
+    /**
+     * Check is rule object valid
+     * @param {Rule} rule
+     * @return {boolean}
+     */
+    isValidRule(rule: Rule): boolean;
+    /**
+     * 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
+     */
+    private _processAND;
+    /**
+     * 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
+     */
+    private _processORWHEN;
+    /**
+     * 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
+     */
+    private _processRuleItem;
+}
+
+export { RuleManager, type RuleManagerInterface };

package/lib/index.js

@@ -1,8 +1,248 @@
 '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);
+        this._mapper = (config === null || config === void 0 ? void 0 : config.mapper) || ((value) => value);
+        (_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()', this._mapper({
+            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()', this._mapper({
+            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, _j, _k, _l, _m, _o;
+        if (this.isValidRule(rule)) {
+            try {
+                const negation = rule.matching.negated || false;
+                const matching = rule.matching.match_type;
+                if (this.getComparisonProcessorMethods().indexOf(matching) !== -1) {
+                    if (data && typeof data === 'object' && (data === null || data === void 0 ? void 0 : data.constructor)) {
+                        // 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 ||
+                                    ((_c = data === null || data === void 0 ? void 0 : data.mapper) === null || _c === void 0 ? void 0 : _c.call(data, 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 {
+                            (_e = (_d = this._loggerManager) === null || _d === void 0 ? void 0 : _d.trace) === null || _e === void 0 ? void 0 : _e.call(_d, 'RuleManager._processRuleItem()', {
+                                warn: jsSdkEnums.ERROR_MESSAGES.RULE_DATA_NOT_VALID,
+                                data
+                            });
+                        }
+                    }
+                    else {
+                        (_g = (_f = this._loggerManager) === null || _f === void 0 ? void 0 : _f.trace) === null || _g === void 0 ? void 0 : _g.call(_f, 'RuleManager._processRuleItem()', {
+                            warn: jsSdkEnums.ERROR_MESSAGES.RULE_NOT_VALID,
+                            data,
+                            rule
+                        });
+                    }
+                }
+                else {
+                    (_j = (_h = this._loggerManager) === null || _h === void 0 ? void 0 : _h.warn) === null || _j === void 0 ? void 0 : _j.call(_h, 'RuleManager._processRuleItem()', jsSdkEnums.ERROR_MESSAGES.RULE_MATCH_TYPE_NOT_SUPPORTED.replace('#', matching));
+                }
+            }
+            catch (error) {
+                (_l = (_k = this._loggerManager) === null || _k === void 0 ? void 0 : _k.error) === null || _l === void 0 ? void 0 : _l.call(_k, 'RuleManager._processRuleItem()', {
+                    error: error.message
+                });
+            }
+        }
+        else {
+            (_o = (_m = this._loggerManager) === null || _m === void 0 ? void 0 : _m.warn) === null || _o === void 0 ? void 0 : _o.call(_m, '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,a;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),this._mapper=(null==o?void 0:o.mapper)||(e=>e),null===(a=null===(t=this._loggerManager)||void 0===t?void 0:t.trace)||void 0===a||a.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 a,s,i,n,c,u,_,g,R,p;let d;if(null===(s=null===(a=this._loggerManager)||void 0===a?void 0:a.trace)||void 0===s||s.call(a,"RuleManager.isRuleMatched()",this._mapper({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,a=l.OR.length;e<a;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()",this._mapper({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,a,s,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===(a=null===(t=this._loggerManager)||void 0===t?void 0:t.info)||void 0===a||a.call(t,"RuleManager._processAND()",r.MESSAGES.RULE_MATCH_AND)),n}return null===(i=null===(s=this._loggerManager)||void 0===s?void 0:s.warn)||void 0===i||i.call(s,"RuleManager._processAND()",r.ERROR_MESSAGES.RULE_NOT_VALID),!1}_processORWHEN(o,l){var t,a;let s;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(s=this._processRuleItem(o,l.OR_WHEN[e]),!1!==s)return s}else null===(a=null===(t=this._loggerManager)||void 0===t?void 0:t.warn)||void 0===a||a.call(t,"RuleManager._processORWHEN()",r.ERROR_MESSAGES.RULE_NOT_VALID);return!1}_processRuleItem(o,l){var t,a,s,i,n,c,u,_,g,R,p,d,v;if(this.isValidRule(l))try{const R=l.matching.negated||!1,p=l.matching.match_type;if(-1!==this.getComparisonProcessorMethods().indexOf(p))if(o&&"object"==typeof o&&(null==o?void 0:o.constructor))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[p](o[e],l.value,R)}else if(null==l?void 0:l.rule_type){null===(a=null===(t=this._loggerManager)||void 0===t?void 0:t.info)||void 0===a||a.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;const a=e.camelCase(`get ${l.rule_type.replace(/_/g," ")}`);if(t===a||(null===(s=null==o?void 0:o.mapper)||void 0===s?void 0:s.call(o,t))===a){const e=o[t](l);return Object.values(r.RuleError).includes(e)||"js_condition"===l.rule_type?e:this._comparisonProcessor[p](e,l.value,R)}}}else null===(n=null===(i=this._loggerManager)||void 0===i?void 0:i.trace)||void 0===n||n.call(i,"RuleManager._processRuleItem()",{warn:r.ERROR_MESSAGES.RULE_DATA_NOT_VALID,data:o});else null===(u=null===(c=this._loggerManager)||void 0===c?void 0:c.trace)||void 0===u||u.call(c,"RuleManager._processRuleItem()",{warn:r.ERROR_MESSAGES.RULE_NOT_VALID,data:o,rule:l});else null===(g=null===(_=this._loggerManager)||void 0===_?void 0:_.warn)||void 0===g||g.call(_,"RuleManager._processRuleItem()",r.ERROR_MESSAGES.RULE_MATCH_TYPE_NOT_SUPPORTED.replace("#",p))}catch(e){null===(p=null===(R=this._loggerManager)||void 0===R?void 0:R.error)||void 0===p||p.call(R,"RuleManager._processRuleItem()",{error:e.message})}else null===(v=null===(d=this._loggerManager)||void 0===d?void 0:d.warn)||void 0===v||v.call(d,"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 a,ERROR_MESSAGES as s}from"@convertcom/js-sdk-enums";class i{constructor(o,{loggerManager:l}={}){var a,s;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),this._mapper=(null==o?void 0:o.mapper)||(e=>e),null===(s=null===(a=this._loggerManager)||void 0===a?void 0:a.trace)||void 0===s||s.call(a,"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,v,h;let R;if(null===(n=null===(i=this._loggerManager)||void 0===i?void 0:i.trace)||void 0===n||n.call(i,"RuleManager.isRuleMatched()",this._mapper({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(a).includes(R)?null===(g=null===(_=this._loggerManager)||void 0===_?void 0:_.info)||void 0===g||g.call(_,"RuleManager.isRuleMatched()",l||"",s.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===(h=null===(v=this._loggerManager)||void 0===v?void 0:v.warn)||void 0===h||h.call(v,"RuleManager.isRuleMatched()",l||"",s.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()",this._mapper({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,a,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===(a=null===(l=this._loggerManager)||void 0===l?void 0:l.info)||void 0===a||a.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()",s.RULE_NOT_VALID),!1}_processORWHEN(e,r){var l,t;let a;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(a=this._processRuleItem(e,r.OR_WHEN[o]),!1!==a)return a}else null===(t=null===(l=this._loggerManager)||void 0===l?void 0:l.warn)||void 0===t||t.call(l,"RuleManager._processORWHEN()",s.RULE_NOT_VALID);return!1}_processRuleItem(e,r){var o,i,n,c,u,_,g,p,d,v,h,R,O;if(this.isValidRule(r))try{const v=r.matching.negated||!1,h=r.matching.match_type;if(-1!==this.getComparisonProcessorMethods().indexOf(h))if(e&&"object"==typeof e&&(null==e?void 0:e.constructor))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[h](e[o],r.value,v)}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;const t=l(`get ${r.rule_type.replace(/_/g," ")}`);if(o===t||(null===(n=null==e?void 0:e.mapper)||void 0===n?void 0:n.call(e,o))===t){const l=e[o](r);return Object.values(a).includes(l)||"js_condition"===r.rule_type?l:this._comparisonProcessor[h](l,r.value,v)}}}else null===(u=null===(c=this._loggerManager)||void 0===c?void 0:c.trace)||void 0===u||u.call(c,"RuleManager._processRuleItem()",{warn:s.RULE_DATA_NOT_VALID,data:e});else null===(g=null===(_=this._loggerManager)||void 0===_?void 0:_.trace)||void 0===g||g.call(_,"RuleManager._processRuleItem()",{warn:s.RULE_NOT_VALID,data:e,rule:r});else null===(d=null===(p=this._loggerManager)||void 0===p?void 0:p.warn)||void 0===d||d.call(p,"RuleManager._processRuleItem()",s.RULE_MATCH_TYPE_NOT_SUPPORTED.replace("#",h))}catch(e){null===(h=null===(v=this._loggerManager)||void 0===v?void 0:v.error)||void 0===h||h.call(v,"RuleManager._processRuleItem()",{error:e.message})}else null===(O=null===(R=this._loggerManager)||void 0===R?void 0:R.warn)||void 0===O||O.call(R,"RuleManager._processRuleItem()",s.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,246 @@
+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);
+        this._mapper = (config === null || config === void 0 ? void 0 : config.mapper) || ((value) => value);
+        (_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()', this._mapper({
+            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()', this._mapper({
+            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, _j, _k, _l, _m, _o;
+        if (this.isValidRule(rule)) {
+            try {
+                const negation = rule.matching.negated || false;
+                const matching = rule.matching.match_type;
+                if (this.getComparisonProcessorMethods().indexOf(matching) !== -1) {
+                    if (data && typeof data === 'object' && (data === null || data === void 0 ? void 0 : data.constructor)) {
+                        // 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 ||
+                                    ((_c = data === null || data === void 0 ? void 0 : data.mapper) === null || _c === void 0 ? void 0 : _c.call(data, 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 {
+                            (_e = (_d = this._loggerManager) === null || _d === void 0 ? void 0 : _d.trace) === null || _e === void 0 ? void 0 : _e.call(_d, 'RuleManager._processRuleItem()', {
+                                warn: ERROR_MESSAGES.RULE_DATA_NOT_VALID,
+                                data
+                            });
+                        }
+                    }
+                    else {
+                        (_g = (_f = this._loggerManager) === null || _f === void 0 ? void 0 : _f.trace) === null || _g === void 0 ? void 0 : _g.call(_f, 'RuleManager._processRuleItem()', {
+                            warn: ERROR_MESSAGES.RULE_NOT_VALID,
+                            data,
+                            rule
+                        });
+                    }
+                }
+                else {
+                    (_j = (_h = this._loggerManager) === null || _h === void 0 ? void 0 : _h.warn) === null || _j === void 0 ? void 0 : _j.call(_h, 'RuleManager._processRuleItem()', ERROR_MESSAGES.RULE_MATCH_TYPE_NOT_SUPPORTED.replace('#', matching));
+                }
+            }
+            catch (error) {
+                (_l = (_k = this._loggerManager) === null || _k === void 0 ? void 0 : _k.error) === null || _l === void 0 ? void 0 : _l.call(_k, 'RuleManager._processRuleItem()', {
+                    error: error.message
+                });
+            }
+        }
+        else {
+            (_o = (_m = this._loggerManager) === null || _m === void 0 ? void 0 : _m.warn) === null || _o === void 0 ? void 0 : _o.call(_m, '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/index.js

@@ -0,0 +1,304 @@
+'use strict';
+
+var jsSdkUtils = require('@convertcom/js-sdk-utils');
+var jsSdkEnums = require('@convertcom/js-sdk-enums');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var DEFAULT_KEYS_CASE_SENSITIVE = true;
+var DEFAULT_NEGATION = '!';
+/**
+ * Provides rule processing calculations with corresponding comparisons methods
+ * @category Modules
+ * @constructor
+ * @implements {RuleManagerInterface}
+ */
+var RuleManager = /** @class */ (function () {
+    /**
+     * @param {Config=} config
+     * @param {Object=} dependencies
+     * @param {LogManagerInterface=} dependencies.loggerManager
+     */
+    function RuleManager(config, _a) {
+        var _b = _a === void 0 ? {} : _a, loggerManager = _b.loggerManager;
+        var _c, _d;
+        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);
+        this._mapper = (config === null || config === void 0 ? void 0 : config.mapper) || (function (value) { return value; });
+        (_d = (_c = this._loggerManager) === null || _c === void 0 ? void 0 : _c.trace) === null || _d === void 0 ? void 0 : _d.call(_c, 'RuleManager()', jsSdkEnums.MESSAGES.RULE_CONSTRUCTOR, this);
+    }
+    Object.defineProperty(RuleManager.prototype, "comparisonProcessor", {
+        /**
+         * Getter for comparison processor
+         */
+        get: function () {
+            return this._comparisonProcessor;
+        },
+        /**
+         * Setter for comparison processor
+         * @param {Record<string, any>} comparisonProcessor
+         */
+        set: function (comparisonProcessor) {
+            this._comparisonProcessor = comparisonProcessor;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Retrieve comparison methods from comparison processor
+     * @return {Array<string>} List of methods of comparison processor
+     */
+    RuleManager.prototype.getComparisonProcessorMethods = function () {
+        var _this = this;
+        return Object.getOwnPropertyNames(this._comparisonProcessor).filter(function (name) { return 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}
+     */
+    RuleManager.prototype.isRuleMatched = function (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()', this._mapper({
+            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
+        var match;
+        if (Object.prototype.hasOwnProperty.call(ruleSet, 'OR') &&
+            jsSdkUtils.arrayNotEmpty(ruleSet === null || ruleSet === void 0 ? void 0 : ruleSet.OR)) {
+            for (var 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}
+     */
+    RuleManager.prototype.isValidRule = function (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()', this._mapper({
+            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
+     */
+    RuleManager.prototype._processAND = function (data, rulesSubset) {
+        var _a, _b, _c, _d;
+        // Second AND level
+        var match;
+        if (Object.prototype.hasOwnProperty.call(rulesSubset, 'AND') &&
+            jsSdkUtils.arrayNotEmpty(rulesSubset === null || rulesSubset === void 0 ? void 0 : rulesSubset.AND)) {
+            for (var 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
+     */
+    RuleManager.prototype._processORWHEN = function (data, rulesSubset) {
+        var _a, _b;
+        // Third OR level. Called OR_WHEN.
+        var match;
+        if (Object.prototype.hasOwnProperty.call(rulesSubset, 'OR_WHEN') &&
+            jsSdkUtils.arrayNotEmpty(rulesSubset === null || rulesSubset === void 0 ? void 0 : rulesSubset.OR_WHEN)) {
+            for (var 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
+     */
+    RuleManager.prototype._processRuleItem = function (data, rule) {
+        var e_1, _a, e_2, _b;
+        var _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        if (this.isValidRule(rule)) {
+            try {
+                var negation = rule.matching.negated || false;
+                var matching = rule.matching.match_type;
+                if (this.getComparisonProcessorMethods().indexOf(matching) !== -1) {
+                    if (data && typeof data === 'object' && (data === null || data === void 0 ? void 0 : data.constructor)) {
+                        // Validate data key-value set.
+                        if (data.constructor === Object) {
+                            try {
+                                // Rule object has to have `key` field
+                                for (var _r = __values(Object.keys(data)), _s = _r.next(); !_s.done; _s = _r.next()) {
+                                    var key = _s.value;
+                                    var k = this._keys_case_sensitive ? key : key.toLowerCase();
+                                    var rule_k = this._keys_case_sensitive
+                                        ? rule.key
+                                        : rule.key.toLowerCase();
+                                    if (k === rule_k) {
+                                        return this._comparisonProcessor[matching](data[key], rule.value, negation);
+                                    }
+                                }
+                            }
+                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                            finally {
+                                try {
+                                    if (_s && !_s.done && (_a = _r.return)) _a.call(_r);
+                                }
+                                finally { if (e_1) throw e_1.error; }
+                            }
+                        }
+                        else if (rule === null || rule === void 0 ? void 0 : rule.rule_type) {
+                            // Rule object has to have `rule_type` field
+                            (_d = (_c = this._loggerManager) === null || _c === void 0 ? void 0 : _c.info) === null || _d === void 0 ? void 0 : _d.call(_c, 'RuleManager._processRuleItem()', jsSdkEnums.MESSAGES.RULE_MATCH_START.replace('#', rule.rule_type));
+                            try {
+                                for (var _t = __values(Object.getOwnPropertyNames(data.constructor.prototype)), _u = _t.next(); !_u.done; _u = _t.next()) {
+                                    var method = _u.value;
+                                    if (method === 'constructor')
+                                        continue;
+                                    var rule_method = jsSdkUtils.camelCase("get ".concat(rule.rule_type.replace(/_/g, ' ')));
+                                    if (method === rule_method ||
+                                        ((_e = data === null || data === void 0 ? void 0 : data.mapper) === null || _e === void 0 ? void 0 : _e.call(data, method)) === rule_method) {
+                                        var 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);
+                                    }
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (_u && !_u.done && (_b = _t.return)) _b.call(_t);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                        else {
+                            (_g = (_f = this._loggerManager) === null || _f === void 0 ? void 0 : _f.trace) === null || _g === void 0 ? void 0 : _g.call(_f, 'RuleManager._processRuleItem()', {
+                                warn: jsSdkEnums.ERROR_MESSAGES.RULE_DATA_NOT_VALID,
+                                data: data
+                            });
+                        }
+                    }
+                    else {
+                        (_j = (_h = this._loggerManager) === null || _h === void 0 ? void 0 : _h.trace) === null || _j === void 0 ? void 0 : _j.call(_h, 'RuleManager._processRuleItem()', {
+                            warn: jsSdkEnums.ERROR_MESSAGES.RULE_NOT_VALID,
+                            data: data,
+                            rule: rule
+                        });
+                    }
+                }
+                else {
+                    (_l = (_k = this._loggerManager) === null || _k === void 0 ? void 0 : _k.warn) === null || _l === void 0 ? void 0 : _l.call(_k, 'RuleManager._processRuleItem()', jsSdkEnums.ERROR_MESSAGES.RULE_MATCH_TYPE_NOT_SUPPORTED.replace('#', matching));
+                }
+            }
+            catch (error) {
+                (_o = (_m = this._loggerManager) === null || _m === void 0 ? void 0 : _m.error) === null || _o === void 0 ? void 0 : _o.call(_m, 'RuleManager._processRuleItem()', {
+                    error: error.message
+                });
+            }
+        }
+        else {
+            (_q = (_p = this._loggerManager) === null || _p === void 0 ? void 0 : _p.warn) === null || _q === void 0 ? void 0 : _q.call(_p, 'RuleManager._processRuleItem()', jsSdkEnums.ERROR_MESSAGES.RULE_NOT_VALID);
+        }
+        return false;
+    };
+    return RuleManager;
+}());
+
+exports.RuleManager = RuleManager;
+//# sourceMappingURL=index.js.map

package/lib/legacy/index.js.map

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

package/lib/legacy/index.min.js

@@ -0,0 +1,8 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * 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");function o(e){var r="function"==typeof Symbol&&Symbol.iterator,o=r&&e[r],t=0;if(o)return o.call(e);if(e&&"number"==typeof e.length)return{next:function(){return e&&t>=e.length&&(e=void 0),{value:e&&e[t++],done:!e}}};throw new TypeError(r?"Object is not iterable.":"Symbol.iterator is not defined.")}"function"==typeof SuppressedError&&SuppressedError;var t=function(){function t(o,t){var l,a,n=(void 0===t?{}:t).loggerManager;this._comparisonProcessor=e.Comparisons,this._negation="!",this._keys_case_sensitive=true,this._loggerManager=n,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),this._mapper=(null==o?void 0:o.mapper)||function(e){return e},null===(a=null===(l=this._loggerManager)||void 0===l?void 0:l.trace)||void 0===a||a.call(l,"RuleManager()",r.MESSAGES.RULE_CONSTRUCTOR,this)}return Object.defineProperty(t.prototype,"comparisonProcessor",{get:function(){return this._comparisonProcessor},set:function(e){this._comparisonProcessor=e},enumerable:!1,configurable:!0}),t.prototype.getComparisonProcessorMethods=function(){var e=this;return Object.getOwnPropertyNames(this._comparisonProcessor).filter((function(r){return"function"==typeof e._comparisonProcessor[r]}))},t.prototype.isRuleMatched=function(o,t,l){var a,n,i,s,c,u,p,_,g,v,d;if(null===(n=null===(a=this._loggerManager)||void 0===a?void 0:a.trace)||void 0===n||n.call(a,"RuleManager.isRuleMatched()",this._mapper({data:o,ruleSet:t})),l&&(null===(s=null===(i=this._loggerManager)||void 0===i?void 0:i.info)||void 0===s||s.call(i,"RuleManager.isRuleMatched()",r.MESSAGES.PROCESSING_ENTITY.replace("#",l))),Object.prototype.hasOwnProperty.call(t,"OR")&&e.arrayNotEmpty(null==t?void 0:t.OR)){for(var R=0,h=t.OR.length;R<h;R++)if(d=this._processAND(o,t.OR[R]),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()",l||"",r.ERROR_MESSAGES.RULE_ERROR):null===(_=null===(p=this._loggerManager)||void 0===p?void 0:p.info)||void 0===_||_.call(p,"RuleManager.isRuleMatched()",l||"",!1===d?r.MESSAGES.RULE_NOT_MATCH:r.MESSAGES.RULE_MATCH.replace("#",String(R))),!1!==d)return d}else null===(v=null===(g=this._loggerManager)||void 0===g?void 0:g.warn)||void 0===v||v.call(g,"RuleManager.isRuleMatched()",l||"",r.ERROR_MESSAGES.RULE_NOT_VALID);return!1},t.prototype.isValidRule=function(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()",this._mapper({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")},t.prototype._processAND=function(o,t){var l,a,n,i,s;if(Object.prototype.hasOwnProperty.call(t,"AND")&&e.arrayNotEmpty(null==t?void 0:t.AND)){for(var c=0,u=t.AND.length;c<u;c++)if(!1===(s=this._processORWHEN(o,t.AND[c])))return!1;return!1!==s&&(null===(a=null===(l=this._loggerManager)||void 0===l?void 0:l.info)||void 0===a||a.call(l,"RuleManager._processAND()",r.MESSAGES.RULE_MATCH_AND)),s}return null===(i=null===(n=this._loggerManager)||void 0===n?void 0:n.warn)||void 0===i||i.call(n,"RuleManager._processAND()",r.ERROR_MESSAGES.RULE_NOT_VALID),!1},t.prototype._processORWHEN=function(o,t){var l,a,n;if(Object.prototype.hasOwnProperty.call(t,"OR_WHEN")&&e.arrayNotEmpty(null==t?void 0:t.OR_WHEN)){for(var i=0,s=t.OR_WHEN.length;i<s;i++)if(!1!==(n=this._processRuleItem(o,t.OR_WHEN[i])))return n}else null===(a=null===(l=this._loggerManager)||void 0===l?void 0:l.warn)||void 0===a||a.call(l,"RuleManager._processORWHEN()",r.ERROR_MESSAGES.RULE_NOT_VALID);return!1},t.prototype._processRuleItem=function(t,l){var a,n,i,s,c,u,p,_,g,v,d,R,h,E,y,f,M;if(this.isValidRule(l))try{var O=l.matching.negated||!1,S=l.matching.match_type;if(-1!==this.getComparisonProcessorMethods().indexOf(S))if(t&&"object"==typeof t&&(null==t?void 0:t.constructor))if(t.constructor===Object)try{for(var m=o(Object.keys(t)),A=m.next();!A.done;A=m.next()){var N=A.value;if((this._keys_case_sensitive?N:N.toLowerCase())===(this._keys_case_sensitive?l.key:l.key.toLowerCase()))return this._comparisonProcessor[S](t[N],l.value,O)}}catch(e){a={error:e}}finally{try{A&&!A.done&&(n=m.return)&&n.call(m)}finally{if(a)throw a.error}}else if(null==l?void 0:l.rule_type){null===(u=null===(c=this._loggerManager)||void 0===c?void 0:c.info)||void 0===u||u.call(c,"RuleManager._processRuleItem()",r.MESSAGES.RULE_MATCH_START.replace("#",l.rule_type));try{for(var b=o(Object.getOwnPropertyNames(t.constructor.prototype)),P=b.next();!P.done;P=b.next()){var j=P.value;if("constructor"!==j){var T=e.camelCase("get ".concat(l.rule_type.replace(/_/g," ")));if(j===T||(null===(p=null==t?void 0:t.mapper)||void 0===p?void 0:p.call(t,j))===T){var w=t[j](l);return Object.values(r.RuleError).includes(w)||"js_condition"===l.rule_type?w:this._comparisonProcessor[S](w,l.value,O)}}}}catch(e){i={error:e}}finally{try{P&&!P.done&&(s=b.return)&&s.call(b)}finally{if(i)throw i.error}}}else null===(g=null===(_=this._loggerManager)||void 0===_?void 0:_.trace)||void 0===g||g.call(_,"RuleManager._processRuleItem()",{warn:r.ERROR_MESSAGES.RULE_DATA_NOT_VALID,data:t});else null===(d=null===(v=this._loggerManager)||void 0===v?void 0:v.trace)||void 0===d||d.call(v,"RuleManager._processRuleItem()",{warn:r.ERROR_MESSAGES.RULE_NOT_VALID,data:t,rule:l});else null===(h=null===(R=this._loggerManager)||void 0===R?void 0:R.warn)||void 0===h||h.call(R,"RuleManager._processRuleItem()",r.ERROR_MESSAGES.RULE_MATCH_TYPE_NOT_SUPPORTED.replace("#",S))}catch(e){null===(y=null===(E=this._loggerManager)||void 0===E?void 0:E.error)||void 0===y||y.call(E,"RuleManager._processRuleItem()",{error:e.message})}else null===(M=null===(f=this._loggerManager)||void 0===f?void 0:f.warn)||void 0===M||M.call(f,"RuleManager._processRuleItem()",r.ERROR_MESSAGES.RULE_NOT_VALID);return!1},t}();exports.RuleManager=t;
+//# sourceMappingURL=index.min.js.map

package/lib/legacy/index.min.js.map

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

package/lib/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@convertcom/js-sdk-rules",
+  "main": "index.min.js",
+  "module": "index.min.mjs",
+  "browser": "index.umd.min.js",
+  "types": "index.d.ts",
+  "files": [
+    "**/**/*"
+  ],
+  "author": "Convert Insights, Inc",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/convertcom/javascript-sdk.git",
+    "directory": "packages/rules"
+  },
+  "license": "Apache-2.0",
+  "version": "1.0.1"
+}

package/package.json

@@ -14,8 +14,62 @@
     "directory": "packages/rules"
   },
   "license": "Apache-2.0",
+  "scripts": {
+    "pretest": "mkdir -p webpack-build && rm -rf coverage",
+    "test": "nyc yarn test:server && yarn coverage",
+    "test:server": "nyc yarn test:mocha",
+    "test:mocha": "mocha -r ts-node/register --recursive \"tests/**/*.tests.ts\" --exit",
+    "clean": "rm -rf lib",
+    "prebuild:version": "node -p \"'export const LIB_VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
+    "prebuild": "yarn clean",
+    "build": "rollup -c build.mjs",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "yarn lint -- --fix",
+    "coverage": "nyc report -r cobertura --reporter=text-summary",
+    "postcoverage": "istanbul-cobertura-badger -e 85 -g 70 -r coverage/cobertura-coverage.xml -d ./coverage -b coverage"
+  },
   "engines": {
     "node": ">=8.0.0"
   },
-  "version": "0.0.1"
+  "devDependencies": {
+    "@babel/core": "^7.23.2",
+    "@babel/preset-env": "^7.23.2",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@types/chai": "^4.3.9",
+    "@types/chai-string": "^1.4.4",
+    "@types/mocha": "^10.0.3",
+    "@typescript-eslint/eslint-plugin": "^6.9.0",
+    "@typescript-eslint/parser": "^6.9.0",
+    "assert": "^2.1.0",
+    "babel-cli": "^6.26.0",
+    "babel-preset-es2015": "^6.24.1",
+    "chai": "^4.3.10",
+    "chai-string": "^1.5.0",
+    "dotenv": "^16.3.1",
+    "eslint": "^8.52.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-jasmine": "^4.1.3",
+    "eslint-plugin-local-rules": "^2.0.0",
+    "eslint-plugin-mocha": "^10.2.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "istanbul-cobertura-badger": "^1.3.1",
+    "mocha": "^10.2.0",
+    "nyc": "^15.1.0",
+    "prettier": "^3.0.3",
+    "require": "^2.4.20",
+    "rollup": "^3.20.2",
+    "rollup-plugin-dts": "^6.1.0",
+    "rollup-plugin-generate-package-json": "^3.2.0",
+    "rollup-plugin-modify": "^3.0.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "ts-node": "^10.9.1",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^5.2.2",
+    "typings": "^2.1.1",
+    "webpack": "^5.89.0"
+  },
+  "version": "1.0.1"
 }