eru-grid 0.0.49 → 0.0.51

package/types/eru-grid.d.ts

@@ -256,6 +256,8 @@ interface DynamicDataRequest {
     apiName?: string;
     apiField?: string;
     search?: string;
+    limit?: number;
+    skip?: number;
     filter?: Record<string, any>;
 }
 interface Field {
@@ -269,6 +271,7 @@ interface Field {
     minWidth?: number;
     maxWidth?: number;
     symbol?: string;
+    symbol_field?: string;
     options?: any[];
     option_type?: 'STATIC' | 'API' | 'ENTITY_DATA';
     entity_name?: string;
@@ -300,6 +303,7 @@ interface Field {
         to?: number | null;
         color?: string | null;
     }[];
+    cell_rules?: CellFormatRule[];
     data_length?: number;
     start_value?: number;
     end_value?: number;
@@ -342,6 +346,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 +388,55 @@ 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`
+ *   cell_rules              conditional formatting is a grid feature; it
+ *                           overrides the field's `color_ranges` per grid
+ *
+ * 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 +543,169 @@ 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[];
+/**
+ * True when this grid's column carries conditional formatting of its own.
+ *
+ * The test for "configured" is a non-empty list: an empty `cell_rules` is what
+ * removing the last rule leaves behind, and that has to read as "nothing
+ * configured here" so the data model's bands come back rather than the column
+ * being stuck with no formatting at all.
+ */
+declare function hasOwnCellRules(column: Field | null | undefined): boolean;
+/**
+ * The rules in force on a column: its own conditional formatting if configured,
+ * otherwise the data model's `color_ranges` bands.
+ *
+ * Conditional formatting is a property of this grid's view, `color_ranges` a
+ * property of the field — so the two are separate keys and this is the one place
+ * that decides between them. Every consumer (cell painting, stat requests, the
+ * design pane) reads through here, so they cannot disagree about which list is
+ * live.
+ */
+declare function columnCellRules(column: Field | null | undefined): CellFormatRule[];
+/** 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 +885,130 @@ 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.
+ */
+/**
+ * Theme colours offerable on a column or a conditional-format rule.
+ *
+ * A one-for-one mirror of eru-studio's `colorTokens`, label for label, with
+ * `--studio-` swapped for `--grid-`: the two libraries dress the same page, so a
+ * colour chosen on a field and the same colour chosen on a grid column have to
+ * mean the same thing. Keep the two lists in step when either changes.
+ *
+ * 'Primary Light' used to sit in here and was never part of that set — nor was
+ * `--grid-primary-light` ever defined, so picking it produced an invalid
+ * `var()` and silently dropped whatever it was applied to. Its M3 equivalent is
+ * Primary Container, which is what studio calls it.
+ */
+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;
+/**
+ * Which scale a value abbreviates on when no `display_number_as` is chosen:
+ * the one its digit grouping already implies.
+ *
+ * `seperator` and `display_number_as` were asking the same question twice — the
+ * data model already says whether a field reads Indian or Western, and a column
+ * grouped 1,00,00,000 that abbreviates to 'mn' is a contradiction. So the
+ * grouping supplies the scale and 'Display as' stays editable to override it.
+ */
+declare function abbreviationScaleFor(seperator: string | null | undefined): 'lacs' | 'mn';
+/**
+ * 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 +1017,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 +1400,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 +1925,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 +2272,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 +2296,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 +2476,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';
@@ -2141,6 +2517,50 @@ declare function resolveRowValue(row: any, fieldName: string): any;
  */
 declare function evaluateRowCondition(expression: string | null | undefined, row: any): boolean;
 
+/**
+ * Restricts an `<input type="text">` to a numeric value.
+ *
+ * Lives in eru-grid and is exported from its public API so the grid's cells and
+ * eru-studio's page controls share one implementation — the same value typed in
+ * a grid and on a page has to be accepted or rejected identically.
+ *
+ * Text rather than `type="number"` on purpose: a number input reformats the
+ * value on its own, refuses to show a grouped or symbol-prefixed value, and
+ * renders spinners the design does not use. Every eru-studio numeric field is
+ * therefore a text input — which accepted any string at all until this.
+ *
+ * Filtering happens at `beforeinput`, so the character is judged in the context
+ * it would land in: this is what tells a second '.' from the first, and a '-'
+ * typed at the start from one typed mid-value. A `keypress` filter cannot see
+ * either, and blur-time validation lets the user type a whole wrong value first.
+ */
+declare class NumericInputDirective {
+    private el;
+    /** Allow a decimal point. Off for an integer-only field. */
+    readonly allowDecimal: _angular_core.InputSignal<boolean>;
+    /** Allow a leading minus. Off where a negative makes no sense. */
+    readonly allowNegative: _angular_core.InputSignal<boolean>;
+    /**
+     * Would this be a valid numeric string, allowing the in-progress forms a
+     * user necessarily passes through — '', '-', '1.' — none of which parse as a
+     * number but all of which are on the way to one.
+     */
+    private isAcceptable;
+    /** The value the input would hold if this event were allowed through. */
+    private projectedValue;
+    onBeforeInput(event: InputEvent): void;
+    /**
+     * A paste is filtered rather than blocked: pasting a formatted amount
+     * ("$1,234.50") is a normal thing to do, and stripping it to 1234.50 is what
+     * the user meant. Only a paste with no digits at all is rejected outright.
+     */
+    onPaste(event: ClipboardEvent): void;
+    /** Digits, at most one decimal point, and a single leading minus. */
+    private clean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumericInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NumericInputDirective, "input[eruNumericInput]", never, { "allowDecimal": { "alias": "eruAllowDecimal"; "required": false; "isSignal": true; }; "allowNegative": { "alias": "eruAllowNegative"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 interface AttachmentConfig {
     disabled?: boolean;
     required?: boolean;
@@ -2244,6 +2664,116 @@ 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>;
 }
 
+/** One chip. `color`/`background`/`dot` are optional: without them the chip
+ *  takes the neutral surface, which is what a plain value wants. */
+interface ChipListItem {
+    label: string;
+    color?: string | null;
+    background?: string | null;
+    dot?: string | null;
+}
+/**
+ * A row of chips that fits its container, with a `+N` for the rest.
+ *
+ * Shared by the grid's and eru-studio's multi-selects so a set of values reads
+ * the same in a cell, on a page and inside a select's trigger.
+ *
+ * Widths are MEASURED, not estimated. The tag cell assumes ~30px per chip,
+ * which is close enough for short tags and wrong for the entity names a select
+ * holds ("Acme Industries Pvt Ltd" is four times that) — it either wraps or
+ * hides chips that would have fitted. Measuring with a canvas rather than by
+ * rendering avoids the two-pass flicker of laying every chip out and then
+ * hiding the overflow.
+ */
+declare class ChipListComponent implements OnDestroy {
+    private host;
+    private readonly _chips;
+    /** Plain labels — the neutral chip. */
+    set labels(value: string[] | null | undefined);
+    /**
+     * Chips that carry their own colours — a tag or a status, where the colour is
+     * part of the value's meaning rather than decoration. Takes precedence over
+     * `labels`; set one or the other.
+     */
+    set chips(value: ChipListItem[] | null | undefined);
+    private readonly _compact;
+    set compact(value: boolean | null | undefined);
+    /**
+     * Width to fit into. 0 means "measure the host", which is what a page control
+     * wants; a grid cell passes its column width, which is known before layout.
+     */
+    private readonly _availableWidth;
+    set availableWidth(value: number | null | undefined);
+    readonly isCompact: _angular_core.Signal<boolean>;
+    /** Width assumed when nothing above the row constrains it. */
+    private static readonly UNCONSTRAINED_WIDTH;
+    private readonly measuredWidth;
+    private observer;
+    constructor();
+    private observe;
+    ngOnDestroy(): void;
+    /**
+     * The width to fit into.
+     *
+     * A grid cell hands us its column width and that is the constraint. A page
+     * control does not: eru-studio sizes every field shell with `width:
+     * fit-content`, so the host hugs whatever we just rendered — measuring the
+     * host would mean measuring our own output, and the row could never grow past
+     * the chip it happens to be showing. That is why view mode sat at one chip
+     * while edit mode, which gets Material's fixed infix width, showed three.
+     *
+     * So when no width is given, look UP for the first ancestor that is wider
+     * than the host: that is the box actually constraining the layout, and it
+     * does not change when our content does.
+     */
+    private measure;
+    /** Chip text width for the host's actual font, via a shared canvas. */
+    private static canvas;
+    private textWidth;
+    private readonly fit;
+    readonly visible: _angular_core.Signal<ChipListItem[]>;
+    readonly hiddenCount: _angular_core.Signal<number>;
+    readonly hiddenLabels: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipListComponent, "eru-chip-list", never, { "labels": { "alias": "labels"; "required": false; }; "chips": { "alias": "chips"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "availableWidth": { "alias": "availableWidth"; "required": false; }; }, {}, 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 +2816,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 +3089,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;
@@ -2867,6 +3397,15 @@ declare class SelectComponent implements OnInit, AfterViewInit {
     editModeChange: EventEmitter<boolean>;
     currentValue: _angular_core.WritableSignal<any>;
     searchText: _angular_core.WritableSignal<string>;
+    private static readonly OPTIONS_PAGE_SIZE;
+    /** The rendered mat-select, for its `panel` element once the overlay opens. */
+    private matSelect?;
+    /** Debounced search text, sent to the consumer as `search` (→ field_str). */
+    private readonly serverSearch;
+    private readonly optionsSkip;
+    /** Set when a short page comes back — nothing more to ask for. */
+    private readonly optionsExhausted;
+    private searchDebounce;
     error: _angular_core.WritableSignal<string>;
     isAllSelected: _angular_core.Signal<boolean>;
     isIndeterminate: _angular_core.Signal<boolean>;
@@ -2910,11 +3449,31 @@ declare class SelectComponent implements OnInit, AfterViewInit {
      */
     optionsCacheKey: _angular_core.Signal<string>;
     onSearchChange(searchValue: string): void;
+    /**
+     * Ask the consumer for the next page when the panel nears its end.
+     *
+     * Options are appended, never recycled: mat-select addresses MatOption
+     * instances for its selection, trigger text and keyboard navigation, so a
+     * virtual scroller destroying them as they leave the viewport breaks all
+     * three. Paging the data while keeping the DOM is what is wanted here.
+     */
+    private panelScrollTeardown;
+    /** Attach the paging listener to mat-select's panel once the overlay exists. */
+    private attachPanelScroll;
+    private detachPanelScroll;
+    private onPanelScroll;
     onOpenedChange(opened: boolean): void;
     ngAfterViewInit(): void;
     onDrillableClick(event: Event): void;
     getProperty(property: string): any;
     hasRequiredValidation(): boolean;
+    /**
+     * Selected values as their option labels, for the chip row.
+     *
+     * Same resolution as formatDisplayValue — the chip list only changes how they
+     * are laid out, so the two must never disagree about what a value is called.
+     */
+    readonly selectedLabels: _angular_core.Signal<string[]>;
     formatDisplayValue(): string;
     trackByValueAndIndex(index: number, option: any): string;
     /**
@@ -3053,6 +3612,13 @@ declare class TagComponent implements OnInit {
         label: any;
         color: any;
     }[]>;
+    /**
+     * Selected tags as coloured chips for the shared chip row.
+     *
+     * The colour is part of a tag's meaning, so it travels with the label rather
+     * than the chip list assuming a neutral pill.
+     */
+    readonly tagChips: _angular_core.Signal<ChipListItem[]>;
     maxDisplayTags: _angular_core.Signal<number>;
     tagDisplay: _angular_core.Signal<{
         displayTags: string[];
@@ -3221,5 +3787,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, ChipListComponent, 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, NumericInputDirective, 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, abbreviationScaleFor, cellRuleBarPercent, cellRuleMatches, cellRuleToCss, cellStatAlias, cellTextStyleToCss, collectColumnStatRequests, columnCellRules, composeColorValue, evaluateRowCondition, formatCellValue, formatDateWithPattern, formatNumberValue, hasOwnCellRules, 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, ChipListItem, 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 };