@tale-ui/react 0.0.3

package/composite/list/useCompositeListItem.js

@@ -0,0 +1,85 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexGuessBehavior = void 0;
+exports.useCompositeListItem = useCompositeListItem;
+var React = _interopRequireWildcard(require("react"));
+var _useIsoLayoutEffect = require("@tale-ui/utils/useIsoLayoutEffect");
+var _CompositeListContext = require("./CompositeListContext");
+let IndexGuessBehavior = exports.IndexGuessBehavior = /*#__PURE__*/function (IndexGuessBehavior) {
+  IndexGuessBehavior[IndexGuessBehavior["None"] = 0] = "None";
+  IndexGuessBehavior[IndexGuessBehavior["GuessFromOrder"] = 1] = "GuessFromOrder";
+  return IndexGuessBehavior;
+}({});
+/**
+ * Used to register a list item and its index (DOM position) in the `CompositeList`.
+ */
+function useCompositeListItem(params = {}) {
+  const {
+    label,
+    metadata,
+    textRef,
+    indexGuessBehavior,
+    index: externalIndex
+  } = params;
+  const {
+    register,
+    unregister,
+    subscribeMapChange,
+    elementsRef,
+    labelsRef,
+    nextIndexRef
+  } = (0, _CompositeListContext.useCompositeListContext)();
+  const indexRef = React.useRef(-1);
+  const [index, setIndex] = React.useState(externalIndex ?? (indexGuessBehavior === IndexGuessBehavior.GuessFromOrder ? () => {
+    if (indexRef.current === -1) {
+      const newIndex = nextIndexRef.current;
+      nextIndexRef.current += 1;
+      indexRef.current = newIndex;
+    }
+    return indexRef.current;
+  } : -1));
+  const componentRef = React.useRef(null);
+  const ref = React.useCallback(node => {
+    componentRef.current = node;
+    if (index !== -1 && node !== null) {
+      elementsRef.current[index] = node;
+      if (labelsRef) {
+        const isLabelDefined = label !== undefined;
+        labelsRef.current[index] = isLabelDefined ? label : textRef?.current?.textContent ?? node.textContent;
+      }
+    }
+  }, [index, elementsRef, labelsRef, label, textRef]);
+  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
+    if (externalIndex != null) {
+      return undefined;
+    }
+    const node = componentRef.current;
+    if (node) {
+      register(node, metadata);
+      return () => {
+        unregister(node);
+      };
+    }
+    return undefined;
+  }, [externalIndex, register, unregister, metadata]);
+  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
+    if (externalIndex != null) {
+      return undefined;
+    }
+    return subscribeMapChange(map => {
+      const i = componentRef.current ? map.get(componentRef.current)?.index : null;
+      if (i != null) {
+        setIndex(i);
+      }
+    });
+  }, [externalIndex, subscribeMapChange, setIndex]);
+  return React.useMemo(() => ({
+    ref,
+    index
+  }), [index, ref]);
+}

package/composite/root/CompositeRoot.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { type CompositeMetadata } from "../list/CompositeList.js";
+import type { TaleUIComponentProps } from "../../utils/types.js";
+import type { Dimensions, ModifierKey } from "../composite.js";
+import { StateAttributesMapping } from "../../utils/getStateAttributesProps.js";
+/**
+ * @internal
+ */
+export declare function CompositeRoot<Metadata extends {}, State extends Record<string, any>>(componentProps: CompositeRoot.Props<Metadata, State>): import("react/jsx-runtime").JSX.Element;
+export interface CompositeRootProps<Metadata, State extends Record<string, any>> extends Pick<TaleUIComponentProps<'div', State>, 'render' | 'className' | 'children'> {
+  props?: Array<Record<string, any> | (() => Record<string, any>)> | undefined;
+  state?: State | undefined;
+  stateAttributesMapping?: StateAttributesMapping<State> | undefined;
+  refs?: React.Ref<HTMLElement | null>[] | undefined;
+  tag?: keyof React.JSX.IntrinsicElements | undefined;
+  orientation?: 'horizontal' | 'vertical' | 'both' | undefined;
+  cols?: number | undefined;
+  loopFocus?: boolean | undefined;
+  highlightedIndex?: number | undefined;
+  onHighlightedIndexChange?: ((index: number) => void) | undefined;
+  itemSizes?: Dimensions[] | undefined;
+  dense?: boolean | undefined;
+  enableHomeAndEndKeys?: boolean | undefined;
+  onMapChange?: ((newMap: Map<Node, CompositeMetadata<Metadata> | null>) => void) | undefined;
+  stopEventPropagation?: boolean | undefined;
+  rootRef?: React.RefObject<HTMLElement | null> | undefined;
+  disabledIndices?: number[] | undefined;
+  modifierKeys?: ModifierKey[] | undefined;
+  highlightItemOnHover?: boolean | undefined;
+}
+export declare namespace CompositeRoot {
+  type Props<Metadata, State extends Record<string, any>> = CompositeRootProps<Metadata, State>;
+}

