@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/core/collectCellLeads.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.
+*/ // Components rendered at the start of a row's first data cell, before its content (the tree
+// indent and chevron, the expandable-row chevron), from the features' `cellLead`. Each receives
+// `{ api, item }` for wrapped row items and returns null when it has nothing to show.
+function collectCellLeads(features) {
+    return features.map((feature)=>feature.cellLead).filter(Boolean);
+}
+export default collectCellLeads;

package/dist/core/collectClaimedViewKeys.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.
+*/ // View keys with an owner. `columns` belongs to the core; the rest of the view (filter, search,
+// ...) passes through unchanged until a feature module claims it.
+function collectClaimedViewKeys(features) {
+    const keys = new Set([
+        'columns'
+    ]);
+    features.forEach((feature)=>{
+        (feature.viewKeys ?? []).forEach((key)=>keys.add(key));
+    });
+    return keys;
+}
+export default collectClaimedViewKeys;

package/dist/core/collectGridHandlers.js

@@ -0,0 +1,29 @@
+/*
+  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.
+*/ // Every delegated handler, by DOM event type, in feature order. The grid root carries one React
+// listener per event type (D5); a handler that returns true stops the chain.
+function collectGridHandlers(features) {
+    const handlers = {};
+    features.forEach((feature)=>{
+        Object.entries(feature.gridHandlers ?? {}).forEach(([eventType, handler])=>{
+            handlers[eventType] = [
+                ...handlers[eventType] ?? [],
+                handler
+            ];
+        });
+    });
+    return handlers;
+}
+export default collectGridHandlers;

package/dist/core/collectHeaderParts.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.
+*/ // Components rendered inside every data header cell (filter indicator, menu button, sort
+// indicator, resize handle), in feature order. Each receives `{ api, col, focused, state }`.
+function collectHeaderParts(features) {
+    return features.flatMap((feature)=>feature.headerParts ?? []);
+}
+export default collectHeaderParts;

package/dist/core/collectRowRenderers.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.
+*/ // Components for display items that are not data rows, by item kind (grouping and server groups:
+// `group`; expandable: `detail`), from the features' `rowRenderers`. Data rows (TanStack rows and
+// wrapped `kind: 'row'` items) render with the core Row.
+function collectRowRenderers(features) {
+    return Object.assign({}, ...features.map((feature)=>feature.rowRenderers ?? {}));
+}
+export default collectRowRenderers;

package/dist/core/collectSliceDefinitions.js

@@ -0,0 +1,29 @@
+/*
+  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.
+*/ // Every state slice the features declare, by name. Slices are React-owned (controlled TanStack
+// state), which is what lets a slice update run inside a transition.
+function collectSliceDefinitions(features) {
+    const definitions = {};
+    features.forEach((feature)=>{
+        Object.entries(feature.slices ?? {}).forEach(([name, definition])=>{
+            definitions[name] = {
+                ...definition,
+                feature: feature.name
+            };
+        });
+    });
+    return definitions;
+}
+export default collectSliceDefinitions;

package/dist/core/computeLayout.js

