@raytio/core 10.1.0 → 11.0.0

package/dist/rules/convertInstanceToRuleInput.js

@@ -1,139 +1,138 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertInstanceToRuleInput = void 0;
-const ramda_1 = require("ramda");
-const verifications_1 = require("../verifications");
-const schema_1 = require("../schema");
-const helpers_1 = require("./helpers");
-// has to be hardcodede since we're in @raytio/core
-const VERIFICATION_SCHEMA = "ss_Verification";
-/**
- * this is only called for field values, so we can easily work out the type
- * There are no complications like POVerification or DateUnits
- */
-function getTypeofFieldValue(value) {
-    if (Array.isArray(value))
-        return "Array";
-    if (typeof value === "boolean")
-        return "Bool";
-    if (typeof value === "number")
-        return "Number";
-    if (typeof value === "string")
-        return "String";
-    return undefined;
-}
-const isDateField = (schema) => ([fieldName]) => {
-    var _a;
-    return (_a = schema.properties[fieldName].tags) === null || _a === void 0 ? void 0 : _a.some(tag => tag.startsWith("group:date_picker"));
-};
-const convertInstanceToRuleInput = async (instance, realVers, getSchema) => {
-    const out = {};
-    // eslint-disable-next-line fp/no-loops
-    for (const PO of instance.profile_objects) {
-        const schemaName = (0, schema_1.findSchemaLabel)(PO.labels);
-        // eslint-disable-next-line no-continue
-        if (schemaName === VERIFICATION_SCHEMA)
-            continue;
-        const schema = await getSchema(schemaName);
-        const verified = (0, verifications_1.getPOVerification)({ PO, schema, realVers });
-        // remove anything we can't make rules for (e.g. object), and
-        // also remove any fields that aren't defined in the schema.
-        const validFields = Object.entries(PO.properties).filter(([fieldName, value]) => getTypeofFieldValue(value) && schema.properties[fieldName]);
-        const nonDateProperties = validFields
-            .filter(d => !isDateField(schema)(d))
-            .map(([fieldName, value]) => {
-            var _a;
-            const verifiedBy = (0, ramda_1.uniq)((_a = realVers
-                .filter(x => x.belongsToNId === PO.n_id &&
-                x.fieldName === fieldName &&
-                x.provider.verifierNId)) === null || _a === void 0 ? void 0 : _a.map(x => x.provider.verifierNId));
-            const field = {
-                hField: {
-                    __typeof__: helpers_1.HFieldSymbol,
-                    cameFromSchema: schemaName,
-                    verification: verified.fieldVerifications[fieldName],
-                    verifiedBy,
-                },
-                type: getTypeofFieldValue(value),
-                value,
-            };
-            return [fieldName, field];
-        });
-        const dateFieldByCategorys = (0, ramda_1.groupBy)(([fieldName]) => schema.properties[fieldName].tags.find(tag => tag.startsWith("group:date_picker")), validFields.filter(isDateField(schema)));
-        // the three date fields become one pseudo field for the score system
-        const pseudoDateFields = Object.entries(dateFieldByCategorys).map(([groupTag, members]) => {
-            var _a;
-            const groupName = groupTag.split(":")[2] || "NO_NAME";
-            const memberFieldNames = members.map(x => x[0]);
-            const worstVer = (0, ramda_1.sort)((a, b) => b - a, // find the highest enum value (that's the worst)
-            memberFieldNames.map(f => verified.fieldVerifications[f]))[0];
-            const fieldVers = (0, ramda_1.uniq)((_a = realVers
-                .filter(x => x.belongsToNId === PO.n_id &&
-                memberFieldNames.includes(x.fieldName) &&
-                x.provider.verifierNId)) === null || _a === void 0 ? void 0 : _a.map(v => v.provider.verifierNId).filter((val) => !!val));
-            const values = Object.fromEntries(members);
-            const dayFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:day"); });
-            const monthFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:month"); });
-            const yearFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:year"); });
-            if (!dayFieldName || !monthFieldName || !yearFieldName) {
-                throw new Error("Failed to infer date component field");
-            }
-            const isoString = [
-                values[yearFieldName],
-                `${values[monthFieldName]}`.padStart(2, "0"),
-                `${values[dayFieldName]}`.padStart(2, "0"),
-            ].join("-");
-            const pseudoField = {
-                hField: {
-                    __typeof__: helpers_1.HFieldSymbol,
-                    cameFromSchema: schemaName,
-                    verification: worstVer,
-                    verifiedBy: fieldVers,
-                },
-                type: "Date",
-                value: new Date(isoString),
-            };
-            return [`__group_${groupName}`, pseudoField];
-        });
-        const deepProperties = Object.entries(PO.properties)
-            .filter(([fieldName, fieldValue]) => {
-            const field = schema.properties[fieldName];
-            return (field &&
-                field.type === "object" &&
-                field.properties &&
-                fieldValue &&
-                typeof fieldValue === "object");
-        })
-            .flatMap(([fieldName, fieldValue]) => {
-            const subFields = Object.keys(schema.properties[fieldName].properties);
-            return subFields.map(subFieldName => {
-                const value = fieldValue[subFieldName];
-                const hsubfield = {
-                    hField: null,
-                    type: getTypeofFieldValue(value),
-                    value,
-                };
-                return [`${fieldName}|${subFieldName}`, hsubfield];
-            });
-        });
-        // eslint-disable-next-line fp/no-mutation
-        out[schemaName] || (out[schemaName] = []);
-        // eslint-disable-next-line fp/no-mutating-methods
-        out[schemaName].push({
-            hSchema: {
-                __typeof__: helpers_1.HSchemaSymbol,
-                verification: verified.status,
-                verifiedBy: verified.details.verifiers
-                    .map(x => x.verifierNId)
-                    .filter((val) => !!val),
-            },
-            properties: Object.fromEntries([
-                ...nonDateProperties,
-                ...pseudoDateFields,
-                ...deepProperties,
-            ]),
-        });
-    }
-    return out;
-};
-exports.convertInstanceToRuleInput = convertInstanceToRuleInput;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertInstanceToRuleInput = void 0;
+const ramda_1 = require("ramda");
+const verifications_1 = require("../verifications");
+const schema_1 = require("../schema");
+const helpers_1 = require("./helpers");
+// has to be hardcodede since we're in @raytio/core
+const VERIFICATION_SCHEMA = "ss_Verification";
+/**
+ * this is only called for field values, so we can easily work out the type
+ * There are no complications like POVerification or DateUnits
+ */
+function getTypeofFieldValue(value) {
+    if (Array.isArray(value))
+        return "Array";
+    if (typeof value === "boolean")
+        return "Bool";
+    if (typeof value === "number")
+        return "Number";
+    if (typeof value === "string")
+        return "String";
+    return undefined;
+}
+const isDateField = (schema) => ([fieldName]) => {
+    var _a;
+    return (_a = schema.properties[fieldName].tags) === null || _a === void 0 ? void 0 : _a.some(tag => tag.startsWith("group:date_picker"));
+};
+const convertInstanceToRuleInput = async (POs, realVers, getSchema) => {
+    const out = {};
+    for (const PO of POs) {
+        const schemaName = (0, schema_1.findSchemaLabel)(PO.labels);
+        // eslint-disable-next-line no-continue
+        if (schemaName === VERIFICATION_SCHEMA)
+            continue;
+        const schema = await getSchema(schemaName);
+        const verified = (0, verifications_1.getPOVerification)({ PO, schema, realVers });
+        // remove anything we can't make rules for (e.g. object), and
+        // also remove any fields that aren't defined in the schema.
+        const validFields = Object.entries(PO.properties).filter(([fieldName, value]) => getTypeofFieldValue(value) && schema.properties[fieldName]);
+        const nonDateProperties = validFields
+            .filter(d => !isDateField(schema)(d))
+            .map(([fieldName, value]) => {
+            var _a;
+            const verifiedBy = (0, ramda_1.uniq)((_a = realVers
+                .filter(x => x.belongsToNId === PO.n_id &&
+                x.fieldName === fieldName &&
+                x.provider.verifierNId)) === null || _a === void 0 ? void 0 : _a.map(x => x.provider.verifierNId));
+            const field = {
+                hField: {
+                    __typeof__: helpers_1.HFieldSymbol,
+                    cameFromSchema: schemaName,
+                    verification: verified.fieldVerifications[fieldName],
+                    verifiedBy,
+                },
+                type: getTypeofFieldValue(value),
+                value,
+            };
+            return [fieldName, field];
+        });
+        const dateFieldByCategorys = (0, ramda_1.groupBy)(([fieldName]) => schema.properties[fieldName].tags.find(tag => tag.startsWith("group:date_picker")), validFields.filter(isDateField(schema)));
+        // the three date fields become one pseudo field for the score system
+        const pseudoDateFields = Object.entries(dateFieldByCategorys).map(([groupTag, members]) => {
+            var _a;
+            const groupName = groupTag.split(":")[2] || "NO_NAME";
+            const memberFieldNames = members.map(x => x[0]);
+            const worstVer = (0, ramda_1.sort)((a, b) => b - a, // find the highest enum value (that's the worst)
+            memberFieldNames.map(f => verified.fieldVerifications[f]))[0];
+            const fieldVers = (0, ramda_1.uniq)((_a = realVers
+                .filter(x => x.belongsToNId === PO.n_id &&
+                memberFieldNames.includes(x.fieldName) &&
+                x.provider.verifierNId)) === null || _a === void 0 ? void 0 : _a.map(v => v.provider.verifierNId).filter((val) => !!val));
+            const values = Object.fromEntries(members);
+            const dayFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:day"); });
+            const monthFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:month"); });
+            const yearFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:year"); });
+            if (!dayFieldName || !monthFieldName || !yearFieldName) {
+                throw new Error("Failed to infer date component field");
+            }
+            const isoString = [
+                values[yearFieldName],
+                `${values[monthFieldName]}`.padStart(2, "0"),
+                `${values[dayFieldName]}`.padStart(2, "0"),
+            ].join("-");
+            const pseudoField = {
+                hField: {
+                    __typeof__: helpers_1.HFieldSymbol,
+                    cameFromSchema: schemaName,
+                    verification: worstVer,
+                    verifiedBy: fieldVers,
+                },
+                type: "Date",
+                value: new Date(isoString),
+            };
+            return [`__group_${groupName}`, pseudoField];
+        });
+        const deepProperties = Object.entries(PO.properties)
+            .filter(([fieldName, fieldValue]) => {
+            const field = schema.properties[fieldName];
+            return (field &&
+                field.type === "object" &&
+                field.properties &&
+                fieldValue &&
+                typeof fieldValue === "object");
+        })
+            .flatMap(([fieldName, fieldValue]) => {
+            const subFields = Object.keys(schema.properties[fieldName].properties);
+            return subFields.map(subFieldName => {
+                const value = fieldValue[subFieldName];
+                const hsubfield = {
+                    hField: null,
+                    type: getTypeofFieldValue(value),
+                    value,
+                };
+                return [`${fieldName}|${subFieldName}`, hsubfield];
+            });
+        });
+        // eslint-disable-next-line fp/no-mutation
+        out[schemaName] || (out[schemaName] = []);
+        // eslint-disable-next-line fp/no-mutating-methods
+        out[schemaName].push({
+            hSchema: {
+                __typeof__: helpers_1.HSchemaSymbol,
+                verification: verified.status,
+                verifiedBy: verified.details.verifiers
+                    .map(x => x.verifierNId)
+                    .filter((val) => !!val),
+            },
+            properties: Object.fromEntries([
+                ...nonDateProperties,
+                ...pseudoDateFields,
+                ...deepProperties,
+            ]),
+        });
+    }
+    return out;
+};
+exports.convertInstanceToRuleInput = convertInstanceToRuleInput;

