@degenerate/rules 0.0.1

package/dist/rules/jest.config.js

@@ -0,0 +1,44 @@
+"use strict";
+// Changes to this file should be maed throughout all packages to keep consistency.
+// Descritions of the properties are in the root jest.config.ts file.
+/**
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    collectCoverageFrom: [
+        "src/**/*.ts"
+    ],
+    coverageDirectory: "coverage",
+    coverageProvider: "v8",
+    moduleFileExtensions: [
+        "js",
+        "mjs",
+        "cjs",
+        "jsx",
+        "ts",
+        "tsx",
+        "json",
+        "node"
+    ],
+    modulePathIgnorePatterns: [
+        "dist",
+    ],
+    preset: "ts-jest",
+    roots: [
+        "<rootDir>/src/"
+    ],
+    testEnvironment: "jsdom",
+    testMatch: [
+        "**/__tests__/**/*.[jt]s?(x)",
+        "**/?(*.)+(spec|test).[tj]s?(x)"
+    ],
+    transform: {
+        '^.+\\.tsx?$': ['ts-jest', {
+                tsConfig: 'tsconfig.json',
+            }],
+    },
+    verbose: true,
+};
+exports.default = config;

package/dist/rules/src/evaluation/check-function-integrity.d.ts

@@ -0,0 +1,7 @@
+import { IShareFunction } from '../../../generic/src';
+/**
+ * This function ensures function integrity by comparing the function that was run to a list of functions that are allowed to be run.
+ */
+declare const checkFunctionIntegrity: (shareDataFunction: IShareFunction<any, (...args: any[]) => any, any>, shareDataFunctions: IShareFunction<any, (...args: any[]) => any, any>[]) => boolean;
+export { checkFunctionIntegrity };
+//# sourceMappingURL=check-function-integrity.d.ts.map

package/dist/rules/src/evaluation/check-function-integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-function-integrity.d.ts","sourceRoot":"","sources":["../../../../src/evaluation/check-function-integrity.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;GAEG;AACH,QAAA,MAAM,sBAAsB,sBAAuB,cAAc,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,GAAG,CAAC,sBAC5E,cAAc,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,GAAG,CAAC,EAAE,KAAG,OAK7E,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/rules/src/evaluation/check-function-integrity.js

@@ -0,0 +1,14 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFunctionIntegrity = void 0;
+/**
+ * This function ensures function integrity by comparing the function that was run to a list of functions that are allowed to be run.
+ */
+const checkFunctionIntegrity = (shareDataFunction, shareDataFunctions) => {
+    if (shareDataFunctions.includes(shareDataFunction)) {
+        return true;
+    }
+    return false;
+};
+exports.checkFunctionIntegrity = checkFunctionIntegrity;

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

@@ -0,0 +1,11 @@
+import { IShareRulesEvaluationResult } from '../../../generic/src';
+/**
+ * This function checks if the proposal is valid.
+ *
+ * @param totalRulesToBeValid the total rules that need to be valid
+ * @param rulesResults the rules results
+ * @returns
+ */
+declare const checkIfProposalIsValid: (totalRulesToBeValid: number, rulesResults: IShareRulesEvaluationResult[]) => boolean;
+export { checkIfProposalIsValid };
+//# sourceMappingURL=check-if-proposal-is-valid.d.ts.map

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,sBAAsB,CAAC;AAEnE;;;;;;GAMG;AACH,QAAA,MAAM,sBAAsB,wBACH,MAAM,gBACb,2BAA2B,EAAE,KAC5C,OAGF,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/rules/src/evaluation/check-if-proposal-is-valid.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfProposalIsValid = void 0;
+/**
+ * This function checks if the proposal is valid.
+ *
+ * @param totalRulesToBeValid the total rules that need to be valid
+ * @param rulesResults the rules results
+ * @returns
+ */
+const checkIfProposalIsValid = (totalRulesToBeValid, rulesResults) => {
+    const totalRulesValid = rulesResults.filter((x) => x.passedRuleCheck).length;
+    return totalRulesValid === totalRulesToBeValid;
+};
+exports.checkIfProposalIsValid = checkIfProposalIsValid;

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

