@ariakit/react-core 0.0.1 → 0.1.1

package/cjs/__chunks/W2ODSL37.cjs

@@ -0,0 +1,130 @@
+"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 _6622YWGRcjs = require('./6622YWGR.cjs');
+
+
+var _NVMBKFRBcjs = require('./NVMBKFRB.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+// src/composite/composite-typeahead.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+var _misc = require('@ariakit/core/utils/misc');
+var chars = "";
+function clearChars() {
+  chars = "";
+}
+function isValidTypeaheadEvent(event) {
+  const target = event.target;
+  if (target && _dom.isTextField.call(void 0, target))
+    return false;
+  if (event.key === " " && chars.length)
+    return true;
+  return event.key.length === 1 && !event.ctrlKey && !event.altKey && !event.metaKey && /^[\p{Letter}\p{Number}]$/u.test(event.key);
+}
+function isSelfTargetOrItem(event, items) {
+  if (_events.isSelfTarget.call(void 0, event))
+    return true;
+  const target = event.target;
+  if (!target)
+    return false;
+  const isItem = items.some((item) => item.element === target);
+  return isItem;
+}
+function getEnabledItems(items) {
+  return items.filter((item) => !item.disabled);
+}
+function itemTextStartsWith(item, text) {
+  const itemText = _optionalChain([item, 'access', _ => _.element, 'optionalAccess', _2 => _2.textContent]) || item.children;
+  if (!itemText)
+    return false;
+  return _misc.normalizeString.call(void 0, itemText).toLowerCase().startsWith(text.toLowerCase());
+}
+function getSameInitialItems(items, char, activeId) {
+  if (!activeId)
+    return items;
+  const activeItem = items.find((item) => item.id === activeId);
+  if (!activeItem)
+    return items;
+  if (!itemTextStartsWith(activeItem, char))
+    return items;
+  if (chars !== char && itemTextStartsWith(activeItem, chars))
+    return items;
+  chars = char;
+  return _6622YWGRcjs.flipItems.call(void 0, 
+    items.filter((item) => itemTextStartsWith(item, chars)),
+    activeId
+  ).filter((item) => item.id !== activeId);
+}
+var useCompositeTypeahead = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ store, typeahead = true, ...props }) => {
+    const context = _react.useContext.call(void 0, _NVMBKFRBcjs.CompositeContext);
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "CompositeTypeahead must be a Composite component"
+    );
+    const onKeyDownCaptureProp = props.onKeyDownCapture;
+    const cleanupTimeoutRef = _react.useRef.call(void 0, 0);
+    const onKeyDownCapture = _5QY4WCTRcjs.useEvent.call(void 0, 
+      (event) => {
+        _optionalChain([onKeyDownCaptureProp, 'optionalCall', _3 => _3(event)]);
+        if (event.defaultPrevented)
+          return;
+        if (!typeahead)
+          return;
+        if (!store)
+          return;
+        const { items, activeId } = store.getState();
+        if (!isValidTypeaheadEvent(event))
+          return clearChars();
+        let enabledItems = getEnabledItems(items);
+        if (!isSelfTargetOrItem(event, enabledItems))
+          return clearChars();
+        event.preventDefault();
+        window.clearTimeout(cleanupTimeoutRef.current);
+        cleanupTimeoutRef.current = window.setTimeout(() => {
+          chars = "";
+        }, 500);
+        const char = event.key.toLowerCase();
+        chars += char;
+        enabledItems = getSameInitialItems(enabledItems, char, activeId);
+        const item = enabledItems.find(
+          (item2) => itemTextStartsWith(item2, chars)
+        );
+        if (item) {
+          store.move(item.id);
+        } else {
+          clearChars();
+        }
+      }
+    );
+    props = {
+      ...props,
+      onKeyDownCapture
+    };
+    return props;
+  }
+);
+var CompositeTypeahead = _UYIFJ7U3cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCompositeTypeahead(props);
+    return _UYIFJ7U3cjs.createElement.call(void 0, "div", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CompositeTypeahead.displayName = "CompositeTypeahead";
+}
+
+
+
+
+exports.useCompositeTypeahead = useCompositeTypeahead; exports.CompositeTypeahead = CompositeTypeahead;

package/cjs/__chunks/W5PBA4D6.cjs

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

package/cjs/__chunks/WPKIYKH6.cjs

