@lowdefy/blocks-aggrid 5.0.0 → 5.2.0

package/dist/blocks/AgGridMaterial/meta.js

@@ -65,6 +65,14 @@
                 rows: 'The displayed rows after sorting.',
                 sort: 'The sort column state.'
             }
+        },
+        onCellLink: {
+            description: 'Triggered when a built-in `cell.type: link` (or avatar with `link`) cell is clicked. Wire to a `Link` action with `params: { _event: link }` to navigate.',
+            event: {
+                link: 'The resolved link config (pageId/href/urlQuery/back/home/newTab).',
+                row: 'The row data.',
+                value: 'The cell value.'
+            }
         }
     },
     properties: {
@@ -87,6 +95,21 @@
                 type: 'string',
                 description: 'The data field to use in `getRowId` which results in Row Selection being maintained across Row Data changes (assuming the Row exists in both sets). See Ag Grid docs for more details (https://www.ag-grid.com/react-data-grid/data-update-row-data/).'
             },
+            enableBrowserTooltips: {
+                type: 'boolean',
+                default: false,
+                description: "Set to `true` to use the browser native `title` attribute tooltips instead of AG Grid's styled tooltip component."
+            },
+            tooltipShowDelay: {
+                type: 'number',
+                default: 2000,
+                description: 'The delay in milliseconds before a tooltip is shown. Not applied when `enableBrowserTooltips` is `true`.'
+            },
+            tooltipHideDelay: {
+                type: 'number',
+                default: 10000,
+                description: 'The delay in milliseconds before a tooltip is hidden. Not applied when `enableBrowserTooltips` is `true`.'
+            },
             defaultColDef: {
                 type: 'object',
                 description: 'Column properties which get applied to all columns. See all (https://www.ag-grid.com/javascript-data-grid/column-properties/).'
@@ -138,6 +161,243 @@
                                 'string'
                             ],
                             description: 'A function (using the `_function` operator) or expression to format a value, should return a string. Not used for CSV export or copy to clipboard, only for UI cell rendering.'
