@rivet-health/design-system 40.44.0 → 40.44.2

package/esm2022/lib/input/select/state.mjs

@@ -0,0 +1,882 @@
+import Fuse from 'fuse.js';
+import { defaultsDeep, flattenDeep, isNumber, sortBy } from 'lodash';
+import { connectable, map, merge, ReplaySubject, scan, startWith, Subject, } from 'rxjs';
+import { NumberPipe } from '../../format/pipes/number.pipe';
+export var RivSelect;
+(function (RivSelect) {
+    /////////////
+    // Options //
+    /////////////
+    /**
+     * The OptionSet class provides Set-like functionality, but uniqueness is
+     * determined by the option's ID rather than the object reference.
+     */
+    class OptionSet extends Set {
+        constructor(values) {
+            super();
+            // Parallel id → option map so has()/add()/delete() are O(1) instead of
+            // spreading the Set and linear-scanning it. Rebuilding an O(N²) lookup
+            // for a 16k-option selection was the primary cause of the multi-minute
+            // freeze that surfaced RVT-25383's tree-select scale problem.
+            this.byId = new Map();
+            if (values) {
+                for (const value of values) {
+                    this.add(value);
+                }
+            }
+        }
+        has(option) {
+            return this.byId.has(option.id);
+        }
+        add(option) {
+            const existing = this.byId.get(option.id);
+            if (existing === option) {
+                // Same object reference — nothing to update. Ancestor re-adds
+                // during a selection snapshot hit this path repeatedly, so keeping
+                // it O(1) is what prevents the tree-select N² blow-up seen in
+                // RVT-25470.
+                return this;
+            }
+            if (existing !== undefined) {
+                // Different reference, same id — swap the stored ref while
+                // preserving Set insertion order. The rebuild is O(N), but this
+                // path is rare in practice (the hot ancestor-snapshot loop takes
+                // the identity fast-path above).
+                const items = [...this].map(o => (o.id === option.id ? option : o));
+                this.byId.set(option.id, option);
+                super.clear();
+                for (const item of items)
+                    super.add(item);
+            }
+            else {
+                this.byId.set(option.id, option);
+                super.add(option);
+            }
+            return this;
+        }
+        delete(option) {
+            const existing = this.byId.get(option.id);
+            if (existing) {
+                this.byId.delete(option.id);
+                super.delete(existing);
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        clear() {
+            this.byId.clear();
+            super.clear();
+        }
+    }
+    RivSelect.OptionSet = OptionSet;
+    const MIN_OPTIONS_FOR_CONTROLS = 5;
+    const DEFAULT_DISPLAY_LIMIT = 100;
+    function createManager(source, options) {
+        const defaultState = {
+            query: {
+                search: '',
+                order: 'title',
+            },
+            load: {
+                loading: false,
+                error: null,
+            },
+            sourceOptionGroups: [],
+            originalOptionGroups: [],
+            selection: {
+                selected: new OptionSet(),
+            },
+            display: {
+                placeholder: 'Select',
+                open: false,
+                expandedOptions: new Set(),
+            },
+        };
+        const defaultedInitialState = defaultsDeep({}, options?.initialState, defaultState);
+        const actions = new Subject();
+        const internalActions = new Subject();
+        const coreStateWithSelectionSnapshot = merge(actions, internalActions).pipe(scan(([state, snapshot], action) => {
+            const newState = sideEffects(reduce(state, action, options), action, source, internalActions);
+            const newSelectionSnapshot = (action.type === 'openChange' && action.open) ||
+                (action.type === 'loadComplete' &&
+                    (newState.display.open || options?.inline))
+                ? createSelectionSnapshotWithAncestors(newState)
+                : snapshot;
+            return [newState, newSelectionSnapshot];
+        }, [defaultedInitialState, new OptionSet()]), startWith([
+            defaultedInitialState,
+            new OptionSet(),
+        ]));
+        const state = connectable(coreStateWithSelectionSnapshot.pipe(map(([s, selectionAtOpen]) => {
+            const allOptionGroups = s.sourceOptionGroups.map(optionGroup => {
+                return {
+                    ...optionGroup,
+                    options: optionGroup.options.map(option => augmentOptionToFullOption(s, option, options)),
+                };
+            });
+            const topLevelOptions = getTopLevelOptions(allOptionGroups);
+            const sortedOptionGroups = options?.sortSelectedToTop ?? options?.allowMultiSelect
+                ? sortOptionsByPreviouslySelectedState(allOptionGroups, selectionAtOpen)
+                : allOptionGroups;
+            const displayLimit = options?.displayLimit ?? DEFAULT_DISPLAY_LIMIT;
+            const displayLimitedOptionGroups = applyDisplayLimit(sortedOptionGroups, displayLimit);
+            const fullOptionGroups = applySelectedOptionLimit(s, displayLimitedOptionGroups, topLevelOptions, options);
+            return {
+                ...s,
+                query: {
+                    ...s.query,
+                    showSearch: !!s.query.search ||
+                        (!!options?.allowSearch &&
+                            countAllOptions(allOptionGroups) >
+                                MIN_OPTIONS_FOR_CONTROLS) ||
+                        countAllOptions(allOptionGroups) > displayLimit,
+                    searchPlaceholder: options?.searchPlaceholder ?? 'Search',
+                    showOrder: !!options?.allowOrder &&
+                        !s.query.search &&
+                        countAllOptions(allOptionGroups) > MIN_OPTIONS_FOR_CONTROLS,
+                },
+                fullOptionGroups,
+                selection: {
+                    ...s.selection,
+                    allowMultiSelect: !!options?.allowMultiSelect,
+                    allowSelectAll: !!options?.allowSelectAll &&
+                        options?.selectedOptionLimit == undefined,
+                    visibleSelectionState: getParentMultiSelectionState(topLevelOptions),
+                },
+                display: {
+                    ...s.display,
+                    formattedSelectedOptions: getFormattedOptionsForDisplay(s, topLevelOptions, options),
+                    zeroStateMessage: getZeroStateMessage(s),
+                    dividers: !!options?.dividers,
+                    inline: !!options?.inline,
+                    maxHeight: options?.maxHeight ?? null,
+                    maxWidth: options?.maxWidth ?? null,
+                    minHeight: options?.minHeight ?? null,
+                    minWidth: options?.minWidth ?? null,
+                    displayLimitMessage: getDisplayLimitMessage(countVisibleOptions(fullOptionGroups, !!s.query.search), countVisibleOptions(allOptionGroups, !!s.query.search), s.query),
+                    showSingleSelected: !!options?.showSingleSelected,
+                    pillCount: getPillCountForDisplay(s, topLevelOptions, options),
+                },
+            };
+        })), {
+            connector: () => new ReplaySubject(1),
+            resetOnDisconnect: false,
+        });
+        state.connect();
+        // Load the options immediately for selects that are displayed inline.
+        if (options?.inline)
+            actions.next({ type: 'load' });
+        return { actions, state };
+    }
+    RivSelect.createManager = createManager;
+    function createInMemoryManager(fetchDataset, options) {
+        let data;
+        let fuse;
+        let exactMatch = false;
+        let parents;
+        let children;
+        const source = async (query, mostRecentAction) => {
+            /*
+              Re-fetch the options on the load action, and rebuild the state
+              derived from the option data.
+            */
+            if (mostRecentAction.type === 'load' ||
+                mostRecentAction.type === 'openChange') {
+                data = await fetchDataset();
+                const topLevelOptions = getTopLevelOptions(data);
+                fuse = new Fuse(flattenOptions(topLevelOptions, false), {
+                    threshold: 0.2,
+                    keys: ['title'],
+                    includeScore: true,
+                    includeMatches: true,
+                    ...options?.fuseOptions,
+                });
+                exactMatch = options?.fuseOptions?.threshold == 0;
+                [parents, children] = getRelationshipMaps(topLevelOptions);
+            }
+            // Leading/trailing whitespace shouldn't affect fuzzy matching (Fuse
+            // scores the pattern's length against the text's, so a stray space
+            // changes results in surprising ways); a search string of only
+            // whitespace is treated the same as no search.
+            const search = query.search.trim();
+            /*
+              If the user is not searching options, return the full set of options
+              sorted appropriately.
+            */
+            if (!search) {
+                /*
+                  The `source` order property allows for opting out of automatic
+                  sorting, returning the data in its natural input order.
+                */
+                if (query.order === 'source')
+                    return data;
+                /*
+                  Sort the options by title and subtitle.
+                */
+                if (query.order === 'title') {
+                    function sortByTitle(options) {
+                        return sortBy(options, [
+                            (o) => o.title.toLowerCase(),
+                            (o) => o.subtitle?.toLowerCase() ?? '',
+                        ]).map(option => ({
+                            ...option,
+                            children: option.children?.length
+                                ? sortByTitle(option.children)
+                                : undefined,
+                        }));
+                    }
+                    return data.map(group => ({
+                        ...group,
+                        options: sortByTitle(group.options),
+                    }));
+                }
+                /*
+                  Sort the options by count, then by title, then by subtitle.
+                */
+                if (query.order === 'count') {
+                    function sortByCount(options) {
+                        return sortBy(options, [
+                            (o) => (isNumber(o.count) ? -o.count : Infinity),
+                            (o) => o.title.toLowerCase(),
+                            (o) => o.subtitle?.toLowerCase() ?? '',
+                        ]).map(option => ({
+                            ...option,
+                            children: option.children?.length
+                                ? sortByCount(option.children)
+                                : undefined,
+                        }));
+                    }
+                    return data.map(group => ({
+                        ...group,
+                        options: sortByCount(group.options),
+                    }));
+                }
+            }
+            /*
+              Execute the search with fuse. Once we have the search match data,
+              rebuild just as much of the tree as is needed to render the search
+              results. Specifically, any match will need all of its ancestors (so
+              that matched leaf nodes are shown nested under their ancestors) and all
+              of its children (because a matching parent means that all of its
+              descendants match too, per the design specification), whether they
+              themselves matched or not.
+            */
+            const matchedOptions = fuse.search(search);
+            const matchedIds = new Set(matchedOptions.map(result => result.item.id));
+            const matchAncestors = new Set();
+            function collectAncestors(ids) {
+                for (const id of ids) {
+                    const parentId = parents.get(id);
+                    if (parentId) {
+                        matchAncestors.add(parentId);
+                        collectAncestors([parentId]);
+                    }
+                }
+            }
+            collectAncestors([...matchedIds]);
+            const matchDescendants = new Set();
+            function collectDescendants(ids) {
+                for (const id of ids) {
+                    const childrenIds = children.get(id);
+                    if (childrenIds) {
+                        for (const child of childrenIds) {
+                            matchDescendants.add(child);
+                        }
+                        collectDescendants(childrenIds);
+                    }
+                }
+            }
+            collectDescendants([...matchedIds]);
+            /*
+              Next, we'll combine all the matched IDs with their direct ancestors and
+              descandants, and filter the original data set down to just these
+              options.
+            */
+            const filteredIds = new Set([
+                ...matchedIds,
+                ...matchAncestors,
+                ...matchDescendants,
+            ]);
+            function filterOptions(options) {
+                const filteredOptions = [];
+                for (const option of options) {
+                    if (filteredIds.has(option.id)) {
+                        filteredOptions.push({
+                            ...option,
+                            children: option.children?.length
+                                ? filterOptions(option.children)
+                                : undefined,
+                        });
+                    }
+                }
+                return filteredOptions;
+            }
+            const filteredOptions = filterOptions(getTopLevelOptions(data));
+            /*
+              At this point, we have an array of distinct trees (top-level options),
+              filtered down to only the options matching the search query. Note that
+              we don't care about section headers when searching since results should
+              be ordered by relevance. To calculate the order of these trees, we'll
+              take the total match scores for options found in the tree, divided by
+              the count of matches in the tree (the best average match score).
+            */
+            const scoreMap = new Map(matchedOptions.map(result => [result.item.id, result.score ?? 0]));
+            const ordered = sortBy(filteredOptions, (option) => {
+                function calculateScore(option) {
+                    return ((scoreMap.get(option.id) ?? 0) +
+                        (option.children ?? []).reduce((score, child) => score + calculateScore(child), 0));
+                }
+                function calculateCount(option) {
+                    return (1 +
+                        (option.children ?? []).reduce((count, child) => count + calculateCount(child), 0));
+                }
+                const totalScore = calculateScore(option);
+                const totalCount = calculateCount(option);
+                return totalScore / totalCount;
+            });
+            const highlightMap = new Map(matchedOptions.map(result => {
+                const highlights = {};
+                for (const match of result.matches ?? []) {
+                    // filter out inexact matches
+                    if (exactMatch && match.value != null) {
+                        match.indices = match.indices.filter(isFuseMatchExact(match, search));
+                    }
+                    if (match.key === 'title') {
+                        highlights.titleHighlightIndices = [...match.indices];
+                    }
+                    if (match.key === 'subtitle') {
+                        highlights.subtitleHighlightIndices = [...match.indices];
+                    }
+                }
+                return [result.item.id, highlights];
+            }));
+            function addHighlightsToOption(options) {
+                return options.map(option => ({
+                    ...option,
+                    ...highlightMap.get(option.id),
+                    ...(option.children?.length
+                        ? { children: addHighlightsToOption(option.children) }
+                        : null),
+                }));
+            }
+            return {
+                data: [{ options: addHighlightsToOption(ordered) }],
+                originalData: data,
+            };
+        };
+        return createManager(source, options);
+    }
+    RivSelect.createInMemoryManager = createInMemoryManager;
+    function isFuseMatchExact(match, search) {
+        return matchedIndices => {
+            const matchedValue = match
+                .value.slice(matchedIndices[0], matchedIndices[1] + 1)
+                .toLowerCase();
+            // fuse is weird with it's matches. For a text of "planning" and a search string of "plan"
+            // the matched value will be "plann" with the extra 'n' because of its fuzzy matching.
+            // so just make sure the matched value at least starts with the search string.
+            // it's extra weird because for a text of "analytics" and a search string of "nalytics",
+            // the matched value will be "analytics". So we just need to make sure the the matched value
+            // includes the search string because there might be extra stuff on the front or the end.
+            return matchedValue.includes(search.toLowerCase());
+        };
+    }
+    RivSelect.isFuseMatchExact = isFuseMatchExact;
+    //////////////////////////////////
+    // State reducer (with helpers) //
+    //////////////////////////////////
+    function createSelectionSnapshotWithAncestors(state) {
+        const snapshot = new OptionSet(state.selection.selected);
+        const topLevelOptions = getTopLevelOptions(state.sourceOptionGroups);
+        const [parents] = getRelationshipMaps(topLevelOptions);
+        // Sibling leaves share ancestors, so once we've walked up through a
+        // given parent id we can stop — anything above it has already been
+        // added by a previous iteration. Without this short-circuit the loop
+        // re-runs findOption (which is a full tree walk) once per shared
+        // ancestor edge, which was the #2 hotspot behind OptionSet.add in
+        // RVT-25470's profile.
+        const visited = new Set();
+        for (const selectedOption of state.selection.selected) {
+            let parentId = parents.get(selectedOption.id);
+            while (parentId !== undefined && !visited.has(parentId)) {
+                visited.add(parentId);
+                const parentOption = findOption(topLevelOptions, parentId);
+                if (parentOption) {
+                    snapshot.add(parentOption);
+                }
+                parentId = parents.get(parentId);
+            }
+        }
+        return snapshot;
+    }
+    function getDisplayLimitMessage(displayedOptionCount, totalOptionCount, query) {
+        if (displayedOptionCount === totalOptionCount)
+            return null;
+        const rivNumber = new NumberPipe();
+        const displayed = rivNumber.transform(displayedOptionCount);
+        const total = rivNumber.transform(totalOptionCount);
+        const start = `Showing ${displayed} of ${total} options`;
+        return query.search ? `${start} matching "${query.search}"` : start;
+    }
+    function countVisibleOptions(optionGroups, leafOnly) {
+        function count(options) {
+            return options.reduce((acc, option) => {
+                if (option.expanded && option.children?.length) {
+                    return acc + (leafOnly ? 0 : 1) + count(option.children);
+                }
+                return acc + 1;
+            }, 0);
+        }
+        return optionGroups.reduce((total, group) => total + count(group.options), 0);
+    }
+    function countAllOptions(optionGroups) {
+        function count(options) {
+            return options.reduce((acc, option) => {
+                if (option.children?.length) {
+                    return acc + 1 + count(option.children);
+                }
+                return acc + 1;
+            }, 0);
+        }
+        return optionGroups.reduce((total, group) => total + count(group.options), 0);
+    }
+    function applyDisplayLimit(optionGroups, displayLimit) {
+        function filterWithLimit(options, remaining) {
+            let left = remaining;
+            const visibleOptions = [];
+            for (const option of options) {
+                if (left <= 0)
+                    break;
+                if (option.expanded && option.children?.length) {
+                    const [childOptions, childRemaining] = filterWithLimit(option.children, left - 1);
+                    visibleOptions.push({
+                        ...option,
+                        children: childOptions,
+                    });
+                    left = childRemaining;
+                }
+                else {
+                    visibleOptions.push(option);
+                    left--;
+                }
+            }
+            return [visibleOptions, left];
+        }
+        const startingValue = [[], displayLimit];
+        const [resolvedGroups] = optionGroups.reduce(([groups, remaining], group) => {
+            const [options, leftAfter] = filterWithLimit(group.options, remaining);
+            if (options.length) {
+                return [[...groups, { ...group, options }], leftAfter];
+            }
+            else {
+                return [groups, remaining];
+            }
+        }, startingValue);
+        return resolvedGroups;
+    }
+    /*
+      Sort options so that previously selected options (from prior sessions)
+      appear at the top of their peer/sibling lists.
+    */
+    function sortOptionsByPreviouslySelectedState(optionGroups, selectionAtOpen) {
+        function sortOptions(options) {
+            return sortBy(options, option => !selectionAtOpen.has(option)).map(option => {
+                if (option.children) {
+                    return {
+                        ...option,
+                        children: sortOptions(option.children),
+                    };
+                }
+                else
+                    return option;
+            });
+        }
+        return optionGroups.map(group => ({
+            ...group,
+            options: sortOptions(group.options),
+        }));
+    }
+    /*
+      If we are restricting how many options are selected to a specific limit,
+        when we are at that limit, disable all options not currently selected.
+    */
+    function applySelectedOptionLimit(state, optionGroups, topLevelOptions, options) {
+        if (options?.selectedOptionLimit === undefined) {
+            return optionGroups;
+        }
+        // When useTopLevelOptionsForDisplay is true and search is active, count
+        // selected top-level options from the original (unfiltered) data to ensure
+        // already-selected options that don't match the search are still counted.
+        const useOriginalForCounting = options?.useTopLevelOptionsForDisplay &&
+            state.query.search &&
+            state.originalOptionGroups.length > 0;
+        const topOptionsForCounting = useOriginalForCounting
+            ? getTopLevelOptions(state.originalOptionGroups).map(option => augmentOptionToFullOption(state, option, options))
+            : topLevelOptions;
+        const selectedOrIndeterminateTopOptions = topOptionsForCounting.filter(option => option.selected != false);
+        const numSelectedOptions = options?.useTopLevelOptionsForDisplay
+            ? selectedOrIndeterminateTopOptions.length
+            : state.selection.selected.size;
+        const selectedOptionLimit = options.selectedOptionLimit;
+        // If we have less items selected than the limit, business as usual.
+        if (numSelectedOptions < selectedOptionLimit) {
+            return optionGroups;
+        }
+        // If we have equal items selected to the limit (or more), prevent users from selecting more options.
+        function disableUnselectedItems(currentOptions, optionsAreChildrenOfSelectedGroup) {
+            const updatedItems = [];
+            for (const option of currentOptions) {
+                const isDisabledOrUnselected = !!option.disabled || (option.selectable && option.selected == false);
+                const isCurrentOptionSelected = option.selectable && option.selected != false;
+                const isCurrentOrParentOptionSelected = isCurrentOptionSelected || optionsAreChildrenOfSelectedGroup;
+                const forceEnabledBasedOnParent = !!options?.useTopLevelOptionsForDisplay &&
+                    optionsAreChildrenOfSelectedGroup;
+                const markDisabled = isDisabledOrUnselected && !forceEnabledBasedOnParent;
+                if (option.children?.length) {
+                    const childOptions = disableUnselectedItems(option.children, isCurrentOrParentOptionSelected);
+                    updatedItems.push({
+                        ...option,
+                        disabled: !!markDisabled,
+                        children: childOptions,
+                    });
+                }
+                else {
+                    updatedItems.push({
+                        ...option,
+                        disabled: !!markDisabled,
+                    });
+                }
+            }
+            return updatedItems;
+        }
+        const groupsAfterLimit = [];
+        for (const currentGroup of optionGroups) {
+            groupsAfterLimit.push({
+                ...currentGroup,
+                options: disableUnselectedItems(currentGroup.options, false),
+            });
+        }
+        return groupsAfterLimit;
+    }
+    function getRelationshipMaps(options) {
+        const parents = new Map();
+        function buildParentsMap(options, parent) {
+            for (const option of options) {
+                if (parent) {
+                    parents.set(option.id, parent.id);
+                }
+                if (option.children?.length) {
+                    buildParentsMap(option.children, option);
+                }
+            }
+        }
+        buildParentsMap(options);
+        const children = new Map();
+        function buildChildrenMap(options) {
+            for (const option of options) {
+                if (option.children?.length) {
+                    children.set(option.id, option.children.map(({ id }) => id));
+                    buildChildrenMap(option.children);
+                }
+            }
+        }
+        buildChildrenMap(options);
+        return [parents, children];
+    }
+    function getTopLevelOptions(optionGroups) {
+        return optionGroups.reduce((options, group) => [...options, ...group.options], []);
+    }
+    function getParentMultiSelectionState(children) {
+        if (children.every(child => child.selected === true))
+            return true;
+        if (children.every(child => child.selected === false))
+            return false;
+        return 'indeterminate';
+    }
+    function augmentOptionToFullOption(state, option, managerOptions) {
+        if (option.children?.length) {
+            const augmentedChildren = option.children.map(child => augmentOptionToFullOption(state, child, managerOptions));
+            const selectableWhenSearching = managerOptions?.allowSelectNonLeafDuringSearch ?? false;
+            // When allowSelectNonLeafDuringSearch is enabled and search is active,
+            // calculate selection state from ALL original children, not just the
+            // filtered ones visible in search results.
+            const useOriginalForSelectionState = managerOptions?.allowSelectNonLeafDuringSearch &&
+                state.query.search &&
+                state.originalOptionGroups.length > 0;
+            let selected;
+            if (useOriginalForSelectionState) {
+                const originalOption = findOption(getTopLevelOptions(state.originalOptionGroups), option.id);
+                if (originalOption) {
+                    const allLeaves = flattenOptions([originalOption], true);
+                    const selectedCount = allLeaves.filter(leaf => state.selection.selected.has(leaf)).length;
+                    if (selectedCount === 0) {
+                        selected = false;
+                    }
+                    else if (selectedCount === allLeaves.length) {
+                        selected = true;
+                    }
+                    else {
+                        selected = 'indeterminate';
+                    }
+                }
+                else {
+                    selected = getParentMultiSelectionState(augmentedChildren);
+                }
+            }
+            else {
+                selected = getParentMultiSelectionState(augmentedChildren);
+            }
+            return {
+                ...option,
+                children: augmentedChildren,
+                selected,
+                expanded: state.query.search
+                    ? true
+                    : state.display.expandedOptions.has(option.id),
+                selectable: !state.query.search || selectableWhenSearching,
+                expandable: !state.query.search,
+            };
+        }
+        return {
+            ...option,
+            children: undefined,
+            selected: state.selection.selected.has(option),
+            expanded: false,
+            selectable: true,
+            expandable: false,
+        };
+    }
+    function getFormattedOptionsForDisplay(state, topLevelOptions, options) {
+        // If we have a custom display function, use it
+        if (options?.getCustomOptionDisplay) {
+            return options.getCustomOptionDisplay([...state.selection.selected]);
+        }
+        if (options?.useTopLevelOptionsForDisplay) {
+            return getTopLevelFormattedOptionsForDisplay(topLevelOptions);
+        }
+        // Otherwise, use the default display for options - titles separated by commas.
+        return [...state.selection.selected].map(({ title }) => title).join(', ');
+    }
+    function getTopLevelFormattedOptionsForDisplay(topLevelOptions) {
+        if (!topLevelOptions || topLevelOptions.length == 0) {
+            return '';
+        }
+        const selectedOrIndeterminateTopOptions = topLevelOptions.filter(option => option.selected != false);
+        return selectedOrIndeterminateTopOptions
+            .map(({ title }) => title)
+            .join(', ');
+    }
+    function getPillCountForDisplay(state, topLevelOptions, options) {
+        if (options?.useTopLevelOptionsForDisplay) {
+            const selectedOrIndeterminateTopOptions = topLevelOptions.filter(option => option.selected != false);
+            return selectedOrIndeterminateTopOptions.length;
+        }
+        return state.selection.selected.size;
+    }
+    function getZeroStateMessage(state) {
+        if (state.sourceOptionGroups.every(group => group.options.length === 0)) {
+            if (state.query.search)
+                return 'No results found.';
+            return 'No options.';
+        }
+        return null;
+    }
+    function findOption(options, id) {
+        for (const option of options) {
+            if (option.id === id)
+                return option;
+            if (option.children?.length) {
+                const child = findOption(option.children, id);
+                if (child)
+                    return child;
+            }
+        }
+        return null;
+    }
+    function flattenOptions(options, leafOnly) {
+        return flattenDeep(options.map(option => {
+            if (option.children?.length) {
+                const descendants = option.children.map(child => flattenOptions([child], leafOnly));
+                return leafOnly ? descendants : [option, ...descendants];
+            }
+            else {
+                return [option];
+            }
+        }));
+    }
+    function toggleSelected(state, id, managerOptions) {
+        const topLevelOptions = getTopLevelOptions(state.sourceOptionGroups);
+        const option = findOption(topLevelOptions, id);
+        if (!option)
+            return state;
+        const newSelection = new OptionSet(state.selection.selected);
+        const newValue = !(augmentOptionToFullOption(state, option, managerOptions).selected === true);
+        // When allowSelectNonLeafDuringSearch is enabled and search is active,
+        // use the original (unfiltered) data to get all children, not just
+        // those visible in the filtered search results.
+        const useOriginalData = managerOptions?.allowSelectNonLeafDuringSearch &&
+            state.query.search &&
+            state.originalOptionGroups.length > 0;
+        const optionForLeaves = useOriginalData
+            ? findOption(getTopLevelOptions(state.originalOptionGroups), id) ?? option
+            : option;
+        const leaves = flattenOptions([optionForLeaves], true);
+        for (const leaf of leaves) {
+            if (newValue) {
+                newSelection.add(leaf);
+            }
+            else {
+                newSelection.delete(leaf);
+            }
+        }
+        return {
+            ...state,
+            selection: {
+                selected: newSelection,
+            },
+        };
+    }
+    function setSelectedOption(state, id) {
+        const topLevelOptions = getTopLevelOptions(state.sourceOptionGroups);
+        const option = findOption(topLevelOptions, id);
+        if (!option)
+            return state;
+        const newSelection = new OptionSet();
+        newSelection.add(option);
+        return {
+            ...state,
+            selection: {
+                selected: newSelection,
+            },
+        };
+    }
+    function toggleVisibleSelected(state) {
+        const leaves = flattenOptions(getTopLevelOptions(state.sourceOptionGroups), true);
+        const isAllSelected = leaves.every(leaf => state.selection.selected.has(leaf));
+        const newSelection = new OptionSet(state.selection.selected);
+        for (const leaf of leaves) {
+            if (isAllSelected)
+                newSelection.delete(leaf);
+            else
+                newSelection.add(leaf);
+        }
+        return {
+            ...state,
+            selection: {
+                ...state.selection,
+                selected: newSelection,
+            },
+        };
+    }
+    function toggleOptionExpanded(state, id) {
+        const newValue = !state.display.expandedOptions.has(id);
+        const newExpandedOptions = new Set(state.display.expandedOptions);
+        if (newValue)
+            newExpandedOptions.add(id);
+        else
+            newExpandedOptions.delete(id);
+        return {
+            ...state,
+            display: {
+                ...state.display,
+                expandedOptions: newExpandedOptions,
+            },
+        };
+    }
+    function sideEffects(state, action, source, internalActions) {
+        if (action.type === 'load' ||
+            action.type === 'searchChange' ||
+            action.type === 'orderChange' ||
+            (action.type === 'openChange' && action.open)) {
+            source(state.query, action)
+                .then(result => {
+                const data = Array.isArray(result) ? result : result.data;
+                const originalData = Array.isArray(result)
+                    ? undefined
+                    : result.originalData;
+                internalActions.next({ type: 'loadComplete', data, originalData });
+            })
+                .catch(error => {
+                // eslint-disable-next-line no-console
+                console.error(error);
+                internalActions.next({ type: 'loadError', error });
+            });
+            return {
+                ...state,
+                load: {
+                    loading: true,
+                    error: null,
+                },
+            };
+        }
+        return state;
+    }
+    function reduce(state, action, managerOptions) {
+        switch (action.type) {
+            case 'load':
+                return state;
+            case 'loadComplete':
+                return {
+                    ...state,
+                    load: {
+                        loading: false,
+                        error: null,
+                    },
+                    sourceOptionGroups: action.data,
+                    originalOptionGroups: action.originalData ?? [],
+                };
+            case 'loadError':
+                return {
+                    ...state,
+                    load: {
+                        loading: false,
+                        error: action.error,
+                    },
+                };
+            case 'openChange':
+                return {
+                    ...state,
+                    query: {
+                        ...state.query,
+                        search: '',
+                    },
+                    display: {
+                        ...state.display,
+                        open: action.open,
+                    },
+                };
+            case 'searchChange':
+                return {
+                    ...state,
+                    query: {
+                        ...state.query,
+                        search: action.payload,
+                    },
+                };
+            case 'orderChange':
+                return {
+                    ...state,
+                    query: {
+                        ...state.query,
+                        order: action.payload,
+                    },
+                };
+            case 'selectionChange':
+                return {
+                    ...state,
+                    selection: action.payload,
+                };
+            case 'toggleOptionSelected':
+                return toggleSelected(state, action.id, managerOptions);
+            case 'setSelectedOption':
+                return setSelectedOption(state, action.id);
+            case 'visibleSelectedChange':
+                return toggleVisibleSelected(state);
+            case 'toggleOptionExpanded':
+                return toggleOptionExpanded(state, action.id);
+        }
+    }
+})(RivSelect || (RivSelect = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state.js","sourceRoot":"","sources":["../../../../../../projects/riv/src/lib/input/select/state.ts"],"names":[],"mappings":"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","sourcesContent":["import Fuse, {\n  FuseResult,\n  FuseResultMatch,\n  IFuseOptions,\n  RangeTuple,\n} from 'fuse.js';\nimport { defaultsDeep, flattenDeep, isNumber, sortBy } from 'lodash';\nimport {\n  connectable,\n  Connectable,\n  map,\n  merge,\n  Observable,\n  ReplaySubject,\n  scan,\n  startWith,\n  Subject,\n} from 'rxjs';\nimport { DeepPartial } from 'utility-types';\nimport { NumberPipe } from '../../format/pipes/number.pipe';\nimport { HighlightComponent } from '../../visualization/highlight/highlight.component';\n\nexport namespace RivSelect {\n  /////////////\n  // Options //\n  /////////////\n\n  /**\n   * ┌─────────────────────-------------------───┐\n   * │ BaseOption                                │\n   * │                                           │\n   * │ The core data required for each option    │\n   * │ (such as id and title).                   │\n   * ├──────────────────────-------------------──┤\n   * │ Option (BaseOption + children)            │\n   * │                                           │\n   * │ Provides recursive type safety to the     │\n   * │ type safety to the BaseOption.            │\n   * └─------------------┬-------────────────────┘\n   *                     |\n   * ┌───────────────────▼───────────────────────┐\n   * │ SourceOption (Option + search highlights) │\n   * │                                           │\n   * │ Adds search highlights to the Option and  │\n   * │ is the return type for the option Source  │\n   * │ (data fetcher) function.                  │\n   * └───────────────────┬───────────────────────┘\n   *                     |\n   * ┌───────────────────▼───────────────────────┐\n   * │ FullOption (SourceOption + UI state)      │\n   * │                                           │\n   * │ Augments the SourceOption with all of the │\n   * │ UI information from other parts of the    │\n   * │ state, such as selection status, whether  │\n   * │ or not the node is expanded, etc.         │\n   * └───────────────────────────────────────────┘\n   *\n   * Note that the usages of Omit<...> in this section are not required, but\n   * do help in-editor type hints to be more clear and direct.\n   */\n\n  export type BaseOption = {\n    id: string | number;\n    title: string;\n    subtitle?: string;\n    help?: string;\n    count?: number;\n    disabled?: boolean;\n    disabledExplanation?: string;\n  };\n  export type Option<O extends BaseOption = BaseOption> = O & {\n    children?: Option<O>[];\n  };\n\n  export type SourceOption<O extends BaseOption> = Omit<\n    Option<O>,\n    'children'\n  > & {\n    titleHighlightIndices?: HighlightComponent.HighlightIndices[];\n    subtitleHighlightIndices?: HighlightComponent.HighlightIndices[];\n    children?: SourceOption<O>[];\n  };\n\n  export type MultiSelectionState = boolean | 'indeterminate';\n\n  export type FullOption<O extends BaseOption> = Omit<\n    SourceOption<O>,\n    'children'\n  > & {\n    selected: MultiSelectionState;\n    expanded: boolean;\n    selectable: boolean;\n    expandable: boolean;\n    children?: FullOption<O>[];\n  };\n\n  ///////////////////\n  // Option groups //\n  ///////////////////\n\n  /**\n   * The relationships between OptionGroup, SourceOptionGroup, and\n   * FullOptionGroup is analogous to the option types above.\n   *\n   * As with before, the use of Omit<...> is not required but helpful.\n   */\n\n  export type OptionGroup<O extends BaseOption> = {\n    header?: string;\n    /** Info icon + tooltip shown beside the header. No-op without a header. */\n    help?: string;\n    options: Option<O>[];\n  };\n\n  export type SourceOptionGroup<O extends BaseOption> = Omit<\n    OptionGroup<O>,\n    'options'\n  > & {\n    options: SourceOption<O>[];\n  };\n\n  export type FullOptionGroup<O extends BaseOption> = Omit<\n    SourceOptionGroup<O>,\n    'options'\n  > & {\n    options: FullOption<O>[];\n  };\n\n  /**\n   * The OptionSet class provides Set-like functionality, but uniqueness is\n   * determined by the option's ID rather than the object reference.\n   */\n  export class OptionSet<O extends BaseOption> extends Set<SourceOption<O>> {\n    // Parallel id → option map so has()/add()/delete() are O(1) instead of\n    // spreading the Set and linear-scanning it. Rebuilding an O(N²) lookup\n    // for a 16k-option selection was the primary cause of the multi-minute\n    // freeze that surfaced RVT-25383's tree-select scale problem.\n    private readonly byId = new Map<O['id'], SourceOption<O>>();\n\n    constructor(values?: Iterable<SourceOption<O>> | null) {\n      super();\n      if (values) {\n        for (const value of values) {\n          this.add(value);\n        }\n      }\n    }\n\n    override has(option: SourceOption<O> | FullOption<O>) {\n      return this.byId.has(option.id);\n    }\n\n    override add(option: SourceOption<O>) {\n      const existing = this.byId.get(option.id);\n      if (existing === option) {\n        // Same object reference — nothing to update. Ancestor re-adds\n        // during a selection snapshot hit this path repeatedly, so keeping\n        // it O(1) is what prevents the tree-select N² blow-up seen in\n        // RVT-25470.\n        return this;\n      }\n      if (existing !== undefined) {\n        // Different reference, same id — swap the stored ref while\n        // preserving Set insertion order. The rebuild is O(N), but this\n        // path is rare in practice (the hot ancestor-snapshot loop takes\n        // the identity fast-path above).\n        const items = [...this].map(o => (o.id === option.id ? option : o));\n        this.byId.set(option.id, option);\n        super.clear();\n        for (const item of items) super.add(item);\n      } else {\n        this.byId.set(option.id, option);\n        super.add(option);\n      }\n      return this;\n    }\n\n    override delete(option: SourceOption<O>) {\n      const existing = this.byId.get(option.id);\n      if (existing) {\n        this.byId.delete(option.id);\n        super.delete(existing);\n        return true;\n      } else {\n        return false;\n      }\n    }\n\n    override clear() {\n      this.byId.clear();\n      super.clear();\n    }\n  }\n\n  ///////////\n  // State //\n  ///////////\n\n  /**\n   * The CoreState provides all of the foundational pieces of state required\n   * for a working component. FullState is a pure derivation of CoreState plus\n   * the configuration options, and provides conveniences for rendering the\n   * components. Actions and the core state are passed to the reducer to\n   * produce new CoreStates (which are then used to calculate new FullStates).\n   *\n   * ┌──────┐\n   * │  UI  ◄────────┐\n   * └──┬───┘        │\n   *    │            │\n   * ┌──▼────────┐   │\n   * │  Actions  │   │\n   * └──┬────────┘   │\n   *    │            │\n   * ┌──▼────────────┴─┐\n   * │  State reducer  │\n   * └─────────────────┘\n   */\n\n  export type OrderBy = 'title' | 'count' | 'source';\n\n  const MIN_OPTIONS_FOR_CONTROLS = 5;\n\n  const DEFAULT_DISPLAY_LIMIT = 100;\n\n  export type CoreState<O extends BaseOption> = {\n    query: {\n      search: string;\n      order: OrderBy;\n    };\n    load: {\n      loading: boolean;\n      error: unknown | null;\n    };\n    sourceOptionGroups: SourceOptionGroup<O>[];\n    /**\n     * Stores the unfiltered original option groups when search filtering is active.\n     * Used by `allowSelectNonLeafDuringSearch` to select all children of a parent,\n     * including those not visible in the filtered search results.\n     */\n    originalOptionGroups: SourceOptionGroup<O>[];\n    selection: {\n      selected: OptionSet<O>;\n    };\n    display: {\n      placeholder: string;\n      open: boolean;\n      expandedOptions: Set<O['id']>;\n    };\n  };\n\n  export type FullState<O extends BaseOption> = CoreState<O> & {\n    query: {\n      showSearch: boolean;\n      searchPlaceholder: string;\n      showOrder: boolean;\n    };\n    fullOptionGroups: FullOptionGroup<O>[];\n    selection: {\n      allowMultiSelect: boolean;\n      allowSelectAll: boolean;\n      visibleSelectionState: MultiSelectionState;\n    };\n    display: {\n      formattedSelectedOptions: string;\n      zeroStateMessage: string | null;\n      dividers: boolean;\n      inline: boolean;\n      maxHeight: string | null;\n      maxWidth: string | null;\n      minHeight: string | null;\n      minWidth: string | null;\n      displayLimitMessage: string | null;\n      showSingleSelected: boolean;\n      pillCount: number;\n    };\n  };\n\n  /////////////\n  // Actions //\n  /////////////\n\n  export type Action<O extends BaseOption> =\n    | { type: 'load' }\n    | { type: 'openChange'; open: boolean }\n    | { type: 'searchChange'; payload: string }\n    | { type: 'orderChange'; payload: OrderBy }\n    | {\n        type: 'selectionChange';\n        payload: CoreState<O>['selection'];\n      }\n    | {\n        type: 'toggleOptionSelected';\n        id: O['id'];\n      }\n    | {\n        type: 'setSelectedOption';\n        id: O['id'];\n      }\n    | {\n        type: 'visibleSelectedChange';\n      }\n    | {\n        type: 'toggleOptionExpanded';\n        id: O['id'];\n      };\n\n  type InternalAction<O extends BaseOption> =\n    | {\n        type: 'loadComplete';\n        data: SourceOptionGroup<O>[];\n        /** Original unfiltered data, provided when search is active */\n        originalData?: SourceOptionGroup<O>[];\n      }\n    | { type: 'loadError'; error: unknown };\n\n  ////////////\n  // Source //\n  ////////////\n\n  /**\n   * The Source's job is to fetch options (based on the current state) which\n   * then blend with the other pieces of state to produce the FullState.\n   */\n\n  export type SourceResult<O extends BaseOption> =\n    | SourceOptionGroup<O>[]\n    | {\n        data: SourceOptionGroup<O>[];\n        /**\n         * Original unfiltered data, provided when search filtering is active.\n         * Used by `allowSelectNonLeafDuringSearch` to select all children of\n         * a parent, including those not visible in the filtered search results.\n         */\n        originalData?: SourceOptionGroup<O>[];\n      };\n\n  export type Source<O extends BaseOption> = (\n    query: CoreState<O>['query'],\n    mostRecentAction: Action<O>,\n  ) => Promise<SourceResult<O>>;\n\n  /////////////\n  // Manager //\n  /////////////\n\n  export type Manager<O extends BaseOption> = {\n    actions: Subject<Action<O>>;\n    state: Connectable<FullState<O>>;\n  };\n\n  export type ManagerOptions<O extends BaseOption> = {\n    initialState?: DeepPartial<CoreState<O>>;\n    allowMultiSelect?: boolean;\n    allowSearch?: boolean;\n    allowSelectAll?: boolean;\n    allowOrder?: boolean;\n    searchPlaceholder?: string;\n    dividers?: boolean;\n    inline?: boolean;\n    maxHeight?: string | null;\n    maxWidth?: string | null;\n    minHeight?: string | null;\n    minWidth?: string | null;\n    displayLimit?: number;\n    selectedOptionLimit?: number;\n    showSingleSelected?: boolean;\n    useTopLevelOptionsForDisplay?: boolean;\n    getCustomOptionDisplay?: (selectedOptions: SourceOption<O>[]) => string;\n    /**\n     * When true, non-leaf nodes (parents) remain selectable during search,\n     * and selecting them will select/deselect ALL children from the original\n     * dataset, not just the visible filtered results.\n     *\n     * Default: false (current behavior - parents are not selectable during search)\n     */\n    allowSelectNonLeafDuringSearch?: boolean;\n    /**\n     * When true, options that were selected when the select was opened are\n     * sorted to the top of their sibling lists. Set to false to preserve the\n     * natural (or chosen OrderBy) order instead.\n     *\n     * Default: the value of allowMultiSelect\n     */\n    sortSelectedToTop?: boolean;\n  };\n\n  export function createManager<O extends BaseOption>(\n    source: Source<O>,\n    options?: ManagerOptions<O>,\n  ): Manager<O> {\n    const defaultState: CoreState<O> = {\n      query: {\n        search: '',\n        order: 'title',\n      },\n      load: {\n        loading: false,\n        error: null,\n      },\n      sourceOptionGroups: [],\n      originalOptionGroups: [],\n      selection: {\n        selected: new OptionSet(),\n      },\n      display: {\n        placeholder: 'Select',\n        open: false,\n        expandedOptions: new Set(),\n      },\n    };\n    const defaultedInitialState: CoreState<O> = defaultsDeep(\n      {},\n      options?.initialState,\n      defaultState,\n    );\n\n    const actions: Subject<Action<O>> = new Subject();\n    const internalActions: Subject<InternalAction<O>> = new Subject();\n\n    const coreStateWithSelectionSnapshot: Observable<\n      [CoreState<O>, OptionSet<O>]\n    > = merge(actions, internalActions).pipe(\n      scan<Action<O> | InternalAction<O>, [CoreState<O>, OptionSet<O>]>(\n        ([state, snapshot], action) => {\n          const newState = sideEffects(\n            reduce(state, action, options),\n            action,\n            source,\n            internalActions,\n          );\n\n          const newSelectionSnapshot =\n            (action.type === 'openChange' && action.open) ||\n            (action.type === 'loadComplete' &&\n              (newState.display.open || options?.inline))\n              ? createSelectionSnapshotWithAncestors(newState)\n              : snapshot;\n\n          return [newState, newSelectionSnapshot];\n        },\n        [defaultedInitialState, new OptionSet<O>()],\n      ),\n      startWith<[CoreState<O>, OptionSet<O>]>([\n        defaultedInitialState,\n        new OptionSet<O>(),\n      ]),\n    );\n\n    const state: Connectable<FullState<O>> = connectable(\n      coreStateWithSelectionSnapshot.pipe(\n        map(([s, selectionAtOpen]) => {\n          const allOptionGroups: FullOptionGroup<O>[] =\n            s.sourceOptionGroups.map(optionGroup => {\n              return {\n                ...optionGroup,\n                options: optionGroup.options.map(option =>\n                  augmentOptionToFullOption(s, option, options),\n                ),\n              };\n            });\n\n          const topLevelOptions = getTopLevelOptions(allOptionGroups);\n\n          const sortedOptionGroups =\n            options?.sortSelectedToTop ?? options?.allowMultiSelect\n              ? sortOptionsByPreviouslySelectedState(\n                  allOptionGroups,\n                  selectionAtOpen,\n                )\n              : allOptionGroups;\n\n          const displayLimit = options?.displayLimit ?? DEFAULT_DISPLAY_LIMIT;\n          const displayLimitedOptionGroups = applyDisplayLimit(\n            sortedOptionGroups,\n            displayLimit,\n          );\n          const fullOptionGroups = applySelectedOptionLimit(\n            s,\n            displayLimitedOptionGroups,\n            topLevelOptions,\n            options,\n          );\n\n          return {\n            ...s,\n            query: {\n              ...s.query,\n              showSearch:\n                !!s.query.search ||\n                (!!options?.allowSearch &&\n                  countAllOptions(allOptionGroups) >\n                    MIN_OPTIONS_FOR_CONTROLS) ||\n                countAllOptions(allOptionGroups) > displayLimit,\n              searchPlaceholder: options?.searchPlaceholder ?? 'Search',\n              showOrder:\n                !!options?.allowOrder &&\n                !s.query.search &&\n                countAllOptions(allOptionGroups) > MIN_OPTIONS_FOR_CONTROLS,\n            },\n            fullOptionGroups,\n            selection: {\n              ...s.selection,\n              allowMultiSelect: !!options?.allowMultiSelect,\n              allowSelectAll:\n                !!options?.allowSelectAll &&\n                options?.selectedOptionLimit == undefined,\n              visibleSelectionState:\n                getParentMultiSelectionState(topLevelOptions),\n            },\n            display: {\n              ...s.display,\n              formattedSelectedOptions: getFormattedOptionsForDisplay(\n                s,\n                topLevelOptions,\n                options,\n              ),\n              zeroStateMessage: getZeroStateMessage(s),\n              dividers: !!options?.dividers,\n              inline: !!options?.inline,\n              maxHeight: options?.maxHeight ?? null,\n              maxWidth: options?.maxWidth ?? null,\n              minHeight: options?.minHeight ?? null,\n              minWidth: options?.minWidth ?? null,\n              displayLimitMessage: getDisplayLimitMessage(\n                countVisibleOptions(fullOptionGroups, !!s.query.search),\n                countVisibleOptions(allOptionGroups, !!s.query.search),\n                s.query,\n              ),\n              showSingleSelected: !!options?.showSingleSelected,\n              pillCount: getPillCountForDisplay(s, topLevelOptions, options),\n            },\n          };\n        }),\n      ),\n      {\n        connector: () => new ReplaySubject(1),\n        resetOnDisconnect: false,\n      },\n    );\n    state.connect();\n\n    // Load the options immediately for selects that are displayed inline.\n    if (options?.inline) actions.next({ type: 'load' });\n\n    return { actions, state };\n  }\n\n  export type InMemoryManagerOptions<O extends BaseOption> =\n    ManagerOptions<O> & {\n      fuseOptions?: IFuseOptions<O>;\n    };\n\n  export function createInMemoryManager<O extends BaseOption>(\n    fetchDataset: () => Promise<OptionGroup<O>[]> | OptionGroup<O>[],\n    options?: InMemoryManagerOptions<O>,\n  ): Manager<O> {\n    let data: OptionGroup<O>[];\n    let fuse: Fuse<O>;\n    let exactMatch: boolean = false;\n    let parents: Map<O['id'], O['id']>;\n    let children: Map<O['id'], O['id'][]>;\n\n    const source: Source<O> = async (query, mostRecentAction) => {\n      /*\n        Re-fetch the options on the load action, and rebuild the state\n        derived from the option data.\n      */\n      if (\n        mostRecentAction.type === 'load' ||\n        mostRecentAction.type === 'openChange'\n      ) {\n        data = await fetchDataset();\n        const topLevelOptions = getTopLevelOptions(data);\n\n        fuse = new Fuse(flattenOptions(topLevelOptions, false), {\n          threshold: 0.2,\n          keys: ['title'],\n          includeScore: true,\n          includeMatches: true,\n          ...options?.fuseOptions,\n        });\n\n        exactMatch = options?.fuseOptions?.threshold == 0;\n        [parents, children] = getRelationshipMaps(topLevelOptions);\n      }\n\n      // Leading/trailing whitespace shouldn't affect fuzzy matching (Fuse\n      // scores the pattern's length against the text's, so a stray space\n      // changes results in surprising ways); a search string of only\n      // whitespace is treated the same as no search.\n      const search = query.search.trim();\n\n      /*\n        If the user is not searching options, return the full set of options\n        sorted appropriately.\n      */\n      if (!search) {\n        /*\n          The `source` order property allows for opting out of automatic\n          sorting, returning the data in its natural input order.\n        */\n        if (query.order === 'source') return data;\n\n        /*\n          Sort the options by title and subtitle.\n        */\n        if (query.order === 'title') {\n          function sortByTitle(options: Option<O>[]): Option<O>[] {\n            return sortBy(options, [\n              (o: Option<O>) => o.title.toLowerCase(),\n              (o: Option<O>) => o.subtitle?.toLowerCase() ?? '',\n            ]).map(option => ({\n              ...option,\n              children: option.children?.length\n                ? sortByTitle(option.children)\n                : undefined,\n            }));\n          }\n\n          return data.map(group => ({\n            ...group,\n            options: sortByTitle(group.options),\n          }));\n        }\n\n        /*\n          Sort the options by count, then by title, then by subtitle.\n        */\n        if (query.order === 'count') {\n          function sortByCount(options: Option<O>[]): Option<O>[] {\n            return sortBy(options, [\n              (o: Option<O>) => (isNumber(o.count) ? -o.count : Infinity),\n              (o: Option<O>) => o.title.toLowerCase(),\n              (o: Option<O>) => o.subtitle?.toLowerCase() ?? '',\n            ]).map(option => ({\n              ...option,\n              children: option.children?.length\n                ? sortByCount(option.children)\n                : undefined,\n            }));\n          }\n\n          return data.map(group => ({\n            ...group,\n            options: sortByCount(group.options),\n          }));\n        }\n      }\n\n      /*\n        Execute the search with fuse. Once we have the search match data,\n        rebuild just as much of the tree as is needed to render the search\n        results. Specifically, any match will need all of its ancestors (so\n        that matched leaf nodes are shown nested under their ancestors) and all\n        of its children (because a matching parent means that all of its\n        descendants match too, per the design specification), whether they\n        themselves matched or not.\n      */\n      const matchedOptions: FuseResult<O>[] = fuse.search(search);\n      const matchedIds: Set<O['id']> = new Set(\n        matchedOptions.map(result => result.item.id),\n      );\n\n      const matchAncestors: Set<O['id']> = new Set();\n      function collectAncestors(ids: O['id'][]) {\n        for (const id of ids) {\n          const parentId = parents.get(id);\n          if (parentId) {\n            matchAncestors.add(parentId);\n            collectAncestors([parentId]);\n          }\n        }\n      }\n      collectAncestors([...matchedIds]);\n\n      const matchDescendants: Set<O['id']> = new Set();\n      function collectDescendants(ids: O['id'][]) {\n        for (const id of ids) {\n          const childrenIds = children.get(id);\n          if (childrenIds) {\n            for (const child of childrenIds) {\n              matchDescendants.add(child);\n            }\n            collectDescendants(childrenIds);\n          }\n        }\n      }\n      collectDescendants([...matchedIds]);\n\n      /*\n        Next, we'll combine all the matched IDs with their direct ancestors and\n        descandants, and filter the original data set down to just these\n        options.\n      */\n      const filteredIds: Set<O['id']> = new Set([\n        ...matchedIds,\n        ...matchAncestors,\n        ...matchDescendants,\n      ]);\n\n      function filterOptions(options: Option<O>[]): Option<O>[] {\n        const filteredOptions: Option<O>[] = [];\n        for (const option of options) {\n          if (filteredIds.has(option.id)) {\n            filteredOptions.push({\n              ...option,\n              children: option.children?.length\n                ? filterOptions(option.children)\n                : undefined,\n            });\n          }\n        }\n        return filteredOptions;\n      }\n      const filteredOptions = filterOptions(getTopLevelOptions(data));\n\n      /*\n        At this point, we have an array of distinct trees (top-level options),\n        filtered down to only the options matching the search query. Note that\n        we don't care about section headers when searching since results should\n        be ordered by relevance. To calculate the order of these trees, we'll\n        take the total match scores for options found in the tree, divided by\n        the count of matches in the tree (the best average match score).\n      */\n\n      const scoreMap: Map<O['id'], number> = new Map(\n        matchedOptions.map(result => [result.item.id, result.score ?? 0]),\n      );\n      const ordered = sortBy(filteredOptions, (option: Option<O>): number => {\n        function calculateScore(option: Option<O>): number {\n          return (\n            (scoreMap.get(option.id) ?? 0) +\n            (option.children ?? []).reduce(\n              (score, child) => score + calculateScore(child),\n              0,\n            )\n          );\n        }\n        function calculateCount(option: Option<O>): number {\n          return (\n            1 +\n            (option.children ?? []).reduce(\n              (count, child) => count + calculateCount(child),\n              0,\n            )\n          );\n        }\n        const totalScore = calculateScore(option);\n        const totalCount = calculateCount(option);\n        return totalScore / totalCount;\n      });\n\n      /*\n        Finally, we'll add highlight indices to the matches so that they can be\n        displayed to the user.\n      */\n\n      type Highlights = {\n        titleHighlightIndices?: HighlightComponent.HighlightIndices[];\n        subtitleHighlightIndices?: HighlightComponent.HighlightIndices[];\n      };\n      const highlightMap: Map<O['id'], Highlights> = new Map(\n        matchedOptions.map(result => {\n          const highlights: Highlights = {};\n          for (const match of result.matches ?? []) {\n            // filter out inexact matches\n            if (exactMatch && match.value != null) {\n              match.indices = match.indices.filter(\n                isFuseMatchExact(match, search),\n              );\n            }\n            if (match.key === 'title') {\n              highlights.titleHighlightIndices = [...match.indices];\n            }\n            if (match.key === 'subtitle') {\n              highlights.subtitleHighlightIndices = [...match.indices];\n            }\n          }\n          return [result.item.id, highlights];\n        }),\n      );\n      function addHighlightsToOption(options: Option<O>[]): SourceOption<O>[] {\n        return options.map(option => ({\n          ...option,\n          ...highlightMap.get(option.id),\n          ...(option.children?.length\n            ? { children: addHighlightsToOption(option.children) }\n            : null),\n        }));\n      }\n\n      return {\n        data: [{ options: addHighlightsToOption(ordered) }],\n        originalData: data,\n      };\n    };\n\n    return createManager(source, options);\n  }\n\n  export function isFuseMatchExact(\n    match: FuseResultMatch,\n    search: string,\n  ): (\n    value: RangeTuple,\n    index: number,\n    array: readonly RangeTuple[],\n  ) => boolean {\n    return matchedIndices => {\n      const matchedValue = match\n        .value!.slice(matchedIndices[0], matchedIndices[1] + 1)\n        .toLowerCase();\n      // fuse is weird with it's matches. For a text of \"planning\" and a search string of \"plan\"\n      // the matched value will be \"plann\" with the extra 'n' because of its fuzzy matching.\n      // so just make sure the matched value at least starts with the search string.\n      // it's extra weird because for a text of \"analytics\" and a search string of \"nalytics\",\n      // the matched value will be \"analytics\". So we just need to make sure the the matched value\n      // includes the search string because there might be extra stuff on the front or the end.\n      return matchedValue.includes(search.toLowerCase());\n    };\n  }\n\n  //////////////////////////////////\n  // State reducer (with helpers) //\n  //////////////////////////////////\n\n  function createSelectionSnapshotWithAncestors<O extends BaseOption>(\n    state: CoreState<O>,\n  ): OptionSet<O> {\n    const snapshot = new OptionSet(state.selection.selected);\n    const topLevelOptions = getTopLevelOptions(state.sourceOptionGroups);\n    const [parents] = getRelationshipMaps(topLevelOptions);\n\n    // Sibling leaves share ancestors, so once we've walked up through a\n    // given parent id we can stop — anything above it has already been\n    // added by a previous iteration. Without this short-circuit the loop\n    // re-runs findOption (which is a full tree walk) once per shared\n    // ancestor edge, which was the #2 hotspot behind OptionSet.add in\n    // RVT-25470's profile.\n    const visited = new Set<O['id']>();\n    for (const selectedOption of state.selection.selected) {\n      let parentId = parents.get(selectedOption.id);\n      while (parentId !== undefined && !visited.has(parentId)) {\n        visited.add(parentId);\n        const parentOption = findOption(topLevelOptions, parentId);\n        if (parentOption) {\n          snapshot.add(parentOption);\n        }\n        parentId = parents.get(parentId);\n      }\n    }\n\n    return snapshot;\n  }\n\n  function getDisplayLimitMessage<O extends BaseOption>(\n    displayedOptionCount: number,\n    totalOptionCount: number,\n    query: CoreState<O>['query'],\n  ): string | null {\n    if (displayedOptionCount === totalOptionCount) return null;\n    const rivNumber = new NumberPipe();\n    const displayed = rivNumber.transform(displayedOptionCount);\n    const total = rivNumber.transform(totalOptionCount);\n    const start = `Showing ${displayed} of ${total} options`;\n    return query.search ? `${start} matching \"${query.search}\"` : start;\n  }\n\n  function countVisibleOptions<O extends BaseOption>(\n    optionGroups: FullOptionGroup<O>[],\n    leafOnly: boolean,\n  ): number {\n    function count(options: FullOption<O>[]): number {\n      return options.reduce((acc, option) => {\n        if (option.expanded && option.children?.length) {\n          return acc + (leafOnly ? 0 : 1) + count(option.children);\n        }\n        return acc + 1;\n      }, 0);\n    }\n\n    return optionGroups.reduce(\n      (total, group) => total + count(group.options),\n      0,\n    );\n  }\n\n  function countAllOptions<O extends BaseOption>(\n    optionGroups: FullOptionGroup<O>[],\n  ): number {\n    function count(options: FullOption<O>[]): number {\n      return options.reduce((acc, option) => {\n        if (option.children?.length) {\n          return acc + 1 + count(option.children);\n        }\n        return acc + 1;\n      }, 0);\n    }\n\n    return optionGroups.reduce(\n      (total, group) => total + count(group.options),\n      0,\n    );\n  }\n\n  function applyDisplayLimit<O extends BaseOption>(\n    optionGroups: FullOptionGroup<O>[],\n    displayLimit: number,\n  ): FullOptionGroup<O>[] {\n    type DisplayLimitOptions = [FullOption<O>[], number];\n    function filterWithLimit(\n      options: FullOption<O>[],\n      remaining: number,\n    ): DisplayLimitOptions {\n      let left = remaining;\n      const visibleOptions: FullOption<O>[] = [];\n      for (const option of options) {\n        if (left <= 0) break;\n\n        if (option.expanded && option.children?.length) {\n          const [childOptions, childRemaining] = filterWithLimit(\n            option.children,\n            left - 1,\n          );\n          visibleOptions.push({\n            ...option,\n            children: childOptions,\n          });\n          left = childRemaining;\n        } else {\n          visibleOptions.push(option);\n          left--;\n        }\n      }\n      return [visibleOptions, left];\n    }\n\n    type DisplayLimitGroups = [FullOptionGroup<O>[], number];\n    const startingValue: DisplayLimitGroups = [[], displayLimit];\n    const [resolvedGroups] = optionGroups.reduce<DisplayLimitGroups>(\n      ([groups, remaining], group) => {\n        const [options, leftAfter] = filterWithLimit(group.options, remaining);\n        if (options.length) {\n          return [[...groups, { ...group, options }], leftAfter];\n        } else {\n          return [groups, remaining];\n        }\n      },\n      startingValue,\n    );\n\n    return resolvedGroups;\n  }\n\n  /*\n    Sort options so that previously selected options (from prior sessions)\n    appear at the top of their peer/sibling lists.\n  */\n  function sortOptionsByPreviouslySelectedState<O extends BaseOption>(\n    optionGroups: FullOptionGroup<O>[],\n    selectionAtOpen: OptionSet<O>,\n  ): FullOptionGroup<O>[] {\n    function sortOptions(options: FullOption<O>[]): FullOption<O>[] {\n      return sortBy(options, option => !selectionAtOpen.has(option)).map(\n        option => {\n          if (option.children) {\n            return {\n              ...option,\n              children: sortOptions(option.children),\n            };\n          } else return option;\n        },\n      );\n    }\n\n    return optionGroups.map(group => ({\n      ...group,\n      options: sortOptions(group.options),\n    }));\n  }\n\n  /*\n    If we are restricting how many options are selected to a specific limit,\n      when we are at that limit, disable all options not currently selected.\n  */\n  function applySelectedOptionLimit<O extends BaseOption>(\n    state: CoreState<O>,\n    optionGroups: FullOptionGroup<O>[],\n    topLevelOptions: FullOption<O>[],\n    options?: ManagerOptions<O>,\n  ): FullOptionGroup<O>[] {\n    if (options?.selectedOptionLimit === undefined) {\n      return optionGroups;\n    }\n\n    // When useTopLevelOptionsForDisplay is true and search is active, count\n    // selected top-level options from the original (unfiltered) data to ensure\n    // already-selected options that don't match the search are still counted.\n    const useOriginalForCounting =\n      options?.useTopLevelOptionsForDisplay &&\n      state.query.search &&\n      state.originalOptionGroups.length > 0;\n\n    const topOptionsForCounting = useOriginalForCounting\n      ? getTopLevelOptions(state.originalOptionGroups).map(option =>\n          augmentOptionToFullOption(state, option, options),\n        )\n      : topLevelOptions;\n\n    const selectedOrIndeterminateTopOptions = topOptionsForCounting.filter(\n      option => option.selected != false,\n    );\n    const numSelectedOptions: number = options?.useTopLevelOptionsForDisplay\n      ? selectedOrIndeterminateTopOptions.length\n      : state.selection.selected.size;\n\n    const selectedOptionLimit: number = options.selectedOptionLimit;\n\n    // If we have less items selected than the limit, business as usual.\n    if (numSelectedOptions < selectedOptionLimit) {\n      return optionGroups;\n    }\n\n    // If we have equal items selected to the limit (or more), prevent users from selecting more options.\n    function disableUnselectedItems(\n      currentOptions: FullOption<O>[],\n      optionsAreChildrenOfSelectedGroup: boolean,\n    ): FullOption<O>[] {\n      const updatedItems: FullOption<O>[] = [];\n      for (const option of currentOptions) {\n        const isDisabledOrUnselected: boolean =\n          !!option.disabled || (option.selectable && option.selected == false);\n\n        const isCurrentOptionSelected: boolean =\n          option.selectable && option.selected != false;\n        const isCurrentOrParentOptionSelected: boolean =\n          isCurrentOptionSelected || optionsAreChildrenOfSelectedGroup;\n\n        const forceEnabledBasedOnParent: boolean =\n          !!options?.useTopLevelOptionsForDisplay &&\n          optionsAreChildrenOfSelectedGroup;\n        const markDisabled: boolean =\n          isDisabledOrUnselected && !forceEnabledBasedOnParent;\n\n        if (option.children?.length) {\n          const childOptions = disableUnselectedItems(\n            option.children,\n            isCurrentOrParentOptionSelected,\n          );\n          updatedItems.push({\n            ...option,\n            disabled: !!markDisabled,\n            children: childOptions,\n          });\n        } else {\n          updatedItems.push({\n            ...option,\n            disabled: !!markDisabled,\n          });\n        }\n      }\n      return updatedItems;\n    }\n\n    const groupsAfterLimit: FullOptionGroup<O>[] = [];\n    for (const currentGroup of optionGroups) {\n      groupsAfterLimit.push({\n        ...currentGroup,\n        options: disableUnselectedItems(currentGroup.options, false),\n      });\n    }\n\n    return groupsAfterLimit;\n  }\n\n  function getRelationshipMaps<O extends BaseOption>(\n    options: Option<O>[],\n  ): [Map<O['id'], O['id']>, Map<O['id'], O['id'][]>] {\n    const parents = new Map();\n    function buildParentsMap(options: Option<O>[], parent?: Option<O>): void {\n      for (const option of options) {\n        if (parent) {\n          parents.set(option.id, parent.id);\n        }\n        if (option.children?.length) {\n          buildParentsMap(option.children, option);\n        }\n      }\n    }\n    buildParentsMap(options);\n\n    const children = new Map();\n    function buildChildrenMap(options: Option<O>[]): void {\n      for (const option of options) {\n        if (option.children?.length) {\n          children.set(\n            option.id,\n            option.children.map(({ id }) => id),\n          );\n          buildChildrenMap(option.children);\n        }\n      }\n    }\n    buildChildrenMap(options);\n\n    return [parents, children];\n  }\n\n  function getTopLevelOptions<O extends BaseOption>(\n    optionGroups: FullOptionGroup<O>[],\n  ): FullOption<O>[];\n  function getTopLevelOptions<O extends BaseOption>(\n    optionGroups: SourceOptionGroup<O>[],\n  ): SourceOption<O>[];\n  function getTopLevelOptions<O extends BaseOption>(\n    optionGroups: OptionGroup<O>[],\n  ): Option<O>[];\n  function getTopLevelOptions<\n    O extends BaseOption,\n    G extends { options: readonly T[] },\n    T = G extends FullOptionGroup<O>\n      ? FullOption<O>\n      : G extends SourceOptionGroup<O>\n      ? SourceOption<O>\n      : Option<O>,\n  >(optionGroups: G[]): T[] {\n    return optionGroups.reduce<T[]>(\n      (options, group) => [...options, ...group.options],\n      [],\n    );\n  }\n\n  function getParentMultiSelectionState<O extends BaseOption>(\n    children: FullOption<O>[],\n  ): MultiSelectionState {\n    if (children.every(child => child.selected === true)) return true;\n    if (children.every(child => child.selected === false)) return false;\n    return 'indeterminate';\n  }\n\n  function augmentOptionToFullOption<O extends BaseOption>(\n    state: CoreState<O>,\n    option: SourceOption<O>,\n    managerOptions?: ManagerOptions<O>,\n  ): FullOption<O> {\n    if (option.children?.length) {\n      const augmentedChildren = option.children.map(child =>\n        augmentOptionToFullOption(state, child, managerOptions),\n      );\n      const selectableWhenSearching =\n        managerOptions?.allowSelectNonLeafDuringSearch ?? false;\n\n      // When allowSelectNonLeafDuringSearch is enabled and search is active,\n      // calculate selection state from ALL original children, not just the\n      // filtered ones visible in search results.\n      const useOriginalForSelectionState =\n        managerOptions?.allowSelectNonLeafDuringSearch &&\n        state.query.search &&\n        state.originalOptionGroups.length > 0;\n\n      let selected: MultiSelectionState;\n      if (useOriginalForSelectionState) {\n        const originalOption = findOption(\n          getTopLevelOptions(state.originalOptionGroups),\n          option.id,\n        );\n        if (originalOption) {\n          const allLeaves = flattenOptions([originalOption], true);\n          const selectedCount = allLeaves.filter(leaf =>\n            state.selection.selected.has(leaf),\n          ).length;\n          if (selectedCount === 0) {\n            selected = false;\n          } else if (selectedCount === allLeaves.length) {\n            selected = true;\n          } else {\n            selected = 'indeterminate';\n          }\n        } else {\n          selected = getParentMultiSelectionState(augmentedChildren);\n        }\n      } else {\n        selected = getParentMultiSelectionState(augmentedChildren);\n      }\n\n      return {\n        ...option,\n        children: augmentedChildren,\n        selected,\n        expanded: state.query.search\n          ? true\n          : state.display.expandedOptions.has(option.id),\n        selectable: !state.query.search || selectableWhenSearching,\n        expandable: !state.query.search,\n      };\n    }\n    return {\n      ...option,\n      children: undefined,\n      selected: state.selection.selected.has(option),\n      expanded: false,\n      selectable: true,\n      expandable: false,\n    };\n  }\n\n  function getFormattedOptionsForDisplay<O extends BaseOption>(\n    state: CoreState<O>,\n    topLevelOptions: FullOption<O>[],\n    options?: ManagerOptions<O>,\n  ): string {\n    // If we have a custom display function, use it\n    if (options?.getCustomOptionDisplay) {\n      return options.getCustomOptionDisplay([...state.selection.selected]);\n    }\n    if (options?.useTopLevelOptionsForDisplay) {\n      return getTopLevelFormattedOptionsForDisplay(topLevelOptions);\n    }\n    // Otherwise, use the default display for options - titles separated by commas.\n    return [...state.selection.selected].map(({ title }) => title).join(', ');\n  }\n\n  function getTopLevelFormattedOptionsForDisplay<O extends BaseOption>(\n    topLevelOptions: FullOption<O>[],\n  ): string {\n    if (!topLevelOptions || topLevelOptions.length == 0) {\n      return '';\n    }\n    const selectedOrIndeterminateTopOptions = topLevelOptions.filter(\n      option => option.selected != false,\n    );\n    return selectedOrIndeterminateTopOptions\n      .map(({ title }) => title)\n      .join(', ');\n  }\n\n  function getPillCountForDisplay<O extends BaseOption>(\n    state: CoreState<O>,\n    topLevelOptions: FullOption<O>[],\n    options?: ManagerOptions<O>,\n  ): number {\n    if (options?.useTopLevelOptionsForDisplay) {\n      const selectedOrIndeterminateTopOptions = topLevelOptions.filter(\n        option => option.selected != false,\n      );\n      return selectedOrIndeterminateTopOptions.length;\n    }\n    return state.selection.selected.size;\n  }\n\n  function getZeroStateMessage<O extends BaseOption>(\n    state: CoreState<O>,\n  ): string | null {\n    if (state.sourceOptionGroups.every(group => group.options.length === 0)) {\n      if (state.query.search) return 'No results found.';\n      return 'No options.';\n    }\n    return null;\n  }\n\n  function findOption<O extends BaseOption>(\n    options: SourceOption<O>[],\n    id: O['id'],\n  ): SourceOption<O> | null {\n    for (const option of options) {\n      if (option.id === id) return option;\n      if (option.children?.length) {\n        const child = findOption(option.children, id);\n        if (child) return child;\n      }\n    }\n    return null;\n  }\n\n  function flattenOptions<O extends BaseOption>(\n    options: Option<O>[],\n    leafOnly: boolean,\n  ): O[] {\n    return flattenDeep(\n      options.map(option => {\n        if (option.children?.length) {\n          const descendants = option.children.map(child =>\n            flattenOptions([child], leafOnly),\n          );\n          return leafOnly ? descendants : [option, ...descendants];\n        } else {\n          return [option];\n        }\n      }),\n    );\n  }\n\n  function toggleSelected<O extends BaseOption>(\n    state: CoreState<O>,\n    id: O['id'],\n    managerOptions?: ManagerOptions<O>,\n  ): CoreState<O> {\n    const topLevelOptions = getTopLevelOptions(state.sourceOptionGroups);\n    const option = findOption(topLevelOptions, id);\n    if (!option) return state;\n\n    const newSelection = new OptionSet(state.selection.selected);\n\n    const newValue = !(\n      augmentOptionToFullOption(state, option, managerOptions).selected === true\n    );\n\n    // When allowSelectNonLeafDuringSearch is enabled and search is active,\n    // use the original (unfiltered) data to get all children, not just\n    // those visible in the filtered search results.\n    const useOriginalData =\n      managerOptions?.allowSelectNonLeafDuringSearch &&\n      state.query.search &&\n      state.originalOptionGroups.length > 0;\n\n    const optionForLeaves = useOriginalData\n      ? findOption(getTopLevelOptions(state.originalOptionGroups), id) ?? option\n      : option;\n\n    const leaves = flattenOptions([optionForLeaves], true);\n    for (const leaf of leaves) {\n      if (newValue) {\n        newSelection.add(leaf);\n      } else {\n        newSelection.delete(leaf);\n      }\n    }\n\n    return {\n      ...state,\n      selection: {\n        selected: newSelection,\n      },\n    };\n  }\n\n  function setSelectedOption<O extends BaseOption>(\n    state: CoreState<O>,\n    id: O['id'],\n  ): CoreState<O> {\n    const topLevelOptions = getTopLevelOptions(state.sourceOptionGroups);\n    const option = findOption(topLevelOptions, id);\n    if (!option) return state;\n\n    const newSelection = new OptionSet<O>();\n    newSelection.add(option);\n\n    return {\n      ...state,\n      selection: {\n        selected: newSelection,\n      },\n    };\n  }\n\n  function toggleVisibleSelected<O extends BaseOption>(\n    state: CoreState<O>,\n  ): CoreState<O> {\n    const leaves = flattenOptions(\n      getTopLevelOptions(state.sourceOptionGroups),\n      true,\n    );\n    const isAllSelected = leaves.every(leaf =>\n      state.selection.selected.has(leaf),\n    );\n    const newSelection = new OptionSet(state.selection.selected);\n\n    for (const leaf of leaves) {\n      if (isAllSelected) newSelection.delete(leaf);\n      else newSelection.add(leaf);\n    }\n\n    return {\n      ...state,\n      selection: {\n        ...state.selection,\n        selected: newSelection,\n      },\n    };\n  }\n\n  function toggleOptionExpanded<O extends BaseOption>(\n    state: CoreState<O>,\n    id: O['id'],\n  ): CoreState<O> {\n    const newValue = !state.display.expandedOptions.has(id);\n    const newExpandedOptions = new Set(state.display.expandedOptions);\n    if (newValue) newExpandedOptions.add(id);\n    else newExpandedOptions.delete(id);\n    return {\n      ...state,\n      display: {\n        ...state.display,\n        expandedOptions: newExpandedOptions,\n      },\n    };\n  }\n\n  function sideEffects<O extends BaseOption>(\n    state: CoreState<O>,\n    action: Action<O> | InternalAction<O>,\n    source: Source<O>,\n    internalActions: Subject<InternalAction<O>>,\n  ): CoreState<O> {\n    if (\n      action.type === 'load' ||\n      action.type === 'searchChange' ||\n      action.type === 'orderChange' ||\n      (action.type === 'openChange' && action.open)\n    ) {\n      source(state.query, action)\n        .then(result => {\n          const data = Array.isArray(result) ? result : result.data;\n          const originalData = Array.isArray(result)\n            ? undefined\n            : result.originalData;\n          internalActions.next({ type: 'loadComplete', data, originalData });\n        })\n        .catch(error => {\n          // eslint-disable-next-line no-console\n          console.error(error);\n          internalActions.next({ type: 'loadError', error });\n        });\n      return {\n        ...state,\n        load: {\n          loading: true,\n          error: null,\n        },\n      };\n    }\n    return state;\n  }\n\n  function reduce<O extends BaseOption>(\n    state: CoreState<O>,\n    action: Action<O> | InternalAction<O>,\n    managerOptions?: ManagerOptions<O>,\n  ): CoreState<O> {\n    switch (action.type) {\n      case 'load':\n        return state;\n      case 'loadComplete':\n        return {\n          ...state,\n          load: {\n            loading: false,\n            error: null,\n          },\n          sourceOptionGroups: action.data,\n          originalOptionGroups: action.originalData ?? [],\n        };\n      case 'loadError':\n        return {\n          ...state,\n          load: {\n            loading: false,\n            error: action.error,\n          },\n        };\n      case 'openChange':\n        return {\n          ...state,\n          query: {\n            ...state.query,\n            search: '',\n          },\n          display: {\n            ...state.display,\n            open: action.open,\n          },\n        };\n      case 'searchChange':\n        return {\n          ...state,\n          query: {\n            ...state.query,\n            search: action.payload,\n          },\n        };\n      case 'orderChange':\n        return {\n          ...state,\n          query: {\n            ...state.query,\n            order: action.payload,\n          },\n        };\n      case 'selectionChange':\n        return {\n          ...state,\n          selection: action.payload,\n        };\n      case 'toggleOptionSelected':\n        return toggleSelected(state, action.id, managerOptions);\n      case 'setSelectedOption':\n        return setSelectedOption(state, action.id);\n      case 'visibleSelectedChange':\n        return toggleVisibleSelected(state);\n      case 'toggleOptionExpanded':\n        return toggleOptionExpanded(state, action.id);\n    }\n  }\n}\n"]}