@homebound/beam 4.59.0 → 4.59.1

package/dist/index.cjs

@@ -20609,9 +20609,20 @@ function useMenuSelectField(props) {
     () => menuTree ? menuTree.orderedKeys.filter((key) => disabledKeySet.has(menuTree.nodes.get(key).valueKey)) : disabledKeys,
     [menuTree, disabledKeySet, disabledKeys]
   );
+  const rememberedSelectedRef = (0, import_react85.useRef)(/* @__PURE__ */ new Map());
+  syncRememberedOptions(rememberedSelectedRef.current, values, optionsByKey);
   const selectedOptions = (0, import_react85.useMemo)(
-    () => menuTree ? selectedTreeOptions(menuTree, selectedKeys) : values.map((v) => optionsByKey.get(valueToKey(v))).filter((o) => o !== void 0),
-    [menuTree, selectedKeys, values, optionsByKey]
+    () => resolveSelectedOptions(
+      values,
+      menuTree,
+      selectedKeys,
+      optionsByKey,
+      rememberedSelectedRef.current,
+      getOptionValue
+    ),
+    // getOptionValue is typically an inline lambda
+    // oxlint-disable-next-line react-hooks/exhaustive-deps
+    [values, optionsByKey, menuTree, selectedKeys]
   );
   const dottedKeys = (0, import_react85.useMemo)(
     () => new Set(mixedValues?.map(valueToKey).filter((key) => optionsByKey.has(key) && !selectedKeys.has(key))),
@@ -20653,9 +20664,8 @@ function useMenuSelectField(props) {
       const valueKey = key === void 0 ? void 0 : menuTree.nodes.get(key)?.valueKey;
       if (valueKey === void 0) return;
       const next2 = toggleTreeSelection(menuTree, selectedKeys, valueKey, added !== void 0, disabledKeySet);
-      const nextOptions = selectedTreeOptions(menuTree, next2);
       proposalProps.onUserEdit?.();
-      onCommit(nextOptions.map(getOptionValue), nextOptions);
+      commitTree(next2);
       return;
     }
     if (!multiple) {
@@ -20670,16 +20680,17 @@ function useMenuSelectField(props) {
       close({ restoreFocus: true });
       return;
     }
-    const next = values.filter((v) => keys.has(valueToKey(v)));
+    const next = values.filter((value) => {
+      const key = valueToKey(value);
+      if (!optionsByKey.has(key)) return true;
+      return keys.has(key);
+    });
     for (const k of keys) {
       const opt = optionsByKey.get(String(k));
       if (opt !== void 0 && !selectedKeys.has(String(k))) next.push(getOptionValue(opt));
     }
     proposalProps.onUserEdit?.();
-    onCommit(
-      next,
-      next.map((v) => optionsByKey.get(valueToKey(v))).filter((o) => o !== void 0)
-    );
+    onCommit(next, optionsForValues(next));
   }
   const collectionItems = (0, import_react85.useMemo)(() => {
     if (treeRows) {
@@ -20891,14 +20902,35 @@ function useMenuSelectField(props) {
     proposalProps.onUserEdit?.();
     if (menuTree) {
       const toggledKeys = toggleTreeSelection(menuTree, selectedKeys, key, false, disabledKeySet);
-      const toggledOptions = selectedTreeOptions(menuTree, toggledKeys);
-      onCommit(toggledOptions.map(getOptionValue), toggledOptions);
+      commitTree(toggledKeys, key);
       return;
     }
     const next = values.filter((value) => valueToKey(value) !== key);
+    onCommit(next, optionsForValues(next));
+  }
+  function optionsForValues(next) {
+    return next.flatMap((value) => {
+      const option = optionForKey(valueToKey(value), optionsByKey, rememberedSelectedRef.current);
+      return option ? [option] : [];
+    });
+  }
+  function commitTree(nextKeys, clearedKey) {
+    if (!menuTree) return;
+    const selectedInTree = selectedTreeOptions(menuTree, nextKeys);
+    const valueKeysInTree = new Set(menuTree.orderedKeys.map((rowKey) => menuTree.nodes.get(rowKey).valueKey));
+    const seen = /* @__PURE__ */ new Set();
+    const keptSelections = values.flatMap((value) => {
+      const key = valueToKey(value);
+      if (valueKeysInTree.has(key) || key === clearedKey || seen.has(key)) return [];
+      const option = optionForKey(key, optionsByKey, rememberedSelectedRef.current);
+      if (!option) return [];
+      seen.add(key);
+      return [option];
+    });
+    const nextOptions = [...selectedInTree, ...keptSelections];
     onCommit(
-      next,
-      next.map((value) => optionsByKey.get(valueToKey(value))).filter((option) => option !== void 0)
+      nextOptions.map((option) => getOptionValue(option)),
+      nextOptions
     );
   }
   const triggerProps = {
@@ -20964,6 +20996,41 @@ function useMenuSelectField(props) {
     }
   };
 }
+function syncRememberedOptions(remembered, values, optionsByKey) {
+  const selected = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const key = valueToKey(value);
+    selected.add(key);
+    const option = optionsByKey.get(key);
+    if (option) remembered.set(key, option);
+  }
+  for (const key of remembered.keys()) {
+    if (!selected.has(key)) remembered.delete(key);
+  }
+}
+function optionForKey(key, optionsByKey, remembered) {
+  return optionsByKey.get(key) ?? remembered.get(key);
+}
+function resolveSelectedOptions(values, menuTree, selectedKeys, optionsByKey, remembered, getOptionValue) {
+  if (!menuTree) {
+    return values.flatMap((value) => {
+      const option = optionForKey(valueToKey(value), optionsByKey, remembered);
+      return option ? [option] : [];
+    });
+  }
+  const selectedInTree = selectedTreeOptions(menuTree, selectedKeys);
+  const seen = new Set(selectedInTree.map((option) => valueToKey(getOptionValue(option))));
+  const keptSelections = [];
+  for (const value of values) {
+    const key = valueToKey(value);
+    if (seen.has(key)) continue;
+    const option = optionForKey(key, optionsByKey, remembered);
+    if (!option) continue;
+    seen.add(key);
+    keptSelections.push(option);
+  }
+  return [...selectedInTree, ...keptSelections];
+}
 function labelsFor(values, options, getOptionValue, getOptionLabel) {
   const keys = new Set(values.map(valueToKey));
   const seen = /* @__PURE__ */ new Set();