package/dist/rules/evaluateScoreCondition.d.ts

@@ -1,2 +1,2 @@
-import { ASTScoreConditionNode, RuleData } from "./types";
-export declare function evaluateScoreCondition(node: ASTScoreConditionNode, data: RuleData): boolean;
+import { ASTScoreConditionNode, RuleData } from "./types";
+export declare function evaluateScoreCondition(node: ASTScoreConditionNode, data: RuleData): boolean;

package/dist/rules/evaluateScoreCondition.js

@@ -1,45 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateScoreCondition = void 0;
-/* eslint-disable fp/no-loops */
-const ramda_1 = require("ramda");
-const general_1 = require("../general");
-const operators_1 = require("./operators");
-const helpers_1 = require("./helpers");
-function evaluateScoreCondition(node, data) {
-    (0, general_1.assertSafeProperty)(node.operator);
-    const op = operators_1.operators[node.operator];
-    if (!op) {
-        throw new Error(`Operator '${node.operator}' is not known`);
-    }
-    if (node.values.length !== op.operands.length) {
-        throw new Error(`Operator argument length mismatch for '${node.operator}'`);
-    }
-    const rawValues = node.values
-        .map(x => x.value.type === "constant"
-        ? [x.value.value]
-        : (0, helpers_1.getValuesFromPath)(x.value.path, data))
-        .map(valuesForArg => valuesForArg.filter(v => typeof v !== "undefined"));
-    for (const [i, argType] of op.operands.entries()) {
-        if ((0, helpers_1.simplifyValueType)(argType) !== (0, helpers_1.simplifyValueType)(node.values[i].type)) {
-            throw new TypeError(`Operator argument ${i} expected ${argType} but got ${node.values[i].type} for '${node.operator}'`);
-        }
-        const values = rawValues[i];
-        if (!values.length) {
-            // TODO: if one of the values required for your rule doesn't exist, then what?
-            // for now, the rule will return false.
-            return false;
-        }
-        // also check if the claimed type of the value matches the actual type of the value
-        for (const value of values) {
-            if (!(0, helpers_1.checkTypeofValue)(argType, value)) {
-                throw new Error(`Operator argument ${i} falsely claimed to be ${argType} for '${node.operator}'`);
-            }
-        }
-    }
-    const options = (0, ramda_1.transpose)(rawValues);
-    // everything adds up so far, so we can call the function for each
-    // data value. Return true if ANY of the values return true.
-    return options.some(args => op.implementation(...args));
-}
-exports.evaluateScoreCondition = evaluateScoreCondition;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateScoreCondition = void 0;
+const ramda_1 = require("ramda");
+const general_1 = require("../general");
+const operators_1 = require("./operators");
+const helpers_1 = require("./helpers");
+function evaluateScoreCondition(node, data) {
+    (0, general_1.assertSafeProperty)(node.operator);
+    const op = operators_1.operators[node.operator];
+    if (!op) {
+        throw new Error(`Operator '${node.operator}' is not known`);
+    }
+    if (node.values.length !== op.operands.length) {
+        throw new Error(`Operator argument length mismatch for '${node.operator}'`);
+    }
+    const rawValues = node.values
+        .map(x => x.value.type === "constant"
+        ? [x.value.value]
+        : (0, helpers_1.getValuesFromPath)(x.value.path, data))
+        .map(valuesForArg => valuesForArg.filter(v => typeof v !== "undefined"));
+    for (const [i, argType] of op.operands.entries()) {
+        if ((0, helpers_1.simplifyValueType)(argType) !== (0, helpers_1.simplifyValueType)(node.values[i].type)) {
+            throw new TypeError(`Operator argument ${i} expected ${argType} but got ${node.values[i].type} for '${node.operator}'`);
+        }
+        const values = rawValues[i];
+        if (!values.length) {
+            // TODO: if one of the values required for your rule doesn't exist, then what?
+            // for now, the rule will return false.
+            return false;
+        }
+        // also check if the claimed type of the value matches the actual type of the value
+        for (const value of values) {
+            if (!(0, helpers_1.checkTypeofValue)(argType, value)) {
+                throw new Error(`Operator argument ${i} falsely claimed to be ${argType} for '${node.operator}'`);
+            }
+        }
+    }
+    const options = (0, ramda_1.transpose)(rawValues);
+    // everything adds up so far, so we can call the function for each
+    // data value. Return true if ANY of the values return true.
+    return options.some(args => op.implementation(...args));
+}
+exports.evaluateScoreCondition = evaluateScoreCondition;

