@ariakit/react-core 0.0.1 → 0.1.1

package/cjs/__chunks/XKBGBOWQ.cjs

@@ -0,0 +1,174 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _X2GXTE3Pcjs = require('./X2GXTE3P.cjs');
+
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+// src/dialog/utils/use-hide-on-interact-outside.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+function isInDocument(target) {
+  if (target.tagName === "HTML")
+    return true;
+  return _dom.contains.call(void 0, _dom.getDocument.call(void 0, target).body, target);
+}
+function isDisclosure(disclosure, target) {
+  if (_dom.contains.call(void 0, disclosure, target))
+    return true;
+  const activeId = target.getAttribute("aria-activedescendant");
+  if (activeId) {
+    const activeElement = _dom.getDocument.call(void 0, disclosure).getElementById(activeId);
+    if (activeElement) {
+      return _dom.contains.call(void 0, disclosure, activeElement);
+    }
+  }
+  return false;
+}
+function isBackdrop(dialog, target) {
+  if (!dialog)
+    return false;
+  if (!target)
+    return false;
+  return target.hasAttribute("data-backdrop") && target.getAttribute("data-backdrop") === dialog.id;
+}
+function dialogContains(target) {
+  return (dialog) => {
+    if (_dom.contains.call(void 0, dialog, target))
+      return true;
+    if (isBackdrop(dialog, target))
+      return true;
+    return false;
+  };
+}
+function useEventOutside({
+  store,
+  type,
+  listener,
+  nestedDialogs,
+  capture
+}) {
+  const callListener = _5QY4WCTRcjs.useEvent.call(void 0, listener);
+  const nestedDialogsRef = _5QY4WCTRcjs.useLiveRef.call(void 0, nestedDialogs);
+  const open = store.useState("open");
+  _react.useEffect.call(void 0, () => {
+    if (!open)
+      return;
+    const onEvent = (event) => {
+      const dialog = store.getState().contentElement;
+      const disclosure = store.getState().disclosureElement;
+      const target = event.target;
+      if (!dialog)
+        return;
+      if (!target)
+        return;
+      if (!isInDocument(target))
+        return;
+      if (_dom.contains.call(void 0, dialog, target))
+        return;
+      if (disclosure && isDisclosure(disclosure, target))
+        return;
+      if (target.hasAttribute("data-focus-trap"))
+        return;
+      if (nestedDialogsRef.current.some(dialogContains(target)))
+        return;
+      callListener(event);
+    };
+    return _events.addGlobalEventListener.call(void 0, type, onEvent, capture);
+  }, [open, capture]);
+}
+function shouldHideOnInteractOutside(hideOnInteractOutside, event) {
+  if (typeof hideOnInteractOutside === "function") {
+    return hideOnInteractOutside(event);
+  }
+  return !!hideOnInteractOutside;
+}
+function useHideOnInteractOutside({
+  store,
+  modal,
+  hideOnInteractOutside,
+  nestedDialogs
+}) {
+  const open = store.useState("open");
+  const previousMouseDownRef = _X2GXTE3Pcjs.usePreviousMouseDownRef.call(void 0, open);
+  const props = { store, nestedDialogs, capture: true };
+  useEventOutside({
+    ...props,
+    type: "mousedown",
+    listener: (event) => {
+      const dialog = store.getState().contentElement;
+      if (!dialog)
+        return;
+      if (modal && !shouldHideOnInteractOutside(hideOnInteractOutside, event)) {
+        dialog.focus();
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    }
+  });
+  useEventOutside({
+    ...props,
+    type: "click",
+    listener: (event) => {
+      const previousMouseDown = previousMouseDownRef.current;
+      if (!previousMouseDown)
+        return;
+      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) {
+        if (!modal)
+          return;
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      const dialog = store.getState().contentElement;
+      const draggingFromDialog = dialog && _dom.contains.call(void 0, dialog, previousMouseDown);
+      if (draggingFromDialog)
+        return;
+      store.hide();
+    }
+  });
+  useEventOutside({
+    ...props,
+    type: "focusin",
+    listener: (event) => {
+      const dialog = store.getState().contentElement;
+      if (!dialog)
+        return;
+      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) {
+        if (!modal)
+          return;
+        dialog.focus();
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      if (event.target === _dom.getDocument.call(void 0, dialog))
+        return;
+      store.hide();
+    }
+  });
+  useEventOutside({
+    ...props,
+    type: "contextmenu",
+    listener: (event) => {
+      const dialog = store.getState().contentElement;
+      if (!dialog)
+        return;
+      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) {
+        if (!modal)
+          return;
+        dialog.focus();
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      store.hide();
+    }
+  });
+}
+
+
+
+exports.useHideOnInteractOutside = useHideOnInteractOutside;

package/cjs/__chunks/Y5DDEPH5.cjs

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _FO6MB5HFcjs = require('./FO6MB5HF.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+// src/checkbox/checkbox-check.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var checkmark = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  "svg",
+  {
+    display: "block",
+    fill: "none",
+    stroke: "currentColor",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    strokeWidth: "1.5pt",
+    viewBox: "0 0 16 16",
+    height: "1em",
+    width: "1em",
+    children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "polyline", { points: "4,8 7,12 12,4" })
+  }
+);
+function getChildren(props) {
+  if (props.checked) {
+    return props.children || checkmark;
+  }
+  if (typeof props.children === "function") {
+    return props.children;
+  }
+  return null;
+}
+var useCheckboxCheck = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ store, checked, ...props }) => {
+    const context = _react.useContext.call(void 0, _FO6MB5HFcjs.CheckboxCheckedContext);
+    checked = _nullishCoalesce(checked, () => ( context));
+    const children = getChildren({ checked, children: props.children });
+    props = {
+      "aria-hidden": true,
+      ...props,
+      children,
+      style: {
+        width: "1em",
+        height: "1em",
+        pointerEvents: "none",
+        ...props.style
+      }
+    };
+    return props;
+  }
+);
+var CheckboxCheck = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useCheckboxCheck(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "span", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  CheckboxCheck.displayName = "CheckboxCheck";
+}
+
+
+
+
+exports.useCheckboxCheck = useCheckboxCheck; exports.CheckboxCheck = CheckboxCheck;

