Migration Notes

Migration notes are updated whenever a release changes public behavior, exported APIs, event payloads, or documented defaults. Each fixed version directory (e.g. 1.4) carries its own copy of this page describing the delta from the version before it — that copy is frozen at release time and never edited afterward. For a plain list of what shipped in each release (not just breaking changes), see the Changelog.

next (unreleased)Copy Anchor Link

Tracks work that will ship in the release after 1.4.

Named views (plan 190)Copy Anchor Link

Why: a saved view was a blob of grid state applied over whatever was on screen, workspace tabs were a second concept beside it, and a save was done when the store's call returned. A view is now one destination with an owner that acknowledges each save.

Fix: move workspace tabs to views.defined, and raise a definition's revision when you change it (the same revision with other content is reported, and the one held is kept). Views kept by an earlier version are not read.

Field types, collections and composed parts (plan 189)Copy Anchor Link

useGrid() and <GridScope>Copy Anchor Link

React cell components take the value as unknownCopy Anchor Link

Why: a React renderer's component is now typed (ComponentType<CellRendererProps<TRow>>), so props are checked.

Fix: a component declared with a narrower value (({ value }: { value: string })) takes unknown and narrows it (String(value)), or is typed CellRendererProps<TRow>. Drop any as any on a renderer spec.

Column filters patch per fieldCopy Anchor Link

Why: changing one column's filter meant copying, editing and writing back the whole map.

Fix: write only the field that changes: setState({ filter: { columns: { amount: null } } }) removes one. Code that wrote a whole map to remove a field (copy, delete, write back) now keeps the removed field; write null for it instead. To replace every column filter at once, clear first (filter: { columns: null }).

Live language, workspace and rulesCopy Anchor Link

Rules, issues and saving: dataCopy Anchor Link

Integrity issues and command targetsCopy Anchor Link

One filter: filterCopy Anchor Link

Saved layouts and views are schema version 5: blobs saved before are not applied.

Options are set with setOptionsCopy Anchor Link

Why: each setting had its own setter, some had none, and some were creation-only. One shape, all live.

Fix:

Style rules' selectionCopy Anchor Link

params.selection in a style rule is a GridSelectionTarget: focus, anchor and bounds. Rules that read range read anchor and focus instead.

Single-value gettersCopy Anchor Link

No state snapshotCopy Anchor Link

Why: getStateSnapshot() repeated getState() in other shapes beside options and status.

Fix: read each value from its read. Don't mutate what a read returns: it is frozen.

What the grid reports: getStatus()Copy Anchor Link

Why: status was spread over five getters and nine watch keys, and the page sat in both the state and getPagination().

getState() is frozen, and watch reads itCopy Anchor Link

Why: getState() built new objects on every call, so it could not be compared, and watch read a second, differently shaped snapshot instead.

Fix: don't mutate what getState() returns (copy it first). In a watch selector, g.selection is the public selection, possibly null (g.selection?.focus ?? null), and g.aggregation is a list of aggregations.

A visual row's record is its id and dataCopy Anchor Link

Why: a data row's node was typed as the grid's internal row node, so the public types named an internal class.

Fix: row.node is a VisualRowRecord ({ id, data }). Read row.node.data and row.node.id as before; for anything else about the record (selection, expansion, its place), use api.record(id).node.

Each export in one entry, for one audienceCopy Anchor Link

Why: the root exported 628 names, many of them the grid's internals, and two entries overlapped; an app could not tell what it was meant to use.

Fix:

What a column means is on the columnCopy Anchor Link

Why: the workspace's records said what each field meant away from the field, beside a column schema that already said what it holds; done and blocked statuses sat there too, and saying "no column is the progress" took an empty string.

Fix:

A view's own records ({ kind: 'calendar', records: { schedule: 'due' } }) is unchanged.

A column has one property per jobCopy Anchor Link

