@vuu-ui/vuu-utils 3.4.1 → 3.5.0-beta.1

package/types/date/date-utils.d.ts

@@ -5,34 +5,60 @@ export type zeroToFive = 0 | oneToFive;
 export type sixToNine = 6 | 7 | 8 | 9;
 export type zeroToNine = zeroToFive | sixToNine;
 export type oneToNine = oneToFive | sixToNine;
-export type TimeUnit = "hours" | "minutes" | "seconds";
+export type TimeUnit = "hours" | "minutes" | "seconds" | "milliseconds";
 export type Hours = `${0 | 1}${zeroToNine}` | `2${0 | 1 | 2 | 3}`;
 export type Minutes = `${zeroToFive}${zeroToNine}`;
 export type Seconds = `${zeroToFive}${zeroToNine}`;
-export type TimeUnitValue<T extends TimeUnit> = T extends "hours" ? Hours : T extends "minutes" ? Minutes : Seconds;
+export type Milliseconds = `${zeroToNine}${zeroToNine}${zeroToNine}`;
+export type TimeUnitValue<T extends TimeUnit> = T extends "hours" ? Hours : T extends "minutes" ? Minutes : T extends "seconds" ? Seconds : Milliseconds;
 export type TimeString = `${number}${number}:${number}${number}:${number}${number}`;
+/**
+ * A TimeString with millisecond precision, hh:mm:ss.SSS
+ */
+export type TimeStringMillis = `${TimeString}.${number}${number}${number}`;
 type YYYY = `19${zeroToNine}${zeroToNine}` | `20${zeroToNine}${zeroToNine}`;
 type MM = `0${oneToNine}` | `1${0 | 1 | 2}`;
 type DD = `${0}${oneToNine}` | `${1 | 2}${zeroToNine}` | `3${0 | 1}`;
 export type DateStringISO = `${YYYY}-${MM}-${DD}`;
 export declare const zeroTime: TimeString;
+export declare const zeroTimeMillis: TimeStringMillis;
 export declare const zeroTimeUnit: TimeUnitValue<TimeUnit>;
-export declare function incrementTimeUnitValue<T extends TimeUnit>(unit: T, value: TimeUnitValue<T>): Hours | TimeUnitValue<T>;
-export declare function decrementTimeUnitValue<T extends TimeUnit>(unit: T, value: TimeUnitValue<T>): Hours | TimeUnitValue<T>;
-export declare function updateTimeString<T extends TimeUnit>(timeString: TimeString, unit: T, value: TimeUnitValue<T>): TimeString;
+export declare function incrementTimeUnitValue<T extends TimeUnit>(unit: T, value: TimeUnitValue<T>): TimeUnitValue<T>;
+export declare function decrementTimeUnitValue<T extends TimeUnit>(unit: T, value: TimeUnitValue<T>): TimeUnitValue<T>;
+export declare function updateTimeString<S extends TimeString | TimeStringMillis, T extends TimeUnit>(timeString: S, unit: T, value: TimeUnitValue<T>): S;
 export declare const isValidTimeString: (value: unknown) => value is TimeString;
+export declare const isValidTimeStringMillis: (value: unknown) => value is TimeStringMillis;
+/**
+ * Convert a valid TimeString or TimeStringMillis to the required precision.
+ * Milliseconds are added (as 000) or removed as necessary. Returns undefined
+ * if value is not a valid time.
+ */
+export declare function normaliseTimeString(value: unknown, milliseconds: true): TimeStringMillis | undefined;
+export declare function normaliseTimeString(value: unknown, milliseconds?: false): TimeString | undefined;
+export declare function normaliseTimeString(value: unknown, milliseconds?: boolean): TimeString | TimeStringMillis | undefined;
 export declare function asTimeString(value: unknown, allowUndefined: false): TimeString;
 export declare function asTimeString(value: unknown, allowUndefined?: true): TimeString | undefined;
+/**
+ * Millisecond precision equivalent of asTimeString. Accepts a TimeString,
+ * TimeStringMillis or a timestamp (millis since epoch, number or string).
+ */
+export declare function asTimeStringMillis(value: unknown, allowUndefined: false): TimeStringMillis;
+export declare function asTimeStringMillis(value: unknown, allowUndefined?: true): TimeStringMillis | undefined;
 export interface Time {
     hours: number;
     minutes: number;
     seconds: number;
+    milliseconds: number;
     asDate: (date?: Date | DateStringISO) => Date;
 }
 export declare const Time: {
-    (timeString: TimeString): Time;
+    (timeString: TimeString | TimeStringMillis): Time;
     millisToTimeString(timestamp: number): TimeString;
-    toString(hours: number, minutes: number, seconds: number): TimeString;
+    millisToTimeStringMillis(timestamp: number): TimeStringMillis;
+    toString: typeof timeToString;
     isDateInMillis(dtInMillis: string | number): boolean;
 };
