@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/utils/useBaseUiId.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useBaseUiId_exports = {};
+__export(useBaseUiId_exports, {
+  useBaseUiId: () => useBaseUiId
+});
+module.exports = __toCommonJS(useBaseUiId_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function useBaseUiId(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useBaseUiId");
+  const idOverride = user[0];
+  const id = (0, import_octane.useId)(slot);
+  return idOverride ?? `base-ui-${id}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useBaseUiId
+});

package/dist/cjs/utils/useButton.cjs

@@ -0,0 +1,177 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useButton_exports = {};
+__export(useButton_exports, {
+  useButton: () => useButton
+});
+module.exports = __toCommonJS(useButton_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+var import_mergeProps = require("./mergeProps.cjs");
+var import_CompositeRootContext = require("./CompositeRootContext.cjs");
+var import_useFocusableWhenDisabled = require("./useFocusableWhenDisabled.cjs");
+var import_useStableCallback = require("./useStableCallback.cjs");
+function isButtonElement(elem) {
+  return elem != null && elem instanceof HTMLElement && elem.tagName === "BUTTON";
+}
+function isValidLinkElement(elem) {
+  return Boolean(elem != null && elem.tagName === "A" && elem.href);
+}
+function useButton(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useButton");
+  const {
+    disabled = false,
+    focusableWhenDisabled,
+    tabIndex = 0,
+    native: isNativeButton = true,
+    composite: compositeProp
+  } = user[0] ?? {};
+  const elementRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "el"));
+  const compositeRootContext = (0, import_CompositeRootContext.useCompositeRootContext)(true);
+  const isCompositeItem = compositeProp ?? compositeRootContext !== void 0;
+  const { props: focusableWhenDisabledProps } = (0, import_useFocusableWhenDisabled.useFocusableWhenDisabled)(
+    { focusableWhenDisabled, disabled, composite: isCompositeItem, tabIndex, isNativeButton },
+    (0, import_internal.subSlot)(slot, "fwd")
+  );
+  const updateDisabled = (0, import_octane.useCallback)(
+    () => {
+      const element = elementRef.current;
+      if (!isButtonElement(element)) {
+        return;
+      }
+      if (isCompositeItem && disabled && focusableWhenDisabledProps.disabled === void 0 && element.disabled) {
+        element.disabled = false;
+      }
+    },
+    [disabled, focusableWhenDisabledProps.disabled, isCompositeItem],
+    (0, import_internal.subSlot)(slot, "upd")
+  );
+  (0, import_octane.useLayoutEffect)(updateDisabled, [updateDisabled], (0, import_internal.subSlot)(slot, "e:upd"));
+  const getButtonProps = (0, import_octane.useCallback)(
+    (externalProps = {}) => {
+      const {
+        onClick: externalOnClick,
+        onMouseDown: externalOnMouseDown,
+        onKeyUp: externalOnKeyUp,
+        onKeyDown: externalOnKeyDown,
+        onPointerDown: externalOnPointerDown,
+        ...otherExternalProps
+      } = externalProps;
+      return (0, import_mergeProps.mergeProps)(
+        {
+          onClick(event) {
+            if (disabled) {
+              event.preventDefault();
+              return;
+            }
+            externalOnClick?.(event);
+          },
+          onMouseDown(event) {
+            if (!disabled) {
+              externalOnMouseDown?.(event);
+            }
+          },
+          onKeyDown(event) {
+            if (disabled) {
+              return;
+            }
+            (0, import_mergeProps.makeEventPreventable)(event);
+            externalOnKeyDown?.(event);
+            if (event.baseUIHandlerPrevented) {
+              return;
+            }
+            const isCurrentTarget = event.target === event.currentTarget;
+            const currentTarget = event.currentTarget;
+            const isButton = isButtonElement(currentTarget);
+            const isLink = !isNativeButton && isValidLinkElement(currentTarget);
+            const shouldClick = isCurrentTarget && (isNativeButton ? isButton : !isLink);
+            const isEnterKey = event.key === "Enter";
+            const isSpaceKey = event.key === " ";
+            const role = currentTarget.getAttribute("role");
+            const isTextNavigationRole = role?.startsWith("menuitem") || role === "option" || role === "gridcell";
+            if (isCurrentTarget && isCompositeItem && isSpaceKey) {
+              if (event.defaultPrevented && isTextNavigationRole) {
+                return;
+              }
+              event.preventDefault();
+              if (isLink || isNativeButton && isButton) {
+                currentTarget.click();
+                event.preventBaseUIHandler();
+              } else if (shouldClick) {
+                externalOnClick?.(event);
+                event.preventBaseUIHandler();
+              }
+              return;
+            }
+            if (shouldClick) {
+              if (!isNativeButton && (isSpaceKey || isEnterKey)) {
+                event.preventDefault();
+              }
+              if (!isNativeButton && isEnterKey) {
+                externalOnClick?.(event);
+              }
+            }
+          },
+          onKeyUp(event) {
+            if (disabled) {
+              return;
+            }
+            (0, import_mergeProps.makeEventPreventable)(event);
+            externalOnKeyUp?.(event);
+            if (event.target === event.currentTarget && isNativeButton && isCompositeItem && isButtonElement(event.currentTarget) && event.key === " ") {
+              event.preventDefault();
+              return;
+            }
+            if (event.baseUIHandlerPrevented) {
+              return;
+            }
+            if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && event.key === " ") {
+              externalOnClick?.(event);
+            }
+          },
+          onPointerDown(event) {
+            if (disabled) {
+              event.preventDefault();
+              return;
+            }
+            externalOnPointerDown?.(event);
+          }
+        },
+        isNativeButton ? { type: "button" } : { role: "button" },
+        focusableWhenDisabledProps,
+        otherExternalProps
+      );
+    },
+    [disabled, focusableWhenDisabledProps, isCompositeItem, isNativeButton],
+    (0, import_internal.subSlot)(slot, "gbp")
+  );
+  const buttonRef = (0, import_useStableCallback.useStableCallback)(
+    (element) => {
+      elementRef.current = element;
+      updateDisabled();
+    },
+    (0, import_internal.subSlot)(slot, "ref")
+  );
+  return { getButtonProps, buttonRef };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useButton
+});

package/dist/cjs/utils/useCheckboxGroupParent.cjs

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useCheckboxGroupParent_exports = {};
+__export(useCheckboxGroupParent_exports, {
+  useCheckboxGroupParent: () => useCheckboxGroupParent
+});
+module.exports = __toCommonJS(useCheckboxGroupParent_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+var import_useBaseUiId = require("./useBaseUiId.cjs");
+var import_useStableCallback = require("./useStableCallback.cjs");
+const EMPTY = [];
+function useCheckboxGroupParent(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useCheckboxGroupParent");
+  const {
+    allValues = EMPTY,
+    value = EMPTY,
+    onValueChange: onValueChangeProp
+  } = user[0] ?? {};
+  const uncontrolledStateRef = (0, import_octane.useRef)(value, (0, import_internal.subSlot)(slot, "uncontrolled"));
+  const disabledStatesRef = (0, import_octane.useRef)(/* @__PURE__ */ new Map(), (0, import_internal.subSlot)(slot, "disabledStates"));
+  const [status, setStatus] = (0, import_octane.useState)("mixed", (0, import_internal.subSlot)(slot, "status"));
+  const id = (0, import_useBaseUiId.useBaseUiId)(void 0, (0, import_internal.subSlot)(slot, "id"));
+  const checked = value.length === allValues.length;
+  const indeterminate = value.length !== allValues.length && value.length > 0;
+  const onValueChange = (0, import_useStableCallback.useStableCallback)(onValueChangeProp, (0, import_internal.subSlot)(slot, "onValueChange"));
+  const getParentProps = (0, import_octane.useCallback)(
+    () => ({
+      id,
+      indeterminate,
+      checked,
+      "aria-controls": allValues.map((v) => `${id}-${v}`).join(" "),
+      onCheckedChange(_, eventDetails) {
+        const uncontrolledState = uncontrolledStateRef.current;
+        const none = allValues.filter(
+          (v) => disabledStatesRef.current.get(v) && uncontrolledState.includes(v)
+        );
+        const all = allValues.filter(
+          (v) => !disabledStatesRef.current.get(v) || disabledStatesRef.current.get(v) && uncontrolledState.includes(v)
+        );
+        const allOnOrOff = uncontrolledState.length === all.length || uncontrolledState.length === 0;
+        if (allOnOrOff) {
+          if (value.length === all.length) {
+            onValueChange(none, eventDetails);
+          } else {
+            onValueChange(all, eventDetails);
+          }
+          return;
+        }
+        let nextStatus = "mixed";
+        let nextValue = uncontrolledState;
+        if (status === "mixed") {
+          nextStatus = "on";
+          nextValue = all;
+        } else if (status === "on") {
+          nextStatus = "off";
+          nextValue = none;
+        }
+        onValueChange(nextValue, eventDetails);
+        if (!eventDetails.isCanceled) {
+          setStatus(nextStatus);
+        }
+      }
+    }),
+    [allValues, checked, id, indeterminate, onValueChange, status, value.length],
+    (0, import_internal.subSlot)(slot, "getParentProps")
+  );
+  const getChildProps = (0, import_octane.useCallback)(
+    (childValue) => ({
+      checked: value.includes(childValue),
+      onCheckedChange(nextChecked, eventDetails) {
+        const newValue = value.slice();
+        if (nextChecked) {
+          newValue.push(childValue);
+        } else {
+          newValue.splice(newValue.indexOf(childValue), 1);
+        }
+        onValueChange(newValue, eventDetails);
+        if (!eventDetails.isCanceled) {
+          uncontrolledStateRef.current = newValue;
+          setStatus("mixed");
+        }
+      }
+    }),
+    [onValueChange, value],
+    (0, import_internal.subSlot)(slot, "getChildProps")
+  );
+  return (0, import_octane.useMemo)(
+    () => ({ id, indeterminate, getParentProps, getChildProps, disabledStatesRef }),
+    [id, indeterminate, getParentProps, getChildProps],
+    (0, import_internal.subSlot)(slot, "return")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCheckboxGroupParent
+});

package/dist/cjs/utils/useControlled.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useControlled_exports = {};
+__export(useControlled_exports, {
+  useControlled: () => useControlled
+});
+module.exports = __toCommonJS(useControlled_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function useControlled(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useControlled");
+  const { controlled, default: defaultProp } = user[0];
+  const { current: isControlled } = (0, import_octane.useRef)(controlled !== void 0, (0, import_internal.subSlot)(slot, "ctrl"));
+  const [valueState, setValue] = (0, import_octane.useState)(defaultProp, (0, import_internal.subSlot)(slot, "val"));
+  const value = isControlled ? controlled : valueState;
+  const setValueIfUncontrolled = (0, import_octane.useCallback)(
+    (newValue) => {
+      if (!isControlled) {
+        setValue(newValue);
+      }
+    },
+    [],
+    (0, import_internal.subSlot)(slot, "set")
+  );
+  return [value, setValueIfUncontrolled];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useControlled
+});

package/dist/cjs/utils/useEnhancedClickHandler.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useEnhancedClickHandler_exports = {};
+__export(useEnhancedClickHandler_exports, {
+  useEnhancedClickHandler: () => useEnhancedClickHandler
+});
+module.exports = __toCommonJS(useEnhancedClickHandler_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function useEnhancedClickHandler(handler, slot) {
+  const lastClickInteractionTypeRef = (0, import_octane.useRef)("", (0, import_internal.subSlot)(slot, "last"));
+  const handlePointerDown = (0, import_octane.useCallback)(
+    (event) => {
+      if (event.defaultPrevented) {
+        return;
+      }
+      lastClickInteractionTypeRef.current = event.pointerType;
+      handler(event, event.pointerType);
+    },
+    [handler],
+    (0, import_internal.subSlot)(slot, "pd")
+  );
+  const handleClick = (0, import_octane.useCallback)(
+    (event) => {
+      if (event.detail === 0) {
+        handler(event, "keyboard");
+        return;
+      }
+      if ("pointerType" in event) {
+        handler(event, event.pointerType);
+      } else {
+        handler(event, lastClickInteractionTypeRef.current);
+      }
+      lastClickInteractionTypeRef.current = "";
+    },
+    [handler],
+    (0, import_internal.subSlot)(slot, "click")
+  );
+  return { onClick: handleClick, onPointerDown: handlePointerDown };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useEnhancedClickHandler
+});

package/dist/cjs/utils/useFocusableWhenDisabled.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useFocusableWhenDisabled_exports = {};
+__export(useFocusableWhenDisabled_exports, {
+  useFocusableWhenDisabled: () => useFocusableWhenDisabled
+});
+module.exports = __toCommonJS(useFocusableWhenDisabled_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function useFocusableWhenDisabled(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useFocusableWhenDisabled");
+  const {
+    focusableWhenDisabled,
+    disabled,
+    composite = false,
+    tabIndex: tabIndexProp = 0,
+    isNativeButton
+  } = user[0];
+  const isFocusableComposite = composite && focusableWhenDisabled !== false;
+  const isNonFocusableComposite = composite && focusableWhenDisabled === false;
+  const props = (0, import_octane.useMemo)(
+    () => {
+      const additionalProps = {
+        onKeyDown(event) {
+          if (disabled && focusableWhenDisabled && event.key !== "Tab") {
+            event.preventDefault();
+          }
+        }
+      };
+      if (!composite) {
+        additionalProps.tabIndex = tabIndexProp;
+        if (!isNativeButton && disabled) {
+          additionalProps.tabIndex = focusableWhenDisabled ? tabIndexProp : -1;
+        }
+      }
+      if (isNativeButton && (focusableWhenDisabled || isFocusableComposite) || !isNativeButton && disabled) {
+        additionalProps["aria-disabled"] = disabled;
+      }
+      if (isNativeButton && (!focusableWhenDisabled || isNonFocusableComposite)) {
+        additionalProps.disabled = disabled;
+      }
+      return additionalProps;
+    },
+    [
+      composite,
+      disabled,
+      focusableWhenDisabled,
+      isFocusableComposite,
+      isNonFocusableComposite,
+      isNativeButton,
+      tabIndexProp
+    ],
+    slot
+  );
+  return { props };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFocusableWhenDisabled
+});

package/dist/cjs/utils/useForcedRerendering.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useForcedRerendering_exports = {};
+__export(useForcedRerendering_exports, {
+  useForcedRerendering: () => useForcedRerendering
+});
+module.exports = __toCommonJS(useForcedRerendering_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function useForcedRerendering(...args) {
+  const [, slotArg] = (0, import_internal.splitSlot)(["_", ...args]);
+  const slot = slotArg ?? (0, import_internal.S)("useForcedRerendering");
+  const [, setState] = (0, import_octane.useState)({}, (0, import_internal.subSlot)(slot, "state"));
+  return (0, import_octane.useCallback)(() => setState({}), [], (0, import_internal.subSlot)(slot, "cb"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useForcedRerendering
+});

package/dist/cjs/utils/useIsHydrating.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useIsHydrating_exports = {};
+__export(useIsHydrating_exports, {
+  useIsHydrating: () => useIsHydrating
+});
+module.exports = __toCommonJS(useIsHydrating_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function subscribe() {
+  return () => {
+  };
+}
+function getSnapshot() {
+  return false;
+}
+function getServerSnapshot() {
+  return true;
+}
+function useIsHydrating(...args) {
+  const [, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useIsHydrating");
+  return (0, import_octane.useSyncExternalStore)(subscribe, getSnapshot, getServerSnapshot, (0, import_internal.subSlot)(slot, "store"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useIsHydrating
+});

package/dist/cjs/utils/useMixedToggleClickHandler.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useMixedToggleClickHandler_exports = {};
+__export(useMixedToggleClickHandler_exports, {
+  useMixedToggleClickHandler: () => useMixedToggleClickHandler
+});
+module.exports = __toCommonJS(useMixedToggleClickHandler_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+var import_empty = require("./empty.cjs");
+var import_owner = require("./owner.cjs");
+function useMixedToggleClickHandler(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useMixedToggleClickHandler");
+  const { enabled = true, mouseDownAction, open } = user[0];
+  const ignoreClickRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "ignore"));
+  return (0, import_octane.useMemo)(
+    () => {
+      if (!enabled) {
+        return import_empty.EMPTY_OBJECT;
+      }
+      return {
+        onMouseDown: (event) => {
+          if (mouseDownAction === "open" && !open || mouseDownAction === "close" && open) {
+            ignoreClickRef.current = true;
+            (0, import_owner.ownerDocument)(event.currentTarget).addEventListener(
+              "click",
+              () => {
+                ignoreClickRef.current = false;
+              },
+              { once: true }
+            );
+          }
+        },
+        onClick: (event) => {
+          if (ignoreClickRef.current) {
+            ignoreClickRef.current = false;
+            event.preventBaseUIHandler();
+          }
+        }
+      };
+    },
+    [enabled, mouseDownAction, open],
+    (0, import_internal.subSlot)(slot, "m")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMixedToggleClickHandler
+});