@nxgt/material-core 0.14.0 → 0.15.0-next-20261013091433

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @nxgt/material-core
 
+## 0.15.0-next-20261013091433
+
+### 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`; they read a number as `NumberField` does, directional marks skipped and `−` as a minus.
+
+- [#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`).
+
+- [#769](https://github.com/softistx/nxgt-material/pull/769) [`8e4cdfa`](https://github.com/softistx/nxgt-material/commit/8e4cdfae4d67d6563f916e35112cadac8d54e2ce) Thanks [@SteveGT96](https://github.com/SteveGT96)! - `@nxgt/material-core/escape-forward`: a control marked `data-keeps-escape` keeps Escape from the Dialog, Sheet, Drawer, AlertDialog or Popover around it (in both libraries), as a field whose list is open does; `isKeptEscape(event)` tells such an Escape from one the page prevented.
+
 ## 0.14.0
 
 ### Minor Changes

package/README.md

@@ -10,8 +10,8 @@ the date range presets, a debounce, accent-insensitive text matching and a race-
 rule, a field's first reachable control (`/focus-control`) and its `aria-describedby`
 (`/described-by`), where the focus goes in a repeatable row group
 (`/repeatable-group`), the page behind a modal layer made inert
-(`/inert-others`), Escape pressed while an overlay closes or in a field whose
-list is open (`/escape-forward`), the Toaster's guard against a tap's emulated hover
+(`/inert-others`), Escape pressed while an overlay closes, in a field whose
+list is open or in a control marked `data-keeps-escape` (`/escape-forward`), the Toaster's guard against a tap's emulated hover
 (`/touch-hover`), the focus a toast's action hands back (`/toast-focus`), a
 table row's activation, the zod error map's issue messages
 (`/zod-issue-messages`), a zod error map that words an issue by its code
@@ -30,7 +30,8 @@ re-export what they always exported, at the same subpaths:
 from here, and so do their `PdfReader`, `CurrencyField`, form fields (their
 focus, blur, `aria-describedby` and zod messages), file list and upload
 field (`formatFileSize`), modal layers (the inert page behind, Escape while
-closing, Escape in a field whose list is open), `Toaster`, `DataTable` rows, `@nxgt/material/next` and
+closing, Escape in a field whose list is open or in a control marked
+`data-keeps-escape`), `Toaster`, `DataTable` rows, `@nxgt/material/next` and
 `@nxgt/material-vue/nuxt`. Import it directly when you want the model or a
 formatter without a UI library, or one of these helpers in a component of
 your own.
@@ -92,7 +93,7 @@ can reach. No other subpath imports a `node:` built-in.
 | `/field-blur-layers` | `layerOf`, `openerOf`, `FieldLayers` — whose overlay a layer of the page is, for a field's blur |
 | `/focus-control` | `firstControl`, `focusHandle`, `FocusHandle` — the first control of a field a user can reach, and a stand-in element that focuses it for a form library |
 | `/repeatable-group` | `focusAfterRemove`, `focusAfterMove`, `focusRowTarget`, `rowMoveTarget`, `canAddRow`, `canRemoveRow`, `RowFocusTarget`, `RowMoveDirection`, `RowAnnouncement`, `ROW_SLOT`, `ROW_FIELDS_SLOT`, `ADD_ATTRIBUTE` — where the focus goes after a row of a `RepeatableGroup` is added, removed or moved, and what its live region says |
-| `/escape-forward` | `forwardEscape`, `keepListEscape` — Escape pressed while an overlay closes, pressed again for the overlay below once it has gone; Escape pressed in a field whose list is open, kept from closing the overlay around it |
+| `/escape-forward` | `forwardEscape`, `keepListEscape`, `isKeptEscape` — Escape pressed while an overlay closes, pressed again for the overlay below once it has gone; Escape pressed in a field whose list is open, or in a control marked `data-keeps-escape`, kept from closing the overlay around it, and told from an Escape the page prevented |
 | `/described-by` | `describedBy` — an `aria-describedby` value from the caller's ids and a field's help and error ids |
 | `/inert-others` | `inertOthers`, `INERT_MARKER` — the rest of the page `inert` behind a modal layer, live regions kept, nested layers counted |
 | `/backgrounds` | `buildBackgroundScene`, `buildGrain`, `assertSafeScene`, `svgIdPrefix`, `observeBackgroundActivity`, `mulberry32`, `valueNoise2`, `scatter`, `motifShape`, `place`, `BACKGROUND_PRESETS`, `SHIPPED_BACKGROUND_PRESETS`, `resolveShippedPreset`, `BACKGROUND_TONES`, `MOTIF_SHAPES`, `MOTIF_DEFAULTS` and the types `BackgroundPreset`, `ShippedBackgroundPreset`, `BackgroundTone`, `BackgroundIntensity`, `MotifOptions`, `SceneNode`, `PresetInfo` — the engine behind the libraries' background presets: a seeded generator, scattering, motif shapes, a plain SVG scene format with its safety check, ids for `url(#…)`, and the observer that pauses an animation |
@@ -120,6 +121,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
 
@@ -1079,6 +1082,30 @@ list sits in a `[data-slot="combobox-content"]` popup (a command palette's
 input is not), or when it carries `data-list-open="true"` (the Vue
 `Autocomplete`'s textbox).
 
+A control that handles Escape itself (a grid's cell editor, whose Escape
+cancels the edit; a grid cell whose Escape collapses a selected range)
+carries `data-keeps-escape`, or sits inside an element that does (a grid's
+paste-problems panel, whose Escape closes it): `keepListEscape` keeps its
+Escape from the overlay around it too. Its own handler then sees `defaultPrevented` true,
+for an Escape that is still its own: `isKeptEscape(event)` is `true` for an
+Escape `keepListEscape` kept (and only for one), so the handler can tell it
+from an Escape something else prevented.
+
+```tsx
+import { isKeptEscape } from '@nxgt/material-core/escape-forward';
+
+declare function cancelEdit(): void;
+
+<input
+  data-keeps-escape=""
+  onKeyDown={(event) => {
+    const native = event.nativeEvent;
+    if (event.defaultPrevented && !isKeptEscape(native)) return;
+    if (event.key === 'Escape') cancelEdit(); // the dialog stays open
+  }}
+/>;
+```
+
 ```ts
 import { forwardEscape, keepListEscape } from '@nxgt/material-core/escape-forward';
 
@@ -1382,6 +1409,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-zpm2cke7.js

@@ -0,0 +1,50 @@
+// src/lib/parse-number.ts
+var IGNORED = /[\s\u200e\u200f\u061c]/g;
+function clean(raw) {
+  return raw.trim().replace(IGNORED, "").replace(/\u2212/g, "-");
+}
+function parseNumberInput2(raw) {
+  const cleaned = clean(raw);
+  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 = clean(raw);
+  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=90F9821DC4F6087964756E2164756E21
+//# sourceMappingURL=index-zpm2cke7.js.map

package/dist/chunks/index-zpm2cke7.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/**\n * What a user or a locale puts in a number besides its digits: spaces (`\\s`\n * covers the no-break ones) and the directional marks around an Arabic minus.\n */\nconst IGNORED = /[\\s\\u200e\\u200f\\u061c]/g;\n\n/** `raw` without its spaces and marks, a Unicode minus (`−`) read as `-`. */\nfunction clean(raw: string) {\n\treturn raw\n\t\t.trim()\n\t\t.replace(IGNORED, '')\n\t\t.replace(/\\u2212/g, '-');\n}\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 * Directional marks are skipped and `−` is a minus, so what `Intl` writes\n * for an Arabic locale reads back.\n */\nexport function parseNumberInput(raw: string): number | null {\n\tconst cleaned = clean(raw);\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 = clean(raw);\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": ";AAUA,IAAM,UAAU;AAGhB,SAAS,KAAK,CAAC,KAAa;AAAA,EAC3B,OAAO,IACL,KAAK,EACL,QAAQ,SAAS,EAAE,EACnB,QAAQ,WAAW,GAAG;AAAA;AAUlB,SAAS,iBAAgB,CAAC,KAA4B;AAAA,EAC5D,MAAM,UAAU,MAAM,GAAG;AAAA,EACzB,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,MAAM,GAAG;AAAA,EACzB,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": "90F9821DC4F6087964756E2164756E21",
+  "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"}