@@ -0,0 +1,15 @@
+/**
+ * This file contains the functions for checking that the boolean conditions are met.
+ */
+import { ConditionTypeBoolean } from '../../../../generic/src/models/rules/share-rule-models';
+/**
+ * This takes a value and checks if it meets the boolean condition.
+ *
+ * @param dataValue the value to check
+ * @param conditionType whether this is a boolean or not boolean condition
+ *
+ * @returns
+ */
+declare const isValidBooleanValue: (dataValue: unknown, conditionType: ConditionTypeBoolean) => boolean;
+export { isValidBooleanValue };
+//# sourceMappingURL=boolean-conditions.d.ts.map

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;AAGH,OAAO,EAAE,oBAAoB,EAAE,MAAM,wDAAwD,CAAC;AAG9F;;;;;;;GAOG;AACH,QAAA,MAAM,mBAAmB,cAAe,OAAO,iBAAiB,oBAAoB,KAAG,OAWtF,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/boolean-conditions.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * This file contains the functions for checking that the boolean conditions are met.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidBooleanValue = void 0;
+const src_1 = require("../../../../generic/src");
+const share_rule_models_1 = require("../../../../generic/src/models/rules/share-rule-models");
+/**
+ * This takes a value and checks if it meets the boolean condition.
+ *
+ * @param dataValue the value to check
+ * @param conditionType whether this is a boolean or not boolean condition
+ *
+ * @returns
+ */
+const isValidBooleanValue = (dataValue, conditionType) => {
+    const isBoolean = (0, src_1.validateBoolean)(dataValue);
+    if (!isBoolean) {
+        return false;
+    }
+    switch (conditionType) {
+        case share_rule_models_1.ConditionTypeBoolean.IS_TRUE:
+            return dataValue === true;
+        case share_rule_models_1.ConditionTypeBoolean.IS_FALSE:
+            return dataValue === false;
+    }
+};
+exports.isValidBooleanValue = isValidBooleanValue;

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

@@ -0,0 +1,16 @@
+/**
+ * This file contains the functions for checking that contains conditions are met.
+ */
+import { ConditionTypeContains } from '../../../../generic/src';
+/**
+ * This takes a value and checks if it is contained or not contained in the proper range of values.
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType whether this is a contains or not contains condition
+ *
+ * @returns
+ */
+declare const isValidContainsValue: (dataValue: string | number, conditionValue: string | (number | string)[], conditionType: ConditionTypeContains) => boolean;
+export { isValidContainsValue };
+//# sourceMappingURL=contains-conditions.d.ts.map

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,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,cAAe,MAAM,GAAG,MAAM,kBAAkB,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,iBACnF,qBAAqB,KAAG,OAQ1C,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/contains-conditions.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * This file contains the functions for checking that contains conditions are met.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidContainsValue = void 0;
+const src_1 = require("../../../../generic/src");
+/**
+ * This takes a value and checks if it is contained or not contained in the proper range of values.
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType whether this is a contains or not contains condition
+ *
+ * @returns
+ */
+const isValidContainsValue = (dataValue, conditionValue, conditionType) => {
+    let isMatchedCondition = false;
+    if (typeof conditionValue === 'string') {
+        isMatchedCondition = conditionValue.includes(dataValue.toString());
+    }
+    else {
+        isMatchedCondition = conditionValue.includes(dataValue);
+    }
+    return (conditionType === src_1.ConditionTypeContains.CONTAINS) ? isMatchedCondition : !isMatchedCondition;
+};
+exports.isValidContainsValue = isValidContainsValue;

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

@@ -0,0 +1,15 @@
+/**
+ * This file contains the functions for checking that the values are empty
+ */
+import { ConditionTypeEmpty } from '../../../../generic/src';
+/**
+ * This takes a value and checks if it meets the empty condition
+ *
+ * @param dataValue the value to check
+ * @param conditionType whether this is a boolean or not boolean condition
+ *
+ * @returns
+ */
+declare const isValidEmptyValue: (dataValue: unknown, conditionType: ConditionTypeEmpty) => boolean;
+export { isValidEmptyValue };
+//# sourceMappingURL=empty-conditions.d.ts.map

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":"AACA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAiB,MAAM,yBAAyB,CAAC;AAE5E;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,cAAe,OAAO,iBAAiB,kBAAkB,KAAG,OAiBlF,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/empty-conditions.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * This file contains the functions for checking that the values are empty
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmptyValue = void 0;
+const src_1 = require("../../../../generic/src");
+/**
+ * This takes a value and checks if it meets the empty condition
+ *
+ * @param dataValue the value to check
+ * @param conditionType whether this is a boolean or not boolean condition
+ *
+ * @returns
+ */
+const isValidEmptyValue = (dataValue, conditionType) => {
+    const isArray = (0, src_1.validateArray)(dataValue);
+    if (isArray) {
+        switch (conditionType) {
+            case src_1.ConditionTypeEmpty.IS_EMPTY:
+                return dataValue.length === 0;
+            case src_1.ConditionTypeEmpty.IS_NOT_EMPTY:
+                return dataValue.length > 0;
+        }
+    }
+    else {
+        switch (conditionType) {
+            case src_1.ConditionTypeEmpty.IS_EMPTY:
+                return isEmpty(dataValue);
+            case src_1.ConditionTypeEmpty.IS_NOT_EMPTY:
+                return !isEmpty(dataValue);
+        }
+    }
+};
+exports.isValidEmptyValue = isValidEmptyValue;
+/**
+ * Whether the item is empty.
+ *
+ * @param dataValue the value to check
+ * @returns
+ */
+const isEmpty = (dataValue) => {
+    if (dataValue === null || dataValue === undefined) {
+        return true;
+    }
+    if (typeof dataValue === 'string') {
+        return dataValue === '';
+    }
+    return false;
+};

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

