@pzerelles/headlessui-svelte 2.0.0-next.1 → 2.1.2-next.2

package/dist/listbox/ListboxOptions.svelte

@@ -0,0 +1,269 @@
+<script lang="ts" module>import { mergeProps, RenderFeatures } from "../utils/render.js";
+import {
+  useFloatingPanel,
+  useFloatingPanelProps,
+  useResolvedAnchor
+} from "../internal/floating.svelte.js";
+const DEFAULT_OPTIONS_TAG = "div";
+let OptionsRenderFeatures = RenderFeatures.RenderStrategy | RenderFeatures.Static;
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG">import { useId } from "../hooks/use-id.js";
+import { ListboxStates, useActions, useData, ValueMode } from "./Listbox.svelte";
+import { getOwnerDocument } from "../utils/owner.js";
+import { State, useOpenClosed } from "../internal/open-closed.js";
+import { transitionDataAttributes, useTransition } from "../hooks/use-transition.svelte.js";
+import { useOnDisappear } from "../hooks/use-on-disappear.svelte.js";
+import { useScrollLock } from "../hooks/use-scroll-lock.svelte.js";
+import { useInertOthers } from "../hooks/use-inert-others.svelte.js";
+import { useDidElementMove } from "../hooks/use-did-element-move.svelte.js";
+import { useFrozenData } from "../internal/frozen.svelte.js";
+import { useDisposables } from "../utils/disposables.js";
+import { match } from "../utils/match.js";
+import { Focus } from "../utils/calculate-active-index.js";
+import { focusFrom, Focus as FocusManagementFocus } from "../utils/focus-management.js";
+import { useElementSize } from "../hooks/use-element-size.svelte.js";
+import { setContext } from "svelte";
+import Hidden from "../internal/Hidden.svelte";
+import Portal from "../portal/Portal.svelte";
+import { stateFromSlot } from "../utils/state.js";
+import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+const internalId = useId();
+let {
+  as = DEFAULT_OPTIONS_TAG,
+  ref = $bindable(),
+  id = `headlessui-listbox-options-${internalId}`,
+  anchor: rawAnchor,
+  portal = false,
+  modal = true,
+  transition = false,
+  static: isStatic = false,
+  unmount = true,
+  ...theirProps
+} = $props();
+const anchor = $derived(useResolvedAnchor(rawAnchor));
+$effect(() => {
+  if (anchor) {
+    portal = true;
+  }
+});
+const data = useData("ListboxOptions");
+const actions = useActions("ListboxOptions");
+const ownerDocument = $derived(getOwnerDocument(data.optionsRef.current));
+const usesOpenClosedState = useOpenClosed();
+const show = $derived(
+  usesOpenClosedState !== null ? (usesOpenClosedState.value & State.Open) === State.Open : data.listboxState === ListboxStates.Open
+);
+const _transition = useTransition({
+  get enabled() {
+    return transition;
+  },
+  get element() {
+    return ref;
+  },
+  get show() {
+    return show;
+  }
+});
+const { visible, data: transitionData } = $derived(_transition);
+useOnDisappear({
+  get enabled() {
+    return visible;
+  },
+  get ref() {
+    return data.buttonRef.current;
+  },
+  get ondisappear() {
+    return actions.closeListbox;
+  }
+});
+const scrollLockEnabled = $derived(data.__demoMode ? false : modal && data.listboxState === ListboxStates.Open);
+useScrollLock({
+  get enabled() {
+    return scrollLockEnabled;
+  },
+  get ownerDocument() {
+    return ownerDocument;
+  }
+});
+const inertOthersEnabled = $derived(data.__demoMode ? false : modal && data.listboxState === ListboxStates.Open);
+useInertOthers({
+  get enabled() {
+    return inertOthersEnabled;
+  },
+  elements: {
+    get allowed() {
+      return [data.buttonRef.current, data.optionsRef.current];
+    }
+  }
+});
+const didElementMoveEnabled = $derived(data.listboxState !== ListboxStates.Open);
+const didButtonMove = useDidElementMove({
+  get enabled() {
+    return didElementMoveEnabled;
+  },
+  get element() {
+    return data.buttonRef.current;
+  }
+});
+const panelEnabled = $derived(didButtonMove.value ? false : visible);
+const shouldFreeze = $derived(visible && data.listboxState === ListboxStates.Closed);
+const frozenValue = useFrozenData({
+  get freeze() {
+    return shouldFreeze;
+  },
+  get data() {
+    return data.value;
+  }
+});
+const isSelected = (compareValue) => data.compare(frozenValue, compareValue);
+const selectedOptionIndex = () => {
+  if (anchor == null) return null;
+  if (!anchor?.to?.includes("selection")) return null;
+  let idx = data.options.findIndex((option) => isSelected(option.dataRef.current.value));
+  if (idx === -1) idx = 0;
+  return idx;
+};
+const anchorOptions = $derived.by(() => {
+  if (anchor == null) return void 0;
+  if (selectedOptionIndex === null) return { ...anchor, inner: void 0 };
+  let elements = Array.from(data.listRef.current.values());
+  return {
+    ...anchor,
+    inner: {
+      listRef: { current: elements },
+      index: selectedOptionIndex
+    }
+  };
+});
+const floatingPanel = useFloatingPanel({
+  get placement() {
+    return anchorOptions ?? null;
+  }
+});
+const { setFloating, style } = $derived(floatingPanel);
+const getFloatingPanelProps = useFloatingPanelProps();
+$effect(() => {
+  data.optionsRef.current = ref || null;
+  if (anchor) setFloating(ref);
+});
+const searchDisposables = useDisposables();
+const { listboxState, optionsRef } = $derived(data);
+$effect(() => {
+  let container = optionsRef.current;
+  if (!container) return;
+  if (listboxState !== ListboxStates.Open) return;
+  if (container === getOwnerDocument(container)?.activeElement) return;
+  container?.focus({ preventScroll: true });
+});
+const handleKeyDown = (event) => {
+  searchDisposables.dispose();
+  switch (event.key) {
+    case " ":
+      if (data.searchQuery !== "") {
+        event.preventDefault();
+        event.stopPropagation();
+        return actions.search(event.key);
+      }
+    case "Enter":
+      event.preventDefault();
+      event.stopPropagation();
+      if (data.activeOptionIndex !== null) {
+        let { dataRef } = data.options[data.activeOptionIndex];
+        actions.onChange(dataRef.current.value);
+      }
+      if (data.mode === ValueMode.Single) {
+        actions.closeListbox();
+        data.buttonRef.current?.focus({ preventScroll: true });
+      }
+      break;
+    case match(data.orientation, { vertical: "ArrowDown", horizontal: "ArrowRight" }):
+      event.preventDefault();
+      event.stopPropagation();
+      return actions.goToOption(Focus.Next);
+    case match(data.orientation, { vertical: "ArrowUp", horizontal: "ArrowLeft" }):
+      event.preventDefault();
+      event.stopPropagation();
+      return actions.goToOption(Focus.Previous);
+    case "Home":
+    case "PageUp":
+      event.preventDefault();
+      event.stopPropagation();
+      return actions.goToOption(Focus.First);
+    case "End":
+    case "PageDown":
+      event.preventDefault();
+      event.stopPropagation();
+      return actions.goToOption(Focus.Last);
+    case "Escape":
+      event.preventDefault();
+      event.stopPropagation();
+      actions.closeListbox();
+      data.buttonRef.current?.focus({ preventScroll: true });
+      return;
+    case "Tab":
+      event.preventDefault();
+      event.stopPropagation();
+      actions.closeListbox();
+      focusFrom(data.buttonRef.current, event.shiftKey ? FocusManagementFocus.Previous : FocusManagementFocus.Next);
+      break;
+    default:
+      if (event.key.length === 1) {
+        actions.search(event.key);
+        searchDisposables.setTimeout(() => actions.clearSearch(), 350);
+      }
+      break;
+  }
+};
+const labelledby = $derived(data.buttonRef.current?.id);
+const slot = $derived({
+  open: data.listboxState === ListboxStates.Open
+});
+const buttonSize = useElementSize({
+  get element() {
+    return data.buttonRef.current;
+  },
+  unit: true
+});
+const ourProps = $derived(
+  mergeProps(anchor ? getFloatingPanelProps() : {}, {
+    id,
+    "aria-activedescendant": data.activeOptionIndex === null ? void 0 : data.options[data.activeOptionIndex]?.id,
+    "aria-multiselectable": data.mode === ValueMode.Multi ? true : void 0,
+    "aria-labelledby": labelledby,
+    "aria-orientation": data.orientation,
+    onkeydown: handleKeyDown,
+    role: "listbox",
+    // When the `Listbox` is closed, it should not be focusable. This allows us
+    // to skip focusing the `ListboxOptions` when pressing the tab key on an
+    // open `Listbox`, and go to the next focusable element.
+    tabIndex: data.listboxState === ListboxStates.Open ? 0 : void 0,
+    style: [theirProps.style, style, `--button-width: ${buttonSize.width}`].filter(Boolean).join("; "),
+    ...transitionDataAttributes(transitionData),
+    ...stateFromSlot(slot)
+  })
+);
+const derivedData = {
+  ...data,
+  get isSelected() {
+    return data.mode === ValueMode.Multi ? data.isSelected : isSelected;
+  }
+};
+setContext("ListboxDataContext", derivedData);
+</script>
+
+<Portal enabled={portal ? isStatic || visible : false}>
+  {#if !panelEnabled && unmount && !isStatic}
+    <Hidden as="span" bind:ref aria-hidden="true" {...ourProps} />
+  {:else}
+    <ElementOrComponent
+      {ourProps}
+      {theirProps}
+      slots={slot}
+      defaultTag={DEFAULT_OPTIONS_TAG}
+      features={OptionsRenderFeatures}
+      name="MenuItems"
+      bind:ref
+    />
+  {/if}
+</Portal>

package/dist/listbox/ListboxOptions.svelte.d.ts

@@ -0,0 +1,55 @@
+import type { ElementType, Props } from "../utils/types.js";
+import { type PropsForFeatures } from "../utils/render.js";
+import { type AnchorPropsWithSelection } from "../internal/floating.svelte.js";
+declare const DEFAULT_OPTIONS_TAG: "div";
+type OptionsRenderPropArg = {
+    open: boolean;
+};
+type OptionsPropsWeControl = "aria-activedescendant" | "aria-labelledby" | "aria-multiselectable" | "aria-orientation" | "role" | "tabIndex";
+declare let OptionsRenderFeatures: number;
+export type ListboxOptionsProps<TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG> = Props<TTag, OptionsRenderPropArg, OptionsPropsWeControl, {
+    id?: string;
+    anchor?: AnchorPropsWithSelection;
+    portal?: boolean;
+    modal?: boolean;
+    transition?: boolean;
+} & PropsForFeatures<typeof OptionsRenderFeatures>>;
+export type ListboxOptionsChildren = Snippet<[OptionsRenderPropArg]>;
+import { type Snippet } from "svelte";
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "anchor" | "unmount" | "static" | "id" | "transition" | OptionsPropsWeControl | "portal" | "modal"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("../utils/types.js").Children<OptionsRenderPropArg> | undefined;
+        ref?: HTMLElement;
+    } & (true extends (import("../utils/types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("../utils/types.js").PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: import("../utils/types.js").PropsOf<TTag>["class"] | ((bag: OptionsRenderPropArg) => string) | undefined;
+    } : {}) & {
+        id?: string;
+        anchor?: AnchorPropsWithSelection;
+        portal?: boolean;
+        modal?: boolean;
+        transition?: boolean;
+    } & {
+        static?: boolean | undefined;
+        unmount?: boolean | undefined;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag>['props']>, ReturnType<__sveltets_Render<TTag>['events']>, ReturnType<__sveltets_Render<TTag>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
+    }): ReturnType<__sveltets_Render<TTag>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const ListboxOptions: $$IsomorphicComponent;
+type ListboxOptions<TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG> = InstanceType<typeof ListboxOptions<TTag>>;
+export default ListboxOptions;

