@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/features/virtualization/scrollToCell.js

@@ -0,0 +1,49 @@
+/*
+  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.
+*/ // Scrolls the minimum needed to bring a cell into view below the sticky header and beside the
+// pinned columns (`align: 'start' | 'center'` for rows scroll further), with measured row
+// offsets when rows wrap. `startInset` leaves that much room above a row aligned to the start
+// (the stacked sticky group headers above an inner group's header).
+function scrollToCell({ api, row, col, align, startInset = 0 }) {
+    const scroller = api.scrollerRef.current;
+    if (!scroller) return;
+    const { footerHeight, headerHeight, layout, rowOffsets } = api;
+    if (row >= 0) {
+        const bodyHeight = scroller.clientHeight - headerHeight - footerHeight;
+        const rowTop = rowOffsets ? rowOffsets[row] : row * api.rowHeight;
+        const rowHeight = rowOffsets ? rowOffsets[row + 1] - rowOffsets[row] : api.rowHeight;
+        let top = scroller.scrollTop;
+        if (align === 'start') {
+            top = rowTop - startInset;
+        } else if (align === 'center') {
+            top = rowTop - (bodyHeight - rowHeight) / 2;
+        } else if (rowTop < top) {
+            top = rowTop;
+        } else if (rowTop + rowHeight > top + bodyHeight) {
+            top = rowTop + rowHeight - bodyHeight;
+        }
+        scroller.scrollTop = Math.max(0, top);
+    }
+    const target = layout?.cols[col];
+    if (target?.region !== 'center') return;
+    const viewLeft = scroller.scrollLeft;
+    const centerViewport = scroller.clientWidth - layout.startWidth - layout.endWidth;
+    if (target.centerStart < viewLeft) {
+        scroller.scrollLeft = target.centerStart;
+    } else if (target.centerStart + target.width > viewLeft + centerViewport) {
+        scroller.scrollLeft = target.centerStart + target.width - centerViewport;
+    }
+}
+export default scrollToCell;

package/dist/features/virtualization/shiftRowOffsets.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.
+*/ // Applies height changes to row offsets (item tops, the total height last) in place: each change
+// `{ index, delta }` moves the tops of every item after `index` by `delta`. Only the offsets from
+// the first changed item on are touched, with one running sum, instead of recomputing every
+// item's height.
+function shiftRowOffsets({ offsets, changes }) {
+    if (changes.length === 0) return offsets;
+    const sorted = [
+        ...changes
+    ].sort((a, b)=>a.index - b.index);
+    let shift = 0;
+    let next = 0;
+    for(let i = sorted[0].index + 1; i < offsets.length; i++){
+        while(next < sorted.length && sorted[next].index < i){
+            shift += sorted[next].delta;
+            next += 1;
+        }
+        offsets[i] += shift;
+    }
+    return offsets;
+}
+export default shiftRowOffsets;

package/dist/features/virtualization/usePositionedRows.js