package/dist/{verifications/checkVerifications.d.ts → rules/helpers/__tests__/addInfiniteThresholdBoundaries.test.d.ts}

@@ -1 +1 @@
-export {};
+export {};

package/dist/rules/helpers/__tests__/addInfiniteThresholdBoundaries.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const addInfiniteThresholdBoundaries_1 = require("../addInfiniteThresholdBoundaries");
+describe("addInfiniteThresholdBoundaries", () => {
+    it("correctly re-adds Infinity to the first and last boundary", () => {
+        expect((0, addInfiniteThresholdBoundaries_1.addInfiniteThresholdBoundaries)([
+            { colour: "", from: null, to: 1, name: "❤️" },
+            { colour: "", from: 2, to: 50, name: "💛" },
+            { colour: "", from: 51, to: null, name: "💚" },
+        ])).toStrictEqual([
+            { colour: "", from: -Infinity, to: 1, name: "❤️" },
+            { colour: "", from: 2, to: 50, name: "💛" },
+            { colour: "", from: 51, to: Infinity, name: "💚" },
+        ]);
+        expect((0, addInfiniteThresholdBoundaries_1.addInfiniteThresholdBoundaries)([])).toStrictEqual([]);
+        expect((0, addInfiniteThresholdBoundaries_1.addInfiniteThresholdBoundaries)([
+            { colour: "", from: 1, to: 10, name: "my useless single category" },
+        ])).toStrictEqual([
+            {
+                colour: "",
+                from: -Infinity,
+                to: Infinity,
+                name: "my useless single category",
+            },
+        ]);
+    });
+});

