@raytio/core 10.1.0 → 11.1.0

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 }))));

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

@@ -1,9 +1,9 @@
-import { GetTSType, ValueType } from "../types";
-/** asserts that the provided `value` meets the constaints of `type` */
-export declare function checkTypeofValue<T extends ValueType>(type: T, value: unknown): value is GetTSType<T>;
-/**
- * Some types are effectively equivilant (e.g. n_id and string).
- * Any exceptions defined here should use the same validator in
- * `checkTypeofValue` above.
- */
-export declare function simplifyValueType(type: ValueType): ValueType;
+import { GetTSType, ValueType } from "../types";
+/** asserts that the provided `value` meets the constaints of `type` */
+export declare function checkTypeofValue<T extends ValueType>(type: T, value: unknown): value is GetTSType<T>;
+/**
+ * Some types are effectively equivilant (e.g. n_id and string).
+ * Any exceptions defined here should use the same validator in
+ * `checkTypeofValue` above.
+ */
+export declare function simplifyValueType(type: ValueType): ValueType;

package/dist/rules/helpers/checkTypeofValue.js

@@ -1,55 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.simplifyValueType = exports.checkTypeofValue = void 0;
-const types_1 = require("@raytio/types");
-const symbols_1 = require("./symbols");
-const types_2 = require("../types");
-const VALID_DATE_UNITS = types_2.DATE_UNITS;
-// we need this function beacuse TS's typeguards aren't great
-const isObjectWithTypeofProp = (x) => typeof x === "object" && !!x && "__typeof__" in x;
-/** asserts that the provided `value` meets the constaints of `type` */
-function checkTypeofValue(type, value) {
-    switch (type) {
-        case "Array":
-            return Array.isArray(value);
-        case "Bool":
-            return typeof value === "boolean";
-        case "Date":
-            return value instanceof Date;
-        case "DateUnit":
-            return typeof value === "string" && VALID_DATE_UNITS.includes(value);
-        case "FieldVerification":
-            return typeof value === "number" && value in types_1.FieldVerification;
-        case "HField":
-            // this is fakeable (you could make a constant object with these props),
-            // but that's not a concern in this context.
-            return isObjectWithTypeofProp(value) && value.__typeof__ === symbols_1.HFieldSymbol;
-        case "HSchema":
-            // this is fakeable (you could make a constant object with these props),
-            // but that's not a concern in this context.
-            return (isObjectWithTypeofProp(value) && value.__typeof__ === symbols_1.HSchemaSymbol);
-        case "Number":
-            return typeof value === "number";
-        case "POVerification":
-            return typeof value === "number" && value in types_1.POVerification;
-        case "RegEx":
-            return value instanceof RegExp;
-        case "Verifier":
-        case "String":
-            return typeof value === "string";
-        default:
-            return false;
-    }
-}
-exports.checkTypeofValue = checkTypeofValue;
-/**
- * Some types are effectively equivilant (e.g. n_id and string).
- * Any exceptions defined here should use the same validator in
- * `checkTypeofValue` above.
- */
-function simplifyValueType(type) {
-    if (type === "Verifier")
-        return "String";
-    return type;
-}
-exports.simplifyValueType = simplifyValueType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplifyValueType = exports.checkTypeofValue = void 0;
+const types_1 = require("@raytio/types");
+const symbols_1 = require("./symbols");
+const types_2 = require("../types");
+const VALID_DATE_UNITS = types_2.DATE_UNITS;
+// we need this function because TS's typeguards aren't great
+const isObjectWithTypeofProp = (x) => typeof x === "object" &&
+    !!x &&
+    "__typeof__" in x &&
+    typeof x.__typeof__ === "symbol";
+/** asserts that the provided `value` meets the constaints of `type` */
+function checkTypeofValue(type, value) {
+    switch (type) {
+        case "Array":
+            return Array.isArray(value);
+        case "Bool":
+            return typeof value === "boolean";
+        case "Date":
+            return value instanceof Date;
+        case "DateUnit":
+            return typeof value === "string" && VALID_DATE_UNITS.includes(value);
+        case "FieldVerification":
+            return typeof value === "number" && value in types_1.FieldVerification;
+        case "HField":
+            // this is not fakeable because we use a unique symbol for __typeof__, like
+            // what react does with $$typeof. But even if you could construct a fake object,
+            // it wouldn't be a concern in this context.
+            return isObjectWithTypeofProp(value) && value.__typeof__ === symbols_1.HFieldSymbol;
+        case "HSchema":
+            // this is not fakeable because we use a unique symbol for __typeof__, like
+            // what react does with $$typeof. But even if you could construct a fake object,
+            // it wouldn't be a concern in this context.
+            return (isObjectWithTypeofProp(value) && value.__typeof__ === symbols_1.HSchemaSymbol);
+        case "Number":
+            return typeof value === "number";
+        case "POVerification":
+            return typeof value === "number" && value in types_1.POVerification;
+        case "RegEx":
+            return value instanceof RegExp;
+        case "Verifier":
+        case "String":
+            return typeof value === "string";
+        default:
+            return false;
+    }
+}
+exports.checkTypeofValue = checkTypeofValue;
+/**
+ * Some types are effectively equivilant (e.g. n_id and string).
+ * Any exceptions defined here should use the same validator in
+ * `checkTypeofValue` above.
+ */
+function simplifyValueType(type) {
+    if (type === "Verifier")
+        return "String";
+    return type;
+}
+exports.simplifyValueType = simplifyValueType;

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