@@ -0,0 +1,15 @@
+/**
+ * This file contains the functions for checking that equality conditions are met.
+ */
+import { ConditionTypeEquality } from '../../../../generic/src';
+/**
+ * This takes a value and checks if two values are strictly equal or not equal.
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType the type of equality condition to check for
+ * @returns
+ */
+declare const isValidEqualityValue: (dataValue: unknown, conditionValue: unknown, conditionType: ConditionTypeEquality) => boolean;
+export { isValidEqualityValue };
+//# sourceMappingURL=equality-conditions.d.ts.map

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,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;GAOG;AACH,QAAA,MAAM,oBAAoB,cAAe,OAAO,kBAAkB,OAAO,iBAAiB,qBAAqB,KAAG,OAOjH,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/equality-conditions.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * This file contains the functions for checking that equality conditions are met.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEqualityValue = void 0;
+const src_1 = require("../../../../generic/src");
+/**
+ * This takes a value and checks if two values are strictly equal or not equal.
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType the type of equality condition to check for
+ * @returns
+ */
+const isValidEqualityValue = (dataValue, conditionValue, conditionType) => {
+    switch (conditionType) {
+        case src_1.ConditionTypeEquality.EQUAL:
+            return dataValue === conditionValue;
+        case src_1.ConditionTypeEquality.NOT_EQUAL:
+            return dataValue !== conditionValue;
+    }
+};
+exports.isValidEqualityValue = isValidEqualityValue;

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

@@ -0,0 +1,15 @@
+/**
+ * This file contains the functions for checking that the null conditions are met.
+ */
+import { ConditionTypeNull } from '../../../../generic/src';
+/**
+ * This takes a value and checks if it meets the null condition.
+ *
+ * @param dataValue the value to check
+ * @param conditionType whether this is a contains or not contains condition
+ *
+ * @returns
+ */
+declare const isValidNullValue: (dataValue: any, conditionType: ConditionTypeNull) => boolean;
+export { isValidNullValue };
+//# sourceMappingURL=null-conditions.d.ts.map

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,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D;;;;;;;GAOG;AACH,QAAA,MAAM,gBAAgB,cAAe,GAAG,iBAAiB,iBAAiB,KAAG,OAO5E,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/null-conditions.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * This file contains the functions for checking that the null conditions are met.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidNullValue = void 0;
+const src_1 = require("../../../../generic/src");
+/**
+ * This takes a value and checks if it meets the null condition.
+ *
+ * @param dataValue the value to check
+ * @param conditionType whether this is a contains or not contains condition
+ *
+ * @returns
+ */
+const isValidNullValue = (dataValue, conditionType) => {
+    switch (conditionType) {
+        case src_1.ConditionTypeNull.IS_NULL:
+            return dataValue === null;
+        case src_1.ConditionTypeNull.IS_NOT_NULL:
+            return dataValue !== null;
+    }
+};
+exports.isValidNullValue = isValidNullValue;

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

@@ -0,0 +1,15 @@
+/**
+ * This file contains the functions for checking that range conditions are met.
+ */
+import { ConditionTypeRange } from '../../../../generic/src';
+/**
+ * This takes a value and checks if it is in the proper range of values.
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType the type of equality condition to check for
+ * @returns
+ */
+declare const isValidRangeValue: (dataValue: string | number, conditionValue: string | number, conditionType: ConditionTypeRange) => boolean;
+export { isValidRangeValue };
+//# sourceMappingURL=range-conditions.d.ts.map

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,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,cAAe,MAAM,GAAG,MAAM,kBAAkB,MAAM,GAAG,MAAM,iBAAiB,kBAAkB,KAAG,OAW3H,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/range-conditions.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * This file contains the functions for checking that range conditions are met.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidRangeValue = void 0;
+const src_1 = require("../../../../generic/src");
+/**
+ * This takes a value and checks if it is in the proper range of values.
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType the type of equality condition to check for
+ * @returns
+ */
+const isValidRangeValue = (dataValue, conditionValue, conditionType) => {
+    switch (conditionType) {
+        case src_1.ConditionTypeRange.GREATER_THAN:
+            return dataValue > conditionValue;
+        case src_1.ConditionTypeRange.LESS_THAN:
+            return dataValue < conditionValue;
+        case src_1.ConditionTypeRange.GREATER_THAN_OR_EQUAL:
+            return dataValue >= conditionValue;
+        case src_1.ConditionTypeRange.LESS_THAN_OR_EQUAL:
+            return dataValue <= conditionValue;
+    }
+};
+exports.isValidRangeValue = isValidRangeValue;

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

