@raytio/core 10.0.1 → 11.0.0

package/dist/rules/helpers/__tests__/addInfiniteThresholdBoundaries.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const addInfiniteThresholdBoundaries_1 = require("../addInfiniteThresholdBoundaries");
+describe("addInfiniteThresholdBoundaries", () => {
+    it("correctly re-adds Infinity to the first and last boundary", () => {
+        expect((0, addInfiniteThresholdBoundaries_1.addInfiniteThresholdBoundaries)([
+            { colour: "", from: null, to: 1, name: "❤️" },
+            { colour: "", from: 2, to: 50, name: "💛" },
+            { colour: "", from: 51, to: null, name: "💚" },
+        ])).toStrictEqual([
+            { colour: "", from: -Infinity, to: 1, name: "❤️" },
+            { colour: "", from: 2, to: 50, name: "💛" },
+            { colour: "", from: 51, to: Infinity, name: "💚" },
+        ]);
+        expect((0, addInfiniteThresholdBoundaries_1.addInfiniteThresholdBoundaries)([])).toStrictEqual([]);
+        expect((0, addInfiniteThresholdBoundaries_1.addInfiniteThresholdBoundaries)([
+            { colour: "", from: 1, to: 10, name: "my useless single category" },
+        ])).toStrictEqual([
+            {
+                colour: "",
+                from: -Infinity,
+                to: Infinity,
+                name: "my useless single category",
+            },
+        ]);
+    });
+});

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

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

package/dist/rules/helpers/__tests__/checkTypeofValue.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@raytio/types");
+const checkTypeofValue_1 = require("../checkTypeofValue");
+const symbols_1 = require("../symbols");
+const hField = { __typeof__: symbols_1.HFieldSymbol };
+const hSchema = { __typeof__: symbols_1.HSchemaSymbol };
+describe("checkTypeofValue", () => {
+    it.each `
+    val           | type                   | isValid
+    ${[]}         | ${"Array"}             | ${true}
+    ${[]}         | ${"Number"}            | ${false}
+    ${false}      | ${"Bool"}              | ${true}
+    ${undefined}  | ${"Bool"}              | ${false}
+    ${new Date()} | ${"Date"}              | ${true}
+    ${2020}       | ${"Date"}              | ${false}
+    ${"Y"}        | ${"DateUnit"}          | ${true}
+    ${"y"}        | ${"DateUnit"}          | ${false}
+    ${types_1.FieldVerification.Expired} | ${"FieldVerification"} | ${true}
+    ${12345}      | ${"FieldVerification"} | ${false}
+    ${hField}     | ${"HField"}            | ${true}
+    ${{}}         | ${"HField"}            | ${false}
+    ${hSchema}    | ${"HSchema"}           | ${true}
+    ${{}}         | ${"HSchema"}           | ${false}
+    ${123}        | ${"Number"}            | ${true}
+    ${types_1.FieldVerification.Expired} | ${"Number"}            | ${true}
+    ${"123"}      | ${"Number"}            | ${false}
+    ${types_1.POVerification.Expired} | ${"POVerification"}    | ${true}
+    ${12345}      | ${"POVerification"}    | ${false}
+    ${/a/}        | ${"RegEx"}             | ${true}
+    ${"/a/"}      | ${"RegEx"}             | ${false}
+    ${""}         | ${"String"}            | ${true}
+    ${1}          | ${"String"}            | ${false}
+    ${""}         | ${"Verifier"}          | ${true}
+    ${1}          | ${"Verifier"}          | ${false}
+    ${0}          | ${"invalidddd"}        | ${false}
+  `("asserts that $val is/isNot $type ($isValid)", ({ val, type, isValid }) => {
+        expect((0, checkTypeofValue_1.checkTypeofValue)(type, val)).toBe(isValid);
+    });
+});
+describe("simplifyValueType", () => {
+    it.each `
+    input                 | output
+    ${"Verifier"}         | ${"String"}
+    ${"some other value"} | ${"some other value"}
+  `("can simplify functionally equivalent types ($input -> $output)", ({ input, output }) => {
+        expect((0, checkTypeofValue_1.simplifyValueType)(input)).toStrictEqual(output);
+    });
+});

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

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

