@one-grid-core/angular 0.2.1 → 0.4.0

package/lib/core/icons/one-grid-icons.d.ts

@@ -0,0 +1,35 @@
+import { Provider } from '@angular/core';
+/**
+ * The Lucide icons the grid draws, and only those.
+ *
+ * Every component that renders a `<lucide-icon>` picks this set itself, so the
+ * icons travel with the component. That matters now the components are
+ * standalone: a consumer importing `OneGridComponent` directly never touches
+ * `OneGridModule`, and previously got a runtime error — "The 'chevron-first'
+ * icon has not been provided by any available icon providers" — the moment the
+ * pagination bar rendered.
+ *
+ * Eight icons rather than `LucideAngularModule.pick(icons)`, which registered
+ * the entire Lucide set. Nothing else in the grid uses one, and the rest were
+ * dead weight in every consumer's bundle.
+ */
+export declare const ONE_GRID_ICONS: {
+    readonly ArrowDownUp: import("lucide-angular").LucideIconData;
+    readonly ArrowDownZA: import("lucide-angular").LucideIconData;
+    readonly ArrowUpAZ: import("lucide-angular").LucideIconData;
+    readonly ChevronFirst: import("lucide-angular").LucideIconData;
+    readonly ChevronLast: import("lucide-angular").LucideIconData;
+    readonly ChevronLeft: import("lucide-angular").LucideIconData;
+    readonly ChevronRight: import("lucide-angular").LucideIconData;
+    readonly GripVertical: import("lucide-angular").LucideIconData;
+};
+/**
+ * Providers that register {@link ONE_GRID_ICONS} for one standalone component.
+ *
+ * `LucideAngularModule.pick()` cannot be used here: it returns a
+ * `ModuleWithProviders`, and a standalone component's `imports` only accepts
+ * components, directives, pipes and NgModule classes. This is the same
+ * registration `pick` performs, expressed as providers so it can sit on the
+ * component instead.
+ */
+export declare const ONE_GRID_ICON_PROVIDERS: Provider[];

package/lib/core/instants/one-grid-api.class.d.ts

@@ -1,4 +1,4 @@
-import { OneColumnDef } from '../models/one-column-def-types.model';
+import { OneColumnDef, OneColumnStateEntry } from '../models/one-column-def-types.model';
 import { OneRowNode } from "./one-row-node.class";
 import { OneGridInitOptions, OneGridType, OneSortModel } from '../models/one-grid-types.model';
 import { OneGridEventService } from '../services/one-grid-event.service';
@@ -8,6 +8,8 @@ import { OneFilterModel } from "../models/one-filter.model";
 import { OneGridExpansionService } from '../services/one-grid-expansion.service';
 import { OneGetDetailRowDataParams } from "../models/one-master-detail.model";
 import { OneGridRowService } from "../services/one-grid-row.service";
+import { OneCsvExportOptions } from "../../helpers/one-csv.helper";
+import { OneAggColumn } from "../../helpers/one-row-grouping.helper";
 import { OneRowDragSuppressedReason } from "../models/one-row-drag.model";
 import { OneGridCellService } from '../services/one-grid-cell.service';
 import { ColumnChangedEvent, OnePinnedRowSide, RowSelectionMode } from "../models/one-event-types.model";
