@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/utils/usePositioner.cjs

@@ -0,0 +1,53 @@
+"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 usePositioner_exports = {};
+__export(usePositioner_exports, {
+  usePositioner: () => usePositioner
+});
+module.exports = __toCommonJS(usePositioner_exports);
+var import_internal = require("../internal.cjs");
+var import_popupStateMapping = require("./popupStateMapping.cjs");
+var import_useRenderElement = require("./useRenderElement.cjs");
+var import_getDisabledMountTransitionStyles = require("./getDisabledMountTransitionStyles.cjs");
+function usePositioner(componentProps, state, { styles, transitionStatus, props, refs, hidden, inert = false }, slotArg) {
+  const slot = slotArg ?? (0, import_internal.S)("usePositioner");
+  const style = { ...styles };
+  if (inert) {
+    style.pointerEvents = "none";
+  }
+  return (0, import_useRenderElement.useRenderElement)(
+    "div",
+    componentProps,
+    {
+      state,
+      ref: refs,
+      props: [
+        { role: "presentation", hidden, style },
+        (0, import_getDisabledMountTransitionStyles.getDisabledMountTransitionStyles)(transitionStatus),
+        props
+      ],
+      stateAttributesMapping: import_popupStateMapping.popupStateMapping
+    },
+    (0, import_internal.subSlot)(slot, "re")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usePositioner
+});

package/dist/cjs/utils/usePressAndHold.cjs

@@ -0,0 +1,51 @@
+"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 usePressAndHold_exports = {};
+__export(usePressAndHold_exports, {
+  isTouchLikePointerType: () => isTouchLikePointerType,
+  usePressAndHold: () => usePressAndHold
+});
+module.exports = __toCommonJS(usePressAndHold_exports);
+function isTouchLikePointerType(pointerType) {
+  return pointerType === "touch" || pointerType === "pen";
+}
+function usePressAndHold(_params) {
+  return {
+    pointerHandlers: {
+      onTouchStart() {
+      },
+      onTouchEnd() {
+      },
+      onPointerDown() {
+      },
+      onPointerUp() {
+      },
+      onPointerMove() {
+      },
+      onPointerLeave() {
+      }
+    },
+    shouldSkipClick: () => false
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isTouchLikePointerType,
+  usePressAndHold
+});

package/dist/cjs/utils/usePreviousValue.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 usePreviousValue_exports = {};
+__export(usePreviousValue_exports, {
+  usePreviousValue: () => usePreviousValue
+});
+module.exports = __toCommonJS(usePreviousValue_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function previousCommittedValue(_current, previous) {
+  return previous === void 0 ? null : previous.source;
+}
+const PREVIOUS_VALUE_OPTIONS = {
+  sourceEqual: (previous, next) => previous === next
+};
+function usePreviousValue(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("usePreviousValue");
+  const value = user[0];
+  const [previous] = (0, import_octane.useLinkedState)(
+    value,
+    previousCommittedValue,
+    PREVIOUS_VALUE_OPTIONS,
+    (0, import_internal.subSlot)(slot, "st")
+  );
+  return previous;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usePreviousValue
+});

package/dist/cjs/utils/useRefWithInit.cjs

@@ -0,0 +1,41 @@
+"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 useRefWithInit_exports = {};
+__export(useRefWithInit_exports, {
+  useRefWithInit: () => useRefWithInit
+});
+module.exports = __toCommonJS(useRefWithInit_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+const UNSET = /* @__PURE__ */ Symbol("base-ui.useRefWithInit.unset");
+function useRefWithInit(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useRefWithInit");
+  const init = user[0];
+  const arg = user[1];
+  const ref = (0, import_octane.useRef)(UNSET, (0, import_internal.subSlot)(slot, "ref"));
+  if (ref.current === UNSET) {
+    ref.current = init(arg);
+  }
+  return ref;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRefWithInit
+});

package/dist/cjs/utils/useRegisteredLabelId.cjs

@@ -0,0 +1,48 @@
+"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 useRegisteredLabelId_exports = {};
+__export(useRegisteredLabelId_exports, {
+  useRegisteredLabelId: () => useRegisteredLabelId
+});
+module.exports = __toCommonJS(useRegisteredLabelId_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+var import_useBaseUiId = require("./useBaseUiId.cjs");
+function useRegisteredLabelId(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useRegisteredLabelId");
+  const idProp = user[0];
+  const setLabelId = user[1];
+  const id = (0, import_useBaseUiId.useBaseUiId)(idProp, (0, import_internal.subSlot)(slot, "id"));
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      setLabelId(id);
+      return () => {
+        setLabelId(void 0);
+      };
+    },
+    [id, setLabelId],
+    (0, import_internal.subSlot)(slot, "e:label")
+  );
+  return id;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRegisteredLabelId
+});