package/cjs/__chunks/YAJKVIK2.cjs

@@ -0,0 +1,116 @@
+"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 _GEJXRZB4cjs = require('./GEJXRZB4.cjs');
+
+
+var _W5PBA4D6cjs = require('./W5PBA4D6.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+// src/popover/popover.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var usePopover = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({
+    store,
+    modal = false,
+    portal = !!modal,
+    preserveTabOrder = true,
+    autoFocusOnShow = true,
+    wrapperProps,
+    ...props
+  }) => {
+    const popoverElement = store.useState("popoverElement");
+    const contentElement = store.useState("contentElement");
+    _5QY4WCTRcjs.useSafeLayoutEffect.call(void 0, () => {
+      const wrapper = popoverElement;
+      const popover = contentElement;
+      if (!wrapper)
+        return;
+      if (!popover)
+        return;
+      wrapper.style.zIndex = getComputedStyle(popover).zIndex;
+    }, [popoverElement, contentElement]);
+    const [canAutoFocusOnShow, setCanAutoFocusOnShow] = _react.useState.call(void 0, false);
+    const { portalRef, domReady } = _5QY4WCTRcjs.usePortalRef.call(void 0, portal, props.portalRef);
+    const mounted = store.useState("mounted");
+    _5QY4WCTRcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (!domReady)
+        return;
+      if (!mounted)
+        return;
+      if (!_optionalChain([contentElement, 'optionalAccess', _ => _.isConnected]))
+        return;
+      const raf = requestAnimationFrame(() => {
+        setCanAutoFocusOnShow(true);
+      });
+      return () => {
+        cancelAnimationFrame(raf);
+      };
+    }, [domReady, mounted, contentElement]);
+    const position = store.useState(
+      (state) => state.fixed ? "fixed" : "absolute"
+    );
+    props = _5QY4WCTRcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        "div",
+        {
+          role: "presentation",
+          ...wrapperProps,
+          style: {
+            position,
+            top: 0,
+            left: 0,
+            ..._optionalChain([wrapperProps, 'optionalAccess', _2 => _2.style])
+          },
+          ref: store.setPopoverElement,
+          children: element
+        }
+      ),
+      [store, position, wrapperProps]
+    );
+    props = _5QY4WCTRcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _W5PBA4D6cjs.PopoverContext.Provider, { value: store, children: element }),
+      [store]
+    );
+    props = {
+      ...props,
+      style: {
+        position: "relative",
+        ...props.style
+      }
+    };
+    props = _GEJXRZB4cjs.useDialog.call(void 0, {
+      store,
+      modal,
+      preserveTabOrder,
+      portal,
+      autoFocusOnShow: canAutoFocusOnShow && autoFocusOnShow,
+      ...props,
+      portalRef
+    });
+    return props;
+  }
+);
+var Popover = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = usePopover(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Popover.displayName = "Popover";
+}
+
+
+
+
+exports.usePopover = usePopover; exports.Popover = Popover;

