@lowdefy/blocks-antd 4.7.2 → 5.0.0

package/dist/blocks/Search/useRecentSearches.js

@@ -0,0 +1,77 @@
+/*
+  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 { useState, useCallback } from 'react';
+function getStorageKey(storageKey) {
+    return `lf-${storageKey}-recent`;
+}
+function readFromStorage(key) {
+    try {
+        const raw = localStorage.getItem(key);
+        return raw ? JSON.parse(raw) : [];
+    } catch  {
+        return [];
+    }
+}
+function writeToStorage(key, items) {
+    try {
+        localStorage.setItem(key, JSON.stringify(items));
+    } catch  {
+    // localStorage unavailable
+    }
+}
+function useRecentSearches({ enabled, storageKey = 'search', maxCount = 5 }) {
+    const key = getStorageKey(storageKey);
+    const [recentSearches, setRecentSearches] = useState(()=>{
+        if (!enabled) return [];
+        return readFromStorage(key);
+    });
+    const addSearch = useCallback((query)=>{
+        if (!enabled || !query) return;
+        setRecentSearches((prev)=>{
+            const filtered = prev.filter((item)=>item.query !== query);
+            const updated = [
+                {
+                    query,
+                    timestamp: Date.now()
+                },
+                ...filtered
+            ].slice(0, maxCount);
+            writeToStorage(key, updated);
+            return updated;
+        });
+    }, [
+        enabled,
+        key,
+        maxCount
+    ]);
+    const clearSearches = useCallback(()=>{
+        if (!enabled) return;
+        setRecentSearches([]);
+        try {
+            localStorage.removeItem(key);
+        } catch  {
+        // localStorage unavailable
+        }
+    }, [
+        enabled,
+        key
+    ]);
+    return {
+        recentSearches,
+        addSearch,
+        clearSearches
+    };
+}
+export default useRecentSearches;

package/dist/blocks/Search/useSearchIndex.js

@@ -0,0 +1,144 @@
+/*
+  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 { useState, useCallback, useRef } from 'react';
+import MiniSearch from 'minisearch';
+const indexCache = new Map();
+function useSearchIndex({ indexUrl, documents, fields, storeFields, searchOptions }) {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const indexMetaRef = useRef({
+        searchDefaults: {},
+        resultDefaults: {},
+        groups: []
+    });
+    const instancesRef = useRef([]);
+    const loadedRef = useRef(false);
+    const documentsRef = useRef(null);
+    const loadIndexes = useCallback(async ()=>{
+        if (indexUrl) {
+            const urls = Array.isArray(indexUrl) ? indexUrl : [
+                indexUrl
+            ];
+            const uncached = urls.filter((url)=>!indexCache.has(url));
+            if (uncached.length === 0) {
+                instancesRef.current = urls.map((url)=>indexCache.get(url).instance);
+                const first = indexCache.get(urls[0]);
+                indexMetaRef.current = {
+                    searchDefaults: first.searchDefaults ?? {},
+                    resultDefaults: first.resultDefaults ?? {},
+                    groups: first.groups ?? []
+                };
+                loadedRef.current = true;
+                return;
+            }
+            setLoading(true);
+            setError(null);
+            try {
+                const results = await Promise.all(uncached.map(async (url)=>{
+                    const response = await fetch(url);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch index: ${url} (${response.status})`);
+                    }
+                    return {
+                        url,
+                        json: await response.json()
+                    };
+                }));
+                for (const { url, json } of results){
+                    const instance = await MiniSearch.loadJSONAsync(JSON.stringify(json.data), json.options);
+                    indexCache.set(url, {
+                        instance,
+                        searchDefaults: json.searchDefaults,
+                        resultDefaults: json.resultDefaults,
+                        groups: json.groups
+                    });
+                }
+                instancesRef.current = urls.map((url)=>indexCache.get(url).instance);
+                const first = indexCache.get(urls[0]);
+                indexMetaRef.current = {
+                    searchDefaults: first.searchDefaults ?? {},
+                    resultDefaults: first.resultDefaults ?? {},
+                    groups: first.groups ?? []
+                };
+                loadedRef.current = true;
+            } catch (err) {
+                setError(err);
+            } finally{
+                setLoading(false);
+            }
+        }
+    }, [
+        indexUrl
+    ]);
+    const buildFromDocuments = useCallback(()=>{
+        if (!documents || documentsRef.current === documents) return;
+        documentsRef.current = documents;
+        const instance = new MiniSearch({
+            fields: fields ?? [
+                'title',
+                'content'
+            ],
+            storeFields: storeFields ?? []
+        });
+        instance.addAll(documents);
+        instancesRef.current = [
+            instance
+        ];
+        loadedRef.current = true;
+    }, [
+        documents,
+        fields,
+        storeFields
+    ]);
+    const ensureLoaded = useCallback(async ()=>{
+        if (loadedRef.current && !documents) return;
+        if (documents) {
+            buildFromDocuments();
+        } else if (indexUrl) {
+            await loadIndexes();
+        }
+    }, [
+        documents,
+        indexUrl,
+        loadIndexes,
+        buildFromDocuments
+    ]);
+    const search = useCallback((query)=>{
+        if (!loadedRef.current || !query) return [];
+        const mergedOptions = {
+            ...indexMetaRef.current.searchDefaults,
+            ...searchOptions
+        };
+        const allResults = [];
+        for (const instance of instancesRef.current){
+            const results = instance.search(query, mergedOptions);
+            allResults.push(...results);
+        }
+        allResults.sort((a, b)=>b.score - a.score);
+        return allResults;
+    }, [
+        searchOptions
+    ]);
+    return {
+        search,
+        loading,
+        error,
+        ensureLoaded,
+        searchDefaults: indexMetaRef.current.searchDefaults,
+        resultDefaults: indexMetaRef.current.resultDefaults,
+        groups: indexMetaRef.current.groups
+    };
+}
+export default useSearchIndex;

package/dist/blocks/SegmentedSelector/SegmentedSelector.js

@@ -0,0 +1,93 @@
+/*
+  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';
+import { Segmented } from 'antd';
+import { renderHtml, withBlockDefaults } from '@lowdefy/block-utils';
+import { type } from '@lowdefy/helpers';
+import Label from '../Label/Label.js';
+import getValueIndex from '../../getValueIndex.js';
+import getUniqueValues from '../../getUniqueValues.js';
+import withTheme from '../withTheme.js';
+const SegmentedSelector = ({ blockId, classNames = {}, components: { Icon }, events, loading, methods, properties, required, styles = {}, validation, value })=>{
+    const uniqueValueOptions = getUniqueValues(properties.options || []);
+    return /*#__PURE__*/ React.createElement(Label, {
+        blockId: blockId,
+        classNames: classNames,
+        components: {
+            Icon
+        },
+        events: events,
+        properties: {
+            title: properties.title,
+            size: properties.size,
+            ...properties.label
+        },
+        validation: validation,
+        required: required,
+        styles: styles,
+        content: {
+            content: ()=>/*#__PURE__*/ React.createElement(Segmented, {
+                    id: `${blockId}_input`,
+                    className: classNames.element,
+                    style: styles.element,
+                    options: uniqueValueOptions.map((opt, i)=>type.isPrimitive(opt) ? {
+                            label: renderHtml({
+                                html: `${opt}`,
+                                methods
+                            }),
+                            value: `${i}`
+                        } : {
+                            label: type.isNone(opt.label) ? renderHtml({
+                                html: `${opt.value}`,
+                                methods
+                            }) : renderHtml({
+                                html: opt.label,
+                                methods
+                            }),
+                            value: `${i}`,
+                            disabled: opt.disabled || properties.disabled || loading,
+                            icon: opt.icon ? /*#__PURE__*/ React.createElement(Icon, {
+                                blockId: `${blockId}_${i}_icon`,
+                                classNames: {
+                                    element: classNames.icon
+                                },
+                                events: events,
+                                properties: opt.icon,
+                                styles: {
+                                    element: styles.icon
+                                }
+                            }) : undefined
+                        }),
+                    size: properties.size,
+                    block: properties.block,
+                    disabled: properties.disabled || loading,
+                    vertical: properties.vertical,
+                    shape: properties.shape,
+                    value: type.isNone(value) ? undefined : getValueIndex(value, properties.options || []),
+                    onChange: (index)=>{
+                        const val = type.isPrimitive(uniqueValueOptions[index]) ? uniqueValueOptions[index] : uniqueValueOptions[index].value;
+                        methods.setValue(val);
+                        methods.triggerEvent({
+                            name: 'onChange',
+                            event: {
+                                value: val
+                            }
+                        });
+                    }
+                })
+        }
+    });
+};
+export default withTheme('Segmented', withBlockDefaults(SegmentedSelector));

