@raytio/core 10.1.0 → 11.0.0

package/dist/rules/operators/__tests__/hfield.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@raytio/types");
+const hfield_1 = require("../hfield");
+describe("fieldOperators", () => {
+    it("field_shared", () => {
+        expect(hfield_1.fieldOperators.field_shared.implementation()).toBe(true);
+    });
+    it.each `
+    field                         | verifier                | result
+    ${{ verifiedBy: ["MoH"] }}    | ${"MoH"}                | ${true}
+    ${{ verifiedBy: ["MinEdu"] }} | ${"Ministry of Health"} | ${false}
+    ${{ verifiedBy: [] }}         | ${"Ministry of Health"} | ${false}
+  `("field_verifiedBy {...}, $verifier", ({ field, verifier, result }) => {
+        expect(hfield_1.fieldOperators.field_verifiedBy.implementation(field, verifier)).toBe(result);
+    });
+    it.each `
+    field                               | value          | result
+    ${{ verification: types_1.FieldVerification.Verified }}    | ${types_1.FieldVerification.Verified} | ${true}
+    ${{ verification: types_1.FieldVerification.NotVerified }} | ${types_1.FieldVerification.Verified} | ${false}
+  `("field_hasVerStatus {...}, $value", ({ field, value, result }) => {
+        expect(hfield_1.fieldOperators.field_hasVerStatus.implementation(field, value)).toBe(result);
+    });
+    it.each `
+    field                         | value     | result
+    ${{ cameFromSchema: "ss_A" }} | ${"ss_A"} | ${true}
+    ${{ cameFromSchema: "ss_A" }} | ${"ss_B"} | ${false}
+  `("field_cameFromSchema {...}, $value", ({ field, value, result }) => {
+        expect(hfield_1.fieldOperators.field_cameFromSchema.implementation(field, value)).toBe(result);
+    });
+    it.each `
+    field                         | value     | result
+    ${{ cameFromSchema: "ss_A" }} | ${"ss_A"} | ${false}
+    ${{ cameFromSchema: "ss_A" }} | ${"ss_B"} | ${true}
+  `("field_ncameFromSchema {...}, $value", ({ field, value, result }) => {
+        expect(hfield_1.fieldOperators.field_ncameFromSchema.implementation(field, value)).toBe(result);
+    });
+});

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

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

package/dist/rules/operators/__tests__/hschema.test.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@raytio/types");
+const hschema_1 = require("../hschema");
+describe("schemaOperators", () => {
+    it("schema_shared", () => {
+        expect(hschema_1.schemaOperators.schema_shared.implementation()).toBe(true);
+    });
+    it.each `
+    field                         | verifier                | result
+    ${{ verifiedBy: ["MoH"] }}    | ${"MoH"}                | ${true}
+    ${{ verifiedBy: ["MinEdu"] }} | ${"Ministry of Health"} | ${false}
+    ${{ verifiedBy: [] }}         | ${"Ministry of Health"} | ${false}
+  `("schema_verifiedBy {...}, $verifier", ({ field, verifier, result }) => {
+        expect(hschema_1.schemaOperators.schema_verifiedBy.implementation(field, verifier)).toBe(result);
+    });
+    it.each `
+    field                                 | value               | result
+    ${{ verification: types_1.POVerification.FullyVerified }} | ${types_1.POVerification.FullyVerified} | ${true}
+    ${{ verification: types_1.POVerification.NotVerified }}   | ${types_1.POVerification.FullyVerified} | ${false}
+  `("schema_hasVerStatus {...}, $value", ({ field, value, result }) => {
+        expect(hschema_1.schemaOperators.schema_hasVerStatus.implementation(field, value)).toBe(result);
+    });
+});

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

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

