@fibery/views 17.0.4 → 18.0.2

package/lib/src/unit-utils/decimal.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable */
+const EXP_LIMIT = 9e15;
+// The limit on the value of `precision`, and on the value of the first argument to `toFixed`.
+const MAX_DIGITS = 1e9;
+// The minimum exponent value, beneath which underflow to zero occurs.
+// JavaScript numbers: -324  (5e-324)
+const minE = -EXP_LIMIT;
+// The maximum exponent value, above which overflow to Infinity occurs.
+// JavaScript numbers: 308  (1.7976931348623157e+308)
+const maxE = EXP_LIMIT;
+const decimalError = "[DecimalError] ";
+const invalidArgument = decimalError + "Invalid argument: ";
+const mathpow = Math.pow;
+const isDecimalRegex = /^-?(\d+(\.\d*)?|\.\d+)$/i;
+const BASE = 1e7;
+const LOG_BASE = 7;
+function checkInt32(i, min, max) {
+    if (i !== ~~i || i < min || i > max) {
+        throw Error(invalidArgument + i);
+    }
+}
+const isNeg = (decimal) => {
+    return decimal.s < 0;
+};
+const isZero = (decimal) => {
+    return Boolean(decimal.d) && decimal.d?.[0] === 0;
+};
+const isFinite = (decimal) => {
+    return Boolean(decimal.d);
+};
+// ±Infinity, NaN.
+function nonFiniteToString(x) {
+    // Unsigned.
+    return String((x.s * x.s) / 0);
+}
+function getZeroString(k) {
+    let zs = "";
+    for (let i = k; i--;) {
+        zs += "0";
+    }
+    return zs;
+}
+function digitsToString(d) {
+    let str = "";
+    let w = d[0];
+    const indexOfLastWord = d.length - 1;
+    if (indexOfLastWord > 0) {
+        str += w;
+        let i;
+        for (i = 1; i < indexOfLastWord; i++) {
+            const ws = String(d[i]);
+            const k = LOG_BASE - ws.length;
+            if (k) {
+                str += getZeroString(k);
+            }
+            str += ws;
+        }
+        w = d[i];
+        const ws = String(w);
+        const k = LOG_BASE - ws.length;
+        if (k) {
+            str += getZeroString(k);
+        }
+    }
+    else if (w === 0) {
+        return "0";
+    }
+    // Remove trailing zeros of last w.
+    for (; w % 10 === 0;) {
+        w /= 10;
+    }
+    return str + w;
+}
+function finiteToString(x, sd) {
+    if (!isFinite(x)) {
+        return nonFiniteToString(x);
+    }
+    let k;
+    const e = x.e;
+    let str = digitsToString(x.d);
+    const len = str.length;
+    if (e < 0) {
+        str = "0." + getZeroString(-e - 1) + str;
+        if (sd && (k = sd - len) > 0) {
+            str += getZeroString(k);
+        }
+    }
+    else if (e >= len) {
+        str += getZeroString(e + 1 - len);
+        if (sd && (k = sd - e - 1) > 0) {
+            str = str + "." + getZeroString(k);
+        }
+    }
+    else {
+        if ((k = e + 1) < len) {
+            str = str.slice(0, k) + "." + str.slice(k);
+        }
+        if (sd && (k = sd - len) > 0) {
+            if (e + 1 === len) {
+                str += ".";
+            }
+            str += getZeroString(k);
+        }
+    }
+    return str;
+}
+/*
+ * Round `x` to `sd` significant digits using rounding mode `rm`.
+ * Check for over/under-flow.
+ */
+function finalise(x, sd, rm) {
+    let digits;
+    let i;
+    let j;
+    let k;
+    let rd;
+    let roundUp;
+    let w;
+    let xd;
+    let xdi;
+    // Don't round if sd is null or undefined.
+    out: if (sd != null) {
+        xd = x.d;
+        // Infinity/NaN.
+        if (!xd) {
+            return x;
+        }
+        // rd: the rounding digit, i.e. the digit after the digit that may be rounded up.
+        // w: the word of xd containing rd, a base 1e7 number.
+        // xdi: the index of w within xd.
+        // digits: the number of digits of w.
+        // i: what would be the index of rd within w if all the numbers were 7 digits long (i.e. if
+        // they had leading zeros)
+        // j: if > 0, the actual index of rd within w (if < 0, rd is a leading zero).
+        // Get the length of the first word of the digits array xd.
+        for (digits = 1, k = xd[0]; k >= 10; k /= 10) {
+            digits++;
+        }
+        i = sd - digits;
+        // Is the rounding digit in the first word of xd?
+        if (i < 0) {
+            i += LOG_BASE;
+            j = sd;
+            w = xd[(xdi = 0)];
+            // Get the rounding digit at index j of w.
+            rd = (w / mathpow(10, digits - j - 1)) % 10 | 0;
+        }
+        else {
+            xdi = Math.ceil((i + 1) / LOG_BASE);
+            k = xd.length;
+            if (xdi >= k) {
+                break out;
+            }
+            else {
+                w = k = xd[xdi];
+                // Get the number of digits of w.
+                for (digits = 1; k >= 10; k /= 10) {
+                    digits++;
+                }
+                // Get the index of rd within w.
+                i %= LOG_BASE;
+                // Get the index of rd within w, adjusted for leading zeros.
+                // The number of leading zeros of w is given by LOG_BASE - digits.
+                j = i - LOG_BASE + digits;
+                // Get the rounding digit at index j of w.
+                rd = j < 0 ? 0 : (w / mathpow(10, digits - j - 1)) % 10 | 0;
+            }
+        }
+        // Are there any non-zero digits after the rounding digit?
+        const isTruncated = sd < 0 || xd[xdi + 1] !== undefined || (j < 0 ? w : w % mathpow(10, digits - j - 1));
+        // The expression `w % mathpow(10, digits - j - 1)` returns all the digits of w to the right
+        // of the digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression
+        // will give 714.
+        roundUp =
+            rm < 4
+                ? (rd || isTruncated) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))
+                : rd > 5 ||
+                    (rd == 5 &&
+                        (rm == 4 ||
+                            isTruncated ||
+                            (rm == 6 &&
+                                // Check whether the digit to the left of the rounding digit is odd.
+                                (i > 0 ? (j > 0 ? w / mathpow(10, digits - j) : 0) : xd[xdi - 1]) % 10 & 1) ||
+                            rm == (x.s < 0 ? 8 : 7)));
+        if (sd < 1 || !xd[0]) {
+            xd.length = 0;
+            if (roundUp) {
+                // Convert sd to decimal places.
+                sd -= x.e + 1;
+                // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+                xd[0] = mathpow(10, (LOG_BASE - (sd % LOG_BASE)) % LOG_BASE);
+                x.e = -sd || 0;
+            }
+            else {
+                // Zero.
+                xd[0] = x.e = 0;
+            }
+            return x;
+        }
+        // Remove excess digits.
+        if (i == 0) {
+            xd.length = xdi;
+            k = 1;
+            xdi--;
+        }
+        else {
+            xd.length = xdi + 1;
+            k = mathpow(10, LOG_BASE - i);
+            // E.g. 56700 becomes 56000 if 7 is the rounding digit.
+            // j > 0 means i > number of leading zeros of w.
+            xd[xdi] = j > 0 ? ((w / mathpow(10, digits - j)) % mathpow(10, j) | 0) * k : 0;
+        }
+        if (roundUp) {
+            for (;;) {
+                // Is the digit to be rounded up in the first word of xd?
+                if (xdi == 0) {
+                    // i will be the length of xd[0] before k is added.
+                    for (i = 1, j = xd[0]; j >= 10; j /= 10) {
+                        i++;
+                    }
+                    j = xd[0] += k;
+                    for (k = 1; j >= 10; j /= 10) {
+                        k++;
+                    }
+                    // if i != k the length has increased.
+                    if (i != k) {
+                        x.e++;
+                        if (xd[0] == BASE) {
+                            xd[0] = 1;
+                        }
+                    }
+                    break;
+                }
+                else {
+                    xd[xdi] += k;
+                    if (xd[xdi] != BASE) {
+                        break;
+                    }
+                    xd[xdi--] = 0;
+                    k = 1;
+                }
+            }
+        }
+        // Remove trailing zeros.
+        for (i = xd.length; xd[--i] === 0;) {
+            xd.pop();
+        }
+    }
+    return x;
+}
+function toFixedHelper(decimal, decimalPlaces, roundingMode) {
+    if (decimalPlaces === undefined) {
+        throw new Error("number of decimal places must be specified");
+    }
+    checkInt32(decimalPlaces, 0, MAX_DIGITS);
+    if (roundingMode === undefined) {
+        throw new Error("rounding strategy must be specified");
+    }
+    else {
+        checkInt32(roundingMode, 0, 8);
+    }
+    const rounded = finalise(new Decimal(decimal), decimalPlaces + decimal.e + 1, roundingMode);
+    const str = finiteToString(rounded, decimalPlaces + rounded.e + 1);
+    return isNeg(decimal) && !isZero(decimal) ? "-" + str : str;
+}
+function parseDecimal(x, str) {
+    let e = str.indexOf(".");
+    // Decimal point?
+    if (e > -1) {
+        str = str.replace(".", "");
+    }
+    if (e < 0) {
+        // Integer.
+        e = str.length;
+    }
+    let i;
+    // Determine leading zeros.
+    for (i = 0; str.charCodeAt(i) === 48; i++) { }
+    let len;
+    // Determine trailing zeros.
+    for (len = str.length; str.charCodeAt(len - 1) === 48; --len) { }
+    str = str.slice(i, len);
+    if (str) {
+        len -= i;
+        x.e = e = e - i - 1;
+        x.d = [];
+        // Transform base
+        // e is the base 10 exponent.
+        // i is where to slice str to get the first word of the digits array.
+        i = (e + 1) % LOG_BASE;
+        if (e < 0) {
+            i += LOG_BASE;
+        }
+        if (i < len) {
+            if (i) {
+                x.d.push(Number(str.slice(0, i)));
+            }
+            for (len -= LOG_BASE; i < len;) {
+                x.d.push(Number(str.slice(i, (i += LOG_BASE))));
+            }
+            str = str.slice(i);
+            i = LOG_BASE - str.length;
+        }
+        else {
+            i -= len;
+        }
+        for (; i--;) {
+            str += "0";
+        }
+        x.d.push(Number(str));
+        // Overflow?
+        if (x.e > maxE) {
+            // Infinity.
+            x.e = NaN;
+            x.d = null;
+            // Underflow?
+        }
+        else if (x.e < minE) {
+            // Zero.
+            x.e = 0;
+            x.d = [0];
+        }
+    }
+    else {
+        // Zero.
+        x.e = 0;
+        x.d = [0];
+    }
+    return x;
+}
+/*
+ * The Decimal class for arbitrary-precision decimal arithmetic.
+ *
+ * ROUND_UP         0 Away from zero.
+ * ROUND_DOWN       1 Towards zero.
+ * ROUND_CEIL       2 Towards +Infinity.
+ * ROUND_FLOOR      3 Towards -Infinity.
+ * ROUND_HALF_UP    4 Towards nearest neighbour. If equidistant, up.
+ * ROUND_HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.
+ * ROUND_HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.
+ * ROUND_HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.
+ * ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.
+ */
+class Decimal {
+    static ROUND_UP = 0;
+    static ROUND_DOWN = 1;
+    static ROUND_CEIL = 2;
+    static ROUND_FLOOR = 3;
+    static ROUND_HALF_UP = 4;
+    static ROUND_HALF_DOWN = 5;
+    static ROUND_HALF_EVEN = 6;
+    static ROUND_HALF_CEIL = 7;
+    static ROUND_HALF_FLOOR = 8;
+    s = 0;
+    e = 0;
+    d = null;
+    /**
+     * Create a new Decimal instance.
+     * @param v A numeric string or Decimal instance
+     */
+    constructor(v) {
+        // Duplicate.
+        if (v instanceof Decimal) {
+            this.s = v.s;
+            this.e = v.e;
+            this.d = v.d ? v.d.slice() : v.d;
+            return;
+        }
+        if (typeof v !== "string") {
+            throw Error(invalidArgument + v);
+        }
+        // Minus sign?
+        if (v.charCodeAt(0) === 45) {
+            v = v.slice(1);
+            this.s = -1;
+        }
+        else {
+            this.s = 1;
+        }
+        if (!isDecimalRegex.test(v)) {
+            throw new Error("String value is not Decimal");
+        }
+        parseDecimal(this, v);
+    }
+    /**
+     * Return a string representing the value of this Decimal in normal (fixed-point) notation to
+     * `dp` fixed decimal places and rounded using rounding mode `rm`.
+     *
+     * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.
+     *
+     * @param dp Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * @example
+     * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
+     * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
+     * (-0).toFixed(3) is '0.000'.
+     * (-0.5).toFixed(0) is '-0'.
+     */
+    toFixed(dp, rm) {
+        return toFixedHelper(this, dp, rm);
+    }
+    /**
+     * Test whether a string value is a valid decimal.
+     * @param value The string to test
+     * @returns true if the value is a valid decimal string
+     */
+    static isDecimal(value) {
+        return isDecimalRegex.test(value);
+    }
+}
+exports.default = Decimal;

