@convertcom/js-sdk-rules 0.0.1 → 1.0.0

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

@@ -0,0 +1,16 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum ExperienceType {
+    AB = "a/b",
+    AA = "a/a",
+    MVT = "mvt",
+    SPLIT = "split_url",
+    DEPLOY = "deploy",
+    MULTIPAGE = "multipage",
+    AB_FULLSTACK = "a/b_fullstack",
+    FEATURE_ROLLOUT = "feature_rollout"
+}

package/lib/legacy/enums/src/feature-status.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 FeatureStatus {
+    ENABLED = "enabled",
+    DISABLED = "disabled"
+}

package/lib/legacy/enums/src/ga-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 GoogleAnalyticsType {
+    GA3 = "ga3",
+    GA4 = "ga4"
+}

package/lib/legacy/enums/src/goal-data-key.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 GoalDataKey {
+    AMOUNT = "amount",
+    PRODUCTS_COUNT = "productsCount",
+    TRANSACTION_ID = "transactionId"
+}

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

@@ -0,0 +1,22 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum GoalType {
+    ADVANCED = "advanced",
+    DOM_INTERACTION = "dom_interaction",
+    SCROLL_PERCENTAGE = "scroll_percentage",
+    CODE_TRIGGER = "code_trigger",
+    REVENUE = "revenue",
+    GOOGLE_ANALYTICS_IMPORT = "ga_import",
+    CLICKS_ELEMENT = "clicks_element",
+    CLICKS_LINK = "clicks_link",
+    SUBMITS_FORM = "submits_form",
+    VISITS_PAGE = "visits_page"
+}
+export declare enum GoalRevenueTriggeringType {
+    MANUAL = "manual",
+    GOOGLE_ANALYTICS = "ga"
+}

package/lib/legacy/enums/src/integration-provider.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum IntegrationProvider {
+    BAIDU = "baidu",
+    CLICK_TALE = "clicktale",
+    CLICKY = "clicky",
+    CNZZ = "cnzz",
+    CRAZY_EGG = "crazyegg",
+    ECONDA = "econda",
+    EULERIAN = "eulerian",
+    GOOGLE_ANALYTICS = "google_analytics",
+    GO_SQUARED = "gosquared",
+    HEAP_ANALYTICS = "heapanalytics",
+    HOT_JAR = "hotjar",
+    KISS_METRICS = "kissmetrics",
+    MIX_PANEL = "mixpanel",
+    MOUSE_FLOW = "mouseflow",
+    PIWIK = "piwik",
+    SEGMENTIO = "segmentio",
+    SITE_CATALYST = "sitecatalyst",
+    WOOPRA = "woopra",
+    YSANCE = "ysance"
+}

package/lib/legacy/enums/src/log-level.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum LogLevel {
+    TRACE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4,
+    SILENT = 5
+}

package/lib/legacy/enums/src/log-method.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum LogMethod {
+    LOG = "log",
+    TRACE = "trace",
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}

package/lib/legacy/enums/src/project-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 ProjectType {
+    WEB = "web",
+    FULLSTACK = "fullstack"
+}

package/lib/legacy/enums/src/rule-error.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 RuleError {
+    NO_DATA_FOUND = "convert.com_no_data_found",
+    NEED_MORE_DATA = "convert.com_need_more_data"
+}

package/lib/legacy/enums/src/segments/browser-type.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum BrowserType {
+    IE = "IE",
+    CH = "CH",
+    FF = "FF",
+    OP = "OP",
+    SF = "SF",
+    EDG = "EDG",
+    MO = "MO",
+    NS = "NS",
+    OTH = "OTH"
+}

package/lib/legacy/enums/src/segments/device-type.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum DeviceType {
+    ALLPH = "ALLPH",
+    IPH = "IPH",
+    OTHPH = "OTHPH",
+    ALLTAB = "ALLTAB",
+    IPAD = "IPAD",
+    OTHTAB = "OTHTAB",
+    DESK = "DESK",
+    OTHDEV = "OTHDEV"
+}

package/lib/legacy/enums/src/segments/segments-keys.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum SegmentsKeys {
+    COUNTRY = "country",
+    BROWSER = "browser",
+    DEVICES = "devices",
+    SOURCE = "source",
+    CAMPAIGN = "campaign",
+    VISITOR_TYPE = "visitorType",
+    CUSTOM_SEGMENTS = "customSegments"
+}