package/cjs/__chunks/YHG3KGFW.cjs

@@ -0,0 +1,28 @@
+"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; }// src/dialog/utils/walk-tree-outside.ts
+var _dom = require('@ariakit/core/utils/dom');
+var ignoreTags = ["SCRIPT", "STYLE"];
+function isValidElement(element, ignoredElements) {
+  if (ignoreTags.includes(element.tagName))
+    return false;
+  return !ignoredElements.some(
+    (enabledElement) => enabledElement && _dom.contains.call(void 0, element, enabledElement)
+  );
+}
+function walkTreeOutside(elements, callback) {
+  for (let element of elements) {
+    const document = _dom.getDocument.call(void 0, element);
+    while (_optionalChain([element, 'optionalAccess', _ => _.parentElement]) && element !== document.body) {
+      for (const child of element.parentElement.children) {
+        if (isValidElement(child, elements)) {
+          callback(child);
+        }
+      }
+      element = element.parentElement;
+    }
+  }
+}
+
+
+
+
+exports.isValidElement = isValidElement; exports.walkTreeOutside = walkTreeOutside;

package/cjs/__chunks/YITIRUCT.cjs

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _TIVUAJD3cjs = require('./TIVUAJD3.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+// src/toolbar/toolbar-item.ts
+var useToolbarItem = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ store, ...props }) => {
+    props = _TIVUAJD3cjs.useCompositeItem.call(void 0, { store, ...props });
+    return props;
+  }
+);
+var ToolbarItem = _UYIFJ7U3cjs.createMemoComponent.call(void 0, (props) => {
+  const htmlProps = useToolbarItem(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "button", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  ToolbarItem.displayName = "ToolbarItem";
+}
+
+
+
+
+exports.useToolbarItem = useToolbarItem; exports.ToolbarItem = ToolbarItem;

package/cjs/__chunks/ZNVMDYMM.cjs

@@ -0,0 +1,78 @@
+"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 _MAH7ORCZcjs = require('./MAH7ORCZ.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+// src/focus-trap/focus-trap-region.tsx
+var _react = require('react');
+var _focus = require('@ariakit/core/utils/focus');
+var _jsxruntime = require('react/jsx-runtime');
+var useFocusTrapRegion = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ enabled = false, ...props }) => {
+    const ref = _react.useRef.call(void 0, null);
+    props = _5QY4WCTRcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => {
+        const renderFocusTrap = () => {
+          if (!enabled)
+            return null;
+          return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _MAH7ORCZcjs.FocusTrap,
+            {
+              onFocus: (event) => {
+                const container = ref.current;
+                if (!container)
+                  return;
+                const tabbables = _focus.getAllTabbableIn.call(void 0, container, true);
+                const first = tabbables[0];
+                const last = tabbables[tabbables.length - 1];
+                if (!tabbables.length) {
+                  container.focus();
+                  return;
+                }
+                if (event.relatedTarget === first) {
+                  _optionalChain([last, 'optionalAccess', _ => _.focus, 'call', _2 => _2()]);
+                } else {
+                  _optionalChain([first, 'optionalAccess', _3 => _3.focus, 'call', _4 => _4()]);
+                }
+              }
+            }
+          );
+        };
+        return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          renderFocusTrap(),
+          element,
+          renderFocusTrap()
+        ] });
+      },
+      [enabled]
+    );
+    props = {
+      ...props,
+      ref: _5QY4WCTRcjs.useForkRef.call(void 0, ref, props.ref)
+    };
+    return props;
+  }
+);
+var FocusTrapRegion = _UYIFJ7U3cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useFocusTrapRegion(props);
+    return _UYIFJ7U3cjs.createElement.call(void 0, "div", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  FocusTrapRegion.displayName = "FocusTrapRegion";
+}
+
+
+
+
+exports.useFocusTrapRegion = useFocusTrapRegion; exports.FocusTrapRegion = FocusTrapRegion;