package/lib/src/unit-utils/dynamic-keys.d.ts

@@ -0,0 +1,7 @@
+export declare const isUserActiveDynamicKeyPrefix = "is-user-active";
+export declare const isFinalStateDynamicKeyPrefix = "is-final-state";
+export declare const colorCodingKeyPrefix = "color-coding";
+export declare const hasAccessToSecretKeyPrefix = "has-access-to-secret";
+export declare const collectionCountKeyPrefix = "collection-count";
+export declare const accessCheckKeyKeyPrefix = "access/check";
+export declare const makeDynamicKey: (prefix: string, key?: string) => string;

package/lib/src/unit-utils/dynamic-keys.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDynamicKey = exports.accessCheckKeyKeyPrefix = exports.collectionCountKeyPrefix = exports.hasAccessToSecretKeyPrefix = exports.colorCodingKeyPrefix = exports.isFinalStateDynamicKeyPrefix = exports.isUserActiveDynamicKeyPrefix = void 0;
+exports.isUserActiveDynamicKeyPrefix = "is-user-active";
+exports.isFinalStateDynamicKeyPrefix = "is-final-state";
+exports.colorCodingKeyPrefix = "color-coding";
+exports.hasAccessToSecretKeyPrefix = "has-access-to-secret";
+exports.collectionCountKeyPrefix = "collection-count";
+exports.accessCheckKeyKeyPrefix = "access/check";
+const makeDynamicKey = (prefix, key) => {
+    return `?${prefix}${key === undefined ? "" : `_${key}`}`;
+};
+exports.makeDynamicKey = makeDynamicKey;