Why: a column could get a type two ways (a spread or a name in a registry only React read), its text had a formatter, a display's text and onCopy, text came back through onPaste only (paste into a currency column wrote the text), required sat beside the integrity rules, and checkboxSelection marked a column only the grid makes.

Fix:

Built-in column types now read pasted and typed text: numbers with grouping, currency signs and %, dates people write, yes / no, options by label.

A row node is a readCopy Anchor Link

Why: record(id).node carried its own writes beside the grid's one way for each.

Fix: read the node's fields; change rows the grid's way.

Row shaping is state; its gestures are commandsCopy Anchor Link

Why: grouping, expansion, detail rows and pivot each had their own getters, setters and add / remove / move / toggle methods beside the state, and a row node could open itself.

Fix: read state with getState() (or watch), options with getOptions(); run the gestures as commands.

Which rows and details are open is the expansion state (setState({ expansion }), initialState.expansion); saved layouts do not keep it. isExpanded(id) and isDetailOpen(id) stay as reads.

One write: transactionCopy Anchor Link

Two row reads: records and recordCopy Anchor Link

One cell read: cellCopy Anchor Link

Fix: api.getCellValue(rowId, field) → api.cell(rowId, field).value. The stored value is .raw; the text export and copy show is .text.

State is followed with watch; events are things that happenCopy Anchor Link

Why: about 26 events only said that a piece of state changed, some fired several times for one change, and a restore fired them for six keys only. watch hears every state change once per commit, with its cause.

Fix: the events below leave GridEventName and GridEventPayloadMap; follow the state instead. A watch listener gets (next, previous, cause); cause.source tells a person (user) from your code (api), a restore, undo or redo.

State is set with setStateCopy Anchor Link

Why: each piece of state had its own setter (some two), and reading it back took as many getters.

Fix: api.setState(partial) with the keys you change; api.getState() reads every key.

Saved layouts and views are schema version 4: state is GridState as JSON (columnState in place of columnOrder, columnVisibility, columnWidths and pinnedColumns). Blobs saved before are not applied (the grid reports it and keeps its state); save again after upgrading.

<Grid> props are the grid's optionsCopy Anchor Link

Why: some settings were React props only (a grid without React could not have them), and switches had three naming styles.

Fix: the props have the option names, and every one of them is live.

One storage option; the workspace's options say only what the workspace isCopy Anchor Link

Why: where things were kept was spread over five options with four adapter shapes, workspace meant either a saved-views adapter or the workspace's options, and three workspace switches repeated what a capability or composing already says.

Fix:

People's own layouts and saved chips no longer default to this browser's localStorage: without a place they last for the session. Views kept by createLocalStorageWorkspaceAdapter are not read back.

initialState is state; the rest are options or create optionsCopy Anchor Link

Why: initialState mixed what a person changes with what the app configures, under internal names, and several <Grid> props were initial-only although nothing stopped them changing.

Fix: initialState is a GridState (the keys getState() reads), applied as setState applies them. What the app configures is an option (live); what a grid is made with is a create option (GridCreateOptions: getRowId, initialState, persistence, workspace, dataIntegrity, fields, messages, offline).

Expanded rows and open details are not state yet: open them with setExpanded / setDetailOpen.

One theme, one way to change a column menuCopy Anchor Link

Why: the workspace had a second set of design tokens, and a column's menu had three ways to change it.

Fix:

• workspace.theme: { accent, radius, … } → the grid's theme: initialState.themeOverrides: { focusRing: accent, radius: '10px', shadow } (or api.setOptions({ theme })). Background, text and lines follow bgColor, textColor and borderColor.
• suppressHeaderMenu: true → compose that column's menu empty: compose.menu: (entries, c) => (c.menu === 'column' && c.colField === 'id' ? [] : entries). The header then shows no menu button.
• headerMenuRenderer / headerMenuComponent → compose the column's menu, and give the column a custom filter editor (filterDef) for filter UI of your own: the menu's filter entry draws it. HeaderMenuRendererProps is gone.