package/dist/{verifications/checkVerificationsNew.d.ts → rules/helpers/__tests__/checkTypeofValue.test.d.ts}

@@ -1 +1 @@
-export {};
+export {};

package/dist/rules/helpers/__tests__/checkTypeofValue.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@raytio/types");
+const checkTypeofValue_1 = require("../checkTypeofValue");
+const symbols_1 = require("../symbols");
+const hField = { __typeof__: symbols_1.HFieldSymbol };
+const hSchema = { __typeof__: symbols_1.HSchemaSymbol };
+describe("checkTypeofValue", () => {
+    it.each `
+    val           | type                   | isValid
+    ${[]}         | ${"Array"}             | ${true}
+    ${[]}         | ${"Number"}            | ${false}
+    ${false}      | ${"Bool"}              | ${true}
+    ${undefined}  | ${"Bool"}              | ${false}
+    ${new Date()} | ${"Date"}              | ${true}
+    ${2020}       | ${"Date"}              | ${false}
+    ${"Y"}        | ${"DateUnit"}          | ${true}
+    ${"y"}        | ${"DateUnit"}          | ${false}
+    ${types_1.FieldVerification.Expired} | ${"FieldVerification"} | ${true}
+    ${12345}      | ${"FieldVerification"} | ${false}
+    ${hField}     | ${"HField"}            | ${true}
+    ${{}}         | ${"HField"}            | ${false}
+    ${hSchema}    | ${"HSchema"}           | ${true}
+    ${{}}         | ${"HSchema"}           | ${false}
+    ${123}        | ${"Number"}            | ${true}
+    ${types_1.FieldVerification.Expired} | ${"Number"}            | ${true}
+    ${"123"}      | ${"Number"}            | ${false}
+    ${types_1.POVerification.Expired} | ${"POVerification"}    | ${true}
+    ${12345}      | ${"POVerification"}    | ${false}
+    ${/a/}        | ${"RegEx"}             | ${true}
+    ${"/a/"}      | ${"RegEx"}             | ${false}
+    ${""}         | ${"String"}            | ${true}
+    ${1}          | ${"String"}            | ${false}
+    ${""}         | ${"Verifier"}          | ${true}
+    ${1}          | ${"Verifier"}          | ${false}
+    ${0}          | ${"invalidddd"}        | ${false}
+  `("asserts that $val is/isNot $type ($isValid)", ({ val, type, isValid }) => {
+        expect((0, checkTypeofValue_1.checkTypeofValue)(type, val)).toBe(isValid);
+    });
+});
+describe("simplifyValueType", () => {
+    it.each `
+    input                 | output
+    ${"Verifier"}         | ${"String"}
+    ${"some other value"} | ${"some other value"}
+  `("can simplify functionally equivalent types ($input -> $output)", ({ input, output }) => {
+        expect((0, checkTypeofValue_1.simplifyValueType)(input)).toStrictEqual(output);
+    });
+});