+                        },
+                        tooltipField: {
+                            type: 'string',
+                            description: "The field of the row object to read the tooltip value from. When set, hovering a cell shows a tooltip with that value using the grid's default tooltip component."
+                        },
+                        tooltipValueGetter: {
+                            type: 'object',
+                            description: 'Provide a function (using the `_function` operator) that returns the tooltip value for a cell. Overrides `tooltipField`.'
+                        },
+                        tooltipComponent: {
+                            type: 'object',
+                            description: 'Provide a custom tooltip component. See AG Grid tooltip component docs (https://www.ag-grid.com/react-data-grid/component-tooltip/).'
+                        },
+                        ellipsis: {
+                            type: 'number',
+                            description: 'Line-clamp count for long text. Automatically enables `wrapText` and `autoHeight` and applies the `.lf-ellipsis-N` class (1–6).'
+                        },
+                        cell: {
+                            type: 'object',
+                            description: 'Built-in cell renderer. Takes precedence over `cellRenderer` when `type` is set. Field-valued keys (e.g. `nameField`, `srcField`, `urlQuery.*`) are row-data paths.',
+                            properties: {
+                                type: {
+                                    type: 'string',
+                                    enum: [
+                                        'tag',
+                                        'avatar',
+                                        'link',
+                                        'date',
+                                        'boolean',
+                                        'progress',
+                                        'number'
+                                    ],
+                                    description: 'The built-in renderer to use.'
+                                },
+                                colorMap: {
+                                    type: 'object',
+                                    description: 'Tag: map of cell value → color (antd tag color name or hex). Used when `cell.type: tag`.'
+                                },
+                                colorFrom: {
+                                    type: 'string',
+                                    description: 'Tag: row-data path to a color value. Takes precedence over `colorMap`.'
+                                },
+                                default: {
+                                    type: 'string',
+                                    description: 'Tag: fallback color for values not in `colorMap`.'
+                                },
+                                nameField: {
+                                    type: 'string',
+                                    description: 'Avatar: row-data path for the name label.'
+                                },
+                                srcField: {
+                                    type: 'string',
+                                    description: 'Avatar: row-data path for the image src (optional).'
+                                },
+                                idField: {
+                                    type: 'string',
+                                    description: 'Avatar: row-data path for an id used to seed initials colour.'
+                                },
+                                shape: {
+                                    type: 'string',
+                                    enum: [
+                                        'circle',
+                                        'square'
+                                    ],
+                                    description: 'Avatar shape. Defaults to `circle`.'
+                                },
+                                link: {
+                                    type: 'object',
+                                    description: 'Avatar/Link: navigation config. Emits `onCellLink` on click. `pageId`/`href`/`back`/`home`/`newTab` are literal; `urlQuery` values are row-data paths.'
+                                },
+                                pageId: {
+                                    type: 'string',
+                                    description: 'Link: target page id (literal).'
+                                },
+                                href: {
+                                    type: 'string',
+                                    description: 'Link: literal href (overrides `pageId`).'
+                                },
+                                back: {
+                                    type: 'boolean',
+                                    description: 'Link: navigate back.'
+                                },
+                                home: {
+                                    type: 'boolean',
+                                    description: 'Link: navigate home.'
+                                },
+                                newTab: {
+                                    type: 'boolean',
+                                    description: 'Link: open in a new tab.'
+                                },
+                                urlQuery: {
+                                    type: 'object',
+                                    description: 'Link: query params. Each value is a row-data path.'
+                                },
+                                labelField: {
+                                    type: 'string',
+                                    description: 'Link: row-data path for the visible label (falls back to cell value).'
+                                },
+                                format: {
+                                    type: 'string',
+                                    description: 'Date: dayjs format string. Default `YYYY-MM-DD HH:mm`.'
+                                },
+                                relative: {
+                                    type: 'boolean',
+                                    description: 'Date: render as relative time (e.g. "3 hours ago").'
+                                },
+                                trueLabel: {
+                                    type: 'string',
+                                    description: 'Boolean: label when truthy.'
+                                },
+                                falseLabel: {
+                                    type: 'string',
+                                    description: 'Boolean: label when falsy.'
+                                },
+                                trueColor: {
+                                    type: 'string',
+                                    description: 'Boolean: CSS colour when truthy.'
+                                },
+                                falseColor: {
+                                    type: 'string',
+                                    description: 'Boolean: CSS colour when falsy.'
+                                },
+                                thresholds: {
+                                    type: 'array',
+                                    description: 'Progress: threshold values (ascending). Each threshold defines where the next colour starts.',
+                                    items: {
+                                        type: 'number'
+                                    }
+                                },
+                                colors: {
+                                    type: 'array',
+                                    description: 'Progress: colour per bucket (length = thresholds.length + 1).',
+                                    items: {
+                                        type: 'string'
+                                    }
+                                },
+                                suffix: {
+                                    type: 'string',
+                                    description: 'Number/Progress: literal suffix appended after the formatted value. Default `%` for progress.'
+                                },
+                                nullLabel: {
+                                    type: 'string',
+                                    description: 'Progress: label when value is null. Default `None`.'
+                                },
+                                format: {
+                                    type: 'string',
+                                    description: 'Number: `number` (default), `currency`, `percent`, or `compact` (K/M/B). Date: dayjs format string (default `YYYY-MM-DD HH:mm`).'
+                                },
+                                locale: {
+                                    type: 'string',
+                                    description: 'Number: BCP 47 locale for `Intl.NumberFormat` (e.g. `en-US`, `de-DE`). Defaults to browser.'
+                                },
+                                currency: {
+                                    type: 'string',
+                                    description: 'Number: ISO 4217 currency code when `format: currency`. Default `USD`.'
+                                },
+                                currencyDisplay: {
+                                    type: 'string',
+                                    enum: [
+                                        'symbol',
+                                        'narrowSymbol',
+                                        'code',
+                                        'name'
+                                    ],
+                                    description: 'Number: currency display style when `format: currency`.'
+                                },
+                                decimals: {
+                                    type: 'number',
+                                    description: 'Number: fixed number of fraction digits (sets both `minimumFractionDigits` and `maximumFractionDigits`).'
+                                },
+                                minDecimals: {
+                                    type: 'number',
+                                    description: 'Number: `Intl.NumberFormat` `minimumFractionDigits`.'
+                                },
+                                maxDecimals: {
+                                    type: 'number',
+                                    description: 'Number: `Intl.NumberFormat` `maximumFractionDigits`.'
+                                },
+                                notation: {
+                                    type: 'string',
+                                    enum: [
+                                        'standard',
+                                        'scientific',
+                                        'engineering',
+                                        'compact'
+                                    ],
+                                    description: 'Number: `Intl.NumberFormat` notation. `compact` format sets this automatically.'
+                                },
+                                useGrouping: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Number: include thousands separators.'
+                                },
+                                negative: {
+                                    type: 'string',
+                                    enum: [
+                                        'minus',
+                                        'parentheses'
+                                    ],
+                                    default: 'minus',
+                                    description: 'Number: how to render negative numbers — `minus` (default) or `parentheses` for accounting.'
+                                },
+                                signColor: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Number: when true, positives use `positiveColor` (default success token), negatives use `negativeColor` (default error token).'
+                                },
+                                positiveColor: {
+                                    type: 'string',
+                                    description: 'Number: CSS colour when value > 0 (requires `signColor: true`).'
+                                },
+                                negativeColor: {
+                                    type: 'string',
+                                    description: 'Number: CSS colour when value < 0 (requires `signColor: true`).'
+                                },
+                                zeroColor: {
+                                    type: 'string',
+                                    description: 'Number: CSS colour when value === 0 (requires `signColor: true`).'
+                                },
+                                color: {
+                                    type: 'string',
+                                    description: 'Number: CSS colour applied to all values (overridden by `signColor`).'
+                                },
+                                prefix: {
+                                    type: 'string',
+                                    description: 'Number: literal prefix (e.g. `Δ `, `~`).'
+                                },
+                                align: {
+                                    type: 'string',
+                                    enum: [
+                                        'left',
+                                        'center',
+                                        'right'
+                                    ],
+                                    description: 'Cell horizontal alignment. Defaults to `right` for `cell.type: number`. Sets `cellStyle.justifyContent` and `ag-*-aligned-header` on the header.'
+                                }
+                            }
                         }
                     }
                 }