@@ -0,0 +1,133 @@
+/*
+  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 distributeFlex from './distributeFlex.js';
+import getViewWrapColumn from '../features/density/getViewWrapColumn.js';
+function fromTanstackColumn({ column, region, widths, wrap }) {
+    const { meta } = column.columnDef;
+    return {
+        key: column.id,
+        region,
+        column: wrap ? getViewWrapColumn(meta.column) : meta.column,
+        accessor: meta.accessor,
+        width: widths?.[column.id] ?? column.getSize(),
+        minWidth: column.columnDef.minSize,
+        maxWidth: column.columnDef.maxSize
+    };
+}
+// The column geometry every row shares: visual order (start-pinned, centre, end-pinned), widths,
+// sticky offsets, centre prefix offsets for column virtualisation, and the CSS variables that
+// carry widths and offsets. `widths` overrides column sizes (a resize drag in progress); `wrap` is
+// the view's wrap.
+function computeLayout({ table, leadingColumns, viewportWidth, widths, wrap = false }) {
+    const start = [
+        ...leadingColumns.map((leading)=>({
+                ...leading,
+                region: 'start',
+                minWidth: leading.width,
+                maxWidth: leading.width
+            })),
+        ...table.getStartVisibleLeafColumns().map((column)=>fromTanstackColumn({
+                column,
+                region: 'start',
+                widths,
+                wrap
+            }))
+    ];
+    const center = table.getCenterVisibleLeafColumns().map((column)=>fromTanstackColumn({
+            column,
+            region: 'center',
+            widths,
+            wrap
+        }));
+    const end = table.getEndVisibleLeafColumns().map((column)=>fromTanstackColumn({
+            column,
+            region: 'end',
+            widths,
+            wrap
+        }));
+    const cols = [
+        ...start,
+        ...center,
+        ...end
+    ];
+    const sizing = {
+        ...table.atoms.columnSizing.get(),
+        ...widths
+    };
+    distributeFlex({
+        cols,
+        viewportWidth,
+        sizing
+    });
+    const vars = {};
+    const byKey = new Map();
+    let startWidth = 0;
+    start.forEach((col)=>{
+        col.left = startWidth;
+        startWidth += col.width;
+    });
+    let endWidth = 0;
+    for(let i = end.length - 1; i >= 0; i--){
+        end[i].right = endWidth;
+        endWidth += end[i].width;
+    }
+    const centerStarts = new Float64Array(center.length);
+    const centerEnds = new Float64Array(center.length);
+    let centerWidth = 0;
+    center.forEach((col, i)=>{
+        col.centerStart = centerWidth;
+        centerStarts[i] = centerWidth;
+        centerWidth += col.width;
+        centerEnds[i] = centerWidth;
+    });
+    cols.forEach((col, index)=>{
+        col.index = index;
+        col.ariaIndex = index + 1;
+        vars[`--lf-w${index}`] = `${col.width}px`;
+        const style = {
+            width: `var(--lf-w${index})`
+        };
+        if (col.region === 'start') {
+            vars[`--lf-l${index}`] = `${col.left}px`;
+            style.left = `var(--lf-l${index})`;
+        }
+        if (col.region === 'end') {
+            vars[`--lf-r${index}`] = `${col.right}px`;
+            style.right = `var(--lf-r${index})`;
+        }
+        col.style = style;
+        byKey.set(col.key, col);
+    });
+    if (start.length) start[start.length - 1].pinnedEdge = true;
+    if (end.length) end[0].pinnedEdge = true;
+    const totalWidth = startWidth + centerWidth + endWidth;
+    vars['--lf-total'] = `${totalWidth}px`;
+    vars['--lf-center-w'] = `${centerWidth}px`;
+    return {
+        byKey,
+        center,
+        centerEnds,
+        centerStarts,
+        centerWidth,
+        cols,
+        end,
+        endWidth,
+        start,
+        startWidth,
+        totalWidth,
+        vars
+    };
+}
+export default computeLayout;

package/dist/core/createAccessor.js

@@ -0,0 +1,39 @@
+/*
+  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';
+// Compiled once per column: cells and sort keys read values through this instead of `get`,
+// which would split the path on every call.
+function createAccessor(field) {
+    if (!type.isString(field)) {
+        return function accessUndefined() {
+            return undefined;
+        };
+    }
+    if (!field.includes('.')) {
+        return function accessField(row) {
+            return row?.[field];
+        };
+    }
+    const parts = field.split('.');
+    return function accessPath(row) {
+        let current = row;
+        for(let i = 0; i < parts.length; i++){
+            if (type.isNone(current)) return undefined;
+            current = current[parts[i]];
+        }
+        return current;
+    };
+}
+export default createAccessor;

package/dist/core/createApi.js

@@ -0,0 +1,86 @@
+/*
+  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 createCellActivity from './createCellActivity.js';
+import createTextMeasure from './createTextMeasure.js';
+import createInitialState from './createInitialState.js';
+import deriveValue from './deriveValue.js';
+// The table's per-instance API object: one stable mutable object that the core refreshes on every
+// render (table, config, state, layout, ...), so delegated event handlers, actions and methods
+// always read current values without being recreated.
+function createApi({ features }) {
+    const api = {
+        actions: {},
+        cellActivity: createCellActivity(),
+        features,
+        foreignKeys: new Map(),
+        rootRef: {
+            current: null
+        },
+        scrollerRef: {
+            current: null
+        },
+        // Row ids (to raw keys) left out of an `{ all: true, except }` selection, kept while their
+        // rows are not loaded (server mode).
+        selectionExcept: new Map(),
+        suppressedClick: false,
+        textMeasure: createTextMeasure()
+    };
+    // Cell renderers build the full event payload (row, rowKey, ...); one stable function keeps
+    // the memoised cells from re-rendering when the block's methods object changes. Row button and
+    // menu events also go to afterRowAction (`keyboard.next`).
+    api.onCellEvent = ({ name, event })=>{
+        const result = api.methods.triggerEvent({
+            name,
+            event
+        });
+        if (event.button || event.item) {
+            api.actions.afterRowAction({
+                id: api.config.getId(event.row),
+                result
+            });
+        }
+        return result;
+    };
+    api.contains = (element)=>Boolean(api.rootRef.current?.contains(element));
+    // The block value of the current state, and of any value once the fallback rules are applied
+    // (a saved view resolves to the view the table would write after loading it).
+    api.getValue = ()=>deriveValue({
+            state: api.state,
+            api
+        });
+    api.resolveValue = (value)=>deriveValue({
+            state: createInitialState({
+                value,
+                config: api.config,
+                features: api.features,
+                rows: []
+            }),
+            api
+        });
+    api.suppressClick = ()=>{
+        api.suppressedClick = true;
+        // A drag that ends outside the header produces no click; do not swallow the next one.
+        setTimeout(()=>{
+            api.suppressedClick = false;
+        }, 0);
+    };
+    api.takeSuppressedClick = ()=>{
+        const suppressed = api.suppressedClick;
+        api.suppressedClick = false;
+        return suppressed;
+    };
+    return api;
+}
+export default createApi;

package/dist/core/createCellActivity.js

@@ -0,0 +1,47 @@
+/*
+  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.
+*/ // Which rows may mount their tier-1 cells (D4, D10.4): the hovered row, the row holding focus, and
+// whether the grid is scrolling fast. A small external store, so a change re-renders only the lazy
+// cells whose answer changes, never the rows or the grid.
+function createCellActivity() {
+    const listeners = new Set();
+    const state = {
+        focusedRow: null,
+        hoveredRow: null,
+        fastScrolling: false
+    };
+    // Devices without hover show `showOn: hover` buttons all the time (see tableCells.css).
+    const noHover = typeof window !== 'undefined' && window.matchMedia?.('(hover: none)').matches === true;
+    function set(partial) {
+        let changed = false;
+        Object.entries(partial).forEach(([key, value])=>{
+            if (state[key] === value) return;
+            state[key] = value;
+            changed = true;
+        });
+        if (changed) listeners.forEach((listener)=>listener());
+    }
+    function subscribe(listener) {
+        listeners.add(listener);
+        return ()=>listeners.delete(listener);
+    }
+    return {
+        noHover,
+        set,
+        state,
+        subscribe
+    };
+}
+export default createCellActivity;