@@ -0,0 +1,37 @@
+/*
+  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 useTanstackRowWindow from './useTanstackRowWindow.js';
+// The `positioned` row window strategy (the bench-only `rowWindowStrategy`): TanStack Virtual's
+// range and per-row positioning in place of the translated window, when rows are virtualised and
+// one row high.
+function usePositionedRows({ headerHeight, range, rowHeight, rowOffsets, rows, scrollerRef, virtualRows }) {
+    const positioned = virtualRows && rowOffsets === null;
+    const tanstackRows = useTanstackRowWindow({
+        enabled: positioned,
+        headerHeight,
+        rowCount: rows.length,
+        rowHeight,
+        scrollerRef
+    });
+    if (!positioned || !tanstackRows) return {};
+    return {
+        range: {
+            ...range,
+            ...tanstackRows,
+            positioning: 'positioned'
+        }
+    };
+}
+export default usePositionedRows;

package/dist/features/virtualization/useRowOffsets.js

@@ -0,0 +1,123 @@
+/*
+  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 { useCallback, useMemo, useRef, useState } from 'react';
+import computeRowOffsets from './computeRowOffsets.js';
+import getMeasureKey from './getMeasureKey.js';
+import shiftRowOffsets from './shiftRowOffsets.js';
+// The one row height mechanism (D10.1). Every display item is one row high unless it is measured:
+// data rows when a visible column wraps or clamps to more than one line (`measuredColumns`), and
+// items a `useItems` hook gives a height estimate for (`rowHeights`: expandable detail rows).
+// Measured elements carry `data-measure-key` and report their rendered height after each window
+// render (`measureRows`, called by the body; a detail row also reports when its content resizes).
+// Heights are cached by that key; an item not measured yet takes its estimate or the row height.
+// Items that grew above the viewport move the scroll position by the same amount, so the rows in
+// view stay put. A layout change (column widths, order, visibility) re-wraps text, so it drops
+// the cache. Null offsets mean every item is one row high (index * rowHeight).
+//
+// The offsets are computed in full only when the list, the row height or the layout change. A
+// measurement shifts them from the first changed item on (shiftRowOffsets): scrolling into rows
+// that were never measured costs one pass of additions, not a height lookup per item. The
+// measurements reported before the next render go into one copy, so a render sees one new array.
+function useRowOffsets({ api, layout, measuredColumns, rowHeight, rowHeights, rows, scrollerRef }) {
+    const enabled = measuredColumns || rowHeights !== null;
+    const heightsRef = useRef(new Map());
+    const layoutRef = useRef(layout);
+    const [, setVersion] = useState(0);
+    if (layoutRef.current !== layout) {
+        layoutRef.current = layout;
+        heightsRef.current = new Map();
+    }
+    const computed = useMemo(()=>{
+        if (!enabled) return null;
+        const heights = heightsRef.current;
+        return computeRowOffsets({
+            rows,
+            rowHeight,
+            heightOf: (item, index)=>{
+                const key = getMeasureKey(item);
+                const measured = key === null ? undefined : heights.get(key);
+                return measured ?? rowHeights?.(item, index);
+            }
+        });
+    }, [
+        enabled,
+        rows,
+        rowHeight,
+        rowHeights,
+        layout
+    ]);
+    // `base` is the full computation the measured offsets shifted; a new one replaces them (it
+    // already holds every measured height). `rendered`: a render has handed `offsets` out, so the
+    // next measurement shifts a copy.
+    const workingRef = useRef({
+        base: null,
+        offsets: null,
+        rendered: false
+    });
+    if (workingRef.current.base !== computed) {
+        workingRef.current = {
+            base: computed,
+            offsets: computed,
+            rendered: false
+        };
+    }
+    workingRef.current.rendered = true;
+    const offsets = workingRef.current.offsets;
+    api.rowOffsets = offsets;
+    const measureRows = useCallback((elements)=>{
+        const working = workingRef.current;
+        const scroller = scrollerRef.current;
+        if (!working.offsets || !scroller) return;
+        const current = working.offsets;
+        const heights = heightsRef.current;
+        const scrollTop = scroller.scrollTop;
+        const changes = [];
+        let shift = 0;
+        for(let i = 0; i < elements.length; i++){
+            const element = elements[i];
+            const key = element.dataset.measureKey;
+            if (key === undefined) continue;
+            const index = Number(element.dataset.rowIndex);
+            const height = element.offsetHeight;
+            const previous = current[index + 1] - current[index];
+            heights.set(key, height);
+            if (height === previous) continue;
+            changes.push({
+                index,
+                delta: height - previous
+            });
+            if (current[index + 1] <= scrollTop) shift += height - previous;
+        }
+        if (changes.length === 0) return;
+        if (shift !== 0) scroller.scrollTop = scrollTop + shift;
+        const next = working.rendered ? current.slice() : current;
+        shiftRowOffsets({
+            offsets: next,
+            changes
+        });
+        workingRef.current = {
+            base: working.base,
+            offsets: next,
+            rendered: false
+        };
+        setVersion((value)=>value + 1);
+    }, []);
+    api.measureRows = enabled ? measureRows : null;
+    return {
+        measureRows: api.measureRows,
+        rowOffsets: offsets
+    };
+}
+export default useRowOffsets;

package/dist/features/virtualization/useScrollWindow.js

@@ -0,0 +1,114 @@
+/*
+  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 { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { flushSync } from 'react-dom';
+import computeWindow from './computeWindow.js';
+import isSameRange from './isSameRange.js';
+import writeScrollEdges from './writeScrollEdges.js';
+// Native scroll, observed passively and coalesced into one rAF; React renders only when the
+// rendered range changes (D10.2). The render is flushed inside that frame so new rows paint with
+// the scroll position that needed them. The scroll offset itself never enters React state; the
+// pinned-edge shadows follow it through attributes on the scroller (writeScrollEdges).
+function useScrollWindow({ scrollerRef, params }) {
+    const paramsRef = useRef(params);
+    paramsRef.current = params;
+    const scrollRef = useRef({
+        top: 0,
+        direction: 0
+    });
+    const edgesRef = useRef({
+        start: false,
+        end: false
+    });
+    const [range, setRange] = useState(()=>computeWindow({
+            ...params,
+            direction: 0,
+            scrollLeft: 0,
+            scrollTop: 0,
+            viewportHeight: params.rowHeight * 20,
+            viewportWidth: 1200
+        }));
+    const update = useCallback((sync)=>{
+        const element = scrollerRef.current;
+        if (!element) return;
+        writeScrollEdges({
+            element,
+            edges: edgesRef.current
+        });
+        const scroll = scrollRef.current;
+        const top = element.scrollTop;
+        if (top !== scroll.top) scroll.direction = top > scroll.top ? 1 : -1;
+        scroll.top = top;
+        const next = computeWindow({
+            ...paramsRef.current,
+            direction: scroll.direction,
+            scrollLeft: element.scrollLeft,
+            scrollTop: top,
+            viewportHeight: element.clientHeight,
+            viewportWidth: element.clientWidth
+        });
+        const apply = ()=>setRange((previous)=>isSameRange(previous, next) ? previous : next);
+        if (sync) {
+            flushSync(apply);
+        } else {
+            apply();
+        }
+    }, []);
+    useLayoutEffect(()=>{
+        update(false);
+    }, [
+        params.headerHeight,
+        params.layout,
+        params.rowCount,
+        params.rowHeight,
+        params.rowOffsets,
+        params.virtualColumns,
+        params.virtualRows
+    ]);
+    useEffect(()=>{
+        const element = scrollerRef.current;
+        let frame = 0;
+        function onFrame() {
+            frame = 0;
+            update(true);
+        }
+        function schedule() {
+            if (!frame) frame = requestAnimationFrame(onFrame);
+        }
+        element.addEventListener('scroll', schedule, {
+            passive: true
+        });
+        const observer = new ResizeObserver(schedule);
+        observer.observe(element);
+        return ()=>{
+            element.removeEventListener('scroll', schedule);
+            observer.disconnect();
+            if (frame) cancelAnimationFrame(frame);
+        };
+    }, []);
+    // The range state catches up with a new row or column count in a layout effect, after this
+    // render; until then it is clamped to what exists, so a shrinking row list (a new page, fewer
+    // rows) never renders past its end.
+    const rowEnd = Math.min(range.rowEnd, params.rowCount);
+    const colEnd = Math.min(range.colEnd, params.layout.center.length);
+    if (rowEnd === range.rowEnd && colEnd === range.colEnd) return range;
+    return {
+        rowStart: Math.min(range.rowStart, rowEnd),
+        rowEnd,
+        colStart: Math.min(range.colStart, colEnd),
+        colEnd
+    };
+}
+export default useScrollWindow;

package/dist/features/virtualization/useTanstackRowWindow.js

@@ -0,0 +1,43 @@
+/*
+  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 { useCallback, useEffect } from 'react';
+import { useVirtualizer } from '@tanstack/react-virtual';
+// TanStack Virtual's row range, for the `positioned` strategy the benchmark compares against the
+// translated window (per-row absolute transforms, count-based overscan of about one viewport).
+function useTanstackRowWindow({ enabled, headerHeight, rowCount, rowHeight, scrollerRef }) {
+    const estimateSize = useCallback(()=>rowHeight, [
+        rowHeight
+    ]);
+    const virtualizer = useVirtualizer({
+        count: rowCount,
+        enabled,
+        estimateSize,
+        getScrollElement: ()=>scrollerRef.current,
+        overscan: Math.ceil(900 / rowHeight),
+        scrollMargin: headerHeight
+    });
+    useEffect(()=>{
+        virtualizer.measure();
+    }, [
+        rowHeight
+    ]);
+    const items = virtualizer.getVirtualItems();
+    if (!enabled || !items.length) return null;
+    return {
+        rowStart: items[0].index,
+        rowEnd: items[items.length - 1].index + 1
+    };
+}
+export default useTanstackRowWindow;

package/dist/features/virtualization/useVirtualization.js

@@ -0,0 +1,64 @@
+/*
+  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 isMeasuredColumn from './isMeasuredColumn.js';
+import useRowOffsets from './useRowOffsets.js';
+import useScrollWindow from './useScrollWindow.js';
+const AUTO_ROW_THRESHOLD = 200;
+const AUTO_COLUMN_THRESHOLD = 20;
+// `virtual: auto` (D15) virtualises rows above 200 and columns above 20 or when the table is wider
+// than twice the viewport; below that the extra range logic costs more than it saves. Measured
+// rows (wrapped or multi-line columns) turn column virtualisation off, as a row's height depends
+// on every cell in it. Items of other heights (measured rows, detail rows) are placed by
+// `rowOffsets` (useRowOffsets), which also rules out the bench's positioned strategy
+// (positionedRowsFeature). The rows are placed by one translated window.
+function useVirtualization(ctx) {
+    const { api, config, headerHeight, layout, rowHeight, rowHeights, rows, scrollerRef, viewport } = ctx;
+    const measuredColumns = layout.cols.some(isMeasuredColumn);
+    const auto = config.virtual === 'auto';
+    const virtualRows = config.virtual === true || auto && rows.length > AUTO_ROW_THRESHOLD;
+    const virtualColumns = !measuredColumns && (config.virtual === true || auto && (layout.center.length > AUTO_COLUMN_THRESHOLD || layout.totalWidth > 2 * viewport.width));
+    const { measureRows, rowOffsets } = useRowOffsets({
+        api,
+        layout,
+        measuredColumns,
+        rowHeight,
+        rowHeights,
+        rows,
+        scrollerRef
+    });
+    const scrollWindow = useScrollWindow({
+        scrollerRef,
+        params: {
+            headerHeight,
+            layout,
+            rowCount: rows.length,
+            rowHeight,
+            rowOffsets,
+            virtualColumns,
+            virtualRows
+        }
+    });
+    return {
+        measuredColumns,
+        measureRows,
+        range: {
+            ...scrollWindow,
+            positioning: 'translated'
+        },
+        rowOffsets,
+        virtualRows
+    };
+}
+export default useVirtualization;

package/dist/features/virtualization/virtualizationFeature.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 createScrollToRow from './createScrollToRow.js';
+import useVirtualization from './useVirtualization.js';
+const virtualizationFeature = {
+    name: 'virtualization',
+    useGridFeature: useVirtualization,
+    methods: {
+        scrollToRow: createScrollToRow
+    }
+};
+export default virtualizationFeature;

package/dist/features/virtualization/writeScrollEdges.js

@@ -0,0 +1,33 @@
+/*
+  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.
+*/ // Marks the scroller while columns are scrolled under the pinned regions: `data-scrolled-start`
+// once it scrolls away from the start, `data-scrolled-end` until it reaches the end. The pinned
+// edge cells show their shadow from these (table.css). Attributes are written only when they
+// change, so a scroll frame costs no style recalculation; the reads come from the frame's own
+// range update, after its layout is already done.
+function writeScrollEdges({ element, edges }) {
+    const left = Math.abs(element.scrollLeft);
+    const start = left > 0.5;
+    const end = left < element.scrollWidth - element.clientWidth - 0.5;
+    if (start !== edges.start) {
+        element.toggleAttribute('data-scrolled-start', start);
+        edges.start = start;
+    }
+    if (end !== edges.end) {
+        element.toggleAttribute('data-scrolled-end', end);
+        edges.end = end;
+    }
+}
+export default writeScrollEdges;

