fix(datagrid-web): derive default export decimals per value to avoid trailing dot

A static `{base}.########` mask emits the literal decimal point even when
all fractional `#` digits collapse, so whole numbers exported as `1983.`
and broke the export e2e test. Count the fractional digits from the value
itself instead, so integers use `0` (no dot) and decimals mirror the grid.

Author: yordan-st

packages/pluggableWidgets/datagrid-web/openspec/design.md

@@ -3,9 +3,9 @@
 ### Reproduction Tests
 
 - Attribute number with default export type mirrors the grid - (unit)
-    - **Given**: Attribute column with `exportType = "default"`, attribute has `formatter = { type: "number", config: { groupDigits: true } }` (Mendix Decimal attributes only expose `groupDigits` at runtime, not a fixed `decimalPrecision`)
+    - **Given**: Attribute column with `exportType = "default"`, value `1234.56`, attribute has `formatter = { type: "number", config: { groupDigits: true } }` (Mendix Decimal attributes only expose `groupDigits` at runtime, not a fixed `decimalPrecision`)
     - **When**: Export reads the cell
-    - **Then**: Cell is `{ t: "n", v: 1234.56, z: "#,##0.########" }` — `#` suppresses trailing zeros so Excel renders exactly what the grid shows (`1234.56` stays `1234.56`, `0.5` stays `0.5`, integers stay integers)
+    - **Then**: Cell is `{ t: "n", v: 1234.56, z: "#,##0.00" }` — the fractional-digit count is taken from the value itself so Excel renders exactly what the grid shows
 
 - Attribute date with default export type uses custom pattern - (unit)
     - **Given**: Attribute column with `exportType = "default"`, attribute has `formatter = { type: "datetime", config: { type: "custom", pattern: "dd/MM/yyyy" } }`
@@ -25,9 +25,14 @@
     - **Then**: Cell has `z: "0"` (no grouping, no decimals) — an explicit `decimalPrecision` takes priority over the grid-mirroring fallback
 
 - Attribute number without grouping mirrors the grid - (unit)
-    - **Given**: Attribute column with `exportType = "default"`, attribute has `formatter = { type: "number", config: { groupDigits: false } }` (no `decimalPrecision`)
+    - **Given**: Attribute column with `exportType = "default"`, value `0.5`, attribute has `formatter = { type: "number", config: { groupDigits: false } }` (no `decimalPrecision`)
     - **When**: Export reads the cell
-    - **Then**: Cell has `z: "0.########"` (no grouping, up to 8 fractional digits with trailing zeros suppressed)
+    - **Then**: Cell has `z: "0.0"` (no grouping, one fractional digit derived from the value)
+
+- Attribute whole-number value produces no fractional format - (unit)
+    - **Given**: Attribute column with `exportType = "default"`, value `1983`, attribute has `formatter = { type: "number", config: { groupDigits: false } }`
+    - **When**: Export reads the cell
+    - **Then**: Cell has `z: "0"` — no fractional section, so Excel does not render a trailing dot (`"1983"`, not `"1983."`)
 
 - Attribute with formatter lacking type field - (unit)
     - **Given**: Attribute column with `exportType = "default"`, attribute has basic formatter (no `type` property, e.g., default mock)
@@ -53,7 +58,7 @@
 
 ## Notes
 
-- Mendix Decimal attributes do **not** expose a fixed `decimalPrecision` on the formatter config at runtime — only `groupDigits` is present (verified against the live client). The number-default format therefore mirrors the grid using `{base}.########` (8 = the Mendix DB fractional-digit maximum) with `#` suppressing trailing zeros, rather than deriving a fixed precision. The `decimalPrecision` branch is retained for the case where a future runtime does supply it.
+- Mendix Decimal attributes do **not** expose a fixed `decimalPrecision` on the formatter config at runtime — only `groupDigits` is present (verified against the live client). The number-default format therefore mirrors the grid by counting the fractional digits of the value itself and building `{base}.{0×n}`. A static `{base}.########` mask cannot be used because the literal `.` in the mask is always emitted, so whole numbers would render with a trailing dot (`1983` → `"1983."`). The `decimalPrecision` branch is retained for the case where a future runtime does supply it.
 - The `M → m` conversion is needed because Mendix uses Java-style date patterns (M = month) while Excel uses `m` for month.
 - `getAttributeDefaultFormat` returns `undefined` for string, boolean, and enum attributes — these fall through to existing logic (displayValue for strings, native boolean cells).
 - The `editorConfig` change is Studio Pro-only (design time) — no runtime test needed.

packages/pluggableWidgets/datagrid-web/openspec/proposal.md

