@degenerate/rules 0.1.2 → 0.1.3

package/dist/rules/src/evaluation/check-if-proposal-is-valid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-if-proposal-is-valid.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/check-if-proposal-is-valid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAElE;;;;;;GAMG;AACH,QAAA,MAAM,sBAAsB,wBACH,MAAM,gBACb,2BAA2B,EAAE,KAC5C,OAGF,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/boolean-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/boolean-conditions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAmB,MAAM,qBAAqB,CAAC;AAEpG;;;;;;;GAOG;AACH,QAAA,MAAM,mBAAmB,cAAe,OAAO,iBAAiB,oBAAoB,0BACxD,sBAAsB,KAAG,OAYpD,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/contains-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contains-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/contains-conditions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,cAAe,MAAM,GAAG,MAAM,kBAAkB,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,0BAC1E,sBAAsB,KAAG,OAUpD,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/empty-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/empty-conditions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAiB,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE5E;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,cAAe,OAAO,0BAA0B,sBAAsB,KAAG,OAQ/F,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/equality-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/equality-conditions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;;;;;;GAOG;AACH,QAAA,MAAM,oBAAoB,cAAe,OAAO,kBAAkB,OAAO,0BAC7C,sBAAsB,KAAG,OAIpD,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/null-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/null-conditions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;;;;;;GAOG;AACH,QAAA,MAAM,gBAAgB,cAAe,GAAG,0BAA0B,sBAAsB,KAAG,OAI1F,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/range-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/range-conditions.ts"],"names":[],"mappings":"AACA;;GAEG;AAEH,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEjF;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,cAAe,MAAM,GAAG,MAAM,kBAAkB,MAAM,GAAG,MAAM,iBACnE,kBAAkB,0BAA0B,sBAAsB,KAAG,OAsBvF,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/special-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"special-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/special-conditions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAkD,MAAM,qBAAqB,CAAC;AAEnI;;;;;;;GAOG;AACH,QAAA,MAAM,mBAAmB,cAAe,OAAO,kBAAkB,OAAO,iBACrD,oBAAoB,0BAA0B,sBAAsB,KAAG,OAiBzF,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/starts-end-with-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starts-end-with-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/starts-end-with-conditions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAEH,sBAAsB,EACtB,2BAA2B,EAI9B,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;GAQG;AACH,QAAA,MAAM,wBAAwB,cAAe,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,kBAAkB,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,iBACtH,2BAA2B,0BAA0B,sBAAsB,KAAG,OAiBhG,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/typeof-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeof-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/typeof-conditions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE9E;;;;;;;;GAQG;AACH,QAAA,MAAM,kBAAkB,cAAe,OAAO,eAAe,eAAe,0BAChD,sBAAsB,KAAG,OAGpD,CAAC;AAsCF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/rules/src/evaluation/determine-if-data-has-changed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"determine-if-data-has-changed.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/determine-if-data-has-changed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB,YAAa,UAAU,WAAW,UAAU,KAAG,OAE7E,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/rules/src/evaluation/evaluate-rule-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-rule-conditions.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/evaluate-rule-conditions.ts"],"names":[],"mappings":"AACA,OAAO,EAMH,UAAU,EACV,aAAa,EAChB,MAAM,qBAAqB,CAAC;AAW7B;;;;;GAKG;AACH,QAAA,MAAM,sBAAsB,iBAAkB,aAAa,aAAa,UAAU,KAAG,OA+BpF,CAAC;AAGF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/rules/src/evaluation/evaluate-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-rule.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/evaluate-rule.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAG/F;;;;;;;;GAQG;AACH,QAAA,MAAM,YAAY,SACR,iBAAiB,oBACL,UAAU,qBACT,UAAU,wBAE9B,yBAmCF,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/rules/src/evaluation/evaluate-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-rules.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/evaluate-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,2BAA2B,EAA6B,MAAM,qBAAqB,CAAC;AAG5H;;;;;;;GAOG;AACH,QAAA,MAAM,aAAa,cACJ,MAAM,gBACH,iBAAiB,EAAE,oBACf,UAAU,qBACT,UAAU,wBAE9B,2BA2BF,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/rules/src/evaluation/get-data-changed-information.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-data-changed-information.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/get-data-changed-information.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGjD;;;;;;GAMG;AACH,QAAA,MAAM,0BAA0B,qBAAsB,UAAU,qBACzC,UAAU,KAAG,MAAM,EAsBzC,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/rules/src/evaluation/get-root-property-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-root-property-results.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/get-root-property-results.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAGjG;;;;;;;;;GASG;AACH,QAAA,MAAM,sBAAsB,4BACC,MAAM,EAAE,gBACnB,iBAAiB,EAAE,oBACf,UAAU,qBACT,UAAU,wBAE9B,2BAA2B,EAa7B,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/rules/src/evaluation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/index.ts"],"names":[],"mappings":"AAEA,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gCAAgC,CAAC;AAI/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iBAAiB,CAAC;AAChC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC"}