package/dist/core/createColumnDefs.js

@@ -0,0 +1,42 @@
+/*
+  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 createSortKeyGetter from '@lowdefy/blocks-antd/table/createSortKeyGetter.js';
+import createAccessor from './createAccessor.js';
+const DEFAULT_WIDTH = 160;
+const MIN_WIDTH = 48;
+const MAX_WIDTH = 2000;
+// Compiled once per column config change, with stable accessor and sort key identities (D10.5):
+// cells and sort keys never rebuild them per row. `getSortKey` is the shared column core's, so
+// the index sort orders rows exactly as the shared comparator (and TableLight) would.
+function createColumnDefs({ columns }) {
+    return columns.map((column)=>({
+            id: column.key,
+            accessorFn: createAccessor(column.field),
+            header: column.title,
+            size: column.width ?? DEFAULT_WIDTH,
+            minSize: column.minWidth ?? MIN_WIDTH,
+            maxSize: column.maxWidth ?? MAX_WIDTH,
+            enableSorting: column.sortable,
+            sortDescFirst: false,
+            meta: {
+                column,
+                accessor: createAccessor(column.field),
+                getSortKey: createSortKeyGetter({
+                    column
+                })
+            }
+        }));
+}
+export default createColumnDefs;

package/dist/core/createFeatureActions.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.
+*/ // Actions are how features call each other (keyboard Enter -> activateRow, Space ->
+// toggleRowSelected) without importing each other: each is created once per table instance.
+function createFeatureActions(api) {
+    api.features.list.forEach((feature)=>{
+        Object.entries(feature.actions ?? {}).forEach(([name, create])=>{
+            api.actions[name] = create(api);
+        });
+    });
+}
+export default createFeatureActions;