package/dist/features/visibility/initColumnVisibility.js

@@ -0,0 +1,22 @@
+/*
+  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 initColumnVisibility({ viewColumns }) {
+    const visibility = {};
+    viewColumns.forEach((entry)=>{
+        if (entry.hidden) visibility[entry.key] = false;
+    });
+    return visibility;
+}
+export default initColumnVisibility;

package/dist/features/visibility/visibilityFeature.js

@@ -0,0 +1,31 @@
+/*
+  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 { columnVisibilityFeature } from '@tanstack/react-table';
+import initColumnVisibility from './initColumnVisibility.js';
+import visibilityToViewColumn from './visibilityToViewColumn.js';
+const visibilityFeature = {
+    name: 'visibility',
+    tableFeatures: {
+        columnVisibilityFeature
+    },
+    slices: {
+        columnVisibility: {
+            init: initColumnVisibility,
+            cause: 'columns'
+        }
+    },
+    toViewColumn: visibilityToViewColumn
+};
+export default visibilityFeature;

package/dist/features/visibility/visibilityToViewColumn.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.
+*/ function visibilityToViewColumn({ key, state }) {
+    return state.columnVisibility[key] === false ? {
+        hidden: true
+    } : {};
+}
+export default visibilityToViewColumn;

package/dist/metas.js

@@ -0,0 +1,16 @@
+/*
+  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.
+*/ export { default as Table } from './blocks/Table/meta.js';
+export { default as TableInput } from './blocks/TableInput/meta.js';

package/dist/types.js

@@ -0,0 +1,17 @@
+/*
+  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 { extractBlockTypes } from '@lowdefy/block-utils';
+import * as metas from './metas.js';
+export default extractBlockTypes(metas);