@vuu-ui/vuu-utils 3.5.17 → 3.5.18-beta.1

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.17",
+  "version": "3.5.18-beta.1",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -15,14 +15,14 @@
   },
   "devDependencies": {
     "@dnd-kit/react": "^0.1.21",
-    "@vuu-ui/vuu-data-types": "3.5.17",
-    "@vuu-ui/vuu-table-types": "3.5.17",
-    "@vuu-ui/vuu-filter-types": "3.5.17",
-    "@vuu-ui/vuu-protocol-types": "3.5.17"
+    "@vuu-ui/vuu-data-types": "3.5.18-beta.1",
+    "@vuu-ui/vuu-table-types": "3.5.18-beta.1",
+    "@vuu-ui/vuu-filter-types": "3.5.18-beta.1",
+    "@vuu-ui/vuu-protocol-types": "3.5.18-beta.1"
   },
   "peerDependencies": {
     "@internationalized/date": "^3.0.0",
-    "@vuu-ui/vuu-filter-parser": "3.5.17",
+    "@vuu-ui/vuu-filter-parser": "3.5.18-beta.1",
     "clsx": "^2.0.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3"

package/src/ScaledDecimal.js

@@ -9,7 +9,6 @@ class ScaledDecimal {
     constructor(value, decimals = 6){
         this.value = value;
         this.decimals = decimals;
-        console.log(`create a scaled decimal ${value} (${decimals} decimals)`);
     }
     get asLong() {
         if ("" === this.value) return "";

package/src/filters/filterAsQuery.js

@@ -4,6 +4,7 @@ import { isStartOfDay, startOfDay, startOfNextDay, timeOfDayToEpochMillis } from
 import { stringIsValidLong } from "../data-utils.js";
 import { isMultiClauseFilter, isMultiValueFilter, isSerializableFilter } from "./filter-utils.js";
 import { ScaledDecimal } from "../ScaledDecimal.js";
+import { getScaledDecimalScale, isScaledDecimalFilterOptions, scaledDecimalFilterAsQuery } from "./scaled-decimal-filter.js";
 const filterValue = (value, columnType)=>{
     if ("string" == typeof value) {
         if (void 0 !== columnType) {
@@ -12,7 +13,11 @@ const filterValue = (value, columnType)=>{
                 "long",
                 "double",
                 "epochtimestamp",
-                "epochtimestampnano"
+                "epochtimestampnano",
+                "scaleddecimal2",
+                "scaleddecimal4",
+                "scaleddecimal6",
+                "scaleddecimal8"
             ].includes(columnType);
             return isNumericType ? value : `"${value}"`;
         }
@@ -43,6 +48,7 @@ const filterAsQueryCore = (f, opts)=>{
 function singleValueFilterAsQuery(f, opts) {
     if (isSerializableFilter(f)) return f.asQuery();
     {
+        if (isScaledDecimalFilterOptions(f.extendedOptions)) return scaledDecimalFilterAsQuery(f, f.extendedOptions);
         const column = opts?.columnsByName?.[f.column];
         const temporalInfo = getTemporalInfo(column);
         if (temporalInfo) return temporalFilterAsQuery(f, temporalInfo);
@@ -143,7 +149,10 @@ const getColumnsByNameForFilter = (tableSchema, columnsByName)=>{
 };
 const filterRequiresResolution = (filter, columnsByName)=>{
     if (isMultiClauseFilter(filter)) return filter.filters.some((f)=>filterRequiresResolution(f, columnsByName));
-    if (isSerializableFilter(filter)) return true;
-    return void 0 !== getTemporalInfo(columnsByName?.[filter.column]);
+    {
+        if (isSerializableFilter(filter) || isScaledDecimalFilterOptions(filter.extendedOptions)) return true;
+        const column = columnsByName?.[filter.column];
+        return void 0 !== getTemporalInfo(column) || void 0 !== getScaledDecimalScale(column?.serverDataType);
+    }
 };
 export { ONE_DAY_IN_MILLIS, dateFilterAsQuery, filterAsQuery, filterRequiresResolution, getColumnsByName, getColumnsByNameForFilter, temporalFilterAsQuery };

package/src/filters/index.js

@@ -1,3 +1,4 @@
 export * from "./filter-utils.js";
 export * from "./filterAsQuery.js";
 export * from "./temporal-cell-filter.js";
+export * from "./scaled-decimal-filter.js";

package/src/filters/scaled-decimal-filter.js

@@ -0,0 +1,130 @@
+import { isTypeDescriptor } from "../column-utils.js";
+import { roundScaledDecimal } from "../round-decimal.js";
+const DEFAULT_DISPLAY_DECIMALS = 4;
+const scales = {
+    scaleddecimal2: 2,
+    scaleddecimal4: 4,
+    scaleddecimal6: 6,
+    scaleddecimal8: 8
+};
+const getScaledDecimalScale = (serverDataType)=>void 0 === serverDataType ? void 0 : scales[serverDataType];
+const decimalPattern = /^-?(\d+(\.\d*)?|\.\d+)$/;
+const isValidDecimalString = (value)=>decimalPattern.test(value);
+const isScaledDecimalFilterOptions = (options)=>options?.type === "ScaledDecimal";
+const toDecimalString = (value, scale)=>{
+    if ("number" == typeof value) {
+        const text = `${value}`;
+        return /e/i.test(text) ? value.toFixed(scale) : text;
+    }
+    return `${value}`;
+};
+const toScaledInteger = (value, scale)=>{
+    if (!isValidDecimalString(value)) throw Error(`[scaled-decimal-filter] invalid decimal value '${value}'`);
+    const negative = value.startsWith("-");
+    const [integral, fraction = ""] = (negative ? value.slice(1) : value).split(".");
+    const magnitude = BigInt((integral || "0") + fraction.slice(0, scale).padEnd(scale, "0"));
+    return negative ? -magnitude : magnitude;
+};
+const fromScaledInteger = (value, scale)=>{
+    const negative = value < 0n;
+    const digits = (negative ? -value : value).toString().padStart(scale + 1, "0");
+    const literal = `${digits.slice(0, -scale)}.${digits.slice(-scale)}`;
+    return negative ? `-${literal}` : literal;
+};
+const getScaledDecimalFilterOptions = (column)=>{
+    const scale = getScaledDecimalScale(column.serverDataType);
+    if (void 0 === scale) return;
+    if (isTypeDescriptor(column.type)) {
+        const { decimals = DEFAULT_DISPLAY_DECIMALS, roundingRule = "round" } = column.type.formatting ?? {};
+        return decimals < scale ? {
+            type: "ScaledDecimal",
+            scale,
+            decimals,
+            roundingRule
+        } : {
+            type: "ScaledDecimal",
+            scale
+        };
+    }
+    return {
+        type: "ScaledDecimal",
+        scale
+    };
+};
+const countDecimals = (value)=>value.split(".")[1]?.length ?? 0;
+const getScaledDecimalMatchRange = (value, { scale, decimals, roundingRule = "round" })=>{
+    const scaledValue = toScaledInteger(value, scale);
+    const precision = void 0 === decimals ? scale : Math.max(decimals, countDecimals(value));
+    if (precision >= scale) return [
+        scaledValue,
+        scaledValue
+    ];
+    const step = 10n ** BigInt(scale - precision);
+    if ("truncate" === roundingRule) if (scaledValue > 0n) return [
+        scaledValue,
+        scaledValue + step - 1n
+    ];
+    else if (scaledValue < 0n) return [
+        scaledValue - step + 1n,
+        scaledValue
+    ];
+    else return [
+        -step + 1n,
+        step - 1n
+    ];
+    {
+        const half = step / 2n;
+        if (scaledValue > 0n) return [
+            scaledValue - half,
+            scaledValue + half - 1n
+        ];
+        if (scaledValue < 0n) return [
+            scaledValue - half + 1n,
+            scaledValue + half
+        ];
+        return [
+            -half + 1n,
+            half - 1n
+        ];
+    }
+};
+const scaledDecimalFilterAsQuery = ({ column, op, value }, options)=>{
+    const { scale } = options;
+    const [from, to] = getScaledDecimalMatchRange(toDecimalString(value, scale), options);
+    const lo = fromScaledInteger(from, scale);
+    const hi = fromScaledInteger(to, scale);
+    if (from === to) return `${column} ${op} ${lo}`;
+    switch(op){
+        case "=":
+            return `(${column} >= ${lo} and ${column} <= ${hi})`;
+        case "!=":
+            return `(${column} < ${lo} or ${column} > ${hi})`;
+        case ">":
+            return `${column} > ${hi}`;
+        case ">=":
+            return `${column} >= ${lo}`;
+        case "<":
+            return `${column} < ${lo}`;
+        case "<=":
+            return `${column} <= ${hi}`;
+        default:
+            throw Error(`[scaled-decimal-filter] operator ${op} is not supported for scaled decimals`);
+    }
+};
+const getScaledDecimalCellFilter = (column, value)=>{
+    const options = getScaledDecimalFilterOptions(column);
+    if (void 0 === options || "string" != typeof value || "" === value) return;
+    const { decimals, roundingRule } = options;
+    if (void 0 === decimals) return {
+        label: value,
+        op: "=",
+        value
+    };
+    const display = (useLocaleString)=>roundScaledDecimal(value, void 0, decimals, true, false, useLocaleString, roundingRule);
+    return {
+        label: display(true),
+        op: "=",
+        value: display(false)
+    };
+};
+export { fromScaledInteger, getScaledDecimalCellFilter, getScaledDecimalFilterOptions, getScaledDecimalMatchRange, getScaledDecimalScale, isScaledDecimalFilterOptions, isValidDecimalString, scaledDecimalFilterAsQuery, toDecimalString, toScaledInteger };

package/src/form-utils.js

@@ -4,6 +4,7 @@ import { getTemporalInfo, parseTemporalInput } from "./date/temporal.js";
 import { getDefaultTimeZone } from "./date/time-zone.js";
 import { isTypeDescriptor } from "./column-utils.js";
 import { queryClosest } from "./html-utils.js";
+import { isValidDecimalString } from "./filters/scaled-decimal-filter.js";
 import { ScaledDecimal2, ScaledDecimal4, ScaledDecimal6, ScaledDecimal8 } from "./ScaledDecimal.js";
 class DataValidationError extends Error {
     actualType;
@@ -33,6 +34,12 @@ function getTypedRange([value1, value2], dataType, options) {
         getTypedValue(value2, dataType, false, options)
     ];
 }
+const ScaledDecimalFactory = {
+    scaleddecimal2: ScaledDecimal2,
+    scaleddecimal4: ScaledDecimal4,
+    scaleddecimal6: ScaledDecimal6,
+    scaleddecimal8: ScaledDecimal8
+};
 const getActualType = (value)=>{
     if ("boolean" == typeof value) return "boolean";
     if ("number" == typeof value) return "number";
@@ -53,13 +60,12 @@ function getTypedValue(value, type, throwIfInvalid = false, options) {
             if (!throwIfInvalid) return;
             throw new DataValidationError(`value ${value} is not a valid ${type}`, "single character", getActualType(value));
         case "scaleddecimal2":
-            return ScaledDecimal2(value);
         case "scaleddecimal4":
-            return ScaledDecimal4(value);
         case "scaleddecimal6":
-            return ScaledDecimal6(value);
         case "scaleddecimal8":
-            return ScaledDecimal8(value);
+            if ("" === value || isValidDecimalString(value)) return ScaledDecimalFactory[type](value);
+            if (!throwIfInvalid) return;
+            throw new DataValidationError(`value ${value} is not a valid ${type}`, "decimal", getActualType(value));
         case "double":
         case "number":
             if (stringIsValidDecimal(value)) return parseFloat(value);

package/src/round-decimal.js

@@ -5,7 +5,26 @@ const integerFormat = new Intl.NumberFormat();
 const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER.toString();
 const MAX_INTEGER_DIGITS = MAX_SAFE_INTEGER.length;
 const exceedsMaxSafeInteger = (value)=>value.length > MAX_INTEGER_DIGITS || value.length === MAX_INTEGER_DIGITS && value > MAX_SAFE_INTEGER;
-const carriesIntoIntegral = (fraction, decimals, roundingRule)=>"round" === roundingRule && decimals !== DECIMALS_AUTO && fraction.length > decimals && parseFloat(`0.${fraction}`).toFixed(decimals).startsWith("1");
+const roundFraction = (fraction, decimals)=>{
+    const kept = fraction.slice(0, decimals);
+    if (fraction.length <= decimals || fraction[decimals] < "5") return [
+        kept,
+        false
+    ];
+    if (0 === decimals) return [
+        "",
+        true
+    ];
+    const rounded = (BigInt(kept) + 1n).toString().padStart(decimals, "0");
+    return rounded.length > decimals ? [
+        rounded.slice(1),
+        true
+    ] : [
+        rounded,
+        false
+    ];
+};
+const carriesIntoIntegral = (fraction, decimals, roundingRule)=>"round" === roundingRule && decimals !== DECIMALS_AUTO && fraction.length > decimals && roundFraction(fraction, decimals)[1];
 const incrementIntegral = (integral)=>{
     const negative = integral.startsWith("-");
     const magnitude = BigInt(negative ? integral.slice(1) : integral) + 1n;
@@ -73,7 +92,10 @@ function roundDecimal(value, align = Align.Right, decimals = 4, zeroPad, alignOn
     const actualDecimals = part2.length;
     integral = "-0" === part1 ? "-0" : useLocaleString ? integerFormat.format(parseFloat(part1)) : parseFloat(part1).toString();
     if (align === Align.Left && alignOnDecimals) integral = padLeft(integral);
-    fraction = decimals === DECIMALS_AUTO || actualDecimals === decimals ? part2 : actualDecimals > decimals ? "round" === roundingRule ? parseFloat("0." + part2).toFixed(decimals).slice(2) : part2.slice(0, decimals) : (Pad = zeroPad ? Zero : alignOnDecimals && align !== Align.Left ? Space : null) ? 0 === actualDecimals ? Pad.FULL_PADDING[decimals] ?? "" : pad(part2, decimals, Pad) : part2;
+    if (decimals === DECIMALS_AUTO || actualDecimals === decimals) fraction = part2;
+    else if (actualDecimals > decimals) if ("round" === roundingRule) [fraction] = roundFraction(part2, decimals);
+    else fraction = part2.slice(0, decimals);
+    else fraction = (Pad = zeroPad ? Zero : alignOnDecimals && align !== Align.Left ? Space : null) ? 0 === actualDecimals ? Pad.FULL_PADDING[decimals] ?? "" : pad(part2, decimals, Pad) : part2;
     return integral + (fraction ? "." + fraction : "");
 }
 function roundScaledDecimal(value, align = Align.Right, decimals = 4, zeroPad, alignOnDecimals, useLocaleString = true, roundingRule = "round") {
@@ -86,7 +108,10 @@ function roundScaledDecimal(value, align = Align.Right, decimals = 4, zeroPad, a
     const actualDecimals = part2.length;
     integral = "" === part1 ? "0" : "-0" === part1 ? "-0" : useLocaleString ? exceedsMaxSafeInteger(value) ? integerFormat.format(BigInt(part1)) : integerFormat.format(parseFloat(part1)) : part1;
     if (align === Align.Left && alignOnDecimals) integral = padLeft(integral);
-    fraction = decimals === DECIMALS_AUTO || actualDecimals === decimals ? part2 : actualDecimals > decimals ? "round" === roundingRule ? parseFloat("0." + part2).toFixed(decimals).slice(2) : part2.slice(0, decimals) : (Pad = zeroPad ? Zero : alignOnDecimals && align !== Align.Left ? Space : null) ? 0 === actualDecimals ? Pad.FULL_PADDING[decimals] ?? "" : pad(part2, decimals, Pad) : part2;
+    if (decimals === DECIMALS_AUTO || actualDecimals === decimals) fraction = part2;
+    else if (actualDecimals > decimals) if ("round" === roundingRule) [fraction] = roundFraction(part2, decimals);
+    else fraction = part2.slice(0, decimals);
+    else fraction = (Pad = zeroPad ? Zero : alignOnDecimals && align !== Align.Left ? Space : null) ? 0 === actualDecimals ? Pad.FULL_PADDING[decimals] ?? "" : pad(part2, decimals, Pad) : part2;
     return integral + (fraction ? "." + fraction : "");
 }
 export { exceedsMaxSafeInteger, roundDecimal, roundScaledDecimal };

package/types/filters/filterAsQuery.d.ts

@@ -43,7 +43,8 @@ export declare const getColumnsByName: (columns: readonly ColumnDescriptor[]) =>
 export declare const getColumnsByNameForFilter: (tableSchema?: Pick<TableSchema, "columns">, columnsByName?: ColumnDescriptorsByName) => ColumnDescriptorsByName | undefined;
 /**
  * Returns true if the filter includes clauses whose meaning depends on the
- * column type (temporal columns) or which serialize themselves. Such filters
- * must be resolved (see resolveFilterQuery) before they can be evaluated locally.
+ * column type (temporal and scaled decimal columns) or which serialize
+ * themselves. Such filters must be resolved (see resolveFilterQuery) before
+ * they can be evaluated locally.
  */
 export declare const filterRequiresResolution: (filter: Filter, columnsByName?: ColumnDescriptorsByName) => boolean;

package/types/filters/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./filter-utils";
 export * from "./filterAsQuery";
 export * from "./temporal-cell-filter";
+export * from "./scaled-decimal-filter";

package/types/filters/scaled-decimal-filter.d.ts

@@ -0,0 +1,58 @@
+import type { ExtendedFilterOptions, ScaledDecimalFilterOptions, SingleValueFilterClause } from "@vuu-ui/vuu-filter-types";
+import type { DataValueDescriptor } from "@vuu-ui/vuu-data-types";
+export type ScaledDecimalScale = ScaledDecimalFilterOptions["scale"];
+export declare const getScaledDecimalScale: (serverDataType?: string) => ScaledDecimalScale | undefined;
+export declare const isValidDecimalString: (value: string) => boolean;
+export declare const isScaledDecimalFilterOptions: (options?: ExtendedFilterOptions) => options is ScaledDecimalFilterOptions;
+/**
+ * A decimal (not exponential) string representation of a filter value.
+ */
+export declare const toDecimalString: (value: unknown, scale: ScaledDecimalScale) => string;
+/**
+ * Convert a decimal string to its scaled integer representation. Digits beyond
+ * the scale are truncated, as the Vuu server does.
+ */
+export declare const toScaledInteger: (value: string, scale: ScaledDecimalScale) => bigint;
+/**
+ * Convert a scaled integer to a decimal string with 'scale' decimal places,
+ * the literal form in which scaled decimals are expressed in a filter query.
+ */
+export declare const fromScaledInteger: (value: bigint, scale: ScaledDecimalScale) => string;
+/**
+ * The filter options for a clause on a scaled decimal column, describing the
+ * precision with which the column displays values. These mirror the formatting
+ * rules of numericFormatter: a column with no type descriptor displays the full
+ * value, a type descriptor with no decimals displays 4 decimal places.
+ */
+export declare const getScaledDecimalFilterOptions: (column: Pick<DataValueDescriptor, "serverDataType" | "type">) => ScaledDecimalFilterOptions | undefined;
+/**
+ * The range of scaled integer values, inclusive at both ends, matched by a
+ * filter value. A value with no more decimal places than are displayed matches
+ * every value that displays as that value, e.g 1.23, displayed with 2 decimals,
+ * rounded, matches [1.225, 1.235). Display rounding applies to the magnitude,
+ * so -1.23 matches (-1.235, -1.225]. A value with more decimal places than are
+ * displayed is matched at its own precision, by the same rounding rule, e.g
+ * 1.234 matches [1.2335, 1.2345). A value with as many decimal places as the
+ * column holds, or any value where every decimal is displayed, is matched exactly.
+ */
+export declare const getScaledDecimalMatchRange: (value: string, { scale, decimals, roundingRule }: ScaledDecimalFilterOptions) => [bigint, bigint];
+/**
+ * Serialize a filter clause on a scaled decimal column. Where the value matches
+ * a range of values (see getScaledDecimalMatchRange), each operator applies to
+ * that range, e.g '>' matches values greater than every value in the range.
+ * Note: '!=' on a range is expressed as '< from or > to', which, unlike an
+ * exact '!=', does not match a null value.
+ */
+export declare const scaledDecimalFilterAsQuery: ({ column, op, value, }: Pick<SingleValueFilterClause, "column" | "op" | "value">, options: ScaledDecimalFilterOptions) => string;
+export interface ScaledDecimalCellFilter {
+    /** The value as displayed */
+    label: string;
+    op: "=";
+    value: string;
+}
+/**
+ * The filter for a cell value on a scaled decimal column, matching the value as
+ * displayed, e.g a cell displaying 1.23 (underlying value 1.234567) creates a
+ * filter matching every value that displays as 1.23.
+ */
+export declare const getScaledDecimalCellFilter: (column: Pick<DataValueDescriptor, "serverDataType" | "type">, value: unknown) => ScaledDecimalCellFilter | undefined;