package/dist/rules/src/evaluation/start-rule-evaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-rule-evaluation.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/start-rule-evaluation.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,sBAAsB,EAGzB,MAAM,qBAAqB,CAAC;AAO7B;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,gBACR,MAAM,qBACA,cAAc,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,GAAG,CAAC,sBAChD,cAAc,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,GAAG,CAAC,EAAE,gBACzD,iBAAiB,EAAE,oBACf,UAAU,qBACT,UAAU,wBAE9B,sBA4BF,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/rules/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-base.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This function validates the base condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionBase: (incomingObject: unknown) => void;
+export { validateConditionBase };
+//# sourceMappingURL=validate-condition-base.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-base.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-base.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,QAAA,MAAM,qBAAqB,mBAAoB,OAAO,KAAG,IAoBxD,CAAA;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-base.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionBase = void 0;
+const src_1 = require("@degenerate/generic/src");
+const validate_condition_qualifier_1 = require("./validate-condition-qualifier");
+/**
+ * This function validates the base condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+const validateConditionBase = (incomingObject) => {
+    if (typeof incomingObject !== 'object' || incomingObject === null) {
+        throw new src_1.SafeRuleConditionNotObjectError(incomingObject);
+    }
+    if (!('conditionType' in incomingObject)) {
+        throw new src_1.SafeRuleConditionPropertyMissingError('conditionType');
+    }
+    if (!('conditionTypeQualifier' in incomingObject)) {
+        throw new src_1.SafeRuleConditionPropertyMissingError('conditionTypeQualifier');
+    }
+    // make sure the condition type qualifier is in the basic condition
+    (0, validate_condition_qualifier_1.validateConditionQualifier)(incomingObject['conditionTypeQualifier']);
+    if (!('targettedProperty' in incomingObject && typeof incomingObject['targettedProperty'] === 'string')) {
+        throw new src_1.SafeRuleConditionPropertyMissingError('targettedProperty');
+    }
+    return;
+};
+exports.validateConditionBase = validateConditionBase;

package/dist/rules/src/validation/conditions/validate-condition-boolean.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * This function validates the boolean condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionBoolean: (incomingObject: ICondition) => void;
+export { validateConditionBoolean };
+//# sourceMappingURL=validate-condition-boolean.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-boolean.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtF;;;;;GAKG;AACH,QAAA,MAAM,wBAAwB,mBAAoB,UAAU,KAAG,IAa9D,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-boolean.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionBoolean = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * This function validates the boolean condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+const validateConditionBoolean = (incomingObject) => {
+    // make sure there are 3 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 3) {
+        throw new src_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 3, totalProperties);
+    }
+    if (incomingObject['conditionType'] === generic_1.ConditionTypeBoolean.FALSE ||
+        incomingObject['conditionType'] === generic_1.ConditionTypeBoolean.TRUE) {
+        return;
+    }
+    else {
+        throw new src_1.SafeRuleConditionNotTypeOfError('false or true', incomingObject['conditionType']);
+    }
+};
+exports.validateConditionBoolean = validateConditionBoolean;

package/dist/rules/src/validation/conditions/validate-condition-contains.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * This function validates the contains condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionContains: (incomingObject: ICondition) => void;
+export { validateConditionContains };
+//# sourceMappingURL=validate-condition-contains.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-contains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-contains.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-contains.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,UAAU,EAEb,MAAM,qBAAqB,CAAC;AAS7B;;;;;GAKG;AACH,QAAA,MAAM,yBAAyB,mBAAoB,UAAU,KAAG,IAkC/D,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-contains.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionContains = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * This function validates the contains condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+const validateConditionContains = (incomingObject) => {
+    // make sure there are 4 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 4) {
+        throw new src_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 4, totalProperties);
+    }
+    if (incomingObject['conditionType'] !== src_1.ConditionTypeSingle.CONTAINS) {
+        throw new src_1.SafeRuleConditionNotTypeOfError(src_1.ConditionTypeSingle.CONTAINS, incomingObject['conditionType']);
+    }
+    if (!('conditionValue' in incomingObject)) {
+        throw new src_1.SafeRuleConditionPropertyMissingError('conditionValue');
+    }
+    // make sure the condition value is a string or an array of strings
+    if (typeof incomingObject['conditionValue'] === 'string') {
+        return;
+    }
+    else {
+        if (!(0, generic_1.validateArray)(incomingObject['conditionValue'])) {
+            throw new src_1.SafeRuleConditionValueWrongType(incomingObject['conditionValue'], 'string or array of strings');
+        }
+        else {
+            // make sure all items in the array are strings
+            if ((0, generic_1.checkIfAllItemsInAnArrayAreSameType)(incomingObject['conditionValue'], 'string')) {
+                return;
+            }
+            if ((0, generic_1.checkIfAllItemsInAnArrayAreSameType)(incomingObject['conditionValue'], 'number')) {
+                return;
+            }
+            throw new src_1.SafeRuleConditionValueWrongType(incomingObject['conditionValue'], 'Values in array are not all strings or numbers');
+        }
+    }
+};
+exports.validateConditionContains = validateConditionContains;

package/dist/rules/src/validation/conditions/validate-condition-empty.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * This function validates the empty condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionEmpty: (incomingObject: ICondition) => void;
+export { validateConditionEmpty };
+//# sourceMappingURL=validate-condition-empty.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-empty.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-empty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtE;;;;;GAKG;AACH,QAAA,MAAM,sBAAsB,mBAAoB,UAAU,SAYzD,CAAA;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-empty.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionEmpty = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * This function validates the empty condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+const validateConditionEmpty = (incomingObject) => {
+    // make sure there are 3 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 3) {
+        throw new src_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 3, totalProperties);
+    }
+    if (incomingObject['conditionType'] !== generic_1.ConditionTypeSingle.EMPTY) {
+        throw new src_1.SafeRuleConditionNotTypeOfError(generic_1.ConditionTypeSingle.EMPTY, incomingObject['conditionType']);
+    }
+    return;
+};
+exports.validateConditionEmpty = validateConditionEmpty;

package/dist/rules/src/validation/conditions/validate-condition-equality.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * This function validates the equality condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionEquality: (incomingObject: ICondition) => void;
+export { validateConditionEquality };
+//# sourceMappingURL=validate-condition-equality.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-equality.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-equality.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,UAAU,EACb,MAAM,qBAAqB,CAAC;AAO7B;;;;;GAKG;AACH,QAAA,MAAM,yBAAyB,mBAAoB,UAAU,KAAG,IAgB/D,CAAA;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-equality.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionEquality = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * This function validates the equality condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+const validateConditionEquality = (incomingObject) => {
+    // make sure there are 4 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 4) {
+        throw new src_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 4, totalProperties);
+    }
+    if (incomingObject['conditionType'] !== generic_1.ConditionTypeSingle.EQUAL) {
+        throw new src_1.SafeRuleConditionNotTypeOfError(generic_1.ConditionTypeSingle.EQUAL, incomingObject['conditionType']);
+    }
+    if (!('conditionValue' in incomingObject)) {
+        throw new src_1.SafeRuleConditionPropertyMissingError('conditionValue');
+    }
+    return;
+};
+exports.validateConditionEquality = validateConditionEquality;

package/dist/rules/src/validation/conditions/validate-condition-null.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * This function validates the null condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionNull: (incomingObject: ICondition) => void;
+export { validateConditionNull };
+//# sourceMappingURL=validate-condition-null.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-null.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-null.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-null.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtE;;;;;GAKG;AACH,QAAA,MAAM,qBAAqB,mBAAoB,UAAU,KAAG,IAY3D,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-null.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionNull = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * This function validates the null condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+const validateConditionNull = (incomingObject) => {
+    // make sure there are 3 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 3) {
+        throw new src_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 3, totalProperties);
+    }
+    if (incomingObject['conditionType'] !== generic_1.ConditionTypeSingle.NULL) {
+        throw new src_1.SafeRuleConditionNotTypeOfError(generic_1.ConditionTypeSingle.NULL, incomingObject['conditionType']);
+    }
+    return;
+};
+exports.validateConditionNull = validateConditionNull;

package/dist/rules/src/validation/conditions/validate-condition-qualifier.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This function validates the condition type qualifier.
+ *
+ * @param conditionTypeQualifier the condition type qualifier to validate
+ * @returns
+ */
+declare const validateConditionQualifier: (conditionTypeQualifier: unknown) => void;
+export { validateConditionQualifier };
+//# sourceMappingURL=validate-condition-qualifier.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-qualifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-qualifier.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-qualifier.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,QAAA,MAAM,0BAA0B,2BAA4B,OAAO,KAAG,IAOrE,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-qualifier.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionQualifier = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * This function validates the condition type qualifier.
+ *
+ * @param conditionTypeQualifier the condition type qualifier to validate
+ * @returns
+ */
+const validateConditionQualifier = (conditionTypeQualifier) => {
+    const containsConditionQualifier = Object.values(generic_1.ConditionTypeQualifier).includes(conditionTypeQualifier);
+    if (!containsConditionQualifier) {
+        throw new src_1.SafeRuleConditionQualifierError(conditionTypeQualifier);
+    }
+    return;
+};
+exports.validateConditionQualifier = validateConditionQualifier;