package/cjs/__chunks/ZQAFJQIS.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/collection/collection-context.ts
+var _react = require('react');
+var CollectionContext = _react.createContext.call(void 0, 
+  void 0
+);
+
+
+
+exports.CollectionContext = CollectionContext;

package/cjs/button/button.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _GTWUFHVOcjs = require('../__chunks/GTWUFHVO.cjs');
+require('../__chunks/EWCMH6G3.cjs');
+require('../__chunks/44UMDBZE.cjs');
+require('../__chunks/UYIFJ7U3.cjs');
+require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+
+
+exports.Button = _GTWUFHVOcjs.Button; exports.useButton = _GTWUFHVOcjs.useButton;

package/cjs/button/button.d.ts

@@ -0,0 +1,26 @@
+import type { CommandOptions } from "../command/command.js";
+import type { As, Props } from "../utils/types.js";
+/**
+ * Returns props to create a `Button` component. If the element is not a native
+ * button, the hook will return additional props to make sure it's accessible.
+ * @see https://ariakit.org/components/button
+ * @example
+ * ```jsx
+ * const props = useButton({ as: "div" });
+ * <Role {...props}>Accessible button</Role>
+ * ```
+ */
+export declare const useButton: import("../utils/types.js").Hook<ButtonOptions<"button">>;
+/**
+ * Renders an accessible button element. If the underlying element is not a
+ * native button, this component will pass additional attributes to make sure
+ * it's accessible.
+ * @see https://ariakit.org/components/button
+ * @example
+ * ```jsx
+ * <Button as="div">Accessible button</Button>
+ * ```
+ */
+export declare const Button: import("../utils/types.js").Component<ButtonOptions<"button">>;
+export type ButtonOptions<T extends As = "button"> = CommandOptions<T>;
+export type ButtonProps<T extends As = "button"> = Props<ButtonOptions<T>>;

package/cjs/checkbox/checkbox-check.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _Y5DDEPH5cjs = require('../__chunks/Y5DDEPH5.cjs');
+require('../__chunks/FO6MB5HF.cjs');
+require('../__chunks/UYIFJ7U3.cjs');
+
+
+
+exports.CheckboxCheck = _Y5DDEPH5cjs.CheckboxCheck; exports.useCheckboxCheck = _Y5DDEPH5cjs.useCheckboxCheck;

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

@@ -0,0 +1,37 @@
+import type { As, Options, Props } from "../utils/types.js";
+import type { CheckboxStore } from "./checkbox-store.js";
+/**
+ * Returns props to create a `CheckboxCheck` component, that's usually rendered
+ * inside a `Checkbox` component.
+ * @see https://ariakit.org/components/checkbox
+ * @example
+ * ```jsx
+ * const props = useCheckboxCheck({ checked: true });
+ * <Role {...props} />
+ * ```
+ */
+export declare const useCheckboxCheck: import("../utils/types.js").Hook<CheckboxCheckOptions<"span">>;
+/**
+ * Renders a check mark icon, usually inside a `Checkbox` component.
+ * @see https://ariakit.org/components/checkbox
+ * @example
+ * ```jsx
+ * <CheckboxCheck checked />
+ * ```
+ */
+export declare const CheckboxCheck: import("../utils/types.js").Component<CheckboxCheckOptions<"span">>;
+export interface CheckboxCheckOptions<T extends As = "span"> extends Options<T> {
+    /**
+     * Object returned by the `useCheckboxStore` hook. If not provided, the parent
+     * `Checkbox` component's context will be used. If the `checked` prop is
+     * provided, it will override this prop.
+     */
+    store?: CheckboxStore;
+    /**
+     * Whether the check mark should be shown. This value is automatically
+     * inferred from the `store` prop or the parent `Checkbox` component. Manually
+     * setting this prop will override the inferred value.
+     */
+    checked?: boolean;
+}
+export type CheckboxCheckProps<T extends As = "span"> = Props<CheckboxCheckOptions<T>>;