+declare function timeToString(hours: number, minutes: number, seconds: number): TimeString;
+declare function timeToString(hours: number, minutes: number, seconds: number, milliseconds: number): TimeStringMillis;
+declare function timeToString(hours: number, minutes: number, seconds: number, milliseconds?: number): TimeString | TimeStringMillis;
 export {};

package/types/date/dateTimePattern.d.ts

@@ -1,8 +1,15 @@
-import { DateTimeDataValueDescriptor } from "@vuu-ui/vuu-data-types";
+import type { DataValueType, DateTimeDataValueDescriptor } from "@vuu-ui/vuu-data-types";
+import type { TemporalKind } from "./temporal";
 import { DateTimePattern } from "./types";
 export declare const defaultPatternsByType: {
     readonly time: "hh:mm:ss";
     readonly date: "dd.mm.yyyy";
 };
 export declare const fallbackDateTimePattern: DateTimePattern;
-export declare function dateTimePattern(type: DateTimeDataValueDescriptor["type"]): DateTimePattern;
+export declare const defaultDateTimePatternByKind: Record<TemporalKind, DateTimePattern>;
+/**
+ * Returns the DateTimePattern configured on the type (formatting.pattern), if
+ * there is one. Otherwise, the default pattern for the temporal kind. If kind
+ * is not provided, it is inferred from type name.
+ */
+export declare function dateTimePattern(type?: DataValueType | DateTimeDataValueDescriptor["type"], kind?: TemporalKind | undefined): DateTimePattern;

package/types/date/formatter.d.ts

@@ -1,9 +1,34 @@
 import { DateFormatter } from "@internationalized/date";
+import type { FractionalSecondDigits } from "@vuu-ui/vuu-table-types";
+import { EpochTimestamp } from "./EpochTimestamp";
+import { type TimeZoneSpec } from "./time-zone";
 import { DateTimePattern } from "./types";
 type DateTimeFormatConfig = {
     locale: string;
     options: Intl.DateTimeFormatOptions;
 };
+export interface DateTimeFormatOptions {
+    /**
+     * Number of sub-second digits to display, when pattern includes time. If
+     * not specified, 3 is used for the 'hh:mm:ss.ms' pattern, otherwise 0.
+     */
+    fractionalSecondDigits?: FractionalSecondDigits;
+    /**
+     * Override the locale implied by the pattern. Pattern then determines the
+     * style of each field, locale determines order and language.
+     */
+    locale?: string;
+    timeZone?: TimeZoneSpec;
+}
+type TimestampFormatter = (ts: EpochTimestamp) => string;
+/**
+ * Create a formatter for EpochTimestamp values. This is the most general
+ * formatter, it supports nanosecond precision.
+ */
+export declare function formatTimestamp({ date, time }: DateTimePattern, { fractionalSecondDigits, locale, timeZone, }?: DateTimeFormatOptions): TimestampFormatter;
+/**
+ * Create a formatter for Date values.
+ */
+export declare function formatDate(pattern: DateTimePattern, options?: DateTimeFormatOptions): (d: Date) => string;
 export declare function getDateFormatter({ locale, options }: DateTimeFormatConfig): DateFormatter;
-export declare function formatDate(pattern: DateTimePattern): (d: Date) => string;
 export {};

package/types/date/index.d.ts

@@ -1,4 +1,8 @@
-export { asTimeString, decrementTimeUnitValue, incrementTimeUnitValue, isValidTimeString, Time, toCalendarDate, type DateStringISO, type Hours, type Minutes, type Seconds, type TimeString, type TimeUnit, type TimeUnitValue, updateTimeString, zeroTime, zeroTimeUnit, } from "./date-utils";
+export { asTimeString, asTimeStringMillis, decrementTimeUnitValue, incrementTimeUnitValue, isValidTimeString, isValidTimeStringMillis, normaliseTimeString, Time, toCalendarDate, type DateStringISO, type Hours, type Milliseconds, type Minutes, type Seconds, type TimeString, type TimeStringMillis, type TimeUnit, type TimeUnitValue, updateTimeString, zeroTime, zeroTimeMillis, zeroTimeUnit, } from "./date-utils";
 export { dateTimePattern, defaultPatternsByType, fallbackDateTimePattern, } from "./dateTimePattern";
 export * from "./formatter";
 export { dateTimeLabelByType, isDatePattern, isTimePattern, supportedDateTimePatterns, type DatePattern, type DateTimePattern, type TimePattern, } from "./types";