package/dist/rules/operators/__tests__/number.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const number_1 = require("../number");
+describe("numberOperators", () => {
+    it.each `
+    a         | b         | result
+    ${1}      | ${1}      | ${true}
+    ${1}      | ${2}      | ${false}
+    ${3.3333} | ${3.3333} | ${true}
+  `("num_eq $a, $b", ({ a, b, result }) => {
+        expect(number_1.numberOperators.num_eq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a         | b         | result
+    ${1}      | ${1}      | ${false}
+    ${1}      | ${2}      | ${true}
+    ${3.3333} | ${3.3333} | ${false}
+  `("num_neq $a, $b", ({ a, b, result }) => {
+        expect(number_1.numberOperators.num_neq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a    | b    | result
+    ${0} | ${1} | ${false}
+    ${1} | ${1} | ${true}
+    ${2} | ${1} | ${true}
+  `("num_gt_eq $a, $b", ({ a, b, result }) => {
+        expect(number_1.numberOperators.num_gt_eq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a    | b    | result
+    ${0} | ${1} | ${false}
+    ${1} | ${1} | ${false}
+    ${2} | ${1} | ${true}
+  `("num_gt $a, $b", ({ a, b, result }) => {
+        expect(number_1.numberOperators.num_gt.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a    | b    | result
+    ${0} | ${1} | ${true}
+    ${1} | ${1} | ${true}
+    ${2} | ${1} | ${false}
+  `("num_lt_eq $a, $b", ({ a, b, result }) => {
+        expect(number_1.numberOperators.num_lt_eq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a    | b    | result
+    ${0} | ${1} | ${true}
+    ${1} | ${1} | ${false}
+    ${2} | ${1} | ${false}
+  `("num_lt $a, $b", ({ a, b, result }) => {
+        expect(number_1.numberOperators.num_lt.implementation(a, b)).toBe(result);
+    });
+});

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

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

package/dist/rules/operators/__tests__/string.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const string_1 = require("../string");
+describe("stringOperators", () => {
+    it.each `
+    a       | b       | result
+    ${"AA"} | ${"aa"} | ${true}
+    ${"Aa"} | ${"Bb"} | ${false}
+  `("string_eq $a, $b", ({ a, b, result }) => {
+        expect(string_1.stringOperators.string_eq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a       | b       | result
+    ${"AA"} | ${"aa"} | ${false}
+    ${"Aa"} | ${"Bb"} | ${true}
+  `("string_neq $a, $b", ({ a, b, result }) => {
+        expect(string_1.stringOperators.string_neq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    str        | substr  | result
+    ${"alOOf"} | ${"oo"} | ${true}
+    ${"Hello"} | ${""}   | ${true}
+    ${"Hello"} | ${"X"}  | ${false}
+  `("string_contains $str, $substr", ({ str, substr, result }) => {
+        expect(string_1.stringOperators.string_contains.implementation(str, substr)).toBe(result);
+    });
+    it.each `
+    str        | substr  | result
+    ${"alOOf"} | ${"oo"} | ${false}
+    ${"Hello"} | ${""}   | ${false}
+    ${"Hello"} | ${"X"}  | ${true}
+  `("string_ncontains $str, $substr", ({ str, substr, result }) => {
+        expect(string_1.stringOperators.string_ncontains.implementation(str, substr)).toBe(result);
+    });
+    it.each `
+    str        | substr   | result
+    ${"alOOf"} | ${"alo"} | ${true}
+    ${"Hello"} | ${""}    | ${true}
+    ${"Hello"} | ${"X"}   | ${false}
+  `("string_startsWith $str, $substr", ({ str, substr, result }) => {
+        expect(string_1.stringOperators.string_startsWith.implementation(str, substr)).toBe(result);
+    });
+    it.each `
+    str        | substr   | result
+    ${"alOOf"} | ${"alo"} | ${false}
+    ${"Hello"} | ${""}    | ${false}
+    ${"Hello"} | ${"X"}   | ${true}
+  `("string_nstartsWith $str, $substr", ({ str, substr, result }) => {
+        expect(string_1.stringOperators.string_nstartsWith.implementation(str, substr)).toBe(result);
+    });
+    it.each `
+    str        | substr   | result
+    ${"alOOf"} | ${"oof"} | ${true}
+    ${"Hello"} | ${""}    | ${true}
+    ${"Hello"} | ${"X"}   | ${false}
+  `("string_endsWith $str, $substr", ({ str, substr, result }) => {
+        expect(string_1.stringOperators.string_endsWith.implementation(str, substr)).toBe(result);
+    });
+    it.each `
+    str        | substr   | result
+    ${"alOOf"} | ${"oof"} | ${false}
+    ${"Hello"} | ${""}    | ${false}
+    ${"Hello"} | ${"X"}   | ${true}
+  `("string_nendsWith $str, $substr", ({ str, substr, result }) => {
+        expect(string_1.stringOperators.string_nendsWith.implementation(str, substr)).toBe(result);
+    });
+    it.each `
+    str        | regex          | result
+    ${"Hello"} | ${/[^A-za-z]/} | ${false}
+    ${"Hēllō"} | ${/[^A-za-z]/} | ${true}
+  `("string_regex $str, $regex", ({ str, regex, result }) => {
+        expect(string_1.stringOperators.string_regex.implementation(str, regex)).toBe(result);
+    });
+});

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", "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;
-        },
-    },
-};
+"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", "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;
-        },
-    },
-};
+"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>>;