package/lib/legacy/enums/src/segments/source-type.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 SourceType {
+    CAMPAIGN = "campaign",
+    SEARCH = "search",
+    REFERRAL = "referral",
+    DIRECT = "direct"
+}

package/lib/legacy/enums/src/segments/visitor-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 VisitorType {
+    NEW = "new",
+    RETURNING = "returning"
+}

package/lib/legacy/enums/src/system-events.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+/**
+ * SDK system events. Possible values: 'ready' | 'queue-released'
+ * or custom visitor's event
+ */
+export declare enum SystemEvents {
+    READY = "ready",
+    CONFIG_UPDATED = "config.updated",
+    API_QUEUE_RELEASED = "api.queue.released",
+    BUCKETING = "bucketing",
+    CONVERSION = "conversion",
+    SEGMENTS = "segments",
+    LOCATION_ACTIVATED = "location.activated",
+    LOCATION_DEACTIVATED = "location.deactivated",
+    AUDIENCES = "audiences",
+    DATA_STORE_QUEUE_RELEASED = "datastore.queue.released"
+}

package/lib/legacy/enums/src/variable-types.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 VARIABLE_TYPES: readonly ["boolean", "float", "json", "integer", "string"];

package/lib/legacy/enums/src/variation-change-type.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export declare enum VariationChangeType {
+    RICH_STRUCTURE = "richStructure",
+    CUSTOM_CODE = "customCode",
+    DEFAULT_CODE = "defaultCode",
+    DEFAULT_CODE_MULTIPAGE = "defaultCodeMultipage",
+    DEFAULT_REDIRECT = "defaultRedirect",
+    FULLSTACK_FEATURE = "fullStackFeature"
+}

package/lib/legacy/index.js

