@raytio/core 8.1.1 → 9.0.1

package/dist/general/password.js

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashPassword = void 0;
-// ⚠ updating this value will lock all existing users out of their accounts
-/** @internal */
-const SALT = "247 213 94 9 15 236 156 48 194 177 107 216 198 215 169 239";
-/**
- * AWS Cognito never gets the raw password. We send them
- * a hashed verison using PBKDF2 with SHA-256 and 10,000
- * iterations.
- * @param password The raw password
- * @returns Promise resolving to the hashed password
- */
-async function hashPassword(password) {
-    const binaryPassword = new TextEncoder().encode(password);
-    const cryptoKey = await crypto.subtle.importKey("raw", binaryPassword, "PBKDF2", false, ["deriveBits"]);
-    const options = {
-        name: "PBKDF2",
-        hash: "SHA-256",
-        salt: new Uint8Array(SALT.split(" ").map(Number)),
-        iterations: 10000,
-    };
-    const keyBuffer = new Uint8Array(await crypto.subtle.deriveBits(options, cryptoKey, 256));
-    const compositeStr = Array.from(keyBuffer)
-        .map(byte => String.fromCharCode(byte))
-        .join("");
-    return btoa(compositeStr);
-}
-exports.hashPassword = hashPassword;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashPassword = void 0;
+// ⚠ updating this value will lock all existing users out of their accounts
+/** @internal */
+const SALT = "247 213 94 9 15 236 156 48 194 177 107 216 198 215 169 239";
+/**
+ * AWS Cognito never gets the raw password. We send them
+ * a hashed verison using PBKDF2 with SHA-256 and 10,000
+ * iterations.
+ * @param password The raw password
+ * @returns Promise resolving to the hashed password
+ */
+async function hashPassword(password) {
+    const binaryPassword = new TextEncoder().encode(password);
+    const cryptoKey = await crypto.subtle.importKey("raw", binaryPassword, "PBKDF2", false, ["deriveBits"]);
+    const options = {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        salt: new Uint8Array(SALT.split(" ").map(Number)),
+        iterations: 10000,
+    };
+    const keyBuffer = new Uint8Array(await crypto.subtle.deriveBits(options, cryptoKey, 256));
+    const compositeStr = Array.from(keyBuffer)
+        .map(byte => String.fromCharCode(byte))
+        .join("");
+    return btoa(compositeStr);
+}
+exports.hashPassword = hashPassword;