@@ -187,6 +189,25 @@ export declare class OneGridApi<T = any> {
      * Deselect all nodes (optimized)
      */
     deselectAll(): void;
+    /**
+     * Select or deselect one row, honouring the grid's selection mode.
+     *
+     * The mode rule used to live in the checkbox component, which meant the only
+     * way to select a row was to click that checkbox — anything else reaching for
+     * `toggleSelection` got multi-select behaviour on a single-select grid. It
+     * lives here so every path into selection obeys the same rule.
+     *
+     * @returns `false` when the grid has no selection mode, so a caller can tell
+     *          a refused request from an applied one.
+     */
+    toggleRowSelection(rowId: string, selected: boolean): boolean;
+    /**
+     * Select every row between two, inclusive, in display order.
+     *
+     * What a shift-extended keyboard selection needs. Multi-select only — a
+     * single-select grid has no meaningful range.
+     */
+    selectRowRange(fromRowId: string, toRowId: string): boolean;
     toggleSelection(rowId: string, selected: boolean): void;
     setSelectedById(rowId: string): void;
     setSelectedByIds(rowIds: string[], selected?: boolean): void;
@@ -281,7 +302,100 @@ export declare class OneGridApi<T = any> {
     getColumnState(): ColumnChangedEvent;
     setColumnDefs(columnDefs: OneColumnDef<T>[]): void;
     updateColumn(id: string, changes: Partial<OneColumnDef<T>>): void;
+    /** The visible fields as one comparable key. */
+    private visibleColumnFields;
+    /** Recompute every node's cell states against the current columns. */
+    private regenerateCellStates;
     reorderColumnDefs(fromIndex: number, toIndex: number): void;
+    private _rowGroupFields;
+    private _aggColumns;
+    /** The fields the rows are grouped by, in nesting order. Empty when off. */
+    get rowGroupFields(): readonly string[];
+    /**
+     * Turn row grouping on. Called by `OneGridComponent` when column
+     * definitions declare `rowGroup`; the grid then behaves as a tree over
+     * synthetic group rows, and `setRowData` / `updateRowData` keep taking the
+     * flat rows they always took.
+     */
+    setRowGrouping(groupFields: string[], aggregations?: OneAggColumn<T>[]): void;
+    private _undoLimit;
+    private _undoStack;
+    private _redoStack;
+    /**
+     * Start recording committed cell edits for undo/redo. Called by
+     * `OneGridComponent` from `[undoRedoCellEditing]`; the stack keeps the last
+     * `limit` edits. Programmatic `setDataValue` writes are not recorded — only
+     * commits, the ones that raise `cellValueChanged` without a source.
+     */
+    enableUndoRedoCellEditing(limit?: number): void;
+    /** Revert the most recent committed edit. Returns whether one was undone. */
+    undoCellEditing(): boolean;
+    /** Re-apply the most recently undone edit. Returns whether one was redone. */
+    redoCellEditing(): boolean;
+    getCurrentUndoSize(): number;
+    getCurrentRedoSize(): number;
+    private replayEdit;
+    private _clientPagination;
+    private _pageSize;
+    private _currentPage;
+    /** The paging state, when the grid pages its own rows. */
+    get paginationState(): Readonly<{
+        enabled: boolean;
+        pageSize: number;
+        currentPage: number;
+    }>;
+    /**
+     * Turn grid-owned paging on or off. Called by `OneGridComponent` from its
+     * `clientSidePagination` input; the display slice is what changes — the
+     * full dataset stays behind the API (selection, filters and sorting keep
+     * operating on all of it).
+     */
+    setClientSidePagination(enabled: boolean, pageSize?: number): void;
+    /** Change the page size and return to the first page. */
+    setPageSize(pageSize: number): void;
+    /** Move to a page (1-based). Clamped to at least 1; the top end clamps when the slice is taken. */
+    setCurrentPage(page: number): void;
+    /**
+     * The slice of rows the current page shows — a passthrough while paging is
+     * off. The body routes its render list through here, after reporting the
+     * full count, so `rowCountChanged` keeps meaning "rows after filtering"
+     * whether or not the grid pages.
+     */
+    pageNodes(nodes: readonly OneRowNode<T>[]): OneRowNode<T>[];
+    /**
+     * Size the flex columns into the given width.
+     *
+     * Called by the grid body with its own viewport width — on first render, on
+     * container resize and after column changes — so `columnDef.flex` works
+     * without the host doing anything. Also callable directly with any width.
+     * A no-op when no visible column declares `flex` or nothing would change.
+     */
+    applyFlexWidths(availableWidth: number): void;
+    /**
+     * The current grid as CSV: visible columns in display order, visible rows
+     * in current sort order, values through the same getter/formatter pipeline
+     * the cells render with. Pinned rows and detail grids are not data and are
+     * not included.
+     */
+    getDataAsCsv(options?: OneCsvExportOptions): string;
+    /** Build the CSV and hand it to the browser as a download. */
+    exportDataAsCsv(options?: OneCsvExportOptions): void;
+    /**
+     * Show or hide one column. A hidden column keeps its order, width and pin,
+     * so showing it again restores it exactly.
+     */
+    setColumnVisible(id: string, visible: boolean): void;
+    /**
+     * Persistable layout state: one JSON-safe entry per column — hidden ones
+     * included — in display order. Feed it back through `applyColumnState`.
+     */
+    getColumnStateSnapshot(): OneColumnStateEntry[];
+    /**
+     * Restore a snapshot from `getColumnStateSnapshot`: order, width, pin and
+     * visibility. Ids the grid no longer has are skipped, so a stale snapshot
+     * degrades to a partial restore rather than an error.
+     */
+    applyColumnState(entries: OneColumnStateEntry[]): void;
     /**
      * Update checkbox selection features
      */

package/lib/core/models/one-column-def-types.model.d.ts

@@ -26,7 +26,16 @@ export interface OneCellOptions {
 }
 export type OneCellStatus = 0 | 1;
 export type OneCellButtonIconType = 'add' | 'option' | 'language';
-export type OneCellInputType = 'text' | 'number' | 'email' | 'date' | 'time' | 'datetime' | 'datetime-local';
+export type OneCellInputType = 'text' | 'number' | 'email' | 'date' | 'time' | 'datetime' | 'datetime-local' | 'select';
+/**
+ * One choice in a `select` cell editor. `value` is committed as-is — it keeps
+ * its type, unlike an input editor's string — and `label` is what the option
+ * shows.
+ */
+export interface OneCellSelectOption {
+    label: string;
+    value: any;
+}
 /**
  * What a per-cell presentation callback is handed.
  *
@@ -71,6 +80,12 @@ export interface OneCellRendererParams<T = any> {
     inputType?: OneCellInputType;
     placeholder?: string;
     required?: boolean;
+    /**
+     * The choices for a `select` editor (`inputType: 'select'`). Give the
+     * current cell value a matching option: the browser preselects the first
+     * option otherwise, and closing the editor then commits it.
+     */
+    selectOptions?: OneCellSelectOption[];
     detailActiveButtonStatus?: OneCellStatus;
     detailActiveExcludeLevels?: number[];
     gotoDetailButtonStatus?: OneCellStatus;
@@ -151,6 +166,7 @@ export interface OneColumnDef<T = any> {
     _resolvedSortable?: boolean;
     _resolvedResizable?: boolean;
     _resolvedDragable?: boolean;
+    _resolvedFilterable?: boolean;
     _resolvedSuppressHeaderMenuButton?: boolean;
     _resolvedHeaderClass?: string | string[];
     _resolvedCellClass?: string | string[];
@@ -168,6 +184,32 @@ export interface OneColumnDef<T = any> {
      * nothing pinned renders exactly as before.
      */
     pinned?: 'left' | 'right';
+    /**
+     * Group the rows by this column's value. Several `rowGroup` columns nest,
+     * in column-definition order. The grid then runs its tree machinery over
+     * synthetic group rows: expand/collapse, the auto group column,
+     * `groupDefaultExpanded` — all of it applies. Grouped-by columns are
+     * hidden automatically (their value shows on the group row); un-hide via
+     * `api.setColumnVisible` if you want both. Client-side rows only, and
+     * exclusive with `treeData` and `masterDetail`.
+     */
+    rowGroup?: boolean;
+    /**
+     * Aggregate this column's leaf values onto every group row when row
+     * grouping is active: a built-in name, or a function over the leaves.
+     * The result lands in the group row's own `data[field]`, so formatters
+     * and renderers apply to it like any cell value.
+     */
+    aggFunc?: OneAggFunc<T>;
+    /**
+     * Remove this column from the rendered grid without forgetting it.
+     *
+     * A hidden column keeps its place in the column order, its width and its
+     * pin, so showing it again restores it exactly. Toggle at runtime with
+     * `api.setColumnVisible(id, visible)`. Plain state, not a predicate —
+     * visibility is something a host changes, not something a row decides.
+     */
+    hide?: boolean;
     /** Distance in px from the pinned edge. Computed by the grid; do not set. */
     _pinnedOffset?: number | null;
     /** True on the innermost pinned column of each side, which carries the divider. */
@@ -180,7 +222,14 @@ export interface OneColumnDef<T = any> {
     updatable?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
     disable?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
     hideActionButton?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
-    /** @deprecated Not implemented — nothing in the grid reads this. */
+    /**
+     * Give this column an input in the grid's filter row (`[filterRow]`).
+     *
+     * Header-scoped like `sortable`: resolved once per column, when the
+     * columns are registered, against columnDef, field and context — there is
+     * no row. Without the filter row this changes nothing; filtering stays
+     * available through `api.setFilterModel` either way.
+     */
     filterable?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
     cellRendererComponent?: Type<OneCellRendererComponent>;
     cellRenderer?: (params: OneCellPresentationParams<T>) => string;
@@ -207,6 +256,32 @@ export interface OneColumnDef<T = any> {
     valueSetter?: (value: any, rowIndex: number) => void;
 }
 export type OneCellValidationType = 'disabled' | 'integer' | 'number' | 'code' | 'title' | 'phone' | 'email' | 'description' | 'regex' | 'none';
+/** The built-in aggregation functions for row grouping. */
+export type OneAggFuncName = 'sum' | 'min' | 'max' | 'avg' | 'count' | 'first' | 'last';
+/** What a custom aggregation function receives: one group's leaves. */
+export interface OneAggFuncParams<T = any> {
+    /** The leaf values of this column, nulls and undefineds already removed. */
+    values: any[];
+    /** The leaf rows themselves, for aggregates that need more than one field. */
+    rows: T[];
+    field: string;
+}
+export type OneAggFunc<T = any> = OneAggFuncName | ((params: OneAggFuncParams<T>) => any);
+/**
+ * One column's persistable layout state.
+ *
+ * `api.getColumnStateSnapshot()` returns one entry per column — hidden ones
+ * included — in display order; `api.applyColumnState(entries)` restores them.
+ * The snapshot is plain JSON-safe data, so it can be stored as-is.
+ */
+export interface OneColumnStateEntry {
+    id: string;
+    /** Omitted when the column has no explicit width. */
+    width?: number;
+    /** `null` means unpinned. Omitting the property keeps the current pin. */
+    pinned?: 'left' | 'right' | null;
+    hide?: boolean;
+}
 export interface CellSelection {
     rowId: string;
     field: string;

package/lib/core/models/one-event-types.model.d.ts

@@ -1,6 +1,7 @@
 import type { OneColumnDef, OneGroupColumnDef } from "./one-column-def-types.model";
 import type { OneGridApi } from "../instants/one-grid-api.class";
 import type { OneRowNode } from "../instants/one-row-node.class";
+import type { OneSortModel } from "./one-grid-types.model";
 export interface RowSelectedEvent {
     rowId: string;
     selected: boolean;
@@ -54,6 +55,23 @@ export interface CellOptionMenuSelectedEvent<T = any> {
 }
 export interface SortChangedEvent<T = any> {
     nodes: OneRowNode<T>[];
+    /** The model that produced this order. Empty when sorting was cleared. */
+    sortModel: readonly OneSortModel<T>[];
+}
+/**
+ * A cell edit was committed with a value different from the one it started
+ * with. Programmatic writes through `node.setDataValue` do not raise this —
+ * the caller already holds both values.
+ */
+export interface CellValueChangedEvent<T = any> {
+    node: OneRowNode<T>;
+    data: T;
+    column: OneColumnDef<T>;
+    field: string;
+    oldValue: any;
+    newValue: any;
+    /** Absent for a committed edit; set when undo/redo re-applied one. */
+    source?: 'undo' | 'redo';
 }
 export interface ColumnResizedEvent {
     columnId: string;
@@ -95,6 +113,7 @@ export interface EventPayloadMap<T = any> {
     sortChanged: SortChangedEvent<T>;
     rowOrderChanged: RowOrderChangedEvent<T>;
     cellStateChanged: CellStateChangedEvent<T>;
+    cellValueChanged: CellValueChangedEvent<T>;
 }
 export type OneCheckboxState = 'checked' | 'unchecked' | 'indeterminate';
 export type RowSelectionMode = 'single' | 'multiple' | null;

package/lib/core/models/one-filter.model.d.ts

@@ -8,8 +8,15 @@ export interface OneFilterModel {
 }
 /**
  * A single condition inside a filter.
+ *
+ * Comparison operators (`greaterThan`, `inRange`, …) compare numerically when
+ * both sides parse as numbers and lexicographically otherwise, which orders
+ * ISO date strings correctly. `blank` matches null, undefined and the empty
+ * string — not 0. Unknown operators are ignored rather than failing the row.
  */
 export interface OneFilterCondition {
-    operator: 'equals' | 'contains' | 'startsWith' | 'endsWith' | 'greaterThan' | 'lessThan';
+    operator: 'equals' | 'notEqual' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'inRange' | 'blank' | 'notBlank';
     value?: string | number;
+    /** Upper bound for `inRange`. Both bounds are inclusive. */
+    valueTo?: string | number;
 }

package/lib/core/pipes/aria-sort.pipe.d.ts

@@ -0,0 +1,15 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Maps the grid's sort state onto the values `aria-sort` accepts.
+ *
+ * The attribute takes `ascending` / `descending` / `none`, not the `asc` /
+ * `desc` the sort model uses. `none` is only correct on a column that *can* be
+ * sorted — on one that cannot, the attribute is omitted entirely, because
+ * "not sorted" and "not sortable" are different statements.
+ */
+export declare class AriaSortPipe implements PipeTransform {
+    transform(sort: 'asc' | 'desc' | null, sortable: boolean | undefined): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AriaSortPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AriaSortPipe, "ariaSort", true>;
+}

package/lib/core/pipes/cell-action-button-enable.pipe.d.ts

@@ -4,5 +4,5 @@ import * as i0 from "@angular/core";
 export declare class CellActionButtonEnablePipe<T> implements PipeTransform {
     transform(params: OneCellRendererParams<T> | null): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CellActionButtonEnablePipe<any>, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CellActionButtonEnablePipe<any>, "cellActionButtonEnable", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellActionButtonEnablePipe<any>, "cellActionButtonEnable", true>;
 }

package/lib/core/pipes/cell-editable.pipe.d.ts

@@ -5,5 +5,5 @@ import * as i0 from "@angular/core";
 export declare class CellEditablePipe implements PipeTransform {
     transform(cellStates: OneCellStates, column: OneColumnDef, node: OneRowNode, editable: (column: OneColumnDef, node: OneRowNode) => boolean, updatable: (column: OneColumnDef, node: OneRowNode) => boolean, allowedEdit: boolean): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CellEditablePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CellEditablePipe, "cellEditable", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellEditablePipe, "cellEditable", true>;
 }

package/lib/core/pipes/cell-invalid.pipe.d.ts

@@ -5,5 +5,5 @@ import * as i0 from "@angular/core";
 export declare class CellInvalidPipe<T> implements PipeTransform {
     transform(cellStates: OneCellStates, value: any, column: OneColumnDef<T>, node: OneRowNode<T>, allowedEdit: boolean, submitted: boolean): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CellInvalidPipe<any>, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CellInvalidPipe<any>, "cellInvalid", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellInvalidPipe<any>, "cellInvalid", true>;
 }

package/lib/core/pipes/cell-key.pipe.d.ts

@@ -3,5 +3,5 @@ import * as i0 from "@angular/core";
 export declare class CellKeyPipe implements PipeTransform {
     transform(rowId?: string | null, field?: string | null): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<CellKeyPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CellKeyPipe, "cellKey", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellKeyPipe, "cellKey", true>;
 }

package/lib/core/pipes/cell-level-padding.pipe.d.ts

@@ -3,5 +3,5 @@ import * as i0 from "@angular/core";
 export declare class CellLevelPaddingPipe implements PipeTransform {
     transform(level: number, factor: number): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<CellLevelPaddingPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CellLevelPaddingPipe, "cellLevelPadding", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellLevelPaddingPipe, "cellLevelPadding", true>;
 }

package/lib/core/pipes/cell-selected.pipe.d.ts

@@ -3,5 +3,5 @@ import * as i0 from "@angular/core";
 export declare class CellSelectedPipe implements PipeTransform {
     transform(selectedCells: Set<string>, rowId: string, field: string): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<CellSelectedPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CellSelectedPipe, "cellSelected", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellSelectedPipe, "cellSelected", true>;
 }

package/lib/core/pipes/cell-state-renderer.pipe.d.ts

@@ -4,5 +4,5 @@ import * as i0 from "@angular/core";
 export declare class CellStateRendererPipe implements PipeTransform {
     transform(cellStates: OneCellStates | null | undefined, field: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<CellStateRendererPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CellStateRendererPipe, "cellStateRenderer", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellStateRendererPipe, "cellStateRenderer", true>;
 }

package/lib/core/pipes/column-sort-state.pipe.d.ts

@@ -4,5 +4,5 @@ import * as i0 from "@angular/core";
 export declare class ColumnSortStatePipe implements PipeTransform {
     transform(field: string, sortModel: readonly OneSortModel[]): 'asc' | 'desc' | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<ColumnSortStatePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnSortStatePipe, "columnSortState", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ColumnSortStatePipe, "columnSortState", true>;
 }

package/lib/core/pipes/header-checkbox-checked.pipe.d.ts

@@ -5,5 +5,5 @@ import * as i0 from "@angular/core";
 export declare class HeaderCheckboxCheckedPipe implements PipeTransform {
     transform(rowNodes: OneRowNode[], selectionMode: RowSelectionMode, state: OneCheckboxState): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<HeaderCheckboxCheckedPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderCheckboxCheckedPipe, "headerCheckboxChecked", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderCheckboxCheckedPipe, "headerCheckboxChecked", true>;
 }

package/lib/core/pipes/header-checkbox-disabled.pipe.d.ts

@@ -5,5 +5,5 @@ import * as i0 from "@angular/core";
 export declare class HeaderCheckboxDisabledPipe implements PipeTransform {
     transform(rowNodes: OneRowNode[], selectionMode: RowSelectionMode, allowedEdit: boolean): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<HeaderCheckboxDisabledPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderCheckboxDisabledPipe, "headerCheckboxDisabled", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderCheckboxDisabledPipe, "headerCheckboxDisabled", true>;
 }

package/lib/core/pipes/header-checkbox-indeterminate.pipe.d.ts

@@ -5,5 +5,5 @@ import * as i0 from "@angular/core";
 export declare class HeaderCheckboxIndeterminatePipe implements PipeTransform {
     transform(rowNodes: OneRowNode[], selectionMode: RowSelectionMode, state: OneCheckboxState): unknown;
     static ɵfac: i0.ɵɵFactoryDeclaration<HeaderCheckboxIndeterminatePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderCheckboxIndeterminatePipe, "headerCheckboxIndeterminate", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HeaderCheckboxIndeterminatePipe, "headerCheckboxIndeterminate", true>;
 }

package/lib/core/services/og-column.service.d.ts

@@ -1,4 +1,4 @@
-import { OneCellPresentationParams, OneCellRendererParams, OneColumnDef, OneGroupColumnDef } from '../models/one-column-def-types.model';
+import { OneCellPresentationParams, OneCellRendererParams, OneColumnDef, OneColumnStateEntry, OneGroupColumnDef } from '../models/one-column-def-types.model';
 import { ColumnChangedEvent } from '../models/one-event-types.model';
 import * as i0 from "@angular/core";
 export declare class OgColumnService {
@@ -8,12 +8,27 @@ export declare class OgColumnService {
      * callbacks do. Set during init; null in a bare service.
      */
     private context;
+    /**
+     * Every column, hidden ones included, in display order. `columnDefs$` below
+     * carries only the visible subset — it is what the header and body render
+     * from, so hiding a column means leaving it out of the emission, and every
+     * consumer keeps working with no notion of visibility at all. This list is
+     * what remembers a hidden column's place, width and pin for when it returns.
+     */
+    private allColumnDefs;
     private columnDefs$;
     private groupColumnDefs$;
     initColumnDefs(defaultColumnDef: OneColumnDef, columnDefs: OneColumnDef[], groupColumnDefs: OneGroupColumnDef[], context?: unknown): void;
     getColumnState(): ColumnChangedEvent;
     setGroupColumnDefs(groupColumnDefs: OneGroupColumnDef[]): void;
     setColumnDefs(columnDefs: OneColumnDef[]): void;
+    /**
+     * Re-band, re-measure and publish a new column list.
+     *
+     * Every mutation funnels here so the master list and the visible emission
+     * cannot drift apart.
+     */
+    private commit;
     /**
      * Move pinned columns to their edge and measure how far in each one sits.
      *
@@ -26,10 +41,39 @@ export declare class OgColumnService {
      * grid that does not use the feature is unaffected.
      */
     private applyPinning;
-    /** Total width of the columns frozen against the given edge. */
+    /** Total width of the visible columns frozen against the given edge. */
     getPinnedWidth(side: 'left' | 'right'): number;
     updateColumnDef(id: string, changes: Partial<OneColumnDef>): void;
+    /**
+     * Reorder columns. The indexes are *visible* positions — they come from the
+     * header, which only renders visible columns — so they are mapped onto the
+     * master list before splicing. A hidden column between the two keeps its
+     * place relative to its neighbours.
+     */
     reorderColumnDefs(fromIndex: number, toIndex: number): void;
+    /**
+     * Distribute the viewport width left over by fixed columns among the flex
+     * ones, in proportion to their `flex` values and clamped to their bounds.
+     *
+     * @returns Whether any width actually changed — the caller only dispatches
+     * (and the body only re-triggers) on a real change, which is what terminates
+     * the columnChanged → flex → columnChanged loop.
+     */
+    applyFlexWidths(availableWidth: number): boolean;
+    /**
+     * One JSON-safe entry per column — hidden ones included — in display order.
+     */
+    getColumnStateSnapshot(): OneColumnStateEntry[];
+    /**
+     * Restore a saved snapshot: order, width, pin and visibility.
+     *
+     * Entries are applied in the order given and become the front of the new
+     * column order; columns the snapshot does not mention keep their current
+     * relative order behind them, and ids the grid no longer has are skipped —
+     * so a stale snapshot degrades to a partial restore instead of an error.
+     * Only the properties present on an entry are applied.
+     */
+    applyColumnState(entries: OneColumnStateEntry[]): void;
     /**
      * Group Header Columns
      */

package/lib/core/services/one-grid-cell.service.d.ts

@@ -3,9 +3,6 @@ import { OneRowNode } from '../instants/one-row-node.class';
 import type { OneGridApi } from '../instants/one-grid-api.class';
 import * as i0 from "@angular/core";
 export declare class OneGridCellService {
-    private _cellFieldValueEmpty;
-    private _cellValueGetter;
-    private _cellFieldValue;
     private _columnDefs;
     private _context;
     private _api;

package/lib/helpers/one-cell.helper.d.ts

@@ -24,3 +24,20 @@ export declare function resolveCellStyle(column: OneColumnDef, row: any): {
  * @returns
  */
 export declare function resolveCellClass(column: OneColumnDef, row: any): string | string[];
+/**
+ * The cell's raw field value, with blank treated as absent.
+ *
+ * Was `CellFieldValuePipe`. It lived as an Angular pipe but was only ever
+ * instantiated inside a service — a utility wearing a `@Pipe` decorator, which
+ * also cost it a module declaration for a template use that never existed.
+ */
+export declare function readCellValue<T>(data: T, field: string): string | null;
+/**
+ * Whether a cell has nothing to show.
+ *
+ * Was `CellFieldValueEmptyPipe`. `field` is optional on `OneColumnDef` — an
+ * action-only column legitimately has none — and reading it unguarded used to
+ * throw while the grid built cell state, taking the whole grid down. No field
+ * means nothing to read, which is empty by definition.
+ */
+export declare function isCellEmpty<T>(data: T, field: string): boolean;

package/lib/helpers/one-column-def.helper.d.ts

@@ -1,4 +1,5 @@
 import { OneCellRendererParams, OneColumnDef, OneValueGetterParams } from "../core/models/one-column-def-types.model";
+import type { OneRowNode } from "../core/instants/one-row-node.class";
 /** Width used when a column defines neither `width` nor `minWidth`. */
 export declare const ONE_DEFAULT_COLUMN_WIDTH = 150;
 /**
@@ -33,3 +34,11 @@ export declare function resolveOneColumDefParams<R>(prop: R | ((params: any) =>
  * One Column Params Resolver (Value Getter)
  */
 export declare function resolveOneValueGetterParams<T, R>(prop: R | ((params: OneValueGetterParams<T>) => R), params: OneValueGetterParams<T>): R;
+/**
+ * Run a column's `valueGetter` for one row.
+ *
+ * Was `CellValueGetterPipe`, which existed only to call this resolver from a
+ * service. The pipe added a module declaration and an indirection for a
+ * template use that never existed.
+ */
+export declare function resolveCellValueGetter<T>(data: T, node: OneRowNode, column: OneColumnDef, context: unknown): string;

package/lib/helpers/one-csv.helper.d.ts

@@ -0,0 +1,29 @@
+import type { OneRowNode } from "../core/instants/one-row-node.class";
+import type { OneColumnDef } from "../core/models/one-column-def-types.model";
+/** Options for `api.getDataAsCsv` / `api.exportDataAsCsv`. */
+export interface OneCsvExportOptions {
+    /** Field separator. Defaults to ','. */
+    columnSeparator?: string;
+    /** Whether the first line carries the header names. Defaults to true. */
+    includeHeaders?: boolean;
+    /** Export only the selected rows instead of every visible one. */
+    onlySelected?: boolean;
+    /** Download name for `exportDataAsCsv`. Defaults to 'export.csv'. */
+    fileName?: string;
+}
+/**
+ * The columns an export can say anything about: those that read a row —
+ * through a field or a valueGetter. Action columns have neither, and the
+ * row-number column reads state the data does not hold; both are skipped.
+ */
+export declare function exportableColumns<T>(columns: OneColumnDef<T>[]): OneColumnDef<T>[];
+/**
+ * Serialize rows to RFC 4180 CSV.
+ *
+ * Each cell goes through the same value pipeline the grid renders with:
+ * `valueGetter` when declared, the field otherwise, then `valueFormatter` —
+ * so the file says what the screen says. Null and undefined export as empty
+ * cells, before the formatter, exactly as the grid leaves them to the
+ * placeholder.
+ */
+export declare function buildCsv<T>(nodes: readonly OneRowNode<T>[], columns: OneColumnDef<T>[], context?: any, options?: OneCsvExportOptions): string;