package/dist/core/createFeatureSet.js

@@ -0,0 +1,39 @@
+/*
+  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 collectBodyOverlays from './collectBodyOverlays.js';
+import collectCellLeads from './collectCellLeads.js';
+import collectClaimedViewKeys from './collectClaimedViewKeys.js';
+import collectGridHandlers from './collectGridHandlers.js';
+import collectHeaderParts from './collectHeaderParts.js';
+import collectRowRenderers from './collectRowRenderers.js';
+import collectSliceDefinitions from './collectSliceDefinitions.js';
+import createTanstackFeatures from './createTanstackFeatures.js';
+// A table's feature modules, in composition order, with what the core reads from them collected
+// once: `api.features`. Built once per distinct list, so every table with the same features
+// shares one set (and one stable TanStack feature set).
+function createFeatureSet(list) {
+    return {
+        bodyOverlays: collectBodyOverlays(list),
+        cellLeads: collectCellLeads(list),
+        claimedViewKeys: collectClaimedViewKeys(list),
+        gridHandlers: collectGridHandlers(list),
+        headerParts: collectHeaderParts(list),
+        list,
+        rowRenderers: collectRowRenderers(list),
+        sliceDefinitions: collectSliceDefinitions(list),
+        tanstackFeatures: createTanstackFeatures(list)
+    };
+}
+export default createFeatureSet;

package/dist/core/createInitialState.js

@@ -0,0 +1,63 @@
+/*
+  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';
+import pickViewPart from './pickViewPart.js';
+import resolveViewColumns from './resolveViewColumns.js';
+function passthroughView({ claimedViewKeys, value, defaultView }) {
+    const keys = new Set([
+        ...Object.keys(defaultView ?? {}),
+        ...Object.keys(value?.view ?? {})
+    ]);
+    const view = {};
+    keys.forEach((key)=>{
+        if (claimedViewKeys.has(key)) return;
+        const part = pickViewPart({
+            value,
+            defaultView,
+            key
+        });
+        if (!type.isUndefined(part)) view[key] = part;
+    });
+    return view;
+}
+// Builds the whole table state from a block value: each feature slice resolves its own part of the
+// value with the brief's fallback rules (value, then defaultView, then column defaults).
+function createInitialState({ value, config, features, rows }) {
+    const { defaultView } = config;
+    const viewColumns = resolveViewColumns({
+        value,
+        defaultView,
+        columns: config.columns
+    });
+    const args = {
+        value,
+        defaultView,
+        config,
+        viewColumns,
+        rows,
+        getKey: config.getKey
+    };
+    const state = {};
+    Object.entries(features.sliceDefinitions).forEach(([name, definition])=>{
+        state[name] = definition.init(args);
+    });
+    state.viewPassthrough = passthroughView({
+        claimedViewKeys: features.claimedViewKeys,
+        value,
+        defaultView
+    });
+    return state;
+}
+export default createInitialState;

package/dist/core/createKeyIndex.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.
+*/ // Row key -> index in `rows`, built on the first lookup: row events need it, most renders do not.
+function createKeyIndex({ rows, getKey }) {
+    let indices = null;
+    return function getIndex(rowKey) {
+        if (indices === null) {
+            indices = new Map();
+            rows.forEach((row, index)=>indices.set(String(getKey(row)), index));
+        }
+        return indices.get(String(rowKey)) ?? null;
+    };
+}
+export default createKeyIndex;