@@ -0,0 +1,290 @@
+"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 _OLGMV24Ucjs = require('./OLGMV24U.cjs');
+
+
+var _YAJKVIK2cjs = require('./YAJKVIK2.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+
+
+
+
+
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+// src/hovercard/hovercard.tsx
+
+
+
+
+
+
+
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+var _focus = require('@ariakit/core/utils/focus');
+var _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+function isMovingOnHovercard(target, card, anchor, nested) {
+  if (_focus.hasFocusWithin.call(void 0, card))
+    return true;
+  if (!target)
+    return false;
+  if (_dom.contains.call(void 0, card, target))
+    return true;
+  if (anchor && _dom.contains.call(void 0, anchor, target))
+    return true;
+  if (_optionalChain([nested, 'optionalAccess', _ => _.some, 'call', _2 => _2((card2) => isMovingOnHovercard(target, card2, anchor))])) {
+    return true;
+  }
+  return false;
+}
+function useAutoFocusOnShow({ store, ...props }) {
+  const open = store.useState("open");
+  const openRef = _5QY4WCTRcjs.useLiveRef.call(void 0, open);
+  _react.useEffect.call(void 0, () => {
+    if (!open) {
+      store.setAutoFocusOnShow(false);
+    }
+  }, [open, store]);
+  _react.useEffect.call(void 0, 
+    () => () => {
+      if (!openRef.current) {
+        store.setAutoFocusOnShow(false);
+      }
+    },
+    [store]
+  );
+  const modal = !!props.modal;
+  const autoFocusOnShow = store.useState(
+    (state) => modal || state.autoFocusOnShow
+  );
+  return { autoFocusOnShow, ...props };
+}
+function useAutoFocusOnHide({ store, ...props }) {
+  const [autoFocusOnHide, setAutoFocusOnHide] = _react.useState.call(void 0, false);
+  const mounted = store.useState("mounted");
+  _react.useEffect.call(void 0, () => {
+    if (!mounted) {
+      setAutoFocusOnHide(false);
+    }
+  }, [mounted]);
+  const onFocusProp = props.onFocus;
+  const onFocus = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+    _optionalChain([onFocusProp, 'optionalCall', _3 => _3(event)]);
+    if (event.defaultPrevented)
+      return;
+    setAutoFocusOnHide(true);
+  });
+  const finalFocusRef = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    return store.sync(
+      (state) => {
+        finalFocusRef.current = state.anchorElement;
+      },
+      ["anchorElement"]
+    );
+  }, []);
+  props = {
+    autoFocusOnHide,
+    finalFocus: finalFocusRef,
+    ...props,
+    onFocus
+  };
+  return props;
+}
+var NestedHovercardContext = _react.createContext.call(void 0, null);
+var useHovercard = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({
+    store,
+    modal = false,
+    portal = !!modal,
+    hideOnEscape = true,
+    hideOnControl = false,
+    hideOnHoverOutside = true,
+    disablePointerEventsOnApproach = !!hideOnHoverOutside,
+    ...props
+  }) => {
+    const ref = _react.useRef.call(void 0, null);
+    const [nestedHovercards, setNestedHovercards] = _react.useState.call(void 0, []);
+    const hideTimeoutRef = _react.useRef.call(void 0, 0);
+    const enterPointRef = _react.useRef.call(void 0, null);
+    const { portalRef, domReady } = _5QY4WCTRcjs.usePortalRef.call(void 0, portal, props.portalRef);
+    const hideOnEscapeProp = _5QY4WCTRcjs.useBooleanEvent.call(void 0, hideOnEscape);
+    const hideOnControlProp = _5QY4WCTRcjs.useBooleanEvent.call(void 0, hideOnControl);
+    const open = store.useState("open");
+    _react.useEffect.call(void 0, () => {
+      if (!open)
+        return;
+      return _events.addGlobalEventListener.call(void 0, "keydown", (event) => {
+        if (event.defaultPrevented)
+          return;
+        const isEscape = event.key === "Escape" && hideOnEscapeProp(event);
+        const isControl = event.key === "Control" && hideOnControlProp(event);
+        if (isEscape || isControl) {
+          store.hide();
+        }
+      });
+    }, [store, open, hideOnEscapeProp, hideOnControlProp]);
+    const mayHideOnHoverOutside = !!hideOnHoverOutside;
+    const hideOnHoverOutsideProp = _5QY4WCTRcjs.useBooleanEvent.call(void 0, hideOnHoverOutside);
+    const mayDisablePointerEvents = !!disablePointerEventsOnApproach;
+    const disablePointerEventsProp = _5QY4WCTRcjs.useBooleanEvent.call(void 0, 
+      disablePointerEventsOnApproach
+    );
+    const mounted = store.useState("mounted");
+    _react.useEffect.call(void 0, () => {
+      if (!domReady)
+        return;
+      if (!mounted)
+        return;
+      if (!mayHideOnHoverOutside && !mayDisablePointerEvents)
+        return;
+      const element = ref.current;
+      if (!element)
+        return;
+      const onMouseMove = (event) => {
+        const { anchorElement, hideTimeout } = store.getState();
+        const enterPoint = enterPointRef.current;
+        const target = event.target;
+        const anchor = anchorElement;
+        if (isMovingOnHovercard(target, element, anchor, nestedHovercards)) {
+          enterPointRef.current = target && anchor && _dom.contains.call(void 0, anchor, target) ? _OLGMV24Ucjs.getEventPoint.call(void 0, event) : null;
+          window.clearTimeout(hideTimeoutRef.current);
+          hideTimeoutRef.current = 0;
+          return;
+        }
+        if (hideTimeoutRef.current)
+          return;
+        if (enterPoint) {
+          const currentPoint = _OLGMV24Ucjs.getEventPoint.call(void 0, event);
+          const polygon = _OLGMV24Ucjs.getElementPolygon.call(void 0, element, enterPoint);
+          if (_OLGMV24Ucjs.isPointInPolygon.call(void 0, currentPoint, polygon)) {
+            enterPointRef.current = currentPoint;
+            if (!disablePointerEventsProp(event))
+              return;
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+          }
+        }
+        if (!hideOnHoverOutsideProp(event))
+          return;
+        hideTimeoutRef.current = window.setTimeout(() => {
+          hideTimeoutRef.current = 0;
+          store.hide();
+        }, hideTimeout);
+      };
+      return _events.addGlobalEventListener.call(void 0, "mousemove", onMouseMove, true);
+    }, [
+      store,
+      domReady,
+      mounted,
+      mayHideOnHoverOutside,
+      mayDisablePointerEvents,
+      nestedHovercards,
+      disablePointerEventsProp,
+      hideOnHoverOutsideProp
+    ]);
+    _react.useEffect.call(void 0, () => {
+      if (!domReady)
+        return;
+      if (!mounted)
+        return;
+      if (!mayDisablePointerEvents)
+        return;
+      const disableEvent = (event) => {
+        const element = ref.current;
+        if (!element)
+          return;
+        const enterPoint = enterPointRef.current;
+        if (!enterPoint)
+          return;
+        const polygon = _OLGMV24Ucjs.getElementPolygon.call(void 0, element, enterPoint);
+        if (_OLGMV24Ucjs.isPointInPolygon.call(void 0, _OLGMV24Ucjs.getEventPoint.call(void 0, event), polygon)) {
+          if (!disablePointerEventsProp(event))
+            return;
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      };
+      return _misc.chain.call(void 0, 
+        // Note: we may need to add pointer events here in the future.
+        _events.addGlobalEventListener.call(void 0, "mouseenter", disableEvent, true),
+        _events.addGlobalEventListener.call(void 0, "mouseover", disableEvent, true),
+        _events.addGlobalEventListener.call(void 0, "mouseout", disableEvent, true),
+        _events.addGlobalEventListener.call(void 0, "mouseleave", disableEvent, true)
+      );
+    }, [domReady, mounted, mayDisablePointerEvents, disablePointerEventsProp]);
+    const registerOnParent = _react.useContext.call(void 0, NestedHovercardContext);
+    _5QY4WCTRcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (modal)
+        return;
+      if (!portal)
+        return;
+      if (!mounted)
+        return;
+      if (!domReady)
+        return;
+      const element = ref.current;
+      if (!element)
+        return;
+      return _optionalChain([registerOnParent, 'optionalCall', _4 => _4(element)]);
+    }, [modal, portal, mounted, domReady]);
+    const registerNestedHovercard = _react.useCallback.call(void 0, 
+      (element) => {
+        setNestedHovercards((prevElements) => [...prevElements, element]);
+        const parentUnregister = _optionalChain([registerOnParent, 'optionalCall', _5 => _5(element)]);
+        return () => {
+          setNestedHovercards(
+            (prevElements) => prevElements.filter((item) => item !== element)
+          );
+          _optionalChain([parentUnregister, 'optionalCall', _6 => _6()]);
+        };
+      },
+      [registerOnParent]
+    );
+    props = _5QY4WCTRcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NestedHovercardContext.Provider, { value: registerNestedHovercard, children: element }),
+      [registerNestedHovercard]
+    );
+    props = {
+      ...props,
+      ref: _5QY4WCTRcjs.useForkRef.call(void 0, ref, props.ref)
+    };
+    props = useAutoFocusOnHide({ store, ...props });
+    props = useAutoFocusOnShow({ store, modal, ...props });
+    props = _YAJKVIK2cjs.usePopover.call(void 0, {
+      hideOnEscape,
+      store,
+      modal,
+      portal,
+      ...props,
+      portalRef
+    });
+    return props;
+  }
+);
+var Hovercard = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useHovercard(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Hovercard.displayName = "Hovercard";
+}
+
+
+
+
+exports.useHovercard = useHovercard; exports.Hovercard = Hovercard;

