@raytio/core 10.1.0 → 11.1.0

package/dist/rules/index.d.ts

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

package/dist/rules/index.js

@@ -1,25 +1,25 @@
-"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; } });
+"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/operators/__tests__/bool.test.d.ts

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

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bool_1 = require("../bool");
+describe("boolOperators", () => {
+    it.each `
+    a        | b        | result
+    ${true}  | ${true}  | ${true}
+    ${false} | ${true}  | ${false}
+    ${false} | ${false} | ${true}
+  `("bool_eq $a, $b", ({ a, b, result }) => {
+        expect(bool_1.boolOperators.bool_eq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a        | b        | result
+    ${true}  | ${true}  | ${false}
+    ${false} | ${true}  | ${true}
+    ${false} | ${false} | ${false}
+  `("bool_neq $a, $b", ({ a, b, result }) => {
+        expect(bool_1.boolOperators.bool_neq.implementation(a, b)).toBe(result);
+    });
+});

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

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

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_1 = require("../date");
+describe("dateOperators", () => {
+    it.each `
+    a                                   | b                                   | result
+    ${new Date("2001-06-06T01:00:00Z")} | ${new Date("2001-06-06T23:59:59Z")} | ${true}
+    ${new Date("2001-02-02")}           | ${new Date("2001-02-03")}           | ${false}
+  `("date_eq $a, $b", ({ a, b, result }) => {
+        expect(date_1.dateOperators.date_eq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a                                   | b                                   | result
+    ${new Date("2001-06-06T01:00:00Z")} | ${new Date("2001-06-06T23:59:59Z")} | ${false}
+    ${new Date("2001-02-02")}           | ${new Date("2001-02-03")}           | ${true}
+  `("date_neq $a, $b", ({ a, b, result }) => {
+        expect(date_1.dateOperators.date_neq.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a                            | result
+    ${new Date("2001-01-01")}    | ${true}
+    ${new Date("bobs ur uncle")} | ${false}
+  `("date_valid $a", ({ a, result }) => {
+        expect(date_1.dateOperators.date_valid.implementation(a)).toBe(result);
+    });
+    it.each `
+    a                            | result
+    ${new Date("2001-01-01")}    | ${false}
+    ${new Date("bobs ur uncle")} | ${true}
+  `("date_invalid $a", ({ a, result }) => {
+        expect(date_1.dateOperators.date_invalid.implementation(a)).toBe(result);
+    });
+    it.each `
+    a                         | b                         | result
+    ${new Date("2001-02-02")} | ${new Date("2001-02-03")} | ${true}
+    ${new Date("2001-01-01")} | ${new Date("1999-01-01")} | ${false}
+  `("date_before $a, $b", ({ a, b, result }) => {
+        expect(date_1.dateOperators.date_before.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a                         | b                         | result
+    ${new Date("2001-02-02")} | ${new Date("2001-02-03")} | ${false}
+    ${new Date("2001-01-01")} | ${new Date("1999-01-01")} | ${true}
+  `("date_after $a, $b", ({ a, b, result }) => {
+        expect(date_1.dateOperators.date_after.implementation(a, b)).toBe(result);
+    });
+    it.each `
+    a                   | b                   | c                   | result
+    ${new Date("2001")} | ${new Date("2000")} | ${new Date("2002")} | ${true}
+    ${new Date("2001")} | ${new Date("2005")} | ${new Date("2000")} | ${false}
+    ${new Date("1900")} | ${new Date("1900")} | ${new Date("1900")} | ${true}
+  `("date_between $a, $b, $c", ({ a, b, c, result }) => {
+        expect(date_1.dateOperators.date_between.implementation(a, b, c)).toBe(result);
+    });
+    it.each `
+    date                | num   | units   | result
+    ${new Date("2010")} | ${10} | ${"Y"}  | ${true}
+    ${new Date("2010")} | ${20} | ${"Y"}  | ${false}
+    ${new Date("2030")} | ${1}  | ${"Y"}  | ${false}
+    ${new Date()}       | ${1}  | ${"ms"} | ${true /* reminaing tests are just for 100% coverage */}
+    ${new Date()}       | ${1}  | ${"s"}  | ${false}
+    ${new Date()}       | ${1}  | ${"m"}  | ${false}
+    ${new Date()}       | ${1}  | ${"h"}  | ${false}
+    ${new Date()}       | ${1}  | ${"D"}  | ${false}
+    ${new Date()}       | ${1}  | ${"W"}  | ${false}
+    ${new Date()}       | ${1}  | ${"M"}  | ${false}
+  `("date_older_than $date, $num, $units", ({ date, num, units, result }) => {
+        expect(date_1.dateOperators.date_older_than.implementation(date, num, units)).toBe(result);
+    });
+    it("date_older_than (throws an error for an invalid DateUnit)", () => {
+        expect(() => date_1.dateOperators.date_older_than.implementation(new Date(), 6, "Quaters")).toThrow(new Error("Invalid date unit: Quaters"));
+    });
+    it.each `
+    date                | num   | units  | result
+    ${new Date("2030")} | ${1}  | ${"Y"} | ${true}
+    ${new Date("2030")} | ${10} | ${"Y"} | ${false}
+    ${new Date()}       | ${1}  | ${"h"} | ${false}
+  `("date_newer_than $date, $num, $units", ({ date, num, units, result }) => {
+        expect(date_1.dateOperators.date_newer_than.implementation(date, num, units)).toBe(result);
+    });
+});

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

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

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