package/lib/src/unit-utils/enums.d.ts

@@ -0,0 +1,27 @@
+import { TypeObject } from "@fibery/schema";
+import { FieldExpression } from "@fibery/expression-utils";
+import type { Select } from "@fibery/expression-utils/src/types";
+export declare const getEnumIconColorQuery: ({ typeObject, contextPath, }: {
+    typeObject: TypeObject;
+    contextPath?: FieldExpression;
+}) => Select;
+export declare function getEnumIconSelect(typeObject: TypeObject): {
+    "enum/icon": string[];
+} | {
+    "enum/icon"?: undefined;
+};
+export declare const getEnumsRequest: (enumTypeObject: TypeObject) => {
+    query: {
+        "q/from": string;
+        "q/select": {
+            "workflow/Final"?: string | undefined;
+            "workflow/Type"?: string | undefined;
+            "fibery/id": string;
+            "enum/name": string;
+            "fibery/rank": string;
+        };
+        "q/limit": string;
+        "q/order-by": (string | string[])[][];
+    };
+    params: {};
+};

package/lib/src/unit-utils/enums.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumsRequest = exports.getEnumIconColorQuery = void 0;
+exports.getEnumIconSelect = getEnumIconSelect;
+const select_1 = require("@fibery/query-utils/src/select");
+const enum_value_1 = require("../field-utils/enum-value");
+const access_1 = require("./access");
+const getWorkflowQuery = ({ typeObject }) => {
+    if (!typeObject.isEnum) {
+        return null;
+    }
+    return typeObject.nameParts.namespace === "workflow"
+        ? {
+            "workflow/Final": "workflow/Final",
+            "workflow/Type": "workflow/Type",
+        }
+        : null;
+};
+const getEnumIconColorQuery = ({ typeObject, contextPath = [], }) => {
+    if (!typeObject.isEnum) {
+        return {};
+    }
+    const select = {
+        "?accessToIcon": ["q/access?", [...contextPath, "enum/icon"]],
+    };
+    if (Object.hasOwn(typeObject.fieldObjectsByName, "enum/color")) {
+        select["enum/color"] = "enum/color";
+    }
+    if (Object.hasOwn(typeObject.fieldObjectsByName, "enum/icon")) {
+        select["enum/icon"] = "enum/icon";
+    }
+    return select;
+};
+exports.getEnumIconColorQuery = getEnumIconColorQuery;
+const getEnumNumberFieldQuery = (typeObject) => {
+    const fieldObject = (0, enum_value_1.getNumberFieldObject)(typeObject);
+    if (!fieldObject) {
+        return null;
+    }
+    return (0, select_1.toSelectMapClause)([fieldObject.name]);
+};
+function getEnumIconSelect(typeObject) {
+    if (typeObject.isEnum) {
+        return {
+            "enum/icon": ["enum/icon"],
+        };
+    }
+    return {};
+}
+const getEnumsRequest = (enumTypeObject) => {
+    return {
+        query: {
+            "q/from": enumTypeObject.name,
+            "q/select": {
+                "fibery/id": "fibery/id",
+                "enum/name": "enum/name",
+                "fibery/rank": "fibery/rank",
+                ...(0, access_1.generateAccessCheckQueryExpression)({ typeObject: enumTypeObject }),
+                ...(0, exports.getEnumIconColorQuery)({ typeObject: enumTypeObject }),
+                ...getWorkflowQuery({ typeObject: enumTypeObject }),
+                ...getEnumNumberFieldQuery(enumTypeObject),
+            },
+            "q/limit": "q/no-limit",
+            "q/order-by": [[["fibery/rank"], "q/asc"]],
+        },
+        params: {},
+    };
+};
+exports.getEnumsRequest = getEnumsRequest;