package/composite/root/CompositeRoot.js

@@ -0,0 +1,91 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CompositeRoot = CompositeRoot;
+var React = _interopRequireWildcard(require("react"));
+var _CompositeList = require("../list/CompositeList");
+var _useCompositeRoot = require("./useCompositeRoot");
+var _CompositeRootContext = require("./CompositeRootContext");
+var _useRenderElement = require("../../utils/useRenderElement");
+var _DirectionContext = require("../../direction-provider/DirectionContext");
+var _constants = require("../../utils/constants");
+var _jsxRuntime = require("react/jsx-runtime");
+/**
+ * @internal
+ */
+function CompositeRoot(componentProps) {
+  const {
+    render,
+    className,
+    refs = _constants.EMPTY_ARRAY,
+    props = _constants.EMPTY_ARRAY,
+    state = _constants.EMPTY_OBJECT,
+    stateAttributesMapping,
+    highlightedIndex: highlightedIndexProp,
+    onHighlightedIndexChange: onHighlightedIndexChangeProp,
+    orientation,
+    dense,
+    itemSizes,
+    loopFocus,
+    cols,
+    enableHomeAndEndKeys,
+    onMapChange: onMapChangeProp,
+    stopEventPropagation = true,
+    rootRef,
+    disabledIndices,
+    modifierKeys,
+    highlightItemOnHover = false,
+    tag = 'div',
+    ...elementProps
+  } = componentProps;
+  const direction = (0, _DirectionContext.useDirection)();
+  const {
+    props: defaultProps,
+    highlightedIndex,
+    onHighlightedIndexChange,
+    elementsRef,
+    onMapChange: onMapChangeUnwrapped,
+    relayKeyboardEvent
+  } = (0, _useCompositeRoot.useCompositeRoot)({
+    itemSizes,
+    cols,
+    loopFocus,
+    dense,
+    orientation,
+    highlightedIndex: highlightedIndexProp,
+    onHighlightedIndexChange: onHighlightedIndexChangeProp,
+    rootRef,
+    stopEventPropagation,
+    enableHomeAndEndKeys,
+    direction,
+    disabledIndices,
+    modifierKeys
+  });
+  const element = (0, _useRenderElement.useRenderElement)(tag, componentProps, {
+    state,
+    ref: refs,
+    props: [defaultProps, ...props, elementProps],
+    stateAttributesMapping
+  });
+  const contextValue = React.useMemo(() => ({
+    highlightedIndex,
+    onHighlightedIndexChange,
+    highlightItemOnHover,
+    relayKeyboardEvent
+  }), [highlightedIndex, onHighlightedIndexChange, highlightItemOnHover, relayKeyboardEvent]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_CompositeRootContext.CompositeRootContext.Provider, {
+    value: contextValue,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_CompositeList.CompositeList, {
+      elementsRef: elementsRef,
+      onMapChange: newMap => {
+        onMapChangeProp?.(newMap);
+        onMapChangeUnwrapped(newMap);
+      },
+      children: element
+    })
+  });
+}

package/composite/root/CompositeRootContext.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+export interface CompositeRootContext {
+  highlightedIndex: number;
+  onHighlightedIndexChange: (index: number, shouldScrollIntoView?: boolean) => void;
+  highlightItemOnHover: boolean;
+  /**
+   * Makes it possible to control composite components using events that don't originate from their children.
+   * For example, a Menubar with detached triggers may define its Menu.Root outside of CompositeRoot.
+   * Keyboard events that occur within this menu won't normally be captured by the CompositeRoot,
+   * so they need to be forwarded manually using this function.
+   */
+  relayKeyboardEvent: (event: React.KeyboardEvent<any>) => void;
+}
+export declare const CompositeRootContext: React.Context<CompositeRootContext | undefined>;
+export declare function useCompositeRootContext(optional: true): CompositeRootContext | undefined;
+export declare function useCompositeRootContext(optional?: false): CompositeRootContext;