package/dist/rules/src/validation/conditions/validate-condition-range.d.ts

@@ -0,0 +1,9 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * The function validates the range condition.
+ * @param incomingObject
+ * @returns
+ */
+declare const validateConditionRange: (incomingObject: ICondition) => void;
+export { validateConditionRange };
+//# sourceMappingURL=validate-condition-range.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-range.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-range.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGpF;;;;GAIG;AACH,QAAA,MAAM,sBAAsB,mBAAoB,UAAU,KAAG,IA+B5D,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-range.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionRange = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * The function validates the range condition.
+ * @param incomingObject
+ * @returns
+ */
+const validateConditionRange = (incomingObject) => {
+    // make sure there are 4 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 4) {
+        throw new src_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 4, totalProperties);
+    }
+    if (!(incomingObject['conditionType'] === generic_1.ConditionTypeRange.GREATER_THAN ||
+        incomingObject['conditionType'] === generic_1.ConditionTypeRange.GREATER_THAN_OR_EQUAL ||
+        incomingObject['conditionType'] === generic_1.ConditionTypeRange.LESS_THAN ||
+        incomingObject['conditionType'] === generic_1.ConditionTypeRange.LESS_THAN_OR_EQUAL)) {
+        throw new src_1.SafeRuleConditionNotTypeOfError('greater than or | greater than or equal | less than | less than or equal', incomingObject['conditionType']);
+    }
+    if (!('conditionValue' in incomingObject)) {
+        throw new src_1.SafeRuleConditionPropertyMissingError('conditionValue');
+    }
+    // make sure the condition value is a string or number
+    if (typeof incomingObject['conditionValue'] === 'string') {
+        return;
+    }
+    if (typeof incomingObject['conditionValue'] === 'number') {
+        return;
+    }
+    throw new src_1.SafeRuleConditionValueWrongType(incomingObject['conditionValue'], 'string or number');
+};
+exports.validateConditionRange = validateConditionRange;

