@kameleoon/javascript-sdk-core 1.1.1 → 2.0.0

package/dist/targeting/conditions/targetExperimentCondition.js

@@ -1,42 +1,64 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.TargetExperimentCondition = void 0;
-const ts_res_1 = require("ts-res");
-const types_1 = require("../types");
+var _tsRes = require("ts-res");
+var _types = require("../types");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 class TargetExperimentCondition {
-    constructor({ variation, experiment, isInclude, variationMatchType, }) {
-        this.inverseResult = !(isInclude !== null && isInclude !== void 0 ? isInclude : true);
-        this.experimentId = experiment;
-        this.variationId = variation;
-        this.matchType = variationMatchType;
+  constructor({
+    variation,
+    experiment,
+    isInclude,
+    variationMatchType
+  }) {
+    _defineProperty(this, "inverseResult", void 0);
+    _defineProperty(this, "experimentId", void 0);
+    _defineProperty(this, "variationId", void 0);
+    _defineProperty(this, "matchType", void 0);
+    this.inverseResult = !(isInclude ?? true);
+    this.experimentId = experiment;
+    this.variationId = variation;
+    this.matchType = variationMatchType;
+  }
+  evaluate({
+    variationData
+  }) {
+    if (!this.experimentId) {
+      return (0, _tsRes.Ok)(false);
     }
-    evaluate({ variationData, }) {
-        if (!this.experimentId) {
-            return (0, ts_res_1.Ok)(false);
-        }
-        if (this.matchType === types_1.MatchTypeVariation.EXACT && !this.variationId) {
-            (0, ts_res_1.Ok)(false);
-        }
-        const result = this.checkCondition({
-            variationId: this.variationId,
-            experimentId: this.experimentId,
-            variationData,
-        });
-        return (0, ts_res_1.Ok)(this.inverseResult ? !result : result);
+    if (this.matchType === _types.MatchTypeVariation.EXACT && !this.variationId) {
+      (0, _tsRes.Ok)(false);
     }
-    checkCondition({ variationId, experimentId, variationData, }) {
-        const experimentIdString = String(experimentId);
-        const variation = variationData[experimentIdString];
-        switch (this.matchType) {
-            case types_1.MatchTypeVariation.EXACT: {
-                return (variation === null || variation === void 0 ? void 0 : variation.variationId) === variationId;
-            }
-            case types_1.MatchTypeVariation.ANY:
-                return Boolean(variation);
-            default:
-                return false;
+    const result = this.checkCondition({
+      variationId: this.variationId,
+      experimentId: this.experimentId,
+      variationData
+    });
+    return (0, _tsRes.Ok)(this.inverseResult ? !result : result);
+  }
+  checkCondition({
+    variationId,
+    experimentId,
+    variationData
+  }) {
+    const experimentIdString = String(experimentId);
+    const variation = variationData[experimentIdString];
+    switch (this.matchType) {
+      case _types.MatchTypeVariation.EXACT:
+        {
+          return variation?.variationId === variationId;
         }
+      case _types.MatchTypeVariation.ANY:
+        return Boolean(variation);
+      default:
+        return false;
     }
+  }
 }
 exports.TargetExperimentCondition = TargetExperimentCondition;
 //# sourceMappingURL=targetExperimentCondition.js.map

package/dist/targeting/conditions/targetExperimentCondition.js.map

@@ -1 +1 @@
-{"version":3,"file":"targetExperimentCondition.js","sourceRoot":"","sources":["../../../src/targeting/conditions/targetExperimentCondition.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AAGpC,oCAAkE;AAGlE,MAAa,yBAAyB;IAMpC,YAAY,EACV,SAAS,EACT,UAAU,EACV,SAAS,EACT,kBAAkB,GACA;QAClB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,SAAS,aAAT,SAAS,cAAT,SAAS,GAAI,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC;QAC/B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,kBAAkB,CAAC;IACtC,CAAC;IAED,QAAQ,CAAC,EACP,aAAa,GACM;QACnB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,OAAO,IAAA,WAAE,EAAC,KAAK,CAAC,CAAC;SAClB;QAED,IAAI,IAAI,CAAC,SAAS,KAAK,0BAAkB,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACpE,IAAA,WAAE,EAAC,KAAK,CAAC,CAAC;SACX;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC;YACjC,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,aAAa;SACd,CAAC,CAAC;QAEH,OAAO,IAAA,WAAE,EAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;IAEO,cAAc,CAAC,EACrB,WAAW,EACX,YAAY,EACZ,aAAa,GAKd;QACC,MAAM,kBAAkB,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAChD,MAAM,SAAS,GAAG,aAAa,CAAC,kBAAkB,CAAC,CAAC;QAEpD,QAAQ,IAAI,CAAC,SAAS,EAAE;YACtB,KAAK,0BAAkB,CAAC,KAAK,CAAC,CAAC;gBAC7B,OAAO,CAAA,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,WAAW,MAAK,WAAW,CAAC;aAC/C;YACD,KAAK,0BAAkB,CAAC,GAAG;gBACzB,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC;YAC5B;gBACE,OAAO,KAAK,CAAC;SAChB;IACH,CAAC;CACF;AA5DD,8DA4DC"}
+{"version":3,"file":"targetExperimentCondition.js","names":["_tsRes","require","_types","_defineProperty","obj","key","value","_toPropertyKey","Object","defineProperty","enumerable","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","TargetExperimentCondition","constructor","variation","experiment","isInclude","variationMatchType","inverseResult","experimentId","variationId","matchType","evaluate","variationData","Ok","MatchTypeVariation","EXACT","result","checkCondition","experimentIdString","ANY","Boolean","exports"],"sources":["../../../src/targeting/conditions/targetExperimentCondition.ts"],"sourcesContent":["import { Ok, Result } from 'ts-res';\nimport { KameleoonError } from '../../kameleoonError';\nimport { ExperimentVariationsType } from '../../storage';\nimport { EvaluationDataType, MatchTypeVariation } from '../types';\nimport { ConditionDataType, ICondition } from './types';\n\nexport class TargetExperimentCondition implements ICondition {\n  private inverseResult: boolean;\n  private experimentId?: number | null;\n  private variationId?: number | null;\n  private matchType?: MatchTypeVariation | null;\n\n  constructor({\n    variation,\n    experiment,\n    isInclude,\n    variationMatchType,\n  }: ConditionDataType) {\n    this.inverseResult = !(isInclude ?? true);\n    this.experimentId = experiment;\n    this.variationId = variation;\n    this.matchType = variationMatchType;\n  }\n\n  evaluate({\n    variationData,\n  }: EvaluationDataType): Result<boolean, KameleoonError> {\n    if (!this.experimentId) {\n      return Ok(false);\n    }\n\n    if (this.matchType === MatchTypeVariation.EXACT && !this.variationId) {\n      Ok(false);\n    }\n\n    const result = this.checkCondition({\n      variationId: this.variationId,\n      experimentId: this.experimentId,\n      variationData,\n    });\n\n    return Ok(this.inverseResult ? !result : result);\n  }\n\n  private checkCondition({\n    variationId,\n    experimentId,\n    variationData,\n  }: {\n    variationId?: number | null;\n    experimentId: number;\n    variationData: ExperimentVariationsType;\n  }): boolean {\n    const experimentIdString = String(experimentId);\n    const variation = variationData[experimentIdString];\n\n    switch (this.matchType) {\n      case MatchTypeVariation.EXACT: {\n        return variation?.variationId === variationId;\n      }\n      case MatchTypeVariation.ANY:\n        return Boolean(variation);\n      default:\n        return false;\n    }\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGA,IAAAC,MAAA,GAAAD,OAAA;AAAkE,SAAAE,gBAAAC,GAAA,EAAAC,GAAA,EAAAC,KAAA,IAAAD,GAAA,GAAAE,cAAA,CAAAF,GAAA,OAAAA,GAAA,IAAAD,GAAA,IAAAI,MAAA,CAAAC,cAAA,CAAAL,GAAA,EAAAC,GAAA,IAAAC,KAAA,EAAAA,KAAA,EAAAI,UAAA,QAAAC,YAAA,QAAAC,QAAA,oBAAAR,GAAA,CAAAC,GAAA,IAAAC,KAAA,WAAAF,GAAA;AAAA,SAAAG,eAAAM,GAAA,QAAAR,GAAA,GAAAS,YAAA,CAAAD,GAAA,2BAAAR,GAAA,gBAAAA,GAAA,GAAAU,MAAA,CAAAV,GAAA;AAAA,SAAAS,aAAAE,KAAA,EAAAC,IAAA,eAAAD,KAAA,iBAAAA,KAAA,kBAAAA,KAAA,MAAAE,IAAA,GAAAF,KAAA,CAAAG,MAAA,CAAAC,WAAA,OAAAF,IAAA,KAAAG,SAAA,QAAAC,GAAA,GAAAJ,IAAA,CAAAK,IAAA,CAAAP,KAAA,EAAAC,IAAA,2BAAAK,GAAA,sBAAAA,GAAA,YAAAE,SAAA,4DAAAP,IAAA,gBAAAF,MAAA,GAAAU,MAAA,EAAAT,KAAA;AAG3D,MAAMU,yBAAyB,CAAuB;EAM3DC,WAAWA,CAAC;IACVC,SAAS;IACTC,UAAU;IACVC,SAAS;IACTC;EACiB,CAAC,EAAE;IAAA5B,eAAA;IAAAA,eAAA;IAAAA,eAAA;IAAAA,eAAA;IACpB,IAAI,CAAC6B,aAAa,GAAG,EAAEF,SAAS,IAAI,IAAI,CAAC;IACzC,IAAI,CAACG,YAAY,GAAGJ,UAAU;IAC9B,IAAI,CAACK,WAAW,GAAGN,SAAS;IAC5B,IAAI,CAACO,SAAS,GAAGJ,kBAAkB;EACrC;EAEAK,QAAQA,CAAC;IACPC;EACkB,CAAC,EAAmC;IACtD,IAAI,CAAC,IAAI,CAACJ,YAAY,EAAE;MACtB,OAAO,IAAAK,SAAE,EAAC,KAAK,CAAC;IAClB;IAEA,IAAI,IAAI,CAACH,SAAS,KAAKI,yBAAkB,CAACC,KAAK,IAAI,CAAC,IAAI,CAACN,WAAW,EAAE;MACpE,IAAAI,SAAE,EAAC,KAAK,CAAC;IACX;IAEA,MAAMG,MAAM,GAAG,IAAI,CAACC,cAAc,CAAC;MACjCR,WAAW,EAAE,IAAI,CAACA,WAAW;MAC7BD,YAAY,EAAE,IAAI,CAACA,YAAY;MAC/BI;IACF,CAAC,CAAC;IAEF,OAAO,IAAAC,SAAE,EAAC,IAAI,CAACN,aAAa,GAAG,CAACS,MAAM,GAAGA,MAAM,CAAC;EAClD;EAEQC,cAAcA,CAAC;IACrBR,WAAW;IACXD,YAAY;IACZI;EAKF,CAAC,EAAW;IACV,MAAMM,kBAAkB,GAAG5B,MAAM,CAACkB,YAAY,CAAC;IAC/C,MAAML,SAAS,GAAGS,aAAa,CAACM,kBAAkB,CAAC;IAEnD,QAAQ,IAAI,CAACR,SAAS;MACpB,KAAKI,yBAAkB,CAACC,KAAK;QAAE;UAC7B,OAAOZ,SAAS,EAAEM,WAAW,KAAKA,WAAW;QAC/C;MACA,KAAKK,yBAAkB,CAACK,GAAG;QACzB,OAAOC,OAAO,CAACjB,SAAS,CAAC;MAC3B;QACE,OAAO,KAAK;IAAC;EAEnB;AACF;AAACkB,OAAA,CAAApB,yBAAA,GAAAA,yBAAA"}

package/dist/targeting/conditions/types.js

@@ -1,3 +1,6 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 //# sourceMappingURL=types.js.map

package/dist/targeting/conditions/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/targeting/conditions/types.ts"],"names":[],"mappings":""}
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/targeting/conditions/types.ts"],"sourcesContent":["import { Result } from 'ts-res';\nimport { KameleoonError } from '../../kameleoonError';\nimport {\n  EvaluationDataType,\n  MatchTypeCustomData,\n  MatchTypeTest,\n  MatchTypeVariation,\n  TargetingType,\n} from '../types';\nimport { CustomDataCondition } from './customDataCondition';\nimport { ExclusiveExperimentCondition } from './exclusiveExperimentCondition';\nimport { TargetExperimentCondition } from './targetExperimentCondition';\n\nexport interface ICondition {\n  evaluate: (data: EvaluationDataType) => Result<boolean, KameleoonError>;\n}\n\nexport type ConditionType =\n  | CustomDataCondition\n  | ExclusiveExperimentCondition\n  | TargetExperimentCondition;\n\nexport type ConditionDataType = {\n  id: number;\n  targetingType: TargetingType;\n  isInclude: boolean | null;\n  weight: number;\n  customDataIndex: string | null;\n  value: string | null;\n  valueMatchType: MatchTypeCustomData | null;\n  experiment?: number | null;\n  variation?: number | null;\n  variationMatchType?: MatchTypeVariation | null;\n  testMatchType?: MatchTypeTest | null;\n};\n"],"mappings":""}

package/dist/targeting/index.js

@@ -1,15 +1,81 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExclusiveExperimentCondition = exports.TargetExperimentCondition = exports.CustomDataCondition = exports.MatchTypeVariation = exports.MatchTypeCustomData = exports.TargetingType = exports.Operator = exports.TargetingTree = void 0;
-var targetingTree_1 = require("./targetingTree");
-Object.defineProperty(exports, "TargetingTree", { enumerable: true, get: function () { return targetingTree_1.TargetingTree; } });
-var types_1 = require("./types");
-Object.defineProperty(exports, "Operator", { enumerable: true, get: function () { return types_1.Operator; } });
-Object.defineProperty(exports, "TargetingType", { enumerable: true, get: function () { return types_1.TargetingType; } });
-Object.defineProperty(exports, "MatchTypeCustomData", { enumerable: true, get: function () { return types_1.MatchTypeCustomData; } });
-Object.defineProperty(exports, "MatchTypeVariation", { enumerable: true, get: function () { return types_1.MatchTypeVariation; } });
-var conditions_1 = require("./conditions");
-Object.defineProperty(exports, "CustomDataCondition", { enumerable: true, get: function () { return conditions_1.CustomDataCondition; } });
-Object.defineProperty(exports, "TargetExperimentCondition", { enumerable: true, get: function () { return conditions_1.TargetExperimentCondition; } });
-Object.defineProperty(exports, "ExclusiveExperimentCondition", { enumerable: true, get: function () { return conditions_1.ExclusiveExperimentCondition; } });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CustomDataCondition", {
+  enumerable: true,
+  get: function () {
+    return _conditions.CustomDataCondition;
+  }
+});
+Object.defineProperty(exports, "EvaluationDataType", {
+  enumerable: true,
+  get: function () {
+    return _types.EvaluationDataType;
+  }
+});
+Object.defineProperty(exports, "ExclusiveExperimentCondition", {
+  enumerable: true,
+  get: function () {
+    return _conditions.ExclusiveExperimentCondition;
+  }
+});
+Object.defineProperty(exports, "MatchTypeCustomData", {
+  enumerable: true,
+  get: function () {
+    return _types.MatchTypeCustomData;
+  }
+});
+Object.defineProperty(exports, "MatchTypeVariation", {
+  enumerable: true,
+  get: function () {
+    return _types.MatchTypeVariation;
+  }
+});
+Object.defineProperty(exports, "Operator", {
+  enumerable: true,
+  get: function () {
+    return _types.Operator;
+  }
+});
+Object.defineProperty(exports, "SegmentType", {
+  enumerable: true,
+  get: function () {
+    return _types.SegmentType;
+  }
+});
+Object.defineProperty(exports, "TargetExperimentCondition", {
+  enumerable: true,
+  get: function () {
+    return _conditions.TargetExperimentCondition;
+  }
+});
+Object.defineProperty(exports, "TargetingDataItemType", {
+  enumerable: true,
+  get: function () {
+    return _types.TargetingDataItemType;
+  }
+});
+Object.defineProperty(exports, "TargetingDataType", {
+  enumerable: true,
+  get: function () {
+    return _types.TargetingDataType;
+  }
+});
+Object.defineProperty(exports, "TargetingTree", {
+  enumerable: true,
+  get: function () {
+    return _targetingTree.TargetingTree;
+  }
+});
+Object.defineProperty(exports, "TargetingType", {
+  enumerable: true,
+  get: function () {
+    return _types.TargetingType;
+  }
+});
+var _targetingTree = require("./targetingTree");
+var _types = require("./types");
+var _conditions = require("./conditions");
 //# sourceMappingURL=index.js.map

package/dist/targeting/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/targeting/index.ts"],"names":[],"mappings":";;;AAAA,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,iCASiB;AARf,iGAAA,QAAQ,OAAA;AACR,sGAAA,aAAa,OAAA;AAIb,4GAAA,mBAAmB,OAAA;AACnB,2GAAA,kBAAkB,OAAA;AAGpB,2CAIsB;AAHpB,iHAAA,mBAAmB,OAAA;AACnB,uHAAA,yBAAyB,OAAA;AACzB,0HAAA,4BAA4B,OAAA"}
+{"version":3,"file":"index.js","names":["_targetingTree","require","_types","_conditions"],"sources":["../../src/targeting/index.ts"],"sourcesContent":["export { TargetingTree } from './targetingTree';\nexport {\n  Operator,\n  TargetingType,\n  SegmentType,\n  TargetingDataType,\n  EvaluationDataType,\n  MatchTypeCustomData,\n  MatchTypeVariation,\n  TargetingDataItemType,\n} from './types';\nexport {\n  CustomDataCondition,\n  TargetExperimentCondition,\n  ExclusiveExperimentCondition,\n} from './conditions';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,cAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAUA,IAAAE,WAAA,GAAAF,OAAA"}

package/dist/targeting/targetingNode.js

@@ -1,40 +1,48 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.TargetingNode = void 0;
-const conditions_1 = require("./conditions");
-const types_1 = require("./types");
+var _conditions = require("./conditions");
+var _types = require("./types");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 class TargetingNode {
-    constructor(value, left, right) {
-        if (this.isOperator(value)) {
-            this.nodeValue = value;
-        }
-        else {
-            const result = conditions_1.ConditionFactory.createCondition(value);
-            if (result.ok) {
-                this.nodeValue = result.data;
-            }
-            else {
-                this.nodeError = result.error;
-            }
-        }
-        this.leftChild = left;
-        this.rightChild = right;
-    }
-    get value() {
-        return this.nodeValue;
-    }
-    get error() {
-        return this.nodeError;
-    }
-    get left() {
-        return this.leftChild;
-    }
-    get right() {
-        return this.rightChild;
-    }
-    isOperator(value) {
-        return value === types_1.Operator.And || value === types_1.Operator.Or;
+  constructor(value, left, right) {
+    _defineProperty(this, "nodeValue", void 0);
+    _defineProperty(this, "nodeError", void 0);
+    _defineProperty(this, "leftChild", void 0);
+    _defineProperty(this, "rightChild", void 0);
+    if (this.isOperator(value)) {
+      this.nodeValue = value;
+    } else {
+      const result = _conditions.ConditionFactory.createCondition(value);
+      if (result.ok) {
+        this.nodeValue = result.data;
+      } else {
+        this.nodeError = result.error;
+      }
     }
+    this.leftChild = left;
+    this.rightChild = right;
+  }
+  get value() {
+    return this.nodeValue;
+  }
+  get error() {
+    return this.nodeError;
+  }
+  get left() {
+    return this.leftChild;
+  }
+  get right() {
+    return this.rightChild;
+  }
+  isOperator(value) {
+    return value === _types.Operator.And || value === _types.Operator.Or;
+  }
 }
 exports.TargetingNode = TargetingNode;
 //# sourceMappingURL=targetingNode.js.map

package/dist/targeting/targetingNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"targetingNode.js","sourceRoot":"","sources":["../../src/targeting/targetingNode.ts"],"names":[],"mappings":";;;AACA,6CAAmE;AACnE,mCAAkD;AASlD,MAAa,aAAa;IAMxB,YACE,KAAmC,EACnC,IAAqB,EACrB,KAAsB;QAEtB,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE;YAC1B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;SACxB;aAAM;YACL,MAAM,MAAM,GAAG,6BAAgB,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;YAEvD,IAAI,MAAM,CAAC,EAAE,EAAE;gBACb,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;aAC9B;iBAAM;gBACL,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;aAC/B;SACF;QAED,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAEO,UAAU,CAAC,KAAmC;QACpD,OAAO,KAAK,KAAK,gBAAQ,CAAC,GAAG,IAAI,KAAK,KAAK,gBAAQ,CAAC,EAAE,CAAC;IACzD,CAAC;CACF;AA9CD,sCA8CC"}
+{"version":3,"file":"targetingNode.js","names":["_conditions","require","_types","_defineProperty","obj","key","value","_toPropertyKey","Object","defineProperty","enumerable","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","TargetingNode","constructor","left","right","isOperator","nodeValue","result","ConditionFactory","createCondition","ok","data","nodeError","error","leftChild","rightChild","Operator","And","Or","exports"],"sources":["../../src/targeting/targetingNode.ts"],"sourcesContent":["import { KameleoonError } from '../kameleoonError';\nimport { ConditionFactory, ConditionDataType } from './conditions';\nimport { NodeValueType, Operator } from './types';\n\nexport interface ITargetingNode {\n  readonly value?: NodeValueType;\n  readonly left?: ITargetingNode;\n  readonly right?: ITargetingNode;\n  readonly error?: KameleoonError;\n}\n\nexport class TargetingNode implements ITargetingNode {\n  private nodeValue?: NodeValueType;\n  private nodeError?: KameleoonError;\n  private leftChild?: ITargetingNode;\n  private rightChild?: ITargetingNode;\n\n  constructor(\n    value: ConditionDataType | Operator,\n    left?: ITargetingNode,\n    right?: ITargetingNode,\n  ) {\n    if (this.isOperator(value)) {\n      this.nodeValue = value;\n    } else {\n      const result = ConditionFactory.createCondition(value);\n\n      if (result.ok) {\n        this.nodeValue = result.data;\n      } else {\n        this.nodeError = result.error;\n      }\n    }\n\n    this.leftChild = left;\n    this.rightChild = right;\n  }\n\n  get value(): NodeValueType | undefined {\n    return this.nodeValue;\n  }\n\n  get error(): KameleoonError | undefined {\n    return this.nodeError;\n  }\n\n  get left(): ITargetingNode | undefined {\n    return this.leftChild;\n  }\n\n  get right(): ITargetingNode | undefined {\n    return this.rightChild;\n  }\n\n  private isOperator(value: ConditionDataType | Operator): value is Operator {\n    return value === Operator.And || value === Operator.Or;\n  }\n}\n"],"mappings":";;;;;;AACA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAAkD,SAAAE,gBAAAC,GAAA,EAAAC,GAAA,EAAAC,KAAA,IAAAD,GAAA,GAAAE,cAAA,CAAAF,GAAA,OAAAA,GAAA,IAAAD,GAAA,IAAAI,MAAA,CAAAC,cAAA,CAAAL,GAAA,EAAAC,GAAA,IAAAC,KAAA,EAAAA,KAAA,EAAAI,UAAA,QAAAC,YAAA,QAAAC,QAAA,oBAAAR,GAAA,CAAAC,GAAA,IAAAC,KAAA,WAAAF,GAAA;AAAA,SAAAG,eAAAM,GAAA,QAAAR,GAAA,GAAAS,YAAA,CAAAD,GAAA,2BAAAR,GAAA,gBAAAA,GAAA,GAAAU,MAAA,CAAAV,GAAA;AAAA,SAAAS,aAAAE,KAAA,EAAAC,IAAA,eAAAD,KAAA,iBAAAA,KAAA,kBAAAA,KAAA,MAAAE,IAAA,GAAAF,KAAA,CAAAG,MAAA,CAAAC,WAAA,OAAAF,IAAA,KAAAG,SAAA,QAAAC,GAAA,GAAAJ,IAAA,CAAAK,IAAA,CAAAP,KAAA,EAAAC,IAAA,2BAAAK,GAAA,sBAAAA,GAAA,YAAAE,SAAA,4DAAAP,IAAA,gBAAAF,MAAA,GAAAU,MAAA,EAAAT,KAAA;AAS3C,MAAMU,aAAa,CAA2B;EAMnDC,WAAWA,CACTrB,KAAmC,EACnCsB,IAAqB,EACrBC,KAAsB,EACtB;IAAA1B,eAAA;IAAAA,eAAA;IAAAA,eAAA;IAAAA,eAAA;IACA,IAAI,IAAI,CAAC2B,UAAU,CAACxB,KAAK,CAAC,EAAE;MAC1B,IAAI,CAACyB,SAAS,GAAGzB,KAAK;IACxB,CAAC,MAAM;MACL,MAAM0B,MAAM,GAAGC,4BAAgB,CAACC,eAAe,CAAC5B,KAAK,CAAC;MAEtD,IAAI0B,MAAM,CAACG,EAAE,EAAE;QACb,IAAI,CAACJ,SAAS,GAAGC,MAAM,CAACI,IAAI;MAC9B,CAAC,MAAM;QACL,IAAI,CAACC,SAAS,GAAGL,MAAM,CAACM,KAAK;MAC/B;IACF;IAEA,IAAI,CAACC,SAAS,GAAGX,IAAI;IACrB,IAAI,CAACY,UAAU,GAAGX,KAAK;EACzB;EAEA,IAAIvB,KAAKA,CAAA,EAA8B;IACrC,OAAO,IAAI,CAACyB,SAAS;EACvB;EAEA,IAAIO,KAAKA,CAAA,EAA+B;IACtC,OAAO,IAAI,CAACD,SAAS;EACvB;EAEA,IAAIT,IAAIA,CAAA,EAA+B;IACrC,OAAO,IAAI,CAACW,SAAS;EACvB;EAEA,IAAIV,KAAKA,CAAA,EAA+B;IACtC,OAAO,IAAI,CAACW,UAAU;EACxB;EAEQV,UAAUA,CAACxB,KAAmC,EAAqB;IACzE,OAAOA,KAAK,KAAKmC,eAAQ,CAACC,GAAG,IAAIpC,KAAK,KAAKmC,eAAQ,CAACE,EAAE;EACxD;AACF;AAACC,OAAA,CAAAlB,aAAA,GAAAA,aAAA"}

package/dist/targeting/targetingTree.js

@@ -1,115 +1,136 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.TargetingTree = void 0;
-const ts_res_1 = require("ts-res");
-const targetingNode_1 = require("./targetingNode");
-const types_1 = require("./types");
+var _tsRes = require("ts-res");
+var _targetingNode = require("./targetingNode");
+var _types = require("./types");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 class TargetingTree {
-    constructor(segment) {
-        this.error = null;
-        const { conditions, operators } = this.flattenSegment(segment);
-        const nodes = conditions.map((condition) => new targetingNode_1.TargetingNode(condition));
-        // --- Note ---
-        // - Targeting tree is built bottom-up, it's the only way to both get the consistent logic
-        // (grouping nested conditions) and have human readable tree representation.
-        // - Here is an example of how tree is built (we use strict complete binary tree)
-        // Let's say we have such a condition `value < 10 || value > 20 && value < 30`
-        // Code-wise it looks as follows (this is not real code, real tree is more complicated and can have more
-        // levels of deeply nested conditions):
-        //
-        // `const operators = [Operator.Or, Operator.And]`
-        // `const conditions = [
-        //     {type: Condition.Less, value: 10},
-        //     {type: Condition.Greater, value: 20},
-        //     {type: Condition.Less, value: 30},
-        // ]`
-        //
-        // After the first iteration we have node like this:
-        //    AND
-        //   /   \
-        //  <30  >20
-        //
-        // After the second iteration tree looks as follows:
-        //         OR
-        //        /  \
-        //    AND    <10
-        //   /   \
-        //  <30  >20
-        // As you can see Leaf Nodes contain conditions and Non-Leaf Nodes contain logical operators
-        for (const operator of operators) {
-            const left = nodes.shift();
-            const right = nodes.shift();
-            nodes.unshift(new targetingNode_1.TargetingNode(operator, left, right));
-        }
-        // --- Note ---
-        // It's guaranteed that only one root node will remain after iterations
-        // (as soon as the backend `operators-conditions` relation doesn't change)
-        this.tree = nodes[0];
+  constructor(segment) {
+    _defineProperty(this, "tree", void 0);
+    _defineProperty(this, "error", null);
+    const {
+      conditions,
+      operators
+    } = this.flattenSegment(segment);
+    const nodes = conditions.map(condition => new _targetingNode.TargetingNode(condition));
+
+    // --- Note ---
+    // - Targeting tree is built bottom-up, it's the only way to both get the consistent logic
+    // (grouping nested conditions) and have human readable tree representation.
+    // - Here is an example of how tree is built (we use strict complete binary tree)
+    // Let's say we have such a condition `value < 10 || value > 20 && value < 30`
+    // Code-wise it looks as follows (this is not real code, real tree is more complicated and can have more
+    // levels of deeply nested conditions):
+    //
+    // `const operators = [Operator.Or, Operator.And]`
+    // `const conditions = [
+    //     {type: Condition.Less, value: 10},
+    //     {type: Condition.Greater, value: 20},
+    //     {type: Condition.Less, value: 30},
+    // ]`
+    //
+    // After the first iteration we have node like this:
+    //    AND
+    //   /   \
+    //  <30  >20
+    //
+    // After the second iteration tree looks as follows:
+    //         OR
+    //        /  \
+    //    AND    <10
+    //   /   \
+    //  <30  >20
+    // As you can see Leaf Nodes contain conditions and Non-Leaf Nodes contain logical operators
+    for (const operator of operators) {
+      const left = nodes.shift();
+      const right = nodes.shift();
+      nodes.unshift(new _targetingNode.TargetingNode(operator, left, right));
     }
-    evaluate(data) {
-        const result = this.evaluateNode(this.tree, data);
-        if (this.error) {
-            return (0, ts_res_1.Err)(this.error);
-        }
-        return (0, ts_res_1.Ok)(result);
+
+    // --- Note ---
+    // It's guaranteed that only one root node will remain after iterations
+    // (as soon as the backend `operators-conditions` relation doesn't change)
+    this.tree = nodes[0];
+  }
+  evaluate(data) {
+    const result = this.evaluateNode(this.tree, data);
+    if (this.error) {
+      return (0, _tsRes.Err)(this.error);
     }
-    evaluateNode(node, data) {
-        if (this.isLeafNode(node)) {
-            if (node.error) {
-                this.error = node.error;
-                return false;
-            }
-            const result = node.value.evaluate(data);
-            if (!result.ok) {
-                this.error = result.error;
-                return false;
-            }
-            return result.data;
-        }
-        if (this.isNonLeafNode(node)) {
-            switch (node.value) {
-                case types_1.Operator.And: {
-                    return (this.evaluateNode(node.left, data) &&
-                        this.evaluateNode(node.right, data));
-                }
-                case types_1.Operator.Or: {
-                    return (this.evaluateNode(node.left, data) ||
-                        this.evaluateNode(node.right, data));
-                }
-                default:
-                    break;
-            }
-        }
+    return (0, _tsRes.Ok)(result);
+  }
+  evaluateNode(node, data) {
+    if (this.isLeafNode(node)) {
+      if (node.error) {
+        // --- Note ---
+        // Non-existing condition should not break targeting tree
+        // instead it should be treated as `false` condition
         return false;
+      }
+      const result = node.value.evaluate(data);
+      if (!result.ok) {
+        this.error = result.error;
+        return false;
+      }
+      return result.data;
     }
-    isLeafNode(node) {
-        return !Boolean(node.left && node.right);
-    }
-    isNonLeafNode(node) {
-        return Boolean(node.left &&
-            node.right &&
-            (node.value === types_1.Operator.Or || node.value === types_1.Operator.And));
-    }
-    flattenSegment(segment) {
-        const { firstLevel: conditions, firstLevelOrOperators: operators } = segment.conditionsData;
-        const resultOperators = [...operators];
-        const resultConditions = [];
-        conditions.forEach((condition) => {
-            const { conditions: conditionList, orOperators } = condition;
-            // --- Note ---
-            // if `condition` has nested conditions and operators in it, they go to the
-            // beginning of list, otherwise we just add it to the end
-            if (orOperators.length) {
-                orOperators.forEach((item) => resultOperators.unshift(item));
-                conditionList.forEach((item) => resultConditions.unshift(item));
-            }
-            else {
-                conditionList.forEach((item) => resultConditions.push(item));
-            }
-        });
-        const convertedOperators = resultOperators.map((operator) => operator ? types_1.Operator.Or : types_1.Operator.And);
-        return { conditions: resultConditions, operators: convertedOperators };
+    if (this.isNonLeafNode(node)) {
+      switch (node.value) {
+        case _types.Operator.And:
+          {
+            return this.evaluateNode(node.left, data) && this.evaluateNode(node.right, data);
+          }
+        case _types.Operator.Or:
+          {
+            return this.evaluateNode(node.left, data) || this.evaluateNode(node.right, data);
+          }
+        default:
+          break;
+      }
     }
+    return false;
+  }
+  isLeafNode(node) {
+    return !Boolean(node.left && node.right);
+  }
+  isNonLeafNode(node) {
+    return Boolean(node.left && node.right && (node.value === _types.Operator.Or || node.value === _types.Operator.And));
+  }
+  flattenSegment(segment) {
+    const {
+      firstLevel: conditions,
+      firstLevelOrOperators: operators
+    } = segment.conditionsData;
+    const resultOperators = [...operators];
+    const resultConditions = [];
+    conditions.forEach(condition => {
+      const {
+        conditions: conditionList,
+        orOperators
+      } = condition;
+
+      // --- Note ---
+      // if `condition` has nested conditions and operators in it, they go to the
+      // beginning of list, otherwise we just add it to the end
+      if (orOperators.length) {
+        orOperators.forEach(item => resultOperators.unshift(item));
+        conditionList.forEach(item => resultConditions.unshift(item));
+      } else {
+        conditionList.forEach(item => resultConditions.push(item));
+      }
+    });
+    const convertedOperators = resultOperators.map(operator => operator ? _types.Operator.Or : _types.Operator.And);
+    return {
+      conditions: resultConditions,
+      operators: convertedOperators
+    };
+  }
 }
 exports.TargetingTree = TargetingTree;
 //# sourceMappingURL=targetingTree.js.map

package/dist/targeting/targetingTree.js.map

@@ -1 +1 @@
-{"version":3,"file":"targetingTree.js","sourceRoot":"","sources":["../../src/targeting/targetingTree.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"targetingTree.js","names":["_tsRes","require","_targetingNode","_types","_defineProperty","obj","key","value","_toPropertyKey","Object","defineProperty","enumerable","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","TargetingTree","constructor","segment","conditions","operators","flattenSegment","nodes","map","condition","TargetingNode","operator","left","shift","right","unshift","tree","evaluate","data","result","evaluateNode","error","Err","Ok","node","isLeafNode","ok","isNonLeafNode","Operator","And","Or","Boolean","firstLevel","firstLevelOrOperators","conditionsData","resultOperators","resultConditions","forEach","conditionList","orOperators","length","item","push","convertedOperators","exports"],"sources":["../../src/targeting/targetingTree.ts"],"sourcesContent":["import { Result, Ok, Err } from 'ts-res';\nimport { KameleoonError } from '../kameleoonError';\nimport { ConditionDataType } from './conditions';\nimport { ITargetingNode, TargetingNode } from './targetingNode';\nimport {\n  EvaluationDataType,\n  FlatSegmentType,\n  LeafNodeType,\n  NonLeafNodeType,\n  Operator,\n  SegmentType,\n} from './types';\n\ninterface ITargetingTree {\n  evaluate: (data: EvaluationDataType) => Result<boolean, KameleoonError>;\n}\n\nexport class TargetingTree implements ITargetingTree {\n  private tree: TargetingNode;\n  private error: KameleoonError | null = null;\n\n  constructor(segment: SegmentType) {\n    const { conditions, operators } = this.flattenSegment(segment);\n    const nodes = conditions.map((condition) => new TargetingNode(condition));\n\n    // --- Note ---\n    // - Targeting tree is built bottom-up, it's the only way to both get the consistent logic\n    // (grouping nested conditions) and have human readable tree representation.\n    // - Here is an example of how tree is built (we use strict complete binary tree)\n    // Let's say we have such a condition `value < 10 || value > 20 && value < 30`\n    // Code-wise it looks as follows (this is not real code, real tree is more complicated and can have more\n    // levels of deeply nested conditions):\n    //\n    // `const operators = [Operator.Or, Operator.And]`\n    // `const conditions = [\n    //     {type: Condition.Less, value: 10},\n    //     {type: Condition.Greater, value: 20},\n    //     {type: Condition.Less, value: 30},\n    // ]`\n    //\n    // After the first iteration we have node like this:\n    //    AND\n    //   /   \\\n    //  <30  >20\n    //\n    // After the second iteration tree looks as follows:\n    //         OR\n    //        /  \\\n    //    AND    <10\n    //   /   \\\n    //  <30  >20\n    // As you can see Leaf Nodes contain conditions and Non-Leaf Nodes contain logical operators\n    for (const operator of operators) {\n      const left = nodes.shift();\n      const right = nodes.shift();\n\n      nodes.unshift(new TargetingNode(operator, left, right));\n    }\n\n    // --- Note ---\n    // It's guaranteed that only one root node will remain after iterations\n    // (as soon as the backend `operators-conditions` relation doesn't change)\n    this.tree = nodes[0];\n  }\n\n  public evaluate(data: EvaluationDataType): Result<boolean, KameleoonError> {\n    const result = this.evaluateNode(this.tree, data);\n\n    if (this.error) {\n      return Err(this.error);\n    }\n\n    return Ok(result);\n  }\n\n  private evaluateNode(node: TargetingNode, data: EvaluationDataType): boolean {\n    if (this.isLeafNode(node)) {\n      if (node.error) {\n        // --- Note ---\n        // Non-existing condition should not break targeting tree\n        // instead it should be treated as `false` condition\n        return false;\n      }\n\n      const result = node.value.evaluate(data);\n\n      if (!result.ok) {\n        this.error = result.error;\n\n        return false;\n      }\n\n      return result.data;\n    }\n\n    if (this.isNonLeafNode(node)) {\n      switch (node.value) {\n        case Operator.And: {\n          return (\n            this.evaluateNode(node.left, data) &&\n            this.evaluateNode(node.right, data)\n          );\n        }\n        case Operator.Or: {\n          return (\n            this.evaluateNode(node.left, data) ||\n            this.evaluateNode(node.right, data)\n          );\n        }\n        default:\n          break;\n      }\n    }\n\n    return false;\n  }\n\n  private isLeafNode(node: ITargetingNode): node is LeafNodeType {\n    return !Boolean(node.left && node.right);\n  }\n\n  private isNonLeafNode(node: ITargetingNode): node is NonLeafNodeType {\n    return Boolean(\n      node.left &&\n        node.right &&\n        (node.value === Operator.Or || node.value === Operator.And),\n    );\n  }\n\n  private flattenSegment(segment: SegmentType): FlatSegmentType {\n    const { firstLevel: conditions, firstLevelOrOperators: operators } =\n      segment.conditionsData;\n\n    const resultOperators: boolean[] = [...operators];\n    const resultConditions: ConditionDataType[] = [];\n\n    conditions.forEach((condition) => {\n      const { conditions: conditionList, orOperators } = condition;\n\n      // --- Note ---\n      // if `condition` has nested conditions and operators in it, they go to the\n      // beginning of list, otherwise we just add it to the end\n      if (orOperators.length) {\n        orOperators.forEach((item) => resultOperators.unshift(item));\n        conditionList.forEach((item) => resultConditions.unshift(item));\n      } else {\n        conditionList.forEach((item) => resultConditions.push(item));\n      }\n    });\n\n    const convertedOperators = resultOperators.map((operator) =>\n      operator ? Operator.Or : Operator.And,\n    );\n\n    return { conditions: resultConditions, operators: convertedOperators };\n  }\n}\n"],"mappings":"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"}