@lowdefy/blocks-table 0.0.0-experimental-20260929110023

package/dist/core/isRowEqual.js

@@ -0,0 +1,40 @@
+/*
+  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';
+// Structural equality for row objects coming out of the Lowdefy engine, which hands the block
+// fresh copies whenever `data` is re-evaluated. Plain data only: objects, arrays, dates, primitives.
+function isRowEqual(a, b) {
+    if (a === b) return true;
+    if (type.isDate(a) && type.isDate(b)) return a.getTime() === b.getTime();
+    if (type.isArray(a)) {
+        if (!type.isArray(b) || a.length !== b.length) return false;
+        for(let i = 0; i < a.length; i++){
+            if (!isRowEqual(a[i], b[i])) return false;
+        }
+        return true;
+    }
+    if (type.isObject(a)) {
+        if (!type.isObject(b)) return false;
+        const aKeys = Object.keys(a);
+        if (aKeys.length !== Object.keys(b).length) return false;
+        for(let i = 0; i < aKeys.length; i++){
+            const key = aKeys[i];
+            if (!isRowEqual(a[key], b[key])) return false;
+        }
+        return true;
+    }
+    return false;
+}
+export default isRowEqual;

package/dist/core/isSameSignature.js

@@ -0,0 +1,19 @@
+/*
+  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 isSameSignature(a, b) {
+    if (!a || !b) return false;
+    return a.view === b.view && a.selected === b.selected && a.expanded === b.expanded;
+}
+export default isSameSignature;

package/dist/core/lazyCellTypes.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.
+*/ // Cell types that render as more than text (chips, avatars, sanitised html, bars, the Link
+// component, antd Buttons). While the grid scrolls fast, cells of these types that come into view
+// render a cheap placeholder and upgrade once the scroll settles (D10.4); `buttons` also mount
+// only on demand (tier 1, see LazyCell).
+const LAZY_CELL_TYPES = new Set([
+    'avatar',
+    'buttons',
+    'html',
+    'image',
+    'link',
+    'people',
+    'progress',
+    'rating',
+    'relation',
+    'status',
+    'tag',
+    'tags'
+]);
+export default LAZY_CELL_TYPES;

package/dist/core/lazyComponent.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.
+*/ import { lazy } from 'react';
+// A component whose module loads on first render, for UI that opens on demand (popovers, menus,
+// editors), with `preload()` to start the load early (on hover or focus of what opens it) so it
+// opens without a wait. Render it inside a Suspense boundary of its own, so loading it never
+// suspends the table.
+function lazyComponent(load) {
+    let promise = null;
+    function preload() {
+        if (promise === null) promise = load();
+        return promise;
+    }
+    const Component = /*#__PURE__*/ lazy(preload);
+    Component.preload = preload;
+    return Component;
+}
+export default lazyComponent;

package/dist/core/loadOptionalFeature.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.
+*/ const records = new Map();
+// Loads an optional feature's chunk once per page: the record holds the feature module once it
+// has loaded (or the load error), and the promise Suspense waits on until then.
+function loadOptionalFeature(entry) {
+    let record = records.get(entry.name);
+    if (record === undefined) {
+        record = {
+            error: null,
+            feature: null,
+            promise: null
+        };
+        record.promise = entry.load().then((module)=>{
+            record.feature = module.default;
+        }, (error)=>{
+            record.error = error;
+        });
+        records.set(entry.name, record);
+    }
+    return record;
+}
+export default loadOptionalFeature;

package/dist/core/normalizeViewColumn.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.
+*/ import { type } from '@lowdefy/helpers';
+function normalizeViewColumn({ entry, fallback }) {
+    const width = type.isNumber(entry.width) ? entry.width : fallback?.width;
+    let pinned = fallback?.pinned;
+    if (!type.isUndefined(entry.pinned)) pinned = entry.pinned;
+    let hidden = fallback?.hidden ?? false;
+    if (!type.isUndefined(entry.hidden)) hidden = entry.hidden === true;
+    return {
+        key: entry.key,
+        width,
+        pinned: pinned === 'start' || pinned === 'end' ? pinned : undefined,
+        hidden
+    };
+}
+export default normalizeViewColumn;

package/dist/core/pickViewPart.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 brief's fallback rule for every top-level part of the view: the value's part, then the
+// `defaultView` part. Column defaults are the caller's last fallback.
+function pickViewPart({ value, defaultView, key }) {
+    const fromValue = value?.view?.[key];
+    if (!type.isUndefined(fromValue)) return fromValue;
+    return defaultView?.[key];
+}
+export default pickViewPart;

package/dist/core/renderRegion.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.
+*/ import React from 'react';
+function renderRegion(entries) {
+    return entries.map((entry)=>/*#__PURE__*/ React.createElement(React.Fragment, {
+            key: entry.name
+        }, entry.element));
+}
+export default renderRegion;

package/dist/core/resolveMountValue.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 { type } from '@lowdefy/helpers';
+// The value the table mounts with. A value set from outside always wins; a null value (a fresh
+// mount) takes the first feature `mountValue` that returns one (the persisted view, then the
+// active saved view), else it resolves to the defaults. Reset does not come through here, so it
+// always returns to `defaultView`.
+function resolveMountValue({ value, config, features, properties }) {
+    if (!type.isNone(value)) return value;
+    for (const feature of features){
+        const mounted = feature.mountValue?.({
+            config,
+            properties
+        });
+        if (!type.isNone(mounted)) return mounted;
+    }
+    return value;
+}
+export default resolveMountValue;