@@ -0,0 +1,291 @@
+'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);
+        (_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()', {
+            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()', {
+            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;
+        if (this.isValidRule(rule)) {
+            try {
+                var negation = rule.matching.negated || false;
+                var matching = rule.matching.match_type;
+                if (this.getComparisonProcessorMethods().indexOf(matching) !== -1) {
+                    if (typeof data === 'object') {
+                        // Validate data key-value set.
+                        if (data.constructor === Object) {
+                            try {
+                                // Rule object has to have `key` field
+                                for (var _l = __values(Object.keys(data)), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                    var key = _m.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 (_m && !_m.done && (_a = _l.return)) _a.call(_l);
+                                }
+                                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 _o = __values(Object.getOwnPropertyNames(data.constructor.prototype)), _p = _o.next(); !_p.done; _p = _o.next()) {
+                                    var method = _p.value;
+                                    if (method === 'constructor')
+                                        continue;
+                                    var rule_method = jsSdkUtils.camelCase("get ".concat(rule.rule_type.replace(/_/g, ' ')));
+                                    if (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 (_p && !_p.done && (_b = _o.return)) _b.call(_o);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                    }
+                    else {
+                        (_f = (_e = this._loggerManager) === null || _e === void 0 ? void 0 : _e.warn) === null || _f === void 0 ? void 0 : _f.call(_e, 'RuleManager._processRuleItem()', {
+                            warn: jsSdkEnums.ERROR_MESSAGES.RULE_DATA_NOT_VALID
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                (_h = (_g = this._loggerManager) === null || _g === void 0 ? void 0 : _g.error) === null || _h === void 0 ? void 0 : _h.call(_g, 'RuleManager._processRuleItem()', {
+                    error: error.message
+                });
+            }
+        }
+        else {
+            (_k = (_j = this._loggerManager) === null || _j === void 0 ? void 0 : _j.warn) === null || _k === void 0 ? void 0 : _k.call(_j, '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,n,a=(void 0===t?{}:t).loggerManager;this._comparisonProcessor=e.Comparisons,this._negation="!",this._keys_case_sensitive=true,this._loggerManager=a,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===(n=null===(l=this._loggerManager)||void 0===l?void 0:l.trace)||void 0===n||n.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 n,a,i,s,c,u,p,g,_,v,d;if(null===(a=null===(n=this._loggerManager)||void 0===n?void 0:n.trace)||void 0===a||a.call(n,"RuleManager.isRuleMatched()",{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===(g=null===(p=this._loggerManager)||void 0===p?void 0:p.info)||void 0===g||g.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===(_=this._loggerManager)||void 0===_?void 0:_.warn)||void 0===v||v.call(_,"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()",{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,n,a,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===(n=null===(l=this._loggerManager)||void 0===l?void 0:l.info)||void 0===n||n.call(l,"RuleManager._processAND()",r.MESSAGES.RULE_MATCH_AND)),s}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},t.prototype._processORWHEN=function(o,t){var l,n,a;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!==(a=this._processRuleItem(o,t.OR_WHEN[i])))return a}else null===(n=null===(l=this._loggerManager)||void 0===l?void 0:l.warn)||void 0===n||n.call(l,"RuleManager._processORWHEN()",r.ERROR_MESSAGES.RULE_NOT_VALID);return!1},t.prototype._processRuleItem=function(t,l){var n,a,i,s,c,u,p,g,_,v,d,R;if(this.isValidRule(l))try{var h=l.matching.negated||!1,y=l.matching.match_type;if(-1!==this.getComparisonProcessorMethods().indexOf(y))if("object"==typeof t){if(t.constructor===Object)try{for(var f=o(Object.keys(t)),E=f.next();!E.done;E=f.next()){var M=E.value;if((this._keys_case_sensitive?M:M.toLowerCase())===(this._keys_case_sensitive?l.key:l.key.toLowerCase()))return this._comparisonProcessor[y](t[M],l.value,h)}}catch(e){n={error:e}}finally{try{E&&!E.done&&(a=f.return)&&a.call(f)}finally{if(n)throw n.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 O=o(Object.getOwnPropertyNames(t.constructor.prototype)),S=O.next();!S.done;S=O.next()){var m=S.value;if("constructor"!==m)if(m===e.camelCase("get ".concat(l.rule_type.replace(/_/g," ")))){var A=t[m](l);return Object.values(r.RuleError).includes(A)||"js_condition"===l.rule_type?A:this._comparisonProcessor[y](A,l.value,h)}}}catch(e){i={error:e}}finally{try{S&&!S.done&&(s=O.return)&&s.call(O)}finally{if(i)throw i.error}}}}else null===(g=null===(p=this._loggerManager)||void 0===p?void 0:p.warn)||void 0===g||g.call(p,"RuleManager._processRuleItem()",{warn:r.ERROR_MESSAGES.RULE_DATA_NOT_VALID})}catch(e){null===(v=null===(_=this._loggerManager)||void 0===_?void 0:_.error)||void 0===v||v.call(_,"RuleManager._processRuleItem()",{error:e.message})}else null===(R=null===(d=this._loggerManager)||void 0===d?void 0:d.warn)||void 0===R||R.call(d,"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/legacy/logger/index.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Convert JS SDK test
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+export { LogManager } from './src/log-manager';
+export { LogManagerInterface } from './src/interfaces/log-manager';

package/lib/legacy/logger/src/interfaces/log-client.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { LogLevel } from '@convertcom/js-sdk-enums';
+import { LogMethodMapInterface } from './log-method-map';
+export interface LogClientInterface {
+    sdk: any;
+    level: LogLevel;
+    mapper: LogMethodMapInterface;
+}

package/lib/legacy/logger/src/interfaces/log-manager.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { LogLevel } from '@convertcom/js-sdk-enums';
+import { LogMethodMapInterface } from './log-method-map';
+export interface LogManagerInterface {
+    log(level: LogLevel, ...args: any[]): void;
+    trace(...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    addClient(client?: any, level?: LogLevel, methodMap?: LogMethodMapInterface): void;
+    setClientLevel(level: LogLevel, client?: any): void;
+}

package/lib/legacy/logger/src/interfaces/log-method-map.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Convert JS SDK
+ * Version 1.0.0
+ * Copyright(c) 2020 Convert Insights, Inc
+ * License Apache-2.0
+ */
+import { LogMethod } from '@convertcom/js-sdk-enums';
+export interface LogMethodMapInterface {
+    [LogMethod.LOG]?: string;
+    [LogMethod.DEBUG]?: string;
+    [LogMethod.INFO]?: string;
+    [LogMethod.WARN]?: string;
+    [LogMethod.ERROR]?: string;
+    [LogMethod.TRACE]?: string;
+}