package/cjs/__chunks/WYGT6WVD.cjs

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+var _H5Z2A5K2cjs = require('./H5Z2A5K2.cjs');
+
+
+
+var _F6IOE5QTcjs = require('./F6IOE5QT.cjs');
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+// src/popover/popover-store.ts
+var _popoverstore = require('@ariakit/core/popover/popover-store'); var Core = _interopRequireWildcard(_popoverstore);
+function usePopoverStoreOptions(props) {
+  const getAnchorRect = _5QY4WCTRcjs.useEvent.call(void 0, props.getAnchorRect);
+  const renderCallback = _5QY4WCTRcjs.useEvent.call(void 0, props.renderCallback);
+  return {
+    ..._H5Z2A5K2cjs.useDialogStoreOptions.call(void 0, props),
+    getAnchorRect: props.getAnchorRect ? getAnchorRect : void 0,
+    renderCallback: props.renderCallback ? renderCallback : void 0
+  };
+}
+function usePopoverStoreProps(store, props) {
+  store = _H5Z2A5K2cjs.useDialogStoreProps.call(void 0, store, props);
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "placement");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "fixed");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "gutter");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "flip");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "shift");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "slide");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "overlap");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "sameWidth");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "fitViewport");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "arrowPadding");
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "overflowPadding");
+  return store;
+}
+function usePopoverStore(props = {}) {
+  const options = usePopoverStoreOptions(props);
+  const store = _F6IOE5QTcjs.useStore.call(void 0, 
+    () => Core.createPopoverStore({ ...props, ...options })
+  );
+  return usePopoverStoreProps(store, props);
+}
+
+
+
+
+
+exports.usePopoverStoreOptions = usePopoverStoreOptions; exports.usePopoverStoreProps = usePopoverStoreProps; exports.usePopoverStore = usePopoverStore;