package/dist/rules/src/validation/conditions/validate-condition-share-rule.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * This validates the condition to be a type of a share rule.
+ *
+ * @param incomingObject the object to validate as a share rule condition
+ * @returns
+ */
+declare const validateConditionShareRule: (incomingObject: ICondition) => void;
+export { validateConditionShareRule };
+//# sourceMappingURL=validate-condition-share-rule.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-share-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-share-rule.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-share-rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,UAAU,EAKb,MAAM,qBAAqB,CAAC;AAG7B;;;;;GAKG;AACH,QAAA,MAAM,0BAA0B,mBAAoB,UAAU,KAAG,IA0BhE,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-share-rule.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionShareRule = void 0;
+const generic_1 = require("@degenerate/generic");
+const validate_share_rule_1 = require("../validate-share-rule");
+/**
+ * This validates the condition to be a type of a share rule.
+ *
+ * @param incomingObject the object to validate as a share rule condition
+ * @returns
+ */
+const validateConditionShareRule = (incomingObject) => {
+    // make sure there are 4 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 4) {
+        throw new generic_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 4, totalProperties);
+    }
+    if (incomingObject['conditionType'] !== generic_1.ConditionTypeSingle.SHARE_RULE) {
+        throw new generic_1.SafeRuleConditionNotTypeOfError(generic_1.ConditionTypeSingle.SHARE_RULE, incomingObject['conditionType']);
+    }
+    if (!('conditionValue' in incomingObject)) {
+        throw new generic_1.SafeRuleConditionPropertyMissingError('conditionValue');
+    }
+    // make sure the condition value is an object that is not null
+    if (typeof incomingObject['conditionValue'] === 'object' &&
+        incomingObject['conditionValue'] !== null) {
+        (0, validate_share_rule_1.validateShareRule)(incomingObject['conditionValue']);
+        return;
+    }
+    else {
+        throw new generic_1.SafeRuleConditionValueWrongType(incomingObject['conditionValue'], 'object');
+    }
+};
+exports.validateConditionShareRule = validateConditionShareRule;

