@ariakit/core 0.0.1 → 0.1.1

package/cjs/__chunks/NX5OHIMM.cjs

@@ -0,0 +1,169 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _3BBA3Z5Gcjs = require('./3BBA3Z5G.cjs');
+
+
+
+var _5D5Y5EI4cjs = require('./5D5Y5EI4.cjs');
+
+
+var _OFNGELMAcjs = require('./OFNGELMA.cjs');
+
+// src/collection/collection-store.ts
+function isElementPreceding(a, b) {
+  return Boolean(
+    b.compareDocumentPosition(a) & Node.DOCUMENT_POSITION_PRECEDING
+  );
+}
+function sortBasedOnDOMPosition(items) {
+  const pairs = items.map((item, index) => [index, item]);
+  let isOrderDifferent = false;
+  pairs.sort(([indexA, a], [indexB, b]) => {
+    const elementA = a.element;
+    const elementB = b.element;
+    if (elementA === elementB)
+      return 0;
+    if (!elementA || !elementB)
+      return 0;
+    if (isElementPreceding(elementA, elementB)) {
+      if (indexA > indexB) {
+        isOrderDifferent = true;
+      }
+      return -1;
+    }
+    if (indexA < indexB) {
+      isOrderDifferent = true;
+    }
+    return 1;
+  });
+  if (isOrderDifferent) {
+    return pairs.map(([_, item]) => item);
+  }
+  return items;
+}
+function getCommonParent(items) {
+  const firstItem = items.find((item) => !!item.element);
+  const lastItem = [...items].reverse().find((item) => !!item.element);
+  let parentElement = _optionalChain([firstItem, 'optionalAccess', _2 => _2.element, 'optionalAccess', _3 => _3.parentElement]);
+  while (parentElement && _optionalChain([lastItem, 'optionalAccess', _4 => _4.element])) {
+    const parent = parentElement;
+    if (lastItem && parent.contains(lastItem.element)) {
+      return parentElement;
+    }
+    parentElement = parentElement.parentElement;
+  }
+  return _OFNGELMAcjs.getDocument.call(void 0, parentElement).body;
+}
+function createCollectionStore(props = {}) {
+  const itemsMap = /* @__PURE__ */ new Map();
+  const syncState = _optionalChain([props, 'access', _5 => _5.store, 'optionalAccess', _6 => _6.getState, 'call', _7 => _7()]);
+  const initialState = {
+    items: _5D5Y5EI4cjs.defaultValue.call(void 0, props.items, _optionalChain([syncState, 'optionalAccess', _8 => _8.items]), props.defaultItems, []),
+    renderedItems: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _9 => _9.renderedItems]), [])
+  };
+  const privateStore = _3BBA3Z5Gcjs.createStore.call(void 0, {
+    renderedItems: initialState.renderedItems
+  });
+  const collection = _3BBA3Z5Gcjs.createStore.call(void 0, initialState, props.store);
+  const sortItems = () => {
+    const state = privateStore.getState();
+    const renderedItems = sortBasedOnDOMPosition(state.renderedItems);
+    privateStore.setState("renderedItems", renderedItems);
+    collection.setState("renderedItems", renderedItems);
+  };
+  collection.setup(() => {
+    return privateStore.syncBatch(
+      (state) => {
+        let firstRun = true;
+        let raf = 0;
+        raf = requestAnimationFrame(sortItems);
+        if (typeof IntersectionObserver !== "function")
+          return;
+        const callback = () => {
+          if (firstRun) {
+            firstRun = false;
+            return;
+          }
+          cancelAnimationFrame(raf);
+          raf = requestAnimationFrame(sortItems);
+        };
+        const root = getCommonParent(state.renderedItems);
+        const observer = new IntersectionObserver(callback, { root });
+        state.renderedItems.forEach((item) => {
+          if (item.element) {
+            observer.observe(item.element);
+          }
+        });
+        return () => {
+          cancelAnimationFrame(raf);
+          observer.disconnect();
+        };
+      },
+      ["renderedItems"]
+    );
+  });
+  const mergeItem = (item, setItems, canDeleteFromMap = false) => {
+    let prevItem;
+    setItems((items) => {
+      const index = itemsMap.get(item.id) && items.findIndex(({ id }) => id === item.id);
+      const nextItems = items.slice();
+      if (index && index >= 0) {
+        prevItem = items[index];
+        const nextItem = { ...prevItem, ...item };
+        nextItems[index] = nextItem;
+        itemsMap.set(item.id, nextItem);
+      } else {
+        nextItems.push(item);
+        itemsMap.set(item.id, item);
+      }
+      return nextItems;
+    });
+    const unmergeItem = () => {
+      setItems((items) => {
+        if (!prevItem) {
+          if (canDeleteFromMap) {
+            itemsMap.delete(item.id);
+          }
+          return items.filter(({ id }) => id !== item.id);
+        }
+        const index = items.findIndex(({ id }) => id === item.id);
+        if (index === -1)
+          return items;
+        const nextItems = items.slice();
+        nextItems[index] = prevItem;
+        itemsMap.set(item.id, prevItem);
+        return nextItems;
+      });
+    };
+    return unmergeItem;
+  };
+  const registerItem = (item) => mergeItem(item, (getItems) => collection.setState("items", getItems), true);
+  return {
+    ...collection,
+    registerItem,
+    renderItem: (item) => _5D5Y5EI4cjs.chain.call(void 0, 
+      registerItem(item),
+      mergeItem(
+        item,
+        (getItems) => privateStore.setState("renderedItems", getItems)
+      )
+    ),
+    item: (id) => {
+      if (!id)
+        return null;
+      let item = itemsMap.get(id);
+      if (!item) {
+        const { items } = collection.getState();
+        item = items.find((item2) => item2.id === id);
+        if (item) {
+          itemsMap.set(id, item);
+        }
+      }
+      return item || null;
+    }
+  };
+}
+
+
+
+exports.createCollectionStore = createCollectionStore;

