@inandu-solutions/grid-vue 0.0.0-stage → 0.2.0

package/dist/composables/useInanduGrid.d.ts

@@ -0,0 +1,260 @@
+import { MaybeRefOrGetter, VNodeChild } from 'vue';
+import { InanduColumnAggregate, InanduColumnStickySide, InanduColumnType, InanduGridColumnFilterValue, InanduGridRow, TreeVisibleRow } from '../core';
+/**
+ * Plain-value column definition for the Vue API — friendlier than the core's `ColumnConfig`
+ * getter shape (`field()`, `type()`, ...), which exists to match grid-angular's signal-based
+ * columns. `toColumnConfig` below adapts one to the other so the ported core needs no changes.
+ */
+export interface InanduGridColumn {
+    field: string;
+    headerText?: string;
+    type?: InanduColumnType;
+    format?: string;
+    order?: number;
+    aggregate?: InanduColumnAggregate;
+    /** Whether this column can be picked in the "group by" control. Default: true. */
+    groupable?: boolean;
+    /** Whether this field shows an editable control while its row is in edit/add mode. Default: false. */
+    editable?: boolean;
+    required?: boolean;
+    /** `'number'` columns only. */
+    min?: number;
+    /** `'number'` columns only. */
+    max?: number;
+    /** Checked against the raw (unparsed) draft value, `'string'`/`'number'`/`'date'` columns only. */
+    pattern?: string;
+    /** Runs after required/min/max/pattern all pass, against the parsed value and the row's other parsed fields (for cross-field checks). */
+    validator?: (parsed: unknown, parsedRow: Record<string, unknown>) => string | null;
+    /** Runs only once every synchronous rule (above) has already passed for this field; every field's async check runs concurrently. */
+    asyncValidator?: (parsed: unknown, parsedRow: Record<string, unknown>) => Promise<string | null>;
+    /** Whether this column can be hidden via the column-visibility toggle. Default: true. */
+    hideable?: boolean;
+    /** Pins the column to that side of the table, `position: sticky`, regardless of scroll. Unset: not pinned. */
+    pinned?: InanduColumnStickySide;
+    /** Fixed column width in px — also what `stickyOffset`/`stickyOffsetRight` stack against. Default (unset): 80, same fallback grid-angular's `effectiveWidth() || 80` uses. */
+    width?: number;
+    /** Whether this column's header can be dragged to reorder columns. Default: true. */
+    reorder?: boolean;
+    /**
+     * Custom rendering for this column's cells, in place of the built-in formatted text — a render
+     * function returning VNodes (use `h()`). The `#cell-<field>` scoped slot on `<InanduGrid>` does the
+     * same thing template-side and wins when both are set. Doesn't affect editing — pair with
+     * `renderEditor` (or `#editor-<field>`) if this column is also `editable`.
+     */
+    renderCell?: (ctx: InanduCellRenderContext) => VNodeChild;
+    /** Custom rendering for this column's header label (or the `#header-<field>` slot). The sort arrow, multi-sort priority badge, and resize handle next to it are unaffected — same scope as grid-angular's `#inanduHeaderTemplate`. */
+    renderHeader?: (ctx: InanduHeaderRenderContext) => VNodeChild;
+    /** Custom editor for this column's cells while their row is in edit/create mode (or the `#editor-<field>` slot), in place of the built-in type-aware `<input>`/`<select>`. The column must still be `editable`; save-time parsing/validation is unaffected — call `setValue` with the same raw control shape the built-in control would produce (a string for `'string'`/`'number'`/`'date'`, a boolean for `'boolean'`). */
+    renderEditor?: (ctx: InanduEditRenderContext) => VNodeChild;
+}
+/** Passed to a column's `renderCell` / `#cell-<field>` slot — the same information the built-in formatted-text cell would use. */
+export interface InanduCellRenderContext {
+    value: unknown;
+    row: InanduGridRow;
+    field: string;
+}
+/** Passed to a column's `renderHeader` / `#header-<field>` slot. `title` is the resolved display label (`headerText` if set, else `field` — the same fallback the built-in plain-text header uses). */
+export interface InanduHeaderRenderContext {
+    title: string;
+    field: string;
+}
+/** Passed to a column's `renderEditor` / `#editor-<field>` slot. `row` is `{}` for the add-new-row draft. */
+export interface InanduEditRenderContext {
+    value: unknown;
+    row: InanduGridRow;
+    field: string;
+    setValue: (value: unknown) => void;
+    error: string | undefined;
+}
+/** Passed to `onRowSave` — everything `saveRow()` parsed and validated for one already-existing row. */
+export interface InanduGridRowSave {
+    row: InanduGridRow;
+    values: Record<string, unknown>;
+}
+/** One cell update from a `pasteAt()` call — one entry per pasted cell that landed on an existing row and an editable column. */
+export interface InanduGridCellPaste {
+    row: InanduGridRow;
+    field: string;
+    value: unknown;
+}
+/**
+ * What `onQueryChange` emits in `serverSide` mode: the grid's whole request state, ready for
+ * `useInanduGridServer` (or a hand-rolled fetch) to turn into a query string. `page` is 0-based,
+ * like the composable's own `page`.
+ */
+export interface InanduGridServerQuery {
+    page: number;
+    pageSize: number;
+    sortCriteria: InanduGridSort[];
+    filterValues: Record<string, InanduGridColumnFilterValue>;
+    filterQuery: string;
+}
+export interface InanduGridSort {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+/** One bucket of `useInanduGrid`'s `groups` — mirrors grid-angular's `groupedRows`. */
+export interface InanduGridGroup {
+    /** The grouped column's *formatted* display value for every row in this bucket. */
+    key: string;
+    rows: InanduGridRow[];
+    /** One entry per column with `aggregate` set, keyed by that column's field. */
+    aggregates: Record<string, number>;
+}
+export interface UseInanduGridOptions {
+    rows: InanduGridRow[];
+    columns: InanduGridColumn[];
+    locale?: string;
+    /** Drives validation-message translation. Default: `locale`'s primary subtag. */
+    lang?: string;
+    /** 0 disables pagination — `visibleRows` is the full sorted/filtered set. Default: 0. */
+    pageSize?: number;
+    /** Whether the caller renders a select-checkbox column — `stickyOffset()` needs to know, since that column (when present) is always sticky-left too. Default: false. */
+    selectable?: boolean;
+    /** `window.confirm()`-gates `deleteRow()`, same as grid-angular. Unset: deletes immediately. */
+    deleteConfirmMessage?: string;
+    /** `window.confirm()`-gates `deleteSelectedRows()`. Unset: deletes immediately. */
+    bulkDeleteConfirmMessage?: string;
+    /** Called by `saveRow()` once validation passes — the grid never mutates `rows` itself; applying the change is the caller's job. */
+    onRowSave?: (event: InanduGridRowSave) => void;
+    /** Called by `saveNewRow()` once validation passes. No row reference — it doesn't exist in `rows` yet. */
+    onRowCreate?: (values: Record<string, unknown>) => void;
+    /** Called by `deleteRow()` (after confirmation, if any). */
+    onRowDelete?: (row: InanduGridRow) => void;
+    /** Called by `deleteSelectedRows()` (after confirmation, if any) — every currently-selected row. */
+    onRowsDelete?: (rows: InanduGridRow[]) => void;
+    /** Called by `pasteAt()` with every parsed cell update — the grid never mutates `rows` itself. */
+    onCellsPaste?: (updates: InanduGridCellPaste[]) => void;
+    /** Called by `onRowDrop()` with the fully reordered row array — the grid never mutates `rows` itself. */
+    onRowOrderChange?: (rows: InanduGridRow[]) => void;
+    /**
+     * Turns on tree mode: the name of the field on each row holding its child rows (a nested array
+     * of the same shape). `rows` is then the root rows; free-text/column filters keep a node when it
+     * or any descendant matches, and the active sort orders each level of siblings. Auto-disabled
+     * while grouped, same restriction grid-angular's `treeChildrenKey` has (there it also excludes
+     * virtual-scroll/server-side, neither of which this port has). Unset (default): tree mode off.
+     */
+    treeChildrenKey?: string;
+    /** Initial expand state for tree mode: `'none'` (default), `'all'`, or a max depth to open to. */
+    treeDefaultExpanded?: 'none' | 'all' | number;
+    /** Whether master-detail is on — the caller checks this itself, this only controls `toggleRowExpanded`'s accordion behavior. Off (any number of rows can be expanded at once) by default. */
+    singleDetailExpand?: boolean;
+    /**
+     * Opt-in row virtualization for large datasets — bypasses pagination entirely (same as grouping),
+     * feeding the windowing logic the full sorted/filtered set instead. Auto-disables grouping,
+     * master-detail, tree data, row drag-reorder and clipboard, same restrictions grid-angular's
+     * `virtualScroll` has (there it also covers server-side infinite-scroll, which this port doesn't
+     * have). The actual DOM windowing (which rows are mounted, given a real scroll position) is the
+     * `<InanduGrid>` component's job, not this composable's — it has no way to observe scroll state itself.
+     */
+    virtualScroll?: boolean;
+    /** An extra per-row predicate ANDed onto the free-text + column filters — same as grid-angular's `extraRowFilter`. Lets a caller layer its own filtering (e.g. an advanced-filter query) on top of the grid's own. Unset: no extra filtering. */
+    extraRowFilter?: (row: InanduGridRow) => boolean;
+    /**
+     * Server-side mode: `rows` is already the current page, as sorted/filtered/paged by the server
+     * (see `useInanduGridServer`). The composable keeps owning the sort / filter / search / page
+     * *state* so `<InanduGrid>`'s controls work unchanged, but stops applying it to `rows` and reads
+     * the page count from `totalItems`. Grouping, tree data, virtual scroll, `extraRowFilter` and
+     * column-aggregate totals are not available (they would only see one page). Unset: client-side.
+     */
+    serverSide?: {
+        totalItems: number;
+    };
+    /** `serverSide` only: called once on setup and again whenever page, sort, filters or search change. */
+    onQueryChange?: (query: InanduGridServerQuery) => void;
+}
+/**
+ * Headless engine for the grid: owns sort + per-column filter + pagination state and derives
+ * `visibleRows` (the current page) and `filteredRowCount` (before pagination) from `rows` using
+ * the same pure core as grid-angular. No rendering — `<InanduGrid>` is one consumer of this
+ * composable, not the only way to use it.
+ *
+ * `options` may be a plain object, a ref, or a getter — pass a getter (`() => ({ rows: rows.value,
+ * columns })`) to have the grid follow reactive data. The returned object exposes every piece of
+ * state as a reactive *getter* (read `grid.visibleRows`, not `grid.visibleRows.value`), so reading
+ * it inside a template, `computed` or `watch` tracks it. Don't destructure state properties out of
+ * it — that snapshots their current value; the methods are safe to destructure.
+ */
+export declare function useInanduGrid(options: MaybeRefOrGetter<UseInanduGridOptions>): {
+    readonly visibleColumns: InanduGridColumn[];
+    /** Every column in current drag-reorder order, hidden ones included — same as grid-angular's `displayColumns()`. Most rendering should use `visibleColumns` instead; this is for callers (like a saved-view restore) that need to address a currently-hidden column too. */
+    readonly allColumns: InanduGridColumn[];
+    stickyOffset: (field: string) => number;
+    stickyOffsetRight: (field: string) => number;
+    columnPinnedSide: (field: string) => InanduColumnStickySide | undefined;
+    setColumnPinned: (field: string, side: InanduColumnStickySide | undefined) => void;
+    readonly hideableColumns: InanduGridColumn[];
+    isColumnHidden: (field: string) => boolean;
+    toggleColumnVisibility: (field: string) => void;
+    setColumnOrder: (fields: readonly string[]) => void;
+    readonly draggingField: string | undefined;
+    onColumnDragStart: (field: string) => void;
+    onColumnDrop: (targetField: string) => void;
+    effectiveWidth: (field: string) => number;
+    isColumnResized: (field: string) => boolean;
+    setColumnWidth: (field: string, width: number) => void;
+    readonly draggingRow: InanduGridRow | undefined;
+    onRowDragStart: (row: InanduGridRow) => void;
+    onRowDrop: (targetRow: InanduGridRow) => void;
+    readonly hasTreeData: boolean;
+    readonly treeRows: TreeVisibleRow<InanduGridRow>[];
+    isTreeRowExpanded: (row: InanduGridRow) => boolean;
+    toggleTreeRow: (row: InanduGridRow) => void;
+    setAllTreeRowsExpanded: (expanded: boolean) => void;
+    isRowExpanded: (row: InanduGridRow) => boolean;
+    toggleRowExpanded: (row: InanduGridRow) => void;
+    readonly hasVirtualScroll: boolean;
+    readonly visibleRows: InanduGridRow[];
+    /** Same "what's on screen right now" set the select-all checkbox and CSV/Excel/PDF export use — the current page, or every group's rows while grouped. */
+    readonly exportRows: InanduGridRow[];
+    /** Every row matching the current filter and sort, in sort order, regardless of pagination or grouping — same as grid-angular's `sortedData()`. Unlike `exportRows`, this never stops at one page: a full-dataset export/print reads from here instead. */
+    readonly sortedRows: InanduGridRow[];
+    readonly filteredRowCount: number;
+    readonly locale: string;
+    readonly sortCriteria: InanduGridSort[];
+    setSort: (criteria: InanduGridSort[]) => void;
+    toggleSort: (field: string, additive?: boolean) => void;
+    sortDirectionFor: (field: string) => "asc" | "desc" | undefined;
+    sortPriorityFor: (field: string) => number | undefined;
+    readonly filterValues: Record<string, InanduGridColumnFilterValue>;
+    setFilterValue: (field: string, value: InanduGridColumnFilterValue) => void;
+    clearAllFilters: () => void;
+    readonly filterQuery: string;
+    setFilterQuery: (query: string) => void;
+    readonly page: number;
+    setPage: (next: number) => void;
+    readonly pageCount: number;
+    readonly groupByField: string | undefined;
+    setGroupByField: (field: string | undefined) => void;
+    readonly groups: InanduGridGroup[] | null;
+    readonly totals: Record<string, number>;
+    readonly selectedRows: Set<InanduGridRow>;
+    isRowSelected: (row: InanduGridRow) => boolean;
+    toggleRowSelection: (row: InanduGridRow) => void;
+    readonly allSelected: boolean;
+    readonly someSelected: boolean;
+    toggleSelectAll: () => void;
+    clearSelection: () => void;
+    readonly editableColumns: InanduGridColumn[];
+    readonly editingRow: InanduGridRow | undefined;
+    readonly isAddingRow: boolean;
+    readonly rowDraft: Record<string, unknown>;
+    readonly fieldErrors: Record<string, string>;
+    readonly isValidating: boolean;
+    isEditingRow: (row: InanduGridRow) => boolean;
+    isAnotherRowEditing: (row: InanduGridRow) => boolean;
+    startEditingRow: (row: InanduGridRow) => void;
+    cancelRowEdit: () => void;
+    setRowDraftValue: (field: string, value: unknown) => void;
+    saveRow: (row: InanduGridRow) => Promise<void>;
+    deleteRow: (row: InanduGridRow) => void;
+    deleteSelectedRows: () => void;
+    startAddingRow: () => void;
+    cancelAddRow: () => void;
+    saveNewRow: () => Promise<void>;
+    validateCell: (column: InanduGridColumn, value: unknown, row?: Record<string, unknown>) => string | null;
+    copyCellText: (rowIndex: number, field: string) => string;
+    pasteAt: (anchorRowIndex: number, anchorField: string, text: string) => void;
+};
+/** What `useInanduGrid()` returns — also what `<InanduGrid>` exposes as its `grid` template-ref property. */
+export type InanduGridApi = ReturnType<typeof useInanduGrid>;

package/dist/composables/useInanduGridServer.d.ts

@@ -0,0 +1,53 @@
+import { ShallowRef } from 'vue';
+import { InanduGridRow } from '../core';
+import { InanduGridServerQuery } from './useInanduGrid';
+export interface InanduGridQueryOptions {
+    /** Extra params appended after the grid's own (a tenant id, a fixed filter, ...). */
+    extraParams?: Record<string, string>;
+}
+/**
+ * Turns the grid's request state into the query string `Inandu.Grid.Extensions` (the .NET package)
+ * parses — the contract is documented at
+ * https://github.com/inandusolutions/inandu-grid-extensions/blob/main/docs/request-contract.md.
+ *
+ * Param order is deterministic (page, pageSize, sort, q, then column filters in field order) so the
+ * result can be compared as a plain string.
+ */
+export declare function buildInanduGridQuery(query: InanduGridServerQuery, options?: InanduGridQueryOptions): URLSearchParams;
+export interface InanduGridServerOptions extends InanduGridQueryOptions {
+    /** The endpoint, e.g. `/api/products`. The grid's params are appended as a query string. */
+    url: string;
+    /** Passed to `fetch` (auth headers, `credentials`, ...). */
+    init?: RequestInit;
+    /** Replaces `fetch` — handy for tests or a typed API client. Must honour `signal`. */
+    fetcher?: (url: string, init: RequestInit) => Promise<Response>;
+    /** Wait this long after the last change before requesting (typing in the search box). The first request is never delayed. Default: 200. */
+    debounceMs?: number;
+}
+export interface InanduGridServerResult {
+    /** The current page. The previous page stays here while the next one loads, so the table doesn't flash empty. */
+    rows: ShallowRef<InanduGridRow[]>;
+    /** Total rows matching the filters, across all pages. Also kept during a reload. */
+    total: ShallowRef<number>;
+    loading: ShallowRef<boolean>;
+    error: ShallowRef<Error | undefined>;
+    /** Wire this to `<InanduGrid @query-change>` / `useInanduGrid`'s `onQueryChange`. */
+    setQuery: (query: InanduGridServerQuery) => void;
+    /** Re-issues the last request (after an edit, say). */
+    reload: () => void;
+}
+/**
+ * Data layer for `serverSide` mode. Pair it with the grid:
+ *
+ * ```vue
+ * <script setup>
+ * const server = useInanduGridServer({ url: '/api/products' });
+ * </script>
+ * <InanduGrid :rows="server.rows.value" :columns="columns" :page-size="25"
+ *   :server-side="{ totalItems: server.total.value }" @query-change="server.setQuery" />
+ * ```
+ *
+ * Expects the `Inandu.Grid.Extensions` response shape, `{ data: [...], total: n }`. A request that
+ * is superseded by a newer one is aborted, and a late response from it is ignored.
+ */
+export declare function useInanduGridServer(options: InanduGridServerOptions): InanduGridServerResult;

package/dist/core/aggregate.d.ts

@@ -0,0 +1,5 @@
+import { ColumnConfig, InanduColumnAggregate, InanduGridRow } from './types';
+/** Short, language-agnostic symbol shown for each `InanduColumnAggregate` kind — deliberately not translated (the same way units like "CSV"/"PDF" aren't). */
+export declare const AGGREGATE_SYMBOLS: Record<Exclude<InanduColumnAggregate, ''>, string>;
+/** One numeric aggregate per `aggregateColumns` entry, computed over `rows` — `'count'` just counts rows (works for any column type); the rest ignore rows whose raw value isn't a finite number. */
+export declare function computeGroupAggregates(rows: InanduGridRow[], aggregateColumns: readonly ColumnConfig[]): Record<string, number>;

package/dist/core/columns.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Columns with an explicit `order` land at that 0-based slot; columns without one
+ * fill the remaining slots in declaration order. Equal/out-of-range `order` values
+ * degrade gracefully by falling back to declaration order among themselves.
+ *
+ * Generic over the column type: works for `InanduColumnComponent` instances or any object with
+ * an `order()` accessor.
+ */
+export declare function placeColumnsByOrder<C extends {
+    order(): number | undefined;
+}>(columns: readonly C[]): C[];

package/dist/core/constants.d.ts

@@ -0,0 +1,14 @@
+/** Floor enforced while dragging a resize handle, so a column can never be shrunk to zero/negative width. */
+export declare const MIN_COLUMN_WIDTH = 30;
+/** Ceiling `autosize` (double-click a resize handle to fit content) will grow a column to, so one
+ *  very long value can't blow the column out to the width of the page. The drag handle itself is
+ *  not capped by this. */
+export declare const MAX_COLUMN_WIDTH = 600;
+/** Must match `.inandu-select-column`'s CSS width — used by `stickyOffset()` to account for the (always-sticky) checkbox column. */
+export declare const SELECT_COLUMN_WIDTH = 36;
+/** Must match `.inandu-row-drag-column`'s CSS width — used by `stickyOffset()` to account for the (always-leading, when enabled) drag-handle column. */
+export declare const ROW_DRAG_COLUMN_WIDTH = 32;
+/** Must match `.inandu-detail-toggle-column`'s CSS width — used by `stickyOffset()` to account for the (always-leading-most, when enabled) master-detail expand/collapse column. */
+export declare const DETAIL_TOGGLE_COLUMN_WIDTH = 32;
+/** `localStorage` key prefix for `stateKey`-based persistence, so this library's own saved blobs don't collide with anything else a host app stores. */
+export declare const STATE_STORAGE_PREFIX = "inandu-grid-state:";

package/dist/core/dom.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Escapes `value` for use inside a double-quoted CSS attribute-selector value (e.g.
+ * `` `td[data-field="${escaped}"]` ``), for the rare runtime with no native `CSS.escape`. Backslashes
+ * MUST be escaped before quotes — escaping only quotes lets a value containing a backslash (e.g.
+ * `a\"b`) smuggle an unescaped quote through (`\"` in the output reads back as an escaped backslash
+ * followed by a bare, string-terminating `"`), letting the selector break out of the attribute value.
+ */
+export declare function escapeAttributeSelectorValue(value: string): string;

package/dist/core/export/csv.d.ts

@@ -0,0 +1,2 @@
+/** Quotes `value` for a CSV cell (doubling internal quotes) only if it contains a comma, quote, or newline. */
+export declare function escapeCsvValue(value: string): string;

package/dist/core/export/download.d.ts

@@ -0,0 +1,2 @@
+/** Triggers a browser download of `content` as `filename`, via a throwaway object URL + `<a>` click. */
+export declare function downloadBlob(content: string | Blob, filename: string, mimeType?: string): void;

package/dist/core/export/markup.d.ts

@@ -0,0 +1,2 @@
+/** Escapes `&`/`</>` for safe use as XML/HTML element text content — shared by `exportExcel()` and `printTable()`. */
+export declare function escapeMarkup(value: string): string;

package/dist/core/export/pdf.d.ts

@@ -0,0 +1,3 @@
+import { jsPDF } from 'jspdf';
+/** Shortens `text` with a trailing "…" until it fits `maxWidth` (in the PDF's current font), unchanged if it already fits. */
+export declare function truncatePdfText(doc: jsPDF, text: string, maxWidth: number): string;

package/dist/core/filter.d.ts

@@ -0,0 +1,26 @@
+import { ColumnConfig, InanduGridColumnFilterValue, InanduGridRow } from './types';
+import { NumberFormatter } from './format';
+/**
+ * Whether `value` has at least one non-empty key — an entry can exist (e.g. after typing then
+ * clearing) without actually narrowing anything. `values` is the one exception: unlike every other
+ * key, an *empty* array is still meaningful (see `matchesColumnFilter`) — the presence of the key
+ * at all is what counts, not its length. Only an entirely absent/`undefined` `values` reads as "no
+ * set-filter constraint".
+ */
+export declare function hasMeaningfulFilterValue(value: InanduGridColumnFilterValue | undefined): boolean;
+/**
+ * Whether `row` satisfies `column`'s own filter control. An empty/absent `filterValue` (no
+ * constraint entered for this column yet) always matches. Range checks (`'number'`/`'date'`) are
+ * inclusive on both ends; a cell that can't be parsed as that column's type never matches once at
+ * least one bound is set.
+ *
+ * `filterValue.values` (the set filter) is the one key that's *present-vs-absent*, not
+ * *non-empty-vs-empty*: an `undefined` `values` falls through to the type-specific checks below,
+ * same as omitting it; a *defined* `values` — even `[]` — takes over matching for the column
+ * entirely, checked against the formatted display value. This is deliberate: `[]` is how "every
+ * checkbox is unchecked" (match nothing) is told apart from "the set filter was never touched"
+ * (match everything, i.e. don't constrain) — collapsing them to the same "no constraint" meaning,
+ * like every other filter key's blank state does, would make unchecking every box a no-op instead
+ * of the empty result a consumer building a set-filter checklist actually needs.
+ */
+export declare function matchesColumnFilter(column: ColumnConfig, row: InanduGridRow, filterValue: InanduGridColumnFilterValue, locale: string, numberFormatter?: NumberFormatter): boolean;

package/dist/core/format.d.ts

@@ -0,0 +1,24 @@
+import { InanduColumnType } from './types';
+/**
+ * Turns a raw numeric value into its display string. `digitsInfo` is a `DecimalPipe`-style
+ * `'{minInt}.{minFrac}-{maxFrac}'` string (e.g. `"1.2-2"`), or empty for the default.
+ *
+ * Injected into `formatCellValue()` so the framework layer can choose the implementation: the
+ * Angular component passes one backed by `@angular/common`'s `formatNumber` (honouring whatever
+ * locale data the host app registered), keeping its output byte-identical to before this folder
+ * existed. `defaultNumberFormatter` below is the standalone fallback for a non-Angular consumer.
+ */
+export type NumberFormatter = (value: number, locale: string, digitsInfo?: string) => string;
+/** `Intl.NumberFormat`-based `NumberFormatter`. Parses the `digitsInfo` mini-syntax; falls back to Angular's own default of up to 3 fraction digits (`'1.0-3'`) when it's absent. */
+export declare function defaultNumberFormatter(value: number, locale: string, digitsInfo?: string): string;
+/**
+ * Coerces a raw cell value to a `Date` for `type="date"` columns — accepts a `Date`, a timestamp,
+ * or a string. Safari's `Date` string parser is stricter than Chrome's; notably it returns an
+ * Invalid Date for a space-separated `"yyyy-mm-dd hh:mm[:ss]"` that Chrome happily parses. That one
+ * common case is normalised to the ISO `T` form before parsing, so a `type="date"` column renders
+ * and filters identically in both. Anything still unparseable comes back as an Invalid Date — every
+ * caller already guards with `Number.isNaN(date.getTime())`.
+ */
+export declare function coerceToDate(value: unknown): Date;
+export declare function formatDateValue(date: Date, format: string): string;
+export declare function formatCellValue(value: unknown, type: InanduColumnType, format: string, locale: string, numberFormatter?: NumberFormatter): string;

package/dist/core/i18n/en.d.ts

@@ -0,0 +1,46 @@
+export declare const en: {
+    MsgNoData: string;
+    MsgFirstPage: string;
+    MsgPreviousPage: string;
+    MsgNextPage: string;
+    MsgLastPage: string;
+    MsgSortBy: string;
+    MsgPageOf: string;
+    MsgFilterPlaceholder: string;
+    MsgFilterColumn: string;
+    MsgFilterMin: string;
+    MsgFilterMax: string;
+    MsgFilterFrom: string;
+    MsgFilterTo: string;
+    MsgAll: string;
+    MsgCancelFilter: string;
+    MsgCancelAllFilters: string;
+    MsgGroupByHint: string;
+    MsgGroupedBy: string;
+    MsgGroupHeader: string;
+    MsgCancelGrouping: string;
+    MsgSelectAll: string;
+    MsgSelectRow: string;
+    MsgExportCsv: string;
+    MsgExportExcel: string;
+    MsgExportPdf: string;
+    MsgPrint: string;
+    MsgToggleColumns: string;
+    MsgToggleColumn: string;
+    MsgEditCell: string;
+    MsgEditRow: string;
+    MsgSaveRow: string;
+    MsgCancelRowEdit: string;
+    MsgDeleteRow: string;
+    MsgAddRow: string;
+    MsgLoading: string;
+    MsgDragRow: string;
+    MsgAutosizeColumn: string;
+    MsgExpandDetail: string;
+    MsgCollapseDetail: string;
+    MsgDeleteSelected: string;
+    MsgValidationRequired: string;
+    MsgValidationMin: string;
+    MsgValidationMax: string;
+    MsgValidationPattern: string;
+};

package/dist/core/i18n/es.d.ts

@@ -0,0 +1,46 @@
+export declare const es: {
+    MsgNoData: string;
+    MsgFirstPage: string;
+    MsgPreviousPage: string;
+    MsgNextPage: string;
+    MsgLastPage: string;
+    MsgSortBy: string;
+    MsgPageOf: string;
+    MsgFilterPlaceholder: string;
+    MsgFilterColumn: string;
+    MsgFilterMin: string;
+    MsgFilterMax: string;
+    MsgFilterFrom: string;
+    MsgFilterTo: string;
+    MsgAll: string;
+    MsgCancelFilter: string;
+    MsgCancelAllFilters: string;
+    MsgGroupByHint: string;
+    MsgGroupedBy: string;
+    MsgGroupHeader: string;
+    MsgCancelGrouping: string;
+    MsgSelectAll: string;
+    MsgSelectRow: string;
+    MsgExportCsv: string;
+    MsgExportExcel: string;
+    MsgExportPdf: string;
+    MsgPrint: string;
+    MsgToggleColumns: string;
+    MsgToggleColumn: string;
+    MsgEditCell: string;
+    MsgEditRow: string;
+    MsgSaveRow: string;
+    MsgCancelRowEdit: string;
+    MsgDeleteRow: string;
+    MsgAddRow: string;
+    MsgLoading: string;
+    MsgDragRow: string;
+    MsgAutosizeColumn: string;
+    MsgExpandDetail: string;
+    MsgCollapseDetail: string;
+    MsgDeleteSelected: string;
+    MsgValidationRequired: string;
+    MsgValidationMin: string;
+    MsgValidationMax: string;
+    MsgValidationPattern: string;
+};

package/dist/core/i18n/fr.d.ts

@@ -0,0 +1,46 @@
+export declare const fr: {
+    MsgNoData: string;
+    MsgFirstPage: string;
+    MsgPreviousPage: string;
+    MsgNextPage: string;
+    MsgLastPage: string;
+    MsgSortBy: string;
+    MsgPageOf: string;
+    MsgFilterPlaceholder: string;
+    MsgFilterColumn: string;
+    MsgFilterMin: string;
+    MsgFilterMax: string;
+    MsgFilterFrom: string;
+    MsgFilterTo: string;
+    MsgAll: string;
+    MsgCancelFilter: string;
+    MsgCancelAllFilters: string;
+    MsgGroupByHint: string;
+    MsgGroupedBy: string;
+    MsgGroupHeader: string;
+    MsgCancelGrouping: string;
+    MsgSelectAll: string;
+    MsgSelectRow: string;
+    MsgExportCsv: string;
+    MsgExportExcel: string;
+    MsgExportPdf: string;
+    MsgPrint: string;
+    MsgToggleColumns: string;
+    MsgToggleColumn: string;
+    MsgEditCell: string;
+    MsgEditRow: string;
+    MsgSaveRow: string;
+    MsgCancelRowEdit: string;
+    MsgDeleteRow: string;
+    MsgAddRow: string;
+    MsgLoading: string;
+    MsgDragRow: string;
+    MsgAutosizeColumn: string;
+    MsgExpandDetail: string;
+    MsgCollapseDetail: string;
+    MsgDeleteSelected: string;
+    MsgValidationRequired: string;
+    MsgValidationMin: string;
+    MsgValidationMax: string;
+    MsgValidationPattern: string;
+};

package/dist/core/i18n/index.d.ts

@@ -0,0 +1,8 @@
+import { en } from './en';
+import { es } from './es';
+import { fr } from './fr';
+import { it } from './it';
+import { zh } from './zh';
+export { en, es, fr, it, zh };
+/** Every built-in dictionary, keyed by primary language subtag. */
+export declare const INANDU_GRID_TRANSLATIONS: Record<string, Record<string, string>>;

package/dist/core/i18n/it.d.ts

@@ -0,0 +1,46 @@
+export declare const it: {
+    MsgNoData: string;
+    MsgFirstPage: string;
+    MsgPreviousPage: string;
+    MsgNextPage: string;
+    MsgLastPage: string;
+    MsgSortBy: string;
+    MsgPageOf: string;
+    MsgFilterPlaceholder: string;
+    MsgFilterColumn: string;
+    MsgFilterMin: string;
+    MsgFilterMax: string;
+    MsgFilterFrom: string;
+    MsgFilterTo: string;
+    MsgAll: string;
+    MsgCancelFilter: string;
+    MsgCancelAllFilters: string;
+    MsgGroupByHint: string;
+    MsgGroupedBy: string;
+    MsgGroupHeader: string;
+    MsgCancelGrouping: string;
+    MsgSelectAll: string;
+    MsgSelectRow: string;
+    MsgExportCsv: string;
+    MsgExportExcel: string;
+    MsgExportPdf: string;
+    MsgPrint: string;
+    MsgToggleColumns: string;
+    MsgToggleColumn: string;
+    MsgEditCell: string;
+    MsgEditRow: string;
+    MsgSaveRow: string;
+    MsgCancelRowEdit: string;
+    MsgDeleteRow: string;
+    MsgAddRow: string;
+    MsgLoading: string;
+    MsgDragRow: string;
+    MsgAutosizeColumn: string;
+    MsgExpandDetail: string;
+    MsgCollapseDetail: string;
+    MsgDeleteSelected: string;
+    MsgValidationRequired: string;
+    MsgValidationMin: string;
+    MsgValidationMax: string;
+    MsgValidationPattern: string;
+};