+export { defaultDateTimePatternByKind } from "./dateTimePattern";
+export { EpochTimestamp, type TemporalEncoding } from "./EpochTimestamp";
+export * from "./temporal";
+export * from "./time-zone";

package/types/date/temporal.d.ts

@@ -0,0 +1,68 @@
+import type { DataValueDescriptor, TemporalDataValueTypeSimple } from "@vuu-ui/vuu-data-types";
+import type { FractionalSecondDigits } from "@vuu-ui/vuu-table-types";
+import { EpochTimestamp, type TemporalEncoding } from "./EpochTimestamp";
+import { type TimeZoneSpec } from "./time-zone";
+/**
+ * What a temporal value represents, from the user's perspective
+ * - datetime: a point in time, date and time of day are both meaningful
+ * - date: a calendar date, time of day is not meaningful
+ * - time: a time of day, the date is not meaningful (typically 'today')
+ */
+export type TemporalKind = "datetime" | "date" | "time";
+/**
+ * The finest resolution that the encoding can represent.
+ */
+export type TemporalPrecision = "ms" | "ns";
+export interface TemporalInfo {
+    kind: TemporalKind;
+    encoding: TemporalEncoding;
+    precision: TemporalPrecision;
+    timeZone: TimeZoneSpec;
+}
+export declare const isTemporalTypeName: (typeName?: string) => typeName is TemporalDataValueTypeSimple;
+type TemporalDescriptor = Pick<DataValueDescriptor, "serverDataType" | "type">;
+/**
+ * The single source of truth for whether (and how) a column or form field
+ * holds a temporal value. Rules:
+ *
+ * - encoding is determined by serverDataType
+ *   - epochtimestamp => epochMillis
+ *   - epochtimestampnano => epochNanos
+ *   - long, int, double (or unspecified) => epochMillis, but only when the
+ *     'type' is a temporal type. This legacy usage (pre epochtimestamp) is
+ *     DEPRECATED and supported only for backward compatibility. Timestamps
+ *     should be described by the server as epochtimestamp or epochtimestampnano.
+ * - kind is determined by 'type' ('date/time', 'date', 'time'), default 'datetime'.
+ *   An explicit type of 'number' opts an epochtimestamp column out of temporal
+ *   treatment altogether.
+ * - timeZone from type.formatting.timeZone, falling back to the default time zone
+ *
+ * @returns TemporalInfo or undefined if value is not temporal
+ */
+export declare const getTemporalInfo: (descriptor?: TemporalDescriptor) => TemporalInfo | undefined;
+export declare const isTemporal: (descriptor?: TemporalDescriptor) => boolean;
+export declare const defaultFractionalSecondDigits: (info: Pick<TemporalInfo, "precision">) => FractionalSecondDigits;
+/**
+ * Format a timestamp as a canonical, locale independent, editable string:
+ * - date: yyyy-mm-dd
+ * - datetime: yyyy-mm-dd hh:mm:ss[.fffffffff]
+ * - time: hh:mm:ss[.fffffffff]
+ * Sub-second digits are included only when non zero, up to the precision of
+ * the encoding, so they round-trip unchanged through an edit.
+ */
+export declare const formatTemporalInput: (value: EpochTimestamp | undefined, { kind, precision, timeZone }: Omit<TemporalInfo, "encoding">) => string;
+/**
+ * Parse user input. Accepts the canonical formats produced by
+ * formatTemporalInput as well as raw epoch values (in the encoding of the
+ * column). Where the input does not include a component (e.g the date for a
+ * 'time' value), it is taken from baseValue if provided, otherwise today
+ * (date) or midnight (time).
+ *
+ * @returns EpochTimestamp, or undefined if input is not valid
+ */
+export declare const parseTemporalInput: (input: string, { kind, encoding, precision, timeZone }: TemporalInfo, baseValue?: EpochTimestamp) => EpochTimestamp | undefined;
+/**
+ * Placeholder text describing the canonical input format for a kind.
+ */
+export declare const temporalInputPlaceholder: (kind: TemporalKind) => "hh:mm:ss" | "yyyy-mm-dd" | "yyyy-mm-dd hh:mm:ss";
+export {};

package/types/date/time-zone.d.ts