package/composite/root/CompositeRootContext.js

@@ -0,0 +1,19 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CompositeRootContext = void 0;
+exports.useCompositeRootContext = useCompositeRootContext;
+var React = _interopRequireWildcard(require("react"));
+const CompositeRootContext = exports.CompositeRootContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== "production") CompositeRootContext.displayName = "CompositeRootContext";
+function useCompositeRootContext(optional = false) {
+  const context = React.useContext(CompositeRootContext);
+  if (context === undefined && !optional) {
+    throw /* FIXME (minify-errors-in-prod): Unminified error message in production build! */new Error('Tale UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>.');
+  }
+  return context;
+}

package/composite/root/useCompositeRoot.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import type { TextDirection } from "../../direction-provider/DirectionContext.js";
+import { type Dimensions, type ModifierKey } from "../composite.js";
+import { CompositeMetadata } from "../list/CompositeList.js";
+import { HTMLProps } from "../../utils/types.js";
+export interface UseCompositeRootParameters {
+  orientation?: 'horizontal' | 'vertical' | 'both' | undefined;
+  cols?: number | undefined;
+  loopFocus?: boolean | undefined;
+  highlightedIndex?: number | undefined;
+  onHighlightedIndexChange?: ((index: number) => void) | undefined;
+  dense?: boolean | undefined;
+  direction: TextDirection;
+  itemSizes?: Array<Dimensions> | undefined;
+  rootRef?: React.Ref<Element> | undefined;
+  /**
+   * When `true`, pressing the Home key moves focus to the first item,
+   * and pressing the End key moves focus to the last item.
+   * @default false
+   */
+  enableHomeAndEndKeys?: boolean | undefined;
+  /**
+   * When `true`, keypress events on Composite's navigation keys
+   * be stopped with event.stopPropagation().
+   * @default false
+   */
+  stopEventPropagation?: boolean | undefined;
+  /**
+   * Array of item indices to be considered disabled.
+   * Used for composite items that are focusable when disabled.
+   */
+  disabledIndices?: number[] | undefined;
+  /**
+   * Array of [modifier key values](https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values#modifier_keys) that should allow normal keyboard actions
+   * when pressed. By default, all modifier keys prevent normal actions.
+   * @default []
+   */
+  modifierKeys?: ModifierKey[] | undefined;
+}
+export declare function useCompositeRoot(params: UseCompositeRootParameters): {
+  props: HTMLProps;
+  highlightedIndex: number;
+  onHighlightedIndexChange: (index: any, shouldScrollIntoView?: any) => void;
+  elementsRef: React.RefObject<(HTMLDivElement | null)[]>;
+  disabledIndices: number[] | undefined;
+  onMapChange: (map: Map<Element, CompositeMetadata<any>>) => void;
+  relayKeyboardEvent: React.KeyboardEventHandler<any>;
+};

package/composite/root/useCompositeRoot.js