package/dist/rules/src/validation/conditions/validate-condition-special.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * This function validates the special condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionSpecial: (incomingObject: ICondition) => void;
+export { validateConditionSpecial };
+//# sourceMappingURL=validate-condition-special.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-special.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-special.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-special.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAInH;;;;;GAKG;AACH,QAAA,MAAM,wBAAwB,mBAAoB,UAAU,KAAG,IAwB9D,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-special.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionSpecial = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * This function validates the special condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+const validateConditionSpecial = (incomingObject) => {
+    // make sure there are 4 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 4) {
+        throw new src_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 4, totalProperties);
+    }
+    if (!(incomingObject['conditionType'] === generic_1.ConditionTypeSpecial.PATTERN)) {
+        throw new src_1.SafeRuleConditionNotTypeOfError('condition type is not pattern', incomingObject['conditionType']);
+    }
+    if (!('conditionValue' in incomingObject)) {
+        throw new src_1.SafeRuleConditionPropertyMissingError('conditionValue');
+    }
+    // make sure the condition value is a string or number
+    if (typeof incomingObject['conditionValue'] !== 'string') {
+        throw new src_1.SafeRuleConditionValueWrongType(incomingObject['conditionValue'], 'string');
+    }
+    return;
+};
+exports.validateConditionSpecial = validateConditionSpecial;

package/dist/rules/src/validation/conditions/validate-condition-starts-ends-with.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * This function validates the starts or ends with condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionStartsEndsWith: (incomingObject: ICondition) => void;
+export { validateConditionStartsEndsWith };
+//# sourceMappingURL=validate-condition-starts-ends-with.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-starts-ends-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-starts-ends-with.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-starts-ends-with.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAI7F;;;;;GAKG;AACH,QAAA,MAAM,+BAA+B,mBAAoB,UAAU,KAAG,IAyBrE,CAAC;AAEF,OAAO,EAAE,+BAA+B,EAAE,CAAC"}

package/dist/rules/src/validation/conditions/validate-condition-starts-ends-with.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConditionStartsEndsWith = void 0;
+const generic_1 = require("@degenerate/generic");
+const src_1 = require("@degenerate/generic/src");
+/**
+ * This function validates the starts or ends with condition.
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+const validateConditionStartsEndsWith = (incomingObject) => {
+    // make sure there are 4 properties only
+    const totalProperties = Object.keys(incomingObject).length;
+    if (totalProperties !== 4) {
+        throw new src_1.SafeRuleConditionHasMismatchingProperties(incomingObject, 4, totalProperties);
+    }
+    if (!(incomingObject['conditionType'] === generic_1.ConditionTypeStartsEndsWith.ENDS_WITH ||
+        incomingObject['conditionType'] === generic_1.ConditionTypeStartsEndsWith.STARTS_WITH)) {
+        throw new src_1.SafeRuleConditionNotTypeOfError('starts or endwith not set as condition type', incomingObject['conditionType']);
+    }
+    if (!('conditionValue' in incomingObject)) {
+        throw new src_1.SafeRuleConditionPropertyMissingError('conditionValue');
+    }
+    // make sure the condition value is a string or number
+    if (typeof incomingObject['conditionValue'] !== 'string') {
+        throw new src_1.SafeRuleConditionValueWrongType(incomingObject['conditionValue'], 'string');
+    }
+    return;
+};
+exports.validateConditionStartsEndsWith = validateConditionStartsEndsWith;

package/dist/rules/src/validation/conditions/validate-condition-type-of.d.ts

@@ -0,0 +1,10 @@
+import { ICondition } from '@degenerate/generic';
+/**
+ * this validates that the type of condition is correct
+ *
+ * @param incomingObject the object to validate
+ * @returns
+ */
+declare const validateConditionTypeOf: (incomingObject: ICondition) => void;
+export { validateConditionTypeOf };
+//# sourceMappingURL=validate-condition-type-of.d.ts.map

package/dist/rules/src/validation/conditions/validate-condition-type-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-condition-type-of.d.ts","sourceRoot":"","sources":["../../../../../src/validation/conditions/validate-condition-type-of.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,UAAU,EACb,MAAM,qBAAqB,CAAC;AAO7B;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB,mBAAoB,UAAU,KAAG,IAqB7D,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}