package/dist/{verifications/verifyCheck/util/canonicalJsonify.d.ts → rules/helpers/__tests__/getValuesFromPath.test.d.ts}

@@ -1 +1 @@
-export {};
+export {};

package/dist/rules/helpers/__tests__/getValuesFromPath.test.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@raytio/types");
+const getValuesFromPath_1 = require("../getValuesFromPath");
+const symbols_1 = require("../symbols");
+const hSchema = {
+    __typeof__: symbols_1.HSchemaSymbol,
+    verification: types_1.POVerification.PartiallyVerified,
+    verifiedBy: ["Waka Kotahi"],
+};
+const hField = {
+    __typeof__: symbols_1.HFieldSymbol,
+    cameFromSchema: "ss_NZ_DL",
+    verification: types_1.FieldVerification.Verified,
+    verifiedBy: ["Waka Kotahi"],
+};
+const data = {
+    ss_NZ_DL: [
+        {
+            hSchema,
+            properties: {
+                fName: { type: "String", value: "Wolfgang", hField },
+                age: { type: "Number", value: 19.25, hField },
+                "address|housenumber": {
+                    type: "Number",
+                    value: 31,
+                    hField: null,
+                },
+                "address|street": {
+                    type: "String",
+                    value: "Circular Quay",
+                    hField: null,
+                },
+            },
+        },
+    ],
+};
+describe("getValuesFromPath", () => {
+    it.each `
+    path                                                   | out
+    ${["field", "ss_NZ_DL", "fName", "value"]}             | ${["Wolfgang"]}
+    ${["field", "ss_NZ_DL", "fName", "valueLength"]}       | ${[8]}
+    ${["field", "ss_NZ_DL", "fName", "meta"]}              | ${[hField]}
+    ${["schema", "ss_NZ_DL", "meta"]}                      | ${[hSchema]}
+    ${["field", "ss_NZ_DL", "fakeeee", "value"]}           | ${[undefined]}
+    ${["schema", "fakeeee", "meta"]}                       | ${[]}
+    ${["field", "ss_NZ_DL", "address", "subField|street"]} | ${["Circular Quay"]}
+    ${["field", "ss_NZ_DL", "address", "subField|fakeee"]} | ${[undefined]}
+    ${["field", "ss_NZ_DL", "address", "subField|"]}       | ${[undefined]}
+  `("can get a value from a valid path ($path)", ({ path, out }) => {
+        expect((0, getValuesFromPath_1.getValuesFromPath)(path, data)).toStrictEqual(out);
+    });
+    it.each `
+    path                                             | error
+    ${["jkhsfjkdf"]}                                 | ${"Invalid ValuePath[0] (jkhsfjkdf)"}
+    ${["schema", "constructor", "meta"]}             | ${"Unacceptable object property"}
+    ${["schema", "ss_NZ_DL", "fakeeee"]}             | ${"Invalid ValuePath[2] for schema (fakeeee)"}
+    ${["schema", "ss_NZ_DL", "constructor", "meta"]} | ${"Unacceptable object property"}
+    ${["field", "ss_NZ_DL", "fName", "fakeeee"]}     | ${"Invalid ValuePath[3] for field (fakeeee)"}
+    ${["field"]}                                     | ${"Invalid ValuePath[3] for field (undefined)"}
+    ${["schema"]}                                    | ${"Invalid ValuePath[2] for schema (undefined)"}
+    ${""}                                            | ${"Invalid ValuePath[0] (undefined)"}
+    ${["field", "ss_NZ_DL", "age", "valueLength"]}   | ${"valueLength may only be used on arrays and strings"}
+  `("throws an error for invalid paths ($path)", ({ path, error }) => {
+        expect(() => (0, getValuesFromPath_1.getValuesFromPath)(path, data)).toThrow(new Error(error));
+    });
+});