Card displays are the grid's displaysCopy Anchor Link

Why: a field's look was defined once for the table and again for cards. One display now serves the cells, the cards, the inspector, and export and copy.

Fix: move workspace.cardDisplays to the grid's displays (<Grid displays={…}>, or displays in createClientGrid). render(value, row, reader) becomes render(value, { row, rowId, column, surface, api }). A column whose cells drew the same thing with its own renderer can name the display instead (display: 'health'). WorkspaceCardDisplay is GridDisplay.

Two ways to listen: on and watchCopy Anchor Link

Why: the api had eleven ways to listen. Two remain: on for events, watch for state.

Fix:

• api.addEventListener(event, fn) → api.on(event, fn).
• api.subscribeToKey('sortModel', fn) → api.watch((grid) => grid.sortModel, fn).
• api.subscribeToSnapshotSelector(keys, select, fn, equals) → api.watch(select, fn, { equals }) (no key list: the watch follows what select reads).
• api.subscribe(fn) → api.watch((grid) => ({ ...grid }), fn) to hear any state change, or better a selector of what you use.
• subscribeToSyncState, subscribeToPersistenceStatus, subscribeToWorkspaceState, subscribeToIntegrity and onThemeChange → api.watch((grid) => grid.status.sync) (or status.persistence, status.views, status.integrity, status.theme).
• subscribeToCell, subscribeToDomainVersions and subscribeDomain left the public api: they serve adapters' renderers. To follow a cell's value, api.on('changed', …) and read it again.
• React: useGridSelector(select, equals) and useGridKeySelector(key, select, equals) → useGridWatch(select, { equals }); useGridSyncState() → useGridWatch((grid) => grid.status.sync).

One rule per action: canSort, canGroup, canSelectCopy Anchor Link

Why: a column said the same thing several ways, and some surfaces read one way and not the others.

Fix:

• sortable: false → canSort: false; sortable: true → leave it out (on by default).
• enableRowGroup: false → canGroup: false; enableRowGroup: true → leave it out.
• disableCellRangeSelection: true → canSelect: false.
• A rule that returned { allowed: false, reason } returns the reason (a string); { allowed: true } → true. A rule can also be a plain value: canEdit: false, canExport: 'Kept in the app'. mode is gone.
• capabilities.canPerformAction → the rule for that action (canPaste, canFill, …).
• normalizeCapabilityResult, CAPABILITY_ALLOWED and GridCapabilityCallback are gone: ask api.can, and type a rule as GridCapability.

Actions, the palette composer and shortcuts are commandsCopy Anchor Link

Why: a behaviour had several homes: Ctrl+C, the menu's Copy and the palette each ran their own code, and only the workspace could bind keys. Every behaviour is now one command, wherever it is offered.

Fix:

• actions={[approve]} (or api.setActions) → compose={{ commands: (defaults) => [...defaults, approve] }}, with records: 'selection' on a command that acts on the selected records (the old default). GridAction is GridCommand; its run, available and message get the command's target (ids, rows, api, complete, cell, colField, …).
• api.getActions({ rowIds }) → api.getCommands({ rowIds }), and .find(…).run() → api.runCommand(id, { rowIds }). useGridActions → useGridCommands. The actionsChanged event → commandsChanged.
• The workspace's compose.palette → compose.commands: the palette lists the commands that have a group. WorkspaceCommandItem → GridCommand.
• shortcuts: { 'view:gantt': 'shift+g' } → compose that command's keys: commands: (all) => all.map((c) => (c.id === 'view:gantt' ? { ...c, keys: ['shift+g'] } : c)). A key turned off with null → drop the command, or give it keys: []. edit:undo, edit:redo and select:all are the grid's undo, redo and selectAll.
• The cell menu's actions are named by their own id (approve), not action:approve, in menus and in the bulk bar's data-control.
• The cell menu's words (messages.contextMenu.copy…) and the column menu's entry words (sort, pin, group, fields) moved to messages.commands.