package/dist/blocks/SegmentedSelector/e2e.js

@@ -0,0 +1,32 @@
+/*
+  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 { createBlockHelper } from '@lowdefy/e2e-utils';
+import { expect } from '@playwright/test';
+const locator = (page, blockId)=>page.locator(`#${blockId}_input`);
+export default createBlockHelper({
+    locator,
+    do: {
+        select: (page, blockId, text)=>locator(page, blockId).locator('.ant-segmented-item').filter({
+                hasText: text
+            }).click()
+    },
+    expect: {
+        value: (page, blockId, text)=>expect(locator(page, blockId).locator('.ant-segmented-item-selected').filter({
+                hasText: text
+            })).toBeVisible(),
+        disabled: (page, blockId)=>expect(locator(page, blockId)).toHaveClass(/ant-segmented-disabled/),
+        enabled: (page, blockId)=>expect(locator(page, blockId)).not.toHaveClass(/ant-segmented-disabled/)
+    }
+});

package/dist/blocks/SegmentedSelector/meta.js

@@ -0,0 +1,222 @@
+/*
+  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 LabelMeta from '../Label/meta.js';
+import label from '../../schemas/label.js';
+import { disabled, inputTitle, sizeSmallDefaultLarge } from '../../schemas/inputProperties.js';
+export default {
+    category: 'input',
+    icons: [
+        ...LabelMeta.icons
+    ],
+    valueType: 'any',
+    cssKeys: {
+        element: 'The SegmentedSelector element.',
+        icon: 'The icon in the SegmentedSelector.',
+        label: 'The SegmentedSelector label.',
+        extra: 'The SegmentedSelector extra content.',
+        feedback: 'The SegmentedSelector validation feedback.'
+    },
+    events: {
+        onChange: {
+            description: 'Trigger actions when selection is changed.',
+            event: {
+                value: 'The selected value.'
+            }
+        }
+    },
+    properties: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            block: {
+                type: 'boolean',
+                default: false,
+                description: "Option to fit width to its parent's width."
+            },
+            disabled,
+            options: {
+                default: [],
+                oneOf: [
+                    {
+                        type: 'array',
+                        description: 'Options can either be an array of primitive values, or an array of label, value pairs - supports html.',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    {
+                        type: 'array',
+                        description: 'Options can either be an array of primitive values, or an array of label, value pairs.',
+                        items: {
+                            type: 'number'
+                        }
+                    },
+                    {
+                        type: 'array',
+                        description: 'Options can either be an array of primitive values, or an array of label, value pairs.',
+                        items: {
+                            type: 'boolean'
+                        }
+                    },
+                    {
+                        type: 'array',
+                        description: 'Options can either be an array of primitive values, or an array of label, value pairs.',
+                        items: {
+                            type: 'object',
+                            required: [
+                                'value'
+                            ],
+                            properties: {
+                                label: {
+                                    type: 'string',
+                                    description: 'Value label shown to user - supports html.'
+                                },
+                                value: {
+                                    description: 'Value selected. Can be of any type.',
+                                    oneOf: [
+                                        {
+                                            type: 'string'
+                                        },
+                                        {
+                                            type: 'number'
+                                        },
+                                        {
+                                            type: 'boolean'
+                                        },
+                                        {
+                                            type: 'object'
+                                        },
+                                        {
+                                            type: 'array'
+                                        }
+                                    ],
+                                    docs: {
+                                        displayType: 'yaml'
+                                    }
+                                },
+                                disabled: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Disable the option if true.'
+                                },
+                                icon: {
+                                    type: 'string',
+                                    description: 'Name of a React-Icon (See <a href="https://react-icons.github.io/react-icons/">all icons</a>) to display in the segment option.',
+                                    docs: {
+                                        displayType: 'icon'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+            shape: {
+                type: 'string',
+                enum: [
+                    'default',
+                    'round'
+                ],
+                default: 'default',
+                description: 'Shape of the segmented control.'
+            },
+            size: sizeSmallDefaultLarge,
+            vertical: {
+                type: 'boolean',
+                default: false,
+                description: 'Display the segmented control vertically.'
+            },
+            label,
+            title: inputTitle,
+            theme: {
+                type: 'object',
+                description: 'Antd design token overrides for this block. See <a href="https://ant.design/components/overview#design-token">antd design tokens</a>.',
+                docs: {
+                    displayType: 'yaml',
+                    link: 'https://ant.design/components/segmented#design-token'
+                },
+                properties: {
+                    trackBg: {
+                        type: 'string',
+                        description: 'Background color of the segmented track container.'
+                    },
+                    trackPadding: {
+                        type: 'number',
+                        description: 'Padding around the segmented track.'
+                    },
+                    itemColor: {
+                        type: 'string',
+                        description: 'Default text color for segmented items.'
+                    },
+                    itemHoverColor: {
+                        type: 'string',
+                        description: 'Text color when hovering over a segmented item.'
+                    },
+                    itemHoverBg: {
+                        type: 'string',
+                        description: 'Background color when hovering over a segmented item.'
+                    },
+                    itemActiveBg: {
+                        type: 'string',
+                        description: 'Background color when a segmented item is being pressed.'
+                    },
+                    itemSelectedBg: {
+                        type: 'string',
+                        description: 'Background color of the selected segmented item.'
+                    },
+                    itemSelectedColor: {
+                        type: 'string',
+                        description: 'Text color of the selected segmented item.'
+                    },
+                    borderRadius: {
+                        type: 'number',
+                        default: 6,
+                        description: 'Border radius of the segmented control.'
+                    },
+                    borderRadiusLG: {
+                        type: 'number',
+                        default: 8,
+                        description: 'Border radius for large segmented control.'
+                    },
+                    borderRadiusSM: {
+                        type: 'number',
+                        default: 4,
+                        description: 'Border radius for small segmented control.'
+                    },
+                    controlHeight: {
+                        type: 'number',
+                        default: 32,
+                        description: 'Height of the segmented control.'
+                    },
+                    controlHeightLG: {
+                        type: 'number',
+                        default: 40,
+                        description: 'Height for large segmented control.'
+                    },
+                    controlHeightSM: {
+                        type: 'number',
+                        default: 24,
+                        description: 'Height for small segmented control.'
+                    },
+                    fontSize: {
+                        type: 'number',
+                        default: 14,
+                        description: 'Font size of segmented item text.'
+                    }
+                }
+            }
+        }
+    }
+};