@@ -1,3 +1,3 @@
-import { RuleData, ValuePath } from "../types";
-/** this returns an array because there might be multiple of the same schema shared */
-export declare function getValuesFromPath(path: ValuePath, data: RuleData): unknown[];
+import { RuleData, ValuePath } from "../types";
+/** this returns an array because there might be multiple of the same schema shared */
+export declare function getValuesFromPath(path: ValuePath, data: RuleData): unknown[];

package/dist/rules/helpers/getValuesFromPath.js

@@ -1,50 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValuesFromPath = void 0;
-const general_1 = require("../../general");
-/** this returns an array because there might be multiple of the same schema shared */
-function getValuesFromPath(path, data) {
-    var _a, _b, _c, _d;
-    const type = path[0];
-    switch (type) {
-        case "field": {
-            const [, schemaName, fieldName, attr] = path;
-            (0, general_1.assertSafeProperty)(schemaName);
-            (0, general_1.assertSafeProperty)(fieldName);
-            (0, general_1.assertSafeProperty)(attr);
-            if (attr === "meta") {
-                return (((_a = data[schemaName]) === null || _a === void 0 ? void 0 : _a.map(x => { var _a; return (_a = x.properties[fieldName]) === null || _a === void 0 ? void 0 : _a.hField; })) || []);
-            }
-            const values = ((_b = data[schemaName]) === null || _b === void 0 ? void 0 : _b.map(x => { var _a; return (_a = x.properties[fieldName]) === null || _a === void 0 ? void 0 : _a.value; })) || [];
-            if (attr === "value")
-                return values;
-            if (attr === "valueLength") {
-                return values.map(v => {
-                    if (typeof v === "string" || Array.isArray(v))
-                        return v.length;
-                    throw new Error("valueLength may only be used on arrays and strings");
-                });
-            }
-            if (attr === null || attr === void 0 ? void 0 : attr.startsWith("subField|")) {
-                const subFieldName = attr.slice(9);
-                (0, general_1.assertSafeProperty)(subFieldName);
-                const key = `${fieldName}|${subFieldName}`;
-                const subValueList = ((_c = data[schemaName]) === null || _c === void 0 ? void 0 : _c.map(x => { var _a; return (_a = x.properties[key]) === null || _a === void 0 ? void 0 : _a.value; })) || [];
-                return subValueList;
-            }
-            throw new Error(`Invalid ValuePath[3] for field (${attr})`);
-        }
-        case "schema": {
-            const [, schemaName, attr] = path;
-            (0, general_1.assertSafeProperty)(schemaName);
-            (0, general_1.assertSafeProperty)(attr);
-            if (attr === "meta") {
-                return ((_d = data[schemaName]) === null || _d === void 0 ? void 0 : _d.map(x => x.hSchema)) || [];
-            }
-            throw new Error(`Invalid ValuePath[2] for schema (${attr})`);
-        }
-        default:
-            throw new Error(`Invalid ValuePath[0] (${type})`);
-    }
-}
-exports.getValuesFromPath = getValuesFromPath;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValuesFromPath = void 0;
+const general_1 = require("../../general");
+/** this returns an array because there might be multiple of the same schema shared */
+function getValuesFromPath(path, data) {
+    var _a, _b, _c, _d;
+    const type = path[0];
+    switch (type) {
+        case "field": {
+            const [, schemaName, fieldName, attr] = path;
+            (0, general_1.assertSafeProperty)(schemaName);
+            (0, general_1.assertSafeProperty)(fieldName);
+            (0, general_1.assertSafeProperty)(attr);
+            if (attr === "meta") {
+                return (((_a = data[schemaName]) === null || _a === void 0 ? void 0 : _a.map(x => { var _a; return (_a = x.properties[fieldName]) === null || _a === void 0 ? void 0 : _a.hField; })) || []);
+            }
+            const values = ((_b = data[schemaName]) === null || _b === void 0 ? void 0 : _b.map(x => { var _a; return (_a = x.properties[fieldName]) === null || _a === void 0 ? void 0 : _a.value; })) || [];
+            if (attr === "value")
+                return values;
+            if (attr === "valueLength") {
+                return values.map(v => {
+                    if (typeof v === "string" || Array.isArray(v))
+                        return v.length;
+                    throw new Error("valueLength may only be used on arrays and strings");
+                });
+            }
+            if (attr === null || attr === void 0 ? void 0 : attr.startsWith("subField|")) {
+                const subFieldName = attr.slice(9);
+                (0, general_1.assertSafeProperty)(subFieldName);
+                const key = `${fieldName}|${subFieldName}`;
+                const subValueList = ((_c = data[schemaName]) === null || _c === void 0 ? void 0 : _c.map(x => { var _a; return (_a = x.properties[key]) === null || _a === void 0 ? void 0 : _a.value; })) || [];
+                return subValueList;
+            }
+            throw new Error(`Invalid ValuePath[3] for field (${attr})`);
+        }
+        case "schema": {
+            const [, schemaName, attr] = path;
+            (0, general_1.assertSafeProperty)(schemaName);
+            (0, general_1.assertSafeProperty)(attr);
+            if (attr === "meta") {
+                return ((_d = data[schemaName]) === null || _d === void 0 ? void 0 : _d.map(x => x.hSchema)) || [];
+            }
+            throw new Error(`Invalid ValuePath[2] for schema (${attr})`);
+        }
+        default:
+            throw new Error(`Invalid ValuePath[0] (${type})`);
+    }
+}
+exports.getValuesFromPath = getValuesFromPath;

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

