@raytio/core 9.0.3 → 10.1.0

package/dist/rules/index.js

@@ -1,20 +1,25 @@
-"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; } });
+"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 });
+exports.scoreOperators = void 0;
+__exportStar(require("./calculateScore"), exports);
+__exportStar(require("./convertInstanceToRuleInput"), exports);
+__exportStar(require("./validate"), 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/isScoreResultValid.d.ts

@@ -0,0 +1,2 @@
+import { ScoreResult } from "./calculateScore";
+export declare const isScoreResultValid: (x: unknown) => x is ScoreResult;

package/dist/rules/isScoreResultValid.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScoreResultValid = void 0;
+/** @internal - separate function so that TS understands whats going on */
+const isObjectLike = (x) => typeof x === "object" && !!x && "score" in x && "category" in x;
+const isScoreResultValid = (x) => isObjectLike(x) &&
+    typeof x.category === "string" &&
+    typeof x.score === "number";
+exports.isScoreResultValid = isScoreResultValid;

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

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

package/dist/rules/operators/array.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayOperators = void 0;
+exports.arrayOperators = {
+    // TODO: support these two
+    // "Array<T> containsItem T": {
+    //   rhsFormat: " contains item {item}",
+    //   operands: [
+    //     { name: "array", type: "Array" },
+    //     { name: "item", type: "*" },
+    //   ],
+    //   implementation<T>(array: T[], item: T) {
+    //     return array.includes(item);
+    //   },
+    // },
+    // "Array<T> doesNotContainItem T": {
+    //   rhsFormat: " does not contain item {item}",
+    //   operands: [
+    //     { name: "array", type: "Array" },
+    //     { name: "item", type: "*" },
+    //   ],
+    //   implementation<T>(array: T[], item: T) {
+    //     return !array.includes(item);
+    //   },
+    // },
+    "Array length== Number": {
+        rhsFormat: " length == {num}",
+        operands: [
+            { name: "str", type: "Array" },
+            { name: "num", type: "Number" },
+        ],
+        implementation: (arr, num) => arr.length === num,
+    },
+    "Array length!= Number": {
+        rhsFormat: " length != {num}",
+        operands: [
+            { name: "str", type: "Array" },
+            { name: "num", type: "Number" },
+        ],
+        implementation: (arr, num) => arr.length !== num,
+    },
+    "Array length>= Number": {
+        rhsFormat: " length >= {num}",
+        operands: [
+            { name: "str", type: "Array" },
+            { name: "num", type: "Number" },
+        ],
+        implementation: (arr, num) => arr.length >= num,
+    },
+    "Array length<= Number": {
+        rhsFormat: " length <= {num}",
+        operands: [
+            { name: "str", type: "Array" },
+            { name: "num", type: "Number" },
+        ],
+        implementation: (arr, num) => arr.length <= num,
+    },
+    "Array length< Number": {
+        rhsFormat: " length < {num}",
+        operands: [
+            { name: "str", type: "Array" },
+            { name: "num", type: "Number" },
+        ],
+        implementation: (arr, num) => arr.length < num,
+    },
+    "Array length> Number": {
+        rhsFormat: " length > {num}",
+        operands: [
+            { name: "str", type: "Array" },
+            { name: "num", type: "Number" },
+        ],
+        implementation: (arr, num) => arr.length > num,
+    },
+};

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

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

package/dist/rules/operators/bool.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.boolOperators = void 0;
-exports.boolOperators = {
-    bool_eq: {
-        operands: ["Bool", "Bool"],
-        implementation(b1, b2) {
-            return b1 === b2;
-        },
-    },
-    bool_neq: {
-        operands: ["Bool", "Bool"],
-        implementation(b1, b2) {
-            return b1 !== b2;
-        },
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolOperators = void 0;
+exports.boolOperators = {
+    bool_eq: {
+        operands: ["Bool", "Bool"],
+        implementation(b1, b2) {
+            return b1 === b2;
+        },
+    },
+    bool_neq: {
+        operands: ["Bool", "Bool"],
+        implementation(b1, b2) {
+            return b1 !== b2;
+        },
+    },
+};

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

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

package/dist/rules/operators/date.js

@@ -1,91 +1,91 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dateOperators = void 0;
-function getDateInXUnits(offset, unit) {
-    const d = new Date();
-    switch (unit) {
-        case "ms":
-            d.setMilliseconds(d.getMilliseconds() + offset);
-            break;
-        case "s":
-            d.setSeconds(d.getSeconds() + offset);
-            break;
-        case "m":
-            d.setMinutes(d.getMinutes() + offset);
-            break;
-        case "h":
-            d.setHours(d.getHours() + offset);
-            break;
-        case "D":
-            d.setDate(d.getDate() + offset);
-            break;
-        case "M":
-            d.setMonth(d.getMonth() + offset);
-            break;
-        case "W":
-            d.setDate(d.getDate() + 7 * offset);
-            break;
-        case "Y":
-            d.setFullYear(d.getFullYear() + offset);
-            break;
-        default:
-            throw new Error(`Invalid date unit: ${unit}`);
-    }
-    return d;
-}
-exports.dateOperators = {
-    date_eq: {
-        operands: ["Date", "Date"],
-        implementation(d1, d2) {
-            // only comaparing dates (not times), and in the UTC timezone.
-            const isoDate1 = d1.toISOString().split("T")[0];
-            const isoDate2 = d2.toISOString().split("T")[0];
-            return isoDate1 === isoDate2;
-        },
-    },
-    date_neq: {
-        operands: ["Date", "Date"],
-        implementation(d1, d2) {
-            // only comaparing dates (not times), and in the UTC timezone.
-            const isoDate1 = d1.toISOString().split("T")[0];
-            const isoDate2 = d2.toISOString().split("T")[0];
-            return isoDate1 !== isoDate2;
-        },
-    },
-    date_valid: {
-        operands: ["Date"],
-        implementation: (d) => !Number.isNaN(+d),
-    },
-    date_invalid: {
-        operands: ["Date"],
-        implementation: (d) => Number.isNaN(+d),
-    },
-    date_before: {
-        operands: ["Date", "Date"],
-        implementation: (d1, d2) => d1 < d2,
-    },
-    date_after: {
-        operands: ["Date", "Date"],
-        implementation: (d1, d2) => d1 > d2,
-    },
-    date_between: {
-        operands: ["Date", "Date", "Date"],
-        implementation(lhs, lower, upper) {
-            return lhs >= lower && lhs <= upper;
-        },
-    },
-    date_older_than: {
-        operands: ["Date", "Number", "DateUnit"],
-        implementation(date, num, unit) {
-            const XUnitsAgo = getDateInXUnits(-num, unit);
-            return date < XUnitsAgo;
-        },
-    },
-    date_newer_than: {
-        operands: ["Date", "Number", "DateUnit"],
-        implementation(date, num, unit) {
-            const inXUnits = getDateInXUnits(num, unit);
-            return date > inXUnits;
-        },
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateOperators = void 0;
+function getDateInXUnits(offset, unit) {
+    const d = new Date();
+    switch (unit) {
+        case "ms":
+            d.setMilliseconds(d.getMilliseconds() + offset);
+            break;
+        case "s":
+            d.setSeconds(d.getSeconds() + offset);
+            break;
+        case "m":
+            d.setMinutes(d.getMinutes() + offset);
+            break;
+        case "h":
+            d.setHours(d.getHours() + offset);
+            break;
+        case "D":
+            d.setDate(d.getDate() + offset);
+            break;
+        case "M":
+            d.setMonth(d.getMonth() + offset);
+            break;
+        case "W":
+            d.setDate(d.getDate() + 7 * offset);
+            break;
+        case "Y":
+            d.setFullYear(d.getFullYear() + offset);
+            break;
+        default:
+            throw new Error(`Invalid date unit: ${unit}`);
+    }
+    return d;
+}
+exports.dateOperators = {
+    date_eq: {
+        operands: ["Date", "Date"],
+        implementation(d1, d2) {
+            // only comaparing dates (not times), and in the UTC timezone.
+            const isoDate1 = d1.toISOString().split("T")[0];
+            const isoDate2 = d2.toISOString().split("T")[0];
+            return isoDate1 === isoDate2;
+        },
+    },
+    date_neq: {
+        operands: ["Date", "Date"],
+        implementation(d1, d2) {
+            // only comaparing dates (not times), and in the UTC timezone.
+            const isoDate1 = d1.toISOString().split("T")[0];
+            const isoDate2 = d2.toISOString().split("T")[0];
+            return isoDate1 !== isoDate2;
+        },
+    },
+    date_valid: {
+        operands: ["Date"],
+        implementation: (d) => !Number.isNaN(+d),
+    },
+    date_invalid: {
+        operands: ["Date"],
+        implementation: (d) => Number.isNaN(+d),
+    },
+    date_before: {
+        operands: ["Date", "Date"],
+        implementation: (d1, d2) => d1 < d2,
+    },
+    date_after: {
+        operands: ["Date", "Date"],
+        implementation: (d1, d2) => d1 > d2,
+    },
+    date_between: {
+        operands: ["Date", "Date", "Date"],
+        implementation(lhs, lower, upper) {
+            return lhs >= lower && lhs <= upper;
+        },
+    },
+    date_older_than: {
+        operands: ["Date", "Number", "DateUnit"],
+        implementation(date, num, unit) {
+            const XUnitsAgo = getDateInXUnits(-num, unit);
+            return date < XUnitsAgo;
+        },
+    },
+    date_newer_than: {
+        operands: ["Date", "Number", "DateUnit"],
+        implementation(date, num, unit) {
+            const inXUnits = getDateInXUnits(num, unit);
+            return date > inXUnits;
+        },
+    },
+};

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

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

package/dist/rules/operators/hfield.js

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldOperators = void 0;
-exports.fieldOperators = {
-    field_verifiedBy: {
-        operands: ["HField", "String"],
-        implementation(field, verifiedBy) {
-            return field.verifiedBy.includes(verifiedBy);
-        },
-    },
-    field_shared: {
-        operands: ["HField"],
-        implementation: () => true, // we can return true, because if the field didn't exist, this would never be called
-    },
-    field_hasVerStatus: {
-        operands: ["HField", "FieldVerification"],
-        implementation(field, status) {
-            return field.verification === status;
-        },
-    },
-    field_cameFromSchema: {
-        operands: ["HField", "String"],
-        implementation(field, schemaName) {
-            return field.cameFromSchema === schemaName;
-        },
-    },
-    field_ncameFromSchema: {
-        operands: ["HField", "String"],
-        implementation(field, schemaName) {
-            return field.cameFromSchema !== schemaName;
-        },
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldOperators = void 0;
+exports.fieldOperators = {
+    field_verifiedBy: {
+        operands: ["HField", "Verifier"],
+        implementation(field, verifiedBy) {
+            return field.verifiedBy.includes(verifiedBy);
+        },
+    },
+    field_shared: {
+        operands: ["HField"],
+        implementation: () => true, // we can return true, because if the field didn't exist, this would never be called
+    },
+    field_hasVerStatus: {
+        operands: ["HField", "FieldVerification"],
+        implementation(field, status) {
+            return field.verification === status;
+        },
+    },
+    field_cameFromSchema: {
+        operands: ["HField", "String"],
+        implementation(field, schemaName) {
+            return field.cameFromSchema === schemaName;
+        },
+    },
+    field_ncameFromSchema: {
+        operands: ["HField", "String"],
+        implementation(field, schemaName) {
+            return field.cameFromSchema !== schemaName;
+        },
+    },
+};

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

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

package/dist/rules/operators/hschema.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaOperators = void 0;
-exports.schemaOperators = {
-    schema_verifiedBy: {
-        operands: ["HSchema", "String"],
-        implementation(schema, verifiedBy) {
-            return schema === null || schema === void 0 ? void 0 : schema.verifiedBy.includes(verifiedBy);
-        },
-    },
-    schema_shared: {
-        operands: ["HSchema"],
-        implementation: () => true, // we can return true, because if the schema didn't exist, this would never be called
-    },
-    schema_hasVerStatus: {
-        operands: ["HSchema", "POVerification"],
-        implementation(schema, status) {
-            return (schema === null || schema === void 0 ? void 0 : schema.verification) === status;
-        },
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaOperators = void 0;
+exports.schemaOperators = {
+    schema_verifiedBy: {
+        operands: ["HSchema", "Verifier"],
+        implementation(schema, verifiedBy) {
+            return schema === null || schema === void 0 ? void 0 : schema.verifiedBy.includes(verifiedBy);
+        },
+    },
+    schema_shared: {
+        operands: ["HSchema"],
+        implementation: () => true, // we can return true, because if the schema didn't exist, this would never be called
+    },
+    schema_hasVerStatus: {
+        operands: ["HSchema", "POVerification"],
+        implementation(schema, status) {
+            return (schema === null || schema === void 0 ? void 0 : schema.verification) === status;
+        },
+    },
+};

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

@@ -1,3 +1,3 @@
-import { OperatorID, OperatorDef } from "../types";
-/** @ignore */
-export declare const operators: Record<OperatorID, OperatorDef>;
+import { OperatorID, OperatorDef } from "../types";
+/** @ignore */
+export declare const operators: Record<OperatorID, OperatorDef>;

package/dist/rules/operators/index.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.operators = void 0;
-const bool_1 = require("./bool");
-const date_1 = require("./date");
-const hfield_1 = require("./hfield");
-const hschema_1 = require("./hschema");
-const number_1 = require("./number");
-const string_1 = require("./string");
-/** @ignore */
-exports.operators = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, bool_1.boolOperators), date_1.dateOperators), hfield_1.fieldOperators), hschema_1.schemaOperators), number_1.numberOperators), string_1.stringOperators);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operators = void 0;
+const bool_1 = require("./bool");
+const date_1 = require("./date");
+const hfield_1 = require("./hfield");
+const hschema_1 = require("./hschema");
+const number_1 = require("./number");
+const string_1 = require("./string");
+/** @ignore */
+exports.operators = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, bool_1.boolOperators), date_1.dateOperators), hfield_1.fieldOperators), hschema_1.schemaOperators), number_1.numberOperators), string_1.stringOperators);

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

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