package/dist/cellRenderers/AvatarCell.js

@@ -0,0 +1,115 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import { Avatar } from 'antd';
+import { type } from '@lowdefy/helpers';
+import NullCell from './NullCell.js';
+import { resolveLink, resolvePath } from './resolveFieldRefs.js';
+import { buildHref } from './LinkCell.js';
+function initials(name) {
+    if (!type.isString(name) || name.length === 0) return '';
+    return name.trim().split(/\s+/).slice(0, 2).map((part)=>part[0]?.toUpperCase() ?? '').join('');
+}
+function colorSeed(id) {
+    if (type.isNone(id)) return 0;
+    const s = String(id);
+    let hash = 0;
+    for(let i = 0; i < s.length; i += 1)hash = hash * 31 + s.charCodeAt(i) >>> 0;
+    return hash;
+}
+const SEED_COLORS = [
+    'var(--ant-color-info)',
+    'var(--ant-color-success)',
+    'var(--ant-color-warning)',
+    'var(--ant-color-error)',
+    'var(--ant-color-purple, var(--ant-color-info))',
+    'var(--ant-color-cyan, var(--ant-color-info))',
+    'var(--ant-color-magenta, var(--ant-color-error))'
+];
+const rowStyle = {
+    display: 'inline-flex',
+    alignItems: 'center',
+    gap: 'var(--ant-margin-xs, 8px)',
+    maxWidth: '100%'
+};
+const labelStyle = {
+    overflow: 'hidden',
+    textOverflow: 'ellipsis',
+    whiteSpace: 'nowrap'
+};
+const linkStyle = {
+    ...labelStyle,
+    color: 'var(--ant-color-link)',
+    cursor: 'pointer'
+};
+function AvatarCell(params) {
+    const { value, data, cellConfig, methods } = params;
+    const name = type.isString(cellConfig?.nameField) ? resolvePath(cellConfig.nameField, data) : value;
+    const src = type.isString(cellConfig?.srcField) ? resolvePath(cellConfig.srcField, data) : undefined;
+    const id = type.isString(cellConfig?.idField) ? resolvePath(cellConfig.idField, data) : undefined;
+    if (type.isNone(name) && type.isNone(src)) {
+        return /*#__PURE__*/ React.createElement(NullCell, null);
+    }
+    const shape = cellConfig?.shape === 'square' ? 'square' : 'circle';
+    const size = 'var(--lf-avatar-size, var(--ant-control-height-sm, 24px))';
+    const fontSize = 'var(--lf-avatar-font-size, var(--ant-font-size-sm, 12px))';
+    const bg = SEED_COLORS[colorSeed(id ?? name) % SEED_COLORS.length];
+    const avatar = /*#__PURE__*/ React.createElement(Avatar, {
+        src: src || undefined,
+        shape: shape,
+        style: {
+            width: size,
+            height: size,
+            minWidth: size,
+            lineHeight: size,
+            fontSize,
+            backgroundColor: src ? undefined : bg,
+            color: 'var(--ant-color-text-light-solid, #fff)',
+            flexShrink: 0
+        }
+    }, initials(name));
+    const link = cellConfig?.link ? resolveLink(cellConfig.link, data) : undefined;
+    if (link) {
+        const href = buildHref(link);
+        const onClick = (event)=>{
+            if (event.metaKey || event.ctrlKey || event.shiftKey || event.button === 1) return;
+            if (link.newTab) return;
+            event.preventDefault();
+            methods?.triggerEvent?.({
+                name: 'onCellLink',
+                event: {
+                    link,
+                    row: data,
+                    value
+                }
+            });
+        };
+        return /*#__PURE__*/ React.createElement("span", {
+            style: rowStyle
+        }, avatar, /*#__PURE__*/ React.createElement("a", {
+            href: href ?? '#',
+            style: linkStyle,
+            onClick: onClick,
+            target: link.newTab ? '_blank' : undefined,
+            rel: link.newTab ? 'noopener noreferrer' : undefined
+        }, String(name ?? '')));
+    }
+    return /*#__PURE__*/ React.createElement("span", {
+        style: rowStyle
+    }, avatar, /*#__PURE__*/ React.createElement("span", {
+        style: labelStyle
+    }, String(name ?? '')));
+}
+export default AvatarCell;