package/dist/rules/helpers/__tests__/thresholds.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rules/helpers/__tests__/thresholds.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const thresholds_1 = require("../thresholds");
+describe("getThresholdBoundary", () => {
+    it("gets the min and max for plus", () => {
+        expect((0, thresholds_1.getThresholdBoundary)("+", [
+            { trueWeight: 3, falseWeight: 5 },
+            { trueWeight: -20, falseWeight: -10 },
+        ])).toStrictEqual([-17, -5]);
+        expect((0, thresholds_1.getThresholdBoundary)("+", [
+            { trueWeight: -7, falseWeight: -8 },
+        ])).toStrictEqual([-8, -7]);
+    });
+    it("gets the min and max for multiply", () => {
+        expect((0, thresholds_1.getThresholdBoundary)("*", [
+            { trueWeight: 7, falseWeight: -2 },
+            { trueWeight: -1, falseWeight: 2 },
+            { trueWeight: -5, falseWeight: 4 },
+        ])).toStrictEqual([-70, 56]);
+        expect((0, thresholds_1.getThresholdBoundary)("*", [
+            { trueWeight: 7, falseWeight: -2 },
+        ])).toStrictEqual([-2, 7]);
+    });
+    it("works for empty arrays", () => {
+        expect((0, thresholds_1.getThresholdBoundary)("+", [])).toStrictEqual([0, 0]);
+        expect((0, thresholds_1.getThresholdBoundary)("*", [])).toStrictEqual([Infinity, -Infinity]);
+    });
+    it("throws an error for invalid combinators", () => {
+        // @ts-expect-error testing invalid input
+        expect(() => (0, thresholds_1.getThresholdBoundary)("^", [])).toThrow(new Error("Invalid combinator"));
+    });
+});