package/dist/general/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * to prevent a key from the JS object prototype (e.g. `__proto__`) from
+ * returning an unexpected value (see #1162)
+ * @ignore
+ */
+export declare function assertSafeProperty(key: string): asserts key is string;

package/dist/general/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSafeProperty = void 0;
+/**
+ * to prevent a key from the JS object prototype (e.g. `__proto__`) from
+ * returning an unexpected value (see #1162)
+ * @ignore
+ */
+function assertSafeProperty(key) {
+    if (key in {})
+        throw new Error("Unacceptable object property");
+}
+exports.assertSafeProperty = assertSafeProperty;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export * from "./accessApplication";
-export * from "./crypto";
-export * from "./general";
-export * from "./schema";
-export * from "./verifications";
+export * from "./accessApplication";
+export * from "./crypto";
+export * from "./general";
+export * from "./rules";
+export * from "./schema";
+export * from "./verifications";

package/dist/index.js

@@ -1,17 +1,18 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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("./accessApplication"), exports);
-__exportStar(require("./crypto"), exports);
-__exportStar(require("./general"), exports);
-__exportStar(require("./schema"), exports);
-__exportStar(require("./verifications"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./accessApplication"), exports);
+__exportStar(require("./crypto"), exports);
+__exportStar(require("./general"), exports);
+__exportStar(require("./rules"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./verifications"), exports);

package/dist/rules/calculateScore.d.ts

@@ -0,0 +1,11 @@
+import { RuleData, ScoreConfig } from "./types";
+/** @ignore */
+export declare type ScoreResult = {
+    score: number;
+    category: string;
+};
+/**
+ * the main function to calculate a score and category.
+ * Might throw an error.
+ */
+export declare function calculateScore(ruleConfig: ScoreConfig, ruleInput: RuleData): ScoreResult;

package/dist/rules/calculateScore.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateScore = void 0;
+const evaluateScoreCondition_1 = require("./evaluateScoreCondition");
+const helpers_1 = require("./helpers");
+function evaluateASTNode(node, data) {
+    if (node.type === "LanguageOperator") {
+        if (!node.children.length) {
+            // we allow a single child because why not.
+            throw new Error("LanguageOperator has no children");
+        }
+        if (node.operator === "AND") {
+            return node.children.every(n => evaluateASTNode(n, data));
+        }
+        if (node.operator === "OR") {
+            return node.children.some(n => evaluateASTNode(n, data));
+        }
+        throw new Error(`LanguageOperator node has invalid operator '${node.operator}'`);
+    }
+    if (node.type === "ScoreCondition") {
+        return (0, evaluateScoreCondition_1.evaluateScoreCondition)(node, data);
+    }
+    throw new Error("ASTNode has invalid type");
+}
+function evaluateRule(rule, data) {
+    if (rule.tree.length !== 1) {
+        throw new Error("A rule may only have 1 root node");
+    }
+    const rulePassed = rule.tree.every(n => evaluateASTNode(n, data));
+    return rulePassed ? rule.trueWeight : rule.falseWeight;
+}
+/**
+ * the main function to calculate a score and category.
+ * Might throw an error.
+ */
+function calculateScore(ruleConfig, ruleInput) {
+    const result = ruleConfig.rules.map(rule => evaluateRule(rule, ruleInput));
+    const [addOrMultiply, initialValue] = (0, helpers_1.getCombinator)(ruleConfig.combinator);
+    const finalScore = result.reduce(addOrMultiply, initialValue);
+    const matchingCategories = (0, helpers_1.addInfiniteThresholdBoundaries)(ruleConfig.scoreThresholds).filter(threshold => finalScore >= threshold.from && finalScore <= threshold.to);
+    if (matchingCategories.length === 0) {
+        throw new Error(`No categories match the final score (${finalScore})`);
+    }
+    if (matchingCategories.length !== 1) {
+        throw new Error(`Multiple categories match the final score (${finalScore})`);
+    }
+    return {
+        score: finalScore,
+        category: matchingCategories[0].name,
+    };
+}
+exports.calculateScore = calculateScore;

package/dist/rules/convertInstanceToRuleInput.d.ts

@@ -0,0 +1,3 @@
+import { Instance, RealVer, Schema } from "@raytio/types";
+import { RuleData } from "./types";
+export declare const convertInstanceToRuleInput: (instance: Instance, realVers: RealVer[], getSchema: (schemaName: string) => Promise<Schema>) => Promise<RuleData>;

package/dist/rules/convertInstanceToRuleInput.js

@@ -0,0 +1,140 @@
+"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);
+            // TODO: better system
+            const dayFieldName = memberFieldNames.find(f => f.includes("day"));
+            const monthFieldName = memberFieldNames.find(f => f.includes("month"));
+            const yearFieldName = memberFieldNames.find(f => f.includes("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

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

package/dist/rules/evaluateScoreCondition.js

@@ -0,0 +1,45 @@
+"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 (argType !== 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 value
+            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/rules/helpers/addInfiniteThresholdBoundaries.d.ts

@@ -0,0 +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[];

package/dist/rules/helpers/addInfiniteThresholdBoundaries.js

@@ -0,0 +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 }))));

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

@@ -0,0 +1,3 @@
+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>;

package/dist/rules/helpers/checkTypeofValue.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 "String":
+            return typeof value === "string";
+        default:
+            return false;
+    }
+}
+exports.checkTypeofValue = checkTypeofValue;

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

@@ -0,0 +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[];

package/dist/rules/helpers/getValuesFromPath.js

@@ -0,0 +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;

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

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

package/dist/rules/helpers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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

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

package/dist/rules/helpers/symbols.js

@@ -0,0 +1,5 @@
+"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

@@ -0,0 +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];

package/dist/rules/helpers/thresholds.js

@@ -0,0 +1,47 @@
+"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;

package/dist/rules/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./calculateScore";
+export * from "./convertInstanceToRuleInput";
+export * from "./types/config";
+export * from "./helpers/thresholds";
+export * from "./helpers/addInfiniteThresholdBoundaries";
+export { operators as scoreOperators } from "./operators";

package/dist/rules/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+exports.scoreOperators = void 0;
+__exportStar(require("./calculateScore"), exports);
+__exportStar(require("./convertInstanceToRuleInput"), exports);
+__exportStar(require("./types/config"), exports);
+__exportStar(require("./helpers/thresholds"), exports);
+__exportStar(require("./helpers/addInfiniteThresholdBoundaries"), exports);
+var operators_1 = require("./operators");
+Object.defineProperty(exports, "scoreOperators", { enumerable: true, get: function () { return operators_1.operators; } });

package/dist/rules/operators/bool.d.ts

@@ -0,0 +1,2 @@
+import { OperatorID, OperatorDef } from "../types";
+export declare const boolOperators: Partial<Record<OperatorID, OperatorDef>>;