@raytio/core 8.1.3 → 9.0.0

package/README.md

@@ -10,7 +10,7 @@ Nodejs does not support [fetch](https://developer.mozilla.org/en-US/docs/Web/API
 
 If you use the high-level [`@raytio/decrypt-helper`](https://npm.im/@raytio/decrypt-helper) module, you don't need to worry about this.
 
-If you wish to use `@raytio/core` directly, an example of configuring polyfills for nodejs is availble [here](https://gitlab.com/raytio/tools/decrypt-helper/-/blob/master/src/configureEnv.ts)
+If you wish to use `@raytio/core` directly, an example of configuring polyfills for nodejs is availble [here](https://gitlab.com/raytio/tools/decrypt-helper/-/blob/main/src/configureEnv.ts)
 
 # API
 
@@ -24,14 +24,17 @@ If you wish to use `@raytio/core` directly, an example of configuring polyfills
 ### Functions
 
 - [calcSafeHarbourScore](#calcsafeharbourscore)
+- [calculateScore](#calculatescore)
 - [cleanInstance](#cleaninstance)
+- [convertInstanceToRuleInput](#convertinstancetoruleinput)
 - [createAA](#createaa)
 - [decryptSharedData](#decryptshareddata)
 - [findSchemaLabel](#findschemalabel)
 - [fromCognitoAttributes](#fromcognitoattributes)
 - [getAADecryptor](#getaadecryptor)
+- [getOwnRealVerifications](#getownrealverifications)
 - [getPOVerification](#getpoverification)
-- [getRealVerifications](#getrealverifications)
+- [getSomeoneElsesRealVerifications](#getsomeoneelsesrealverifications)
 - [hashPassword](#hashpassword)
 - [isConditionMet](#isconditionmet)
 - [isEncrypted](#isencrypted)
@@ -70,7 +73,7 @@ the response from [calcSafeHarbourScore](#calcsafeharbourscore)
 
 The Safe Harbour Score indidicates whether a person's identity has been verified
 to the extent requried for Safe Harbour Compliance. This requires multiple verifications
-from different sources. For infomation, refer to the
+from different sources. For information, refer to the
 [Raytio Documentation](https://dev-docs.rayt.io/docs/features/pep-checks).
 
 #### Parameters
@@ -78,8 +81,8 @@ from different sources. For infomation, refer to the
 | Name | Type |
 | :------ | :------ |
 | `data` | `Object` |
-| `data.person` | `ProfileObject`<`any`\> |
-| `data.profileObjects` | `ProfileObject`<`any`\>[] |
+| `data.person` | `ProfileObject`<`Json`\> |
+| `data.profileObjects` | `ProfileObject`<`Json`\>[] |
 | `data.realVers` | `RealVer`[] |
 | `data.getSchema` | (`schemaName`: `string`) => `Promise`<`Schema`\> |
 
@@ -89,6 +92,26 @@ from different sources. For infomation, refer to the
 
 ___
 
+### calculateScore
+
+▸ **calculateScore**(`ruleConfig`, `ruleInput`): `ScoreResult`
+
+the main function to calculate a score and category.
+Might throw an error.
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `ruleConfig` | `ScoreConfig` |
+| `ruleInput` | `RuleData` |
+
+#### Returns
+
+`ScoreResult`
+
+___
+
 ### cleanInstance
 
 ▸ **cleanInstance**(`instance`): `Instance`
@@ -111,6 +134,24 @@ We relace `hashed_n_id`s with a string `HASHED::{NId}::{AId}`
 
 ___
 
+### convertInstanceToRuleInput
+
+▸ `Const` **convertInstanceToRuleInput**(`instance`, `realVers`, `getSchema`): `Promise`<`RuleData`\>
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `instance` | `Instance` |
+| `realVers` | `RealVer`[] |
+| `getSchema` | (`schemaName`: `string`) => `Promise`<`Schema`\> |
+
+#### Returns
+
+`Promise`<`RuleData`\>
+
+___
+
 ### createAA
 
 ▸ **createAA**(`__namedParameters`): `Promise`<`AA`\>
@@ -227,6 +268,32 @@ an `ApplicationEncryptor` and the public key of the Access Application
 
 ___
 
+### getOwnRealVerifications
+
+▸ `Const` **getOwnRealVerifications**(`__namedParameters`): `Promise`<`RealVer`[]\>
+
+Given a list of verifications and decrypted profile objects, this function
+locally verifies the credibility of the signatures in the verifications.
+
+This function does NOT call the API, except to fetch the public key.
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `__namedParameters` | `Object` |
+| `__namedParameters.profileObjects` | `ProfileObject`<`Json`\>[] |
+| `__namedParameters.userId` | `UId` |
+| `__namedParameters.verifications` | `Verification`<``false``\>[] |
+
+#### Returns
+
+`Promise`<`RealVer`[]\>
+
+a list of authentic RealVer
+
+___
+
 ### getPOVerification
 
 ▸ **getPOVerification**(`__namedParameters`): `Object`
@@ -238,7 +305,7 @@ Determines the verification status of a profile object, and its individual field
 | Name | Type |
 | :------ | :------ |
 | `__namedParameters` | `Object` |
-| `__namedParameters.PO` | `ProfileObject`<`any`\> \| `ProfileObjectForUpload`<`any`\> |
+| `__namedParameters.PO` | `ProfileObject`<`Json`\> \| `ProfileObjectForUpload`<`Json`\> |
 | `__namedParameters.realVers` | `RealVer`[] |
 | `__namedParameters.schema` | `Schema` |
 
@@ -248,20 +315,24 @@ Determines the verification status of a profile object, and its individual field
 
 | Name | Type |
 | :------ | :------ |
-| `details` | `VerificationProvider`[] |
+| `details` | `Object` |
+| `details.sourceNId?` | `NId` |
+| `details.verifiers` | `VerificationProvider`[] |
 | `fieldVerifications` | `Record`<`string`, `FieldVerification`\> |
 | `status` | `POVerification` |
 
 ___
 
-### getRealVerifications
+### getSomeoneElsesRealVerifications
 
-▸ `Const` **getRealVerifications**(`__namedParameters`): `Promise`<`RealVer`[]\>
+▸ `Const` **getSomeoneElsesRealVerifications**(`__namedParameters`): `Promise`<`RealVer`[]\>
 
 Given a list of verifications and decrypted profile objects, this function calls
 the Raytio API to verify the credibility of these verifications, returning only valid
 verifications.
 
+❗ prefer `getOwnRealVerifications` if the data to be verified belongs to the current user.
+
 #### Parameters
 
 | Name | Type |
@@ -360,7 +431,7 @@ ___
 
 ### someEncrypted
 
-▸ `Const` **someEncrypted**<`T`, `K`\>(`x`): `number`
+▸ `Const` **someEncrypted**<`T`, `K`\>(...`args`): `number`
 
 Given a profile object's properties, returns the number
 of properties that are encryted.
@@ -376,7 +447,7 @@ of properties that are encryted.
 
 | Name | Type |
 | :------ | :------ |
-| `x` | `T` |
+| `...args` | [obj: T] |
 
 #### Returns
 

package/dist/accessApplication/createAA.js

@@ -46,7 +46,6 @@ async function createApplicationEncryptor(userDoc, maxcryptor) {
  */
 async function createAA({ apiUrl, apiToken, userDoc, maxcryptor, application, }) {
     if (!application.org_id) {
-        // eslint-disable-next-line fp/no-throw
         throw new Error("Cannot create an AA without an org_id");
     }
     const newApp = await createApplication({

package/dist/crypto/decryptKeys.js

@@ -13,7 +13,6 @@ const decryptKeys = async ({ applicationDecryptor, keys, data, onCorruptedData,
             const error = new Error(`Can't decrypt shared data because there are no keys for ${key}`);
             if (onCorruptedData)
                 return [key, onCorruptedData(key, value, error)];
-            // eslint-disable-next-line fp/no-throw
             throw error;
         }
         try {
@@ -26,7 +25,6 @@ const decryptKeys = async ({ applicationDecryptor, keys, data, onCorruptedData,
             const error = _ex instanceof Error ? _ex : new Error(`${_ex}`);
             if (onCorruptedData)
                 return [key, onCorruptedData(key, value, error)];
-            // eslint-disable-next-line fp/no-throw
             throw error;
         }
     }));

package/dist/crypto/helpers.d.ts

@@ -15,4 +15,4 @@ export declare const isEncryptedFile: (value: unknown) => value is Encrypted<str
  * Given a profile object's properties, returns the number
  * of properties that are encryted.
  */
-export declare const someEncrypted: <T extends object, K extends keyof T>(x: T) => number;
+export declare const someEncrypted: <T extends object, K extends keyof T>(obj: T) => number;

package/dist/general/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./conditional";
 export * from "./password";
+export * from "./types";

package/dist/general/index.js

@@ -12,3 +12,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./conditional"), exports);
 __exportStar(require("./password"), exports);
+__exportStar(require("./types"), exports);

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 "./rules";
 export * from "./schema";
 export * from "./verifications";

package/dist/index.js

@@ -13,5 +13,6 @@ 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";