package/dist/cellRenderers/BooleanCell.js

@@ -0,0 +1,31 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import { type } from '@lowdefy/helpers';
+import NullCell from './NullCell.js';
+function BooleanCell(params) {
+    const { value, cellConfig } = params;
+    if (type.isNone(value)) return /*#__PURE__*/ React.createElement(NullCell, null);
+    const truthy = Boolean(value);
+    const label = truthy ? cellConfig?.trueLabel ?? 'Yes' : cellConfig?.falseLabel ?? 'No';
+    const color = truthy ? cellConfig?.trueColor ?? 'var(--ant-color-success)' : cellConfig?.falseColor ?? 'var(--ant-color-text-quaternary)';
+    return /*#__PURE__*/ React.createElement("span", {
+        style: {
+            color,
+            fontWeight: truthy ? 600 : 400
+        }
+    }, label);
+}
+export default BooleanCell;

package/dist/cellRenderers/DateCell.js

@@ -0,0 +1,36 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import dayjs from 'dayjs';
+import relativeTime from 'dayjs/plugin/relativeTime.js';
+import { type } from '@lowdefy/helpers';
+import NullCell from './NullCell.js';
+dayjs.extend(relativeTime);
+const DEFAULT_FORMAT = 'YYYY-MM-DD HH:mm';
+function DateCell(params) {
+    const { value, cellConfig } = params;
+    if (type.isNone(value) || value === '') {
+        return /*#__PURE__*/ React.createElement(NullCell, null);
+    }
+    const d = dayjs(value);
+    if (!d.isValid()) {
+        return /*#__PURE__*/ React.createElement(NullCell, {
+            placeholder: "—"
+        });
+    }
+    const text = cellConfig?.relative ? d.fromNow() : d.format(cellConfig?.format ?? DEFAULT_FORMAT);
+    return /*#__PURE__*/ React.createElement("span", null, text);
+}
+export default DateCell;

package/dist/cellRenderers/EllipsisCell.js

@@ -0,0 +1,37 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import { type } from '@lowdefy/helpers';
+function createEllipsisCell(lines) {
+    const clamp = Math.max(1, Math.min(6, Math.floor(lines)));
+    const style = {
+        display: '-webkit-box',
+        WebkitBoxOrient: 'vertical',
+        WebkitLineClamp: clamp,
+        overflow: 'hidden',
+        whiteSpace: 'normal',
+        wordBreak: 'break-word',
+        width: '100%'
+    };
+    function EllipsisCell(params) {
+        const { value } = params;
+        if (type.isNone(value)) return null;
+        return /*#__PURE__*/ React.createElement("span", {
+            style: style
+        }, String(value));
+    }
+    return EllipsisCell;
+}
+export default createEllipsisCell;

package/dist/cellRenderers/LinkCell.js