@@ -0,0 +1,221 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCompositeRoot = useCompositeRoot;
+var React = _interopRequireWildcard(require("react"));
+var _isElementDisabled = require("@tale-ui/utils/isElementDisabled");
+var _useStableCallback = require("@tale-ui/utils/useStableCallback");
+var _useMergedRefs = require("@tale-ui/utils/useMergedRefs");
+var _composite = require("../composite");
+var _constants = require("../constants");
+const EMPTY_ARRAY = [];
+function useCompositeRoot(params) {
+  const {
+    itemSizes,
+    cols = 1,
+    loopFocus = true,
+    dense = false,
+    orientation = 'both',
+    direction,
+    highlightedIndex: externalHighlightedIndex,
+    onHighlightedIndexChange: externalSetHighlightedIndex,
+    rootRef: externalRef,
+    enableHomeAndEndKeys = false,
+    stopEventPropagation = false,
+    disabledIndices,
+    modifierKeys = EMPTY_ARRAY
+  } = params;
+  const [internalHighlightedIndex, internalSetHighlightedIndex] = React.useState(0);
+  const isGrid = cols > 1;
+  const rootRef = React.useRef(null);
+  const mergedRef = (0, _useMergedRefs.useMergedRefs)(rootRef, externalRef);
+  const elementsRef = React.useRef([]);
+  const hasSetDefaultIndexRef = React.useRef(false);
+  const highlightedIndex = externalHighlightedIndex ?? internalHighlightedIndex;
+  const onHighlightedIndexChange = (0, _useStableCallback.useStableCallback)((index, shouldScrollIntoView = false) => {
+    (externalSetHighlightedIndex ?? internalSetHighlightedIndex)(index);
+    if (shouldScrollIntoView) {
+      const newActiveItem = elementsRef.current[index];
+      (0, _composite.scrollIntoViewIfNeeded)(rootRef.current, newActiveItem, direction, orientation);
+    }
+  });
+  const onMapChange = (0, _useStableCallback.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(_constants.ACTIVE_COMPOSITE_ITEM)) ?? null;
+    // Set the default highlighted index of an arbitrary composite item.
+    const activeIndex = activeItem ? sortedElements.indexOf(activeItem) : -1;
+    if (activeIndex !== -1) {
+      onHighlightedIndexChange(activeIndex);
+    }
+    (0, _composite.scrollIntoViewIfNeeded)(rootRef.current, activeItem, direction, orientation);
+  });
+  const props = React.useMemo(() => ({
+    'aria-orientation': orientation === 'both' ? undefined : orientation,
+    ref: mergedRef,
+    onFocus(event) {
+      const element = rootRef.current;
+      if (!element || !(0, _composite.isNativeInput)(event.target)) {
+        return;
+      }
+      event.target.setSelectionRange(0, event.target.value.length ?? 0);
+    },
+    onKeyDown(event) {
+      const RELEVANT_KEYS = enableHomeAndEndKeys ? _composite.ALL_KEYS : _composite.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 ? _composite.ARROW_LEFT : _composite.ARROW_RIGHT;
+      const forwardKey = {
+        horizontal: horizontalForwardKey,
+        vertical: _composite.ARROW_DOWN,
+        both: horizontalForwardKey
+      }[orientation];
+      const horizontalBackwardKey = isRtl ? _composite.ARROW_RIGHT : _composite.ARROW_LEFT;
+      const backwardKey = {
+        horizontal: horizontalBackwardKey,
+        vertical: _composite.ARROW_UP,
+        both: horizontalBackwardKey
+      }[orientation];
+      if ((0, _composite.isNativeInput)(event.target) && !(0, _isElementDisabled.isElementDisabled)(event.target)) {
+        const selectionStart = event.target.selectionStart;
+        const selectionEnd = event.target.selectionEnd;
+        const textContent = event.target.value ?? '';
+        // return to native textbox behavior when
+        // 1 - Shift is held to make a text selection, or if there already is a text selection
+        if (selectionStart == null || event.shiftKey || selectionStart !== selectionEnd) {
+          return;
+        }
+        // 2 - arrow-ing forward and not in the last position of the text
+        if (event.key !== backwardKey && selectionStart < textContent.length) {
+          return;
+        }
+        // 3 -arrow-ing backward and not in the first position of the text
+        if (event.key !== forwardKey && selectionStart > 0) {
+          return;
+        }
+      }
+      let nextIndex = highlightedIndex;
+      const minIndex = (0, _composite.getMinListIndex)(elementsRef, disabledIndices);
+      const maxIndex = (0, _composite.getMaxListIndex)(elementsRef, disabledIndices);
+      if (isGrid) {
+        const sizes = itemSizes || Array.from({
+          length: elementsRef.current.length
+        }, () => ({
+          width: 1,
+          height: 1
+        }));
+        // To calculate movements on the grid, we use hypothetical cell indices
+        // as if every item was 1x1, then convert back to real indices.
+        const cellMap = (0, _composite.createGridCellMap)(sizes, cols, dense);
+        const minGridIndex = cellMap.findIndex(index => index != null && !(0, _composite.isListIndexDisabled)(elementsRef, index, disabledIndices));
+        // last enabled index
+        const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !(0, _composite.isListIndexDisabled)(elementsRef, index, disabledIndices) ? cellIndex : foundIndex, -1);
+        nextIndex = cellMap[(0, _composite.getGridNavigatedIndex)({
+          current: cellMap.map(itemIndex => itemIndex ? elementsRef.current[itemIndex] : null)
+        }, {
+          event,
+          orientation,
+          loopFocus,
+          cols,
+          // treat undefined (empty grid spaces) as disabled indices so we
+          // don't end up in them
+          disabledIndices: (0, _composite.getGridCellIndices)([...(disabledIndices || elementsRef.current.map((_, index) => (0, _composite.isListIndexDisabled)(elementsRef, index) ? index : undefined)), undefined], cellMap),
+          minIndex: minGridIndex,
+          maxIndex: maxGridIndex,
+          prevIndex: (0, _composite.getGridCellIndexOfCorner)(highlightedIndex > maxIndex ? minIndex : highlightedIndex, sizes, cellMap, cols,
+          // use a corner matching the edge closest to the direction we're
+          // moving in so we don't end up in the same item. Prefer
+          // top/left over bottom/right.
+          // eslint-disable-next-line no-nested-ternary
+          event.key === _composite.ARROW_DOWN ? 'bl' : event.key === _composite.ARROW_RIGHT ? 'tr' : 'tl'),
+          rtl: isRtl
+        })]; // navigated cell will never be nullish
+      }
+      const forwardKeys = {
+        horizontal: [horizontalForwardKey],
+        vertical: [_composite.ARROW_DOWN],
+        both: [horizontalForwardKey, _composite.ARROW_DOWN]
+      }[orientation];
+      const backwardKeys = {
+        horizontal: [horizontalBackwardKey],
+        vertical: [_composite.ARROW_UP],
+        both: [horizontalBackwardKey, _composite.ARROW_UP]
+      }[orientation];
+      const preventedKeys = isGrid ? RELEVANT_KEYS : {
+        horizontal: enableHomeAndEndKeys ? _composite.HORIZONTAL_KEYS_WITH_EXTRA_KEYS : _composite.HORIZONTAL_KEYS,
+        vertical: enableHomeAndEndKeys ? _composite.VERTICAL_KEYS_WITH_EXTRA_KEYS : _composite.VERTICAL_KEYS,
+        both: RELEVANT_KEYS
+      }[orientation];
+      if (enableHomeAndEndKeys) {
+        if (event.key === _composite.HOME) {
+          nextIndex = minIndex;
+        } else if (event.key === _composite.END) {
+          nextIndex = maxIndex;
+        }
+      }
+      if (nextIndex === highlightedIndex && (forwardKeys.includes(event.key) || backwardKeys.includes(event.key))) {
+        if (loopFocus && nextIndex === maxIndex && forwardKeys.includes(event.key)) {
+          nextIndex = minIndex;
+        } else if (loopFocus && nextIndex === minIndex && backwardKeys.includes(event.key)) {
+          nextIndex = maxIndex;
+        } else {
+          nextIndex = (0, _composite.findNonDisabledListIndex)(elementsRef, {
+            startingIndex: nextIndex,
+            decrement: backwardKeys.includes(event.key),
+            disabledIndices
+          });
+        }
+      }
+      if (nextIndex !== highlightedIndex && !(0, _composite.isIndexOutOfListBounds)(elementsRef, nextIndex)) {
+        if (stopEventPropagation) {
+          event.stopPropagation();
+        }
+        if (preventedKeys.has(event.key)) {
+          event.preventDefault();
+        }
+        onHighlightedIndexChange(nextIndex, true);
+
+        // Wait for FocusManager `returnFocus` to execute.
+        queueMicrotask(() => {
+          elementsRef.current[nextIndex]?.focus();
+        });
+      }
+    }
+  }), [cols, dense, direction, disabledIndices, elementsRef, enableHomeAndEndKeys, highlightedIndex, isGrid, itemSizes, loopFocus, 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 _composite.MODIFIER_KEYS.values()) {
+    if (ignoredModifierKeys.includes(key)) {
+      continue;
+    }
+    if (event.getModifierState(key)) {
+      return true;
+    }
+  }
+  return false;
+}

