eru-grid 0.0.49 → 0.0.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eru-grid",
-  "version": "0.0.49",
+  "version": "0.0.50",
   "peerDependencies": {
     "@angular/common": "^21.1.2",
     "@angular/core": "^21.1.2",

package/types/eru-grid.d.ts

@@ -269,6 +269,7 @@ interface Field {
     minWidth?: number;
     maxWidth?: number;
     symbol?: string;
+    symbol_field?: string;
     options?: any[];
     option_type?: 'STATIC' | 'API' | 'ENTITY_DATA';
     entity_name?: string;
@@ -342,6 +343,12 @@ interface Field {
     rich_text?: boolean;
     is_hyp?: boolean;
     hypl_nm?: string;
+    composite_fields?: string[];
+    composite_direction?: 'stack' | 'inline';
+    composite_separator?: string;
+    cell_page_id?: string;
+    cell_style?: CellTextStyle;
+    cell_style_secondary?: CellTextStyle;
     is_pii?: boolean;
     is_ephi?: boolean;
     to_encrypt?: boolean;
@@ -378,9 +385,53 @@ interface Field {
  *   searchable              whether a picker needs a filter box depends on how
  *                           many options this grid shows, not on the field
  *   dateTimeFormat          legacy alias; the model writes `date_format`
+ *
+ * See SEEDED_FIELD_KEYS for the middle ground: keys the data model supplies a
+ * starting value for, which this grid may then override.
  */
 declare const INHERITED_FIELD_KEYS: readonly string[];
-type DataTypes = 'number' | 'textbox' | 'textarea' | 'currency' | 'date' | 'datetime' | 'duration' | 'time' | 'dropdown_single_select' | 'dropdown_multi_select' | 'location' | 'email' | 'people' | 'checkbox' | 'phone' | 'priority' | 'status' | 'progress' | 'attachment' | 'tag' | 'rating' | 'website';
+/**
+ * The overridable subset of INHERITED_FIELD_KEYS: the data model still supplies
+ * the starting value, but only while the column has none of its own, and the
+ * design panel leaves the control editable instead of locking it. An override is
+ * a normal column edit — emitted as a columnMetaPatch and persisted with the
+ * page, unlike the keys that are purely inherited.
+ *
+ * These are presentation choices that legitimately differ per grid over the very
+ * same field: whether a figure reads 1,25,00,000 or 1.25 Cr, which scale it
+ * abbreviates on, which sibling field carries each row's currency symbol in a
+ * multi-currency dataset, and how wide a date may be spelled — a dense report
+ * wants 'dd-MM-yy' where a detail grid over the same field wants the model's.
+ *
+ * Kept INSIDE the inherited list rather than removed from it, because that list
+ * is also what eru-studio's properties panel reads to show a bound field's real
+ * value; dropping a key there would make the panel and the page disagree.
+ */
+/**
+ * Datatypes that describe how a column is DRAWN rather than what it holds.
+ *
+ * A composite shows other columns; a page renders a layout. The data model has
+ * no such field type, so a mapped column keeps these instead of inheriting the
+ * model's datatype over them (see buildMappedColumnPatch).
+ */
+declare const PRESENTATION_DATATYPES: ReadonlySet<string>;
+/**
+ * Datatypes that colour their own value from the data — a status pill, a
+ * priority chip, a progress band.
+ *
+ * A column-level text colour has nothing to say about these: the colour IS the
+ * value's meaning, authored on the field's options. They still take the
+ * column's typography, and a `cell` background still tints the cell around
+ * them, which is the one colour choice that remains meaningful.
+ */
+declare const SELF_COLOURED_DATATYPES: ReadonlySet<string>;
+/**
+ * Narrowest the action column may be: what the word "Action" needs in the
+ * header, which is wider than a single action icon.
+ */
+declare const ACTION_COLUMN_MIN_WIDTH = 56;
+declare const SEEDED_FIELD_KEYS: readonly string[];
+type DataTypes = 'number' | 'textbox' | 'textarea' | 'currency' | 'date' | 'datetime' | 'duration' | 'time' | 'dropdown_single_select' | 'dropdown_multi_select' | 'location' | 'email' | 'people' | 'checkbox' | 'phone' | 'priority' | 'status' | 'progress' | 'attachment' | 'tag' | 'rating' | 'website' | 'composite' | 'page';
 /** Resolve a data-model datatype to the canonical DataTypes value. */
 declare function normalizeDatatype(datatype: any): DataTypes;
 /** The three colours a status pill is painted with. */
@@ -487,24 +538,149 @@ declare function formatDateWithPattern(date: Date | null, pattern: string): stri
  * splitting cannot recover the field order on its own.
  */
 declare function parseDateWithPattern(text: string, pattern: string): Date | null;
-/** One value band and the colours it paints. Either bound may be open-ended. */
-interface ColorRangeBand {
-    from?: number | null;
-    to?: number | null;
+/**
+ * Resolve a value against a column's `color_ranges`, returning the first
+ * matching band or null.
+ *
+ * Kept as the name the progress, number and currency cells already call, now a
+ * thin alias over matchCellRule so bands and conditional-format rules can never
+ * disagree about what matches.
+ */
+declare function matchColorRange(value: any, ranges: any): ColorRangeBand | null;
+/**
+ * Operators a conditional-format rule can test with.
+ *
+ * `between` is the historical behaviour of a `color_ranges` band and stays the
+ * default when a rule names no operator, so bands authored before this — in the
+ * data model or the design pane — keep matching exactly as they did.
+ */
+type CellRuleOperator = 'between' | 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq' | 'contains' | 'not_contains' | 'starts_with' | 'ends_with' | 'is_empty' | 'is_not_empty' | 'before' | 'after';
+declare const CELL_RULE_OPERATORS: {
+    value: CellRuleOperator;
+    label: string;
+    operands: 0 | 1 | 2;
+}[];
+/**
+ * One conditional-format rule on a column.
+ *
+ * A superset of ColorRangeBand: the same `from`/`to`/`color`/`background` keys
+ * mean the same thing, so every existing `color_ranges` value is already a
+ * valid rule list and no migration is needed. What is new is `op` (so a rule
+ * can test text and dates, not only numeric ranges), the text/cell `fill`
+ * choice, `bold`, and `bar` for a data bar.
+ *
+ * Rules are checked in order and the first match wins — the author controls
+ * precedence by ordering, as `color_ranges` already did.
+ */
+interface CellFormatRule {
+    op?: CellRuleOperator;
+    from?: number | string | null;
+    to?: number | string | null;
     color?: string | null;
     background?: string | null;
+    fill?: 'text' | 'cell';
+    bold?: boolean;
+    /**
+     * Draw the value's magnitude as a bar behind it. `bar_min`/`bar_max` scale
+     * it; without them the bar cannot be drawn, because a bar is relative to the
+     * column and a cell cannot see the column. Column-relative scaling (and
+     * top/bottom-N) needs per-column stats from the server — see the grid docs.
+     */
+    bar?: boolean;
+    bar_min?: number | null;
+    bar_max?: number | null;
+    /** Scale the bar from the column's own min/max instead of fixed bounds. */
+    bar_auto?: boolean;
+    /**
+     * Operands taken from a column statistic rather than typed in. This is how
+     * "top 10 items" or "above average" are expressed: the server returns one
+     * scalar per statistic and it is substituted for `from`/`to` before matching,
+     * so the rule stays an ordinary comparison and nothing downstream changes.
+     */
+    from_stat?: CellStatRef | null;
+    to_stat?: CellStatRef | null;
+}
+/** Statistics a rule operand may be drawn from. Mirrors the aggregate verbs
+ *  the server exposes; `min`, `max` and `avg` are the ones it already has. */
+type CellStatVerb = 'min' | 'max' | 'avg' | 'stddev' | 'percentile' | 'nth';
+interface CellStatRef {
+    stat: CellStatVerb;
+    /** percentile: 0-100. */
+    p?: number;
+    /** nth: 1-based rank. */
+    n?: number;
+    /** nth: which end to count from. */
+    dir?: 'asc' | 'desc';
+    /**
+     * Multiples of the column's standard deviation added to the base statistic,
+     * which is how "one std dev above average" is written: `{ stat: 'avg',
+     * offset_stddev: 1 }`. Requests the stddev alongside the base.
+     */
+    offset_stddev?: number;
+}
+/** One aggregate the grid needs for a column, in the shape the totals call
+ *  already uses. `args` carries the operands the verb takes, if any. */
+interface ColumnStatRequest {
+    func: CellStatVerb;
+    field: string;
+    alias: string;
+    args?: Record<string, any>;
 }
 /**
- * Resolve a numeric value against a column's `color_ranges`, returning the
- * first matching band or null.
+ * Deterministic alias for a statistic.
  *
- * Shared by the progress, number and currency cells so a value falling in the
- * same band paints the same way whichever datatype renders it. A blank or
- * absent bound is open-ended — data-model bands are authored that way ("80 and
- * above"), and coercing a missing bound to 0 would stop such a band matching.
- * Bands are checked in order, so the author controls precedence.
+ * Both sides key off this: the grid asks for it and looks the answer up by the
+ * same string, so nothing has to correlate requests with responses positionally.
  */
-declare function matchColorRange(value: any, ranges: any): ColorRangeBand | null;
+declare function cellStatAlias(field: string, stat: CellStatVerb, args?: {
+    p?: number;
+    n?: number;
+    dir?: string;
+}): string;
+/**
+ * Every statistic the current columns' rules need, deduplicated by alias.
+ *
+ * Deliberately derived from the rules rather than configured separately: a
+ * column asks for exactly the aggregates its formatting uses, so removing a
+ * rule stops the request without anyone remembering to.
+ */
+declare function collectColumnStatRequests(columns: Field[] | null | undefined): ColumnStatRequest[];
+/** A statistic's value, or null when it has not come back (or cannot apply). */
+declare function resolveStatValue(field: string, ref: CellStatRef | null | undefined, stats: Record<string, number> | null | undefined): number | null;
+/**
+ * A column's rules with every statistic-backed operand replaced by its value.
+ *
+ * A rule whose statistic has not arrived is dropped rather than evaluated: with
+ * the operand missing it would either match everything or nothing, and both are
+ * worse than leaving the cell unformatted until the numbers land.
+ */
+declare function resolveColumnRules(column: Field | null | undefined, stats: Record<string, number> | null | undefined): CellFormatRule[];
+/** Legacy alias: a colour band is a rule with no operator. */
+interface ColorRangeBand extends CellFormatRule {
+}
+/**
+ * Does one rule match this value?
+ *
+ * Numeric operators fall back to a string comparison when either side is not a
+ * number, so `eq` works on a status name as readily as on an amount and an
+ * author does not have to know which operator family their datatype belongs to.
+ */
+declare function cellRuleMatches(value: any, rule: CellFormatRule, field?: Field | null): boolean;
+/**
+ * First rule in the list that matches, or null.
+ *
+ * Every datatype resolves its rules through this, which is the point: colour
+ * bands used to be wired into the number, currency and progress cells only, so
+ * a status or a date column could not be conditionally formatted at all.
+ */
+declare function matchCellRule(value: any, rules: any, field?: Field | null): CellFormatRule | null;
+/**
+ * Percentage of the way `value` sits between a rule's bar bounds, or null when
+ * the bar cannot be scaled.
+ */
+declare function cellRuleBarPercent(value: any, rule: CellFormatRule | null): number | null;
+/** A matched rule as an ngStyle map, merged over the column's own cell style. */
+declare function cellRuleToCss(value: any, rule: CellFormatRule | null): Record<string, string>;
 declare const DATA_TYPES: DataTypes[];
 type AggregationFunction = 'sum' | 'count' | 'avg' | 'min' | 'max';
 interface PivotColumnGroupState {
@@ -684,6 +860,107 @@ interface CellValueChange {
  *   <ng-template #personCard let-userId let-column="column">…</ng-template>
  *   <eru-grid [personCardTemplate]="personCard" [gridConfig]="cfg"></eru-grid>
  */
+/**
+ * Basic text styling a column may set on its own cells.
+ *
+ * Kept to four properties on purpose. Cell appearance is otherwise owned by the
+ * grid preset and its tokens, and a column that can set arbitrary CSS stops
+ * inheriting the theme — the reason this is not a `style` string. These four
+ * are what a designer actually reaches for: making a secondary value smaller
+ * and quieter, or an identifier bolder.
+ */
+interface CellTextStyle {
+    font_size?: number;
+    font_weight?: number;
+    italic?: boolean;
+    color?: string;
+    background?: string;
+    /**
+     * Where `background` is painted. `text` wraps the value in a pill that hugs
+     * it (the shape status and tag cells already use); `cell` tints the whole
+     * cell, which is how a column-wide band reads. Ignored without a background.
+     */
+    fill?: 'text' | 'cell';
+}
+/**
+ * Colour tokens a grid column may pick, mirroring eru-studio's picker but over
+ * the grid's own `--grid-*` set — a column styled with a token keeps tracking
+ * the preset/theme instead of freezing one hex.
+ */
+declare const GRID_COLOR_TOKENS: {
+    label: string;
+    value: string;
+}[];
+interface ParsedColorValue {
+    /** `var(--grid-x)` when the value names a token, else null. */
+    token: string | null;
+    /** Hex for the custom-colour input; '#000000' when the value is a token. */
+    hex: string;
+    /** 0-100. */
+    alpha: number;
+}
+/**
+ * Read one of the three shapes a colour value takes: a bare token, a token
+ * wrapped in `color-mix(... N%, transparent)` for partial opacity, or a plain
+ * `rgba()`/hex. Same contract as eru-studio's property editor, so a colour
+ * authored on a page and one authored on a column mean the same thing.
+ *
+ * Opacity rides in `color-mix` rather than being baked into a hex precisely so
+ * a token stays a token: bake it and the colour stops following the theme.
+ */
+declare function parseColorValue(value: any): ParsedColorValue;
+/** Inverse of parseColorValue. Returns null for "nothing set", so a cleared
+ *  colour falls back to the preset rather than being pinned to black. */
+declare function composeColorValue(token: string | null, hex: string | null, alpha: number): string | null;
+/**
+ * CellTextStyle as an ngStyle map. Empty when nothing is set, so the cell keeps
+ * the preset's own values rather than being pinned to defaults.
+ *
+ * A `text` fill turns the container inline-block so it hugs the value and reads
+ * as a pill; a `cell` fill leaves the box alone and just tints it.
+ */
+declare function cellTextStyleToCss(style: CellTextStyle | null | undefined): Record<string, string>;
+/**
+ * Abbreviate a number to k / L / Cr (lacs) or k / mn / bn / tn (millions).
+ *
+ * Shared: the number cell, the currency cell and a composite part must all
+ * abbreviate identically. It lived as a private copy in both number.component
+ * and currency.component — byte-identical, and two places to fix.
+ */
+declare function abbreviateNumber(num: number, system: 'lacs' | 'mn', decimals: number): string;
+/**
+ * Render a number or currency value the way its column configures it —
+ * decimals, separator locale, abbreviation, optional symbol prefix.
+ *
+ * The single implementation behind the number cell, the currency cell and a
+ * composite part, so the same value never reads two ways in one grid.
+ * A non-numeric string is returned untouched: the grid shows what the row
+ * holds rather than 'NaN'.
+ */
+declare function formatNumberValue(value: any, cfg: Partial<Field> | null | undefined, options?: {
+    prefix?: string;
+    replaceZero?: string;
+}): string;
+/**
+ * Best-effort parse of a stored date value, trying the column's own pattern
+ * before falling back to ISO and then the platform parser. Returns null rather
+ * than an Invalid Date so callers can render an empty cell.
+ */
+declare function parseCellDate(value: any, pattern?: string): Date | null;
+/**
+ * Display text for a value under a field's own formatting rules.
+ *
+ * Used where a value must be shown but not edited — today a composite cell's
+ * parts. It deliberately renders text only: a status pill or an avatar stack is
+ * the interactive cell's job, and a composite that tried to host those would be
+ * a layout engine. A column needing that is a `page` cell.
+ */
+declare function formatCellValue(value: any, field: Field | null | undefined): string;
+/**
+ * Read a field's value off a row, tolerating both shapes the grid is handed:
+ * a flat row and one wrapping its values in `entity_data`.
+ */
+declare function readRowValue(row: any, fieldName: string): any;
 interface PersonCardContext {
     /** The selected person's id ($implicit — bind with let-userId) */
     $implicit: string;
@@ -692,6 +969,16 @@ interface PersonCardContext {
     /** Page the field names as the card, from the data model's people_card */
     cardPage?: string;
 }
+/** Context a `page` cell hands its renderer — one row, one column. Mirrors
+ *  BoardCardContext so a consumer can reuse the same card host for both. */
+interface CellTemplateContext {
+    /** Row data for this cell ($implicit — bind with let-row) */
+    $implicit: Row;
+    /** The column being rendered, carrying `cell_page_id` */
+    column: Field;
+    /** All visible columns, for a card that shows more than its own field */
+    columns: Field[];
+}
 interface BoardCardContext {
     /** Row data for this card ($implicit — bind with let-row) */
     $implicit: Row;
@@ -1065,6 +1352,23 @@ declare class EruGridStore {
         name: string;
         patch: Partial<Field>;
     } | null>;
+    /**
+     * Column-wide statistics behind stat-backed conditional-format rules, keyed
+     * by the alias `cellStatAlias` builds. Supplied by the consuming app, which
+     * owns the round trip; the grid only says which aggregates it needs.
+     */
+    private readonly _columnStats;
+    readonly columnStats: _angular_core.Signal<Record<string, number>>;
+    /** Aggregates the current rules need, or null when none do. */
+    private readonly _columnStatsRequest;
+    readonly columnStatsRequest: _angular_core.Signal<ColumnStatRequest[] | null>;
+    setColumnStats(stats: Record<string, number> | null | undefined): void;
+    /**
+     * Publish the aggregate list. Compared before writing so a re-resolve that
+     * produces the same set does not re-trigger the consumer's fetch — the
+     * columns signal changes on every design edit and resize.
+     */
+    setColumnStatsRequest(requests: ColumnStatRequest[] | null): void;
     readonly columns: _angular_core.Signal<Field[]>;
     readonly groups: _angular_core.Signal<RowGroup[]>;
     readonly rows: _angular_core.Signal<Row[]>;
@@ -1573,6 +1877,20 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
      * card trigger stays inert.
      */
     personCardTemplate?: TemplateRef<PersonCardContext>;
+    /**
+     * Renderer for a `page` column's cells — the same contract as
+     * boardCardTemplate, one level down. The grid invokes it once per row for
+     * every column whose datatype is `page`, handing it the row, that column
+     * (which carries `cell_page_id`) and the visible columns. Omit it and such a
+     * column falls back to showing its raw value.
+     *
+     * Example:
+     *   <ng-template #myCell let-row let-column="column">
+     *     <my-page-host [row]="row" [pageId]="column.cell_page_id"></my-page-host>
+     *   </ng-template>
+     *   <eru-grid [cellTemplate]="myCell" [gridConfig]="cfg"></eru-grid>
+     */
+    cellTemplate?: TemplateRef<CellTemplateContext>;
     /**
      * Height in pixels of each board card slot.
      * Must match the fixed height of the card rendered by boardCardTemplate (or the default card).
@@ -1906,6 +2224,10 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
      * Width of the action column. Icons sit side by side, so the column has to
      * grow with the number configured or they wrap; a kebab is always one icon.
      * Capped so a long action list scrolls the icons rather than eating the grid.
+     *
+     * The floor is the header's own width, not the icons': one action needed only
+     * 48px of icon but the word "Action" is wider than that, so the header was
+     * clipped on every single-action grid.
      */
     readonly actionColumnWidth: _angular_core.Signal<number>;
     onSortColumn(event: Event, column: Field, direction: 'asc' | 'desc'): void;
@@ -1926,6 +2248,12 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
      * Attributes a mapped column inherits from its data-model field. Only keys
      * the field actually defines are returned, so a sparse field never blanks
      * out what the column already has.
+     *
+     * SEEDED_FIELD_KEYS are merged only while the column carries no value of its
+     * own: the model supplies the starting point, and this grid's own choice —
+     * including an explicit `false` on a checkbox — wins from then on. Without the
+     * column in hand there is no way to tell "not set" from "set to the opposite",
+     * so an override was overwritten on every resolve.
      */
     private buildMappedColumnPatch;
     /** Get the field name used for grouping */
@@ -2100,7 +2428,7 @@ declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
     requestBoardRowsForGroup(group: RowGroup): void;
     loadBoardAll(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EruGridComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EruGridComponent, "eru-grid", never, { "gridConfig": { "alias": "gridConfig"; "required": false; }; "boardCardTemplate": { "alias": "boardCardTemplate"; "required": false; }; "personCardTemplate": { "alias": "personCardTemplate"; "required": false; }; "boardCardHeight": { "alias": "boardCardHeight"; "required": false; }; "boardCardGap": { "alias": "boardCardGap"; "required": false; }; "boardCardPadding": { "alias": "boardCardPadding"; "required": false; }; }, { "rowSelect": "rowSelect"; "actionClick": "actionClick"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EruGridComponent, "eru-grid", never, { "gridConfig": { "alias": "gridConfig"; "required": false; }; "boardCardTemplate": { "alias": "boardCardTemplate"; "required": false; }; "personCardTemplate": { "alias": "personCardTemplate"; "required": false; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; }; "boardCardHeight": { "alias": "boardCardHeight"; "required": false; }; "boardCardGap": { "alias": "boardCardGap"; "required": false; }; "boardCardPadding": { "alias": "boardCardPadding"; "required": false; }; }, { "rowSelect": "rowSelect"; "actionClick": "actionClick"; }, never, never, true, never>;
 }
 interface GroupItem {
     type: 'header' | 'row' | 'table-header' | 'row-place-holder' | 'ghost-loading';
@@ -2244,6 +2572,42 @@ declare class CheckboxComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "eru-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "change": "change"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
 }
 
+interface CompositePart {
+    name: string;
+    label: string;
+    text: string;
+}
+/**
+ * Several of the row's own columns rendered as one cell — a name over an email,
+ * an amount over a date.
+ *
+ * View-only, and text-only, by design. Each part is formatted by its OWN
+ * field's rules (`formatCellValue`), so a currency part keeps its symbol and
+ * decimals and a date part keeps its pattern; the composite itself decides only
+ * arrangement and emphasis. Editing stays on the underlying columns, which are
+ * usually hidden once composed.
+ */
+declare class CompositeComponent {
+    row: _angular_core.InputSignal<any>;
+    column: _angular_core.InputSignal<Field | null>;
+    columns: _angular_core.InputSignal<Field[]>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    drilldownClick: _angular_core.OutputEmitterRef<string>;
+    readonly inline: _angular_core.Signal<boolean>;
+    readonly separator: _angular_core.Signal<string>;
+    readonly primaryCss: _angular_core.Signal<Record<string, string>>;
+    readonly secondaryCss: _angular_core.Signal<Record<string, string>>;
+    /**
+     * Falls back to the composite column itself when `composite_fields` is unset
+     * or names nothing that exists, so a column switched to `composite` before it
+     * is configured still shows its own value instead of going blank.
+     */
+    readonly parts: _angular_core.Signal<CompositePart[]>;
+    onDrilldown(event: Event, part: CompositePart): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CompositeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CompositeComponent, "eru-composite", never, { "row": { "alias": "row"; "required": false; "isSignal": true; }; "column": { "alias": "column"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; }, { "drilldownClick": "drilldownClick"; }, never, never, true, never>;
+}
+
 interface CurrencyValidationResult {
     isValid: boolean;
     error?: string;
@@ -2286,7 +2650,7 @@ declare class CurrencyComponent {
     rangeColor: _angular_core.Signal<string | null>;
     rangeBackground: _angular_core.Signal<string | null>;
     constructor();
-    formatNumberSignal: _angular_core.Signal<string | undefined>;
+    formatNumberSignal: _angular_core.Signal<string>;
     onActivate(): void;
     onBlur(): void;
     onValueChange(event: any): void;
@@ -2559,7 +2923,7 @@ declare class NumberComponent {
     rangeColor: _angular_core.Signal<string | null>;
     rangeBackground: _angular_core.Signal<string | null>;
     constructor();
-    formatNumberSignal: _angular_core.Signal<string | undefined>;
+    formatNumberSignal: _angular_core.Signal<string>;
     onActivate(): void;
     onBlur(): void;
     onValueChange(event: any): void;
@@ -3221,5 +3585,5 @@ declare class ThemeToggleComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThemeToggleComponent, "eru-theme-toggle", never, {}, {}, never, never, true, never>;
 }
 
-export { AttachmentComponent, CheckboxComponent, ColumnConstraintsService, CurrencyComponent, CustomVirtualScrollStrategy, DATA_TYPES, DATETIME_FORMATS, DATE_FORMATS, DateComponent, DatetimeComponent, DurationComponent, EmailComponent, EruGridComponent, EruGridService, EruGridStore, INHERITED_FIELD_KEYS, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, MONTH_SHORT_NAMES, NumberComponent, PRESET_CONFIG_DEFAULTS, PRESET_MANAGED_FIELDS, PeopleComponent, PhoneComponent, PriorityComponent, ProgressComponent, RatingComponent, SelectComponent, StatusComponent, TagComponent, TextareaComponent, TextboxComponent, ThemeService, ThemeToggleComponent, WebsiteComponent, evaluateRowCondition, formatDateWithPattern, matchColorRange, normalizeDatatype, normalizeDateFormat, normalizeDateTimeFormat, parseDateWithPattern, resolveRowValue, statusPillColors, tagPillColors };
-export type { ActionClick, AggregationFunction, AttachmentConfig, BoardCardContext, CellValueChange, ColorRangeBand, ColumnReorder, ColumnResize, ColumnWidthConstraints, CurrencyValidationResult, DataTypes, Drilldown, DurationValue, DynamicDataRequest, EmailValidationResult, ExcelDownloadPayload, ExcelDownloadRequest, ExcelPivotConfig, Field, GridAction, GridConfiguration, GridFeatures, GridMode, GridPreset, GridStyles, GridTokens, GroupItem$1 as GroupItem, LocationConfig, LocationValidationResult, NumberValidationResult, PeopleOption, PersonCardContext, PivotColumnGroupState, PivotColumnHeader, PivotColumnKind, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, PivotRowKind, RatingConfig, Row, RowDataRequest, RowDataResponse, RowGrandTotal, RowGroup, ServerValidationNotice, StatusPillColors, TagPillColors, TextareaValidationResult, TextboxValidationResult, Theme, WebsiteValidationResult };
+export { ACTION_COLUMN_MIN_WIDTH, AttachmentComponent, CELL_RULE_OPERATORS, CheckboxComponent, ColumnConstraintsService, CompositeComponent, CurrencyComponent, CustomVirtualScrollStrategy, DATA_TYPES, DATETIME_FORMATS, DATE_FORMATS, DateComponent, DatetimeComponent, DurationComponent, EmailComponent, EruGridComponent, EruGridService, EruGridStore, GRID_COLOR_TOKENS, INHERITED_FIELD_KEYS, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, MONTH_SHORT_NAMES, NumberComponent, PRESENTATION_DATATYPES, PRESET_CONFIG_DEFAULTS, PRESET_MANAGED_FIELDS, PeopleComponent, PhoneComponent, PriorityComponent, ProgressComponent, RatingComponent, SEEDED_FIELD_KEYS, SELF_COLOURED_DATATYPES, SelectComponent, StatusComponent, TagComponent, TextareaComponent, TextboxComponent, ThemeService, ThemeToggleComponent, WebsiteComponent, abbreviateNumber, cellRuleBarPercent, cellRuleMatches, cellRuleToCss, cellStatAlias, cellTextStyleToCss, collectColumnStatRequests, composeColorValue, evaluateRowCondition, formatCellValue, formatDateWithPattern, formatNumberValue, matchCellRule, matchColorRange, normalizeDatatype, normalizeDateFormat, normalizeDateTimeFormat, parseCellDate, parseColorValue, parseDateWithPattern, readRowValue, resolveColumnRules, resolveRowValue, resolveStatValue, statusPillColors, tagPillColors };
+export type { ActionClick, AggregationFunction, AttachmentConfig, BoardCardContext, CellFormatRule, CellRuleOperator, CellStatRef, CellStatVerb, CellTemplateContext, CellTextStyle, CellValueChange, ColorRangeBand, ColumnReorder, ColumnResize, ColumnStatRequest, ColumnWidthConstraints, CompositePart, CurrencyValidationResult, DataTypes, Drilldown, DurationValue, DynamicDataRequest, EmailValidationResult, ExcelDownloadPayload, ExcelDownloadRequest, ExcelPivotConfig, Field, GridAction, GridConfiguration, GridFeatures, GridMode, GridPreset, GridStyles, GridTokens, GroupItem$1 as GroupItem, LocationConfig, LocationValidationResult, NumberValidationResult, ParsedColorValue, PeopleOption, PersonCardContext, PivotColumnGroupState, PivotColumnHeader, PivotColumnKind, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, PivotRowKind, RatingConfig, Row, RowDataRequest, RowDataResponse, RowGrandTotal, RowGroup, ServerValidationNotice, StatusPillColors, TagPillColors, TextareaValidationResult, TextboxValidationResult, Theme, WebsiteValidationResult };