@@ -0,0 +1,52 @@
+import { CalendarDate } from "@internationalized/date";
+import type { DateStringISO, TimeString } from "./date-utils";
+/**
+ * 'local' (browser time zone), 'UTC' or any IANA time zone identifier.
+ */
+export type TimeZoneSpec = "local" | "UTC" | (string & {});
+/**
+ * Set the time zone used for temporal values where a column does not
+ * specify one explicitly (formatting.timeZone). Default is 'local'.
+ */
+export declare const setDefaultTimeZone: (timeZone: TimeZoneSpec) => void;
+export declare const getDefaultTimeZone: () => TimeZoneSpec;
+/**
+ * Resolve a TimeZoneSpec to an IANA time zone identifier.
+ */
+export declare const resolveTimeZone: (timeZone?: TimeZoneSpec) => string;
+export interface DateTimeFields {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    millisecond: number;
+}
+export declare const getDateTimeFields: (epochMillis: number, timeZone?: TimeZoneSpec) => DateTimeFields;
+/**
+ * Convert wall clock fields in the given time zone to epoch millis. Where the
+ * wall clock time is ambiguous or does not exist (DST transitions), the
+ * 'compatible' disambiguation strategy is used (same as Temporal / JS Date).
+ */
+export declare const fromDateTimeFields: ({ year, month, day, hour, minute, second, millisecond, }: Partial<DateTimeFields> & Pick<DateTimeFields, "year" | "month" | "day">, timeZone?: TimeZoneSpec) => number;
+/**
+ * Epoch millis of the start of the calendar day (in timeZone) that contains epochMillis.
+ */
+export declare const startOfDay: (epochMillis: number, timeZone?: TimeZoneSpec) => number;
+/**
+ * Epoch millis of the start of the calendar day (in timeZone) following the day that
+ * contains epochMillis. This is DST safe, the day may be 23, 24 or 25 hours long.
+ */
+export declare const startOfNextDay: (epochMillis: number, timeZone?: TimeZoneSpec) => number;
+export declare const isStartOfDay: (epochMillis: number, timeZone?: TimeZoneSpec) => boolean;
+/**
+ * A date to which a time of day can be applied. 'today' and 'yesterday' are
+ * resolved at the point of use, so filters that use them remain relative.
+ */
+export type RelativeDate = "today" | "yesterday" | DateStringISO;
+export declare const resolveRelativeDate: (date?: RelativeDate | Date, timeZone?: TimeZoneSpec) => CalendarDate;
+/**
+ * Epoch millis of the given time of day on the given date, in timeZone.
+ */
+export declare const timeOfDayToEpochMillis: (timeString: TimeString | `${TimeString}.${string}`, date?: RelativeDate | Date, timeZone?: TimeZoneSpec) => number;

package/types/filters/filter-utils.d.ts

@@ -72,5 +72,9 @@ export declare const stripFilterFromColumns: (columns: RuntimeColumnDescriptor[]
     type?: import("@vuu-ui/vuu-data-types").DataValueType;
 }[];
 export declare const extractFilterForColumn: (filter: Filter | undefined, columnName: string) => Filter | undefined;
+/**
+ * The full-day range used as default value of a time range filter.
+ */
+export declare const getDefaultTimeRange: (column: ColumnDescriptor) => [string, string];
 export declare const getColumnValueFromFilter: (column: ColumnDescriptor, operator: ColumnFilterOp, filter?: FilterContainerFilter) => ColumnFilterValue;
 export declare const filtersAreEqual: (f1: FilterContainerFilter | null | undefined, f2: FilterContainerFilter | null | undefined) => boolean;

package/types/filters/filterAsQuery.d.ts

@@ -1,8 +1,46 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
 import type { ColumnDescriptorsByName, Filter, SingleValueFilterClause } from "@vuu-ui/vuu-filter-types";
+import { type TemporalInfo } from "../date/temporal";
+import { type RelativeDate } from "../date/time-zone";
 export declare const filterAsQuery: (f: Filter, opts?: {
     columnsByName?: ColumnDescriptorsByName;
 }) => string;
 export declare const ONE_DAY_IN_MILLIS: number;
+export interface TemporalFilterAsQueryOptions {
+    /**
+     * The date against which time of day (TimeString) values are resolved.
+     * Default is 'today', resolved at the time the query is created.
+     */
+    date?: RelativeDate;
+}
+/**
+ * Serialize a filter clause on a temporal column. Values are interpreted at
+ * the granularity implied by the value and the column 'kind':
+ * - day: column kind is 'date', or a 'datetime' value at the exact start of a
+ *   day (in the column time zone), e.g as selected from a DatePicker. The clause
+ *   applies to the whole day: '=' becomes a [startOfDay, startOfNextDay) range,
+ *   '>' becomes '>= startOfNextDay' etc. Day boundaries are DST safe.
+ * - second: time of day values (TimeString or whole second 'time' values)
+ * - exact: all other values
+ * Values are encoded according to the column encoding (millis or nanos).
+ */
+export declare function temporalFilterAsQuery(f: SingleValueFilterClause, temporalInfo: TemporalInfo, options?: TemporalFilterAsQueryOptions): string;
+/**
+ * @deprecated use temporalFilterAsQuery
+ */
 export declare function dateFilterAsQuery(f: SingleValueFilterClause<number>, opts?: {
     columnsByName?: ColumnDescriptorsByName;
 }): string;