package/dist/rules/helpers/__tests__/getValuesFromPath.test.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@raytio/types");
+const getValuesFromPath_1 = require("../getValuesFromPath");
+const symbols_1 = require("../symbols");
+const hSchema = {
+    __typeof__: symbols_1.HSchemaSymbol,
+    verification: types_1.POVerification.PartiallyVerified,
+    verifiedBy: ["Waka Kotahi"],
+};
+const hField = {
+    __typeof__: symbols_1.HFieldSymbol,
+    cameFromSchema: "ss_NZ_DL",
+    verification: types_1.FieldVerification.Verified,
+    verifiedBy: ["Waka Kotahi"],
+};
+const data = {
+    ss_NZ_DL: [
+        {
+            hSchema,
+            properties: {
+                fName: { type: "String", value: "Wolfgang", hField },
+                age: { type: "Number", value: 19.25, hField },
+                "address|housenumber": {
+                    type: "Number",
+                    value: 31,
+                    hField: null,
+                },
+                "address|street": {
+                    type: "String",
+                    value: "Circular Quay",
+                    hField: null,
+                },
+            },
+        },
+    ],
+};
+describe("getValuesFromPath", () => {
+    it.each `
+    path                                                   | out
+    ${["field", "ss_NZ_DL", "fName", "value"]}             | ${["Wolfgang"]}
+    ${["field", "ss_NZ_DL", "fName", "valueLength"]}       | ${[8]}
+    ${["field", "ss_NZ_DL", "fName", "meta"]}              | ${[hField]}
+    ${["schema", "ss_NZ_DL", "meta"]}                      | ${[hSchema]}
+    ${["field", "ss_NZ_DL", "fakeeee", "value"]}           | ${[undefined]}
+    ${["schema", "fakeeee", "meta"]}                       | ${[]}
+    ${["field", "ss_NZ_DL", "address", "subField|street"]} | ${["Circular Quay"]}
+    ${["field", "ss_NZ_DL", "address", "subField|fakeee"]} | ${[undefined]}
+    ${["field", "ss_NZ_DL", "address", "subField|"]}       | ${[undefined]}
+  `("can get a value from a valid path ($path)", ({ path, out }) => {
+        expect((0, getValuesFromPath_1.getValuesFromPath)(path, data)).toStrictEqual(out);
+    });
+    it.each `
+    path                                             | error
+    ${["jkhsfjkdf"]}                                 | ${"Invalid ValuePath[0] (jkhsfjkdf)"}
+    ${["schema", "constructor", "meta"]}             | ${"Unacceptable object property"}
+    ${["schema", "ss_NZ_DL", "fakeeee"]}             | ${"Invalid ValuePath[2] for schema (fakeeee)"}
+    ${["schema", "ss_NZ_DL", "constructor", "meta"]} | ${"Unacceptable object property"}
+    ${["field", "ss_NZ_DL", "fName", "fakeeee"]}     | ${"Invalid ValuePath[3] for field (fakeeee)"}
+    ${["field"]}                                     | ${"Invalid ValuePath[3] for field (undefined)"}
+    ${["schema"]}                                    | ${"Invalid ValuePath[2] for schema (undefined)"}
+    ${""}                                            | ${"Invalid ValuePath[0] (undefined)"}
+    ${["field", "ss_NZ_DL", "age", "valueLength"]}   | ${"valueLength may only be used on arrays and strings"}
+  `("throws an error for invalid paths ($path)", ({ path, error }) => {
+        expect(() => (0, getValuesFromPath_1.getValuesFromPath)(path, data)).toThrow(new Error(error));
+    });
+});

package/dist/rules/helpers/__tests__/thresholds.test.d.ts

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

package/dist/rules/helpers/__tests__/thresholds.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const thresholds_1 = require("../thresholds");
+describe("getThresholdBoundary", () => {
+    it("gets the min and max for plus", () => {
+        expect((0, thresholds_1.getThresholdBoundary)("+", [
+            { trueWeight: 3, falseWeight: 5 },
+            { trueWeight: -20, falseWeight: -10 },
+        ])).toStrictEqual([-17, -5]);
+        expect((0, thresholds_1.getThresholdBoundary)("+", [
+            { trueWeight: -7, falseWeight: -8 },
+        ])).toStrictEqual([-8, -7]);
+    });
+    it("gets the min and max for multiply", () => {
+        expect((0, thresholds_1.getThresholdBoundary)("*", [
+            { trueWeight: 7, falseWeight: -2 },
+            { trueWeight: -1, falseWeight: 2 },
+            { trueWeight: -5, falseWeight: 4 },
+        ])).toStrictEqual([-70, 56]);
+        expect((0, thresholds_1.getThresholdBoundary)("*", [
+            { trueWeight: 7, falseWeight: -2 },
+        ])).toStrictEqual([-2, 7]);
+    });
+    it("works for empty arrays", () => {
+        expect((0, thresholds_1.getThresholdBoundary)("+", [])).toStrictEqual([0, 0]);
+        expect((0, thresholds_1.getThresholdBoundary)("*", [])).toStrictEqual([Infinity, -Infinity]);
+    });
+    it("throws an error for invalid combinators", () => {
+        // @ts-expect-error testing invalid input
+        expect(() => (0, thresholds_1.getThresholdBoundary)("^", [])).toThrow(new Error("Invalid combinator"));
+    });
+});

package/dist/rules/helpers/checkTypeofValue.js

@@ -5,8 +5,11 @@ 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;
+// we need this function because TS's typeguards aren't great
+const isObjectWithTypeofProp = (x) => typeof x === "object" &&
+    !!x &&
+    "__typeof__" in x &&
+    typeof x.__typeof__ === "symbol";
 /** asserts that the provided `value` meets the constaints of `type` */
 function checkTypeofValue(type, value) {
     switch (type) {
@@ -21,12 +24,14 @@ function checkTypeofValue(type, 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.
+            // this is not fakeable because we use a unique symbol for __typeof__, like
+            // what react does with $$typeof. But even if you could construct a fake object,
+            // it wouldn't be 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.
+            // this is not fakeable because we use a unique symbol for __typeof__, like
+            // what react does with $$typeof. But even if you could construct a fake object,
+            // it wouldn't be a concern in this context.
             return (isObjectWithTypeofProp(value) && value.__typeof__ === symbols_1.HSchemaSymbol);
         case "Number":
             return typeof value === "number";

package/dist/rules/helpers/thresholds.js

@@ -22,9 +22,8 @@ function getThresholdBoundary(combinator, rules) {
             return [lowest, highest];
         }
         case "*": {
-            // eslint-disable-next-line fp/no-let
             let [lowest, highest] = [Infinity, -Infinity];
-            // eslint-disable-next-line fp/no-loops, fp/no-let, fp/no-mutation
+            // eslint-disable-next-line fp/no-mutation
             for (let i = 0; i < 2 * rules.length; i += 1) {
                 // loop for every possible combination (2*rules.rength), and check that combination
                 const product = i

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