@vuu-ui/vuu-utils 4.0.0-beta.6 → 4.0.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-beta.6",
+  "version": "4.0.0",
   "author": "heswell",
   "main": "./src/index.js",
   "license": "Apache-2.0",
@@ -11,18 +11,18 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "dependencies": {
-    "@salt-ds/core": "1.72.0"
+    "@salt-ds/core": "1.74.0"
   },
   "devDependencies": {
     "@dnd-kit/react": "^0.1.21",
-    "@vuu-ui/vuu-data-types": "4.0.0-beta.6",
-    "@vuu-ui/vuu-table-types": "4.0.0-beta.6",
-    "@vuu-ui/vuu-filter-types": "4.0.0-beta.6",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-beta.6"
+    "@vuu-ui/vuu-data-types": "4.0.0",
+    "@vuu-ui/vuu-table-types": "4.0.0",
+    "@vuu-ui/vuu-filter-types": "4.0.0",
+    "@vuu-ui/vuu-protocol-types": "4.0.0"
   },
   "peerDependencies": {
     "@internationalized/date": "^3.0.0",
-    "@vuu-ui/vuu-filter-parser": "4.0.0-beta.6",
+    "@vuu-ui/vuu-filter-parser": "4.0.0",
     "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/formatting-utils.js

@@ -52,8 +52,8 @@ const numericFormatter = ({ align = "right", serverDataType, type })=>{
     {
         const { alignOnDecimals = false, decimals, roundingRule, useLocaleString, zeroPad = false } = type.formatting ?? DEFAULT_NUMERIC_FORMAT;
         return (value)=>{
-            if (serverDataType?.startsWith("scaleddecimal")) if (null == value) return "";
-            else if ("string" == typeof value) return roundScaledDecimal(value, align, decimals, zeroPad, alignOnDecimals, useLocaleString, roundingRule);
+            if ("long" === serverDataType || serverDataType?.startsWith("scaleddecimal")) if (null == value) return "";
+            else if ("string" == typeof value || "long" === serverDataType && "number" == typeof value) return roundScaledDecimal("number" == typeof value ? value.toString() : value, align, decimals, zeroPad, alignOnDecimals, useLocaleString, roundingRule);
             else throw Error(`[formatting-utils] numericFormatter, invalid data for ${serverDataType}: '${value}'`);
             if ("string" == typeof value && (value.startsWith("Σ") || value.startsWith("["))) return value;
             const number = "number" == typeof value ? value : "string" == typeof value ? parseFloat(value) : void 0;

package/src/round-decimal.js

@@ -1,10 +1,33 @@
 const PUNCTUATION_STR = String.fromCharCode(8200);
 const DIGIT_STR = String.fromCharCode(8199);
 const DECIMALS_AUTO = -1;
+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 exceedsMaxSafeInteger = (value)=>{
+    const digits = value.startsWith("-") ? value.slice(1) : value;
+    return digits.length > MAX_INTEGER_DIGITS || digits.length === MAX_INTEGER_DIGITS && digits > MAX_SAFE_INTEGER;
+};
+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;
@@ -70,9 +93,12 @@ function roundDecimal(value, align = Align.Right, decimals = 4, zeroPad, alignOn
     const [whole, part2 = ""] = value.toString().split(".");
     const part1 = carriesIntoIntegral(part2, decimals, roundingRule) ? incrementIntegral(whole) : whole;
     const actualDecimals = part2.length;
-    integral = "-0" === part1 ? "-0" : useLocaleString ? parseFloat(part1).toLocaleString() : parseFloat(part1).toString();
+    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") {
@@ -83,9 +109,12 @@ function roundScaledDecimal(value, align = Align.Right, decimals = 4, zeroPad, a
     const [whole, part2 = ""] = value.split(".");
     const part1 = carriesIntoIntegral(part2, decimals, roundingRule) ? incrementIntegral(whole) : whole;
     const actualDecimals = part2.length;
-    integral = "" === part1 ? "0" : "-0" === part1 ? "-0" : useLocaleString ? exceedsMaxSafeInteger(value) ? BigInt(part1).toLocaleString() : parseFloat(part1).toLocaleString() : part1;
+    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/component-registry.d.ts

@@ -11,7 +11,12 @@ export interface ConfigurationEditorProps {
     column: ColumnDescriptorCustomRenderer;
     onChangeRendering: ColumnRenderPropsChangeHandler;
 }
-export type RowClassNameGenerator = (dataRow: DataRow) => string | undefined;
+/**
+ * Returns a class name for a row, or undefined. previousDataRow and nextDataRow
+ * are the rows immediately before and after dataRow in data order. Either is
+ * undefined at the start or end of the data, or when that row is not loaded.
+ */
+export type RowClassNameGenerator = (dataRow: DataRow, previousDataRow?: DataRow, nextDataRow?: DataRow) => string | undefined;
 export type RowClassGenerator = {
     id: string;
     fn: RowClassNameGenerator;

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;

package/types/src/Clock.d.ts

@@ -0,0 +1,20 @@
+export interface ClockProps {
+    year?: number;
+    month?: number;
+    day?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+}
+export type ClockTimeUnit = "minutes" | "seconds" | "ms";
+export declare class Clock {
+    #private;
+    constructor(props?: ClockProps);
+    goBack(value: number, units?: ClockTimeUnit): this;
+    advance(value: number, units?: ClockTimeUnit): this;
+    set showCurrentTime(value: boolean);
+    toString(): string;
+    get now(): number;
+    get date(): Date;
+}

package/types/src/PageVisibilityObserver.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from "./event-emitter";
+export type PageVisibilityEvents = {
+    /**
+     * emits when page has been hidden for this period of time
+     */
+    "inactive-timeout": () => void;
+    /**
+     * emits when page is hidden
+     */
+    hidden: () => void;
+    /**
+     * emits when page is made visible
+     */
+    visible: () => void;
+    /**
+     * emits when page visibility status changes
+     */
+    visibilityChange: (hidden: boolean) => void;
+};
+export interface PageVisibilityObserverConstructorProps {
+    /**
+     * timeout period in seconds. Defaults to zero which will never timeout
+     */
+    inactiveTimeout?: number;
+    onHidden?: () => void;
+    onInactiveTimeout?: () => void;
+    onVisible?: () => void;
+    onVisibilityChange?: () => void;
+}
+export declare class PageVisibilityObserver extends EventEmitter<PageVisibilityEvents> {
+    #private;
+    visibilityChangeHandler: () => void;
+    constructor({ inactiveTimeout, onHidden, onInactiveTimeout, onVisibilityChange, onVisible, }?: PageVisibilityObserverConstructorProps);
+    clear(): void;
+    private set hidden(value);
+}

package/types/src/ScaledDecimal.d.ts

@@ -0,0 +1,12 @@
+export declare class ScaledDecimal {
+    protected readonly value: string;
+    private readonly decimals;
+    constructor(value: string, decimals?: number);
+    get asLong(): string;
+    toJSON(): string;
+    toString(): string;
+}
+export declare const ScaledDecimal2: (value: string) => ScaledDecimal;
+export declare const ScaledDecimal4: (value: string) => ScaledDecimal;
+export declare const ScaledDecimal6: (value: string) => ScaledDecimal;
+export declare const ScaledDecimal8: (value: string) => ScaledDecimal;

package/types/src/ShellContext.d.ts

@@ -0,0 +1,11 @@
+import type { RpcResponseHandler } from "@vuu-ui/vuu-data-types";
+import type { DefaultColumnConfiguration, DefaultTableConfiguration } from "@vuu-ui/vuu-table-types";
+import { LookupTableProvider } from "./feature-utils";
+export interface ShellContextProps {
+    getDefaultColumnConfig?: DefaultColumnConfiguration;
+    getDefaultTableConfig?: DefaultTableConfiguration;
+    getLookupValues?: LookupTableProvider;
+    handleRpcResponse?: RpcResponseHandler;
+}
+export declare const ShellContext: import("react").Context<ShellContextProps>;
+export declare const useShellContext: () => ShellContextProps;

package/types/src/ThemeProvider.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from "react";
+export declare const DEFAULT_DENSITY: Density;
+export declare const DEFAULT_THEME = "salt-theme";
+export declare const DEFAULT_THEME_MODE: ThemeMode;
+export type Density = "high" | "medium" | "low" | "touch";
+export type ThemeMode = "light" | "dark";
+export type TargetElement = "root" | "scope" | "child";
+export interface ThemeContextProps {
+    density: Density;
+    theme: string;
+    themeMode: ThemeMode;
+}
+export declare const ThemeContext: import("react").Context<ThemeContextProps>;
+export type ThemeClasses = [string, string, ThemeMode];
+export type ThemeAttributes = {
+    themeClass: string;
+    densityClass: string;
+    dataMode: ThemeMode;
+};
+export declare const useThemeAttributes: (themeAttributes?: ThemeAttributes) => [string, string, ThemeMode];
+interface ThemeProviderProps {
+    applyThemeClasses?: boolean;
+    children: ReactNode;
+    density?: Density;
+    theme?: string;
+    themeMode?: ThemeMode;
+}
+export declare function ThemeProvider({ applyThemeClasses, children, theme: themeProp, themeMode: themeModeProp, density: densityProp, }: ThemeProviderProps): import("react").JSX.Element;
+export declare namespace ThemeProvider {
+    var displayName: string;
+}
+export {};

package/types/src/array-utils.d.ts

@@ -0,0 +1,16 @@
+export type PartitionTest<T> = (value: T, index: number) => boolean;
+export declare function partition<T>(array: T[], test: PartitionTest<T>, pass?: T[], fail?: T[]): [T[], T[]];
+export declare function itemsChanged<T = unknown>(currentItems: T[], newItems: T[], identityProperty?: string): boolean;
+export declare function itemsOrOrderChanged<T = unknown>(currentItems: T[], newItems: T[], identityProperty?: string): boolean;
+export declare const moveItemDeprecated: <T = unknown>(items: T[], item: T, moveTo: number) => T[];
+export declare const moveItem: <T = unknown>(items: T[], fromIndex: number, toIndex: number) => T[];
+export declare const getAddedItems: <T>(values: undefined | T[], newValues: T[]) => T[];
+export declare const getMissingItems: <T, I>(sourceItems: T[], items: I[], identity: (s: T) => I) => I[];
+/**
+ * Given an ordered list of item names, return items in same order
+ */
+export declare const reorderItems: <T extends {
+    name: string;
+} = {
+    name: string;
+}>(originalItems: readonly T[], orderedNames: string[]) => T[];

package/types/src/box-utils.d.ts

@@ -0,0 +1,24 @@
+export interface rect {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+}
+export type rectTuple = [number, number, number, number];
+export type dimension = "width" | "height";
+export declare function boxContainsPoint(rect: rect, x: number, y: number): boolean | undefined;
+export type GridLayoutSplitDirection = "north" | "south" | "east" | "west";
+export type GridLayoutDropPosition = GridLayoutSplitDirection | "header" | "centre";
+export declare function getCenteredBox({ right, left, top, bottom }: rect, pctSize: number): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export declare function pointPositionWithinRect(x: number, y: number, rect: rect, borderZone?: number): {
+    pctX: number;
+    pctY: number;
+    closeToTheEdge: number;
+};
+export declare const isGridLayoutSplitDirection: (position: GridLayoutDropPosition) => position is GridLayoutSplitDirection;
+export declare function getPositionWithinBox(x: number, y: number, rect: rect, pctX: number, pctY: number): GridLayoutDropPosition;

package/types/src/broadcast-channel.d.ts

@@ -0,0 +1,16 @@
+interface VuuBroadcastChannelEventMap<T> {
+    message: MessageEvent<T>;
+    messageerror: MessageEvent<T>;
+}
+export interface VuuBroadcastChannel<T> extends EventTarget {
+    readonly name: string;
+    onmessage: ((this: BroadcastChannel, evt: MessageEvent<T>) => void) | null;
+    onmessageerror: ((this: BroadcastChannel, evt: MessageEvent<T>) => void) | null;
+    close(): void;
+    postMessage<M extends T = T>(message: M): void;
+    addEventListener<K extends keyof VuuBroadcastChannelEventMap<T>>(type: K, listener: (this: BroadcastChannel, evt: VuuBroadcastChannelEventMap<T>[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof VuuBroadcastChannelEventMap<T>>(type: K, listener: (this: BroadcastChannel, evt: VuuBroadcastChannelEventMap<T>[K]) => void, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+export {};