@raytio/core 10.0.1 → 10.1.0

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

package/dist/rules/operators/number.js

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

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

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

package/dist/rules/operators/string.js

@@ -1,58 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringOperators = void 0;
-// also string operators are case-insensitive
-exports.stringOperators = {
-    string_eq: {
-        operands: ["String", "String"],
-        implementation(s1, s2) {
-            return s1.toLowerCase() === s2.toLowerCase();
-        },
-    },
-    string_neq: {
-        operands: ["String", "String"],
-        implementation(s1, s2) {
-            return s1.toLowerCase() !== s2.toLowerCase();
-        },
-    },
-    string_contains: {
-        operands: ["String", "String"],
-        implementation(s1, s2) {
-            return s1.toLowerCase().includes(s2.toLowerCase());
-        },
-    },
-    string_ncontains: {
-        operands: ["String", "String"],
-        implementation(s1, s2) {
-            return !s1.toLowerCase().includes(s2.toLowerCase());
-        },
-    },
-    string_startsWith: {
-        operands: ["String", "String"],
-        implementation(s1, s2) {
-            return s1.toLowerCase().startsWith(s2.toLowerCase());
-        },
-    },
-    string_nstartsWith: {
-        operands: ["String", "String"],
-        implementation(s1, s2) {
-            return !s1.toLowerCase().startsWith(s2.toLowerCase());
-        },
-    },
-    string_endsWith: {
-        operands: ["String", "String"],
-        implementation(s1, s2) {
-            return s1.toLowerCase().endsWith(s2.toLowerCase());
-        },
-    },
-    string_nendsWith: {
-        operands: ["String", "String"],
-        implementation(s1, s2) {
-            return !s1.toLowerCase().endsWith(s2.toLowerCase());
-        },
-    },
-    string_regex: {
-        operands: ["String", "RegEx"],
-        implementation: (str, regEx) => !!str.match(regEx),
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringOperators = void 0;
+// also string operators are case-insensitive
+exports.stringOperators = {
+    string_eq: {
+        operands: ["String", "String"],
+        implementation(s1, s2) {
+            return s1.toLowerCase() === s2.toLowerCase();
+        },
+    },
+    string_neq: {
+        operands: ["String", "String"],
+        implementation(s1, s2) {
+            return s1.toLowerCase() !== s2.toLowerCase();
+        },
+    },
+    string_contains: {
+        operands: ["String", "String"],
+        implementation(s1, s2) {
+            return s1.toLowerCase().includes(s2.toLowerCase());
+        },
+    },
+    string_ncontains: {
+        operands: ["String", "String"],
+        implementation(s1, s2) {
+            return !s1.toLowerCase().includes(s2.toLowerCase());
+        },
+    },
+    string_startsWith: {
+        operands: ["String", "String"],
+        implementation(s1, s2) {
+            return s1.toLowerCase().startsWith(s2.toLowerCase());
+        },
+    },
+    string_nstartsWith: {
+        operands: ["String", "String"],
+        implementation(s1, s2) {
+            return !s1.toLowerCase().startsWith(s2.toLowerCase());
+        },
+    },
+    string_endsWith: {
+        operands: ["String", "String"],
+        implementation(s1, s2) {
+            return s1.toLowerCase().endsWith(s2.toLowerCase());
+        },
+    },
+    string_nendsWith: {
+        operands: ["String", "String"],
+        implementation(s1, s2) {
+            return !s1.toLowerCase().endsWith(s2.toLowerCase());
+        },
+    },
+    string_regex: {
+        operands: ["String", "RegEx"],
+        implementation: (str, regEx) => !!str.match(regEx),
+    },
+};