package/dist/rules/operators/number.js

@@ -1,41 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.numberOperators = void 0;
-exports.numberOperators = {
-    num_eq: {
-        operands: ["Number", "Number"],
-        implementation(n1, n2) {
-            return n1 === n2;
-        },
-    },
-    num_neq: {
-        operands: ["Number", "Number"],
-        implementation(n1, n2) {
-            return n1 !== n2;
-        },
-    },
-    num_gt_eq: {
-        operands: ["Number", "Number"],
-        implementation(n1, n2) {
-            return n1 >= n2;
-        },
-    },
-    num_lt_eq: {
-        operands: ["Number", "Number"],
-        implementation(n1, n2) {
-            return n1 <= n2;
-        },
-    },
-    num_gt: {
-        operands: ["Number", "Number"],
-        implementation(n1, n2) {
-            return n1 > n2;
-        },
-    },
-    num_lt: {
-        operands: ["Number", "Number"],
-        implementation(n1, n2) {
-            return n1 < n2;
-        },
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberOperators = void 0;
+exports.numberOperators = {
+    num_eq: {
+        operands: ["Number", "Number"],
+        implementation(n1, n2) {
+            return n1 === n2;
+        },
+    },
+    num_neq: {
+        operands: ["Number", "Number"],
+        implementation(n1, n2) {
+            return n1 !== n2;
+        },
+    },
+    num_gt_eq: {
+        operands: ["Number", "Number"],
+        implementation(n1, n2) {
+            return n1 >= n2;
+        },
+    },
+    num_lt_eq: {
+        operands: ["Number", "Number"],
+        implementation(n1, n2) {
+            return n1 <= n2;
+        },
+    },
+    num_gt: {
+        operands: ["Number", "Number"],
+        implementation(n1, n2) {
+            return n1 > n2;
+        },
+    },
+    num_lt: {
+        operands: ["Number", "Number"],
+        implementation(n1, n2) {
+            return n1 < n2;
+        },
+    },
+};

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

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