@@ -0,0 +1,15 @@
+/**
+ * This file contains the functions for checking that special conditions are met.
+ */
+import { ConditionTypeSpecial } from '../../../../generic/src';
+/**
+ * This takes a value and checks if the special condition is met.
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType the type of equality condition to check for
+ * @returns
+ */
+declare const isValidSpecialValue: (dataValue: unknown, conditionValue: unknown, conditionType: ConditionTypeSpecial) => boolean;
+export { isValidSpecialValue };
+//# sourceMappingURL=special-conditions.d.ts.map

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,EAAkD,MAAM,yBAAyB,CAAC;AAE/G;;;;;;;GAOG;AACH,QAAA,MAAM,mBAAmB,cAAe,OAAO,kBAAkB,OAAO,iBAAiB,oBAAoB,KAAG,OAK/G,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/special-conditions.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * This file contains the functions for checking that special conditions are met.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidSpecialValue = void 0;
+const src_1 = require("../../../../generic/src");
+/**
+ * This takes a value and checks if the special condition is met.
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType the type of equality condition to check for
+ * @returns
+ */
+const isValidSpecialValue = (dataValue, conditionValue, conditionType) => {
+    switch (conditionType) {
+        case src_1.ConditionTypeSpecial.PATTERN:
+            return evaluatePattern(dataValue, conditionValue);
+    }
+};
+exports.isValidSpecialValue = isValidSpecialValue;
+//#region Special Conditions Functions
+/**
+ * This takes a value and checks if the regex pattern is met.
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @returns
+ */
+const evaluatePattern = (dataValue, conditionValue) => {
+    if (!dataValue || typeof dataValue !== 'string') {
+        return false;
+    }
+    if (!conditionValue || typeof conditionValue !== 'string') {
+        return false;
+    }
+    try {
+        const regex = new RegExp(conditionValue);
+        const result = regex.test(dataValue);
+        return result;
+    }
+    catch (err) {
+        throw new src_1.SafeRuleEvaluationSpecialConditionPatternError(dataValue, conditionValue);
+    }
+    // return regex.test(dataValue as string);
+};
+//#endregion Special Conditions Functions

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

@@ -0,0 +1,16 @@
+/**
+ * This file contains the functions for checking that starts or ends with are met
+ */
+import { ConditionTypeStartsEndsWith } from '../../../../generic/src';
+/**
+ * This takes a value and checks if the value starts or ends with value
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType whether this is a starts with or ends with condition
+ *
+ * @returns
+ */
+declare const isValidStartEndWithValue: (dataValue: string | number, conditionValue: string | (number | string)[], conditionType: ConditionTypeStartsEndsWith) => boolean;
+export { isValidStartEndWithValue };
+//# sourceMappingURL=starts-end-with-conditions.d.ts.map

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,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;;;;;;GAQG;AACH,QAAA,MAAM,wBAAwB,cAAe,MAAM,GAAG,MAAM,kBAAkB,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,iBACvF,2BAA2B,KAAG,OAOhD,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/starts-end-with-conditions.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * This file contains the functions for checking that starts or ends with are met
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidStartEndWithValue = void 0;
+const src_1 = require("../../../../generic/src");
+/**
+ * This takes a value and checks if the value starts or ends with value
+ *
+ * @param dataValue the value to check
+ * @param conditionValue the value to check against
+ * @param conditionType whether this is a starts with or ends with condition
+ *
+ * @returns
+ */
+const isValidStartEndWithValue = (dataValue, conditionValue, conditionType) => {
+    switch (conditionType) {
+        case src_1.ConditionTypeStartsEndsWith.STARTS_WITH:
+            return dataValue.toString().startsWith(conditionValue.toString());
+        case src_1.ConditionTypeStartsEndsWith.ENDS_WITH:
+            return dataValue.toString().endsWith(conditionValue.toString());
+    }
+};
+exports.isValidStartEndWithValue = isValidStartEndWithValue;

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

