@stevederico/skateboard-ui 3.0.1 → 3.6.0

package/index.js

@@ -1,3 +1,3 @@
 export { default as ProtectedRoute } from "./components/ProtectedRoute";
-export { isAuthenticated, getAppKey, getCSRFToken, getCurrentUser, useAppSetup } from "./core/Utilities";
+export { isAuthenticated, getAppKey, getCSRFToken, getCurrentUser, useAppSetup } from "./components/core/Utilities";
 export { createSkateboardApp } from "./App.jsx";

package/package.json

@@ -1,68 +1,68 @@
 {
   "name": "@stevederico/skateboard-ui",
   "private": false,
-  "version": "3.0.1",
+  "version": "3.6.0",
   "type": "module",
   "exports": {
     "./Sidebar": {
-      "import": "./layout/Sidebar.jsx",
-      "default": "./layout/Sidebar.jsx"
+      "import": "./components/layout/Sidebar.jsx",
+      "default": "./components/layout/Sidebar.jsx"
     },
     "./DynamicIcon": {
-      "import": "./core/DynamicIcon.jsx",
-      "default": "./core/DynamicIcon.jsx"
+      "import": "./components/core/DynamicIcon.jsx",
+      "default": "./components/core/DynamicIcon.jsx"
     },
     "./ErrorBoundary": {
       "import": "./components/ErrorBoundary.jsx",
       "default": "./components/ErrorBoundary.jsx"
     },
     "./Header": {
-      "import": "./layout/Header.jsx",
-      "default": "./layout/Header.jsx"
+      "import": "./components/layout/Header.jsx",
+      "default": "./components/layout/Header.jsx"
     },
     "./LandingView": {
-      "import": "./views/LandingView.jsx",
-      "default": "./views/LandingView.jsx"
+      "import": "./components/views/LandingView.jsx",
+      "default": "./components/views/LandingView.jsx"
     },
     "./Layout": {
-      "import": "./layout/Layout.jsx",
-      "default": "./layout/Layout.jsx"
+      "import": "./components/layout/Layout.jsx",
+      "default": "./components/layout/Layout.jsx"
     },
     "./NotFound": {
-      "import": "./views/NotFound.jsx",
-      "default": "./views/NotFound.jsx"
+      "import": "./components/views/NotFound.jsx",
+      "default": "./components/views/NotFound.jsx"
     },
     "./SettingsView": {
-      "import": "./views/SettingsView.jsx",
-      "default": "./views/SettingsView.jsx"
+      "import": "./components/views/SettingsView.jsx",
+      "default": "./components/views/SettingsView.jsx"
     },
     "./Sheet": {
       "import": "./components/Sheet.jsx",
       "default": "./components/Sheet.jsx"
     },
     "./SignInView": {
-      "import": "./views/SignInView.jsx",
-      "default": "./views/SignInView.jsx"
+      "import": "./components/views/SignInView.jsx",
+      "default": "./components/views/SignInView.jsx"
     },
     "./SignUpView": {
-      "import": "./views/SignUpView.jsx",
-      "default": "./views/SignUpView.jsx"
+      "import": "./components/views/SignUpView.jsx",
+      "default": "./components/views/SignUpView.jsx"
     },
     "./SignOutView": {
-      "import": "./views/SignOutView.jsx",
-      "default": "./views/SignOutView.jsx"
+      "import": "./components/views/SignOutView.jsx",
+      "default": "./components/views/SignOutView.jsx"
     },
     "./PaymentView": {
-      "import": "./views/PaymentView.jsx",
-      "default": "./views/PaymentView.jsx"
+      "import": "./components/views/PaymentView.jsx",
+      "default": "./components/views/PaymentView.jsx"
     },
     "./TabBar": {
-      "import": "./layout/TabBar.jsx",
-      "default": "./layout/TabBar.jsx"
+      "import": "./components/layout/TabBar.jsx",
+      "default": "./components/layout/TabBar.jsx"
     },
     "./TextView": {
-      "import": "./views/TextView.jsx",
-      "default": "./views/TextView.jsx"
+      "import": "./components/views/TextView.jsx",
+      "default": "./components/views/TextView.jsx"
     },
     "./ThemeToggle": {
       "import": "./components/ThemeToggle.jsx",
@@ -73,8 +73,8 @@
       "default": "./components/UpgradeSheet.jsx"
     },
     "./Utilities": {
-      "import": "./core/Utilities.js",
-      "default": "./core/Utilities.js"
+      "import": "./components/core/Utilities.js",
+      "default": "./components/core/Utilities.js"
     },
     "./ProtectedRoute": {
       "import": "./components/ProtectedRoute.jsx",
@@ -85,8 +85,8 @@
       "default": "./styles.css"
     },
     "./Context": {
-      "import": "./core/Context.jsx",
-      "default": "./core/Context.jsx"
+      "import": "./components/core/Context.jsx",
+      "default": "./components/core/Context.jsx"
     },
     "./App": {
       "import": "./App.jsx",
@@ -118,6 +118,17 @@
   "scripts": {
     "prod": "npm publish"
   },
+  "files": [
+    "App.jsx",
+    "index.js",
+    "styles.css",
+    "CHANGELOG.md",
+    "README.md",
+    "components",
+    "shadcn",
+    "hooks",
+    "fonts"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -126,23 +137,9 @@
     "type": "git",
     "url": "git+https://github.com/stevederico/skateboard-ui.git"
   },
-  "dependencies": {
-    "@base-ui/react": "^1.4.1",
-    "use-sync-external-store": "^1.6.0",
-    "tailwind-merge": "^3.5.0",
-    "vaul": "^1.1.2"
-  },
   "peerDependencies": {
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
-    "react-router-dom": "^7.0.0",
-    "embla-carousel-react": "^8.6.0",
-    "react-resizable-panels": "^4.10.0",
-    "recharts": "^3.8.1"
-  },
-  "peerDependenciesMeta": {
-    "embla-carousel-react": { "optional": true },
-    "react-resizable-panels": { "optional": true },
-    "recharts": { "optional": true }
+    "react-router-dom": "^7.0.0"
   }
 }

package/shadcn/lib/base-ui/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Material-UI SAS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/shadcn/lib/base-ui/_chunk-01rqe37g.js

@@ -0,0 +1,70 @@
+import {
+  error
+} from "./_chunk-71zm6zgv.js";
+
+// node_modules/.deno/@base-ui+utils@0.2.8/node_modules/@base-ui/utils/esm/useControlled.js
+import * as React from "react";
+"use client";
+function useControlled({
+  controlled,
+  default: defaultProp,
+  name,
+  state = "value"
+}) {
+  const {
+    current: isControlled
+  } = React.useRef(controlled !== undefined);
+  const [valueState, setValue] = React.useState(defaultProp);
+  const value = isControlled ? controlled : valueState;
+  if (true) {
+    React.useEffect(() => {
+      if (isControlled !== (controlled !== undefined)) {
+        error([`A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${name} ` + "element for the lifetime of the component.", "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+      }
+    }, [state, name, controlled]);
+    const {
+      current: defaultValue
+    } = React.useRef(defaultProp);
+    React.useEffect(() => {
+      if (!isControlled && serializeToDevModeString(defaultValue) !== serializeToDevModeString(defaultProp)) {
+        error([`A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. ` + `To suppress this warning opt to use a controlled ${name}.`].join(`
+`));
+      }
+    }, [defaultProp]);
+  }
+  const setValueIfUncontrolled = React.useCallback((newValue) => {
+    if (!isControlled) {
+      setValue(newValue);
+    }
+  }, []);
+  return [value, setValueIfUncontrolled];
+}
+function serializeToDevModeString(input) {
+  let nextId = 0;
+  const seen = new WeakMap;
+  try {
+    const result = JSON.stringify(input, function replacer(key, value) {
+      if (key === "_owner" && this != null && typeof this === "object" && "$$typeof" in this) {
+        return;
+      }
+      if (typeof value === "bigint") {
+        return `__bigint__:${value}`;
+      }
+      if (value !== null && typeof value === "object") {
+        const id = seen.get(value);
+        if (id !== undefined) {
+          return `__object__:${id}`;
+        }
+        seen.set(value, nextId);
+        nextId += 1;
+      }
+      return value;
+    });
+    return result ?? `__top__:${typeof input}`;
+  } catch {
+    return "__unserializable__";
+  }
+}
+
+export { useControlled };

package/shadcn/lib/base-ui/_chunk-0h5sskyw.js

@@ -0,0 +1,347 @@
+import {
+  ACTIVE_COMPOSITE_ITEM
+} from "./_chunk-r0vsdknk.js";
+import {
+  isElementDisabled
+} from "./_chunk-vdc01ss3.js";
+import {
+  CompositeList
+} from "./_chunk-p6qynd6r.js";
+import {
+  useDirection
+} from "./_chunk-wtw745qd.js";
+import {
+  getTarget
+} from "./_chunk-atnkefgd.js";
+import {
+  ALL_KEYS,
+  ARROW_DOWN,
+  ARROW_KEYS,
+  ARROW_LEFT,
+  ARROW_RIGHT,
+  ARROW_UP,
+  END,
+  HOME,
+  HORIZONTAL_KEYS,
+  HORIZONTAL_KEYS_WITH_EXTRA_KEYS,
+  MODIFIER_KEYS,
+  VERTICAL_KEYS,
+  VERTICAL_KEYS_WITH_EXTRA_KEYS,
+  isNativeInput,
+  scrollIntoViewIfNeeded
+} from "./_chunk-qce0xt57.js";
+import {
+  createGridCellMap,
+  findNonDisabledListIndex,
+  getGridCellIndexOfCorner,
+  getGridCellIndices,
+  getGridNavigatedIndex,
+  getMaxListIndex,
+  getMinListIndex,
+  isIndexOutOfListBounds,
+  isListIndexDisabled
+} from "./_chunk-nya71ccw.js";
+import {
+  CompositeRootContext
+} from "./_chunk-6xevjepc.js";
+import {
+  useStableCallback
+} from "./_chunk-mznt6ktj.js";
+import {
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
+  useMergedRefs,
+  useRenderElement
+} from "./_chunk-1s41sngz.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/internals/composite/root/CompositeRoot.js
+import * as React2 from "react";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/internals/composite/root/useCompositeRoot.js
+import * as React from "react";
+"use client";
+var EMPTY_ARRAY2 = [];
+function useCompositeRoot(params) {
+  const {
+    itemSizes,
+    cols = 1,
+    loopFocus = true,
+    onLoop,
+    dense = false,
+    orientation = "both",
+    direction,
+    highlightedIndex: externalHighlightedIndex,
+    onHighlightedIndexChange: externalSetHighlightedIndex,
+    rootRef: externalRef,
+    enableHomeAndEndKeys = false,
+    stopEventPropagation = false,
+    disabledIndices,
+    modifierKeys = EMPTY_ARRAY2
+  } = params;
+  const [internalHighlightedIndex, internalSetHighlightedIndex] = React.useState(0);
+  const isGrid = cols > 1;
+  const rootRef = React.useRef(null);
+  const mergedRef = useMergedRefs(rootRef, externalRef);
+  const elementsRef = React.useRef([]);
+  const hasSetDefaultIndexRef = React.useRef(false);
+  const highlightedIndex = externalHighlightedIndex ?? internalHighlightedIndex;
+  const onHighlightedIndexChange = useStableCallback((index, shouldScrollIntoView = false) => {
+    (externalSetHighlightedIndex ?? internalSetHighlightedIndex)(index);
+    if (shouldScrollIntoView) {
+      const newActiveItem = elementsRef.current[index];
+      scrollIntoViewIfNeeded(rootRef.current, newActiveItem, direction, orientation);
+    }
+  });
+  const onMapChange = useStableCallback((map) => {
+    if (map.size === 0 || hasSetDefaultIndexRef.current) {
+      return;
+    }
+    hasSetDefaultIndexRef.current = true;
+    const sortedElements = Array.from(map.keys());
+    const activeItem = sortedElements.find((compositeElement) => compositeElement?.hasAttribute(ACTIVE_COMPOSITE_ITEM)) ?? null;
+    const activeIndex = activeItem ? sortedElements.indexOf(activeItem) : -1;
+    if (activeIndex !== -1) {
+      onHighlightedIndexChange(activeIndex);
+    }
+    scrollIntoViewIfNeeded(rootRef.current, activeItem, direction, orientation);
+  });
+  const wrappedOnLoop = useStableCallback((event, prevIndex, nextIndex) => {
+    if (!onLoop) {
+      return nextIndex;
+    }
+    return onLoop?.(event, prevIndex, nextIndex, elementsRef);
+  });
+  const props = React.useMemo(() => ({
+    "aria-orientation": orientation === "both" ? undefined : orientation,
+    ref: mergedRef,
+    onFocus(event) {
+      const element = rootRef.current;
+      const target = getTarget(event.nativeEvent);
+      if (!element || target == null || !isNativeInput(target)) {
+        return;
+      }
+      target.setSelectionRange(0, target.value.length ?? 0);
+    },
+    onKeyDown(event) {
+      const RELEVANT_KEYS = enableHomeAndEndKeys ? ALL_KEYS : ARROW_KEYS;
+      if (!RELEVANT_KEYS.has(event.key)) {
+        return;
+      }
+      if (isModifierKeySet(event, modifierKeys)) {
+        return;
+      }
+      const element = rootRef.current;
+      if (!element) {
+        return;
+      }
+      const isRtl = direction === "rtl";
+      const horizontalForwardKey = isRtl ? ARROW_LEFT : ARROW_RIGHT;
+      const forwardKey = {
+        horizontal: horizontalForwardKey,
+        vertical: ARROW_DOWN,
+        both: horizontalForwardKey
+      }[orientation];
+      const horizontalBackwardKey = isRtl ? ARROW_RIGHT : ARROW_LEFT;
+      const backwardKey = {
+        horizontal: horizontalBackwardKey,
+        vertical: ARROW_UP,
+        both: horizontalBackwardKey
+      }[orientation];
+      const target = getTarget(event.nativeEvent);
+      if (target != null && isNativeInput(target) && !isElementDisabled(target)) {
+        const selectionStart = target.selectionStart;
+        const selectionEnd = target.selectionEnd;
+        const textContent = target.value ?? "";
+        if (selectionStart == null || event.shiftKey || selectionStart !== selectionEnd) {
+          return;
+        }
+        if (event.key !== backwardKey && selectionStart < textContent.length) {
+          return;
+        }
+        if (event.key !== forwardKey && selectionStart > 0) {
+          return;
+        }
+      }
+      let nextIndex = highlightedIndex;
+      const minIndex = getMinListIndex(elementsRef, disabledIndices);
+      const maxIndex = getMaxListIndex(elementsRef, disabledIndices);
+      if (isGrid) {
+        const sizes = itemSizes || Array.from({
+          length: elementsRef.current.length
+        }, () => ({
+          width: 1,
+          height: 1
+        }));
+        const cellMap = createGridCellMap(sizes, cols, dense);
+        const minGridIndex = cellMap.findIndex((index) => index != null && !isListIndexDisabled(elementsRef.current, index, disabledIndices));
+        const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isListIndexDisabled(elementsRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);
+        nextIndex = cellMap[getGridNavigatedIndex(cellMap.map((itemIndex) => itemIndex != null ? elementsRef.current[itemIndex] : null), {
+          event,
+          orientation,
+          loopFocus,
+          onLoop: wrappedOnLoop,
+          cols,
+          disabledIndices: getGridCellIndices([...disabledIndices || elementsRef.current.map((_, index) => isListIndexDisabled(elementsRef.current, index) ? index : undefined), undefined], cellMap),
+          minIndex: minGridIndex,
+          maxIndex: maxGridIndex,
+          prevIndex: getGridCellIndexOfCorner(highlightedIndex > maxIndex ? minIndex : highlightedIndex, sizes, cellMap, cols, event.key === ARROW_DOWN ? "bl" : event.key === ARROW_RIGHT ? "tr" : "tl"),
+          rtl: isRtl
+        })];
+      }
+      const forwardKeys = {
+        horizontal: [horizontalForwardKey],
+        vertical: [ARROW_DOWN],
+        both: [horizontalForwardKey, ARROW_DOWN]
+      }[orientation];
+      const backwardKeys = {
+        horizontal: [horizontalBackwardKey],
+        vertical: [ARROW_UP],
+        both: [horizontalBackwardKey, ARROW_UP]
+      }[orientation];
+      const preventedKeys = isGrid ? RELEVANT_KEYS : {
+        horizontal: enableHomeAndEndKeys ? HORIZONTAL_KEYS_WITH_EXTRA_KEYS : HORIZONTAL_KEYS,
+        vertical: enableHomeAndEndKeys ? VERTICAL_KEYS_WITH_EXTRA_KEYS : VERTICAL_KEYS,
+        both: RELEVANT_KEYS
+      }[orientation];
+      if (enableHomeAndEndKeys) {
+        if (event.key === HOME) {
+          nextIndex = minIndex;
+        } else if (event.key === END) {
+          nextIndex = maxIndex;
+        }
+      }
+      if (nextIndex === highlightedIndex && (forwardKeys.includes(event.key) || backwardKeys.includes(event.key))) {
+        if (loopFocus && nextIndex === maxIndex && forwardKeys.includes(event.key)) {
+          nextIndex = minIndex;
+          if (onLoop) {
+            nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef);
+          }
+        } else if (loopFocus && nextIndex === minIndex && backwardKeys.includes(event.key)) {
+          nextIndex = maxIndex;
+          if (onLoop) {
+            nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef);
+          }
+        } else {
+          nextIndex = findNonDisabledListIndex(elementsRef.current, {
+            startingIndex: nextIndex,
+            decrement: backwardKeys.includes(event.key),
+            disabledIndices
+          });
+        }
+      }
+      if (nextIndex !== highlightedIndex && !isIndexOutOfListBounds(elementsRef.current, nextIndex)) {
+        if (stopEventPropagation) {
+          event.stopPropagation();
+        }
+        if (preventedKeys.has(event.key)) {
+          event.preventDefault();
+        }
+        onHighlightedIndexChange(nextIndex, true);
+        queueMicrotask(() => {
+          elementsRef.current[nextIndex]?.focus();
+        });
+      }
+    }
+  }), [cols, dense, direction, disabledIndices, elementsRef, enableHomeAndEndKeys, highlightedIndex, isGrid, itemSizes, loopFocus, onLoop, wrappedOnLoop, mergedRef, modifierKeys, onHighlightedIndexChange, orientation, stopEventPropagation]);
+  return React.useMemo(() => ({
+    props,
+    highlightedIndex,
+    onHighlightedIndexChange,
+    elementsRef,
+    disabledIndices,
+    onMapChange,
+    relayKeyboardEvent: props.onKeyDown
+  }), [props, highlightedIndex, onHighlightedIndexChange, elementsRef, disabledIndices, onMapChange]);
+}
+function isModifierKeySet(event, ignoredModifierKeys) {
+  for (const key of MODIFIER_KEYS.values()) {
+    if (ignoredModifierKeys.includes(key)) {
+      continue;
+    }
+    if (event.getModifierState(key)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/internals/composite/root/CompositeRoot.js
+import { jsx as _jsx } from "react/jsx-runtime";
+"use client";
+function CompositeRoot(componentProps) {
+  const {
+    render,
+    className,
+    style,
+    refs = EMPTY_ARRAY,
+    props = EMPTY_ARRAY,
+    state = EMPTY_OBJECT,
+    stateAttributesMapping,
+    highlightedIndex: highlightedIndexProp,
+    onHighlightedIndexChange: onHighlightedIndexChangeProp,
+    orientation,
+    dense,
+    itemSizes,
+    loopFocus,
+    onLoop,
+    cols,
+    enableHomeAndEndKeys,
+    onMapChange: onMapChangeProp,
+    stopEventPropagation = true,
+    rootRef,
+    disabledIndices,
+    modifierKeys,
+    highlightItemOnHover = false,
+    tag = "div",
+    ...elementProps
+  } = componentProps;
+  const direction = useDirection();
+  const {
+    props: defaultProps,
+    highlightedIndex,
+    onHighlightedIndexChange,
+    elementsRef,
+    onMapChange: onMapChangeUnwrapped,
+    relayKeyboardEvent
+  } = useCompositeRoot({
+    itemSizes,
+    cols,
+    loopFocus,
+    onLoop,
+    dense,
+    orientation,
+    highlightedIndex: highlightedIndexProp,
+    onHighlightedIndexChange: onHighlightedIndexChangeProp,
+    rootRef,
+    stopEventPropagation,
+    enableHomeAndEndKeys,
+    direction,
+    disabledIndices,
+    modifierKeys
+  });
+  const element = useRenderElement(tag, componentProps, {
+    state,
+    ref: refs,
+    props: [defaultProps, ...props, elementProps],
+    stateAttributesMapping
+  });
+  const contextValue = React2.useMemo(() => ({
+    highlightedIndex,
+    onHighlightedIndexChange,
+    highlightItemOnHover,
+    relayKeyboardEvent
+  }), [highlightedIndex, onHighlightedIndexChange, highlightItemOnHover, relayKeyboardEvent]);
+  return /* @__PURE__ */ _jsx(CompositeRootContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ _jsx(CompositeList, {
+      elementsRef,
+      onMapChange: (newMap) => {
+        onMapChangeProp?.(newMap);
+        onMapChangeUnwrapped(newMap);
+      },
+      children: element
+    })
+  });
+}
+
+export { CompositeRoot };

package/shadcn/lib/base-ui/_chunk-0xhx4g7r.js

@@ -0,0 +1,57 @@
+import {
+  getNextTabbable,
+  getTabbableAfterElement,
+  getTabbableBeforeElement,
+  isOutsideEvent
+} from "./_chunk-2tyt8f8r.js";
+import {
+  contains
+} from "./_chunk-atnkefgd.js";
+import {
+  createChangeEventDetails,
+  exports_reason_parts
+} from "./_chunk-4s0k3h7t.js";
+import {
+  useStableCallback
+} from "./_chunk-mznt6ktj.js";
+
+// node_modules/.deno/@base-ui+react@1.4.1/node_modules/@base-ui/react/esm/utils/popups/useTriggerFocusGuards.js
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+"use client";
+function useTriggerFocusGuards(store, triggerElementRef) {
+  const preFocusGuardRef = React.useRef(null);
+  const handlePreFocusGuardFocus = useStableCallback((event) => {
+    ReactDOM.flushSync(() => {
+      store.setOpen(false, createChangeEventDetails(exports_reason_parts.focusOut, event.nativeEvent, event.currentTarget));
+    });
+    const previousTabbable = getTabbableBeforeElement(preFocusGuardRef.current);
+    previousTabbable?.focus();
+  });
+  const handleFocusTargetFocus = useStableCallback((event) => {
+    const positionerElement = store.select("positionerElement");
+    if (positionerElement && isOutsideEvent(event, positionerElement)) {
+      store.context.beforeContentFocusGuardRef.current?.focus();
+    } else {
+      ReactDOM.flushSync(() => {
+        store.setOpen(false, createChangeEventDetails(exports_reason_parts.focusOut, event.nativeEvent, event.currentTarget));
+      });
+      let nextTabbable = getTabbableAfterElement(store.context.triggerFocusTargetRef.current || triggerElementRef.current);
+      while (nextTabbable !== null && contains(positionerElement, nextTabbable)) {
+        const prevTabbable = nextTabbable;
+        nextTabbable = getNextTabbable(nextTabbable);
+        if (nextTabbable === prevTabbable) {
+          break;
+        }
+      }
+      nextTabbable?.focus();
+    }
+  });
+  return {
+    preFocusGuardRef,
+    handlePreFocusGuardFocus,
+    handleFocusTargetFocus
+  };
+}
+
+export { useTriggerFocusGuards };