@@ -16,8 +16,8 @@ The `editorConfig.ts` visibility logic only conditionally hid `exportNumberForma
 
 Package: `packages/pluggableWidgets/datagrid-web`
 
-- `src/features/data-export/cell-readers.ts` — New `getAttributeDefaultFormat(props)` function reads `props.attribute.formatter` and derives an Excel format string:
-    - `formatter.type === "number"` → builds format from `groupDigits`; when `decimalPrecision` is present it is honoured, otherwise the format mirrors the grid as `{base}.########` (up to 8 fractional digits, trailing zeros suppressed by `#`), so `1234.56` exports as `1234.56` and integers stay integers
+- `src/features/data-export/cell-readers.ts` — New `getAttributeDefaultFormat(props, value)` function reads `props.attribute.formatter` and derives an Excel format string:
+    - `formatter.type === "number"` → builds format from `groupDigits`; when `decimalPrecision` is present it is honoured, otherwise the fractional-digit count is taken from the value itself (`{base}.{0×n}`), so `1234.56` exports as `1234.56` and whole numbers export without a trailing dot
     - `formatter.type === "datetime"` with `config.type === "custom"` → converts Mendix pattern to Excel format (M→m replacement)
     - Otherwise returns `undefined` (falls through to existing locale default for dates)
     - Attribute reader now branches: `exportType === "default"` → `getAttributeDefaultFormat()`, else → existing `getCellFormat()`.

packages/pluggableWidgets/datagrid-web/src/features/data-export/__tests__/cell-readers.spec.ts

@@ -127,7 +127,8 @@ describe("cell-readers", () => {
         });
 
         it("mirrors the grid when number formatter config omits decimalPrecision (grouped)", () => {
-            // Real Mendix Decimal attributes only expose `groupDigits` at runtime.
+            // Real Mendix Decimal attributes only expose `groupDigits` at runtime, so the
+            // decimal count is derived from the value itself.
             const attr = listAttribute(() => new Big("1234.56")) as any;
             attr.formatter = { type: "number", config: { groupDigits: true } };
             const col = column("Amount", c => {
@@ -138,7 +139,7 @@ describe("cell-readers", () => {
             const cell = readSingleCell(col);
             expect(cell.t).toBe("n");
             expect(cell.v).toBe(1234.56);
-            expect(cell.z).toBe("#,##0.########");
+            expect(cell.z).toBe("#,##0.00");
         });
 
         it("mirrors the grid when number formatter config omits decimalPrecision (ungrouped)", () => {
@@ -152,8 +153,22 @@ describe("cell-readers", () => {
             const cell = readSingleCell(col);
             expect(cell.t).toBe("n");
             expect(cell.v).toBe(0.5);
-            // `#` suppresses trailing zeros, so Excel renders exactly what the grid shows.
-            expect(cell.z).toBe("0.########");
+            expect(cell.z).toBe("0.0");
+        });
+
+        it("uses no fractional format for a whole-number value (no trailing dot)", () => {
+            // Regression: a static `0.########` mask renders 1983 as "1983." in Excel.
+            const attr = listAttribute(() => new Big("1983")) as any;
+            attr.formatter = { type: "number", config: { groupDigits: false } };
+            const col = column("Birth year", c => {
+                c.showContentAs = "attribute";
+                c.attribute = attr;
+                c.exportType = "default";
+            });
+            const cell = readSingleCell(col);
+            expect(cell.t).toBe("n");
+            expect(cell.v).toBe(1983);
+            expect(cell.z).toBe("0");
         });
 
         it("exports date attribute with format as date cell", () => {

packages/pluggableWidgets/datagrid-web/src/features/data-export/cell-readers.ts

@@ -113,7 +113,13 @@ function countSignificantDigits(value: Big): number {
     return stripped.length || 1;
 }
 
-function getAttributeDefaultFormat(props: ColumnsType): string | undefined {
+function countDecimalPlaces(value: Big): number {
+    const fixed = value.toFixed();
+    const dot = fixed.indexOf(".");
+    return dot === -1 ? 0 : fixed.length - dot - 1;
+}
+
+function getAttributeDefaultFormat(props: ColumnsType, value: unknown): string | undefined {
     const formatter = props.attribute?.formatter;
     if (!formatter) {
         return undefined;
@@ -129,13 +135,12 @@ function getAttributeDefaultFormat(props: ColumnsType): string | undefined {
         const base = cfg.groupDigits ? "#,##0" : "0";
         // Mendix Decimal attributes do not expose a fixed `decimalPrecision` on the
         // formatter config at runtime (only `groupDigits`). Honour it when present,
-        // otherwise mirror the grid: show up to 8 fractional digits (the Mendix DB
-        // maximum) with trailing zeros suppressed via `#`, so 1234.56 stays 1234.56
-        // and integers stay integers — instead of collapsing to a whole number.
-        if (cfg.decimalPrecision != null) {
-            return cfg.decimalPrecision > 0 ? `${base}.${"0".repeat(cfg.decimalPrecision)}` : base;
-        }
-        return `${base}.########`;
+        // otherwise mirror the grid by taking the decimal count from the value itself.
+        // A per-value count (rather than a `0.########` mask) is required because a
+        // static fractional mask emits a trailing dot for whole numbers (1983 -> "1983.").
+        const decimals =
+            cfg.decimalPrecision != null ? cfg.decimalPrecision : value instanceof Big ? countDecimalPlaces(value) : 0;
+        return decimals > 0 ? `${base}.${"0".repeat(decimals)}` : base;
     }
 
     return undefined;
@@ -152,7 +157,7 @@ const readers: ReadersByType = {
         const value = data.value;
         const format =
             props.exportType === "default"
-                ? getAttributeDefaultFormat(props)
+                ? getAttributeDefaultFormat(props, value)
                 : getCellFormat({
                       exportType: props.exportType,
                       exportDateFormat: props.exportDateFormat,