@octanejs/radix 0.1.31 → 0.1.33

package/dist/cjs/ContextMenu.cjs

@@ -0,0 +1,315 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ContextMenu_exports = {};
+__export(ContextMenu_exports, {
+  Arrow: () => Arrow,
+  CheckboxItem: () => CheckboxItem,
+  Content: () => Content,
+  ContextMenu: () => Root,
+  ContextMenuContent: () => Content,
+  ContextMenuItem: () => Item,
+  ContextMenuTrigger: () => Trigger,
+  Group: () => Group,
+  Item: () => Item,
+  ItemIndicator: () => ItemIndicator,
+  Label: () => Label,
+  Portal: () => Portal,
+  RadioGroup: () => RadioGroup,
+  RadioItem: () => RadioItem,
+  Root: () => Root,
+  Separator: () => Separator,
+  Sub: () => Sub,
+  SubContent: () => SubContent,
+  SubTrigger: () => SubTrigger,
+  Trigger: () => Trigger,
+  createContextMenuScope: () => createContextMenuScope
+});
+module.exports = __toCommonJS(ContextMenu_exports);
+var import_octane = require("octane");
+var import_compose_event_handlers = require("./compose-event-handlers.cjs");
+var import_context = require("./context.cjs");
+var import_internal = require("./internal.cjs");
+var MenuPrimitive = __toESM(require("./Menu.cjs"), 1);
+var import_Menu = require("./Menu.cjs");
+var import_Primitive = require("./Primitive.cjs");
+var import_useControllableState = require("./useControllableState.cjs");
+const CONTEXT_MENU_NAME = "ContextMenu";
+const [createContextMenuContext, createContextMenuScope] = (0, import_context.createContextScope)(CONTEXT_MENU_NAME, [
+  import_Menu.createMenuScope
+]);
+const useMenuScope = (0, import_Menu.createMenuScope)();
+const [ContextMenuProvider, useContextMenuContext] = createContextMenuContext(CONTEXT_MENU_NAME);
+function Root(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Root");
+  const {
+    __scopeContextMenu,
+    children,
+    onOpenChange,
+    open: openProp,
+    dir,
+    modal = true
+  } = props ?? {};
+  const hasInteractedRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "interacted"));
+  const [open, setOpen] = (0, import_useControllableState.useControllableState)(
+    { prop: openProp, defaultProp: false, onChange: onOpenChange },
+    (0, import_internal.subSlot)(slot, "open")
+  );
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(ContextMenuProvider, {
+    scope: __scopeContextMenu,
+    open,
+    onOpenChange: setOpen,
+    modal,
+    hasInteractedRef,
+    children: (0, import_octane.createElement)(MenuPrimitive.Root, {
+      ...menuScope,
+      dir,
+      open,
+      onOpenChange: setOpen,
+      modal,
+      children
+    })
+  });
+}
+function Trigger(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Trigger");
+  const { __scopeContextMenu, disabled = false, ref: forwardedRef, ...triggerProps } = props ?? {};
+  const context = useContextMenuContext("ContextMenuTrigger", __scopeContextMenu);
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  const pointRef = (0, import_octane.useRef)({ x: 0, y: 0 }, (0, import_internal.subSlot)(slot, "point"));
+  const virtualRef = (0, import_octane.useRef)(
+    {
+      getBoundingClientRect: () => DOMRect.fromRect({ width: 0, height: 0, ...pointRef.current })
+    },
+    (0, import_internal.subSlot)(slot, "virtual")
+  );
+  const longPressTimerRef = (0, import_octane.useRef)(0, (0, import_internal.subSlot)(slot, "timer"));
+  const clearLongPress = (0, import_octane.useCallback)(
+    () => window.clearTimeout(longPressTimerRef.current),
+    [],
+    (0, import_internal.subSlot)(slot, "clear")
+  );
+  const handleOpen = (event) => {
+    context.hasInteractedRef.current = true;
+    pointRef.current = { x: event.clientX, y: event.clientY };
+    context.onOpenChange(true);
+  };
+  (0, import_octane.useEffect)(() => clearLongPress, [clearLongPress], (0, import_internal.subSlot)(slot, "e:clear"));
+  (0, import_octane.useEffect)(
+    () => void (disabled && clearLongPress()),
+    [disabled, clearLongPress],
+    (0, import_internal.subSlot)(slot, "e:disabled")
+  );
+  return [
+    (0, import_octane.createElement)(MenuPrimitive.Anchor, { key: "anchor", ...menuScope, virtualRef }),
+    (0, import_octane.createElement)(import_Primitive.Primitive.span, {
+      key: "trigger",
+      "data-state": context.open ? "open" : "closed",
+      "data-disabled": disabled ? "" : void 0,
+      ...triggerProps,
+      ref: forwardedRef,
+      // prevent iOS context menu from appearing
+      style: { WebkitTouchCallout: "none", ...props?.style },
+      // if trigger is disabled, enable the native Context Menu
+      onContextMenu: disabled ? props?.onContextMenu : (0, import_compose_event_handlers.composeEventHandlers)(props?.onContextMenu, (event) => {
+        clearLongPress();
+        handleOpen(event);
+        event.preventDefault();
+      }),
+      onPointerDown: disabled ? props?.onPointerDown : (0, import_compose_event_handlers.composeEventHandlers)(
+        props?.onPointerDown,
+        whenTouchOrPen((event) => {
+          clearLongPress();
+          if (context.open) {
+            context.onOpenChange(false);
+          }
+          longPressTimerRef.current = window.setTimeout(() => handleOpen(event), 700);
+        })
+      ),
+      onPointerMove: disabled ? props?.onPointerMove : (0, import_compose_event_handlers.composeEventHandlers)(props?.onPointerMove, whenTouchOrPen(clearLongPress)),
+      onPointerCancel: disabled ? props?.onPointerCancel : (0, import_compose_event_handlers.composeEventHandlers)(props?.onPointerCancel, whenTouchOrPen(clearLongPress)),
+      onPointerUp: disabled ? props?.onPointerUp : (0, import_compose_event_handlers.composeEventHandlers)(props?.onPointerUp, whenTouchOrPen(clearLongPress))
+    })
+  ];
+}
+function Portal(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Portal");
+  const { __scopeContextMenu, ...portalProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.Portal, { ...menuScope, ...portalProps });
+}
+function Content(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Content");
+  const { __scopeContextMenu, ...contentProps } = props ?? {};
+  const context = useContextMenuContext("ContextMenuContent", __scopeContextMenu);
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  const hasInteractedOutsideRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "outside"));
+  return (0, import_octane.createElement)(MenuPrimitive.Content, {
+    ...menuScope,
+    ...contentProps,
+    side: "right",
+    sideOffset: 2,
+    align: "start",
+    onCloseAutoFocus: (event) => {
+      props?.onCloseAutoFocus?.(event);
+      if (!event.defaultPrevented && hasInteractedOutsideRef.current) {
+        event.preventDefault();
+      }
+      hasInteractedOutsideRef.current = false;
+    },
+    onInteractOutside: (event) => {
+      props?.onInteractOutside?.(event);
+      if (!event.defaultPrevented && !context.modal) hasInteractedOutsideRef.current = true;
+    },
+    style: {
+      ...props?.style,
+      // re-namespace exposed content custom properties
+      "--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
+      "--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
+      "--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
+      "--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
+      "--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
+    }
+  });
+}
+function Group(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Group");
+  const { __scopeContextMenu, ...groupProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.Group, { ...menuScope, ...groupProps });
+}
+function Label(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Label");
+  const { __scopeContextMenu, ...labelProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.Label, { ...menuScope, ...labelProps });
+}
+function Item(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Item");
+  const { __scopeContextMenu, ...itemProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.Item, { ...menuScope, ...itemProps });
+}
+function CheckboxItem(props) {
+  const slot = (0, import_internal.S)("ContextMenu.CheckboxItem");
+  const { __scopeContextMenu, ...checkboxItemProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.CheckboxItem, { ...menuScope, ...checkboxItemProps });
+}
+function RadioGroup(props) {
+  const slot = (0, import_internal.S)("ContextMenu.RadioGroup");
+  const { __scopeContextMenu, ...radioGroupProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.RadioGroup, { ...menuScope, ...radioGroupProps });
+}
+function RadioItem(props) {
+  const slot = (0, import_internal.S)("ContextMenu.RadioItem");
+  const { __scopeContextMenu, ...radioItemProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.RadioItem, { ...menuScope, ...radioItemProps });
+}
+function ItemIndicator(props) {
+  const slot = (0, import_internal.S)("ContextMenu.ItemIndicator");
+  const { __scopeContextMenu, ...itemIndicatorProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.ItemIndicator, { ...menuScope, ...itemIndicatorProps });
+}
+function Separator(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Separator");
+  const { __scopeContextMenu, ...separatorProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.Separator, { ...menuScope, ...separatorProps });
+}
+function Arrow(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Arrow");
+  const { __scopeContextMenu, ...arrowProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.Arrow, { ...menuScope, ...arrowProps });
+}
+function Sub(props) {
+  const slot = (0, import_internal.S)("ContextMenu.Sub");
+  const { __scopeContextMenu, children, onOpenChange, open: openProp, defaultOpen } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  const [open, setOpen] = (0, import_useControllableState.useControllableState)(
+    { prop: openProp, defaultProp: defaultOpen ?? false, onChange: onOpenChange },
+    (0, import_internal.subSlot)(slot, "open")
+  );
+  return (0, import_octane.createElement)(MenuPrimitive.Sub, { ...menuScope, open, onOpenChange: setOpen, children });
+}
+function SubTrigger(props) {
+  const slot = (0, import_internal.S)("ContextMenu.SubTrigger");
+  const { __scopeContextMenu, ...triggerItemProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.SubTrigger, { ...menuScope, ...triggerItemProps });
+}
+function SubContent(props) {
+  const slot = (0, import_internal.S)("ContextMenu.SubContent");
+  const { __scopeContextMenu, ...subContentProps } = props ?? {};
+  const menuScope = useMenuScope(__scopeContextMenu, (0, import_internal.subSlot)(slot, "menu"));
+  return (0, import_octane.createElement)(MenuPrimitive.SubContent, {
+    ...menuScope,
+    ...subContentProps,
+    style: {
+      ...props?.style,
+      // re-namespace exposed content custom properties
+      "--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
+      "--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
+      "--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
+      "--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
+      "--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
+    }
+  });
+}
+function whenTouchOrPen(handler) {
+  return (event) => event.pointerType !== "mouse" ? handler(event) : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Arrow,
+  CheckboxItem,
+  Content,
+  ContextMenu,
+  ContextMenuContent,
+  ContextMenuItem,
+  ContextMenuTrigger,
+  Group,
+  Item,
+  ItemIndicator,
+  Label,
+  Portal,
+  RadioGroup,
+  RadioItem,
+  Root,
+  Separator,
+  Sub,
+  SubContent,
+  SubTrigger,
+  Trigger,
+  createContextMenuScope
+});