package/context-menu/index.d.ts

@@ -0,0 +1,19 @@
+export * as ContextMenu from "./index.parts.js";
+export type * from "./root/ContextMenuRoot.js";
+export type * from "./trigger/ContextMenuTrigger.js";
+export type { MenuBackdropProps as ContextMenuBackdropProps, MenuBackdropState as ContextMenuBackdropState } from "../menu/backdrop/MenuBackdrop.js";
+export type { MenuPortalProps as ContextMenuPortalProps } from "../menu/portal/MenuPortal.js";
+export type { MenuPositionerProps as ContextMenuPositionerProps, MenuPositionerState as ContextMenuPositionerState } from "../menu/positioner/MenuPositioner.js";
+export type { MenuPopupProps as ContextMenuPopupProps, MenuPopupState as ContextMenuPopupState } from "../menu/popup/MenuPopup.js";
+export type { MenuArrowProps as ContextMenuArrowProps, MenuArrowState as ContextMenuArrowState } from "../menu/arrow/MenuArrow.js";
+export type { MenuGroupProps as ContextMenuGroupProps, MenuGroupState as ContextMenuGroupState } from "../menu/group/MenuGroup.js";
+export type { MenuGroupLabelProps as ContextMenuGroupLabelProps, MenuGroupLabelState as ContextMenuGroupLabelState } from "../menu/group-label/MenuGroupLabel.js";
+export type { MenuItemProps as ContextMenuItemProps, MenuItemState as ContextMenuItemState } from "../menu/item/MenuItem.js";
+export type { MenuLinkItemProps as ContextMenuLinkItemProps, MenuLinkItemState as ContextMenuLinkItemState } from "../menu/link-item/MenuLinkItem.js";
+export type { MenuCheckboxItemProps as ContextMenuCheckboxItemProps, MenuCheckboxItemState as ContextMenuCheckboxItemState } from "../menu/checkbox-item/MenuCheckboxItem.js";
+export type { MenuCheckboxItemIndicatorProps as ContextMenuCheckboxItemIndicatorProps, MenuCheckboxItemIndicatorState as ContextMenuCheckboxItemIndicatorState } from "../menu/checkbox-item-indicator/MenuCheckboxItemIndicator.js";
+export type { MenuRadioGroupProps as ContextMenuRadioGroupProps, MenuRadioGroupState as ContextMenuRadioGroupState } from "../menu/radio-group/MenuRadioGroup.js";
+export type { MenuRadioItemProps as ContextMenuRadioItemProps, MenuRadioItemState as ContextMenuRadioItemState } from "../menu/radio-item/MenuRadioItem.js";
+export type { MenuRadioItemIndicatorProps as ContextMenuRadioItemIndicatorProps, MenuRadioItemIndicatorState as ContextMenuRadioItemIndicatorState } from "../menu/radio-item-indicator/MenuRadioItemIndicator.js";
+export type { MenuSubmenuRootProps as ContextMenuSubmenuRootProps, MenuSubmenuRootState as ContextMenuSubmenuRootState } from "../menu/submenu-root/MenuSubmenuRoot.js";
+export type { MenuSubmenuTriggerProps as ContextMenuSubmenuTriggerProps, MenuSubmenuTriggerState as ContextMenuSubmenuTriggerState } from "../menu/submenu-trigger/MenuSubmenuTrigger.js";