package/dist/listbox/ListboxSelectedOption.svelte

@@ -0,0 +1,35 @@
+<script lang="ts" module>const DEFAULT_SELECTED_OPTION_TAG = "svelte:fragment";
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_SELECTED_OPTION_TAG">import { useData, ValueMode } from "./Listbox.svelte";
+import { setContext } from "svelte";
+import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+let {
+  ref = $bindable(),
+  options,
+  placeholder,
+  ...theirProps
+} = $props();
+const data = useData("ListboxSelectedOption");
+const shouldShowPlaceholder = $derived(
+  data.value === void 0 || data.value === null || data.mode === ValueMode.Multi && Array.isArray(data.value) && data.value.length === 0
+);
+setContext("SelectedOptionContext", true);
+</script>
+
+{#snippet children()}
+  {#if placeholder && shouldShowPlaceholder}
+    {@const Component = placeholder}
+    <Component />
+  {:else}
+    {@const Component = options}
+    <Component />
+  {/if}
+{/snippet}
+
+<ElementOrComponent
+  theirProps={{ ...theirProps, children }}
+  defaultTag={DEFAULT_SELECTED_OPTION_TAG}
+  name="ListboxSelectedOption"
+  bind:ref
+></ElementOrComponent>

package/dist/listbox/ListboxSelectedOption.svelte.d.ts

@@ -0,0 +1,40 @@
+import type { ElementType, Props } from "../utils/types.js";
+import type { Component } from "svelte";
+declare const DEFAULT_SELECTED_OPTION_TAG = "svelte:fragment";
+type SelectedOptionRenderPropArg = {};
+type SelectedOptionPropsWeControl = never;
+export type ListboxSelectedOptionProps<TTag extends ElementType = typeof DEFAULT_SELECTED_OPTION_TAG> = Props<TTag, SelectedOptionRenderPropArg, SelectedOptionPropsWeControl, {
+    options: Component<any, any>;
+    placeholder?: Component<any, any>;
+}>;
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_SELECTED_OPTION_TAG> {
+    props(): {
+        as?: TTag | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "placeholder" | "options"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("../utils/types.js").Children<SelectedOptionRenderPropArg> | undefined;
+        ref?: HTMLElement;
+    } & (true extends (import("../utils/types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("../utils/types.js").PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: import("../utils/types.js").PropsOf<TTag>["class"] | ((bag: SelectedOptionRenderPropArg) => string) | undefined;
+    } : {}) & {
+        options: Component<any, any>;
+        placeholder?: Component<any, any>;
+    };
+    events(): {} & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TTag extends ElementType = typeof DEFAULT_SELECTED_OPTION_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag>['props']>, ReturnType<__sveltets_Render<TTag>['events']>, ReturnType<__sveltets_Render<TTag>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TTag>['bindings']>;
+    } & ReturnType<__sveltets_Render<TTag>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_SELECTED_OPTION_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
+        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
+    }): ReturnType<__sveltets_Render<TTag>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const ListboxSelectedOption: $$IsomorphicComponent;
+type ListboxSelectedOption<TTag extends ElementType = typeof DEFAULT_SELECTED_OPTION_TAG> = InstanceType<typeof ListboxSelectedOption<TTag>>;
+export default ListboxSelectedOption;

package/dist/listbox/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Listbox, type ListboxProps, type ListboxChildren } from "./Listbox.svelte";
+export { default as ListboxButton, type ListboxButtonProps, type ListboxButtonChildren } from "./ListboxButton.svelte";
+export { default as ListboxOption, type ListboxOptionProps, type ListboxOptionChildren } from "./ListboxOption.svelte";
+export { default as ListboxOptions, type ListboxOptionsProps, type ListboxOptionsChildren, } from "./ListboxOptions.svelte";
+export { default as ListboxSelectedOption, type ListboxSelectedOptionProps } from "./ListboxSelectedOption.svelte";

