@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/core/createMethodStubs.js

@@ -0,0 +1,30 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function noop() {
+    return undefined;
+}
+// The stand-in for an optional feature a table does not load: its block methods as no-ops (a
+// table without groupable columns has no groups to set, expand or collapse; client data has
+// nothing to refresh), so a CallMethod on any declared method succeeds.
+function createMethodStubs(entry) {
+    return {
+        name: entry.name,
+        methods: Object.fromEntries(entry.methods.map((method)=>[
+                method,
+                ()=>noop
+            ]))
+    };
+}
+export default createMethodStubs;

package/dist/core/createSliceHandlers.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // TanStack's controlled-state callbacks (onSortingChange, onColumnSizingChange, ...), each routed
+// through updateSlice so a feature API call (column.toggleSorting, row.toggleSelected) commits the
+// same way a Lowdefy-side update does.
+function createSliceHandlers({ sliceDefinitions, updateSlice }) {
+    const handlers = {};
+    Object.keys(sliceDefinitions).forEach((name)=>{
+        const option = `on${name.charAt(0).toUpperCase()}${name.slice(1)}Change`;
+        handlers[option] = (updater)=>updateSlice(name, updater);
+    });
+    return handlers;
+}
+export default createSliceHandlers;

package/dist/core/createStableCoreRowModel.js

@@ -0,0 +1,91 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { constructRow, makeObjectMap, tableMemo } from '@tanstack/react-table';
+function buildRowModel({ table, data, previous }) {
+    const rows = new Array(data.length);
+    const rowsById = makeObjectMap();
+    for(let i = 0; i < data.length; i++){
+        const original = data[i];
+        const id = table.getRowId(original, i);
+        const prior = previous?.rowsById[id];
+        const row = prior !== undefined && prior.original === original && prior.index === i ? prior : constructRow(table, id, original, i, 0);
+        rows[i] = row;
+        rowsById[id] = row;
+    }
+    return {
+        rows,
+        flatRows: rows,
+        rowsById
+    };
+}
+// Same rows in the same places with a few row objects replaced: patch those rows and the id
+// index instead of rebuilding either. Returns null when rows moved, arrived or left.
+function patchRowModel({ table, data, previous }) {
+    if (!previous || previous.rows.length !== data.length) return null;
+    let rows = null;
+    const replaced = [];
+    for(let i = 0; i < data.length; i++){
+        const prior = previous.rows[i];
+        const original = data[i];
+        if (prior.original === original) continue;
+        const id = table.getRowId(original, i);
+        if (id !== prior.id) return null;
+        if (rows === null) rows = previous.rows.slice();
+        rows[i] = constructRow(table, id, original, i, 0);
+        replaced.push(rows[i]);
+    }
+    if (rows === null) return previous;
+    // The previous model is never read again, so its id index is patched in place.
+    replaced.forEach((row)=>{
+        previous.rowsById[row.id] = row;
+    });
+    return {
+        rows,
+        flatRows: rows,
+        rowsById: previous.rowsById
+    };
+}
+// Replaces TanStack's core row model for flat data. A row whose object and index are unchanged
+// keeps its TanStack Row instance (and its value caches), so updating one row of 100k patches one
+// row instead of rebuilding 100k Row objects and a 100k-key id index (D10 row-update). Data
+// changes never auto-reset table state here: the Lowdefy table owns sorting, selection and
+// expansion through its value.
+function createStableCoreRowModel() {
+    return function getCoreRowModel(table) {
+        let previous = null;
+        return tableMemo({
+            feature: 'coreRowModelsFeature',
+            table,
+            fnName: 'table.getCoreRowModel',
+            memoDeps: ()=>[
+                    table.options.data
+                ],
+            fn: ()=>{
+                const data = table.options.data;
+                previous = patchRowModel({
+                    table,
+                    data,
+                    previous
+                }) ?? buildRowModel({
+                    table,
+                    data,
+                    previous
+                });
+                return previous;
+            }
+        });
+    };
+}
+export default createStableCoreRowModel;

package/dist/core/createTanstackFeatures.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { tableFeatures } from '@tanstack/react-table';
+import createStableCoreRowModel from './createStableCoreRowModel.js';
+// The TanStack feature set merged from the feature modules' slots. TanStack requires `features`
+// to be stable, so it is built once per feature set (createFeatureSet).
+function createTanstackFeatures(features) {
+    return tableFeatures(Object.assign({
+        coreRowModel: createStableCoreRowModel()
+    }, ...features.map((feature)=>feature.tableFeatures ?? {})));
+}
+export default createTanstackFeatures;