@@ -0,0 +1,16 @@
+/**
+ * This file contains the functions for checking that the data is the proper type of data.
+ */
+import { ConditionTypeOf, ConditionTypeTypeOf } from '../../../../generic/src';
+/**
+ * This takes a value and checks if it is the proper type of value.
+ *
+ * @param dataValue the value to check
+ * @param typeofValue the type of value to check for
+ * @param conditionType if the value should be equal to the type of value (is true or is not true)
+ *
+ * @returns
+ */
+declare const isValidTypeOfValue: (dataValue: unknown, typeofValue: ConditionTypeOf, conditionType: ConditionTypeTypeOf) => boolean;
+export { isValidTypeOfValue };
+//# sourceMappingURL=typeof-rule-conditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeof-rule-conditions.d.ts","sourceRoot":"","sources":["../../../../../src/evaluation/conditions/typeof-rule-conditions.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE/E;;;;;;;;GAQG;AACH,QAAA,MAAM,kBAAkB,cAAe,OAAO,eAAe,eAAe,iBAAiB,mBAAmB,KAAG,OAGlH,CAAC;AAsCF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/rules/src/evaluation/conditions/typeof-rule-conditions.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * This file contains the functions for checking that the data is the proper type of data.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidTypeOfValue = void 0;
+const src_1 = require("../../../../generic/src");
+/**
+ * This takes a value and checks if it is the proper type of value.
+ *
+ * @param dataValue the value to check
+ * @param typeofValue the type of value to check for
+ * @param conditionType if the value should be equal to the type of value (is true or is not true)
+ *
+ * @returns
+ */
+const isValidTypeOfValue = (dataValue, typeofValue, conditionType) => {
+    const initialResult = checkType(dataValue, typeofValue);
+    return (conditionType === src_1.ConditionTypeTypeOf.IS_TYPEOF) ? initialResult : !initialResult;
+};
+exports.isValidTypeOfValue = isValidTypeOfValue;
+/**
+ * This checks the type of the value and sees if it matches the type of value.
+ *
+ * @param dataValue the value to check
+ * @param typeofValue the type of value to check for
+ * @returns
+ */
+const checkType = (dataValue, typeofValue) => {
+    switch (typeofValue) {
+        case src_1.ConditionTypeOf.STRING:
+            return typeof dataValue === 'string';
+        case src_1.ConditionTypeOf.NUMBER:
+            return typeof dataValue === 'number';
+        case src_1.ConditionTypeOf.INTEGER:
+            return Number.isInteger(dataValue);
+        case src_1.ConditionTypeOf.BOOLEAN:
+            return typeof dataValue === 'boolean';
+        case src_1.ConditionTypeOf.OBJECT:
+            return typeof dataValue === 'object';
+        case src_1.ConditionTypeOf.ARRAY:
+            return Array.isArray(dataValue);
+        case src_1.ConditionTypeOf.NULL:
+            return dataValue === null;
+        case src_1.ConditionTypeOf.UNDEFINED:
+            return typeof dataValue === 'undefined';
+        case src_1.ConditionTypeOf.FUNCTION:
+            return typeof dataValue === 'function';
+        // case ConditionTypeOf.SYMBOL:
+        //     return typeof dataValue === 'symbol';
+        case src_1.ConditionTypeOf.BIGINT:
+            return typeof dataValue === 'bigint';
+        default:
+            return false;
+    }
+};

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

@@ -0,0 +1,11 @@
+import { IShareData } from '../../../generic/src';
+/**
+ * This function determines if the data has changed.
+ *
+ * @param oldData the old data to compare
+ * @param newData the new data to compare
+ * @returns
+ */
+declare const determineIfDataHasChanged: (oldData: IShareData, newData: IShareData) => boolean;
+export { determineIfDataHasChanged };
+//# sourceMappingURL=determine-if-data-has-changed.d.ts.map

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,sBAAsB,CAAC;AAElD;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB,YAAa,UAAU,WAAW,UAAU,KAAG,OAE7E,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/rules/src/evaluation/determine-if-data-has-changed.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineIfDataHasChanged = void 0;
+/**
+ * This function determines if the data has changed.
+ *
+ * @param oldData the old data to compare
+ * @param newData the new data to compare
+ * @returns
+ */
+const determineIfDataHasChanged = (oldData, newData) => {
+    return JSON.stringify(oldData) !== JSON.stringify(newData);
+};
+exports.determineIfDataHasChanged = determineIfDataHasChanged;