package/cjs/__chunks/OFNGELMA.cjs

@@ -0,0 +1,182 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/utils/dom.ts
+var canUseDOM = checkIsBrowser();
+function checkIsBrowser() {
+  return typeof window !== "undefined" && !!_optionalChain([window, 'access', _ => _.document, 'optionalAccess', _2 => _2.createElement]);
+}
+function getDocument(node) {
+  return node ? node.ownerDocument || node : document;
+}
+function getWindow(node) {
+  return getDocument(node).defaultView || window;
+}
+function getActiveElement(node, activeDescendant = false) {
+  const { activeElement } = getDocument(node);
+  if (!_optionalChain([activeElement, 'optionalAccess', _3 => _3.nodeName])) {
+    return null;
+  }
+  if (isFrame(activeElement) && activeElement.contentDocument) {
+    return getActiveElement(
+      activeElement.contentDocument.body,
+      activeDescendant
+    );
+  }
+  if (activeDescendant) {
+    const id = activeElement.getAttribute("aria-activedescendant");
+    if (id) {
+      const element = getDocument(activeElement).getElementById(id);
+      if (element) {
+        return element;
+      }
+    }
+  }
+  return activeElement;
+}
+function contains(parent, child) {
+  return parent === child || parent.contains(child);
+}
+function isFrame(element) {
+  return element.tagName === "IFRAME";
+}
+function isButton(element) {
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "button")
+    return true;
+  if (tagName === "input" && element.type) {
+    return buttonInputTypes.indexOf(element.type) !== -1;
+  }
+  return false;
+}
+var buttonInputTypes = [
+  "button",
+  "color",
+  "file",
+  "image",
+  "reset",
+  "submit"
+];
+function matches(element, selectors) {
+  if ("matches" in element) {
+    return element.matches(selectors);
+  }
+  if ("msMatchesSelector" in element) {
+    return element.msMatchesSelector(selectors);
+  }
+  return element.webkitMatchesSelector(selectors);
+}
+function isVisible(element) {
+  const htmlElement = element;
+  return htmlElement.offsetWidth > 0 || htmlElement.offsetHeight > 0 || element.getClientRects().length > 0;
+}
+function closest(element, selectors) {
+  if ("closest" in element)
+    return element.closest(selectors);
+  do {
+    if (matches(element, selectors))
+      return element;
+    element = element.parentElement || element.parentNode;
+  } while (element !== null && element.nodeType === 1);
+  return null;
+}
+function isTextField(element) {
+  try {
+    const isTextInput = element instanceof HTMLInputElement && element.selectionStart !== null;
+    const isTextArea = element.tagName === "TEXTAREA";
+    return isTextInput || isTextArea || false;
+  } catch (error) {
+    return false;
+  }
+}
+function getPopupRole(element, fallback) {
+  const allowedPopupRoles = ["dialog", "menu", "listbox", "tree", "grid"];
+  const role = _optionalChain([element, 'optionalAccess', _4 => _4.getAttribute, 'call', _5 => _5("role")]);
+  if (role && allowedPopupRoles.indexOf(role) !== -1) {
+    return role;
+  }
+  return fallback;
+}
+function getPopupItemRole(element, fallback) {
+  const itemRoleByPopupRole = {
+    menu: "menuitem",
+    listbox: "option",
+    tree: "treeitem",
+    grid: "gridcell"
+  };
+  const popupRole = getPopupRole(element);
+  if (!popupRole)
+    return fallback;
+  const key = popupRole;
+  return _nullishCoalesce(itemRoleByPopupRole[key], () => ( fallback));
+}
+function getTextboxSelection(element) {
+  let start = 0;
+  let end = 0;
+  if (isTextField(element)) {
+    start = element.selectionStart || 0;
+    end = element.selectionEnd || 0;
+  } else if (element.isContentEditable) {
+    const selection = getDocument(element).getSelection();
+    if (_optionalChain([selection, 'optionalAccess', _6 => _6.rangeCount]) && selection.anchorNode && contains(element, selection.anchorNode) && selection.focusNode && contains(element, selection.focusNode)) {
+      const range = selection.getRangeAt(0);
+      const nextRange = range.cloneRange();
+      nextRange.selectNodeContents(element);
+      nextRange.setEnd(range.startContainer, range.startOffset);
+      start = nextRange.toString().length;
+      nextRange.setEnd(range.endContainer, range.endOffset);
+      end = nextRange.toString().length;
+    }
+  }
+  return { start, end };
+}
+function scrollIntoViewIfNeeded(element, arg) {
+  if (isPartiallyHidden(element) && "scrollIntoView" in element) {
+    element.scrollIntoView(arg);
+  }
+}
+function getScrollingElement(element) {
+  if (!element)
+    return null;
+  if (element.clientHeight && element.scrollHeight > element.clientHeight) {
+    const { overflowY } = getComputedStyle(element);
+    const isScrollable = overflowY !== "visible" && overflowY !== "hidden";
+    if (isScrollable)
+      return element;
+  }
+  return getScrollingElement(element.parentElement) || document.scrollingElement || document.body;
+}
+function isPartiallyHidden(element) {
+  const elementRect = element.getBoundingClientRect();
+  const scroller = getScrollingElement(element);
+  if (!scroller)
+    return false;
+  const scrollerRect = scroller.getBoundingClientRect();
+  const isHTML = scroller.tagName === "HTML";
+  const scrollerTop = isHTML ? scrollerRect.top + scroller.scrollTop : scrollerRect.top;
+  const scrollerBottom = isHTML ? scroller.clientHeight : scrollerRect.bottom;
+  const scrollerLeft = isHTML ? scrollerRect.left + scroller.scrollLeft : scrollerRect.left;
+  const scrollerRight = isHTML ? scroller.clientWidth : scrollerRect.right;
+  const top = elementRect.top < scrollerTop;
+  const left = elementRect.left < scrollerLeft;
+  const bottom = elementRect.bottom > scrollerBottom;
+  const right = elementRect.right > scrollerRight;
+  return top || left || bottom || right;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.canUseDOM = canUseDOM; exports.getDocument = getDocument; exports.getWindow = getWindow; exports.getActiveElement = getActiveElement; exports.contains = contains; exports.isFrame = isFrame; exports.isButton = isButton; exports.matches = matches; exports.isVisible = isVisible; exports.closest = closest; exports.isTextField = isTextField; exports.getPopupRole = getPopupRole; exports.getPopupItemRole = getPopupItemRole; exports.getTextboxSelection = getTextboxSelection; exports.scrollIntoViewIfNeeded = scrollIntoViewIfNeeded; exports.getScrollingElement = getScrollingElement; exports.isPartiallyHidden = isPartiallyHidden;

package/cjs/checkbox/checkbox-store.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _3BBA3Z5Gcjs = require('../__chunks/3BBA3Z5G.cjs');
+
+
+var _5D5Y5EI4cjs = require('../__chunks/5D5Y5EI4.cjs');
+
+// src/checkbox/checkbox-store.ts
+function createCheckboxStore(props = {}) {
+  const syncState = _optionalChain([props, 'access', _ => _.store, 'optionalAccess', _2 => _2.getState, 'call', _3 => _3()]);
+  const initialState = {
+    value: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.value,
+      _optionalChain([syncState, 'optionalAccess', _4 => _4.value]),
+      props.defaultValue,
+      false
+    )
+  };
+  const checkbox = _3BBA3Z5Gcjs.createStore.call(void 0, initialState, props.store);
+  return {
+    ...checkbox,
+    setValue: (value) => checkbox.setState("value", value)
+  };
+}
+
+
+exports.createCheckboxStore = createCheckboxStore;