package/cjs/checkbox/checkbox-checked-context.cjs

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _FO6MB5HFcjs = require('../__chunks/FO6MB5HF.cjs');
+
+
+exports.CheckboxCheckedContext = _FO6MB5HFcjs.CheckboxCheckedContext;

package/cjs/checkbox/checkbox-checked-context.d.ts

@@ -0,0 +1 @@
+export declare const CheckboxCheckedContext: import("react").Context<boolean>;

package/cjs/checkbox/checkbox-store.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _NJHMO3XKcjs = require('../__chunks/NJHMO3XK.cjs');
+require('../__chunks/F6IOE5QT.cjs');
+require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+
+
+
+exports.useCheckboxStore = _NJHMO3XKcjs.useCheckboxStore; exports.useCheckboxStoreOptions = _NJHMO3XKcjs.useCheckboxStoreOptions; exports.useCheckboxStoreProps = _NJHMO3XKcjs.useCheckboxStoreProps;

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

@@ -0,0 +1,36 @@
+import * as Core from "@ariakit/core/checkbox/checkbox-store";
+import type { PickRequired } from "@ariakit/core/utils/types";
+import type { Store } from "../utils/store.js";
+type Value = Core.CheckboxStoreValue;
+export declare function useCheckboxStoreOptions(_props: CheckboxStoreProps): Partial<CheckboxStoreOptions>;
+export declare function useCheckboxStoreProps<T extends CheckboxStore>(store: T, props: CheckboxStoreProps): T;
+/**
+ * Creates a checkbox store.
+ * @see https://ariakit.org/components/checkbox
+ * @example
+ * ```jsx
+ * const checkbox = useCheckboxStore({ defaultValue: true });
+ * <Checkbox store={checkbox} />
+ * ```
+ */
+export declare function useCheckboxStore<T extends Value = Value>(props: PickRequired<CheckboxStoreProps<T>, "value" | "defaultValue">): CheckboxStore<T>;
+export declare function useCheckboxStore(props?: CheckboxStoreProps): CheckboxStore;
+export type CheckboxStoreValue = Core.CheckboxStoreValue;
+export type CheckboxStoreState<T extends Value = Value> = Core.CheckboxStoreState<T>;
+export type CheckboxStoreFunctions<T extends Value = Value> = Core.CheckboxStoreFunctions<T>;
+export interface CheckboxStoreOptions<T extends Value = Value> extends Core.CheckboxStoreOptions<T> {
+    /**
+     * A callback that gets called when the `value` state changes.
+     * @param value The new value.
+     * @example
+     * function MyCheckbox({ value, onChange }) {
+     *   const checkbox = useCheckboxStore({ value, setValue: onChange });
+     * }
+     */
+    setValue?: (value: CheckboxStoreState<T>["value"]) => void;
+}
+export interface CheckboxStoreProps<T extends Value = Value> extends CheckboxStoreOptions<T>, Core.CheckboxStoreProps<T> {
+}
+export interface CheckboxStore<T extends Value = Value> extends CheckboxStoreFunctions<T>, Store<Core.CheckboxStore<T>> {
+}
+export {};

package/cjs/checkbox/checkbox.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _NYVIJAIXcjs = require('../__chunks/NYVIJAIX.cjs');
+require('../__chunks/FO6MB5HF.cjs');
+require('../__chunks/EWCMH6G3.cjs');
+require('../__chunks/44UMDBZE.cjs');
+require('../__chunks/UYIFJ7U3.cjs');
+require('../__chunks/F6IOE5QT.cjs');
+require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+
+
+exports.Checkbox = _NYVIJAIXcjs.Checkbox; exports.useCheckbox = _NYVIJAIXcjs.useCheckbox;