@proyecto-viviana/solid-stately 0.5.1 → 0.6.0-rc.1

package/src/checkbox/createCheckboxGroupState.ts

@@ -1,3 +1,17 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/checkbox/useCheckboxGroupState.ts
+
 /**
  * Checkbox group state for Solid Stately
  *
@@ -7,10 +21,11 @@
  * This is a 1:1 port of @react-stately/checkbox's useCheckboxGroupState.
  */
 
-import { createMemo, createSignal, Accessor } from "solid-js";
-import { type MaybeAccessor, access } from "../utils";
+import { createMemo, Accessor } from "solid-js";
+import { access, createInternalSignal, readNow, type MaybeAccessor } from "../utils";
 import {
   createFormValidationState,
+  mergeValidation,
   type FormValidationState,
   type ValidationFunction,
   type ValidationResult,
@@ -84,6 +99,8 @@ export interface CheckboxGroupState extends Pick<
   removeValue(value: string): void;
   /** Toggles a value in the set of selected values. */
   toggleValue(value: string): void;
+  /** Records one checkbox's validation and merges it into the group. */
+  setInvalid(value: string, validation: ValidationResult): void;
 
   /** Current display validation result for the group. */
   readonly displayValidation: Accessor<ValidationResult>;
@@ -101,7 +118,7 @@ export function createCheckboxGroupState(
   const initialProps = getProps();
   const initialValue = initialProps.value ?? initialProps.defaultValue ?? [];
 
-  const [internalValue, setInternalValue] = createSignal<readonly string[]>(initialValue);
+  const [internalValue, setInternalValue] = createInternalSignal<readonly string[]>(initialValue);
 
   const controlledValue = createMemo<readonly string[] | undefined>(() => getProps().value);
 
@@ -112,6 +129,8 @@ export function createCheckboxGroupState(
     return controlled !== undefined ? controlled : internalValue();
   };
 
+  const liveValue = (): readonly string[] => (isControlled() ? value() : readNow(internalValue));
+
   const isRequired: Accessor<boolean> = () => {
     const p = getProps();
     return !!p.isRequired && value().length === 0;
@@ -161,9 +180,9 @@ export function createCheckboxGroupState(
       return;
     }
 
-    const current = value();
-    if (!current.includes(addVal)) {
-      setValue([...current, addVal]);
+    const snapshot = liveValue();
+    if (!snapshot.includes(addVal)) {
+      setValue([...snapshot, addVal]);
     }
   }
 
@@ -173,23 +192,35 @@ export function createCheckboxGroupState(
       return;
     }
 
-    const current = value();
-    if (current.includes(removeVal)) {
-      setValue(current.filter((v) => v !== removeVal));
+    const snapshot = liveValue();
+    if (snapshot.includes(removeVal)) {
+      setValue(snapshot.filter((v) => v !== removeVal));
     }
   }
 
+  const invalidValues = new Map<string, ValidationResult>();
+
+  function setInvalid(itemValue: string, result: ValidationResult): void {
+    if (result.isInvalid) {
+      invalidValues.set(itemValue, result);
+    } else {
+      invalidValues.delete(itemValue);
+    }
+
+    validation.updateValidation(mergeValidation(...invalidValues.values()));
+  }
+
   function toggleValue(toggleVal: string): void {
     const p = getProps();
     if (p.isReadOnly || p.isDisabled) {
       return;
     }
 
-    const current = value();
-    if (current.includes(toggleVal)) {
-      setValue(current.filter((v) => v !== toggleVal));
+    const snapshot = liveValue();
+    if (snapshot.includes(toggleVal)) {
+      setValue(snapshot.filter((v) => v !== toggleVal));
     } else {
-      setValue([...current, toggleVal]);
+      setValue([...snapshot, toggleVal]);
     }
   }
 
@@ -211,6 +242,7 @@ export function createCheckboxGroupState(
     addValue,
     removeValue,
     toggleValue,
+    setInvalid,
     realtimeValidation: validation.realtimeValidation,
     displayValidation: validation.displayValidation,
     updateValidation: validation.updateValidation,

package/src/collections/ListCollection.ts

@@ -1,6 +1,37 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/collections/BaseCollection.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/list/ListCollection.ts
+
 /**
  * A simple list collection implementation.
  * Provides a Collection interface over an array of nodes.
+ *
+ * Ported from:
+ * - packages/react-stately/src/list/ListCollection.ts
+ * - packages/react-aria/src/collections/BaseCollection.ts
  */
 
 import type { Collection, CollectionItemLike, CollectionNode, Key } from "./types";

package/src/collections/createListState.ts

@@ -1,11 +1,29 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/list/useListState.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/list/useSingleSelectListState.ts
+
 /**
  * State management for list-like components.
  * Combines collection and selection state.
- * Based on @react-stately/list.
+ * Ported from:
+ * - packages/react-stately/src/list/useListState.ts
+ * - packages/react-stately/src/list/useSingleSelectListState.ts
  */
 
-import { createMemo, createEffect, untrack, type Accessor } from "solid-js";
-import { access, type MaybeAccessor } from "../utils";
+import { createMemo, createEffect } from "solid-js";
+import type { Accessor } from "solid-js";
+import { propsAccessor, type MaybeAccessor } from "../utils";
 import { ListCollection } from "./ListCollection";
 import type { SelectionState, SelectionPressEvent } from "./createSelectionState";
 import { createMultipleSelectionState } from "../selection/createMultipleSelectionState";
@@ -73,7 +91,7 @@ export interface ListState<T = unknown> extends SelectionState {
 export function createListState<T = unknown>(
   props: MaybeAccessor<ListStateProps<T>>,
 ): ListState<T> {
-  const getProps = () => access(props);
+  const getProps = propsAccessor(props);
 
   // Build collection from items (memoized to avoid rebuilding on every access)
   const collection: Accessor<Collection<T>> = createMemo(() => {
@@ -242,9 +260,8 @@ export function createFilteredListState<T = unknown>(
   // forward (then backward) through the previous collection to the nearest
   // surviving, enabled item. Mirrors @react-stately's useFocusedKeyReset.
   let cachedCollection: Collection<T> | null = null;
-  createEffect(() => {
-    const coll = collection();
-    const focusedKey = untrack(() => state.focusedKey());
+  createEffect(collection, (coll) => {
+    const focusedKey = state.focusedKey();
     if (focusedKey != null && !coll.getItem(focusedKey) && cachedCollection) {
       let key = cachedCollection.getKeyAfter(focusedKey);
       let nextFocusedKey: Key | null = null;
@@ -267,7 +284,7 @@ export function createFilteredListState<T = unknown>(
           key = cachedCollection.getKeyBefore(key);
         }
       }
-      untrack(() => state.setFocusedKey(nextFocusedKey));
+      state.setFocusedKey(nextFocusedKey);
     }
     cachedCollection = coll;
   });
@@ -332,7 +349,7 @@ export interface SingleSelectListState<T = unknown> extends ListState<T> {
 export function createSingleSelectListState<T = unknown>(
   props: MaybeAccessor<SingleSelectListStateProps<T>>,
 ): SingleSelectListState<T> {
-  const getProps = () => access(props);
+  const getProps = propsAccessor(props);
 
   // Convert single selection props to multiple selection props
   const listState = createListState<T>({
@@ -359,7 +376,7 @@ export function createSingleSelectListState<T = unknown>(
     allowDuplicateSelectionEvents: true,
     get selectedKeys() {
       const key = getProps().selectedKey;
-      return key != null ? [key] : [];
+      return key !== undefined ? (key != null ? [key] : []) : undefined;
     },
     get defaultSelectedKeys() {
       const key = getProps().defaultSelectedKey;

package/src/collections/createMenuState.ts

@@ -1,9 +1,43 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/menu/useMenuTriggerState.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/menu/useSubmenuTriggerState.ts
+
 /**
  * State management for menu components.
- * Based on @react-stately/menu.
+ *
+ * createMenuTriggerState is ported from
+ * packages/react-stately/src/menu/useMenuTriggerState.ts.
+ * createSubmenuTriggerState is ported from
+ * packages/react-stately/src/menu/useSubmenuTriggerState.ts.
+ * createMenuState is a local composition of the separately attributed list state.
  */
 
-import { access, type MaybeAccessor } from "../utils";
+import { createInternalSignal, propsAccessor, type MaybeAccessor } from "../utils";
+
+import { createOverlayTriggerState, type OverlayTriggerProps } from "../overlays";
 import { createListState, type ListState, type ListStateProps } from "./createListState";
 import type { Key } from "./types";
 
@@ -26,7 +60,7 @@ export interface MenuState<T = unknown> extends ListState<T> {
 export function createMenuState<T = unknown>(
   props: MaybeAccessor<MenuStateProps<T>>,
 ): MenuState<T> {
-  const getProps = () => access(props);
+  const getProps = propsAccessor(props);
 
   // Menus default to action-only items, but can opt into single or multiple selection.
   const listState = createListState<T>({
@@ -84,32 +118,173 @@ export function createMenuState<T = unknown>(
   };
 }
 
-export interface MenuTriggerStateProps {
-  /** Whether the menu is open (controlled). */
-  isOpen?: boolean;
-  /** Default open state (uncontrolled). */
-  defaultOpen?: boolean;
-  /** Handler called when the open state changes. */
-  onOpenChange?: (isOpen: boolean) => void;
+export type MenuTriggerType = "press" | "longPress" | "contextMenu";
+
+export interface MenuTriggerProps extends OverlayTriggerProps {
+  /** How the menu is triggered. */
+  trigger?: MenuTriggerType;
 }
 
+/** @deprecated Use `MenuTriggerProps`. */
+export interface MenuTriggerStateProps extends MenuTriggerProps {}
+
 export interface MenuTriggerState {
   /** Whether the menu is open. */
   readonly isOpen: () => boolean;
+  /** Sets whether the menu is open. */
+  setOpen(isOpen: boolean): void;
   /** Open the menu. */
-  open(): void;
+  open(focusStrategy?: "first" | "last" | null): void;
   /** Close the menu. */
   close(): void;
   /** Toggle the menu. */
-  toggle(): void;
+  toggle(focusStrategy?: "first" | "last" | null): void;
   /** Focus strategy for when the menu opens. */
   readonly focusStrategy: () => "first" | "last" | null;
   /** Set the focus strategy. */
   setFocusStrategy(strategy: "first" | "last" | null): void;
+  /** Cursor position relative to the window viewport. */
+  readonly point: () => { x: number; y: number } | null;
+  /** Sets the cursor position relative to the window viewport. */
+  setPoint(point: { x: number; y: number }): void;
+}
+
+export interface RootMenuTriggerState extends MenuTriggerState {
+  /** Opens a submenu tied to a menu item at a level. */
+  openSubmenu(triggerKey: Key, level: number): void;
+  /** Closes a submenu tied to a menu item at a level. */
+  closeSubmenu(triggerKey: Key, level: number): void;
+  /**
+   * Open submenu trigger keys. The index matches the submenu level.
+   */
+  readonly expandedKeysStack: () => Key[];
 }
 
 /**
- * Creates state for a menu trigger (button that opens a menu).
- * This is essentially the same as overlay trigger state but with focus strategy.
+ * Creates state for a menu trigger. Mirrors `@react-stately/menu` `useMenuTriggerState`:
+ * overlay open state, the focus strategy passed through to `createMenu`, and the
+ * expanded submenu stack.
  */
-export { createOverlayTriggerState as createMenuTriggerState } from "../overlays";
+export function createMenuTriggerState(
+  props: MaybeAccessor<MenuTriggerProps> = {},
+): RootMenuTriggerState {
+  const overlay = createOverlayTriggerState(props);
+  const [focusStrategy, setFocusStrategy] = createInternalSignal<"first" | "last" | null>(null);
+  const [expandedKeysStack, setExpandedKeysStack] = createInternalSignal<Key[]>([]);
+
+  const openSubmenu = (triggerKey: Key, level: number) => {
+    setExpandedKeysStack((oldStack) => {
+      if (level > oldStack.length) {
+        return oldStack;
+      }
+      return [...oldStack.slice(0, level), triggerKey];
+    });
+  };
+
+  const closeSubmenu = (triggerKey: Key, level: number) => {
+    setExpandedKeysStack((oldStack) => {
+      if (oldStack[level] !== triggerKey) {
+        return oldStack;
+      }
+      return oldStack.slice(0, level);
+    });
+  };
+
+  const close = () => {
+    setExpandedKeysStack([]);
+    overlay.close();
+  };
+
+  return {
+    ...overlay,
+    focusStrategy,
+    setFocusStrategy,
+    open(strategy: "first" | "last" | null = null) {
+      setFocusStrategy(strategy);
+      overlay.open();
+    },
+    toggle(strategy: "first" | "last" | null = null) {
+      setFocusStrategy(strategy);
+      overlay.toggle();
+    },
+    close,
+    expandedKeysStack,
+    openSubmenu,
+    closeSubmenu,
+  };
+}
+
+export interface SubmenuTriggerProps {
+  /** Key of the trigger item. */
+  triggerKey: Key;
+}
+
+export interface SubmenuTriggerState {
+  /** Whether the submenu is currently open. */
+  readonly isOpen: () => boolean;
+  /** Controls which item will be auto focused when the submenu opens. */
+  readonly focusStrategy: () => "first" | "last" | null;
+  /** The level of the submenu, frozen when the state is created. */
+  readonly submenuLevel: number;
+  /** Opens the submenu. */
+  open(focusStrategy?: "first" | "last" | null): void;
+  /** Closes the submenu. */
+  close(): void;
+  /** Closes the root menu and every submenu in the tree. */
+  closeAll(): void;
+  /** Toggles the submenu. */
+  toggle(focusStrategy?: "first" | "last" | null): void;
+  /** @private Placeholder so this state can sit where an overlay trigger state sits. */
+  setOpen(): void;
+  /** Submenus do not track a cursor point. */
+  readonly point: null;
+  /** @private */
+  setPoint(): void;
+}
+
+/**
+ * Creates state for a submenu trigger. Mirrors `@react-stately/menu`
+ * `useSubmenuTriggerState`: open state is the root stack entry at this level.
+ */
+export function createSubmenuTriggerState(
+  props: MaybeAccessor<SubmenuTriggerProps>,
+  state: RootMenuTriggerState,
+): SubmenuTriggerState {
+  const getProps = propsAccessor(props);
+  const submenuLevel = state.expandedKeysStack().length;
+  const [focusStrategy, setFocusStrategy] = createInternalSignal<"first" | "last" | null>(null);
+
+  const isOpen = () => state.expandedKeysStack()[submenuLevel] === getProps().triggerKey;
+
+  const open = (strategy?: "first" | "last" | null) => {
+    setFocusStrategy(strategy ?? null);
+    state.openSubmenu(getProps().triggerKey, submenuLevel);
+  };
+
+  const close = () => {
+    setFocusStrategy(null);
+    state.closeSubmenu(getProps().triggerKey, submenuLevel);
+  };
+
+  const toggle = (strategy?: "first" | "last" | null) => {
+    setFocusStrategy(strategy ?? null);
+    if (isOpen()) {
+      close();
+    } else {
+      open(strategy);
+    }
+  };
+
+  return {
+    focusStrategy,
+    isOpen,
+    open,
+    close,
+    closeAll: () => state.close(),
+    submenuLevel,
+    setOpen() {},
+    toggle,
+    point: null,
+    setPoint() {},
+  };
+}

package/src/collections/createSelectionState.ts

@@ -1,14 +1,31 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/SelectionManager.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/useMultipleSelectionState.ts
+
 /**
  * Selection state management for collections.
- * Based on @react-stately/selection.
+ * Ported from:
+ * - packages/react-stately/src/selection/useMultipleSelectionState.ts
+ * - packages/react-stately/src/selection/SelectionManager.ts
  */
 
-import { createSignal, createMemo, type Accessor } from "solid-js";
-import { access, type MaybeAccessor } from "../utils";
+import { createMemo } from "solid-js";
+import type { Accessor } from "solid-js";
+import { createInternalSignal, propsAccessor, readNow, type MaybeAccessor } from "../utils";
 import type {
   Collection,
   DisabledBehavior,
-  FocusStrategy,
   Key,
   Selection,
   SelectionBehavior,
@@ -100,18 +117,18 @@ export interface SelectionPressEvent {
 export function createSelectionState(
   props: MaybeAccessor<SelectionStateProps> = {},
 ): SelectionState {
-  const getProps = () => access(props);
+  const getProps = propsAccessor(props);
 
   // Selection behavior state
-  const [internalBehavior, setInternalBehavior] = createSignal<SelectionBehavior>("toggle");
+  const [internalBehavior, setInternalBehavior] = createInternalSignal<SelectionBehavior>("toggle");
 
   // Internal selection state
-  const [internalSelectedKeys, setInternalSelectedKeys] = createSignal<Selection>(
+  const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal<Selection>(
     getInitialSelection(getProps().defaultSelectedKeys),
   );
 
   // Track anchor for range selection
-  const [anchorKey, setAnchorKey] = createSignal<Key | null>(null);
+  const [anchorKey, setAnchorKey] = createInternalSignal<Key | null>(null);
 
   // Computed values
   const selectionMode: Accessor<SelectionMode> = () => getProps().selectionMode ?? "none";
@@ -124,13 +141,13 @@ export function createSelectionState(
     return getProps().disallowEmptySelection ?? false;
   };
 
-  const selectedKeys: Accessor<Selection> = createMemo(() => {
+  const selectedKeys: Accessor<Selection> = () => {
     const p = getProps();
     if (p.selectedKeys !== undefined) {
       return normalizeSelection(p.selectedKeys);
     }
     return internalSelectedKeys();
-  });
+  };
 
   const disabledKeys: Accessor<Set<Key>> = createMemo(() => {
     const keys = getProps().disabledKeys;
@@ -151,8 +168,11 @@ export function createSelectionState(
   };
 
   // Methods
+  const liveSelectedKeys = (): Selection =>
+    getProps().selectedKeys !== undefined ? selectedKeys() : readNow(internalSelectedKeys);
+
   const isSelected = (key: Key): boolean => {
-    const keys = selectedKeys();
+    const keys = liveSelectedKeys();
     if (keys === "all") return true;
     return keys.has(key);
   };
@@ -171,7 +191,7 @@ export function createSelectionState(
     }
 
     // Uncontrolled mode
-    const current = internalSelectedKeys();
+    const current = readNow(internalSelectedKeys);
     const isDifferent =
       current === "all" ||
       newSelection === "all" ||
@@ -188,7 +208,7 @@ export function createSelectionState(
     if (isDisabled(key)) return;
     if (selectionMode() === "none") return;
 
-    const current = selectedKeys();
+    const current = liveSelectedKeys();
 
     if (selectionMode() === "single") {
       if (isSelected(key) && !disallowEmptySelection()) {

package/src/collections/getChildNodes.ts

@@ -1,7 +1,24 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/collections/getChildNodes.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/collections/getItemCount.ts
+
 /**
  * Helpers for traversing collection nodes and comparing their document order.
  *
- * Based on @react-stately/collections.
+ * Ported from:
+ * - packages/react-stately/src/collections/getChildNodes.ts
+ * - packages/react-stately/src/collections/getItemCount.ts
  */
 
 import type { Collection, CollectionNode } from "./types";
@@ -51,8 +68,8 @@ const itemCountCache = new WeakMap<Collection<unknown>, number>();
 
 /**
  * Counts the item nodes (recursing into sections, ignoring section headers and
- * other non-item nodes) in a collection. Faithful port of
- * @react-stately/collections `getItemCount`; used by createOption to populate
+ * other non-item nodes) in a collection. Ported from
+ * packages/react-stately/src/collections/getItemCount.ts; used by createOption to populate
  * `aria-setsize` when the listbox is virtualized. Cached per (immutable)
  * collection identity, exactly like upstream.
  */

package/src/collections/index.ts

@@ -46,8 +46,14 @@ export {
 export {
   createMenuState,
   createMenuTriggerState,
+  createSubmenuTriggerState,
   type MenuStateProps,
   type MenuState,
+  type MenuTriggerType,
+  type MenuTriggerProps,
   type MenuTriggerStateProps,
   type MenuTriggerState,
+  type RootMenuTriggerState,
+  type SubmenuTriggerProps,
+  type SubmenuTriggerState,
 } from "./createMenuState";