package/context-menu/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ContextMenu = void 0;
+var _ContextMenu = _interopRequireWildcard(require("./index.parts"));
+exports.ContextMenu = _ContextMenu;

package/context-menu/index.parts.d.ts

@@ -0,0 +1,19 @@
+export { ContextMenuRoot as Root } from "./root/ContextMenuRoot.js";
+export { ContextMenuTrigger as Trigger } from "./trigger/ContextMenuTrigger.js";
+export { MenuBackdrop as Backdrop } from "../menu/backdrop/MenuBackdrop.js";
+export { MenuPortal as Portal } from "../menu/portal/MenuPortal.js";
+export { MenuPositioner as Positioner } from "../menu/positioner/MenuPositioner.js";
+export { MenuPopup as Popup } from "../menu/popup/MenuPopup.js";
+export { MenuArrow as Arrow } from "../menu/arrow/MenuArrow.js";
+export { MenuGroup as Group } from "../menu/group/MenuGroup.js";
+export { MenuGroupLabel as GroupLabel } from "../menu/group-label/MenuGroupLabel.js";
+export { MenuItem as Item } from "../menu/item/MenuItem.js";
+export { MenuCheckboxItem as CheckboxItem } from "../menu/checkbox-item/MenuCheckboxItem.js";
+export { MenuCheckboxItemIndicator as CheckboxItemIndicator } from "../menu/checkbox-item-indicator/MenuCheckboxItemIndicator.js";
+export { MenuLinkItem as LinkItem } from "../menu/link-item/MenuLinkItem.js";
+export { MenuRadioGroup as RadioGroup } from "../menu/radio-group/MenuRadioGroup.js";
+export { MenuRadioItem as RadioItem } from "../menu/radio-item/MenuRadioItem.js";
+export { MenuRadioItemIndicator as RadioItemIndicator } from "../menu/radio-item-indicator/MenuRadioItemIndicator.js";
+export { MenuSubmenuRoot as SubmenuRoot } from "../menu/submenu-root/MenuSubmenuRoot.js";
+export { MenuSubmenuTrigger as SubmenuTrigger } from "../menu/submenu-trigger/MenuSubmenuTrigger.js";
+export { Separator } from "../separator/Separator.js";