+export declare const getColumnsByName: (columns: readonly ColumnDescriptor[]) => ColumnDescriptorsByName;
+/**
+ * Build the columnsByName used to serialize a filter. Column descriptors
+ * provided by client take precedence over (are merged with) the schema columns.
+ */
+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.
+ */
+export declare const filterRequiresResolution: (filter: Filter, columnsByName?: ColumnDescriptorsByName) => boolean;

package/types/form-utils.d.ts

@@ -1,7 +1,11 @@
 import { DataValueTypeSimple } from "@vuu-ui/vuu-data-types";
 import { VuuColumnDataType, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
 import { KeyboardEvent, SyntheticEvent } from "react";
+import { EpochTimestamp } from "./date/EpochTimestamp";
+import { type TemporalInfo } from "./date/temporal";
+import type { DataValueDescriptor } from "@vuu-ui/vuu-data-types";
 import { ExtendedFilterOptions } from "@vuu-ui/vuu-filter-types";
+import { type ScaledDecimal } from "./ScaledDecimal";
 export declare class DataValidationError extends Error {
     actualType: string;
     expectedType: string;
@@ -35,3 +39,18 @@ export declare function getTypedRange([value1, value2]: [string, string], dataTy
  */
 export declare function getTypedValue(value: string, type: VuuColumnDataType | DataValueTypeSimple, throwIfInvalid?: false, options?: ExtendedFilterOptions): VuuRowDataItemType | undefined;
 export declare function getTypedValue(value: string, type: VuuColumnDataType | DataValueTypeSimple, throwIfInvalid: true, options?: ExtendedFilterOptions): VuuRowDataItemType;
+/**
+ * Convert a string value (from user input or a filter control) to the wire
+ * representation of a temporal value, using the column's TemporalInfo.
+ * - time kind: a TimeString is applied to today's date (in the column time zone)
+ * - any kind: canonical input (see parseTemporalInput) or raw epoch digits
+ * Values are returned in the column encoding (number for epochMillis, string
+ * for epochNanos).
+ */
+export declare function getTypedTemporalValue(value: string, temporalInfo: TemporalInfo, throwIfInvalid?: boolean, baseValue?: EpochTimestamp): number | string | undefined;
+/**
+ * Like getTypedValue, but takes a column (or form field) descriptor. Temporal
+ * values are handled according to getTemporalInfo, other values according to
+ * the type name, if there is one, otherwise the serverDataType.
+ */
+export declare function getTypedValueForDescriptor(value: string, descriptor: DataValueDescriptor, throwIfInvalid?: boolean): VuuRowDataItemType | ScaledDecimal | bigint | undefined;

package/types/formatting-utils.d.ts

@@ -1,8 +1,23 @@
+import { DataValueDescriptor } from "@vuu-ui/vuu-data-types";
 import { ColumnDescriptor, ValueFormatter } from "@vuu-ui/vuu-table-types";
 export type ValueFormatters = {
     [key: string]: ValueFormatter;
 };
 export declare const defaultValueFormatter: (value: unknown) => string;
+/**
+ * Creates a formatter for a temporal value (see getTemporalInfo). Handles
+ * millisecond and nanosecond encodings, the configured (or default) pattern,
+ * time zone, locale and fractional second digits.
+ * Empty values (null, undefined, '', 0) are rendered as empty string.
+ */
+export declare const temporalFormatter: (column: DataValueDescriptor, temporalInfo?: import("./date/temporal").TemporalInfo | undefined) => ValueFormatter;
+/**
+ * Format a filter value on a temporal column for display (e.g. in a FilterPill
+ * tooltip or a list of filter clauses). Time of day (TimeString) values are
+ * displayed as is. A 'datetime' value at the start of a day (which the filter
+ * applies to the whole day, see temporalFilterAsQuery) is displayed as a date.
+ */
+export declare const formatTemporalFilterValue: (value: unknown, column: DataValueDescriptor) => string;
 export declare const numericFormatter: ({ align, serverDataType, type, }: Partial<ColumnDescriptor>) => (value: unknown) => string;
 export declare const getValueFormatter: (column: ColumnDescriptor) => ValueFormatter;
 /**

package/types/src/Clock.d.ts

@@ -1,20 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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