package/dist/core/createTextMeasure.js

@@ -0,0 +1,106 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function toPx(value) {
+    return Number.parseFloat(value) || 0;
+}
+function toFont(style) {
+    return `${style.fontStyle} ${style.fontWeight} ${style.fontSize} ${style.fontFamily}`;
+}
+// Reads the chip, count, summary and cell styles once from a hidden copy of the markup, so the
+// widths follow the theme's tokens (font, padding, border, gap) without measuring any rendered
+// cell.
+function readStyles() {
+    const probe = document.createElement('div');
+    probe.className = 'lf-table';
+    probe.setAttribute('aria-hidden', 'true');
+    probe.style.cssText = 'position:absolute;top:0;left:-10000px;visibility:hidden;contain:strict';
+    probe.innerHTML = '<div class="lf-table-gridcell"><span class="lf-table-chips">' + '<span class="lf-table-tag">x</span><span class="lf-table-more">+1</span></span>' + '<span class="lf-table-summary"><span class="lf-table-summary-label">x</span>' + '<span class="lf-table-summary-value">x</span></span></div>';
+    document.body.appendChild(probe);
+    const cell = getComputedStyle(probe.firstChild);
+    const chips = getComputedStyle(probe.querySelector('.lf-table-chips'));
+    const tag = getComputedStyle(probe.querySelector('.lf-table-tag'));
+    const more = getComputedStyle(probe.querySelector('.lf-table-more'));
+    const summary = getComputedStyle(probe.querySelector('.lf-table-summary'));
+    const styles = {
+        cellInset: toPx(cell.paddingLeft) + toPx(cell.paddingRight),
+        gap: toPx(chips.columnGap),
+        iconWidth: toPx(tag.fontSize) + toPx(tag.columnGap),
+        moreFont: toFont(more),
+        summaryGap: toPx(summary.columnGap),
+        summaryLabelFont: toFont(getComputedStyle(probe.querySelector('.lf-table-summary-label'))),
+        summaryValueFont: toFont(getComputedStyle(probe.querySelector('.lf-table-summary-value'))),
+        tagFont: toFont(tag),
+        tagInset: toPx(tag.paddingLeft) + toPx(tag.paddingRight) + toPx(tag.borderLeftWidth) + toPx(tag.borderRightWidth)
+    };
+    probe.remove();
+    return styles;
+}
+// Text widths for fitting cells to their column without DOM reads: tag chips and their +N count
+// (the shared TagCell's `fit`) and the summary footer's label and value (SummaryRow). Text
+// widths come from a canvas and are cached by text, so a cell costs a few Map reads, and the
+// styles are read once per table on first use. Widths round up by a pixel so a measured item
+// never ends up a fraction wider than its room.
+function createTextMeasure() {
+    let styles = null;
+    let context = null;
+    const cache = new Map();
+    function init() {
+        styles = readStyles();
+        context = document.createElement('canvas').getContext('2d');
+    }
+    function textWidth(font, text) {
+        const key = `${font}\n${text}`;
+        let width = cache.get(key);
+        if (width === undefined) {
+            context.font = font;
+            width = context.measureText(text).width;
+            cache.set(key, width);
+        }
+        return width;
+    }
+    const measure = {
+        get cellInset () {
+            if (styles === null) init();
+            return styles.cellInset;
+        },
+        get gap () {
+            if (styles === null) init();
+            return styles.gap;
+        },
+        tag ({ label, icon }) {
+            if (styles === null) init();
+            const iconWidth = icon ? styles.iconWidth : 0;
+            return Math.ceil(textWidth(styles.tagFont, label) + styles.tagInset + iconWidth) + 1;
+        },
+        more (text) {
+            if (styles === null) init();
+            return Math.ceil(textWidth(styles.moreFont, text)) + 1;
+        },
+        get summaryGap () {
+            if (styles === null) init();
+            return styles.summaryGap;
+        },
+        summaryLabel (text) {
+            if (styles === null) init();
+            return Math.ceil(textWidth(styles.summaryLabelFont, text)) + 1;
+        },
+        summaryValue (text) {
+            if (styles === null) init();
+            return Math.ceil(textWidth(styles.summaryValueFont, text)) + 1;
+        }
+    };
+    return measure;
+}
+export default createTextMeasure;