package/cjs/checkbox/checkbox-store.d.ts

@@ -0,0 +1,34 @@
+import type { Store, StoreOptions, StoreProps } from "../utils/store.js";
+import type { PickRequired, SetState, ToPrimitive } from "../utils/types.js";
+type Value = boolean | string | number | Array<string | number>;
+/**
+ * Creates a checkbox store.
+ */
+export declare function createCheckboxStore<T extends Value = Value>(props: PickRequired<CheckboxStoreProps<T>, "value" | "defaultValue">): CheckboxStore<T>;
+export declare function createCheckboxStore(props?: CheckboxStoreProps): CheckboxStore;
+export type CheckboxStoreValue = Value;
+export interface CheckboxStoreState<T extends Value = Value> {
+    /**
+     * The checked state of the checkbox.
+     */
+    value: ToPrimitive<T>;
+}
+export interface CheckboxStoreFunctions<T extends Value = Value> {
+    /**
+     * Sets the `value` state.
+     * @example
+     * store.setValue(true);
+     * store.setValue((value) => !value);
+     */
+    setValue: SetState<CheckboxStoreState<T>["value"]>;
+}
+export interface CheckboxStoreOptions<T extends Value = Value> extends StoreOptions<CheckboxStoreState<T>, "value"> {
+    /**
+     * The default value of the checkbox.
+     * @default false
+     */
+    defaultValue?: CheckboxStoreState<T>["value"];
+}
+export type CheckboxStoreProps<T extends Value = Value> = CheckboxStoreOptions<T> & StoreProps<CheckboxStoreState<T>>;
+export type CheckboxStore<T extends Value = Value> = CheckboxStoreFunctions<T> & Store<CheckboxStoreState<T>>;
+export {};

