@dxos/react-ui-stack 0.8.4-main.f5c0578 → 0.8.4-main.fcc0d83b33

package/dist/lib/browser/index.mjs

@@ -1,75 +1,716 @@
-import {
-  Card,
-  CardDragPreview,
-  CardStack,
-  CardStackDragPreview,
-  DEFAULT_EXTRINSIC_SIZE,
-  DEFAULT_HORIZONTAL_SIZE,
-  DEFAULT_VERTICAL_SIZE,
-  Stack,
-  StackContext,
-  StackItem,
-  StackItemDragPreview,
-  autoScrollRootAttributes,
-  cardChrome,
-  cardDialogContent,
-  cardDialogHeader,
-  cardDialogOverflow,
-  cardDialogPaddedOverflow,
-  cardDialogSearchListRoot,
-  cardHeading,
-  cardNoSpacing,
-  cardRoot,
-  cardSpacing,
-  cardStackContent,
-  cardStackFooter,
-  cardStackHeading,
-  cardStackItem,
-  cardStackRoot,
-  cardText,
-  labelSpacing,
-  railGridHorizontal,
-  railGridHorizontalContainFitContent,
-  railGridVertical,
-  railGridVerticalContainFitContent,
-  translationKey,
-  translations
-} from "./chunk-WOG2GQRG.mjs";
+// src/components/Stack/Stack.tsx
+import { composeRefs } from "@radix-ui/react-compose-refs";
+import React, { Children, forwardRef, useCallback, useEffect, useState as useState2 } from "react";
+import { ListItem, useId } from "@dxos/react-ui";
+import { mx } from "@dxos/ui-theme";
+
+// src/hooks/useStackDropForElements.ts
+import { autoScrollForElements } from "@atlaskit/pragmatic-drag-and-drop-auto-scroll/element";
+import { attachClosestEdge, extractClosestEdge } from "@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge";
+import { combine } from "@atlaskit/pragmatic-drag-and-drop/combine";
+import { dropTargetForElements } from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
+import { useLayoutEffect, useState } from "react";
+var noop = () => {
+};
+var useStackDropForElements = ({ id, element, scrollElement = element, orientation, selfDroppable, onRearrange }) => {
+  const [dropping, setDropping] = useState(false);
+  useLayoutEffect(() => {
+    if (!element) {
+      return;
+    }
+    const acceptSourceType = orientation === "horizontal" ? "column" : "card";
+    return combine(selfDroppable ? dropTargetForElements({
+      element,
+      getData: ({ input, element: element2 }) => {
+        return attachClosestEdge({
+          id,
+          type: orientation === "horizontal" ? "card" : "column"
+        }, {
+          input,
+          element: element2,
+          allowedEdges: [
+            orientation === "horizontal" ? "left" : "top"
+          ]
+        });
+      },
+      onDragEnter: ({ source }) => {
+        if (source.data.type === acceptSourceType) {
+          setDropping(true);
+        }
+      },
+      onDrag: ({ source }) => {
+        if (source.data.type === acceptSourceType) {
+          setDropping(true);
+        }
+      },
+      onDragLeave: () => {
+        return setDropping(false);
+      },
+      onDrop: ({ self, source }) => {
+        setDropping(false);
+        if (source.data.type === acceptSourceType && selfDroppable && onRearrange) {
+          onRearrange(source.data, self.data, extractClosestEdge(self.data));
+        }
+      }
+    }) : noop, scrollElement ? autoScrollForElements({
+      element: scrollElement,
+      getAllowedAxis: () => orientation
+    }) : noop);
+  }, [
+    id,
+    element,
+    scrollElement,
+    selfDroppable,
+    orientation,
+    onRearrange
+  ]);
+  return {
+    dropping
+  };
+};
+
+// src/components/StackContext.tsx
+import { createContext, useContext } from "react";
+var StackContext = /* @__PURE__ */ createContext({
+  orientation: "vertical",
+  rail: true,
+  size: "intrinsic"
+});
+var useStack = () => useContext(StackContext);
+var idle = {
+  type: "idle"
+};
+var StackItemContext = /* @__PURE__ */ createContext({
+  selfDragHandleRef: () => {
+  },
+  size: "min-content",
+  setSize: () => {
+  },
+  state: idle,
+  setState: () => {
+  }
+});
+var useStackItem = () => useContext(StackItemContext);
+
+// src/components/Stack/Stack.tsx
+var railGridHorizontal = "grid-rows-[[rail-start]_var(--dx-rail-size)_[content-start]_1fr_[content-end]]";
+var railGridVertical = "grid-cols-[[rail-start]_var(--dx-rail-size)_[content-start]_1fr_[content-end]]";
+var PERPENDICULAR_FOCUS_THRESHHOLD = 128;
+var scrollIntoViewAndFocus = (el, orientation) => {
+  el.scrollIntoView({
+    behavior: "instant",
+    [orientation === "vertical" ? "block" : "inline"]: "center"
+  });
+  return el.focus();
+};
+var Stack = /* @__PURE__ */ forwardRef(({ children, classNames, id, style, orientation = "vertical", rail = true, size = "intrinsic", itemsCount = Children.count(children), circularFocus, separatorOnScroll, getDropElement, onBlur, onKeyDown, onRearrange, ...props }, forwardedRef) => {
+  const stackId = useId("stack", id);
+  const [stackElement, stackRef] = useState2(null);
+  const [lastFocusedItem, setLastFocusedItem] = useState2();
+  const composedItemRef = composeRefs(stackRef, forwardedRef);
+  const selfDroppable = !!(itemsCount < 1 && onRearrange && id);
+  const { dropping } = useStackDropForElements({
+    id,
+    element: getDropElement && stackElement ? getDropElement(stackElement) : stackElement,
+    scrollElement: stackElement,
+    selfDroppable,
+    orientation,
+    onRearrange
+  });
+  const handleScroll = useCallback(() => {
+    if (stackElement && Number.isFinite(separatorOnScroll)) {
+      const scrollPosition = orientation === "horizontal" ? stackElement.scrollLeft : stackElement.scrollTop;
+      const scrollSize = orientation === "horizontal" ? stackElement.scrollWidth : stackElement.scrollHeight;
+      const clientSize = orientation === "horizontal" ? stackElement.clientWidth : stackElement.clientHeight;
+      const separatorHost = stackElement.closest("[data-scroll-separator]");
+      if (separatorHost) {
+        separatorHost.setAttribute("data-scroll-separator", String(scrollPosition > separatorOnScroll));
+        separatorHost.setAttribute("data-scroll-separator-end", String(scrollSize - (scrollPosition + clientSize) > separatorOnScroll));
+      }
+    }
+  }, [
+    stackElement,
+    separatorOnScroll,
+    orientation
+  ]);
+  const handleBlur = useCallback((event) => {
+    if (event.target) {
+      const target = event.target;
+      const closestStackItem = target.closest(`[data-dx-item-id]`);
+      if (closestStackItem?.closest(`[data-dx-stack="${stackId}"]`)) {
+        setLastFocusedItem(closestStackItem?.getAttribute("data-dx-item-id") ?? void 0);
+      }
+    }
+    onBlur?.(event);
+  }, [
+    stackId,
+    onBlur
+  ]);
+  const handleKeyDown = useKeyDown(stackId, circularFocus, onKeyDown);
+  useEffect(() => {
+    if (!(stackElement && Number.isFinite(separatorOnScroll))) {
+      return;
+    }
+    const observer = new MutationObserver(() => {
+      handleScroll();
+    });
+    observer.observe(stackElement, {
+      childList: true,
+      subtree: true
+    });
+    return () => {
+      observer.disconnect();
+    };
+  }, [
+    stackElement,
+    handleScroll
+  ]);
+  return /* @__PURE__ */ React.createElement(StackContext.Provider, {
+    value: {
+      stackId,
+      orientation,
+      rail,
+      size,
+      onRearrange
+    }
+  }, /* @__PURE__ */ React.createElement("div", {
+    ...props,
+    ...Number.isFinite(separatorOnScroll) && {
+      onScroll: handleScroll
+    },
+    className: mx("relative grid [--stack-gap:var(--spacing-trim-xs)]", size === "contain" && (orientation === "horizontal" ? "overflow-x-auto overscroll-x-contain min-h-0 max-h-full h-full" : "overflow-y-auto min-w-0 max-w-full w-full"), rail ? orientation === "horizontal" ? railGridHorizontal : railGridVertical : orientation === "horizontal" ? "grid-rows-1 px-(--stack-gap)" : "grid-cols-1 py-(--stack-gap)", classNames),
+    style: {
+      [orientation === "horizontal" ? "gridTemplateColumns" : "gridTemplateRows"]: size === "split" ? `repeat(${itemsCount}, 1fr)` : `repeat(${itemsCount}, min-content) [tabster-dummies] 0`,
+      ...style
+    },
+    "aria-orientation": orientation,
+    "data-dx-stack": stackId,
+    "data-dx-stack-circular-focus": circularFocus,
+    "data-dx-last-focused-item": lastFocusedItem,
+    "data-rail": rail,
+    onBlur: handleBlur,
+    onKeyDown: handleKeyDown,
+    ref: composedItemRef
+  }, children, selfDroppable && dropping && /* @__PURE__ */ React.createElement(ListItem.DropIndicator, {
+    lineInset: 8,
+    terminalInset: -8,
+    gap: -8,
+    edge: orientation === "horizontal" ? "left" : "top"
+  })));
+});
+var useKeyDown = (stackId, circularFocus, onKeyDown) => useCallback((event) => {
+  const target = event.target;
+  if (event.key.startsWith("Arrow") && !target.closest(`input, textarea, [role="textbox"], [data-tabster*="mover"], [data-arrow-keys="all"], [data-arrow-keys~="${event.key.toLowerCase().slice(5)}"]`)) {
+    const closestOwnedItem = target.closest(`[data-dx-stack-item="${stackId}"]`);
+    const closestStack = target.closest("[data-dx-stack]");
+    const closestStackItems = Array.from(closestStack?.querySelectorAll(`[data-dx-stack-item="${stackId}"]`) ?? []);
+    const closestStackOrientation = closestStack?.getAttribute("aria-orientation");
+    const ancestorStack = closestStack?.parentElement?.closest("[data-dx-stack]");
+    if (closestOwnedItem && closestStack) {
+      const ancestorOrientation = ancestorStack?.getAttribute("aria-orientation");
+      const parallelDelta = (closestStackOrientation === "vertical" ? event.key === "ArrowUp" : event.key === "ArrowLeft") ? -1 : (closestStackOrientation === "vertical" ? event.key === "ArrowDown" : event.key === "ArrowRight") ? 1 : 0;
+      const perpendicularDelta = (closestStackOrientation === "vertical" ? event.key === "ArrowLeft" : event.key === "ArrowUp") ? -1 : (closestStackOrientation === "vertical" ? event.key === "ArrowRight" : event.key === "ArrowDown") ? 1 : 0;
+      if (parallelDelta !== 0) {
+        const currentIndex = closestStackItems.indexOf(closestOwnedItem);
+        const nextIndex = currentIndex + parallelDelta;
+        let adjacentItem;
+        if (circularFocus) {
+          adjacentItem = closestStackItems[(nextIndex + closestStackItems.length) % closestStackItems.length];
+        } else {
+          if (nextIndex >= 0 && nextIndex < closestStackItems.length) {
+            adjacentItem = closestStackItems[nextIndex];
+          }
+        }
+        if (adjacentItem) {
+          event.preventDefault();
+          scrollIntoViewAndFocus(adjacentItem, closestStackOrientation);
+        }
+      }
+      if (perpendicularDelta !== 0) {
+        if (ancestorStack && ancestorOrientation !== closestStackOrientation) {
+          const siblingStacks = Array.from(ancestorStack.querySelectorAll(`[data-dx-stack-item="${ancestorStack.getAttribute("data-dx-stack")}"] [data-dx-stack]`));
+          const currentStackIndex = siblingStacks.indexOf(closestStack);
+          const nextStackIndex = currentStackIndex + perpendicularDelta;
+          let adjacentStack;
+          if (ancestorStack.getAttribute("data-dx-stack-circular-focus") === "true") {
+            adjacentStack = siblingStacks[(nextStackIndex + siblingStacks.length) % siblingStacks.length];
+          } else {
+            if (nextStackIndex >= 0 && nextStackIndex < siblingStacks.length) {
+              adjacentStack = siblingStacks[nextStackIndex];
+            }
+          }
+          const adjacentStackSelfItem = adjacentStack?.closest(`[data-dx-stack-item=${ancestorStack.getAttribute("data-dx-stack")}]`);
+          const adjacentStackItems = adjacentStack ? Array.from(adjacentStack.querySelectorAll(`[data-dx-stack-item="${adjacentStack.getAttribute("data-dx-stack")}"]`)) : [];
+          if (adjacentStack && adjacentStackItems.length > 0) {
+            let closestItem = adjacentStackItems[0];
+            const lastFocusedItem = adjacentStack.querySelector(`[data-dx-item-id="${adjacentStack.getAttribute("data-dx-last-focused-item") ?? "never"}"]`);
+            if (lastFocusedItem) {
+              closestItem = lastFocusedItem;
+            } else {
+              const ownedItemRect = closestOwnedItem.getBoundingClientRect();
+              const targetPosition = closestStackOrientation === "vertical" ? ownedItemRect.top : ownedItemRect.left;
+              let closestDistance = Infinity;
+              for (const item of adjacentStackItems) {
+                const itemRect = item.getBoundingClientRect();
+                const itemPosition = closestStackOrientation === "vertical" ? itemRect.top : itemRect.left;
+                const distance = Math.abs(itemPosition - targetPosition);
+                if (distance < closestDistance) {
+                  closestDistance = distance;
+                  closestItem = item;
+                }
+                if (closestDistance <= PERPENDICULAR_FOCUS_THRESHHOLD) {
+                  break;
+                }
+              }
+            }
+            event.preventDefault();
+            scrollIntoViewAndFocus(closestItem, closestStackOrientation);
+          } else if (adjacentStackSelfItem) {
+            event.preventDefault();
+            scrollIntoViewAndFocus(adjacentStackSelfItem, ancestorOrientation);
+          }
+        } else if (closestOwnedItem) {
+          const closestOwnedItemStack = closestOwnedItem.querySelector("[data-dx-stack]");
+          const closestOwnedItemStackItems = closestOwnedItemStack ? Array.from(closestOwnedItemStack.querySelectorAll(`[data-dx-stack-item="${closestOwnedItemStack.getAttribute("data-dx-stack")}"]`)) : [];
+          if (closestOwnedItemStackItems.length > 0) {
+            event.preventDefault();
+            scrollIntoViewAndFocus(closestOwnedItemStackItems[[
+              "ArrowUp",
+              "ArrowLeft"
+            ].includes(event.key) ? closestOwnedItemStackItems.length - 1 : 0], closestOwnedItemStack?.getAttribute("aria-orientation"));
+          }
+        }
+      }
+    }
+  }
+  onKeyDown?.(event);
+}, [
+  onKeyDown,
+  stackId,
+  circularFocus
+]);
+
+// src/components/StackItem/StackItem.tsx
+import { attachClosestEdge as attachClosestEdge2, extractClosestEdge as extractClosestEdge2 } from "@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge";
+import { combine as combine2 } from "@atlaskit/pragmatic-drag-and-drop/combine";
+import { draggable, dropTargetForElements as dropTargetForElements2 } from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
+import { preserveOffsetOnSource } from "@atlaskit/pragmatic-drag-and-drop/element/preserve-offset-on-source";
+import { setCustomNativeDragPreview } from "@atlaskit/pragmatic-drag-and-drop/element/set-custom-native-drag-preview";
+import { useFocusableGroup } from "@fluentui/react-tabster";
+import { composeRefs as composeRefs2 } from "@radix-ui/react-compose-refs";
+import React8, { forwardRef as forwardRef5, useCallback as useCallback2, useLayoutEffect as useLayoutEffect2, useMemo as useMemo2, useState as useState4 } from "react";
+import { createPortal } from "react-dom";
+import { ListItem as ListItem2 } from "@dxos/react-ui";
+import { resizeAttributes, sizeStyle } from "@dxos/react-ui-dnd";
+import { mx as mx5 } from "@dxos/ui-theme";
+
+// src/components/StackItem/StackItemContent.tsx
+import React2, { forwardRef as forwardRef2, useMemo } from "react";
+import { mx as mx2 } from "@dxos/ui-theme";
+var StackItemContent = /* @__PURE__ */ forwardRef2(({ classNames, children, toolbar, statusbar, ...props }, forwardedRef) => {
+  const { size: stackItemSize } = useStack();
+  const { role } = useStackItem();
+  const style = useMemo(() => ({
+    gridTemplateRows: [
+      toolbar && role === "section" ? "calc(var(--dx-toolbar-size) - 1px)" : "var(--dx-toolbar-size)",
+      "1fr",
+      statusbar && "var(--dx-statusbar-size)"
+    ].filter(Boolean).join(" ")
+  }), [
+    toolbar,
+    statusbar
+  ]);
+  return /* @__PURE__ */ React2.createElement("div", {
+    ...props,
+    role: "none",
+    style,
+    className: mx2("group grid grid-cols-[100%] dx-density-coarse", stackItemSize === "contain" && "min-h-0 overflow-hidden", toolbar && role === "section" && "[&_.dx-toolbar]:sticky [&_.dx-toolbar]:z-[1] [&_.dx-toolbar]:top-0 [&_.dx-toolbar]:-mb-px [&_.dx-toolbar]:min-w-0", toolbar && "[&>.dx-toolbar]:relative [&>.dx-toolbar]:border-b [&>.dx-toolbar]:border-subdued-separator", classNames),
+    "data-popover-collision-boundary": true,
+    ref: forwardedRef
+  }, children);
+});
+StackItemContent.displayName = "StackItemContent";
+
+// src/components/StackItem/StackItemDragHandle.tsx
+import { Primitive } from "@radix-ui/react-primitive";
+import { Slot } from "@radix-ui/react-slot";
+import React3 from "react";
+var StackItemDragHandle = ({ asChild, children }) => {
+  const { selfDragHandleRef } = useStackItem();
+  const Comp = asChild ? Slot : Primitive.div;
+  return /* @__PURE__ */ React3.createElement(Comp, {
+    ref: selfDragHandleRef,
+    role: "button"
+  }, children);
+};
+
+// src/components/StackItem/StackItemHeading.tsx
+import { Primitive as Primitive2 } from "@radix-ui/react-primitive";
+import { Slot as Slot2 } from "@radix-ui/react-slot";
+import React4, { forwardRef as forwardRef3 } from "react";
+import { useAttention } from "@dxos/react-ui-attention";
+import { mx as mx3 } from "@dxos/ui-theme";
+var StackItemHeading = ({ children, classNames, asChild, separateOnScroll, role, ...props }) => {
+  const { orientation } = useStack();
+  const Comp = asChild ? Slot2 : Primitive2.div;
+  return /* @__PURE__ */ React4.createElement(Comp, {
+    ...props,
+    role: role ?? "heading",
+    className: mx3("flex items-center border-x-0! bg-header-surface", separateOnScroll ? 'border-transparent [[data-scroll-separator="true"]_&]:border-subdued-separator' : "border-subdued-separator", orientation === "horizontal" ? "h-(--dx-rail-size)" : "w-(--dx-rail-size) flex-col", orientation === "horizontal" ? "border-b" : "border-e", classNames)
+  }, children);
+};
+var StackItemHeadingStickyContent = ({ children }) => {
+  return /* @__PURE__ */ React4.createElement("div", {
+    role: "none",
+    className: "sticky top-0 bg-(--sticky-bg) p-1 w-full"
+  }, children);
+};
+var StackItemHeadingLabel = /* @__PURE__ */ forwardRef3(({ attendableId, related, classNames, ...props }, forwardedRef) => {
+  const { hasAttention, isAncestor, isRelated } = useAttention(attendableId);
+  return /* @__PURE__ */ React4.createElement("h1", {
+    ...props,
+    "data-attention": (related && isRelated || hasAttention || isAncestor).toString(),
+    className: mx3("px-1 min-w-0 w-0 grow truncate font-medium text-base-surface-text data-[attention=true]:text-accent-text self-center", classNames),
+    ref: forwardedRef
+  });
+});
+
+// src/components/StackItem/StackItemResizeHandle.tsx
+import React5 from "react";
+import { ResizeHandle } from "@dxos/react-ui-dnd";
+var MIN_WIDTH = 20;
+var MIN_HEIGHT = 3;
+var StackItemResizeHandle = (_) => {
+  const { orientation } = useStack();
+  const { setSize, size } = useStackItem();
+  return /* @__PURE__ */ React5.createElement(ResizeHandle, {
+    side: orientation === "horizontal" ? "inline-end" : "block-end",
+    fallbackSize: DEFAULT_EXTRINSIC_SIZE,
+    minSize: orientation === "horizontal" ? MIN_WIDTH : MIN_HEIGHT,
+    size,
+    onSizeChange: setSize
+  });
+};
+
+// src/components/StackItem/StackItemSigil.tsx
+import React7, { Fragment, forwardRef as forwardRef4, useState as useState3 } from "react";
+import { keySymbols } from "@dxos/keyboard";
+import { Button, DropdownMenu, Icon, toLocalizedString, useTranslation } from "@dxos/react-ui";
+import { useAttention as useAttention2 } from "@dxos/react-ui-attention";
+import { mx as mx4 } from "@dxos/ui-theme";
+import { getHostPlatform } from "@dxos/util";
+import { translationKey } from "#translations";
+
+// src/components/StackItem/MenuSignifier.tsx
+import React6 from "react";
+var MenuSignifierHorizontal = () => /* @__PURE__ */ React6.createElement("svg", {
+  className: "absolute bottom-[7px]",
+  width: 20,
+  height: 2,
+  viewBox: "0 0 20 2",
+  stroke: "currentColor",
+  opacity: 0.5
+}, /* @__PURE__ */ React6.createElement("line", {
+  x1: 0.5,
+  y1: 0.75,
+  x2: 19,
+  y2: 0.75,
+  strokeWidth: 1.25,
+  strokeLinecap: "round",
+  strokeDasharray: "6 20",
+  strokeDashoffset: "-6.5"
+}));
+
+// src/components/StackItem/StackItemSigil.tsx
+var StackItemSigilButton = /* @__PURE__ */ forwardRef4(({ attendableId, classNames, related, isMenu = true, children, ...props }, forwardedRef) => {
+  const { hasAttention, isAncestor, isRelated } = useAttention2(attendableId);
+  const variant = related && isRelated || hasAttention || isAncestor ? "primary" : "ghost";
+  return /* @__PURE__ */ React7.createElement(Button, {
+    ...props,
+    variant,
+    classNames: [
+      "shrink-0 px-0 min-h-0 w-(--dx-rail-action) h-(--dx-rail-action) relative dx-app-no-drag",
+      classNames
+    ],
+    ref: forwardedRef
+  }, isMenu && /* @__PURE__ */ React7.createElement(MenuSignifierHorizontal, null), children);
+});
+var StackItemSigil = /* @__PURE__ */ forwardRef4(({ actions: actionGroups, onAction, triggerLabel, attendableId, icon, related, children }, forwardedRef) => {
+  const { t } = useTranslation(translationKey);
+  const [optionsMenuOpen, setOptionsMenuOpen] = useState3(false);
+  const hasActions = actionGroups && actionGroups.length > 0;
+  const button = /* @__PURE__ */ React7.createElement(StackItemSigilButton, {
+    attendableId,
+    related,
+    isMenu: hasActions,
+    // TODO(wittjosiah): Better disabling of interactive styles when no action are available.
+    //   Remove underscore icon when no actions are available?
+    classNames: !hasActions && "cursor-default"
+  }, /* @__PURE__ */ React7.createElement("span", {
+    className: "sr-only"
+  }, triggerLabel), /* @__PURE__ */ React7.createElement(Icon, {
+    icon
+  }));
+  if (!hasActions) {
+    return button;
+  }
+  return /* @__PURE__ */ React7.createElement(DropdownMenu.Root, {
+    open: optionsMenuOpen,
+    onOpenChange: setOptionsMenuOpen
+  }, /* @__PURE__ */ React7.createElement(DropdownMenu.Trigger, {
+    asChild: true,
+    ref: forwardedRef
+  }, button), /* @__PURE__ */ React7.createElement(DropdownMenu.Portal, null, /* @__PURE__ */ React7.createElement(DropdownMenu.Content, {
+    classNames: "z-[31]"
+  }, /* @__PURE__ */ React7.createElement(DropdownMenu.Viewport, null, actionGroups?.map((actions, index) => {
+    const separator = index > 0 ? /* @__PURE__ */ React7.createElement(DropdownMenu.Separator, null) : null;
+    return /* @__PURE__ */ React7.createElement(Fragment, {
+      key: index
+    }, separator, actions.map((action) => {
+      const shortcut = typeof action.properties.keyBinding === "string" ? action.properties.keyBinding : action.properties.keyBinding?.[getHostPlatform()];
+      const menuItemType = action.properties.menuItemType;
+      const Root = menuItemType === "toggle" ? DropdownMenu.CheckboxItem : DropdownMenu.Item;
+      return /* @__PURE__ */ React7.createElement(Root, {
+        key: action.id,
+        onClick: (event) => {
+          if (action.properties.disabled) {
+            return;
+          }
+          event.stopPropagation();
+          setOptionsMenuOpen(false);
+          onAction?.(action);
+        },
+        classNames: "gap-2",
+        disabled: action.properties.disabled,
+        checked: menuItemType === "toggle" ? action.properties.isChecked : void 0,
+        ...action.properties?.testId && {
+          "data-testid": action.properties.testId
+        }
+      }, /* @__PURE__ */ React7.createElement(Icon, {
+        icon: action.properties.icon ?? "ph--placeholder--regular",
+        size: 4
+      }), /* @__PURE__ */ React7.createElement("span", {
+        className: "grow truncate"
+      }, toLocalizedString(action.properties.label ?? "", t)), menuItemType === "toggle" && /* @__PURE__ */ React7.createElement(DropdownMenu.ItemIndicator, {
+        asChild: true
+      }, /* @__PURE__ */ React7.createElement(Icon, {
+        icon: "ph--check--regular",
+        size: 4
+      })), shortcut && /* @__PURE__ */ React7.createElement("span", {
+        className: mx4("shrink-0", "text-description")
+      }, keySymbols(shortcut).join("")));
+    }));
+  }), children), /* @__PURE__ */ React7.createElement(DropdownMenu.Arrow, null))));
+});
+
+// src/components/StackItem/StackItem.tsx
+var DEFAULT_VERTICAL_SIZE = "min-content";
+var DEFAULT_HORIZONTAL_SIZE = 50;
+var DEFAULT_EXTRINSIC_SIZE = DEFAULT_HORIZONTAL_SIZE;
+var StackItemRoot = /* @__PURE__ */ forwardRef5(({ classNames, children, style, role, item, order, prevSiblingId, nextSiblingId, size: sizeProp, onSizeChange, disableRearrange, focusIndicatorVariant = "over-all", ...props }, forwardedRef) => {
+  const [itemElement, itemRef] = useState4(null);
+  const composedItemRef = composeRefs2(itemRef, forwardedRef);
+  const [selfDragHandleElement, selfDragHandleRef] = useState4(null);
+  const [closestEdge, setEdge] = useState4(null);
+  const [sourceId, setSourceId] = useState4(null);
+  const [dragState, setDragState] = useState4(idle);
+  const { orientation, rail, onRearrange, size: stackSize, stackId } = useStack();
+  const [size = orientation === "horizontal" ? DEFAULT_HORIZONTAL_SIZE : DEFAULT_VERTICAL_SIZE, setInternalSize] = useState4(sizeProp);
+  const Root = role ?? "div";
+  const setSize = useCallback2((nextSize, commit) => {
+    setInternalSize(nextSize);
+    if (commit) {
+      onSizeChange?.(nextSize);
+    }
+  }, [
+    onSizeChange
+  ]);
+  const type = orientation === "horizontal" ? "column" : "card";
+  useLayoutEffect2(() => {
+    if (!itemElement || !onRearrange || disableRearrange) {
+      return;
+    }
+    return combine2(draggable({
+      element: itemElement,
+      ...selfDragHandleElement && {
+        dragHandle: selfDragHandleElement
+      },
+      getInitialData: () => ({
+        id: item.id,
+        type
+      }),
+      onGenerateDragPreview: ({ nativeSetDragImage, source, location }) => {
+        document.body.setAttribute("data-drag-preview", "true");
+        const offsetFn = preserveOffsetOnSource({
+          element: source.element,
+          input: location.current.input
+        });
+        const rect = source.element.getBoundingClientRect();
+        setCustomNativeDragPreview({
+          nativeSetDragImage,
+          getOffset: ({ container }) => {
+            return offsetFn({
+              container
+            });
+          },
+          render: ({ container }) => {
+            container.style.width = rect.width + "px";
+            setDragState({
+              type: "preview",
+              container,
+              item
+            });
+            return () => {
+            };
+          }
+        });
+      },
+      onDragStart: () => {
+        document.body.removeAttribute("data-drag-preview");
+        itemElement?.closest("[data-drag-autoscroll]")?.setAttribute("data-drag-autoscroll", "active");
+        setDragState({
+          type: "is-dragging",
+          item
+        });
+      },
+      onDrop: () => {
+        itemElement?.closest("[data-drag-autoscroll]")?.setAttribute("data-drag-autoscroll", "idle");
+        setDragState(idle);
+      }
+    }), dropTargetForElements2({
+      element: itemElement,
+      getData: ({ input, element }) => {
+        return attachClosestEdge2({
+          id: item.id,
+          type
+        }, {
+          input,
+          element,
+          allowedEdges: orientation === "horizontal" ? [
+            "left",
+            "right"
+          ] : [
+            "top",
+            "bottom"
+          ]
+        });
+      },
+      onDragEnter: ({ self, source }) => {
+        if (source.data.type === self.data.type) {
+          setEdge(extractClosestEdge2(self.data));
+          setSourceId(source.data.id);
+        }
+      },
+      onDrag: ({ self, source }) => {
+        if (source.data.type === self.data.type) {
+          setEdge(extractClosestEdge2(self.data));
+          setSourceId(source.data.id);
+        }
+      },
+      onDragLeave: () => {
+        setEdge(null);
+        setSourceId(null);
+      },
+      onDrop: ({ self, source }) => {
+        setEdge(null);
+        setSourceId(null);
+        if (source.data.type === self.data.type) {
+          onRearrange(source.data, self.data, extractClosestEdge2(self.data));
+        }
+      }
+    }));
+  }, [
+    orientation,
+    item,
+    onRearrange,
+    selfDragHandleElement,
+    itemElement
+  ]);
+  const focusableGroupAttrs = useFocusableGroup({
+    tabBehavior: "limited"
+  });
+  const shouldShowDropIndicator = () => {
+    if (!closestEdge || !sourceId) {
+      return false;
+    }
+    if (sourceId === item.id) {
+      return false;
+    }
+    const isTrailingEdgeOfPrevSibling = prevSiblingId !== void 0 && sourceId === prevSiblingId && (orientation === "horizontal" && closestEdge === "left" || orientation === "vertical" && closestEdge === "top");
+    if (isTrailingEdgeOfPrevSibling) {
+      return false;
+    }
+    const isLeadingEdgeOfNextSibling = nextSiblingId !== void 0 && sourceId === nextSiblingId && (orientation === "horizontal" && closestEdge === "right" || orientation === "vertical" && closestEdge === "bottom");
+    if (isLeadingEdgeOfNextSibling) {
+      return false;
+    }
+    return true;
+  };
+  const stackItemContextValue = useMemo2(() => ({
+    selfDragHandleRef,
+    size,
+    setSize,
+    state: dragState,
+    setState: setDragState,
+    role
+  }), [
+    selfDragHandleRef,
+    size,
+    setSize,
+    dragState,
+    setDragState,
+    role
+  ]);
+  return /* @__PURE__ */ React8.createElement(StackItemContext.Provider, {
+    value: stackItemContextValue
+  }, /* @__PURE__ */ React8.createElement(Root, {
+    ...props,
+    tabIndex: 0,
+    ...focusableGroupAttrs,
+    className: mx5("group/stack-item grid relative", focusIndicatorVariant === "over-all" ? "dx-focus-ring-inset-over-all" : focusIndicatorVariant === "over-all-always" ? "dx-focus-ring-inset-over-all-always" : orientation === "horizontal" ? focusIndicatorVariant === "group-always" ? "dx-focus-ring-group-x-always" : "dx-focus-ring-group-x" : focusIndicatorVariant === "group-always" ? "dx-focus-ring-group-y-always" : "dx-focus-ring-group-y", orientation === "horizontal" ? "grid-rows-subgrid" : "grid-cols-subgrid", rail && (orientation === "horizontal" ? "row-span-2" : "col-span-2"), role === "section" && orientation !== "horizontal" && "border-b border-subdued-separator", classNames),
+    "data-dx-stack-item": stackId,
+    "data-dx-item-id": item.id,
+    ...resizeAttributes,
+    style: {
+      ...stackSize !== "split" && sizeStyle(size, orientation),
+      ...Number.isFinite(order) && {
+        [orientation === "horizontal" ? "gridColumn" : "gridRow"]: `${order}`
+      },
+      ...style
+    },
+    ref: composedItemRef
+  }, children, shouldShowDropIndicator() && closestEdge && /* @__PURE__ */ React8.createElement(ListItem2.DropIndicator, {
+    lineInset: 8,
+    terminalInset: -8,
+    edge: closestEdge
+  })));
+});
+var StackItemDragPreview = ({ children }) => {
+  const { state } = useStackItem();
+  return state?.type === "preview" ? /* @__PURE__ */ createPortal(children({
+    item: state.item
+  }), state.container) : null;
+};
+var StackItem = {
+  Root: StackItemRoot,
+  Content: StackItemContent,
+  DragHandle: StackItemDragHandle,
+  DragPreview: StackItemDragPreview,
+  Heading: StackItemHeading,
+  HeadingLabel: StackItemHeadingLabel,
+  HeadingStickyContent: StackItemHeadingStickyContent,
+  ResizeHandle: StackItemResizeHandle,
+  Sigil: StackItemSigil,
+  SigilButton: StackItemSigilButton
+};
 export {
-  Card,
-  CardDragPreview,
-  CardStack,
-  CardStackDragPreview,
   DEFAULT_EXTRINSIC_SIZE,
   DEFAULT_HORIZONTAL_SIZE,
   DEFAULT_VERTICAL_SIZE,
   Stack,
   StackContext,
   StackItem,
-  StackItemDragPreview,
-  autoScrollRootAttributes,
-  cardChrome,
-  cardDialogContent,
-  cardDialogHeader,
-  cardDialogOverflow,
-  cardDialogPaddedOverflow,
-  cardDialogSearchListRoot,
-  cardHeading,
-  cardNoSpacing,
-  cardRoot,
-  cardSpacing,
-  cardStackContent,
-  cardStackFooter,
-  cardStackHeading,
-  cardStackItem,
-  cardStackRoot,
-  cardText,
-  labelSpacing,
   railGridHorizontal,
-  railGridHorizontalContainFitContent,
-  railGridVertical,
-  railGridVerticalContainFitContent,
-  translationKey,
-  translations
+  railGridVertical
 };
 //# sourceMappingURL=index.mjs.map