package/dist/core/densityHeights.js

@@ -0,0 +1,20 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ const densityHeights = {
+    compact: 32,
+    default: 40,
+    comfortable: 52
+};
+export default densityHeights;

package/dist/core/deriveValue.js

@@ -0,0 +1,53 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import isDefaultViewColumns from './isDefaultViewColumns.js';
+// The block value is derived from table state, never kept alongside it.
+function deriveValue({ state, api }) {
+    const entries = state.columnOrder.map((key)=>Object.assign({
+            key
+        }, ...api.features.list.map((feature)=>feature.toViewColumn?.({
+                key,
+                state,
+                api
+            }) ?? {})));
+    const view = {
+        ...state.viewPassthrough
+    };
+    if (!isDefaultViewColumns({
+        entries,
+        config: api.config
+    })) view.columns = entries;
+    const value = {
+        view,
+        selected: [],
+        expanded: state.expanded
+    };
+    api.features.list.forEach((feature)=>{
+        const part = feature.toValue?.({
+            state,
+            api
+        });
+        if (!part) return;
+        Object.entries(part).forEach(([key, partValue])=>{
+            if (key === 'view') {
+                Object.assign(view, partValue);
+            } else {
+                value[key] = partValue;
+            }
+        });
+    });
+    return value;
+}
+export default deriveValue;

package/dist/core/dispatchGridEvent.js

@@ -0,0 +1,21 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function dispatchGridEvent({ api, event, eventType }) {
+    const handlers = api.features.gridHandlers[eventType] ?? [];
+    for(let i = 0; i < handlers.length; i++){
+        if (handlers[i](event, api) === true) return;
+    }
+}
+export default dispatchGridEvent;

package/dist/core/distributeFlex.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Spreads spare viewport width over `flex` columns the user has not resized, by flex weight.
+function distributeFlex({ cols, viewportWidth, sizing }) {
+    const total = cols.reduce((sum, col)=>sum + col.width, 0);
+    const spare = viewportWidth - total;
+    if (spare <= 0) return;
+    const flexCols = cols.filter((col)=>!col.special && col.column.flex > 0 && sizing[col.key] === undefined);
+    const weight = flexCols.reduce((sum, col)=>sum + col.column.flex, 0);
+    if (weight === 0) return;
+    flexCols.forEach((col)=>{
+        const grown = col.width + Math.floor(spare * col.column.flex / weight);
+        col.width = Math.min(col.maxWidth, grown);
+    });
+}
+export default distributeFlex;

package/dist/core/getCellFit.js

@@ -0,0 +1,34 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+const CHIP_TYPES = new Set([
+    'tag',
+    'tags'
+]);
+// The shared renderer's `fit` for a cell: chip cells (`tag`, `tags`) on one line get their
+// content width (the layout column's width less the cell padding), so they show only the chips
+// that fit whole and a +N count. Cells with a lead (tree indent, expand chevron) or on wrapped or
+// multi-line layouts show every chip, as the renderer does without `fit`.
+function getCellFit({ api, col, lead }) {
+    const { column } = col;
+    if (!CHIP_TYPES.has(column.type) || !type.isNone(lead)) return undefined;
+    if (column.wrap || type.isInt(column.ellipsis) && column.ellipsis > 1) return undefined;
+    const measure = api.textMeasure;
+    return {
+        width: col.width - measure.cellInset,
+        measure
+    };
+}
+export default getCellFit;

package/dist/core/getHeaderCellProps.js

@@ -0,0 +1,21 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function getHeaderCellProps({ col, features, state }) {
+    return Object.assign({}, ...features.map((feature)=>feature.headerCellProps?.({
+            col,
+            state
+        }) ?? {}));
+}
+export default getHeaderCellProps;

package/dist/core/getHeaderLevels.js