package/cjs/collection/collection-store.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _NX5OHIMMcjs = require('../__chunks/NX5OHIMM.cjs');
+require('../__chunks/3BBA3Z5G.cjs');
+require('../__chunks/5D5Y5EI4.cjs');
+require('../__chunks/OFNGELMA.cjs');
+
+
+exports.createCollectionStore = _NX5OHIMMcjs.createCollectionStore;

package/cjs/collection/collection-store.d.ts

@@ -0,0 +1,65 @@
+import type { Store, StoreOptions, StoreProps } from "../utils/store.js";
+import type { BivariantCallback } from "../utils/types.js";
+type Item = {
+    id: string;
+    element?: HTMLElement | null;
+};
+/**
+ * Creates a collection store.
+ */
+export declare function createCollectionStore<T extends Item = Item>(props?: CollectionStoreProps<T>): CollectionStore<T>;
+export type CollectionStoreItem = Item;
+export interface CollectionStoreState<T extends Item = Item> {
+    /**
+     * Lists all the items with their meta data. This state is automatically
+     * updated when an item is registered or unregistered with the `registerItem`
+     * function.
+     */
+    items: T[];
+    /**
+     * Lists all the items that are currently rendered. This state is
+     * automatically updated when an item is rendered or unrendered with the
+     * `renderItem` function. This state is also automatically sorted based on
+     * their DOM position.
+     */
+    renderedItems: T[];
+}
+export interface CollectionStoreFunctions<T extends Item = Item> {
+    /**
+     * Registers an item in the collection. This function returns a cleanup
+     * function that unregisters the item.
+     * @param item The item to register.
+     * @example
+     * const unregisterItem = store.registerItem({ id: "item-1" });
+     * // on cleanup
+     * unregisterItem();
+     */
+    registerItem: BivariantCallback<(item: T) => () => void>;
+    /**
+     * Renders an item in the collection. This function returns a cleanup function
+     * that unrenders the item.
+     * @param item The item to render.
+     * @example
+     * const unrenderItem = store.renderItem({ id: "item-1" });
+     * // on cleanup
+     * unrenderItem();
+     */
+    renderItem: BivariantCallback<(item: T) => () => void>;
+    /**
+     * Gets an item by its id.
+     * @param id The id of the item.
+     * @example
+     * const item = store.item("item-1");
+     */
+    item: (id: string | null | undefined) => T | null;
+}
+export interface CollectionStoreOptions<T extends Item = Item> extends StoreOptions<CollectionStoreState<T>, "items"> {
+    /**
+     * The defaut value for the `items` state.
+     * @default []
+     */
+    defaultItems?: CollectionStoreState<T>["items"];
+}
+export type CollectionStoreProps<T extends Item = Item> = CollectionStoreOptions<T> & StoreProps<CollectionStoreState<T>>;
+export type CollectionStore<T extends Item = Item> = CollectionStoreFunctions<T> & Store<CollectionStoreState<T>>;
+export {};