package/cjs/__chunks/X2GXTE3P.cjs

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/dialog/utils/use-previous-mouse-down-ref.ts
+var _react = require('react');
+var _events = require('@ariakit/core/utils/events');
+function usePreviousMouseDownRef(enabled) {
+  const previousMouseDownRef = _react.useRef.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) {
+      previousMouseDownRef.current = null;
+      return;
+    }
+    const onMouseDown = (event) => {
+      previousMouseDownRef.current = event.target;
+    };
+    return _events.addGlobalEventListener.call(void 0, "mousedown", onMouseDown, true);
+  }, [enabled]);
+  return previousMouseDownRef;
+}
+
+
+
+exports.usePreviousMouseDownRef = usePreviousMouseDownRef;

package/cjs/__chunks/XFVLDGPP.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _YHG3KGFWcjs = require('./YHG3KGFW.cjs');
+
+// src/dialog/utils/disable-accessibility-tree-outside.ts
+function disableElement(element) {
+  const previousAriaHidden = element.getAttribute("aria-hidden") || "";
+  element.setAttribute("aria-hidden", "true");
+  const enableElement = () => {
+    if (previousAriaHidden) {
+      element.setAttribute("aria-hidden", previousAriaHidden);
+    } else {
+      element.removeAttribute("aria-hidden");
+    }
+  };
+  return enableElement;
+}
+function disableAccessibilityTreeOutside(...elements) {
+  const cleanups = [];
+  _YHG3KGFWcjs.walkTreeOutside.call(void 0, elements, (element) => {
+    cleanups.unshift(disableElement(element));
+  });
+  const restoreAccessibilityTree = () => {
+    cleanups.forEach((fn) => fn());
+  };
+  return restoreAccessibilityTree;
+}
+
+
+
+exports.disableAccessibilityTreeOutside = disableAccessibilityTreeOutside;