package/dist/cjs/utils/useRenderElement.cjs

@@ -0,0 +1,106 @@
+"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 useRenderElement_exports = {};
+__export(useRenderElement_exports, {
+  useRenderElement: () => useRenderElement
+});
+module.exports = __toCommonJS(useRenderElement_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+var import_composeRefs = require("./composeRefs.cjs");
+var import_getElementRef = require("./getElementRef.cjs");
+var import_getStateAttributesProps = require("./getStateAttributesProps.cjs");
+var import_mergeObjects = require("./mergeObjects.cjs");
+var import_resolveClassName = require("./resolveClassName.cjs");
+var import_resolveStyle = require("./resolveStyle.cjs");
+var import_mergeProps = require("./mergeProps.cjs");
+const EMPTY_OBJECT = {};
+function useRenderElement(element, componentProps, params = {}, ...slotArgs) {
+  const [, slotArg] = (0, import_internal.splitSlot)(["_", ...slotArgs]);
+  const slot = slotArg ?? (0, import_internal.S)("useRenderElement");
+  const renderProp = componentProps.render;
+  const outProps = useRenderElementProps(componentProps, params, (0, import_internal.subSlot)(slot, "rp"));
+  if (params.enabled === false) {
+    return null;
+  }
+  const state = params.state ?? EMPTY_OBJECT;
+  return evaluateRenderProp(element, renderProp, outProps, state);
+}
+function useRenderElementProps(componentProps, params, slot) {
+  const { className: classNameProp, style: styleProp, render: renderProp } = componentProps;
+  const {
+    state = EMPTY_OBJECT,
+    ref,
+    props,
+    stateAttributesMapping,
+    enabled = true
+  } = params;
+  const className = enabled ? (0, import_resolveClassName.resolveClassName)(classNameProp, state) : void 0;
+  const style = enabled ? (0, import_resolveStyle.resolveStyle)(styleProp, state) : void 0;
+  const stateProps = enabled ? (0, import_getStateAttributesProps.getStateAttributesProps)(state, stateAttributesMapping) : EMPTY_OBJECT;
+  const resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : void 0;
+  const outProps = enabled ? (0, import_mergeObjects.mergeObjects)(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
+  const renderRef = (0, import_getElementRef.getElementRef)(renderProp);
+  const refs = Array.isArray(ref) ? [outProps.ref, renderRef, ...ref] : [outProps.ref, renderRef, ref];
+  const composedRef = (0, import_composeRefs.useComposedRefs)(...refs, (0, import_internal.subSlot)(slot, "refs"));
+  if (!enabled) {
+    return EMPTY_OBJECT;
+  }
+  outProps.ref = composedRef;
+  if (className !== void 0) {
+    outProps.className = (0, import_mergeProps.mergeClassNames)(outProps.className, className);
+  }
+  if (style !== void 0) {
+    outProps.style = (0, import_mergeObjects.mergeObjects)(outProps.style, style);
+  }
+  return outProps;
+}
+function evaluateRenderProp(element, render, props, state) {
+  if (render) {
+    if (typeof render === "function") {
+      return render(props, state);
+    }
+    const mergedProps = (0, import_mergeProps.mergeProps)(props, render.props);
+    mergedProps.ref = props.ref;
+    return (0, import_octane.cloneElement)(render, mergedProps);
+  }
+  if (element) {
+    return renderTag(element, props);
+  }
+  throw new Error("Base UI: render element or function are not defined.");
+}
+function resolveRenderFunctionProps(props) {
+  if (Array.isArray(props)) {
+    return (0, import_mergeProps.mergePropsN)(props);
+  }
+  return (0, import_mergeProps.mergeProps)(void 0, props);
+}
+function renderTag(tag, props) {
+  if (tag === "button") {
+    return (0, import_octane.createElement)("button", { type: "button", ...props });
+  }
+  if (tag === "img") {
+    return (0, import_octane.createElement)("img", { alt: "", ...props });
+  }
+  return (0, import_octane.createElement)(tag, props);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRenderElement
+});

package/dist/cjs/utils/useScrollLock.cjs

@@ -0,0 +1,232 @@
+"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 useScrollLock_exports = {};
+__export(useScrollLock_exports, {
+  useScrollLock: () => useScrollLock
+});
+module.exports = __toCommonJS(useScrollLock_exports);
+var import_dom = require("@floating-ui/utils/dom");
+var import_octane = require("octane");
+var import_addEventListener = require("./addEventListener.cjs");
+var import_platform = require("./platform.cjs");
+var import_owner = require("./owner.cjs");
+var import_useTimeout = require("./useTimeout.cjs");
+var import_useAnimationFrame = require("./useAnimationFrame.cjs");
+var import_empty = require("./empty.cjs");
+let originalHtmlStyles = {};
+let originalBodyStyles = {};
+let originalHtmlScrollBehavior = "";
+function hasInsetScrollbars(referenceElement) {
+  if (typeof document === "undefined") {
+    return false;
+  }
+  const doc = (0, import_owner.ownerDocument)(referenceElement);
+  const win = (0, import_owner.ownerWindow)(doc);
+  return win.innerWidth - doc.documentElement.clientWidth > 0;
+}
+function supportsStableScrollbarGutter(referenceElement) {
+  const supported = typeof CSS !== "undefined" && CSS.supports && CSS.supports("scrollbar-gutter", "stable");
+  if (!supported || typeof document === "undefined") {
+    return false;
+  }
+  const doc = (0, import_owner.ownerDocument)(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const scrollContainer = (0, import_dom.isOverflowElement)(html) ? html : body;
+  const originalScrollContainerOverflowY = scrollContainer.style.overflowY;
+  const originalHtmlStyleGutter = html.style.scrollbarGutter;
+  html.style.scrollbarGutter = "stable";
+  scrollContainer.style.overflowY = "scroll";
+  const before = scrollContainer.offsetWidth;
+  scrollContainer.style.overflowY = "hidden";
+  const after = scrollContainer.offsetWidth;
+  scrollContainer.style.overflowY = originalScrollContainerOverflowY;
+  html.style.scrollbarGutter = originalHtmlStyleGutter;
+  return before === after;
+}
+function preventScrollOverlayScrollbars(referenceElement) {
+  const doc = (0, import_owner.ownerDocument)(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const elementToLock = (0, import_dom.isOverflowElement)(html) ? html : body;
+  const originalElementToLockStyles = {
+    overflowY: elementToLock.style.overflowY,
+    overflowX: elementToLock.style.overflowX
+  };
+  Object.assign(elementToLock.style, { overflowY: "hidden", overflowX: "hidden" });
+  return () => {
+    Object.assign(elementToLock.style, originalElementToLockStyles);
+  };
+}
+function preventScrollInsetScrollbars(referenceElement) {
+  const doc = (0, import_owner.ownerDocument)(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const win = (0, import_owner.ownerWindow)(html);
+  let scrollTop = 0;
+  let scrollLeft = 0;
+  let updateGutterOnly = false;
+  const resizeFrame = import_useAnimationFrame.AnimationFrame.create();
+  if (import_platform.platform.engine.webkit && (win.visualViewport?.scale ?? 1) !== 1) {
+    return () => {
+    };
+  }
+  function lockScroll() {
+    const htmlStyles = win.getComputedStyle(html);
+    const bodyStyles = win.getComputedStyle(body);
+    const htmlScrollbarGutterValue = htmlStyles.scrollbarGutter || "";
+    const hasBothEdges = htmlScrollbarGutterValue.includes("both-edges");
+    const scrollbarGutterValue = hasBothEdges ? "stable both-edges" : "stable";
+    scrollTop = html.scrollTop;
+    scrollLeft = html.scrollLeft;
+    originalHtmlStyles = {
+      scrollbarGutter: html.style.scrollbarGutter,
+      overflowY: html.style.overflowY,
+      overflowX: html.style.overflowX
+    };
+    originalHtmlScrollBehavior = html.style.scrollBehavior;
+    originalBodyStyles = {
+      position: body.style.position,
+      height: body.style.height,
+      width: body.style.width,
+      boxSizing: body.style.boxSizing,
+      overflowY: body.style.overflowY,
+      overflowX: body.style.overflowX,
+      scrollBehavior: body.style.scrollBehavior
+    };
+    const isScrollableY = html.scrollHeight > html.clientHeight;
+    const isScrollableX = html.scrollWidth > html.clientWidth;
+    const hasConstantOverflowY = htmlStyles.overflowY === "scroll" || bodyStyles.overflowY === "scroll";
+    const hasConstantOverflowX = htmlStyles.overflowX === "scroll" || bodyStyles.overflowX === "scroll";
+    const scrollbarWidth = Math.max(0, win.innerWidth - body.clientWidth);
+    const scrollbarHeight = Math.max(0, win.innerHeight - body.clientHeight);
+    const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
+    const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
+    const elementToLock = (0, import_dom.isOverflowElement)(html) ? html : body;
+    updateGutterOnly = supportsStableScrollbarGutter(referenceElement);
+    if (updateGutterOnly) {
+      html.style.scrollbarGutter = scrollbarGutterValue;
+      elementToLock.style.overflowY = "hidden";
+      elementToLock.style.overflowX = "hidden";
+      return;
+    }
+    Object.assign(html.style, {
+      scrollbarGutter: scrollbarGutterValue,
+      overflowY: "hidden",
+      overflowX: "hidden"
+    });
+    if (isScrollableY || hasConstantOverflowY) {
+      html.style.overflowY = "scroll";
+    }
+    if (isScrollableX || hasConstantOverflowX) {
+      html.style.overflowX = "scroll";
+    }
+    Object.assign(body.style, {
+      position: "relative",
+      height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : "100dvh",
+      width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : "100vw",
+      boxSizing: "border-box",
+      overflow: "hidden",
+      scrollBehavior: "unset"
+    });
+    body.scrollTop = scrollTop;
+    body.scrollLeft = scrollLeft;
+    html.setAttribute("data-base-ui-scroll-locked", "");
+    html.style.scrollBehavior = "unset";
+  }
+  function cleanup() {
+    Object.assign(html.style, originalHtmlStyles);
+    Object.assign(body.style, originalBodyStyles);
+    if (!updateGutterOnly) {
+      html.scrollTop = scrollTop;
+      html.scrollLeft = scrollLeft;
+      html.removeAttribute("data-base-ui-scroll-locked");
+      html.style.scrollBehavior = originalHtmlScrollBehavior;
+    }
+  }
+  function handleResize() {
+    cleanup();
+    resizeFrame.request(lockScroll);
+  }
+  lockScroll();
+  const unsubscribeResize = (0, import_addEventListener.addEventListener)(win, "resize", handleResize);
+  return () => {
+    resizeFrame.cancel();
+    cleanup();
+    if (typeof win.removeEventListener === "function") {
+      unsubscribeResize();
+    }
+  };
+}
+class ScrollLocker {
+  lockCount = 0;
+  restore = null;
+  timeoutLock = import_useTimeout.Timeout.create();
+  timeoutUnlock = import_useTimeout.Timeout.create();
+  acquire(referenceElement) {
+    this.lockCount += 1;
+    if (this.lockCount === 1 && this.restore === null) {
+      this.timeoutLock.start(0, () => this.lock(referenceElement));
+    }
+    return this.release;
+  }
+  release = () => {
+    this.lockCount -= 1;
+    if (this.lockCount === 0 && this.restore) {
+      this.timeoutUnlock.start(0, this.unlock);
+    }
+  };
+  unlock = () => {
+    if (this.lockCount === 0 && this.restore) {
+      this.restore?.();
+      this.restore = null;
+    }
+  };
+  lock(referenceElement) {
+    if (this.lockCount === 0 || this.restore !== null) {
+      return;
+    }
+    const doc = (0, import_owner.ownerDocument)(referenceElement);
+    const html = doc.documentElement;
+    const htmlOverflowY = (0, import_owner.ownerWindow)(html).getComputedStyle(html).overflowY;
+    if (htmlOverflowY === "hidden" || htmlOverflowY === "clip") {
+      this.restore = import_empty.NOOP;
+      return;
+    }
+    const hasOverlayScrollbars = import_platform.platform.os.ios || !hasInsetScrollbars(referenceElement);
+    this.restore = hasOverlayScrollbars ? preventScrollOverlayScrollbars(referenceElement) : preventScrollInsetScrollbars(referenceElement);
+  }
+}
+const SCROLL_LOCKER = new ScrollLocker();
+function useScrollLock(enabled, referenceElement, slot) {
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!enabled) {
+        return void 0;
+      }
+      return SCROLL_LOCKER.acquire(referenceElement);
+    },
+    [enabled, referenceElement],
+    slot
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useScrollLock
+});

package/dist/cjs/utils/useStableCallback.cjs

@@ -0,0 +1,41 @@
+"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 useStableCallback_exports = {};
+__export(useStableCallback_exports, {
+  useStableCallback: () => useStableCallback
+});
+module.exports = __toCommonJS(useStableCallback_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+function useStableCallback(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useStableCallback");
+  const callback = user[0];
+  const ref = (0, import_octane.useRef)(void 0, (0, import_internal.subSlot)(slot, "ref"));
+  ref.current = callback;
+  return (0, import_octane.useCallback)(
+    ((...a) => ref.current == null ? void 0 : ref.current(...a)),
+    [],
+    (0, import_internal.subSlot)(slot, "cb")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useStableCallback
+});