@sesionario/blocks 1.8.0 → 1.10.0

package/dist/index.cjs

@@ -521,6 +521,9 @@ function ExpandableText({
 var MIN_SCALE = 1;
 var MAX_SCALE = 4;
 var DOUBLE_TAP_MS = 300;
+var SWIPE_LOCK_PX = 8;
+var SWIPE_COMMIT_PX = 56;
+var SWIPE_SNAP_MS = 180;
 var IDENTITY = { scale: 1, tx: 0, ty: 0 };
 function clamp(value, min, max) {
   return Math.min(max, Math.max(min, value));
@@ -538,6 +541,10 @@ function zoomToward(prev, nextScale, originX, originY) {
 function pointerDistance(a, b) {
   return Math.hypot(b.x - a.x, b.y - a.y);
 }
+function prefersReducedMotion() {
+  if (typeof window === "undefined" || !window.matchMedia) return false;
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
 function ImageLightbox({
   images,
   index,
@@ -553,15 +560,24 @@ function ImageLightbox({
   const [transform, setTransform] = React6.useState(IDENTITY);
   const transformRef = React6.useRef(transform);
   transformRef.current = transform;
+  const [isSwipeDragging, setIsSwipeDragging] = React6.useState(false);
+  const [snapBack, setSnapBack] = React6.useState(false);
   const stageRef = React6.useRef(null);
   const pointersRef = React6.useRef(/* @__PURE__ */ new Map());
   const pinchStartRef = React6.useRef(null);
   const panRef = React6.useRef(null);
+  const swipeRef = React6.useRef(null);
   const lastTapRef = React6.useRef(
     null
   );
+  const indexRef = React6.useRef(index);
+  indexRef.current = index;
+  const imagesLengthRef = React6.useRef(images.length);
+  imagesLengthRef.current = images.length;
   const resetZoom = React6.useCallback(() => {
     setTransform(IDENTITY);
+    setIsSwipeDragging(false);
+    setSnapBack(false);
   }, []);
   React6.useEffect(() => {
     resetZoom();
@@ -618,6 +634,10 @@ function ImageLightbox({
     stage.addEventListener("wheel", handleWheel, { passive: false });
     return () => stage.removeEventListener("wheel", handleWheel);
   }, [stageOrigin]);
+  function clearSwipe() {
+    swipeRef.current = null;
+    setIsSwipeDragging(false);
+  }
   function beginPinch() {
     const pts = [...pointersRef.current.values()];
     const [a, b] = pts;
@@ -632,13 +652,18 @@ function ImageLightbox({
       transform: { ...transformRef.current }
     };
     panRef.current = null;
+    clearSwipe();
+    setSnapBack(false);
   }
   function onPointerDown(e) {
     e.stopPropagation();
     const stage = stageRef.current;
     if (!stage) return;
-    stage.setPointerCapture(e.pointerId);
+    if (typeof stage.setPointerCapture === "function") {
+      stage.setPointerCapture(e.pointerId);
+    }
     pointersRef.current.set(e.pointerId, { x: e.clientX, y: e.clientY });
+    setSnapBack(false);
     if (pointersRef.current.size === 2) {
       beginPinch();
       return;
@@ -652,6 +677,17 @@ function ImageLightbox({
         originTy: transformRef.current.ty,
         moved: false
       };
+      return;
+    }
+    if (hasMultiple) {
+      swipeRef.current = {
+        pointerId: e.pointerId,
+        startX: e.clientX,
+        startY: e.clientY,
+        moved: false,
+        axis: null
+      };
+      setIsSwipeDragging(true);
     }
   }
   function onPointerMove(e) {
@@ -676,19 +712,62 @@ function ImageLightbox({
     }
     const pan = panRef.current;
     if (pan && pan.pointerId === e.pointerId) {
-      const dx = e.clientX - pan.startX;
-      const dy = e.clientY - pan.startY;
-      if (Math.abs(dx) > 2 || Math.abs(dy) > 2) pan.moved = true;
+      const dx2 = e.clientX - pan.startX;
+      const dy2 = e.clientY - pan.startY;
+      if (Math.abs(dx2) > 2 || Math.abs(dy2) > 2) pan.moved = true;
       setTransform((prev) => ({
         ...prev,
-        tx: pan.originTx + dx,
-        ty: pan.originTy + dy
+        tx: pan.originTx + dx2,
+        ty: pan.originTy + dy2
       }));
+      return;
+    }
+    const swipe = swipeRef.current;
+    if (!swipe || swipe.pointerId !== e.pointerId) return;
+    const dx = e.clientX - swipe.startX;
+    const dy = e.clientY - swipe.startY;
+    if (Math.abs(dx) > 2 || Math.abs(dy) > 2) swipe.moved = true;
+    if (swipe.axis === null) {
+      const absX = Math.abs(dx);
+      const absY = Math.abs(dy);
+      if (absX < SWIPE_LOCK_PX && absY < SWIPE_LOCK_PX) return;
+      swipe.axis = absX >= absY ? "x" : "y";
+      if (swipe.axis === "y") {
+        clearSwipe();
+        setTransform(IDENTITY);
+        return;
+      }
+    }
+    if (swipe.axis === "x") {
+      setTransform({ scale: MIN_SCALE, tx: dx, ty: 0 });
+    }
+  }
+  function finishSwipe(e) {
+    const swipe = swipeRef.current;
+    if (!swipe || swipe.pointerId !== e.pointerId) return false;
+    const dx = e.clientX - swipe.startX;
+    const wasMoved = swipe.moved;
+    const axis = swipe.axis;
+    clearSwipe();
+    if (axis === "x" && Math.abs(dx) >= SWIPE_COMMIT_PX) {
+      const length = imagesLengthRef.current;
+      const current = indexRef.current;
+      if (dx < 0) {
+        onIndexChange((current + 1) % length);
+      } else {
+        onIndexChange((current - 1 + length) % length);
+      }
+      return true;
     }
+    if (wasMoved || transformRef.current.tx !== 0) {
+      if (!prefersReducedMotion()) setSnapBack(true);
+      setTransform(IDENTITY);
+    }
+    return wasMoved;
   }
   function onPointerUp(e) {
     const stage = stageRef.current;
-    if (stage?.hasPointerCapture(e.pointerId)) {
+    if (stage && typeof stage.hasPointerCapture === "function" && stage.hasPointerCapture(e.pointerId) && typeof stage.releasePointerCapture === "function") {
       stage.releasePointerCapture(e.pointerId);
     }
     pointersRef.current.delete(e.pointerId);
@@ -709,6 +788,8 @@ function ImageLightbox({
         };
       }
     }
+    const swipeHandled = finishSwipe(e);
+    if (swipeHandled) return;
     const pan = panRef.current;
     if (pan && pan.pointerId === e.pointerId) {
       const wasMoved = pan.moved;
@@ -730,6 +811,7 @@ function ImageLightbox({
     e.stopPropagation();
   }
   const { scale, tx, ty } = transform;
+  const transition = snapBack && !isSwipeDragging && !prefersReducedMotion() ? `transform ${SWIPE_SNAP_MS}ms ease-out` : void 0;
   return reactDom.createPortal(
     /* @__PURE__ */ jsxRuntime.jsxs(
       "div",
@@ -769,6 +851,7 @@ function ImageLightbox({
               ref: stageRef,
               className: "relative flex max-h-full max-w-full touch-none items-center justify-center",
               "data-scale": scale,
+              "data-swipe-dragging": isSwipeDragging ? "true" : "false",
               onClick: stopDialogClose,
               onPointerDown,
               onPointerMove,
@@ -783,8 +866,10 @@ function ImageLightbox({
                   className: "max-h-[calc(100dvh-2rem)] max-w-full select-none rounded-lg object-contain",
                   style: {
                     transform: `translate(${tx}px, ${ty}px) scale(${scale})`,
+                    transition,
                     cursor: scale > MIN_SCALE ? "grab" : "default"
-                  }
+                  },
+                  onTransitionEnd: () => setSnapBack(false)
                 }
               )
             }
@@ -1411,7 +1496,7 @@ function LanguageSwitcher({
   const sizes = sizeClasses2[size];
   const shapeClass = shapeClasses2[shape];
   const reduceMotion = framerMotion.useReducedMotion();
-  const defaultLabels4 = {
+  const defaultLabels5 = {
     language: labels.language ?? "Language"
   };
   if (variant === "mini") {
@@ -1421,7 +1506,7 @@ function LanguageSwitcher({
         {
           variant: "ghost",
           size: "icon",
-          "aria-label": defaultLabels4.language,
+          "aria-label": defaultLabels5.language,
           className: cn(sizes.buttonMini, shapeClass, className),
           children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Languages, { className: sizes.iconMini })
         }
@@ -3710,6 +3795,19 @@ var PLAYBACK_RATES = [0.75, 1, 1.25, 1.5, 2];
 var CONTROLS_HIDE_MS = 3e3;
 var LIVE_EDGE_THRESHOLD_S = 8;
 var SEEK_STEP_S = 5;
+function asWebkitVideo(video) {
+  return video;
+}
+function hasWebkitVideoFullscreen(video) {
+  const webkit = asWebkitVideo(video);
+  return typeof webkit?.webkitEnterFullscreen === "function";
+}
+function hasStandardFullscreen() {
+  if (typeof document === "undefined") return false;
+  if (document.fullscreenEnabled) return true;
+  const doc = document;
+  return !!doc.webkitFullscreenEnabled;
+}
 function formatTime(seconds) {
   if (!Number.isFinite(seconds) || seconds < 0) return "0:00";
   const total = Math.floor(seconds);
@@ -3783,10 +3881,10 @@ function VideoPlayer({
     null
   );
   const [behindLive, setBehindLive] = React6__namespace.useState(false);
+  const [webkitFullscreenSupported, setWebkitFullscreenSupported] = React6__namespace.useState(false);
   const hideTimerRef = React6__namespace.useRef(null);
   const pipSupported = typeof document !== "undefined" && "pictureInPictureEnabled" in document && document.pictureInPictureEnabled;
-  const fullscreenSupported = typeof document !== "undefined" && (!!document.fullscreenEnabled || // Safari
-  "webkitFullscreenEnabled" in document);
+  const fullscreenSupported = hasStandardFullscreen() || webkitFullscreenSupported;
   React6__namespace.useEffect(() => {
     const video = videoRef.current;
     if (!video || !active) return;
@@ -3820,11 +3918,26 @@ function VideoPlayer({
       video.removeEventListener("ratechange", onRate);
     };
   }, [videoRef, active, mode]);
+  React6__namespace.useEffect(() => {
+    setWebkitFullscreenSupported(hasWebkitVideoFullscreen(videoRef.current));
+  }, [videoRef, active]);
   React6__namespace.useEffect(() => {
     const onFsChange = () => setIsFullscreen(document.fullscreenElement === containerRef.current);
     document.addEventListener("fullscreenchange", onFsChange);
     return () => document.removeEventListener("fullscreenchange", onFsChange);
   }, []);
+  React6__namespace.useEffect(() => {
+    const video = asWebkitVideo(videoRef.current);
+    if (!video) return;
+    const onBegin = () => setIsFullscreen(true);
+    const onEnd = () => setIsFullscreen(false);
+    video.addEventListener("webkitbeginfullscreen", onBegin);
+    video.addEventListener("webkitendfullscreen", onEnd);
+    return () => {
+      video.removeEventListener("webkitbeginfullscreen", onBegin);
+      video.removeEventListener("webkitendfullscreen", onEnd);
+    };
+  }, [videoRef, active]);
   React6__namespace.useEffect(() => {
     const video = videoRef.current;
     if (!video) return;
@@ -3889,11 +4002,21 @@ function VideoPlayer({
   }
   function toggleFullscreen() {
     const el = containerRef.current;
-    if (!el) return;
-    if (document.fullscreenElement === el) {
+    const video = asWebkitVideo(videoRef.current);
+    if (el && document.fullscreenElement === el) {
       void document.exitFullscreen();
-    } else {
-      void el.requestFullscreen?.();
+      return;
+    }
+    if (video?.webkitDisplayingFullscreen && video.webkitExitFullscreen) {
+      video.webkitExitFullscreen();
+      return;
+    }
+    if (el && hasStandardFullscreen() && typeof el.requestFullscreen === "function") {
+      void el.requestFullscreen();
+      return;
+    }
+    if (video && typeof video.webkitEnterFullscreen === "function") {
+      video.webkitEnterFullscreen();
     }
   }
   function togglePip() {
@@ -4348,6 +4471,18 @@ function useDebouncedValueStrict(value, delayMs) {
   }, [value, delayMs]);
   return debounced;
 }
+function useMediaQuery2(query) {
+  const [matches, setMatches] = React6.useState(false);
+  React6.useEffect(() => {
+    if (typeof window === "undefined" || !window.matchMedia) return;
+    const mql = window.matchMedia(query);
+    const onChange = () => setMatches(mql.matches);
+    onChange();
+    mql.addEventListener("change", onChange);
+    return () => mql.removeEventListener("change", onChange);
+  }, [query]);
+  return matches;
+}
 function useSearchHotkey(options = {}) {
   const { defaultOpen = false, disabled = false } = options;
   const [open, setOpen] = React6.useState(defaultOpen);
@@ -4365,6 +4500,22 @@ function useSearchHotkey(options = {}) {
   }, [disabled]);
   return { open, setOpen, toggle };
 }
+
+// src/components/search/fuzzy.ts
+function normalize(value) {
+  return value.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function fuzzyMatch(query, target) {
+  const q = normalize(query.trim());
+  if (!q) return true;
+  const t = normalize(target);
+  if (t.includes(q)) return true;
+  let qi = 0;
+  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+    if (t[ti] === q[qi]) qi++;
+  }
+  return qi === q.length;
+}
 function Command({
   className,
   ...props
@@ -4482,6 +4633,19 @@ function CommandGroup({
     }
   );
 }
+function CommandSeparator({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    cmdk.Command.Separator,
+    {
+      "data-slot": "command-separator",
+      className: cn("-mx-1 h-px bg-border", className),
+      ...props
+    }
+  );
+}
 function CommandItem({
   className,
   ...props
@@ -4498,23 +4662,584 @@ function CommandItem({
     }
   );
 }
-
-// src/components/search/fuzzy.ts
-function normalize(value) {
-  return value.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+function OptionRow({
+  entry,
+  selected,
+  onSelect,
+  renderOption
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    CommandItem,
+    {
+      value: entry.value,
+      keywords: [entry.label],
+      onSelect,
+      "data-checked": selected || void 0,
+      children: [
+        renderOption ? renderOption(entry.item, { selected }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 flex-1 truncate", children: entry.label }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          lucideReact.CheckIcon,
+          {
+            className: cn(
+              "ml-auto size-4 shrink-0",
+              selected ? "opacity-100" : "opacity-0"
+            )
+          }
+        )
+      ]
+    },
+    entry.value
+  );
 }
-function fuzzyMatch(query, target) {
-  const q = normalize(query.trim());
-  if (!q) return true;
-  const t = normalize(target);
-  if (t.includes(q)) return true;
-  let qi = 0;
-  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
-    if (t[ti] === q[qi]) qi++;
-  }
-  return qi === q.length;
+function SearchablePickerList({
+  query,
+  onQueryChange,
+  labels,
+  isLoading,
+  hasError,
+  recommended,
+  recent,
+  results,
+  selectedValues,
+  mode,
+  allowEmpty,
+  emptyLabel,
+  onSelectEmpty,
+  onSelectItem,
+  renderOption,
+  createOption,
+  onLoadMore,
+  hasMore,
+  isLoadingMore,
+  listClassName
+}) {
+  const hasPinned = recommended.length > 0 || recent.length > 0;
+  const hasResults = results.length > 0;
+  const showEmpty = !isLoading && !hasError && !hasPinned && !hasResults && !(allowEmpty && mode === "single");
+  return /* @__PURE__ */ jsxRuntime.jsxs(Command, { shouldFilter: false, className: "flex h-full min-h-0 flex-col", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      CommandInput,
+      {
+        placeholder: labels.searchPlaceholder,
+        value: query,
+        onValueChange: onQueryChange
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(CommandList, { className: cn("min-h-0 flex-1", listClassName), children: [
+      isLoading ? /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          className: "flex items-center justify-center gap-2 py-6 text-sm text-muted-foreground",
+          role: "status",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-4 animate-spin", "aria-hidden": true }),
+            labels.loading
+          ]
+        }
+      ) : null,
+      hasError && !isLoading ? /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "py-6 text-center text-sm text-destructive",
+          role: "alert",
+          children: labels.error
+        }
+      ) : null,
+      showEmpty ? /* @__PURE__ */ jsxRuntime.jsx(CommandEmpty, { children: labels.empty }) : null,
+      allowEmpty && mode === "single" && !query.trim() ? /* @__PURE__ */ jsxRuntime.jsx(CommandGroup, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+        CommandItem,
+        {
+          value: "__empty__",
+          onSelect: () => onSelectEmpty?.(),
+          "data-checked": !selectedValues.size || void 0,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 flex-1 truncate text-muted-foreground", children: emptyLabel }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              lucideReact.CheckIcon,
+              {
+                className: cn(
+                  "ml-auto size-4 shrink-0",
+                  selectedValues.size === 0 ? "opacity-100" : "opacity-0"
+                )
+              }
+            )
+          ]
+        }
+      ) }) : null,
+      recommended.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(CommandGroup, { heading: labels.recommended, children: recommended.map((entry) => /* @__PURE__ */ jsxRuntime.jsx(
+        OptionRow,
+        {
+          entry,
+          selected: selectedValues.has(entry.value),
+          onSelect: () => onSelectItem(entry.value),
+          renderOption
+        },
+        `rec-${entry.value}`
+      )) }) : null,
+      recent.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(CommandGroup, { heading: labels.recent, children: recent.map((entry) => /* @__PURE__ */ jsxRuntime.jsx(
+        OptionRow,
+        {
+          entry,
+          selected: selectedValues.has(entry.value),
+          onSelect: () => onSelectItem(entry.value),
+          renderOption
+        },
+        `recent-${entry.value}`
+      )) }) : null,
+      hasPinned && hasResults ? /* @__PURE__ */ jsxRuntime.jsx(CommandSeparator, {}) : null,
+      hasResults ? /* @__PURE__ */ jsxRuntime.jsx(CommandGroup, { heading: hasPinned ? labels.results : void 0, children: results.map((entry) => /* @__PURE__ */ jsxRuntime.jsx(
+        OptionRow,
+        {
+          entry,
+          selected: selectedValues.has(entry.value),
+          onSelect: () => onSelectItem(entry.value),
+          renderOption
+        },
+        `res-${entry.value}`
+      )) }) : null,
+      hasMore && onLoadMore ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-2", children: /* @__PURE__ */ jsxRuntime.jsx(
+        Button,
+        {
+          type: "button",
+          variant: "ghost",
+          size: "sm",
+          className: "w-full",
+          disabled: isLoadingMore,
+          onClick: () => void onLoadMore(),
+          children: isLoadingMore ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-4 animate-spin", "aria-hidden": true }),
+            labels.loading
+          ] }) : labels.loadMore
+        }
+      ) }) : null,
+      createOption ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(CommandSeparator, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(CommandGroup, { children: /* @__PURE__ */ jsxRuntime.jsx(
+          CommandItem,
+          {
+            value: "__create__",
+            onSelect: () => createOption.onSelect(),
+            children: createOption.label
+          }
+        ) })
+      ] }) : null
+    ] })
+  ] });
 }
 var defaultLabels3 = {
+  placeholder: "Seleccionar\u2026",
+  searchPlaceholder: "Buscar\u2026",
+  empty: "No se encontraron resultados",
+  loading: "Cargando\u2026",
+  error: "No se pudo cargar la lista",
+  recommended: "Recomendados",
+  recent: "Recientes",
+  results: "Resultados",
+  done: "Listo",
+  cancel: "Cancelar",
+  clear: "Limpiar",
+  selectedCount: (count) => count === 1 ? "1 seleccionado" : `${count} seleccionados`,
+  emptyOption: "Ninguno",
+  loadMore: "Cargar m\xE1s",
+  dialogTitle: "Seleccionar"
+};
+function toListItems(items, getOptionValue, getOptionLabel) {
+  if (!items?.length) return [];
+  return items.map((item) => ({
+    item,
+    value: getOptionValue(item),
+    label: getOptionLabel(item)
+  }));
+}
+function dedupeByValue(items, exclude = /* @__PURE__ */ new Set()) {
+  const seen = new Set(exclude);
+  const out = [];
+  for (const entry of items) {
+    if (seen.has(entry.value)) continue;
+    seen.add(entry.value);
+    out.push(entry);
+  }
+  return out;
+}
+function matchesQuery(entry, query, getOptionKeywords) {
+  if (!query.trim()) return true;
+  if (fuzzyMatch(query, entry.label)) return true;
+  return getOptionKeywords?.(entry.item)?.some(
+    (keyword) => fuzzyMatch(query, keyword)
+  ) ?? false;
+}
+function SearchablePicker(props) {
+  const {
+    options,
+    fetchOptions,
+    getOptionValue,
+    getOptionLabel,
+    getOptionKeywords,
+    renderOption,
+    renderValue,
+    pinned,
+    labels: userLabels,
+    minQueryLength = 0,
+    debounceMs = 200,
+    disabled,
+    open: openProp,
+    onOpenChange,
+    clearable,
+    allowEmpty,
+    emptyLabel,
+    keepOpenOnSelect,
+    maxSelected,
+    createOption,
+    onLoadMore,
+    hasMore,
+    className,
+    triggerClassName: triggerClassName2,
+    id,
+    "aria-labelledby": ariaLabelledBy,
+    "aria-label": ariaLabel
+  } = props;
+  const mode = props.mode ?? "single";
+  const labels = { ...defaultLabels3, ...userLabels };
+  const resolvedEmptyLabel = emptyLabel ?? labels.emptyOption;
+  const isMobile = useMediaQuery2("(max-width: 767px)");
+  const generatedId = React6.useId();
+  const triggerId = id ?? generatedId;
+  const [uncontrolledOpen, setUncontrolledOpen] = React6.useState(false);
+  const open = openProp ?? uncontrolledOpen;
+  const setOpen = React6.useCallback(
+    (next) => {
+      onOpenChange?.(next);
+      if (openProp === void 0) setUncontrolledOpen(next);
+    },
+    [onOpenChange, openProp]
+  );
+  const [query, setQuery] = React6.useState("");
+  const [remoteItems, setRemoteItems] = React6.useState([]);
+  const [isLoading, setIsLoading] = React6.useState(false);
+  const [hasError, setHasError] = React6.useState(false);
+  const [isLoadingMore, setIsLoadingMore] = React6.useState(false);
+  const debouncedQuery = useDebouncedValue(query, debounceMs);
+  const requestIdRef = React6.useRef(0);
+  const knownItemsRef = React6.useRef(/* @__PURE__ */ new Map());
+  const rememberItems = React6.useCallback(
+    (items) => {
+      for (const item of items) {
+        knownItemsRef.current.set(getOptionValue(item), item);
+      }
+    },
+    [getOptionValue]
+  );
+  React6.useEffect(() => {
+    if (options) rememberItems(options);
+    if (pinned?.recommended) rememberItems(pinned.recommended);
+    if (pinned?.recent) rememberItems(pinned.recent);
+  }, [options, pinned, rememberItems]);
+  React6.useEffect(() => {
+    if (!open) {
+      setQuery("");
+      setRemoteItems([]);
+      setHasError(false);
+      setIsLoading(false);
+    }
+  }, [open]);
+  const trimmedDebounced = debouncedQuery.trim();
+  const shouldFetch = Boolean(fetchOptions) && open && trimmedDebounced.length >= minQueryLength && (trimmedDebounced.length > 0 || !options);
+  React6.useEffect(() => {
+    if (!shouldFetch || !fetchOptions) {
+      if (!trimmedDebounced) {
+        setRemoteItems([]);
+        setHasError(false);
+        setIsLoading(false);
+      }
+      return;
+    }
+    const requestId = ++requestIdRef.current;
+    setIsLoading(true);
+    setHasError(false);
+    fetchOptions(trimmedDebounced).then((result) => {
+      if (requestIdRef.current !== requestId) return;
+      setRemoteItems(result);
+      rememberItems(result);
+    }).catch(() => {
+      if (requestIdRef.current !== requestId) return;
+      setRemoteItems([]);
+      setHasError(true);
+    }).finally(() => {
+      if (requestIdRef.current !== requestId) return;
+      setIsLoading(false);
+    });
+  }, [shouldFetch, fetchOptions, trimmedDebounced, rememberItems]);
+  const selectedValues = React6.useMemo(() => {
+    if (mode === "multiple") {
+      const multiValue = props.value ?? [];
+      return new Set(multiValue);
+    }
+    const singleValue = props.value;
+    return singleValue ? /* @__PURE__ */ new Set([singleValue]) : /* @__PURE__ */ new Set();
+  }, [mode, props]);
+  const selectedValueKey = mode === "multiple" ? (props.value ?? []).join("\0") : props.value ?? "";
+  const selectedItems = React6.useMemo(() => {
+    const values = mode === "multiple" ? selectedValueKey ? selectedValueKey.split("\0") : [] : selectedValueKey ? [selectedValueKey] : [];
+    return values.map((value) => knownItemsRef.current.get(value)).filter((item) => item !== void 0);
+  }, [mode, selectedValueKey, options, pinned, remoteItems]);
+  const queryForFilter = query.trim();
+  const recommended = React6.useMemo(() => {
+    if (queryForFilter) return [];
+    const pinnedValues = /* @__PURE__ */ new Set();
+    const items = dedupeByValue(
+      toListItems(pinned?.recommended, getOptionValue, getOptionLabel)
+    );
+    for (const entry of items) pinnedValues.add(entry.value);
+    return items;
+  }, [queryForFilter, pinned?.recommended, getOptionValue, getOptionLabel]);
+  const recent = React6.useMemo(() => {
+    if (queryForFilter) return [];
+    const exclude = new Set(recommended.map((e) => e.value));
+    return dedupeByValue(
+      toListItems(pinned?.recent, getOptionValue, getOptionLabel),
+      exclude
+    );
+  }, [
+    queryForFilter,
+    pinned?.recent,
+    recommended,
+    getOptionValue,
+    getOptionLabel
+  ]);
+  const pinnedValueSet = React6.useMemo(() => {
+    const set = /* @__PURE__ */ new Set();
+    for (const entry of recommended) set.add(entry.value);
+    for (const entry of recent) set.add(entry.value);
+    return set;
+  }, [recommended, recent]);
+  const results = React6.useMemo(() => {
+    const usingRemote = Boolean(fetchOptions) && trimmedDebounced.length >= minQueryLength && (trimmedDebounced.length > 0 || !options);
+    if (usingRemote) {
+      return dedupeByValue(
+        toListItems(remoteItems, getOptionValue, getOptionLabel),
+        queryForFilter ? /* @__PURE__ */ new Set() : pinnedValueSet
+      );
+    }
+    const staticItems = toListItems(options, getOptionValue, getOptionLabel);
+    const filtered = staticItems.filter(
+      (entry) => matchesQuery(entry, queryForFilter, getOptionKeywords)
+    );
+    return dedupeByValue(filtered, queryForFilter ? /* @__PURE__ */ new Set() : pinnedValueSet);
+  }, [
+    fetchOptions,
+    trimmedDebounced,
+    minQueryLength,
+    options,
+    remoteItems,
+    getOptionValue,
+    getOptionLabel,
+    getOptionKeywords,
+    queryForFilter,
+    pinnedValueSet
+  ]);
+  const closeOnSelect = keepOpenOnSelect !== void 0 ? !keepOpenOnSelect : mode === "single";
+  const handleSelectEmpty = React6.useCallback(() => {
+    if (mode === "single") {
+      props.onValueChange?.(
+        null
+      );
+    }
+    if (closeOnSelect) setOpen(false);
+  }, [mode, props, closeOnSelect, setOpen]);
+  const handleSelectItem = React6.useCallback(
+    (value) => {
+      if (mode === "multiple") {
+        const current = props.value ?? [];
+        const onChange = props.onValueChange;
+        const exists = current.includes(value);
+        if (exists) {
+          onChange?.(current.filter((v) => v !== value));
+        } else if (maxSelected !== void 0 && current.length >= maxSelected) {
+          return;
+        } else {
+          onChange?.([...current, value]);
+        }
+        if (closeOnSelect) setOpen(false);
+        return;
+      }
+      props.onValueChange?.(
+        value
+      );
+      if (closeOnSelect) setOpen(false);
+    },
+    [mode, props, maxSelected, closeOnSelect, setOpen]
+  );
+  const handleClear = React6.useCallback(
+    (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      if (mode === "multiple") {
+        props.onValueChange?.(
+          []
+        );
+      } else {
+        props.onValueChange?.(null);
+      }
+    },
+    [mode, props]
+  );
+  const handleLoadMore = React6.useCallback(async () => {
+    if (!onLoadMore || isLoadingMore) return;
+    setIsLoadingMore(true);
+    try {
+      await onLoadMore();
+    } finally {
+      setIsLoadingMore(false);
+    }
+  }, [onLoadMore, isLoadingMore]);
+  const triggerLabel = React6.useMemo(() => {
+    if (renderValue) {
+      if (mode === "multiple") {
+        return renderValue(selectedItems);
+      }
+      return renderValue(selectedItems[0] ?? null);
+    }
+    if (mode === "multiple") {
+      const count = selectedValues.size;
+      if (count === 0) {
+        return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: labels.placeholder });
+      }
+      if (selectedItems.length === 1) {
+        return getOptionLabel(selectedItems[0]);
+      }
+      return labels.selectedCount(count);
+    }
+    if (selectedValues.size === 0) {
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: allowEmpty ? resolvedEmptyLabel : labels.placeholder });
+    }
+    if (selectedItems[0]) {
+      return getOptionLabel(selectedItems[0]);
+    }
+    const only = [...selectedValues][0];
+    return only ?? labels.placeholder;
+  }, [
+    renderValue,
+    mode,
+    selectedItems,
+    selectedValues,
+    labels,
+    getOptionLabel,
+    allowEmpty,
+    resolvedEmptyLabel
+  ]);
+  const showClear = clearable && !disabled && (mode === "multiple" ? selectedValues.size > 0 : selectedValues.size > 0);
+  const list = /* @__PURE__ */ jsxRuntime.jsx(
+    SearchablePickerList,
+    {
+      query,
+      onQueryChange: setQuery,
+      labels,
+      isLoading,
+      hasError,
+      recommended,
+      recent,
+      results,
+      selectedValues,
+      mode,
+      allowEmpty,
+      emptyLabel: resolvedEmptyLabel,
+      onSelectEmpty: handleSelectEmpty,
+      onSelectItem: handleSelectItem,
+      renderOption,
+      createOption,
+      onLoadMore: onLoadMore ? handleLoadMore : void 0,
+      hasMore,
+      isLoadingMore,
+      listClassName: isMobile ? "max-h-[min(50vh,360px)]" : "max-h-72"
+    }
+  );
+  const triggerButton = /* @__PURE__ */ jsxRuntime.jsxs(
+    Button,
+    {
+      type: "button",
+      variant: "outline",
+      role: "combobox",
+      id: triggerId,
+      "aria-expanded": open,
+      "aria-labelledby": ariaLabelledBy,
+      "aria-label": ariaLabel ?? labels.placeholder,
+      disabled,
+      className: cn("w-full justify-between font-normal", triggerClassName2),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 flex-1 truncate text-left", children: triggerLabel }),
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronsUpDown, { className: "ml-2 size-4 shrink-0 opacity-50", "aria-hidden": true })
+      ]
+    }
+  );
+  const clearButton = showClear ? /* @__PURE__ */ jsxRuntime.jsx(
+    Button,
+    {
+      type: "button",
+      variant: "ghost",
+      size: "icon-sm",
+      "aria-label": labels.clear,
+      disabled,
+      className: "shrink-0",
+      onClick: handleClear,
+      children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "size-4" })
+    }
+  ) : null;
+  if (isMobile) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex w-full items-center gap-1", className), children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "min-w-0 flex-1",
+          onClick: () => {
+            if (!disabled) setOpen(true);
+          },
+          children: triggerButton
+        }
+      ),
+      clearButton,
+      /* @__PURE__ */ jsxRuntime.jsx(Drawer, { open, onOpenChange: setOpen, children: /* @__PURE__ */ jsxRuntime.jsxs(DrawerContent, { className: "max-h-[90vh]", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(DrawerHeader, { className: "text-left", children: /* @__PURE__ */ jsxRuntime.jsx(DrawerTitle, { children: labels.dialogTitle }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "min-h-0 flex-1 overflow-hidden px-2 pb-2", children: list }),
+        mode === "multiple" ? /* @__PURE__ */ jsxRuntime.jsxs(DrawerFooter, { className: "flex-row gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              className: "flex-1",
+              onClick: () => setOpen(false),
+              children: labels.cancel
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            Button,
+            {
+              type: "button",
+              className: "flex-1",
+              onClick: () => setOpen(false),
+              children: labels.done
+            }
+          )
+        ] }) : null
+      ] }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex w-full items-center gap-1", className), children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "min-w-0 flex-1", children: /* @__PURE__ */ jsxRuntime.jsxs(Popover, { open, onOpenChange: setOpen, modal: true, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(PopoverTrigger, { asChild: true, children: triggerButton }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        PopoverContent,
+        {
+          className: "w-[var(--radix-popover-trigger-width)] min-w-[240px] p-0",
+          align: "start",
+          children: list
+        }
+      )
+    ] }) }),
+    clearButton
+  ] });
+}
+var defaultLabels4 = {
   placeholder: "Buscar en toda la plataforma\u2026",
   dialogTitle: "Buscar",
   dialogDescription: "Busca funcionalidades, eventos, documentos y m\xE1s",
@@ -4548,7 +5273,7 @@ function SearchCommand({
   debounceMs = 200,
   className
 }) {
-  const labels = { ...defaultLabels3, ...userLabels };
+  const labels = { ...defaultLabels4, ...userLabels };
   const [query, setQuery] = React6.useState("");
   const [hits, setHits] = React6.useState([]);
   const [isLoading, setIsLoading] = React6.useState(false);
@@ -5429,18 +6154,6 @@ function ChatMessageList({
     /* @__PURE__ */ jsxRuntime.jsx(MessageScrollerButton, {})
   ] }) });
 }