@@ -0,0 +1,50 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function walk({ nodes, ancestors, ancestorsByKey }) {
+    let depth = ancestors.length;
+    nodes.forEach((node)=>{
+        if (node.group === true) {
+            const childDepth = walk({
+                nodes: node.children,
+                ancestors: [
+                    ...ancestors,
+                    node
+                ],
+                ancestorsByKey
+            });
+            depth = Math.max(depth, childDepth);
+            return;
+        }
+        ancestorsByKey.set(node.key, ancestors);
+    });
+    return depth;
+}
+// The header group rows above the leaf headers, from normalizeColumns' header tree: `depth` is
+// the number of group rows, and `ancestorsByKey` maps each leaf column key to its group nodes,
+// outermost first. Groups render from the current column layout, so a group whose columns were
+// reordered apart renders as one cell per run of adjacent columns.
+function getHeaderLevels({ headerGroups }) {
+    const ancestorsByKey = new Map();
+    const depth = walk({
+        nodes: headerGroups,
+        ancestors: [],
+        ancestorsByKey
+    });
+    return {
+        depth,
+        ancestorsByKey
+    };
+}
+export default getHeaderLevels;

package/dist/core/getRecordCount.js

@@ -0,0 +1,23 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+// The rows the view matches: the server's `total` when the data source reports one (server
+// mode), else the filtered rows (every page, rows in collapsed groups and collapsed tree rows
+// included).
+function getRecordCount({ api }) {
+    if (type.isNumber(api.total)) return api.total;
+    return api.table.getFilteredRowModel().rows.length;
+}
+export default getRecordCount;

package/dist/core/getSummaryLabel.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import AGGREGATE_LABELS from '@lowdefy/blocks-antd/table/aggregateLabels.js';
+import AGGREGATE_SHORT_LABELS from './aggregateShortLabels.js';
+// What a value wider than its cell keeps beside a short label: it ends with an ellipsis anyway,
+// and a few characters of it with the label say more than more characters without.
+const MIN_VALUE_WIDTH = 28;
+// The label a summary cell shows next to its value in `width`: the full label when it fits with
+// the whole value, else the short form (Σ, Avg, ...) when that fits with the whole value. A label
+// never makes a value that fits end with an ellipsis: without room for either, a value that fits
+// shows alone, and a value too wide for the cell anyway keeps the short label beside its start.
+// The cell's title always holds the full label and value.
+function getSummaryLabel({ fn, measure, text, width }) {
+    const value = measure.summaryValue(text);
+    const full = AGGREGATE_LABELS[fn];
+    if (value + measure.summaryGap + measure.summaryLabel(full) <= width) return full;
+    const short = AGGREGATE_SHORT_LABELS[fn] ?? full;
+    const room = width - measure.summaryGap - measure.summaryLabel(short);
+    if (value <= room) return short;
+    if (value > width && room >= MIN_VALUE_WIDTH) return short;
+    return null;
+}
+export default getSummaryLabel;

package/dist/core/getValueSignature.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // SetState on a path inside the value (`deals.view.sort`, `deals.selected`) mutates the object the
+// table wrote, so identity alone cannot tell an external change from the table's own write. The
+// view is small and compared by JSON; `selected` and `expanded` can be large and are compared by
+// identity, which a SetState on them always changes.
+function getValueSignature(value) {
+    return {
+        view: JSON.stringify(value?.view ?? null),
+        selected: value?.selected,
+        expanded: value?.expanded
+    };
+}
+export default getValueSignature;

package/dist/core/isDataItem.js

@@ -0,0 +1,21 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // A display-list entry that is a data row: a TanStack row, or a wrapped row item (`kind: 'row'`,
+// a tree row or an expandable row). Group headers, detail rows and the `undefined` holes of rows
+// a server table has not loaded yet are not.
+function isDataItem(item) {
+    return item !== undefined && (item.kind ?? 'row') === 'row';
+}
+export default isDataItem;

package/dist/core/isDefaultViewColumns.js

@@ -0,0 +1,36 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import resolveViewColumns from './resolveViewColumns.js';
+function comparable(entry) {
+    return [
+        entry.key,
+        entry.width ?? null,
+        entry.pinned ?? null,
+        entry.hidden === true
+    ];
+}
+// A view whose columns still match the configured layout leaves `columns` out, so it keeps
+// following config: a column added to config later (or `columns` loaded from a request) shows
+// up, instead of being appended hidden as it is for a layout the user changed.
+function isDefaultViewColumns({ entries, config }) {
+    const defaults = resolveViewColumns({
+        value: null,
+        defaultView: config.defaultView,
+        columns: config.columns
+    });
+    if (defaults.length !== entries.length) return false;
+    return JSON.stringify(entries.map(comparable)) === JSON.stringify(defaults.map(comparable));
+}
+export default isDefaultViewColumns;