@nxgt/material-core 0.13.2 → 0.14.0-next-20261013055642

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @nxgt/material-core
 
+## 0.14.0-next-20261013055642
+
+### Minor Changes
+
+- [#693](https://github.com/softistx/nxgt-material/pull/693) [`075693d`](https://github.com/softistx/nxgt-material/commit/075693dda8355458d3a2795277bfba0de14a773b) Thanks [@SteveGT96](https://github.com/SteveGT96)! - `@nxgt/material-core/data-grid`: the pure half of the coming editable `DataGrid` — its model (rows and columns by position and key, what each cell allows, the version each cell was read from, per cell with the row's as the fallback), navigation and keyboard commands (arrows over the header, body and footer rows, Home/End and Ctrl/Cmd+Left/Right, Ctrl/Cmd+Up/Down to a column's ends, Ctrl/Cmd+Home/End, PageUp/PageDown, Tab and Enter skipping cells that cannot be edited, RTL), the selected range, the edit session, validation (a column's parse, then `validate`, then any Standard Schema; the server's refusals by entry index), a number column with codes (`numberCodes`: "abs" or "disp" in any language, `,` or `.` as the decimal separator, bounds and decimals, an empty text clearing the cell) and the live region's message descriptors.
+  
+  `@nxgt/material-core/parse-number`: `parseNumberInput`, `clampNumber` and `stepNumber` move here from `@nxgt/material`'s `NumberField`, plus `decimalsTyped`.
+
+- [#699](https://github.com/softistx/nxgt-material/pull/699) [`b13f08a`](https://github.com/softistx/nxgt-material/commit/b13f08a5c1a92f362ecd4e1f365173b5a8eb88f6) Thanks [@SteveGT96](https://github.com/SteveGT96)! - `@nxgt/material-core/data-grid`: the rest of the coming editable `DataGrid`'s pure half — the changes per cell (`editCell`, each change keeping the value and the version it was read at, per cell with the row's as the fallback; `rebase` after a refetch, a moved version and value turning a pending edit into a conflict while a cell whose value is still its base adopts the new version; a saved value, and "Keep theirs", kept as an overlay until the app's rows hold it, a refetch still read at the version a save or a conflict replaced changing nothing; `resolveConflict` with "theirs" or "mine"; a conflict outliving any edit until it is resolved; `expireSaved`; `changeCounts` and `blocking`), the save queue (`startCall`, `applyAnswer`, `applyFailure`, `applyAbort`, `retry`: one call in flight at a time; per cell up to 200 entries a call, per row once the row is left, or in one batch on `save()` with no limit, blocked while a cell is in error or in conflict; an answer is all or nothing, `versions[i]` updating entry `i`'s cells (and, with `versionScope: 'row'`, the row's other changes) and a refusal flagging its cells as errors or conflicts; paused after 3 failures in a row, an abort counting none), undo and redo (`record`, `undo`, `redo`: 100 steps, an undo is a new edit, cells changed since are skipped and counted), tab-separated copy and paste as Excel and Google Sheets write it, a cell with a quote and no line break read raw (`parseTsv`, `serializeTsv`), the all-or-nothing paste plan (`planPaste`: past the grid, locked, read-only, computed, not parsed and invalid cells listed as problems), the totals' aggregates (`aggregate`: sum, mean, min, max, count, or the app's own, over numbers only; a count of nothing is 0), the sort order kept while editing (`reconcileOrder`) and the conflict panel's two values, a cleared one reading "Cleared" (`conflictValues`).
+
 ## 0.13.2
 
 ### Patch Changes

package/README.md

@@ -120,6 +120,8 @@ can reach. No other subpath imports a `node:` built-in.
 | `/states` | `EMPTY_STATE_KINDS`, `ERROR_STATE_KINDS`, `resolveEmptyStateKind`, `isErrorKind`, `stateCopy`, `STATE_ACTION_KEYS`, `describeError`, `STATE_ILLUSTRATIONS`, `STATE_ACCENT`, `STATE_ICON` and the types `EmptyStateKind`, `ErrorStateKind`, `StateKind`, `LegacyEmptyStateVariant`, `StateFamily`, `StateCopy`, `ErrorDetail`, `StateIllustration`, `IllustrationShape`, `IllustrationTone`, `StateAccent`, `StateIconName` — the kinds, copy keys, error details and illustrations behind `EmptyState` and `ErrorState` |
 | `/vite` | `nxgtMaterial()`, `pdfkitStandardFonts()`, `cspAssetsInlineLimit`, `CSP_NONCE_PLACEHOLDER`, `ZOD_JITLESS_SCRIPT` and the types `NxgtMaterialOptions`, `NxgtMaterialCspOptions`, `NxgtMaterialLibrary` — see below |
 | `/pdfkit-fonts` | **Node only.** `pdfkitStandardFontDirs`, `pdfkitStandardFontFiles`, `PDFKIT_STANDARD_FONTS`, the types `PdfkitStandardFont` and `PdfkitFontsWarn` — where the app's pdfkit keeps its standard fonts, for a server tracer |
+| `/data-grid` | **Headless**, for the editable `DataGrid` coming in `@nxgt/material`; nothing renders yet. The model (`buildGridModel`, `cellAccess`, `cellVersion` and `isNewCellVersion`), navigation (`navigate`, `gridCommandFor`), the range (`extend`, `selectAll`, `rangeCells`, …), the edit session (`editReducer`), validation (`validateCell`, `serverErrors`, `refusalsByCell`, Standard Schema), `numberCodes`, the changes per cell (`NO_CHANGES`, `editCell`, `rebase`, `resolveConflict`, `expireSaved`, `changeCounts`, `blocking`), the save queue (`IDLE_QUEUE`, `nextCall`, `startCall`, `applyAnswer`, `applyFailure`, `applyAbort`, `retry`), undo and redo (`EMPTY_HISTORY`, `record`, `undo`, `redo`), copy and paste (`parseTsv`, `serializeTsv`, `planPaste`), the totals (`aggregate`), the kept sort order (`snapshotOrder`, `reconcileOrder`, `sortingChanged`), the conflict panel's text (`conflictValues`, `conflictSummary`, `clearedText`) and the live region's descriptors (`savedMessage`, `cellStateText`, …), with the types `GridModel`, `GridColumnSpec`, `GridRowSpec`, `GridMsg`, `GridPos`, `GridRange`, `GridVersion`, `GridCode`, `GridChanges`, `GridSaveQueue`, `GridCall`, `GridSaveAnswer`, `GridHistory`, `GridStep`, `GridPasteInput`, `GridPastePlan`, `GridPasteProblem`, `GridAggregate` and `GridSort`. A cell's version is `0` or `undefined` when it does not exist yet on the server. See below |
+| `/parse-number` | `parseNumberInput`, `decimalsTyped`, `clampNumber`, `stepNumber` — a typed number read with `,` or `.` as its decimal separator, its typed decimals, and the clamp and step behind `NumberField` |
 
 ## Usage
 
@@ -1357,6 +1359,249 @@ You rarely call it yourself: `withNxgtPrint` (`@nxgt/material/next`) turns
 the directories into `outputFileTracingIncludes` globs, and the Nuxt module
 of `@nxgt/material-vue` adds the files to `nitro.externals.traceInclude`.
 
+### An editable grid's pure half: `/data-grid`
+
+The logic behind the editable `DataGrid` that is coming to `@nxgt/material`,
+with nothing rendered yet: where a cell is, which cell a key moves to, what a
+typed text parses to, and the messages to announce. It never reads the DOM, so
+it also runs in a test or on a server. Positions are `{ row, col }`; the header
+row is `-1` and the footer rows follow the body.
+
+```ts
+import {
+	buildGridModel,
+	cellVersion,
+	gridCommandFor,
+	gridPlatform,
+	isGridPos,
+	navigate,
+	numberCodes,
+	validateCell,
+	type GridPos,
+} from '@nxgt/material-core/data-grid';
+
+type Row = { id: string; outOf: number; version?: number };
+
+const model = buildGridModel({
+	columns: [
+		{ id: 'name', label: 'Name', frozen: true },
+		{ id: 'maths', label: 'Maths', editor: 'number' },
+	],
+	rows: [{ id: 'ada' }, { id: 'alan' }],
+});
+
+// A key press is a command, and a command takes the active cell somewhere.
+const key = { key: 'ArrowDown', shiftKey: false, ctrlKey: false, metaKey: false, altKey: false };
+const command = gridCommandFor(key, 'nav', gridPlatform(navigator.platform));
+// { type: 'move', cmd: 'down' }
+
+let active: GridPos = { row: 0, col: 1 };
+if (command?.type === 'move') {
+	const next = navigate(active, command.cmd, {
+		model,
+		pageSize: 10,
+		dir: 'ltr',
+		skipReadOnly: true,
+	});
+	if (isGridPos(next)) active = next; // else 'exit-forward' / 'exit-back': leave the grid
+}
+
+// A number column that also takes codes, in any language, with `,` or `.`.
+const grades = numberCodes<Row>({
+	min: 0,
+	max: (row) => row.outOf,
+	decimals: 2,
+	codes: [{ value: 'ABS', labels: { en: 'abs', fr: 'abs' }, aliases: { fr: ['absent'] } }],
+});
+const row: Row = { id: 'ada', outOf: 20 };
+
+grades.parse('abs', { lang: 'fr', row }); // { value: 'ABS' }
+grades.parse('12,5', { lang: 'fr', row }); // { value: 12.5 }
+grades.parse('25', { lang: 'en', row }); // { error: GridMsg } — "Enter a number from 0 to 20"
+
+// Parse, then the column's check, then a Standard Schema: the first error wins.
+const result = validateCell({
+	text: '12,5',
+	row,
+	parse: (text) => grades.parse(text, { lang: 'fr', row }),
+});
+// { ok: true, value: 12.5 } or { ok: false, error: GridMsg }
+
+// The version the server gave a cell: per cell, else the row's.
+cellVersion(row, 'maths', { getRowVersion: (r) => r.version });
+```
+
+- **Messages are descriptors.** Every error and announcement is a `GridMsg`
+  (`{ key: 'material.data-grid.…', fallback, values? }`): the library
+  translates `key`, and `gridFallbackText(message)` gives the English text.
+- **Versions are passed through unchanged.** `cellVersion` answers
+  `getCellVersion` when it is given, else `getRowVersion`, else `undefined`;
+  `isNewCellVersion` is true for `0` and `undefined`, a cell that does not
+  exist yet on the server.
+- **Numbers are never rounded or clamped.** Too many decimals or a value out
+  of bounds is an error. Spaces are stripped (`"1 234"` is 1234), but a
+  second separator is refused: `"1,234"` is 1.234 and `"1,234.5"` an error.
+  `parse` needs the row; with a bound that is a function of the row and no
+  row, it refuses the number rather than let it through unchecked.
+- **A cleared cell skips the schema.** `null` still runs `validate`, but not
+  the Standard Schema, so a `z.number()` does not refuse a clear; refuse an
+  empty cell in `validate` (or with `numberCodes({ emptyClears: false })`).
+  Without `parse`, the value is the text: a column whose value is not a
+  string must give one.
+- **Tab in an editor always moves on.** `tabBehavior: 'exit'` makes Tab leave
+  the grid from a cell, but a commit's Tab (`commitNext` / `commitPrev`)
+  still walks the cells. `gridCommandFor` returns `{ type: 'swallow' }` for
+  the browser's back and forward (Alt+Arrow, Cmd+[ and Cmd+]): call
+  `preventDefault` and do nothing.
+
+#### Saving changes: the queue
+
+Each edited cell is a change that keeps the value and the version it was read
+at. The queue picks what the next call sends, one call at a time; the answer
+is all or nothing.
+
+```ts
+import {
+	applyAbort,
+	applyAnswer,
+	applyFailure,
+	cellVersion,
+	editCell,
+	expireSaved,
+	gridCellKey,
+	type GridCall,
+	type GridSaveAnswer,
+	IDLE_QUEUE,
+	NO_CHANGES,
+	startCall,
+} from '@nxgt/material-core/data-grid';
+
+type Row = { id: string; maths: number | null; version: number };
+const row: Row = { id: 'ada', maths: 12, version: 3 };
+// The app's save: one call, answered as a whole.
+declare function onSave(entries: GridCall['entries'], signal: AbortSignal): Promise<GridSaveAnswer>;
+
+let changes = NO_CHANGES;
+let queue = IDLE_QUEUE;
+
+// An edit: going back to the value read drops it again.
+changes = editCell(changes, {
+	key: gridCellKey(row.id, 'maths'),
+	base: row.maths,
+	baseVersion: cellVersion(row, 'maths', { getRowVersion: (r) => r.version }),
+	value: 14,
+});
+
+// Cell mode sends everything dirty (200 entries a call at most); row mode the
+// rows left; batch mode only on save(), with no limit, and not while a cell is
+// in error or in conflict.
+const started = startCall(changes, queue, { mode: 'cell' });
+if (started) {
+	({ changes, queue } = started); // its cells are 'saving'
+	const { call } = started;
+	const controller = new AbortController();
+	try {
+		const answer = await onSave(call.entries, controller.signal);
+		// Versions per row (no getCellVersion): the row's other changes move too.
+		({ changes, queue } = applyAnswer(changes, queue, call.id, answer, Date.now(), { versionScope: 'row' }));
+	} catch {
+		({ changes, queue } = controller.signal.aborted
+			? applyAbort(changes, queue, call.id) // no failure counted
+			: applyFailure(changes, queue, call.id)); // paused after 3: retry(queue)
+	}
+}
+changes = expireSaved(changes, Date.now()); // 1.5s later: the "saved" mark goes
+```
+
+- **`versions[i]` is entry `i`'s.** It becomes the cell's new `baseVersion`
+  (every changed cell of the row, in row mode; with `versionScope: 'row'`,
+  the row's other changes still on the old version too). Without one, the
+  version the cell was read at stays, and the next `rebase` adopts the
+  row's: a cell whose value is still its base never conflicts.
+- **A refusal saves nothing.** `{ ok: false, refused }` names entries by index:
+  an `error` flags its cell, a `conflict` opens one (`resolveConflict(changes,
+  key, 'theirs' | 'mine')`), and every other cell goes back to dirty, to be
+  sent again. A cell edited during the call stays dirty either way. A
+  refusal naming no cell sent is counted in `outcome.unmatched`.
+- **A saved value stays until the rows hold it.** It is kept as an overlay
+  (status `'clean'` once the mark expires), as "Keep theirs" is, so the cell
+  never flashes back to stale data. The version a save or a conflict
+  replaced is kept as `staleVersion`: a refetch that still reads at it is
+  older than the grid and changes nothing, and `rebase` drops the overlay
+  once the refetched rows hold the value.
+- **A refetch is a `rebase`.** It compares cell versions when `getCellVersion`
+  is given, else the row's; a pending edit whose version and value moved
+  becomes a conflict, and a conflict outlives any edit until it is resolved.
+
+```ts
+import {
+	aggregate,
+	buildGridModel,
+	conflictValues,
+	EMPTY_HISTORY,
+	type GridCellKey,
+	type GridNumberCodeValue,
+	NO_CHANGES,
+	numberCodes,
+	parseTsv,
+	planPaste,
+	splitCellKey,
+	undo,
+} from '@nxgt/material-core/data-grid';
+
+const changes = NO_CHANGES; // the grid's changes
+const rows = new Map([['ada', { maths: 12 as GridNumberCodeValue }]]);
+const model = buildGridModel({
+	columns: [{ id: 'maths', label: 'Maths', editor: 'number' }],
+	rows: [{ id: 'ada' }],
+});
+const grades = numberCodes({ min: 0, max: 20, decimals: 2 });
+const [lang, locale] = ['fr', 'fr-FR'];
+const valueInRows = (key: GridCellKey) => {
+	const { rowId } = splitCellKey(key);
+	return rows.get(rowId)?.maths;
+};
+
+// Undo is a new edit: send each of `undone.edits` through editCell; `skipped` cells changed since.
+const undone = undo(EMPTY_HISTORY, (key) => changes[key]?.value ?? valueInRows(key)); // null: nothing to undo
+
+// A paste is all or nothing, at the matrix's own size: { ok: true, edits, range } or { ok: false, problems }.
+const plan = planPaste({
+	matrix: parseTsv('14\r\n'),
+	anchor: { row: 0, col: 0 },
+	model,
+	parse: (text) => grades.parse(text, { lang, row: undefined }),
+});
+
+// Totals over numbers only: codes and empty cells are skipped.
+aggregate('mean', [12, 'ABS', null, 14]); // 13; aggregate('count', []) is 0
+
+// The conflict panel's two values, formatted with the column's own format; a cleared one is "Cleared".
+conflictValues({
+	theirs: null,
+	yours: 12.5,
+	format: (value) => grades.format(value as GridNumberCodeValue, { lang, locale }),
+}); // { theirs: Cleared, yours: "12,5" }
+```
+
+### A typed number: `/parse-number`
+
+A number typed with `,` or `.` as its decimal separator, the decimals it was
+typed with, and the clamp and step behind `NumberField` and the data grid's
+number editor.
+
+```ts
+import { clampNumber, decimalsTyped, parseNumberInput, stepNumber } from '@nxgt/material-core/parse-number';
+
+parseNumberInput('12,5'); // 12.5
+parseNumberInput('1 234,5'); // 1234.5: the last of `,` and `.` is the decimal separator
+parseNumberInput('-'); // null: empty or incomplete
+decimalsTyped('12,50'); // 2: a trailing zero is what the user typed
+clampNumber(15, 0, 10); // 10: `min` and `max` are each optional
+stepNumber(1.1, 1, 0.1); // 1.2: no float drift
+stepNumber(null, -1, 1, 0); // 0: empty starts at 0, then is clamped
+```
+
 ## Traps
 
 | Symptom | Fix |

package/dist/chunks/index-54gkyr43.js

@@ -0,0 +1,23 @@
+// src/lib/text-match.ts
+var DIACRITICS = /[̀-ͯ]/g;
+function foldText2(text, locale) {
+  return lowercase(text, locale).normalize("NFD").replace(DIACRITICS, "");
+}
+function lowercase(text, locale) {
+  try {
+    return text.toLocaleLowerCase(locale);
+  } catch {
+    return text.toLocaleLowerCase();
+  }
+}
+function matchesText2(text, query, locale) {
+  const needle = foldText2(query.trim(), locale);
+  if (!needle)
+    return true;
+  return foldText2(text, locale).includes(needle);
+}
+
+export { foldText2, matchesText2 };
+
+//# debugId=021CEAFE8087CA9864756E2164756E21
+//# sourceMappingURL=index-54gkyr43.js.map

package/dist/chunks/index-54gkyr43.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/lib/text-match.ts"],
+  "sourcesContent": [
+    "/**\n * Accent- and case-insensitive text matching, for a list filtered as the user\n * types: `'e'` finds \"École\", `'ecole'` finds \"ÉCOLE\".\n */\n\n/** Combining diacritical marks, which `normalize('NFD')` splits from their letter. */\nconst DIACRITICS = /[̀-ͯ]/g;\n\n/**\n * `text` lowercased for `locale` (the runtime's when omitted), then without\n * its diacritics: `foldText('Élève')` is `'eleve'`. Lowercasing comes first,\n * so a Turkish `'İ'` (`'tr'`) folds to `'i'` rather than keeping a dot.\n */\nexport function foldText(text: string, locale?: string): string {\n\treturn lowercase(text, locale).normalize('NFD').replace(DIACRITICS, '');\n}\n\nfunction lowercase(text: string, locale?: string): string {\n\ttry {\n\t\treturn text.toLocaleLowerCase(locale);\n\t} catch {\n\t\t// An invalid language tag: the runtime's own rules, never a throw.\n\t\treturn text.toLocaleLowerCase();\n\t}\n}\n\n/**\n * Whether `query` occurs in `text`, ignoring case and accents. A query of\n * spaces only matches everything, as an empty one does.\n */\nexport function matchesText(\n\ttext: string,\n\tquery: string,\n\tlocale?: string,\n): boolean {\n\tconst needle = foldText(query.trim(), locale);\n\tif (!needle) return true;\n\treturn foldText(text, locale).includes(needle);\n}\n"
+  ],
+  "mappings": ";AAMA,IAAM,aAAa;AAOZ,SAAS,SAAQ,CAAC,MAAc,QAAyB;AAAA,EAC/D,OAAO,UAAU,MAAM,MAAM,EAAE,UAAU,KAAK,EAAE,QAAQ,YAAY,EAAE;AAAA;AAGvE,SAAS,SAAS,CAAC,MAAc,QAAyB;AAAA,EACzD,IAAI;AAAA,IACH,OAAO,KAAK,kBAAkB,MAAM;AAAA,IACnC,MAAM;AAAA,IAEP,OAAO,KAAK,kBAAkB;AAAA;AAAA;AAQzB,SAAS,YAAW,CAC1B,MACA,OACA,QACU;AAAA,EACV,MAAM,SAAS,UAAS,MAAM,KAAK,GAAG,MAAM;AAAA,EAC5C,IAAI,CAAC;AAAA,IAAQ,OAAO;AAAA,EACpB,OAAO,UAAS,MAAM,MAAM,EAAE,SAAS,MAAM;AAAA;",
+  "debugId": "021CEAFE8087CA9864756E2164756E21",
+  "names": []
+}

package/dist/chunks/index-wdn02459.js

@@ -0,0 +1,47 @@
+// src/lib/parse-number.ts
+var SPACES = /\s/g;
+function parseNumberInput2(raw) {
+  const cleaned = raw.trim().replace(SPACES, "");
+  if (!cleaned || cleaned === "-" || cleaned === "+" || cleaned === "." || cleaned === ",") {
+    return null;
+  }
+  const lastComma = cleaned.lastIndexOf(",");
+  const lastDot = cleaned.lastIndexOf(".");
+  const normalized = lastComma > lastDot ? cleaned.replace(/\./g, "").replace(",", ".") : cleaned.replace(/,/g, "");
+  const value = Number(normalized);
+  return Number.isFinite(value) ? value : null;
+}
+function decimalsTyped2(raw) {
+  const cleaned = raw.trim().replace(SPACES, "");
+  const separator = Math.max(cleaned.lastIndexOf(","), cleaned.lastIndexOf("."));
+  if (separator === -1)
+    return 0;
+  return /^\d*/.exec(cleaned.slice(separator + 1))?.[0].length ?? 0;
+}
+function clampNumber2(value, min, max) {
+  let next = value;
+  if (min != null)
+    next = Math.max(min, next);
+  if (max != null)
+    next = Math.min(max, next);
+  return next;
+}
+function decimalPlaces(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  const text = String(value);
+  const index = text.indexOf(".");
+  if (index === -1 || text.includes("e") || text.includes("E"))
+    return 0;
+  return text.length - index - 1;
+}
+function stepNumber2(value, direction, step = 1, min, max) {
+  const places = Math.max(decimalPlaces(step), decimalPlaces(value ?? 0));
+  const next = Number(((value ?? 0) + direction * step).toFixed(places));
+  return clampNumber2(next, min, max);
+}
+
+export { parseNumberInput2, decimalsTyped2, clampNumber2, stepNumber2 };
+
+//# debugId=1910164834C0257964756E2164756E21
+//# sourceMappingURL=index-wdn02459.js.map

package/dist/chunks/index-wdn02459.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/lib/parse-number.ts"],
+  "sourcesContent": [
+    "/**\n * The number a user typed, read with either decimal separator: `'12,5'` and\n * `'12.5'` are both 12.5. Behind `NumberField` and the data grid's number\n * editor (`numberCodes`).\n */\n\n/** Spaces a user or a locale puts in a number (`\\s` covers the no-break ones). */\nconst SPACES = /\\s/g;\n\n/**\n * `raw` as a number, or `null` when it is empty or incomplete (`'-'`, `','`).\n * The last of `,` and `.` is the decimal separator and the other one groups\n * (`'1 234,5'` and `'1,234.5'` are 1234.5); a lone `,` is a decimal comma.\n */\nexport function parseNumberInput(raw: string): number | null {\n\tconst cleaned = raw.trim().replace(SPACES, '');\n\tif (\n\t\t!cleaned ||\n\t\tcleaned === '-' ||\n\t\tcleaned === '+' ||\n\t\tcleaned === '.' ||\n\t\tcleaned === ','\n\t) {\n\t\treturn null;\n\t}\n\tconst lastComma = cleaned.lastIndexOf(',');\n\tconst lastDot = cleaned.lastIndexOf('.');\n\tconst normalized =\n\t\tlastComma > lastDot\n\t\t\t? cleaned.replace(/\\./g, '').replace(',', '.')\n\t\t\t: cleaned.replace(/,/g, '');\n\tconst value = Number(normalized);\n\treturn Number.isFinite(value) ? value : null;\n}\n\n/**\n * How many decimals `raw` was typed with, read as `parseNumberInput` reads\n * it: the digits after the last `,` or `.` — `'12,50'` is 2, `'12'` and\n * `'12.'` are 0. A trailing zero counts: it is what the user typed.\n */\nexport function decimalsTyped(raw: string): number {\n\tconst cleaned = raw.trim().replace(SPACES, '');\n\tconst separator = Math.max(\n\t\tcleaned.lastIndexOf(','),\n\t\tcleaned.lastIndexOf('.'),\n\t);\n\tif (separator === -1) return 0;\n\treturn /^\\d*/.exec(cleaned.slice(separator + 1))?.[0].length ?? 0;\n}\n\n/** `value` kept within `min` and `max`, either of which may be absent. */\nexport function clampNumber(value: number, min?: number, max?: number) {\n\tlet next = value;\n\tif (min != null) next = Math.max(min, next);\n\tif (max != null) next = Math.min(max, next);\n\treturn next;\n}\n\nfunction decimalPlaces(value: number) {\n\tif (!Number.isFinite(value)) return 0;\n\tconst text = String(value);\n\tconst index = text.indexOf('.');\n\tif (index === -1 || text.includes('e') || text.includes('E')) return 0;\n\treturn text.length - index - 1;\n}\n\n/**\n * `value` one `step` up or down, rounded to the decimals of the step or the\n * value (no float drift: 1.1 + 0.1 is 1.2), then clamped. Empty starts at 0.\n */\nexport function stepNumber(\n\tvalue: number | null,\n\tdirection: 1 | -1,\n\tstep = 1,\n\tmin?: number,\n\tmax?: number,\n) {\n\tconst places = Math.max(decimalPlaces(step), decimalPlaces(value ?? 0));\n\tconst next = Number(((value ?? 0) + direction * step).toFixed(places));\n\treturn clampNumber(next, min, max);\n}\n"
+  ],
+  "mappings": ";AAOA,IAAM,SAAS;AAOR,SAAS,iBAAgB,CAAC,KAA4B;AAAA,EAC5D,MAAM,UAAU,IAAI,KAAK,EAAE,QAAQ,QAAQ,EAAE;AAAA,EAC7C,IACC,CAAC,WACD,YAAY,OACZ,YAAY,OACZ,YAAY,OACZ,YAAY,KACX;AAAA,IACD,OAAO;AAAA,EACR;AAAA,EACA,MAAM,YAAY,QAAQ,YAAY,GAAG;AAAA,EACzC,MAAM,UAAU,QAAQ,YAAY,GAAG;AAAA,EACvC,MAAM,aACL,YAAY,UACT,QAAQ,QAAQ,OAAO,EAAE,EAAE,QAAQ,KAAK,GAAG,IAC3C,QAAQ,QAAQ,MAAM,EAAE;AAAA,EAC5B,MAAM,QAAQ,OAAO,UAAU;AAAA,EAC/B,OAAO,OAAO,SAAS,KAAK,IAAI,QAAQ;AAAA;AAQlC,SAAS,cAAa,CAAC,KAAqB;AAAA,EAClD,MAAM,UAAU,IAAI,KAAK,EAAE,QAAQ,QAAQ,EAAE;AAAA,EAC7C,MAAM,YAAY,KAAK,IACtB,QAAQ,YAAY,GAAG,GACvB,QAAQ,YAAY,GAAG,CACxB;AAAA,EACA,IAAI,cAAc;AAAA,IAAI,OAAO;AAAA,EAC7B,OAAO,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC,CAAC,IAAI,GAAG,UAAU;AAAA;AAI1D,SAAS,YAAW,CAAC,OAAe,KAAc,KAAc;AAAA,EACtE,IAAI,OAAO;AAAA,EACX,IAAI,OAAO;AAAA,IAAM,OAAO,KAAK,IAAI,KAAK,IAAI;AAAA,EAC1C,IAAI,OAAO;AAAA,IAAM,OAAO,KAAK,IAAI,KAAK,IAAI;AAAA,EAC1C,OAAO;AAAA;AAGR,SAAS,aAAa,CAAC,OAAe;AAAA,EACrC,IAAI,CAAC,OAAO,SAAS,KAAK;AAAA,IAAG,OAAO;AAAA,EACpC,MAAM,OAAO,OAAO,KAAK;AAAA,EACzB,MAAM,QAAQ,KAAK,QAAQ,GAAG;AAAA,EAC9B,IAAI,UAAU,MAAM,KAAK,SAAS,GAAG,KAAK,KAAK,SAAS,GAAG;AAAA,IAAG,OAAO;AAAA,EACrE,OAAO,KAAK,SAAS,QAAQ;AAAA;AAOvB,SAAS,WAAU,CACzB,OACA,WACA,OAAO,GACP,KACA,KACC;AAAA,EACD,MAAM,SAAS,KAAK,IAAI,cAAc,IAAI,GAAG,cAAc,SAAS,CAAC,CAAC;AAAA,EACtE,MAAM,OAAO,SAAS,SAAS,KAAK,YAAY,MAAM,QAAQ,MAAM,CAAC;AAAA,EACrE,OAAO,aAAY,MAAM,KAAK,GAAG;AAAA;",
+  "debugId": "1910164834C0257964756E2164756E21",
+  "names": []
+}

package/dist/data-grid/aggregates.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A totals row's built-in aggregates over a column's values. Only numbers
+ * count: codes ("abs"), empty cells and anything else are skipped, so the
+ * mean of 12, "abs" and 14 is 13. With no number, `count` is 0 and the
+ * others are `null` (the cell shows nothing); an app's own aggregate is
+ * not called.
+ */
+export type GridAggregateName = 'sum' | 'mean' | 'min' | 'max' | 'count';
+/** An app's own aggregate, over the column's numbers (never empty). */
+export type GridAggregateFn = (values: number[]) => number | null;
+export type GridAggregate = GridAggregateName | GridAggregateFn;
+/** The finite numbers among `values`. */
+export declare function numericValues(values: readonly unknown[]): number[];
+/** `kind` over the numbers among `values`; with none, 0 for `count` and `null` otherwise. */
+export declare function aggregate(kind: GridAggregate, values: readonly unknown[]): number | null;
+//# sourceMappingURL=aggregates.d.ts.map

package/dist/data-grid/aggregates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregates.d.ts","sourceRoot":"","sources":["../../src/data-grid/aggregates.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,CAAC;AAEzE,uEAAuE;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,IAAI,CAAC;AAElE,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAEhE,yCAAyC;AACzC,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,EAAE,CAKlE;AAWD,6FAA6F;AAC7F,wBAAgB,SAAS,CACxB,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,SAAS,OAAO,EAAE,GACxB,MAAM,GAAG,IAAI,CAIf"}

package/dist/data-grid/announce.d.ts

@@ -0,0 +1,41 @@
+import type { GridCellStatus, GridMsg } from './types';
+/** How long saved announcements merge, in ms. */
+export declare const SAVED_MERGE_MS = 1000;
+/** "3 changes saved". */
+export declare function savedMessage(count: number): GridMsg;
+/** The saved count to announce: added to the last one when it was under a second ago. */
+export type SavedTally = {
+    count: number;
+    at: number;
+};
+export declare function mergeSaved(last: SavedTally | null, count: number, now: number): SavedTally;
+/** A save that failed (the network): it is retried, or paused after 3 failures. */
+export declare function saveFailedMessage(paused?: boolean): GridMsg;
+/** "2 changes refused. F8: next problem": the server said no to them. */
+export declare function refusedMessage(count: number): GridMsg;
+/** "1 conflict: changed by someone else. F8: next problem". */
+export declare function conflictMessage(count: number): GridMsg;
+/** "Not cleared: 1 cell changed meanwhile": a Delete whose check answered too late. */
+export declare function clearDroppedMessage(count: number): GridMsg;
+/** "6 cells pasted". */
+export declare function pasteAppliedMessage(count: number): GridMsg;
+/** "Nothing pasted: 2 problems". */
+export declare function pasteRefusedMessage(count: number): GridMsg;
+/** "Undone: 3 cells", or "Undone: 2 cells, 1 skipped" when some had moved on. */
+export declare function undoneMessage(count: number, skipped?: number): GridMsg;
+/** "Redone: 3 cells". */
+export declare function redoneMessage(count: number): GridMsg;
+/** "Not saved", "Saving", "Saved", "Error", "Conflict". */
+export declare function cellStateText(status: GridCellStatus): GridMsg;
+/** "Locked", or "Locked: Grades are final" with the app's reason. */
+export declare function lockedText(reason?: string): GridMsg;
+/** "Read-only", or "Read-only: Left the course". */
+export declare function readOnlyText(reason?: string): GridMsg;
+/** "Calculated": a computed column's cell. */
+export declare function computedText(): GridMsg;
+/**
+ * The grid's description: how to move, edit and leave it ("Cmd" on macOS).
+ * With `tabBehavior: 'exit'`, Tab leaves the grid at once.
+ */
+export declare function exitHintText(platform?: 'mac' | 'other', tabBehavior?: 'cells' | 'exit'): GridMsg;
+//# sourceMappingURL=announce.d.ts.map

package/dist/data-grid/announce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"announce.d.ts","sourceRoot":"","sources":["../../src/data-grid/announce.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvD,iDAAiD;AACjD,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC,yBAAyB;AACzB,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAMnD;AAED,yFAAyF;AACzF,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,wBAAgB,UAAU,CACzB,IAAI,EAAE,UAAU,GAAG,IAAI,EACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACT,UAAU,CAKZ;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,MAAM,UAAQ,GAAG,OAAO,CAUzD;AAKD,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAMrD;AAED,+DAA+D;AAC/D,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAUtD;AAED,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAU1D;AAED,wBAAwB;AACxB,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAM1D;AAED,oCAAoC;AACpC,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAU1D;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAI,GAAG,OAAO,CAYjE;AAED,yBAAyB;AACzB,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAMpD;AAUD,2DAA2D;AAC3D,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAE7D;AAED,qEAAqE;AACrE,wBAAgB,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAMnD;AAED,oDAAoD;AACpD,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAUrD;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,GAAE,KAAK,GAAG,OAAiB,EACnC,WAAW,GAAE,OAAO,GAAG,MAAgB,GACrC,OAAO,CAaT"}

package/dist/data-grid/change-ops.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The changes' small immutable operations, shared by `changes.ts`,
+ * `rebase.ts` and the save answers.
+ */
+import type { GridChange, GridChanges } from './change-types';
+import type { GridCellKey, GridVersion } from './types';
+/** `change` without the fields named. */
+export declare function omit<K extends keyof GridChange>(change: GridChange, ...keys: K[]): GridChange;
+export declare function withEntry(changes: GridChanges, change: GridChange): GridChanges;
+export declare function without(changes: GridChanges, key: GridCellKey): GridChanges;
+/**
+ * The overlay a cell keeps once nothing is left to send: it shows `value`,
+ * the server's, until the app's rows hold it.
+ */
+export declare function cleanOverlay(change: GridChange, value: unknown, version: GridChange['baseVersion']): GridChange;
+/** Whether `change` keeps a version a save or a conflict replaced. */
+export declare function hasStaleVersion(change: GridChange): boolean;
+/**
+ * Whether a refetch read at `version` is older than what `change` knows.
+ * `0` and `undefined` (a cell that does not exist yet) are the same read
+ * here: an app may report a missing cell either way.
+ */
+export declare function isStaleRead(change: GridChange, version: GridVersion | undefined): boolean;
+/**
+ * `change` moved to `version`, the one it had kept as `staleVersion`; the
+ * same change when the version did not move.
+ */
+export declare function moveVersion(change: GridChange, version: GridVersion | undefined): GridChange;
+//# sourceMappingURL=change-ops.d.ts.map

package/dist/data-grid/change-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-ops.d.ts","sourceRoot":"","sources":["../../src/data-grid/change-ops.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGxD,yCAAyC;AACzC,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,UAAU,EAC9C,MAAM,EAAE,UAAU,EAClB,GAAG,IAAI,EAAE,CAAC,EAAE,GACV,UAAU,CAIZ;AAED,wBAAgB,SAAS,CACxB,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,UAAU,GAChB,WAAW,CAEb;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,WAAW,GAAG,WAAW,CAK3E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,UAAU,CAAC,aAAa,CAAC,GAChC,UAAU,CASZ;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAOT;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,WAAW,GAAG,SAAS,GAC9B,UAAU,CAGZ"}

package/dist/data-grid/change-select.d.ts

@@ -0,0 +1,25 @@
+/**
+ * What the changes add up to: the counts a status bar and a save button
+ * show, and the entries in the order they were edited.
+ */
+import type { GridChange, GridChanges } from './change-types';
+/** The entries, oldest edit first. */
+export declare function changeList(changes: GridChanges): GridChange[];
+export type GridChangeCounts = {
+    /** Not saved yet, and valid: `dirty` and `saving`. */
+    dirty: number;
+    saving: number;
+    errors: number;
+    conflicts: number;
+};
+/** Every count in one pass (`onChangesChange`); a `clean` overlay counts for nothing. */
+export declare function changeCounts(changes: GridChanges): GridChangeCounts;
+/** Cells not saved yet (`dirty` or `saving`). */
+export declare function dirtyCount(changes: GridChanges): number;
+export declare function errorCount(changes: GridChanges): number;
+export declare function conflictCount(changes: GridChanges): number;
+/** Whether a cell in error or in conflict blocks a batch save. */
+export declare function blocking(changes: GridChanges): boolean;
+/** Whether anything is left to save or resolve (a saved cell or an overlay is not). */
+export declare function hasPendingChanges(changes: GridChanges): boolean;
+//# sourceMappingURL=change-select.d.ts.map

package/dist/data-grid/change-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-select.d.ts","sourceRoot":"","sources":["../../src/data-grid/change-select.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE9D,sCAAsC;AACtC,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,EAAE,CAE7D;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC9B,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,gBAAgB,CASnE;AAED,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAEvD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAEvD;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAE1D;AAED,kEAAkE;AAClE,wBAAgB,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAGtD;AAED,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAI/D"}

package/dist/data-grid/change-types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The shape of the grid's changes, one entry per changed cell, shared by
+ * `changes.ts` and the save queue. An entry also outlives its save as an
+ * overlay: the cell keeps showing the value saved (or the server's, on
+ * "Keep theirs") until the app's rows hold it.
+ */
+import type { GridCellKey, GridCellStatus, GridMsg, GridVersion } from './types';
+/** What the server holds instead, when a change conflicts with it. */
+export type GridConflict = {
+    value: unknown;
+    version: GridVersion | undefined;
+    /** Who changed it ("Ada Lovelace"). */
+    by?: string;
+    /** When (as the server words it). */
+    at?: string;
+};
+/**
+ * A change's status: a cell's (`dirty`, `saving`, `saved`, `error`,
+ * `conflict`), or `clean`: an overlay with nothing to send and no mark,
+ * kept until the app's rows catch up.
+ */
+export type GridChangeStatus = GridCellStatus | 'clean';
+/** One changed cell. */
+export type GridChange = {
+    key: GridCellKey;
+    rowId: string;
+    columnId: string;
+    /** The value the server holds, as far as the grid knows: going back to it ends the edit. */
+    base: unknown;
+    /** The version `base` is at, this cell's own (or its row's). */
+    baseVersion: GridVersion | undefined;
+    /** The value the cell shows and sends. */
+    value: unknown;
+    /** The text typed, kept with a local error ("25" when the max is 20). */
+    text?: string;
+    status: GridChangeStatus;
+    error?: GridMsg;
+    /** Kept while it is unresolved, under an error typed over it too. */
+    conflict?: GridConflict;
+    /**
+     * `base` came from a save or the server, not from the app's rows: the
+     * entry stays (as `clean` at the least) until `rebase` sees the rows
+     * hold it.
+     */
+    overlay?: true;
+    /**
+     * The version a save or a conflict replaced (`baseVersion` before it).
+     * A refetch read at it is older than what the grid knows: `rebase`
+     * leaves the entry as it is, until `expireSaved` drops the guard on an
+     * overlay. Present or not (`undefined` is a version: the cell did not
+     * exist yet), so test it with `hasStaleVersion`; an `undefined` one is
+     * lost through JSON, so keep the changes in memory, not serialised.
+     */
+    staleVersion?: GridVersion | undefined;
+    /**
+     * What the call in flight sent for this cell. Its status stays `saving`
+     * until the answer, unless it is edited meanwhile.
+     */
+    inFlight?: {
+        value: unknown;
+    };
+    /** When it was saved (`status: 'saved'`), or theirs kept: `expireSaved` reads it. */
+    savedAt?: number;
+    /** The edit's order: later edits have a higher one. */
+    seq: number;
+};
+/** The changes by cell key. A plain object, so a reducer's state can hold it. */
+export type GridChanges = {
+    readonly [key: GridCellKey]: GridChange;
+};
+export declare const NO_CHANGES: GridChanges;
+//# sourceMappingURL=change-types.d.ts.map

package/dist/data-grid/change-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-types.d.ts","sourceRoot":"","sources":["../../src/data-grid/change-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EACX,WAAW,EACX,cAAc,EACd,OAAO,EACP,WAAW,EACX,MAAM,SAAS,CAAC;AAEjB,sEAAsE;AACtE,MAAM,MAAM,YAAY,GAAG;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,WAAW,GAAG,SAAS,CAAC;IACjC,uCAAuC;IACvC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,qCAAqC;IACrC,EAAE,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,OAAO,CAAC;AAExD,wBAAwB;AACxB,MAAM,MAAM,UAAU,GAAG;IACxB,GAAG,EAAE,WAAW,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,4FAA4F;IAC5F,IAAI,EAAE,OAAO,CAAC;IACd,gEAAgE;IAChE,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;IACrC,0CAA0C;IAC1C,KAAK,EAAE,OAAO,CAAC;IACf,yEAAyE;IACzE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;IACf;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACvC;;;OAGG;IACH,QAAQ,CAAC,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC9B,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,UAAU,CAAA;CAAE,CAAC;AAEtE,eAAO,MAAM,UAAU,EAAE,WAA+B,CAAC"}

package/dist/data-grid/changes.d.ts

@@ -0,0 +1,46 @@
+import type { GridChanges } from './change-types';
+import type { GridCellKey, GridMsg, GridVersion } from './types';
+/** How long a saved cell shows it, in ms. */
+export declare const SAVED_EXPIRE_MS = 1500;
+/** An edit: the value, or the text the column could not accept and why. */
+export type GridEditInput = {
+    key: GridCellKey;
+    /** The cell's value in the app's row, kept as the base by a first edit. */
+    base: unknown;
+    /** The version the row gives that cell now (`cellVersion`). */
+    baseVersion: GridVersion | undefined;
+} & ({
+    value: unknown;
+} | {
+    text: string;
+    error: GridMsg;
+});
+/**
+ * `changes` with an edit applied. A first edit keeps `base` and
+ * `baseVersion`; later ones keep the entry's. An edit back to the base
+ * drops the entry (an overlay goes back to `clean`), unless a call is
+ * sending it or it is in conflict. An edit with an `error` keeps its text,
+ * flagged, and is never sent. A conflict outlives any edit, an invalid one
+ * included, until it is resolved: it is never sent at the old version.
+ */
+export declare function editCell(changes: GridChanges, input: GridEditInput): GridChanges;
+/**
+ * A conflict resolved. `'theirs'` keeps theirs as a `clean` overlay, at
+ * their version: nothing is sent, and the cell shows it until the app's
+ * rows hold it. `'mine'` rebases the change on theirs, version included,
+ * to be sent again (still flagged when an invalid text was typed over the
+ * conflict). Given `now`, theirs' guard against a stale read lasts until
+ * `expireSaved`, as a saved value's does.
+ */
+export declare function resolveConflict(changes: GridChanges, key: GridCellKey, choice: 'theirs' | 'mine', now?: number): GridChanges;
+/**
+ * `changes` once the saved marks `after` ms old or more are gone. A saved
+ * value the app's rows do not hold yet stays, as a `clean` overlay, and so
+ * does theirs kept: from then on a refetch that reads a different version
+ * wins, even one at the version the save replaced (`staleVersion` goes).
+ * Versions are opaque and may come back (a deleted cell reads at `0`
+ * again), so the guard lasts only that long. A dirty or conflicting entry
+ * keeps its `staleVersion`: its own value wins anyway.
+ */
+export declare function expireSaved(changes: GridChanges, now: number, after?: number): GridChanges;
+//# sourceMappingURL=changes.d.ts.map