package/dist/core/resolveViewColumns.js

@@ -0,0 +1,65 @@
+/*
+  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 normalizeViewColumn from './normalizeViewColumn.js';
+function columnDefaults(column) {
+    return {
+        key: column.key,
+        pinned: column.pinned,
+        hidden: column.hidden
+    };
+}
+// Resolves `view.columns` (order, widths, pinning, visibility) from the value, then
+// `defaultView`, then the declared columns. Keys that are no longer declared are dropped.
+// Declared columns missing from a stored view (the value) are appended hidden, so a column added
+// to config later never pops into a user's saved layout. `defaultView` is config, so its entries
+// merge over the column's own defaults and unlisted columns are appended with their defaults.
+function resolveViewColumns({ value, defaultView, columns }) {
+    const byKey = new Map(columns.map((column)=>[
+            column.key,
+            column
+        ]));
+    const stored = value?.view?.columns;
+    const fromDefault = defaultView?.columns;
+    let source = null;
+    let isStored = false;
+    if (type.isArray(stored)) {
+        source = stored;
+        isStored = true;
+    } else if (type.isArray(fromDefault)) {
+        source = fromDefault;
+    }
+    if (source === null) return columns.map(columnDefaults);
+    const seen = new Set();
+    const resolved = [];
+    source.forEach((entry)=>{
+        if (!type.isObject(entry) || !byKey.has(entry.key) || seen.has(entry.key)) return;
+        seen.add(entry.key);
+        const fallback = isStored ? null : columnDefaults(byKey.get(entry.key));
+        resolved.push(normalizeViewColumn({
+            entry,
+            fallback
+        }));
+    });
+    columns.forEach((column)=>{
+        if (seen.has(column.key)) return;
+        resolved.push(isStored ? {
+            key: column.key,
+            hidden: true
+        } : columnDefaults(column));
+    });
+    return resolved;
+}
+export default resolveViewColumns;

package/dist/core/someColumnConfig.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.
+*/ import { type } from '@lowdefy/helpers';
+function someEntry(entries, test) {
+    return entries.some((entry)=>{
+        if (!type.isObject(entry)) return false;
+        if (type.isArray(entry.children)) return someEntry(entry.children, test);
+        return test(entry);
+    });
+}
+// Whether the raw column config (`defaultColumn`, or any leaf column, header groups included)
+// passes `test`: how the table decides which optional features a config needs before it
+// normalizes the columns.
+function someColumnConfig({ properties, test }) {
+    if (type.isObject(properties.defaultColumn) && test(properties.defaultColumn)) return true;
+    return type.isArray(properties.columns) && someEntry(properties.columns, test);
+}
+export default someColumnConfig;

package/dist/core/stabilizeData.js

@@ -0,0 +1,90 @@
+/*
+  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 { get, type } from '@lowdefy/helpers';
+import isRowEqual from './isRowEqual.js';
+const EMPTY = [];
+// `rowVersionField` is a dot path (`updated.timestamp`). A row without a version cannot be told
+// apart by it, so it is compared field by field.
+function isSameRow({ prior, row, rowVersionField }) {
+    if (rowVersionField) {
+        const priorVersion = get(prior, rowVersionField);
+        const version = get(row, rowVersionField);
+        if (!type.isNone(priorVersion) && !type.isNone(version)) return isRowEqual(priorVersion, version);
+    }
+    return isRowEqual(prior, row);
+}
+// Diffs incoming rows against the previous render by row key, so unchanged rows keep their object
+// identity (and their memoised row component) even though the engine delivers new copies. Rows
+// that keep their position are matched positionally, without a key lookup; the key index is only
+// rebuilt when rows move, arrive or leave. When nothing changed the previous array is returned,
+// which keeps every TanStack row model memo warm.
+function stabilizeData({ data, previous, getKey, rowVersionField }) {
+    const source = data ?? EMPTY;
+    if (previous && previous.source === source) return previous;
+    const previousRows = previous?.rows ?? EMPTY;
+    const rows = new Array(source.length);
+    let changed = source.length !== previousRows.length;
+    let moved = changed;
+    const changedIndices = [];
+    for(let i = 0; i < source.length; i++){
+        const row = source[i];
+        const positional = previousRows[i];
+        let next = row;
+        if (positional === row) {
+            rows[i] = row;
+            continue;
+        }
+        const key = getKey(row);
+        let prior;
+        if (positional !== undefined && getKey(positional) === key) {
+            prior = positional;
+        } else {
+            moved = true;
+            prior = previous?.byKey.get(key);
+        }
+        if (prior !== undefined && isSameRow({
+            prior,
+            row,
+            rowVersionField
+        })) next = prior;
+        rows[i] = next;
+        if (next !== positional) {
+            changed = true;
+            changedIndices.push(i);
+        }
+    }
+    if (!changed && previous) return {
+        source,
+        rows: previousRows,
+        byKey: previous.byKey
+    };
+    if (!moved && previous) {
+        // Same keys in the same places: patch the index for the rows that changed.
+        changedIndices.forEach((i)=>previous.byKey.set(getKey(rows[i]), rows[i]));
+        return {
+            source,
+            rows,
+            byKey: previous.byKey
+        };
+    }
+    const byKey = new Map();
+    for(let i = 0; i < rows.length; i++)byKey.set(getKey(rows[i]), rows[i]);
+    return {
+        source,
+        rows,
+        byKey
+    };
+}
+export default stabilizeData;