-function useMediaQuery2(query) {
-  const [matches, setMatches] = React6.useState(false);
-  React6.useEffect(() => {
-    if (typeof window === "undefined" || !window.matchMedia) return;
-    const mql = window.matchMedia(query);
-    const onChange = () => setMatches(mql.matches);
-    onChange();
-    mql.addEventListener("change", onChange);
-    return () => mql.removeEventListener("change", onChange);
-  }, [query]);
-  return matches;
-}
 var RECONNECT_DELAY_MS = 2e3;
 function useSupportConversation({
   client,
@@ -6117,6 +6830,7 @@ exports.MexicoMap = MexicoMap;
 exports.OrgSwitcher = OrgSwitcher;
 exports.PhoneInput = PhoneInput;
 exports.SearchCommand = SearchCommand;
+exports.SearchablePicker = SearchablePicker;
 exports.SupportMessengerProvider = SupportMessengerProvider;
 exports.ThemeSwitcher = ThemeSwitcher;
 exports.VerifiedProfessionalBadge = VerifiedProfessionalBadge;
@@ -6140,6 +6854,7 @@ exports.useDebouncedValue = useDebouncedValue;
 exports.useDebouncedValueStrict = useDebouncedValueStrict;
 exports.useHlsPlayback = useHlsPlayback;
 exports.useLanguageContext = useLanguageContext;
+exports.useMediaQuery = useMediaQuery2;
 exports.usePlaybackStats = usePlaybackStats;
 exports.useSearchHotkey = useSearchHotkey;
 exports.useSupportConversation = useSupportConversation;