@@ -1,5 +1,5 @@
-export * from "./addInfiniteThresholdBoundaries";
-export * from "./checkTypeofValue";
-export * from "./getValuesFromPath";
-export * from "./symbols";
-export * from "./thresholds";
+export * from "./addInfiniteThresholdBoundaries";
+export * from "./checkTypeofValue";
+export * from "./getValuesFromPath";
+export * from "./symbols";
+export * from "./thresholds";

package/dist/rules/helpers/index.js

@@ -1,21 +1,21 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./addInfiniteThresholdBoundaries"), exports);
-__exportStar(require("./checkTypeofValue"), exports);
-__exportStar(require("./getValuesFromPath"), exports);
-__exportStar(require("./symbols"), exports);
-__exportStar(require("./thresholds"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./addInfiniteThresholdBoundaries"), exports);
+__exportStar(require("./checkTypeofValue"), exports);
+__exportStar(require("./getValuesFromPath"), exports);
+__exportStar(require("./symbols"), exports);
+__exportStar(require("./thresholds"), exports);

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

@@ -1,2 +1,2 @@
-export declare const HFieldSymbol: unique symbol;
-export declare const HSchemaSymbol: unique symbol;
+export declare const HFieldSymbol: unique symbol;
+export declare const HSchemaSymbol: unique symbol;

package/dist/rules/helpers/symbols.js

@@ -1,5 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HSchemaSymbol = exports.HFieldSymbol = void 0;
-exports.HFieldSymbol = Symbol("HField");
-exports.HSchemaSymbol = Symbol("HSchema");
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HSchemaSymbol = exports.HFieldSymbol = void 0;
+exports.HFieldSymbol = Symbol("HField");
+exports.HSchemaSymbol = Symbol("HSchema");

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

@@ -1,5 +1,5 @@
-import { Combinator, ScoreRule } from "../types";
-/** @ignore */
-export declare function getCombinator(combinator: Combinator): [func: (a: number, b: number) => number, initialValue: number];
-/** @ignore */
-export declare function getThresholdBoundary(combinator: Combinator, rules: ScoreRule[]): [lowest: number, highest: number];
+import { Combinator, ScoreRule } from "../types";
+/** @ignore */
+export declare function getCombinator(combinator: Combinator): [func: (a: number, b: number) => number, initialValue: number];
+/** @ignore */
+export declare function getThresholdBoundary(combinator: Combinator, rules: ScoreRule[]): [lowest: number, highest: number];

package/dist/rules/helpers/thresholds.js

@@ -1,47 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getThresholdBoundary = exports.getCombinator = void 0;
-/** @ignore */
-function getCombinator(combinator) {
-    switch (combinator) {
-        case "+":
-            return [(a, b) => a + b, 0];
-        case "*":
-            return [(a, b) => a * b, 1];
-        default:
-            throw new Error("Invalid combinator");
-    }
-}
-exports.getCombinator = getCombinator;
-/** @ignore */
-function getThresholdBoundary(combinator, rules) {
-    switch (combinator) {
-        case "+": {
-            const lowest = rules.reduce((ac, r) => ac + Math.min(r.falseWeight, r.trueWeight), 0);
-            const highest = rules.reduce((ac, r) => ac + Math.max(r.falseWeight, r.trueWeight), 0);
-            return [lowest, highest];
-        }
-        case "*": {
-            // eslint-disable-next-line fp/no-let
-            let [lowest, highest] = [Infinity, -Infinity];
-            // eslint-disable-next-line fp/no-loops, fp/no-let, fp/no-mutation
-            for (let i = 0; i < 2 * rules.length; i += 1) {
-                // loop for every possible combination (2*rules.rength), and check that combination
-                const product = i
-                    .toString(2)
-                    .padStart(rules.length, "0")
-                    .split("")
-                    .map((bool, j) => rules[j][bool === "1" ? "trueWeight" : "falseWeight"])
-                    .reduce((a, b) => a * b, 1);
-                if (product > highest)
-                    highest = product; // eslint-disable-line fp/no-mutation
-                if (product < lowest)
-                    lowest = product; // eslint-disable-line fp/no-mutation
-            }
-            return [lowest, highest];
-        }
-        default:
-            throw new Error("Invalid combinator");
-    }
-}
-exports.getThresholdBoundary = getThresholdBoundary;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThresholdBoundary = exports.getCombinator = void 0;
+/** @ignore */
+function getCombinator(combinator) {
+    switch (combinator) {
+        case "+":
+            return [(a, b) => a + b, 0];
+        case "*":
+            return [(a, b) => a * b, 1];
+        default:
+            throw new Error("Invalid combinator");
+    }
+}
+exports.getCombinator = getCombinator;
+/** @ignore */
+function getThresholdBoundary(combinator, rules) {
+    switch (combinator) {
+        case "+": {
+            const lowest = rules.reduce((ac, r) => ac + Math.min(r.falseWeight, r.trueWeight), 0);
+            const highest = rules.reduce((ac, r) => ac + Math.max(r.falseWeight, r.trueWeight), 0);
+            return [lowest, highest];
+        }
+        case "*": {
+            let [lowest, highest] = [Infinity, -Infinity];
+            // eslint-disable-next-line fp/no-mutation
+            for (let i = 0; i < 2 * rules.length; i += 1) {
+                // loop for every possible combination (2*rules.rength), and check that combination
+                const product = i
+                    .toString(2)
+                    .padStart(rules.length, "0")
+                    .split("")
+                    .map((bool, j) => rules[j][bool === "1" ? "trueWeight" : "falseWeight"])
+                    .reduce((a, b) => a * b, 1);
+                if (product > highest)
+                    highest = product; // eslint-disable-line fp/no-mutation
+                if (product < lowest)
+                    lowest = product; // eslint-disable-line fp/no-mutation
+            }
+            return [lowest, highest];
+        }
+        default:
+            throw new Error("Invalid combinator");
+    }
+}
+exports.getThresholdBoundary = getThresholdBoundary;