@raytio/core 8.1.3 → 9.0.0

package/dist/rules/helpers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+__exportStar(require("./addInfiniteThresholdBoundaries"), exports);
+__exportStar(require("./checkTypeofValue"), exports);
+__exportStar(require("./getValuesFromPath"), exports);
+__exportStar(require("./symbols"), exports);
+__exportStar(require("./thresholds"), exports);

package/dist/rules/helpers/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const HFieldSymbol: unique symbol;
+export declare const HSchemaSymbol: unique symbol;

package/dist/rules/helpers/symbols.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HSchemaSymbol = exports.HFieldSymbol = void 0;
+exports.HFieldSymbol = Symbol("HField");
+exports.HSchemaSymbol = Symbol("HSchema");

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

@@ -0,0 +1,5 @@
+import { Combinator, ScoreRule } from "../types";
+/** @ignore */
+export declare function getCombinator(combinator: Combinator): [func: (a: number, b: number) => number, initialValue: number];
+/** @ignore */
+export declare function getThresholdBoundary(combinator: Combinator, rules: ScoreRule[]): [lowest: number, highest: number];

package/dist/rules/helpers/thresholds.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThresholdBoundary = exports.getCombinator = void 0;
+/** @ignore */
+function getCombinator(combinator) {
+    switch (combinator) {
+        case "+":
+            return [(a, b) => a + b, 0];
+        case "*":
+            return [(a, b) => a * b, 1];
+        default:
+            throw new Error("Invalid combinator");
+    }
+}
+exports.getCombinator = getCombinator;
+/** @ignore */
+function getThresholdBoundary(combinator, rules) {
+    switch (combinator) {
+        case "+": {
+            const lowest = rules.reduce((ac, r) => ac + Math.min(r.falseWeight, r.trueWeight), 0);
+            const highest = rules.reduce((ac, r) => ac + Math.max(r.falseWeight, r.trueWeight), 0);
+            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
+            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
+                    .toString(2)
+                    .padStart(rules.length, "0")
+                    .split("")
+                    .map((bool, j) => rules[j][bool === "1" ? "trueWeight" : "falseWeight"])
+                    .reduce((a, b) => a * b, 1);
+                if (product > highest)
+                    highest = product; // eslint-disable-line fp/no-mutation
+                if (product < lowest)
+                    lowest = product; // eslint-disable-line fp/no-mutation
+            }
+            return [lowest, highest];
+        }
+        default:
+            throw new Error("Invalid combinator");
+    }
+}
+exports.getThresholdBoundary = getThresholdBoundary;

package/dist/rules/index.d.ts

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

package/dist/rules/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./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/bool.d.ts

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

package/dist/rules/operators/bool.js

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

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

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

package/dist/rules/operators/date.js

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

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

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