Menus share one look and one set of class namesCopy Anchor Link

Why: the grid, the workspace and the sidebar draw every menu the same way.

Fix:

• Rows are .og-menu-item (a <button>, disabled with the disabled attribute), inside .og-menu, on a popover with .og-menu-surface. Labels are .og-menu-label, icons .og-menu-icon, key hints .og-menu-kbd, headings .og-menu-heading, separators .og-menu-sep, and the row under the keyboard has .og-menu-active.
• These classes are gone: .og-context-menu-item (and -icon, -label, -shortcut), .og-context-menu-divider, .og-popover-item, .og-popover-sort-section, .og-popover-divider, .og-ws-menu* and .og-sb-menu*. Point CSS and tests that used them at the new classes.
• The cell and column menus' built-in labels are sentence case: "Copy Selected Range" is now "Copy", "Sort Ascending" is "Sort ascending", "Export All as CSV" is "Export as CSV", and so on. Tests that match the old labels need the new ones, or can match by data-id (each row carries its entry's id). Translations set through messages are unchanged.

The workspace's slots are composed card and header partsCopy Anchor Link

Why: a card's and a group header's parts are declared and composed like every other workspace part, so your content can go anywhere among them, and built-in parts can be dropped or moved. slots, WorkspaceSlots, WorkspaceSlotGroup and SlotContent are removed (the group is now WorkspaceGroup, the content PartContent). slots was only in pre-release builds of next.

Fix:

• slots.cardFooter: { height, render } → compose.card: (parts) => [...parts, { id: 'footer', height, render }].
• slots.groupHeader: (group, reader) => … → compose.groupHeader: (parts) => [...parts, { id: 'mine', render: (group, reader) => … }].

The cell context menu is changed through the grid's compose onlyCopy Anchor Link

Why: every menu the grid draws is composed one way, in one place: the grid's compose.menu, the built-in entries in, the entries to show out. contextMenuOptions (with excludeDefaults, customItems, disableDefaults and disabled), the GridContextMenuOptions and GridContextMenuItem types, and registerGridContextMenu's options argument are removed.

Fix: pass compose to the grid (<Grid compose>, createClientGrid({ compose }) or api.setCompose), and answer the cell menu where context.menu === 'cell':

• excludeDefaults: ['copy'] → menu: (entries, ctx) => ctx.menu === 'cell' ? entries.filter((e) => e === 'separator' || e.id !== 'copy') : entries.
• customItems: [item] → menu: (entries, ctx) => ctx.menu === 'cell' ? [...entries, { label, run: () => … }] : entries. An item's action(params) becomes run(), with the cell (rowId, colField, pointer, selection, api) from the context. shortcut becomes hint, variant: 'danger' becomes danger: true, hidden means leaving the entry out, and an icon is a string (an icon name, an <svg> or text).
• disableDefaults: true → return only your entries for the cell menu.
• disabled: true → enableContextMenu={false} in React, or don't call registerGridContextMenu. To leave the menu off some cells only, return [] for them: a cell whose menu is composed empty opens none.

The workspace's own summary is the bar's summary sectionCopy Anchor Link

Why: the workspace-wide summary was a second way to set the numbers the command bar's summary section shows. It is removed; the section is now in the bar's defaults in every view and the table (empty where there are no numbers) unless the view or the person hides it. It was only in pre-release builds of next.

Fix: summary: numbers → compose: { bar: (sections, { view }) => sections.map((s) => (s.id === 'summary' && !view?.summary ? { ...s, metrics: numbers } : s)) }. A view's own summary is unchanged.

Quick filter chips are composedCopy Anchor Link