package/cjs/combobox/combobox-store.cjs

@@ -0,0 +1,163 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _3KP2MDG6cjs = require('../__chunks/3KP2MDG6.cjs');
+require('../__chunks/EFEGT32M.cjs');
+require('../__chunks/7ZXWQTAY.cjs');
+
+
+var _AZVDLKO3cjs = require('../__chunks/AZVDLKO3.cjs');
+require('../__chunks/NX5OHIMM.cjs');
+
+
+
+var _3BBA3Z5Gcjs = require('../__chunks/3BBA3Z5G.cjs');
+
+
+var _5D5Y5EI4cjs = require('../__chunks/5D5Y5EI4.cjs');
+
+
+
+var _2YFRPUZPcjs = require('../__chunks/2YFRPUZP.cjs');
+require('../__chunks/OFNGELMA.cjs');
+require('../__chunks/GDZQUFNP.cjs');
+
+// src/combobox/combobox-store.ts
+var isSafariOnMobile = _2YFRPUZPcjs.isSafari.call(void 0, ) && _2YFRPUZPcjs.isTouchDevice.call(void 0, );
+function createComboboxStore({
+  menu,
+  select,
+  ...props
+} = {}) {
+  const store = _3BBA3Z5Gcjs.mergeStore.call(void 0, 
+    props.store,
+    _optionalChain([menu, 'optionalAccess', _ => _.omit, 'call', _2 => _2(
+      "baseElement",
+      "arrowElement",
+      "anchorElement",
+      "contentElement",
+      "popoverElement",
+      "disclosureElement"
+    )]),
+    _optionalChain([select, 'optionalAccess', _3 => _3.omit, 'call', _4 => _4(
+      "value",
+      "items",
+      "renderedItems",
+      "baseElement",
+      "arrowElement",
+      "anchorElement",
+      "contentElement",
+      "popoverElement",
+      "disclosureElement"
+    )])
+  );
+  const syncState = store.getState();
+  const activeId = _5D5Y5EI4cjs.defaultValue.call(void 0, 
+    props.activeId,
+    syncState.activeId,
+    props.defaultActiveId,
+    null
+  );
+  const composite = _AZVDLKO3cjs.createCompositeStore.call(void 0, {
+    ...props,
+    store,
+    activeId,
+    includesBaseElement: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.includesBaseElement,
+      syncState.includesBaseElement,
+      true
+    ),
+    orientation: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.orientation,
+      syncState.orientation,
+      "vertical"
+    ),
+    focusLoop: _5D5Y5EI4cjs.defaultValue.call(void 0, props.focusLoop, syncState.focusLoop, true),
+    focusWrap: _5D5Y5EI4cjs.defaultValue.call(void 0, props.focusWrap, syncState.focusWrap, true),
+    virtualFocus: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.virtualFocus,
+      _optionalChain([syncState, 'optionalAccess', _5 => _5.virtualFocus]),
+      !isSafariOnMobile
+    )
+  });
+  const popover = _3KP2MDG6cjs.createPopoverStore.call(void 0, {
+    ...props,
+    store,
+    placement: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.placement,
+      syncState.placement,
+      "bottom-start"
+    )
+  });
+  const initialValue = _5D5Y5EI4cjs.defaultValue.call(void 0, 
+    props.value,
+    syncState.value,
+    props.defaultValue,
+    ""
+  );
+  const initialState = {
+    ...composite.getState(),
+    ...popover.getState(),
+    value: initialValue,
+    resetValueOnHide: _5D5Y5EI4cjs.defaultValue.call(void 0, 
+      props.resetValueOnHide,
+      syncState.resetValueOnHide,
+      false
+    ),
+    activeValue: syncState.activeValue
+  };
+  const combobox = _3BBA3Z5Gcjs.createStore.call(void 0, initialState, composite, popover, store);
+  combobox.setup(
+    () => combobox.sync(
+      (state) => {
+        if (!state.resetValueOnHide)
+          return;
+        if (state.mounted)
+          return;
+        combobox.setState("value", initialValue);
+      },
+      ["resetValueOnHide", "mounted"]
+    )
+  );
+  combobox.setup(
+    () => combobox.syncBatch(
+      (state) => {
+        if (state.mounted)
+          return;
+        combobox.setState("activeId", activeId);
+        combobox.setState("moves", 0);
+      },
+      ["mounted"]
+    )
+  );
+  combobox.setup(
+    () => combobox.sync(
+      (state, prevState) => {
+        if (state.moves === prevState.moves) {
+          combobox.setState("activeValue", void 0);
+        }
+      },
+      ["moves", "activeId"]
+    )
+  );
+  combobox.setup(
+    () => combobox.syncBatch(
+      (state, prev) => {
+        if (state.moves === prev.moves)
+          return;
+        const { activeId: activeId2 } = combobox.getState();
+        const activeItem = composite.item(activeId2);
+        combobox.setState("activeValue", _optionalChain([activeItem, 'optionalAccess', _6 => _6.value]));
+      },
+      ["moves", "renderedItems"]
+    )
+  );
+  return {
+    ...popover,
+    ...composite,
+    ...combobox,
+    setValue: (value) => combobox.setState("value", value)
+  };
+}
+
+
+exports.createComboboxStore = createComboboxStore;