package/dist/rules/operators/hfield.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldOperators = void 0;
+exports.fieldOperators = {
+    field_verifiedBy: {
+        operands: ["HField", "String"],
+        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

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

package/dist/rules/operators/hschema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaOperators = void 0;
+exports.schemaOperators = {
+    schema_verifiedBy: {
+        operands: ["HSchema", "String"],
+        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

@@ -0,0 +1,3 @@
+import { OperatorID, OperatorDef } from "../types";
+/** @ignore */
+export declare const operators: Record<OperatorID, OperatorDef>;

package/dist/rules/operators/index.js

@@ -0,0 +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);

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

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

package/dist/rules/operators/number.js

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

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

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

package/dist/rules/operators/string.js

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

package/dist/rules/types/config.d.ts

@@ -0,0 +1,86 @@
+import { GetTSType } from "./dataValueTypes";
+/**
+ * @ignore
+ * these are just IDs, the string is never parsed by anything.
+ *
+ * However, since they're saved into the WizardConfig schema,
+ * we can't just rename or remove any, since that would break
+ * existing rules.
+ */
+export declare type OperatorID = "bool_eq" | "bool_neq" | "num_eq" | "num_neq" | "num_lt_eq" | "num_gt_eq" | "num_lt" | "num_gt" | "date_valid" | "date_invalid" | "date_before" | "date_after" | "date_eq" | "date_neq" | "date_older_than" | "date_newer_than" | "date_between" | "string_eq" | "string_neq" | "string_contains" | "string_ncontains" | "string_startsWith" | "string_nstartsWith" | "string_endsWith" | "string_nendsWith" | "string_regex" | "field_verifiedBy" | "field_shared" | "field_hasVerStatus" | "field_cameFromSchema" | "field_ncameFromSchema" | "schema_verifiedBy" | "schema_shared" | "schema_hasVerStatus";
+/** @ignore */
+export declare type ValuePathFieldProp = "meta" | "value" | "valueLength" | `subField|${string}`;
+/** @ignore */
+export declare type ValuePath = [type: "schema", schemaName: string, prop: "meta"] | [
+    type: "field",
+    schemaName: string,
+    fieldName: string,
+    prop: ValuePathFieldProp
+];
+/** @ignore */
+export declare type ValueRefConst<T> = {
+    type: "constant";
+    value: T;
+};
+/** @ignore */
+export declare type ValueRefVar = {
+    type: "variable";
+    path: ValuePath;
+};
+/** @ignore */
+export declare type ValueRef<T> = ValueRefConst<T> | ValueRefVar;
+/** @ignore these are the LHS & RHS operands which come from variables (or constants) */
+export declare type FieldValueTypes = "Bool" | "Number" | "String" | "Date" | "Array" | "HField" | "HSchema";
+/** @ignore these are the RHS-only operands which come from constants ONLY */
+export declare type ConstValueTypes = "DateUnit" | "RegEx" | "FieldVerification" | "POVerification";
+/** @ignore full list of operands which come from variables OR constants */
+export declare type ValueType = ConstValueTypes | FieldValueTypes;
+/** @ignore */
+export declare type ValueDef<T = ValueType> = {
+    type: T;
+    value: ValueRef<GetTSType<T>>;
+};
+/** @ignore */
+export declare type ASTScoreConditionNode = {
+    type: "ScoreCondition";
+    operator: OperatorID;
+    values: ValueDef<ValueType>[];
+};
+/** @ignore */
+export declare type ASTLanguageOperatorNode = {
+    type: "LanguageOperator";
+    operator: "OR" | "AND";
+    children: ASTNode[];
+};
+/** @ignore */
+export declare type ASTNode = ASTLanguageOperatorNode | ASTScoreConditionNode;
+/** @ignore */
+export declare type ScoreRule = {
+    /** user defined */
+    name: string;
+    /** user defined */
+    description?: string;
+    /** must be an integer */
+    trueWeight: number;
+    /** must be an integer */
+    falseWeight: number;
+    /** must have a single root node */
+    tree: [ASTNode];
+};
+/** @ignore e.g. 0-10 is "red". We only work with integers. Comparisons use >= and <= */
+export declare type ScoreThreshold = {
+    from: number;
+    to: number;
+    name: string;
+};
+/** @ignore */
+export declare type Combinator = "+" | "*";
+/**
+ * @ignore
+ * the big object for configuring score rules
+ */
+export declare type ScoreConfig = {
+    combinator: Combinator;
+    scoreThresholds: ScoreThreshold[];
+    rules: ScoreRule[];
+};

package/dist/rules/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/rules/types/dataValueTypes.d.ts

@@ -0,0 +1,19 @@
+import { FieldVerification, NId, POVerification } from "@raytio/types";
+import type { HFieldSymbol, HSchemaSymbol } from "../helpers";
+/** undefined if not shared */
+export declare type HField = {
+    __typeof__: typeof HFieldSymbol;
+    verification: FieldVerification;
+    verifiedBy: readonly NId[];
+    /** schemaName */
+    cameFromSchema: string;
+};
+/** undefined if not shared */
+export declare type HSchema = {
+    __typeof__: typeof HSchemaSymbol;
+    verification?: POVerification;
+    verifiedBy: readonly NId[];
+};
+export declare const DATE_UNITS: readonly ["ms", "s", "m", "h", "D", "M", "W", "Y"];
+export declare type DateUnit = typeof DATE_UNITS[number];
+export declare type GetTSType<T> = T extends "Bool" ? boolean : T extends "Number" ? number : T extends "String" ? string : T extends "Date" ? Date : T extends "Array" ? unknown[] : T extends "HField" ? HField : T extends "HSchema" ? HSchema : T extends "DateUnit" ? DateUnit : T extends "RegEx" ? RegExp : T extends "FieldVerification" ? FieldVerification : T extends "POVerification" ? POVerification : never;

package/dist/rules/types/dataValueTypes.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATE_UNITS = void 0;
+exports.DATE_UNITS = ["ms", "s", "m", "h", "D", "M", "W", "Y"];

package/dist/rules/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./dataValueTypes";
+export * from "./config";
+export * from "./internal";

package/dist/rules/types/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+__exportStar(require("./dataValueTypes"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./internal"), exports);

package/dist/rules/types/internal.d.ts

@@ -0,0 +1,20 @@
+import { HField, HSchema, GetTSType } from "./dataValueTypes";
+import { FieldValueTypes, ValueType } from "./config";
+export declare type RuleDataProperty<T extends FieldValueTypes> = {
+    type: T;
+    value: GetTSType<T>;
+    hField: HField;
+};
+export declare type RuleData = {
+    [schemaName: string]: {
+        hSchema: HSchema;
+        properties: {
+            [fieldName: string]: RuleDataProperty<FieldValueTypes>;
+        };
+    }[];
+};
+export declare type OperatorDef = {
+    /** the first operand is the LHS, all others are RHS */
+    operands: ValueType[];
+    implementation: (...args: any[]) => boolean;
+};

package/dist/rules/types/internal.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/canonicalJsonify.js

@@ -0,0 +1,48 @@
+"use strict";
+/* eslint-disable fp/no-mutating-methods, fp/no-mutation, fp/no-let, prefer-reflect */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalJsonify = void 0;
+const isObject = (a) => Object.prototype.toString.call(a) === "[object Object]"; // TODO: wtf ?
+const REGEX = 
+// eslint-disable-next-line no-control-regex
+/[\u0000-\u001F]|"|\\|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/g;
+const SLASH_ESC = {
+    "\b": "\\b",
+    "\t": "\\t",
+    "\n": "\\n",
+    "\f": "\\f",
+    "\r": "\\r",
+    '"': '\\"',
+    "\\": "\\\\",
+};
+const replacer = (char) => SLASH_ESC[char] ||
+    `\\u${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}`;
+function copyObjectWithSortedKeys(object) {
+    if (isObject(object)) {
+        return `{${Object.keys(object)
+            .sort()
+            .map(key => `"${key}":${copyObjectWithSortedKeys(object[key])}`)
+            .join(",")}}`;
+    }
+    if (Array.isArray(object)) {
+        return `[${object.map(copyObjectWithSortedKeys).join(",")}]`;
+    }
+    if (typeof object === "number" && object % 1 !== 0) {
+        // float
+        const exponent = Math.round(Math.log10(Math.abs(object)));
+        let mantissa = `${object / 10 ** exponent}`;
+        if (!mantissa.includes("."))
+            mantissa += ".0";
+        return `${mantissa}E${exponent}`;
+    }
+    if (typeof object === "string")
+        return `"${object.replace(REGEX, replacer)}"`;
+    return object; // bool or int
+}
+/**
+ * @internal
+ * spec compliant, and matches
+ * https://gitlab.com/raytio/mono/-/blob/devo/common/signing/signing/canonical_json.py
+ */
+const canonicalJsonify = (object) => `${copyObjectWithSortedKeys(object)}`;
+exports.canonicalJsonify = canonicalJsonify;

package/dist/util/handleResponse.js

@@ -14,7 +14,6 @@ const handleResponse = async (response) => {
     const json = await response.json();
     // json could be a string | number
     if (typeof json === "object" && "message" in json) {
-        // eslint-disable-next-line fp/no-throw
         throw new Error(json.message);
     }
     return json;

package/dist/util/index.d.ts

@@ -1 +1,2 @@
+export * from "./canonicalJsonify";
 export * from "./handleResponse";