Why: a quickFilters list replaced the built-in chips wholesale. compose.quickFilters gets them by id, like every other part, so you can keep some and add yours. quickFilters is now only false to turn chips off. It was only in pre-release builds of next.

Fix: quickFilters: [chip, …] → compose: { quickFilters: () => [chip, …] } (or (chips) => [...chips, chip] to keep the built-in ones).

Workspace extensions are gone: packages of composers are combinedCopy Anchor Link

Why: extensions were a second way to change the parts compose changes. Your additions are composers, and a package of them is a plain compose object; combineCompose(a, b, c) makes several into the one compose. extensions and WorkspaceExtension are removed. WorkspaceActionContext is merged into WorkspaceComposeContext, whose record(id) is now recordData(id) (the inspector's and menus' record is the record's id). Extensions were only in pre-release builds of next.

Fix: extensions: [{ id, views, toolbar, … }] and compose: mine → compose: combineCompose(package, mine), with the package's parts as composers (a package for some views only checks ctx.view):

• toolbar: [button] → bar: (sections, ctx) => [...sections, { id, row: 'toolbar', controls: [button] }]. A button's run(context, anchor) becomes run(anchor) and pressed(context) becomes pressed(), with the composer's ctx.
• commands: [command] → commands: (commands, ctx) => [...commands, { ...command, group }].
• inspectorTabs: [tab] → inspector: (tabs, ctx) => [...tabs, { id, label, render: (el) => …(ctx.record) }]. Its id is yours, no longer extension:<id>:<tab>.
• bulkActions: [action] → a command with records: 'selection' in commands, and bulkBar: (controls) => [...controls, { id, command: id }]: the same command is in the palette and on its keys.
• settings: (ctx) => [section] → customize: (sections, ctx) => [...sections, { id, ...section }].

Export and charts count every matching recordCopy Anchor Link

Why: a flat export of a paged grid wrote only the current page, and a chart over collapsed groups totalled 0: both read the rows on display.

Upgrade:

• exportCsv / exportExcel without onlySelected or rowIds now write every record that passes the filters, on every page. To export only the page on display, pass its ids: rowIds: api.records('displayed').ids.
• To total over records yourself, read api.records('matching') rather than rows().getAll(), which stays the rows on display.

The summary strip's defaults follow the record rolesCopy Anchor Link

Why: each view's default numbers assumed a project tracker.

Upgrade: a board shows Active and Blocked only when the records have progress, dates or dependencies; a gallery shows Average progress only with a progress field. To keep a card the defaults no longer show, declare it in summary ({ label: 'Blocked', fn: 'blocked' }), or add it to the default summary section in compose.bar.

Conflicts: one list on the gridCopy Anchor Link

Why: conflicts lived in the data-integrity conflict module (only when dataIntegrity.conflicts was set) and offline kept its own; there were two resolve APIs with different shapes.

Upgrade:

• api.integrity.getConflicts() / resolveConflict() / clearConflict() → api.getConflicts() / api.resolveConflict() / api.clearConflict(). They work without dataIntegrity.
• resolveConflict(id, { strategy: 'local' }) → resolveConflict(id, 'local'); { strategy: 'custom', value } → { value }. The result no longer has a blocked status.
• Remove dataIntegrity.conflicts (and its validateBeforeResolve / checkCapabilitiesBeforeResolve): conflicts are always on, and a resolution is checked like any edit (capabilities, and validation per your validateOnSubmit setting).
• GridCellConflict has a required shows: 'local' | 'remote' (the side the cell shows).
• api.integrity.clearIssues() no longer clears conflicts; use api.clearConflict(id).

Cell writes: one preparation for every surfaceCopy Anchor Link

Why: a field's setter and rules ran differently depending on where it was written (an edit awaited the setter and checked its result; a transaction checked the raw value, then ran the setter unawaited).

Upgrade:

• A sync transaction (or setCellValue) writing through a value setter or blocking rule that returns a promise is now rejected with needsAsync: true. Write it with transaction(tx, { async: true }).
• Row rules receive the whole proposed record: a rule that only held because it saw the old values of the other fields may now report.
• Workspace gestures are all or nothing: a move whose cells the user cannot all change moves nothing (bulk actions still apply to the records they can).

Views: records are the query's, not the table's displayCopy Anchor Link

Why: a board or calendar lost records when the table collapsed a group or turned a page.

Upgrade:

• The client row model's getFilteredDataNodes() now returns every record passing the filters, in sort order, whatever is expanded or paged (it returned the displayed rows). getCurrentPageDataNodes() returns the displayed records. The data-integrity filteredRows scope follows.
• Views of your own: WorkspaceViewContext.rows() returns the matching records, position(id) is a record's place among them, and completeness() says 'loaded' for server and infinite models.

Translating: offline's words move to the gridCopy Anchor Link

Why: the grid has one messages table now; offline had its own.

Upgrade:

• offline({ name, messages: { saved: '…' } }) → <Grid messages={{ sync: { saved: '…' } }}> (or createGrid({ messages: { sync: … } })).
• Custom filter editors receive params.messages (the grid's words); nothing to change unless you build DomFilterEditorParams yourself, where it is optional.

Offline and sync: new API members and union membersCopy Anchor Link

Why: offline grids (see Offline and Sync) added to types that apps may implement or switch over exhaustively. Nothing changes for a grid that does not use offline.

Upgrade:

• GridApi has seven new members (getSyncState, subscribeToSyncState, syncNow, getPendingChanges, discardPendingChanges, clearOfflineData). A hand-written mock or wrapper typed as GridApi needs them; without offline, getSyncState() returns null and the others do nothing.
• GridClientProps (React) is now a type alias, a union of "with offline" and "without": interface X extends GridClientProps becomes type X = GridClientProps & { … }.
• New union members: GridTransaction['origin'] adds 'server'; GridConflictSource adds 'sync'; GridInsightLayerId adds 'sync'; RuntimeFaultSource adds 'offline'; GridEventName adds syncStateChanged, changesSynced, changesRejected. Exhaustive switch statements over them need the case.

React: live props apply when their content changesCopy Anchor Link

Why: <Grid> applied styleRules, view, rowAnimation and the other live props whenever their identity changed, so props written inline were applied again, and the grid repainted, on every parent render.

What changed: a live prop is applied when its content changes (plain data by value, functions by identity), during React's commit. A view written inline with the same content is no longer applied again, so a view the person picked inside the grid stays after the parent re-renders.

Fix: to put the grid back on a view, pass a different value, or control it with view and onViewChange.

Data changes: one changed event replaces cellValueChanged and rowsUpdatedCopy Anchor Link

Why: a commit could raise several events, or none (row transactions, server loads), and listeners had to piece together what happened. Each commit now carries one change set.

What changed: GridEventName.cellValueChanged and GridEventName.rowsUpdated are removed. GridEventName.changed delivers GridChanges: added, removed and updated rows (each update with its fields' oldValue and newValue), derived cells, changed config inputs, origin (local, remote, undo, redo, server) and source. The React prop onCellValueChanged is now onChanged. globalVersion is no longer part of the state snapshot.

Fix: listen to changed. For the old per-cell callback, walk the cells with forEachCellChange(changes, (rowId, field, change) => …). Code that watched globalVersion to learn that rows changed should listen to changed too.

Aggregates follow one rule everywhereCopy Anchor Link

Why: grouped grids, totals and pivots counted some values differently.

What changed:

• A value counts as a number when it is a finite number or text that reads as one. This applies to grid aggregation (sum, avg, min, max) as it already did to pivots.
• distinctCount skips blanks.
• A pivot's median skips blanks; it used to read them as 0.
• A pivot's first, last and custom functions read a cell's records in source order at every level. A parent row used to take its last child group's last record.
• In tree data, a row whose parent is missing or whose parent chain loops is a root, in source order. Orphans used to follow the roots, and rows on a cycle disappeared.
• A query model on tree data follows the tree's filterMode.

Fix: none needed unless a test or report depended on the old numbers.

Every cell is final in every frame: renderer scroll options removedCopy Anchor Link

Why: cells used to show stand-in text, a frozen previous row or a '...' placeholder while the grid scrolled, and were repaired after the scroll ended. The renderer now prepares each cell's content ahead of time and draws every cell final in the frame that shows it, so there is nothing to choose.

What changed: capabilities on a column's renderer (scroll, scrollText, scrollState) and rendererOptions.live and rendererOptions.fullWidth are removed, with the CellRendererCapabilities and CellScrollPresentation types. The renderer phases 'scroll-live', 'scroll-force-live' and 'scroll-idle' are gone; a renderer sees 'initial', 'scroll', 'edit', 'interaction' or 'destroy'. Render stats lost the counters of the removed machinery (stand-ins, post-scroll repair, deferred portal work, prewarm, budgets) and gained cellViewsPrepared and preparedRows.

Fix: delete capabilities from renderer specs and live / fullWidth from rendererOptions. A renderer that drew differently while scrolling (scrollState) should draw the same content always.

Renderer scroll options: text or live (superseded by the change above)Copy Anchor Link

Why: six scroll presentation modes, each with its own sub-options, were more than anyone needed. Every custom renderer now picks between stand-in text and the real renderer during scroll.

What changed: capabilities.scrollPresentation, live, textImpostor and htmlSnapshot are replaced by scroll: 'text' | 'live' and scrollText. rendererOptions.domUpdate, liveReact, htmlSnapshot and textImpostor are replaced by rendererOptions.live. Imperative React updates are declared with kind: 'imperativeReact' instead of live.update: 'imperative'. HTML snapshots are removed.

Fix: use the replacements listed in the Changelog and Renderer Capabilities.

One data-write API: transactionCopy Anchor Link

Why: rows and cells used to be written through separate methods, each with its own undo entry, result shape and async variant. api.transaction() covers them all, atomically.

What changed: applyTransaction, applyTransactionAsync, flushAsyncTransactions, batchCellValues, batchCellValuesAsync, setCellValueAsync and updateRows are removed, as are the rowTransaction and full rows fields of transaction(). The type BatchCellValueUpdate is now GridCellWrite.

Fix: use the replacements listed in the Changelog and Transactions. The row nodes of a transaction are now at result.rows, and result is never null.

Text-only cells no longer contain .og-cell-contentCopy Anchor Link

Why: a cell of a column with no custom renderer only ever shows text, so its content wrapper was one more element to style and lay out per cell. Such cells now hold their text directly and carry a data-text-cell attribute. Cells of columns with a custom renderer, and the row-selection checkbox column, keep the wrapper.

Before:

.my-grid .og-cell-content {
	font-variant-numeric: tabular-nums;
}

After: style the cell itself; it applies to both kinds of cell.

.my-grid .og-cell {
	font-variant-numeric: tabular-nums;
}

.og-cell-portal-host no longer has a boxCopy Anchor Link

Why: the host only anchors renderer containers in the DOM; as a flex box of its own it was one more container per custom-renderer cell for every layout to walk through. It is now display: contents, so size, padding, background or border set on it no longer apply.

After: style the renderer's container (.og-custom-renderer-container for React renderers, .og-dom-renderer-container for DOM renderers), or the cell.

Cutting a releaseCopy Anchor Link

When a release is cut, maintainers run pnpm --filter wit-grid-site docs:release:from-package — it reads the version from packages/react/package.json, snapshots next into a fixed version directory named after the major.minor, and updates the version switcher automatically. See Docs Architecture for the full mechanics. After cutting a release, start a fresh, empty "unreleased" section here.