package/lib/src/unit-utils/formatters.d.ts

@@ -0,0 +1,50 @@
+import { FieldObject } from "@fibery/schema";
+import { NumberDisplaySettings } from "../field-utils/number";
+export declare const defaultLocale = "en-US";
+export declare const defaultDateFormat = "MMM D, YYYY";
+export declare const defaultDateTimeFormat = "MMM D, YYYY HH:mm";
+export declare const defaultTimeFormat = "HH:mm";
+export declare const formatArbitraryNumber: (value: number, displaySettings?: NumberDisplaySettings, options?: Intl.NumberFormatOptions) => string;
+export declare const formatNumber: (useGrouping: boolean, precision: number, value: number, displaySettings?: NumberDisplaySettings) => string;
+export declare const formatCurrency: (currency: string, useGrouping: boolean, precision: number, value: number | string, displaySettings?: NumberDisplaySettings) => string;
+export declare const formatPercent: (useGrouping: boolean, precision: number, value: number | string, displaySettings?: NumberDisplaySettings) => string;
+export declare const formatNumberWithoutUnit: ({ value, format, displaySettings, currencyCode, precision, useThousandSeparator, }: {
+    value: string;
+    format?: string;
+    displaySettings?: NumberDisplaySettings;
+    currencyCode: string | null;
+    precision: number;
+    useThousandSeparator: boolean;
+}) => string;
+export declare const formatNumberWithUnitAsString: ({ value, format, displaySettings, unit, currencyCode, precision, useThousandSeparator, withNumberUnit, }: {
+    value: string;
+    format?: string;
+    displaySettings?: NumberDisplaySettings;
+    unit?: string | null;
+    currencyCode: string | null;
+    precision: number;
+    useThousandSeparator: boolean;
+    withNumberUnit: boolean;
+}) => string;
+export declare const formatNumberWithUnitAsStringByFieldObject: (fieldObject: FieldObject, value: string, displaySettings?: NumberDisplaySettings) => string;
+export declare const formatDateRange: ({ value, type, format, }: {
+    value: {
+        start: string;
+        end: string;
+    };
+    type: string;
+    format?: string;
+}) => string;
+export declare const formatDateTimeRange: ({ value, type, dateFormat, timeFormat, dateTimeFormat, }: {
+    value: {
+        start: string;
+        end: string;
+    };
+    type: string;
+    dateFormat?: string;
+    timeFormat?: string;
+    dateTimeFormat?: string;
+}) => string;
+export declare function formatUnitUrl(url: string): {
+    host: string;
+};