package/dist/listbox/index.js

@@ -0,0 +1,5 @@
+export { default as Listbox } from "./Listbox.svelte";
+export { default as ListboxButton } from "./ListboxButton.svelte";
+export { default as ListboxOption } from "./ListboxOption.svelte";
+export { default as ListboxOptions, } from "./ListboxOptions.svelte";
+export { default as ListboxSelectedOption } from "./ListboxSelectedOption.svelte";

package/dist/menu/Menu.svelte

@@ -0,0 +1,235 @@
+<script lang="ts" module>import { useOutsideClick } from "../hooks/use-outside-click.svelte.js";
+import { createFloatingContext } from "../internal/floating.svelte.js";
+import { createOpenClosedContext, State } from "../internal/open-closed.js";
+import { calculateActiveIndex, Focus } from "../utils/calculate-active-index.js";
+import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+import { FocusableMode, isFocusableElement, sortByDomNode } from "../utils/focus-management.js";
+import { match } from "../utils/match.js";
+let DEFAULT_MENU_TAG = "svelte:fragment";
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_MENU_TAG">import { setContext } from "svelte";
+import {
+  ActivationTrigger,
+  MenuStates
+} from "./context.svelte.js";
+function adjustOrderedState(state, adjustment = (i) => i) {
+  let currentActiveItem = state.activeItemIndex !== null ? state.items[state.activeItemIndex] : null;
+  let sortedItems = sortByDomNode(adjustment(state.items.slice()), (item) => item.dataRef.current.domRef.current);
+  let adjustedActiveItemIndex = currentActiveItem ? sortedItems.indexOf(currentActiveItem) : null;
+  if (adjustedActiveItemIndex === -1) {
+    adjustedActiveItemIndex = null;
+  }
+  return {
+    items: sortedItems,
+    activeItemIndex: adjustedActiveItemIndex
+  };
+}
+const stateReducer = (initialState) => {
+  let _state2 = $state(initialState);
+  return {
+    get menuState() {
+      return _state2.menuState;
+    },
+    get buttonElement() {
+      return _state2.buttonElement;
+    },
+    get itemsElement() {
+      return _state2.itemsElement;
+    },
+    get items() {
+      return _state2.items;
+    },
+    get searchQuery() {
+      return _state2.searchQuery;
+    },
+    get activeItemIndex() {
+      return _state2.activeItemIndex;
+    },
+    get activationTrigger() {
+      return _state2.activationTrigger;
+    },
+    get __demoMode() {
+      return _state2.__demoMode;
+    },
+    closeMenu() {
+      if (_state2.menuState === MenuStates.Closed) return _state2;
+      _state2.activeItemIndex = null;
+      _state2.menuState = MenuStates.Closed;
+      return _state2;
+    },
+    openMenu() {
+      if (_state2.menuState === MenuStates.Open) return _state2;
+      _state2.__demoMode = false;
+      _state2.menuState = MenuStates.Open;
+      return _state2;
+    },
+    goToItem(action) {
+      if (_state2.menuState === MenuStates.Closed) return _state2;
+      _state2.searchQuery = "";
+      _state2.activationTrigger = action.trigger ?? ActivationTrigger.Other;
+      _state2.__demoMode = false;
+      if (action.focus === Focus.Nothing) {
+        _state2.activeItemIndex = null;
+        return _state2;
+      }
+      if (action.focus === Focus.Specific) {
+        _state2.activeItemIndex = _state2.items.findIndex((o) => o.id === action.id);
+        return _state2;
+      } else if (action.focus === Focus.Previous) {
+        let activeItemIdx = _state2.activeItemIndex;
+        if (activeItemIdx !== null) {
+          let currentDom = _state2.items[activeItemIdx].dataRef.current.domRef;
+          let previousItemIndex = calculateActiveIndex(action, {
+            resolveItems: () => _state2.items,
+            resolveActiveIndex: () => _state2.activeItemIndex,
+            resolveId: (item) => item.id,
+            resolveDisabled: (item) => item.dataRef.current.disabled
+          });
+          if (previousItemIndex !== null) {
+            let previousDom = _state2.items[previousItemIndex].dataRef.current.domRef;
+            if (
+              // Next to each other
+              currentDom.current?.previousElementSibling === previousDom.current || // Or already the first element
+              previousDom.current?.previousElementSibling === null
+            ) {
+              _state2.activeItemIndex = previousItemIndex;
+              return _state2;
+            }
+          }
+        }
+      } else if (action.focus === Focus.Next) {
+        let activeItemIdx = _state2.activeItemIndex;
+        if (activeItemIdx !== null) {
+          let currentDom = _state2.items[activeItemIdx].dataRef.current.domRef;
+          let nextItemIndex = calculateActiveIndex(action, {
+            resolveItems: () => _state2.items,
+            resolveActiveIndex: () => _state2.activeItemIndex,
+            resolveId: (item) => item.id,
+            resolveDisabled: (item) => item.dataRef.current.disabled
+          });
+          if (nextItemIndex !== null) {
+            let nextDom = _state2.items[nextItemIndex].dataRef.current.domRef;
+            if (
+              // Next to each other
+              currentDom.current?.nextElementSibling === nextDom.current || // Or already the last element
+              nextDom.current?.nextElementSibling === null
+            ) {
+              _state2.activeItemIndex = nextItemIndex;
+              return _state2;
+            }
+          }
+        }
+      }
+      let adjustedState = adjustOrderedState(_state2);
+      let activeItemIndex = calculateActiveIndex(action, {
+        resolveItems: () => adjustedState.items,
+        resolveActiveIndex: () => adjustedState.activeItemIndex,
+        resolveId: (item) => item.id,
+        resolveDisabled: (item) => item.dataRef.current.disabled
+      });
+      _state2.items = adjustedState.items;
+      _state2.activeItemIndex = activeItemIndex;
+      return _state2;
+    },
+    search(value) {
+      let wasAlreadySearching = _state2.searchQuery !== "";
+      let offset = wasAlreadySearching ? 0 : 1;
+      let searchQuery = _state2.searchQuery + value.toLowerCase();
+      let reOrderedItems = _state2.activeItemIndex !== null ? _state2.items.slice(_state2.activeItemIndex + offset).concat(_state2.items.slice(0, _state2.activeItemIndex + offset)) : _state2.items;
+      let matchingItem = reOrderedItems.find(
+        (item) => item.dataRef.current.textValue?.startsWith(searchQuery) && !item.dataRef.current.disabled
+      );
+      let matchIdx = matchingItem ? _state2.items.indexOf(matchingItem) : -1;
+      if (matchIdx === -1 || matchIdx === _state2.activeItemIndex) {
+        _state2.searchQuery = searchQuery;
+        return _state2;
+      }
+      _state2.searchQuery = searchQuery;
+      _state2.activeItemIndex = matchIdx;
+      _state2.activationTrigger = ActivationTrigger.Other;
+      return _state2;
+    },
+    clearSearch() {
+      if (_state2.searchQuery === "") return _state2;
+      _state2.searchQuery = "";
+      return _state2;
+    },
+    registerItem(id, dataRef) {
+      let item = { id, dataRef };
+      let adjustedState = adjustOrderedState(_state2, (items) => [...items, item]);
+      _state2.items = adjustedState.items;
+      _state2.activeItemIndex = adjustedState.activeItemIndex;
+      return _state2;
+    },
+    unregisterItem(id) {
+      let adjustedState = adjustOrderedState(_state2, (items) => {
+        let idx = items.findIndex((a) => a.id === id);
+        if (idx !== -1) items.splice(idx, 1);
+        return items;
+      });
+      _state2.items = adjustedState.items;
+      _state2.activeItemIndex = adjustedState.activeItemIndex;
+      _state2.activationTrigger = ActivationTrigger.Other;
+      return _state2;
+    },
+    setButtonElement(element) {
+      if (_state2.buttonElement === element) return _state2;
+      _state2.buttonElement = element;
+      return _state2;
+    },
+    setItemsElement(element) {
+      if (_state2.itemsElement === element) return _state2;
+      _state2.itemsElement = element;
+      return _state2;
+    }
+  };
+};
+let { ref = $bindable(), __demoMode = false, ...theirProps } = $props();
+const _state = stateReducer({
+  __demoMode,
+  menuState: __demoMode ? MenuStates.Open : MenuStates.Closed,
+  buttonElement: null,
+  itemsElement: null,
+  items: [],
+  searchQuery: "",
+  activeItemIndex: null,
+  activationTrigger: ActivationTrigger.Other
+});
+const { menuState, itemsElement, buttonElement } = $derived(_state);
+setContext("MenuContext", _state);
+const outsideClickEnabled = $derived(menuState === MenuStates.Open);
+useOutsideClick({
+  get enabled() {
+    return outsideClickEnabled;
+  },
+  get containers() {
+    return [buttonElement, itemsElement];
+  },
+  cb: (event, target) => {
+    _state.closeMenu();
+    if (!isFocusableElement(target, FocusableMode.Loose)) {
+      event.preventDefault();
+      buttonElement?.focus();
+    }
+  }
+});
+const slot = $derived({
+  open: _state.menuState === MenuStates.Open,
+  close: _state.closeMenu
+});
+createFloatingContext();
+const openClosed = $derived(
+  match(menuState, {
+    [MenuStates.Open]: State.Open,
+    [MenuStates.Closed]: State.Closed
+  })
+);
+createOpenClosedContext({
+  get value() {
+    return openClosed;
+  }
+});
+</script>
+
+<ElementOrComponent {theirProps} {slot} defaultTag={DEFAULT_MENU_TAG} name="Menu" bind:ref />