package/dist/rules/helpers/addInfiniteThresholdBoundaries.d.ts

@@ -1,8 +1,8 @@
-import { ScoreThreshold } from "../types";
-/**
- * @ignore the first and last threshold boundaries are -Infinity and +Infinity.
- * We override whatever is specified to ensure these boundaries are infinite.
- *
- * This is also needed because json converts non-finite numbers to `null`
- */
-export declare const addInfiniteThresholdBoundaries: (list: readonly ScoreThreshold[]) => ScoreThreshold[];
+import { ScoreThreshold } from "../types";
+/**
+ * @ignore the first and last threshold boundaries are -Infinity and +Infinity.
+ * We override whatever is specified to ensure these boundaries are infinite.
+ *
+ * This is also needed because json converts non-finite numbers to `null`
+ */
+export declare const addInfiniteThresholdBoundaries: (list: readonly ScoreThreshold[]) => ScoreThreshold[];

package/dist/rules/helpers/addInfiniteThresholdBoundaries.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addInfiniteThresholdBoundaries = void 0;
-const ramda_1 = require("ramda");
-/**
- * @ignore the first and last threshold boundaries are -Infinity and +Infinity.
- * We override whatever is specified to ensure these boundaries are infinite.
- *
- * This is also needed because json converts non-finite numbers to `null`
- */
-exports.addInfiniteThresholdBoundaries = (0, ramda_1.pipe)((0, ramda_1.adjust)(0, v => (Object.assign(Object.assign({}, v), { from: -Infinity }))), (0, ramda_1.adjust)(-1, v => (Object.assign(Object.assign({}, v), { to: Infinity }))));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addInfiniteThresholdBoundaries = void 0;
+const ramda_1 = require("ramda");
+/**
+ * @ignore the first and last threshold boundaries are -Infinity and +Infinity.
+ * We override whatever is specified to ensure these boundaries are infinite.
+ *
+ * This is also needed because json converts non-finite numbers to `null`
+ */
+exports.addInfiniteThresholdBoundaries = (0, ramda_1.pipe)((0, ramda_1.adjust)(0, v => (Object.assign(Object.assign({}, v), { from: -Infinity }))), (0, ramda_1.adjust)(-1, v => (Object.assign(Object.assign({}, v), { to: Infinity }))));