@raytio/core 11.5.0 → 11.7.0

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

@@ -1,49 +0,0 @@
-"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

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

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

@@ -1,67 +0,0 @@
-"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

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

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

@@ -1,32 +0,0 @@
-"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/operators/__tests__/bool.test.d.ts

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

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

@@ -1,21 +0,0 @@
-"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

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

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

@@ -1,81 +0,0 @@
-"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

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

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

@@ -1,38 +0,0 @@
-"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

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

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

@@ -1,24 +0,0 @@
-"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

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

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

@@ -1,53 +0,0 @@
-"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

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

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

@@ -1,74 +0,0 @@
-"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/schema/expandSchema/__tests__/addLoadingTimes.test.d.ts

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

package/dist/schema/expandSchema/__tests__/addLoadingTimes.test.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const addLoadingTimes_1 = require("../addLoadingTimes");
-describe("addLoadingTimes", () => {
-    it("parses loading times from the schema tags", () => {
-        const schema = {
-            name: "hi",
-            tags: [
-                "a:b",
-                "c",
-                "time:action1:20",
-                "time:action2:5",
-                "time:action3:0",
-                "time:action4:not a number",
-            ],
-        };
-        expect((0, addLoadingTimes_1.addLoadingTimes)(schema)).toStrictEqual(Object.assign(Object.assign({}, schema), { timing: {
-                action1: 20,
-                action2: 5,
-                action3: 0,
-                action4: NaN,
-            } }));
-    });
-});

package/dist/schema/expandSchema/__tests__/expandSchema.test.d.ts

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

package/dist/schema/expandSchema/__tests__/expandSchema.test.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const expandSchema_1 = require("../expandSchema");
-const fromAPI = [
-    {
-        schema_name: "ps_Vessel",
-        start_date: "1970-01-01T00:00:00+00:00",
-        end_date: "2222-12-31T23:59:59+00:00",
-        active: true,
-        version_current: true,
-        schema_version: "0.0.7",
-        schema_type: "ps",
-        schema: {
-            $id: "https://api.rayt.io/graph/v1/schema/ps/ps_Vessel",
-            $schema: "http://json-schema.org/draft-07/schema#",
-            title: "Vessel/Boat",
-            description: "A schema that describes a maritime vessel",
-            i18n: {
-                "mi-NZ": {
-                    $schema: { title: "Waka" },
-                    vesselName: { title: "nga waka ingoa" },
-                },
-            },
-            tags: ["time:action1:20"],
-            required: ["vesselName"],
-            properties: {
-                manufacture_year: {
-                    allOf: [
-                        { $ref: "#/definitions/ss_birth_year_integer" },
-                        { tags: ["aaa"], priority: 700 },
-                    ],
-                },
-                vesselName: { type: "string", title: "Vessel Name", priority: 1000 },
-            },
-            definitions: {
-                ss_birth_year_integer: { $ref: "urn:schema:ss_birth_year_integer" },
-            },
-        },
-    },
-    {
-        schema_name: "ss_birth_year_integer",
-        schema_version: "0.0.1",
-        schema: {
-            $id: "this field often has typos. in this case its blatantly wrong",
-            $schema: "https://whatever",
-            maximum: 2022,
-            minimum: 1900,
-            tags: ["type:globally_unique_field"],
-            title: "Year of birth",
-        },
-    },
-];
-describe("expandSchema", () => {
-    it("can do the entire expansion process", () => {
-        expect((0, expandSchema_1.expandSchema)(fromAPI[0], fromAPI, ["lb-LU"])).toStrictEqual({
-            wasExpandedByClient: true,
-            // $schema was removed
-            name: "ps_Vessel",
-            title: "Vessel/Boat",
-            description: "A schema that describes a maritime vessel",
-            start_date: "1970-01-01T00:00:00+00:00",
-            end_date: "2222-12-31T23:59:59+00:00",
-            version: "0.0.7",
-            schema_type: "ps",
-            i18n: fromAPI[0].schema.i18n, // unchanged
-            isProfileSchema: true,
-            isSpSchema: false,
-            properties: {
-                manufacture_year: {
-                    // $id was removed
-                    $prop: "manufacture_year",
-                    $ref: "ss_birth_year_integer", // it added a $ref tag
-                    maximum: 2022,
-                    minimum: 1900,
-                    title: "Year of birth",
-                    // it merged the allOf into a single object
-                    priority: 700,
-                    tags: ["aaa", "type:globally_unique_field"],
-                },
-                vesselName: {
-                    $prop: "vesselName",
-                    // no $ref attribute
-                    priority: 1000,
-                    title: "Vessel Name",
-                    type: "string",
-                },
-            },
-            required: ["vesselName"],
-            tags: ["time:action1:20"],
-            timing: {
-                action1: 20,
-            },
-            verified_fields: undefined,
-        });
-    });
-});

package/dist/schema/expandSchema/__tests__/i18n.test.d.ts

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

package/dist/schema/expandSchema/__tests__/i18n.test.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const i18n_1 = require("../i18n");
-const DEFAULT_LOCALES = ["de-DE"]; // match what the client does in vi.setup.ts
-describe("getAllLocales", () => {
-    it("correctly expands languages with a country-componentand lowercases them", () => {
-        const expanded = (0, i18n_1.getAllLocales)([
-            "en-NZ",
-            "de-CH",
-            "be",
-            "ar-001",
-            "az-Cyrl-AZ",
-        ]);
-        expect(expanded).toStrictEqual([
-            "en-nz",
-            "en",
-            "de-ch",
-            "de",
-            "be",
-            "ar-001",
-            "ar",
-            "az-cyrl-az",
-            "az",
-        ]);
-    });
-});
-describe("findSuitableLocale", () => {
-    it("picks the most appropriate option", () => {
-        // the users's locale is `de-DE`, so it picked the most appropriate one from the options: `de-AT`
-        expect((0, i18n_1.findSuitableLocale)(["en-029", "de-AT", "fr-FR"], DEFAULT_LOCALES)).toBe("de-AT");
-    });
-});

package/dist/schema/expandSchema/__tests__/maybeUseI18n.test.d.ts

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