@rivet-health/design-system 33.1.2 → 34.0.1

package/fesm2020/rivet-health-design-system.mjs

@@ -1976,6 +1976,7 @@ var RivSelect;
                 error: null,
             },
             sourceOptionGroups: [],
+            originalOptionGroups: [],
             selection: {
                 selected: new OptionSet(),
             },
@@ -1989,7 +1990,7 @@ var RivSelect;
         const actions = new Subject();
         const internalActions = new Subject();
         const coreStateWithSelectionSnapshot = merge(actions, internalActions).pipe(scan(([state, snapshot], action) => {
-            const newState = sideEffects(reduce(state, action), action, source, internalActions);
+            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))
@@ -2004,7 +2005,7 @@ var RivSelect;
             const allOptionGroups = s.sourceOptionGroups.map(optionGroup => {
                 return {
                     ...optionGroup,
-                    options: optionGroup.options.map(option => augmentOptionToFullOption(s, option)),
+                    options: optionGroup.options.map(option => augmentOptionToFullOption(s, option, options)),
                 };
             });
             const topLevelOptions = getTopLevelOptions(allOptionGroups);
@@ -2244,7 +2245,10 @@ var RivSelect;
                         : null),
                 }));
             }
-            return [{ options: addHighlightsToOption(ordered) }];
+            return {
+                data: [{ options: addHighlightsToOption(ordered) }],
+                originalData: data,
+            };
         };
         return createManager(source, options);
     }
@@ -2381,7 +2385,16 @@ var RivSelect;
         if (options?.selectedOptionLimit === undefined) {
             return optionGroups;
         }
-        const selectedOrIndeterminateTopOptions = topLevelOptions.filter(option => option.selected != false);
+        // 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;
@@ -2461,17 +2474,47 @@ var RivSelect;
             return false;
         return 'indeterminate';
     }
-    function augmentOptionToFullOption(state, option) {
+    function augmentOptionToFullOption(state, option, managerOptions) {
         if (option.children?.length) {
-            const augmentedChildren = option.children.map(child => augmentOptionToFullOption(state, child));
+            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: getParentMultiSelectionState(augmentedChildren),
+                selected,
                 expanded: state.query.search
                     ? true
                     : state.display.expandedOptions.has(option.id),
-                selectable: !state.query.search,
+                selectable: !state.query.search || selectableWhenSearching,
                 expandable: !state.query.search,
             };
         }
@@ -2542,14 +2585,23 @@ var RivSelect;
             }
         }));
     }
-    function toggleSelected(state, id) {
+    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).selected === true);
-        const leaves = flattenOptions([option], true);
+        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);
@@ -2618,8 +2670,12 @@ var RivSelect;
             action.type === 'orderChange' ||
             (action.type === 'openChange' && action.open)) {
             source(state.query, action)
-                .then(data => {
-                internalActions.next({ type: 'loadComplete', data });
+                .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
@@ -2636,7 +2692,7 @@ var RivSelect;
         }
         return state;
     }
-    function reduce(state, action) {
+    function reduce(state, action, managerOptions) {
         switch (action.type) {
             case 'load':
                 return state;
@@ -2648,6 +2704,7 @@ var RivSelect;
                         error: null,
                     },
                     sourceOptionGroups: action.data,
+                    originalOptionGroups: action.originalData ?? [],
                 };
             case 'loadError':
                 return {
@@ -2691,7 +2748,7 @@ var RivSelect;
                     selection: action.payload,
                 };
             case 'toggleOptionSelected':
-                return toggleSelected(state, action.id);
+                return toggleSelected(state, action.id, managerOptions);
             case 'setSelectedOption':
                 return setSelectedOption(state, action.id);
             case 'visibleSelectedChange':
@@ -8381,7 +8438,7 @@ var Chart;
             : scaleUtc(timeseriesDomain(data), yRange);
         const dateFormat = (date) => formatedDate(config.dateFormat || 'day', date);
         const { pipe, fullPipe } = getPipes(config.valueType);
-        const yTicks = yScale.ticks(data.x.length - 1).map(tick => ({
+        const yTicks = yScale.ticks(Math.max(data.x.length - 1, 1)).map(tick => ({
             y: yScale(tick),
             label: isNumber(tick)
                 ? data.type == 'labeled'
@@ -8417,7 +8474,29 @@ var Chart;
                     yPos: yValue,
                     width,
                 });
-                if (data.ys.length == 1 || config.groupingType == 'clustered') {
+                //Don't draw anything for zero-value bars
+                if (width == 0) {
+                    return '';
+                }
+                //These checks are to make sure we still round if all previous/later values are 0
+                const allLeftZero = data.ys
+                    .slice(0, yIndex)
+                    .map(y => y.values[index])
+                    .filter(val => val != 0).length == 0;
+                const leftSideRound = yIndex == 0 ||
+                    data.ys.length == 1 ||
+                    config.groupingType == 'clustered' ||
+                    allLeftZero;
+                const allRightZero = data.ys
+                    .slice(yIndex + 1, data.ys.length)
+                    .map(y => y.values[index])
+                    //If the later data's value is the same as the current data's, that indicates 0 width
+                    .filter(val => val != data.ys[yIndex].values[index]).length == 0;
+                const rightSideRound = yIndex == data.ys.length - 1 ||
+                    data.ys.length == 1 ||
+                    config.groupingType == 'clustered' ||
+                    allRightZero;
+                if (leftSideRound && rightSideRound) {
                     //Both-sides rounding variation
                     const pathD = `
             M ${xValue + horR},${yValue}
@@ -8433,7 +8512,7 @@ var Chart;
           `;
                     return pathD;
                 }
-                if (yIndex == 0) {
+                if (leftSideRound) {
                     //Left-side rounding variation
                     const pathD = `
             M ${xValue + horR},${yValue}
@@ -8447,7 +8526,7 @@ var Chart;
           `;
                     return pathD;
                 }
-                if (yIndex == data.ys.length - 1) {
+                if (rightSideRound) {
                     //Right-side rounding variation
                     const pathD = `
             M ${xValue},${yValue}
@@ -8503,6 +8582,31 @@ var Chart;
                 visibleYIndex = data.ys.length - 1;
             }
             const yIndex = visibleIndices[visibleYIndex];
+            //Check if we've landed on a zero-width bar (only really relevant on ends)
+            if (simplifiedHorizontalBars[visibleYIndex][xIndex].width == 0 &&
+                config.groupingType == 'stacked') {
+                let altBarFound = false;
+                //Check upwards
+                for (let i = visibleYIndex + 1; i < simplifiedHorizontalBars.length; i++) {
+                    if (altBarFound) {
+                        break;
+                    }
+                    if (simplifiedHorizontalBars[i][xIndex].width != 0) {
+                        visibleYIndex = i;
+                        altBarFound = true;
+                    }
+                }
+                //Check downwards
+                for (let i = visibleYIndex - 1; i >= 0; i--) {
+                    if (altBarFound) {
+                        break;
+                    }
+                    if (simplifiedHorizontalBars[i][xIndex].width != 0) {
+                        visibleYIndex = i;
+                        altBarFound = true;
+                    }
+                }
+            }
             const anchor = new DOMRect(pos.rect.x +
                 simplifiedHorizontalBars[visibleYIndex][xIndex].xPos -
                 SMALL_PADDING, pos.rect.y + simplifiedHorizontalBars[visibleYIndex][xIndex].yPos, simplifiedHorizontalBars[visibleYIndex][xIndex].width +