impact-chatbot 2.3.69 → 2.3.70

package/dist/index.cjs.js

@@ -6764,6 +6764,7 @@ const SliderContent = ({ bodyText, isFormDisabled = false, messageIndex }) => {
 
 const INITIAL_DISPLAY_COUNT = 100;
 const LOAD_MORE_COUNT = 100;
+const SEARCH_DISPLAY_LIMIT = 500;
 const formatOption = (option) => ({
     ...option,
     label: replaceSpecialCharacter(option.label.toString()),
@@ -6781,6 +6782,8 @@ const SelectContent = ({ bodyText, isFormDisabled = false, messageIndex }) => {
     const [isAllSelected, setIsAllSelected] = React.useState(false);
     const [initialOptions, setInitialOptions] = React.useState([]);
     const allOptionsRef = React.useRef([]);
+    const isSearchActiveRef = React.useRef(false);
+    const searchTermRef = React.useRef("");
     const chatbotContext = reactRedux.useSelector((state) => state.smartBotReducer.chatbotContext);
     const heirarchyKeyValuePairs = reactRedux.useSelector((state) => state.smartBotReducer.heirarchyKeyValuePairs);
     const dispatch = reactRedux.useDispatch();
@@ -6873,6 +6876,40 @@ const SelectContent = ({ bodyText, isFormDisabled = false, messageIndex }) => {
             setCurrentOptions(initialSlice);
         }
     }, [isCascading]);
+    // Custom search handler: searches ALL options (not just the loaded chunk)
+    // Supports comma-separated values for multi-search
+    const handleSearch = React.useCallback((event) => {
+        const rawInput = event?.target?.value || "";
+        searchTermRef.current = rawInput;
+        const trimmed = rawInput.trim();
+        if (!trimmed) {
+            // Reset to initial lazy-loaded chunk
+            isSearchActiveRef.current = false;
+            const resetSlice = formatSlice(allOptionsRef.current, 0, INITIAL_DISPLAY_COUNT);
+            setCurrentOptions(resetSlice);
+            setInitialOptions(resetSlice);
+            setIsAllSelected(false);
+            return;
+        }
+        isSearchActiveRef.current = true;
+        // Parse comma-separated terms
+        const terms = trimmed
+            .split(",")
+            .map((t) => t.trim().toLowerCase())
+            .filter(Boolean);
+        // Search across ALL options, not just the loaded chunk
+        const allRaw = allOptionsRef.current;
+        const filtered = allRaw.filter((option) => {
+            const labelLower = option.label?.toString().toLowerCase() || "";
+            const valueLower = option.value?.toString().toLowerCase() || "";
+            return terms.some((term) => labelLower.includes(term) || valueLower.includes(term));
+        });
+        // Format and cap the results to avoid UI freeze
+        const formatted = filtered.slice(0, SEARCH_DISPLAY_LIMIT).map(formatOption);
+        setCurrentOptions(formatted);
+        setInitialOptions(formatted);
+        setIsAllSelected(false);
+    }, []);
     return (jsxRuntime.jsx("div", { style: { width: "100%", marginTop: "10px" }, children: jsxRuntime.jsx(impactUiV3.Select, { currentOptions: currentOptions, setCurrentOptions: setCurrentOptions, label: heirarchyKeyValuePairs[paramName] || label, labelOrientation: labelOrientation, 
             // inputPosition={inputPosition}
             // header={header}
@@ -6894,6 +6931,11 @@ const SelectContent = ({ bodyText, isFormDisabled = false, messageIndex }) => {
                 }
             }, handleChange: (selected) => onChange(selected), isCloseWhenClickOutside: true, setIsOpen: (open) => {
                 setIsOpen(open);
+                // When dropdown closes after a filtered select-all on a subset,
+                // reset the isAllSelected flag so scroll-to-load-more doesn't auto-select more items
+                if (!open && isAllSelected && currentSelectedOptions.length < allOptionsRef.current.length) {
+                    setIsAllSelected(false);
+                }
                 if (isCascading) {
                     if (open) {
                         // Lazy fetch: trigger cross-filter API call when dropdown opens for the first time
@@ -6920,7 +6962,10 @@ const SelectContent = ({ bodyText, isFormDisabled = false, messageIndex }) => {
                         }
                     }
                 }
-            }, isOpen: isOpen, selectedOptions: currentSelectedOptions, setSelectedOptions: setCurrentSelectedOptions, initialOptions: initialOptions, isMulti: isMulti, isSelectAll: isAllSelected, setIsSelectAll: setIsAllSelected, toggleSelectAll: true, isLoading: isCascading ? crossFilterCtx.loadingMap[paramName] : false, emptyMessage: isCascading && crossFilterCtx.loadingMap[paramName] ? "Loading values..." : "No options available", isWithSearch: isMulti ? true : false, onMenuScrollToBottom: () => {
+            }, isOpen: isOpen, selectedOptions: currentSelectedOptions, setSelectedOptions: setCurrentSelectedOptions, initialOptions: initialOptions, isMulti: isMulti, isSelectAll: isAllSelected, setIsSelectAll: setIsAllSelected, toggleSelectAll: true, isLoading: isCascading ? crossFilterCtx.loadingMap[paramName] : false, emptyMessage: isCascading && crossFilterCtx.loadingMap[paramName] ? "Loading values..." : "No options available", isWithSearch: isMulti ? true : false, onSearch: handleSearch, onMenuScrollToBottom: () => {
+                // Only allow scroll-to-load-more when NOT in search mode
+                if (isSearchActiveRef.current)
+                    return;
                 const allRaw = allOptionsRef.current;
                 if (allRaw.length > 0 && currentOptions.length < allRaw.length) {
                     const nextCount = Math.min(currentOptions.length + LOAD_MORE_COUNT, allRaw.length);
@@ -6934,33 +6979,53 @@ const SelectContent = ({ bodyText, isFormDisabled = false, messageIndex }) => {
                 }
             }, onSelectAll: (e) => {
                 if (e && e.target.checked) {
-                    setCurrentSelectedOptions([...currentOptions]);
+                    // When search is active, select only the filtered/visible options
+                    // When no search is active, select ALL options from the full dataset
+                    let optionsToSelect;
+                    let valuesToDispatch;
+                    if (isSearchActiveRef.current) {
+                        optionsToSelect = [...currentOptions];
+                        valuesToDispatch = currentOptions.map((opt) => opt.value);
+                    }
+                    else {
+                        optionsToSelect = allOptionsRef.current.map(formatOption);
+                        valuesToDispatch = allOptionsRef.current.map((opt) => opt.value);
+                    }
+                    setCurrentSelectedOptions(optionsToSelect);
                     setIsAllSelected(true);
-                    const allValues = allOptionsRef.current.map((opt) => opt.value);
                     dispatch(smartBotActions.setChatbotContext({
                         ...chatbotContext,
                         [bodyText?.paramName]: {
                             ...chatbotContext?.[bodyText?.paramName],
-                            [bodyText?.paramName]: allValues,
+                            [bodyText?.paramName]: valuesToDispatch,
                             updated: true,
                         },
                     }));
-                    dispatch(smartBotActions.setPersistedFormValues({ [formKey]: currentOptions }));
+                    dispatch(smartBotActions.setPersistedFormValues({ [formKey]: optionsToSelect }));
                     // Notify cross-filter context if cascading is active
                     if (isCascading) {
-                        crossFilterCtx.onFilterChange(paramName, allValues);
+                        crossFilterCtx.onFilterChange(paramName, valuesToDispatch);
                     }
                 }
                 else {
                     setCurrentSelectedOptions([]);
                     setIsAllSelected(false);
+                    dispatch(smartBotActions.setChatbotContext({
+                        ...chatbotContext,
+                        [bodyText?.paramName]: {
+                            ...chatbotContext?.[bodyText?.paramName],
+                            [bodyText?.paramName]: [],
+                            updated: true,
+                        },
+                    }));
+                    dispatch(smartBotActions.setPersistedFormValues({ [formKey]: [] }));
                     // Notify cross-filter context of deselection
                     if (isCascading) {
                         crossFilterCtx.onFilterChange(paramName, []);
                     }
                 }
-            }, customPlaceholderAfterSelect: isAllSelected && allOptionsRef.current.length > 0
-                ? allOptionsRef.current.length
+            }, customPlaceholderAfterSelect: currentSelectedOptions.length > 0
+                ? currentSelectedOptions.length
                 : null }) }));
 };