@@ -0,0 +1,68 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import { type } from '@lowdefy/helpers';
+import NullCell from './NullCell.js';
+import { resolveLink, resolveUrlQuery } from './resolveFieldRefs.js';
+function buildHref(link) {
+    if (!type.isObject(link)) return undefined;
+    if (type.isString(link.href)) return link.href;
+    if (!type.isString(link.pageId)) return undefined;
+    const query = type.isObject(link.urlQuery) ? Object.entries(link.urlQuery).filter(([, v])=>!type.isNone(v)).map(([k, v])=>`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join('&') : '';
+    return `/${link.pageId}${query ? `?${query}` : ''}`;
+}
+const linkStyle = {
+    color: 'var(--ant-color-link)',
+    cursor: 'pointer',
+    textDecoration: 'none'
+};
+function LinkCell(params) {
+    const { value, data, cellConfig, methods } = params;
+    if (type.isNone(value) || value === '') {
+        return /*#__PURE__*/ React.createElement(NullCell, null);
+    }
+    const label = type.isString(cellConfig?.labelField) ? String(data?.[cellConfig.labelField] ?? value) : String(value);
+    const link = resolveLink({
+        pageId: cellConfig?.pageId,
+        href: cellConfig?.href,
+        back: cellConfig?.back,
+        home: cellConfig?.home,
+        newTab: cellConfig?.newTab,
+        urlQuery: cellConfig?.urlQuery
+    }, data);
+    const href = buildHref(link);
+    function onClick(event) {
+        if (event.metaKey || event.ctrlKey || event.shiftKey || event.button === 1) return;
+        if (cellConfig?.newTab) return;
+        event.preventDefault();
+        methods?.triggerEvent?.({
+            name: 'onCellLink',
+            event: {
+                link,
+                row: data,
+                value
+            }
+        });
+    }
+    return /*#__PURE__*/ React.createElement("a", {
+        href: href ?? '#',
+        style: linkStyle,
+        onClick: onClick,
+        target: cellConfig?.newTab ? '_blank' : undefined,
+        rel: cellConfig?.newTab ? 'noopener noreferrer' : undefined
+    }, label);
+}
+export { buildHref, resolveUrlQuery };
+export default LinkCell;

package/dist/cellRenderers/NullCell.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+const style = {
+    color: 'var(--ant-color-text-quaternary)'
+};
+function NullCell({ placeholder = '\u2014' }) {
+    return /*#__PURE__*/ React.createElement("span", {
+        style: style
+    }, placeholder);
+}
+export default NullCell;

package/dist/cellRenderers/NumberCell.js

@@ -0,0 +1,76 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import { type } from '@lowdefy/helpers';
+import NullCell from './NullCell.js';
+function buildOptions(cellConfig = {}) {
+    const { format = 'number', decimals, minDecimals, maxDecimals, currency = 'USD', currencyDisplay = 'symbol', notation, useGrouping = true } = cellConfig;
+    const opts = {
+        useGrouping
+    };
+    if (format === 'currency') {
+        opts.style = 'currency';
+        opts.currency = currency;
+        opts.currencyDisplay = currencyDisplay;
+    } else if (format === 'percent') {
+        opts.style = 'percent';
+    } else if (format === 'compact') {
+        opts.notation = 'compact';
+        opts.compactDisplay = 'short';
+    } else {
+        opts.style = 'decimal';
+    }
+    if (notation && !opts.notation) opts.notation = notation;
+    if (type.isInt(decimals)) {
+        opts.minimumFractionDigits = decimals;
+        opts.maximumFractionDigits = decimals;
+    } else {
+        if (type.isInt(minDecimals)) opts.minimumFractionDigits = minDecimals;
+        if (type.isInt(maxDecimals)) opts.maximumFractionDigits = maxDecimals;
+    }
+    return opts;
+}
+function signColor(num, cellConfig) {
+    if (!cellConfig?.signColor) return cellConfig?.color;
+    if (num > 0) return cellConfig?.positiveColor ?? 'var(--ant-color-success)';
+    if (num < 0) return cellConfig?.negativeColor ?? 'var(--ant-color-error)';
+    return cellConfig?.zeroColor ?? cellConfig?.color;
+}
+function NumberCell(params) {
+    const { value, cellConfig } = params;
+    if (type.isNone(value) || value === '') return /*#__PURE__*/ React.createElement(NullCell, null);
+    const num = Number(value);
+    if (Number.isNaN(num)) return /*#__PURE__*/ React.createElement(NullCell, null);
+    const locale = cellConfig?.locale;
+    const opts = buildOptions(cellConfig);
+    const absText = new Intl.NumberFormat(locale, opts).format(Math.abs(num));
+    let text;
+    if (num < 0) {
+        text = cellConfig?.negative === 'parentheses' ? `(${absText})` : `-${absText}`;
+    } else {
+        text = absText;
+    }
+    const prefix = cellConfig?.prefix ?? '';
+    const suffix = cellConfig?.suffix ?? '';
+    const display = `${prefix}${text}${suffix}`;
+    const color = signColor(num, cellConfig);
+    const style = color ? {
+        color
+    } : undefined;
+    return /*#__PURE__*/ React.createElement("span", {
+        style: style
+    }, display);
+}
+export default NumberCell;