package/dist/cjs/Dialog.cjs

@@ -0,0 +1,291 @@
+"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 Dialog_exports = {};
+__export(Dialog_exports, {
+  Close: () => Close,
+  Content: () => Content,
+  Description: () => Description,
+  Dialog: () => Root,
+  Overlay: () => Overlay,
+  Portal: () => Portal,
+  Root: () => Root,
+  Title: () => Title,
+  Trigger: () => Trigger,
+  createDialogContext: () => createDialogContext,
+  createDialogScope: () => createDialogScope
+});
+module.exports = __toCommonJS(Dialog_exports);
+var import_octane = require("octane");
+var import_aria_hidden = require("aria-hidden");
+var import_compose_event_handlers = require("./compose-event-handlers.cjs");
+var import_compose_refs = require("./compose-refs.cjs");
+var import_context = require("./context.cjs");
+var import_DismissableLayer = require("./DismissableLayer.cjs");
+var import_FocusScope = require("./FocusScope.cjs");
+var import_focus_guards = require("./focus-guards.cjs");
+var import_internal = require("./internal.cjs");
+var import_Portal = require("./Portal.cjs");
+var import_Presence = require("./Presence.cjs");
+var import_Primitive = require("./Primitive.cjs");
+var import_scroll_lock = require("./scroll-lock.cjs");
+var import_useControllableState = require("./useControllableState.cjs");
+var import_useId = require("./useId.cjs");
+const [createDialogContext, createDialogScope] = (0, import_context.createContextScope)("Dialog");
+const [DialogProvider, useDialogContext] = createDialogContext("Dialog");
+const [PortalProvider, usePortalContext] = createDialogContext(
+  "DialogPortal",
+  { forceMount: void 0 }
+);
+function getState(open) {
+  return open ? "open" : "closed";
+}
+function Root(props) {
+  const slot = (0, import_internal.S)("Dialog.Root");
+  const {
+    __scopeDialog,
+    children,
+    open: openProp,
+    defaultOpen,
+    onOpenChange,
+    modal = true
+  } = props ?? {};
+  const triggerRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "trigger"));
+  const contentRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "content"));
+  const [open, setOpen] = (0, import_useControllableState.useControllableState)(
+    { prop: openProp, defaultProp: defaultOpen ?? false, onChange: onOpenChange },
+    (0, import_internal.subSlot)(slot, "open")
+  );
+  return (0, import_octane.createElement)(DialogProvider, {
+    scope: __scopeDialog,
+    triggerRef,
+    contentRef,
+    contentId: (0, import_useId.useId)((0, import_internal.subSlot)(slot, "contentId")),
+    titleId: (0, import_useId.useId)((0, import_internal.subSlot)(slot, "titleId")),
+    descriptionId: (0, import_useId.useId)((0, import_internal.subSlot)(slot, "descriptionId")),
+    open,
+    onOpenChange: setOpen,
+    onOpenToggle: (0, import_octane.useCallback)(() => setOpen((prev) => !prev), [setOpen], (0, import_internal.subSlot)(slot, "toggle")),
+    modal,
+    children
+  });
+}
+function Trigger(props) {
+  const slot = (0, import_internal.S)("Dialog.Trigger");
+  const { __scopeDialog, ref: forwardedRef, ...triggerProps } = props ?? {};
+  const context = useDialogContext("DialogTrigger", __scopeDialog);
+  const composedTriggerRef = (0, import_compose_refs.useComposedRefs)(
+    forwardedRef,
+    context.triggerRef,
+    (0, import_internal.subSlot)(slot, "refs")
+  );
+  return (0, import_octane.createElement)(import_Primitive.Primitive.button, {
+    type: "button",
+    "aria-haspopup": "dialog",
+    "aria-expanded": context.open,
+    "aria-controls": context.open ? context.contentId : void 0,
+    "data-state": getState(context.open),
+    ...triggerProps,
+    ref: composedTriggerRef,
+    onClick: (0, import_compose_event_handlers.composeEventHandlers)(props?.onClick, context.onOpenToggle)
+  });
+}
+function Portal(props) {
+  const { __scopeDialog, forceMount, children, container } = props ?? {};
+  const context = useDialogContext("DialogPortal", __scopeDialog);
+  const wrap = (child) => (0, import_octane.createElement)(import_Presence.Presence, {
+    present: forceMount || context.open,
+    children: (0, import_octane.createElement)(import_Portal.Portal, { asChild: true, container, children: child })
+  });
+  const mapped = typeof children === "function" ? (0, import_octane.createElement)(import_Presence.Presence, {
+    present: forceMount || context.open,
+    children: (0, import_octane.createElement)(import_Portal.Portal, { container, children })
+  }) : import_octane.Children.map(children, wrap);
+  return (0, import_octane.createElement)(PortalProvider, { scope: __scopeDialog, forceMount, children: mapped });
+}
+function Overlay(props) {
+  const portalContext = usePortalContext("DialogOverlay", props?.__scopeDialog);
+  const { forceMount = portalContext.forceMount, ...overlayProps } = props ?? {};
+  const context = useDialogContext("DialogOverlay", props?.__scopeDialog);
+  return context.modal ? (0, import_octane.createElement)(import_Presence.Presence, {
+    present: forceMount || context.open,
+    children: (0, import_octane.createElement)(OverlayImpl, overlayProps)
+  }) : null;
+}
+function OverlayImpl(props) {
+  const slot = (0, import_internal.S)("Dialog.OverlayImpl");
+  const { __scopeDialog, ref: forwardedRef, ...overlayProps } = props;
+  const context = useDialogContext("DialogOverlay", __scopeDialog);
+  const registerDismissableSurface = (0, import_DismissableLayer.useDismissableLayerSurface)((0, import_internal.subSlot)(slot, "surface"));
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(
+    forwardedRef,
+    registerDismissableSurface,
+    (0, import_internal.subSlot)(slot, "refs")
+  );
+  (0, import_scroll_lock.useScrollLock)(context.open, (0, import_internal.subSlot)(slot, "lock"));
+  return (0, import_octane.createElement)(import_Primitive.Primitive.div, {
+    "data-state": getState(context.open),
+    ...overlayProps,
+    ref: composedRefs,
+    // Make sure `Content` is scrollable even when it doesn't live inside `RemoveScroll`
+    // ie. when `Overlay` and `Content` are siblings.
+    style: { pointerEvents: "auto", ...overlayProps.style }
+  });
+}
+function Content(props) {
+  const portalContext = usePortalContext("DialogContent", props?.__scopeDialog);
+  const { forceMount = portalContext.forceMount, ...contentProps } = props ?? {};
+  const context = useDialogContext("DialogContent", props?.__scopeDialog);
+  return (0, import_octane.createElement)(import_Presence.Presence, {
+    present: forceMount || context.open,
+    children: context.modal ? (0, import_octane.createElement)(ContentModal, contentProps) : (0, import_octane.createElement)(ContentNonModal, contentProps)
+  });
+}
+function ContentModal(props) {
+  const slot = (0, import_internal.S)("Dialog.ContentModal");
+  const { ref: forwardedRef, ...rest } = props;
+  const context = useDialogContext("DialogContent", props.__scopeDialog);
+  const contentRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ref"));
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(
+    forwardedRef,
+    context.contentRef,
+    contentRef,
+    (0, import_internal.subSlot)(slot, "refs")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      const content = contentRef.current;
+      if (content) return (0, import_aria_hidden.hideOthers)(content);
+    },
+    [],
+    (0, import_internal.subSlot)(slot, "e:hide")
+  );
+  return (0, import_octane.createElement)(ContentImpl, {
+    ...rest,
+    __scopeDialog: props.__scopeDialog,
+    ref: composedRefs,
+    trapFocus: context.open,
+    disableOutsidePointerEvents: context.open,
+    onCloseAutoFocus: (0, import_compose_event_handlers.composeEventHandlers)(props.onCloseAutoFocus, (event) => {
+      event.preventDefault();
+      context.triggerRef.current?.focus();
+    }),
+    onPointerDownOutside: (0, import_compose_event_handlers.composeEventHandlers)(props.onPointerDownOutside, (event) => {
+      const originalEvent = event.detail.originalEvent;
+      const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
+      const isRightClick = originalEvent.button === 2 || ctrlLeftClick;
+      if (isRightClick) event.preventDefault();
+    }),
+    // When focus is trapped, a `focusout` event may still happen — prevent dismissing.
+    onFocusOutside: (0, import_compose_event_handlers.composeEventHandlers)(
+      props.onFocusOutside,
+      (event) => event.preventDefault()
+    )
+  });
+}
+function ContentNonModal(props) {
+  const slot = (0, import_internal.S)("Dialog.ContentNonModal");
+  const context = useDialogContext("DialogContent", props.__scopeDialog);
+  const hasInteractedOutsideRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "interacted"));
+  const hasPointerDownOutsideRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "pointer"));
+  return (0, import_octane.createElement)(ContentImpl, {
+    ...props,
+    trapFocus: false,
+    disableOutsidePointerEvents: false,
+    onCloseAutoFocus: (event) => {
+      props.onCloseAutoFocus?.(event);
+      if (!event.defaultPrevented) {
+        if (!hasInteractedOutsideRef.current) context.triggerRef.current?.focus();
+        event.preventDefault();
+      }
+      hasInteractedOutsideRef.current = false;
+      hasPointerDownOutsideRef.current = false;
+    },
+    onInteractOutside: (event) => {
+      props.onInteractOutside?.(event);
+      if (!event.defaultPrevented) {
+        hasInteractedOutsideRef.current = true;
+        if (event.detail.originalEvent.type === "pointerdown") {
+          hasPointerDownOutsideRef.current = true;
+        }
+      }
+      const target = event.target;
+      const targetIsTrigger = context.triggerRef.current?.contains(target);
+      if (targetIsTrigger) event.preventDefault();
+      if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.current) {
+        event.preventDefault();
+      }
+    }
+  });
+}
+function ContentImpl(props) {
+  const slot = (0, import_internal.S)("Dialog.ContentImpl");
+  const { __scopeDialog, trapFocus, onOpenAutoFocus, onCloseAutoFocus, ...contentProps } = props;
+  const context = useDialogContext("DialogContent", __scopeDialog);
+  (0, import_focus_guards.useFocusGuards)((0, import_internal.subSlot)(slot, "guards"));
+  return (0, import_octane.createElement)(import_FocusScope.FocusScope, {
+    asChild: true,
+    loop: true,
+    trapped: trapFocus,
+    onMountAutoFocus: onOpenAutoFocus,
+    onUnmountAutoFocus: onCloseAutoFocus,
+    children: (0, import_octane.createElement)(import_DismissableLayer.DismissableLayer, {
+      role: "dialog",
+      id: context.contentId,
+      "aria-describedby": context.descriptionId,
+      "aria-labelledby": context.titleId,
+      "data-state": getState(context.open),
+      ...contentProps,
+      deferPointerDownOutside: true,
+      onDismiss: () => context.onOpenChange(false)
+    })
+  });
+}
+function Title(props) {
+  const { __scopeDialog, ...titleProps } = props ?? {};
+  const context = useDialogContext("DialogTitle", __scopeDialog);
+  return (0, import_octane.createElement)(import_Primitive.Primitive.h2, { id: context.titleId, ...titleProps });
+}
+function Description(props) {
+  const { __scopeDialog, ...descriptionProps } = props ?? {};
+  const context = useDialogContext("DialogDescription", __scopeDialog);
+  return (0, import_octane.createElement)(import_Primitive.Primitive.p, { id: context.descriptionId, ...descriptionProps });
+}
+function Close(props) {
+  const { __scopeDialog, ...closeProps } = props ?? {};
+  const context = useDialogContext("DialogClose", __scopeDialog);
+  return (0, import_octane.createElement)(import_Primitive.Primitive.button, {
+    type: "button",
+    ...closeProps,
+    onClick: (0, import_compose_event_handlers.composeEventHandlers)(props?.onClick, () => context.onOpenChange(false))
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Close,
+  Content,
+  Description,
+  Dialog,
+  Overlay,
+  Portal,
+  Root,
+  Title,
+  Trigger,
+  createDialogContext,
+  createDialogScope
+});