@base-ui/react 1.3.0 → 1.4.0

package/esm/floating-ui-react/utils/composite.js

@@ -5,22 +5,22 @@ import { ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP } from "./constants.js";
 export function isDifferentGridRow(index, cols, prevRow) {
   return Math.floor(index / cols) !== prevRow;
 }
-export function isIndexOutOfListBounds(listRef, index) {
-  return index < 0 || index >= listRef.current.length;
+export function isIndexOutOfListBounds(list, index) {
+  return index < 0 || index >= list.length;
 }
 export function getMinListIndex(listRef, disabledIndices) {
-  return findNonDisabledListIndex(listRef, {
+  return findNonDisabledListIndex(listRef.current, {
     disabledIndices
   });
 }
 export function getMaxListIndex(listRef, disabledIndices) {
-  return findNonDisabledListIndex(listRef, {
+  return findNonDisabledListIndex(listRef.current, {
     decrement: true,
     startingIndex: listRef.current.length,
     disabledIndices
   });
 }
-export function findNonDisabledListIndex(listRef, {
+export function findNonDisabledListIndex(list, {
   startingIndex = -1,
   decrement = false,
   disabledIndices,
@@ -29,13 +29,14 @@ export function findNonDisabledListIndex(listRef, {
   let index = startingIndex;
   do {
     index += decrement ? -amount : amount;
-  } while (index >= 0 && index <= listRef.current.length - 1 && isListIndexDisabled(listRef, index, disabledIndices));
+  } while (index >= 0 && index <= list.length - 1 && isListIndexDisabled(list, index, disabledIndices));
   return index;
 }
-export function getGridNavigatedIndex(listRef, {
+export function getGridNavigatedIndex(list, {
   event,
   orientation,
   loopFocus,
+  onLoop,
   rtl,
   cols,
   disabledIndices,
@@ -63,7 +64,7 @@ export function getGridNavigatedIndex(listRef, {
     {
       let currentRowEl = null;
       let currentRowIndex = -1;
-      listRef.current.forEach((el, idx) => {
+      list.forEach((el, idx) => {
         if (el == null) {
           return;
         }
@@ -94,7 +95,7 @@ export function getGridNavigatedIndex(listRef, {
         }
       }
     }
-    const hasVirtualizedGaps = hasDomRows && visibleItemCount < listRef.current.length;
+    const hasVirtualizedGaps = hasDomRows && visibleItemCount < list.length;
     const verticalCols = inferredDomCols || cols;
     const navigateVertically = direction => {
       if (!hasDomRows || prevIndex === -1) {
@@ -112,11 +113,17 @@ export function getGridNavigatedIndex(listRef, {
             return undefined;
           }
           nextRow = nextRow < 0 ? rows.length - 1 : 0;
+          if (onLoop) {
+            const clampedCol = Math.min(colInRow, rows[nextRow].length - 1);
+            const targetItemIndex = rows[nextRow][clampedCol] ?? rows[nextRow][0];
+            const returnedItemIndex = onLoop(event, prevIndex, targetItemIndex);
+            nextRow = rowIndexMap[returnedItemIndex] ?? nextRow;
+          }
         }
         const targetRow = rows[nextRow];
         for (let col = Math.min(colInRow, targetRow.length - 1); col >= 0; col -= 1) {
           const candidate = targetRow[col];
-          if (!isListIndexDisabled(listRef, candidate, disabledIndices)) {
+          if (!isListIndexDisabled(list, candidate, disabledIndices)) {
             return candidate;
           }
         }
@@ -140,7 +147,7 @@ export function getGridNavigatedIndex(listRef, {
         }
         const rowEnd = Math.min(rowStart + verticalCols - 1, maxIndex);
         for (let candidate = Math.min(rowStart + colInRow, rowEnd); candidate >= rowStart; candidate -= 1) {
-          if (!isListIndexDisabled(listRef, candidate, disabledIndices)) {
+          if (!isListIndexDisabled(list, candidate, disabledIndices)) {
             return candidate;
           }
         }
@@ -156,7 +163,7 @@ export function getGridNavigatedIndex(listRef, {
     } else if (prevIndex === -1) {
       nextIndex = verticalDirection === 'up' ? maxIndex : minIndex;
     } else {
-      nextIndex = findNonDisabledListIndex(listRef, {
+      nextIndex = findNonDisabledListIndex(list, {
         startingIndex: prevIndex,
         amount: verticalCols,
         decrement: verticalDirection === 'up',
@@ -172,17 +179,23 @@ export function getGridNavigatedIndex(listRef, {
           } else {
             nextIndex = maxCol > col ? offset : offset - verticalCols;
           }
+          if (onLoop) {
+            nextIndex = onLoop(event, prevIndex, nextIndex);
+          }
         }
         if (verticalDirection === 'down' && prevIndex + verticalCols > maxIndex) {
-          nextIndex = findNonDisabledListIndex(listRef, {
+          nextIndex = findNonDisabledListIndex(list, {
             startingIndex: prevIndex % verticalCols - verticalCols,
             amount: verticalCols,
             disabledIndices
           });
+          if (onLoop) {
+            nextIndex = onLoop(event, prevIndex, nextIndex);
+          }
         }
       }
     }
-    if (isIndexOutOfListBounds(listRef, nextIndex)) {
+    if (isIndexOutOfListBounds(list, nextIndex)) {
       nextIndex = prevIndex;
     }
   }
@@ -195,21 +208,27 @@ export function getGridNavigatedIndex(listRef, {
         stopEvent(event);
       }
       if (prevIndex % cols !== cols - 1) {
-        nextIndex = findNonDisabledListIndex(listRef, {
+        nextIndex = findNonDisabledListIndex(list, {
           startingIndex: prevIndex,
           disabledIndices
         });
         if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
-          nextIndex = findNonDisabledListIndex(listRef, {
+          nextIndex = findNonDisabledListIndex(list, {
             startingIndex: prevIndex - prevIndex % cols - 1,
             disabledIndices
           });
+          if (onLoop) {
+            nextIndex = onLoop(event, prevIndex, nextIndex);
+          }
         }
       } else if (loopFocus) {
-        nextIndex = findNonDisabledListIndex(listRef, {
+        nextIndex = findNonDisabledListIndex(list, {
           startingIndex: prevIndex - prevIndex % cols - 1,
           disabledIndices
         });
+        if (onLoop) {
+          nextIndex = onLoop(event, prevIndex, nextIndex);
+        }
       }
       if (isDifferentGridRow(nextIndex, cols, prevRow)) {
         nextIndex = prevIndex;
@@ -220,36 +239,45 @@ export function getGridNavigatedIndex(listRef, {
         stopEvent(event);
       }
       if (prevIndex % cols !== 0) {
-        nextIndex = findNonDisabledListIndex(listRef, {
+        nextIndex = findNonDisabledListIndex(list, {
           startingIndex: prevIndex,
           decrement: true,
           disabledIndices
         });
         if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
-          nextIndex = findNonDisabledListIndex(listRef, {
+          nextIndex = findNonDisabledListIndex(list, {
             startingIndex: prevIndex + (cols - prevIndex % cols),
             decrement: true,
             disabledIndices
           });
+          if (onLoop) {
+            nextIndex = onLoop(event, prevIndex, nextIndex);
+          }
         }
       } else if (loopFocus) {
-        nextIndex = findNonDisabledListIndex(listRef, {
+        nextIndex = findNonDisabledListIndex(list, {
           startingIndex: prevIndex + (cols - prevIndex % cols),
           decrement: true,
           disabledIndices
         });
+        if (onLoop) {
+          nextIndex = onLoop(event, prevIndex, nextIndex);
+        }
       }
       if (isDifferentGridRow(nextIndex, cols, prevRow)) {
         nextIndex = prevIndex;
       }
     }
     const lastRow = floor(maxIndex / cols) === prevRow;
-    if (isIndexOutOfListBounds(listRef, nextIndex)) {
+    if (isIndexOutOfListBounds(list, nextIndex)) {
       if (loopFocus && lastRow) {
-        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(listRef, {
+        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(list, {
           startingIndex: prevIndex - prevIndex % cols - 1,
           disabledIndices
         });
+        if (onLoop) {
+          nextIndex = onLoop(event, prevIndex, nextIndex);
+        }
       } else {
         nextIndex = prevIndex;
       }
@@ -328,12 +356,12 @@ export function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {
 export function getGridCellIndices(indices, cellMap) {
   return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);
 }
-export function isListIndexDisabled(listRef, index, disabledIndices) {
+export function isListIndexDisabled(list, index, disabledIndices) {
   const isExplicitlyDisabled = typeof disabledIndices === 'function' ? disabledIndices(index) : disabledIndices?.includes(index) ?? false;
   if (isExplicitlyDisabled) {
     return true;
   }
-  const element = listRef.current[index];
+  const element = list[index];
   if (!element) {
     return false;
   }
@@ -343,5 +371,8 @@ export function isListIndexDisabled(listRef, index, disabledIndices) {
   return !disabledIndices && (element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true');
 }
 export function isElementVisible(element) {
+  if (typeof element.checkVisibility === 'function') {
+    return element.checkVisibility();
+  }
   return getComputedStyle(element).display !== 'none';
 }

package/esm/floating-ui-react/utils/element.d.ts

@@ -1,11 +1,11 @@
 import { type PopupTriggerMap } from "../../utils/popups/index.js";
-export declare function activeElement(doc: Document): Element | null;
-export declare function contains(parent?: Element | null, child?: Element | null): boolean;
+import { activeElement, contains, getTarget } from "./shadowDom.js";
+export { activeElement, contains, getTarget };
 export declare function isTargetInsideEnabledTrigger(target: EventTarget | null, triggerElements: PopupTriggerMap): boolean;
-export declare function getTarget(event: Event): EventTarget | null;
 export declare function isEventTargetWithin(event: Event, node: Node | null | undefined): boolean;
 export declare function isRootElement(element: Element): boolean;
 export declare function isTypeableElement(element: unknown): boolean;
+export declare function isInteractiveElement(element: Element | null): boolean;
 export declare function isTypeableCombobox(element: Element | null): boolean;
 export declare function matchesFocusVisible(element: Element | null): boolean;
 export declare function getFloatingFocusElement(floatingElement: HTMLElement | null | undefined): HTMLElement | null;

package/esm/floating-ui-react/utils/element.js

@@ -1,38 +1,8 @@
-import { isElement, isHTMLElement, isShadowRoot } from '@floating-ui/utils/dom';
+import { isElement, isHTMLElement } from '@floating-ui/utils/dom';
 import { isJSDOM } from '@base-ui/utils/detectBrowser';
 import { FOCUSABLE_ATTRIBUTE, TYPEABLE_SELECTOR } from "./constants.js";
-export function activeElement(doc) {
-  let element = doc.activeElement;
-  while (element?.shadowRoot?.activeElement != null) {
-    element = element.shadowRoot.activeElement;
-  }
-  return element;
-}
-export function contains(parent, child) {
-  if (!parent || !child) {
-    return false;
-  }
-  const rootNode = child.getRootNode?.();
-
-  // First, attempt with faster native method
-  if (parent.contains(child)) {
-    return true;
-  }
-
-  // then fallback to custom implementation with Shadow DOM support
-  if (rootNode && isShadowRoot(rootNode)) {
-    let next = child;
-    while (next) {
-      if (parent === next) {
-        return true;
-      }
-      next = next.parentNode || next.host;
-    }
-  }
-
-  // Give up, the result is false
-  return false;
-}
+import { activeElement, contains, getTarget } from "./shadowDom.js";
+export { activeElement, contains, getTarget };
 export function isTargetInsideEnabledTrigger(target, triggerElements) {
   if (!isElement(target)) {
     return false;
@@ -48,15 +18,6 @@ export function isTargetInsideEnabledTrigger(target, triggerElements) {
   }
   return false;
 }
-export function getTarget(event) {
-  if ('composedPath' in event) {
-    return event.composedPath()[0];
-  }
-
-  // TS thinks `event` is of type never as it assumes all browsers support
-  // `composedPath()`, but browsers without shadow DOM don't.
-  return event.target;
-}
 export function isEventTargetWithin(event, node) {
   if (node == null) {
     return false;
@@ -75,6 +36,9 @@ export function isRootElement(element) {
 export function isTypeableElement(element) {
   return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
 }
+export function isInteractiveElement(element) {
+  return element?.closest(`button,a[href],[role="button"],select,[tabindex]:not([tabindex="-1"]),${TYPEABLE_SELECTOR}`) != null;
+}
 export function isTypeableCombobox(element) {
   if (!element) {
     return false;

package/esm/floating-ui-react/utils/enqueueFocus.d.ts

@@ -1,8 +1,9 @@
-import type { FocusableElement } from 'tabbable';
+import type { FocusableElement } from "./tabbable.js";
+import { NOOP } from "../../utils/noop.js";
 interface Options {
   preventScroll?: boolean | undefined;
   cancelPrevious?: boolean | undefined;
   sync?: boolean | undefined;
 }
-export declare function enqueueFocus(el: FocusableElement | null, options?: Options): void;
+export declare function enqueueFocus(el: FocusableElement | null, options?: Options): typeof NOOP;
 export {};

package/esm/floating-ui-react/utils/enqueueFocus.js

@@ -1,3 +1,4 @@
+import { NOOP } from "../../utils/noop.js";
 let rafId = 0;
 export function enqueueFocus(el, options = {}) {
   const {
@@ -13,7 +14,14 @@ export function enqueueFocus(el, options = {}) {
   });
   if (sync) {
     exec();
-  } else {
-    rafId = requestAnimationFrame(exec);
+    return NOOP;
   }
+  const currentRafId = requestAnimationFrame(exec);
+  rafId = currentRafId;
+  return () => {
+    if (rafId === currentRafId) {
+      cancelAnimationFrame(currentRafId);
+      rafId = 0;
+    }
+  };
 }

package/esm/floating-ui-react/utils/getEmptyRootContext.js

@@ -3,12 +3,13 @@ import { FloatingRootStore } from "../components/FloatingRootStore.js";
 export function getEmptyRootContext() {
   return new FloatingRootStore({
     open: false,
+    transitionStatus: undefined,
     floatingElement: null,
     referenceElement: null,
     triggerElements: new PopupTriggerMap(),
     floatingId: '',
+    syncOnly: false,
     nested: false,
-    noEmit: false,
     onOpenChange: undefined
   });
 }

package/esm/floating-ui-react/utils/nodes.js

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-loop-func */
 
 export function getNodeChildren(nodes, id, onlyOpenChildren = true) {
-  const directChildren = nodes.filter(node => node.parentId === id && (!onlyOpenChildren || node.context?.open));
-  return directChildren.flatMap(child => [child, ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
+  const directChildren = nodes.filter(node => node.parentId === id);
+  return directChildren.flatMap(child => [...(!onlyOpenChildren || child.context?.open ? [child] : []), ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
 }
 export function getDeepestNode(nodes, id) {
   let deepestNodeId;

package/esm/floating-ui-react/utils/shadowDom.d.ts

@@ -0,0 +1,3 @@
+export declare function activeElement(doc: Document): Element | null;
+export declare function contains(parent?: Element | null, child?: Element | null): boolean;
+export declare function getTarget(event: Event): EventTarget | null;

package/esm/floating-ui-react/utils/shadowDom.js

@@ -0,0 +1,40 @@
+import { isShadowRoot } from '@floating-ui/utils/dom';
+export function activeElement(doc) {
+  let element = doc.activeElement;
+  while (element?.shadowRoot?.activeElement != null) {
+    element = element.shadowRoot.activeElement;
+  }
+  return element;
+}
+export function contains(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  const rootNode = child.getRootNode?.();
+
+  // First, attempt with the faster native method.
+  if (parent.contains(child)) {
+    return true;
+  }
+
+  // Then fall back to traversing out of shadow roots when needed.
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    while (next) {
+      if (parent === next) {
+        return true;
+      }
+      next = next.parentNode || next.host;
+    }
+  }
+  return false;
+}
+export function getTarget(event) {
+  if ('composedPath' in event) {
+    return event.composedPath()[0];
+  }
+
+  // TS assumes `composedPath()` always exists, but older browsers without
+  // shadow DOM support still fall back to `target`.
+  return event.target;
+}

package/esm/floating-ui-react/utils/tabbable.d.ts

@@ -1,8 +1,7 @@
-import { type FocusableElement } from 'tabbable';
-export declare const getTabbableOptions: () => {
-  readonly getShadowRoot: true;
-  readonly displayCheck: "none" | "full";
-};
+export type FocusableElement = HTMLElement | SVGElement;
+export declare function isTabbable(element: Element | null): boolean;
+export declare function focusable(container: Element): FocusableElement[];
+export declare function tabbable(container: Element): FocusableElement[];
 export declare function getNextTabbable(referenceElement: Element | null): FocusableElement | null;
 export declare function getPreviousTabbable(referenceElement: Element | null): FocusableElement | null;
 export declare function getTabbableAfterElement(referenceElement: Element | null): FocusableElement | null;

package/esm/floating-ui-react/utils/tabbable.js

@@ -1,16 +1,128 @@
-import { tabbable } from 'tabbable';
+import { getNodeName, isHTMLElement, isShadowRoot } from '@floating-ui/utils/dom';
 import { ownerDocument } from '@base-ui/utils/owner';
 import { activeElement, contains } from "./element.js";
-export const getTabbableOptions = () => ({
-  getShadowRoot: true,
-  displayCheck:
-  // JSDOM does not support the `tabbable` library. To solve this we can
-  // check if `ResizeObserver` is a real function (not polyfilled), which
-  // determines if the current environment is JSDOM-like.
-  typeof ResizeObserver === 'function' && ResizeObserver.toString().includes('[native code]') ? 'full' : 'none'
-});
+import { isElementVisible } from "./composite.js";
+const CANDIDATE_SELECTOR = 'a[href],button,input,select,textarea,summary,details,iframe,object,embed,[tabindex],[contenteditable]:not([contenteditable="false"]),audio[controls],video[controls]';
+function getParentElement(element) {
+  const assignedSlot = element.assignedSlot;
+  if (assignedSlot) {
+    return assignedSlot;
+  }
+  if (element.parentElement) {
+    return element.parentElement;
+  }
+  const rootNode = element.getRootNode();
+  return isShadowRoot(rootNode) ? rootNode.host : null;
+}
+function getDetailsSummary(details) {
+  for (const child of Array.from(details.children)) {
+    if (getNodeName(child) === 'summary') {
+      return child;
+    }
+  }
+  return null;
+}
+function isWithinOpenDetailsSummary(element, details) {
+  const summary = getDetailsSummary(details);
+  return !!summary && (element === summary || contains(summary, element));
+}
+function isFocusableCandidate(element) {
+  const nodeName = element ? getNodeName(element) : '';
+  return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== 'summary' || element.parentElement != null && getNodeName(element.parentElement) === 'details' && getDetailsSummary(element.parentElement) === element) && (nodeName !== 'details' || getDetailsSummary(element) == null) && (nodeName !== 'input' || element.type !== 'hidden');
+}
+function isFocusableElement(element) {
+  if (!isFocusableCandidate(element) || !element.isConnected || element.matches(':disabled')) {
+    return false;
+  }
+  for (let current = element; current; current = getParentElement(current)) {
+    const isSlot = getNodeName(current) === 'slot';
+    if (current.hasAttribute('inert')) {
+      return false;
+    }
+    if (current !== element && getNodeName(current) === 'details' && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute('hidden') || !isSlot && !isElementVisible(current)) {
+      return false;
+    }
+  }
+  return true;
+}
+function getTabIndex(element) {
+  const tabIndex = element.tabIndex;
+  if (tabIndex < 0) {
+    const nodeName = getNodeName(element);
+    if (nodeName === 'details' || nodeName === 'audio' || nodeName === 'video' || isHTMLElement(element) && element.isContentEditable) {
+      return 0;
+    }
+  }
+  return tabIndex;
+}
+function getNamedRadioInput(element) {
+  if (getNodeName(element) !== 'input') {
+    return null;
+  }
+  const input = element;
+  return input.type === 'radio' && input.name !== '' ? input : null;
+}
+function isTabbableRadio(element, candidates) {
+  const input = getNamedRadioInput(element);
+  if (!input) {
+    return true;
+  }
+  const checkedRadio = candidates.find(candidate => {
+    const radio = getNamedRadioInput(candidate);
+    return radio?.name === input.name && radio.form === input.form && radio.checked;
+  });
+  if (checkedRadio) {
+    return checkedRadio === input;
+  }
+  return candidates.find(candidate => {
+    const radio = getNamedRadioInput(candidate);
+    return radio?.name === input.name && radio.form === input.form;
+  }) === input;
+}
+function getComposedChildren(container) {
+  if (isHTMLElement(container) && getNodeName(container) === 'slot') {
+    const assignedElements = container.assignedElements({
+      flatten: true
+    });
+    if (assignedElements.length > 0) {
+      return assignedElements;
+    }
+  }
+  if (isHTMLElement(container) && container.shadowRoot) {
+    return Array.from(container.shadowRoot.children);
+  }
+  return Array.from(container.children);
+}
+function appendCandidates(container, list) {
+  getComposedChildren(container).forEach(child => {
+    if (isFocusableCandidate(child)) {
+      list.push(child);
+    }
+    appendCandidates(child, list);
+  });
+}
+function appendMatchingElements(container, selector, list) {
+  getComposedChildren(container).forEach(child => {
+    if (isHTMLElement(child) && child.matches(selector)) {
+      list.push(child);
+    }
+    appendMatchingElements(child, selector, list);
+  });
+}
+export function isTabbable(element) {
+  return isFocusableElement(element) && getTabIndex(element) >= 0;
+}
+export function focusable(container) {
+  const candidates = [];
+  appendCandidates(container, candidates);
+  return candidates.filter(isFocusableElement);
+}
+export function tabbable(container) {
+  const candidates = focusable(container);
+  return candidates.filter(element => getTabIndex(element) >= 0 && isTabbableRadio(element, candidates));
+}
 function getTabbableIn(container, dir) {
-  const list = tabbable(container, getTabbableOptions());
+  const list = tabbable(container);
   const len = list.length;
   if (len === 0) {
     return undefined;
@@ -31,7 +143,7 @@ function getTabbableNearElement(referenceElement, dir) {
   if (!referenceElement) {
     return null;
   }
-  const list = tabbable(ownerDocument(referenceElement).body, getTabbableOptions());
+  const list = tabbable(ownerDocument(referenceElement).body);
   const elementCount = list.length;
   if (elementCount === 0) {
     return null;
@@ -55,14 +167,15 @@ export function isOutsideEvent(event, container) {
   return !relatedTarget || !contains(containerElement, relatedTarget);
 }
 export function disableFocusInside(container) {
-  const tabbableElements = tabbable(container, getTabbableOptions());
+  const tabbableElements = tabbable(container);
   tabbableElements.forEach(element => {
     element.dataset.tabindex = element.getAttribute('tabindex') || '';
     element.setAttribute('tabindex', '-1');
   });
 }
 export function enableFocusInside(container) {
-  const elements = container.querySelectorAll('[data-tabindex]');
+  const elements = [];
+  appendMatchingElements(container, '[data-tabindex]', elements);
   elements.forEach(element => {
     const tabindex = element.dataset.tabindex;
     delete element.dataset.tabindex;

package/esm/form/Form.js

@@ -25,6 +25,7 @@ export const Form = /*#__PURE__*/React.forwardRef(function Form(componentProps,
     onSubmit,
     onFormSubmit,
     actionsRef,
+    style,
     ...elementProps
   } = componentProps;
   const formRef = React.useRef({

package/esm/index.d.ts

@@ -22,6 +22,7 @@ export * from "./merge-props/index.js";
 export * from "./meter/index.js";
 export * from "./navigation-menu/index.js";
 export * from "./number-field/index.js";
+export * from "./otp-field/index.js";
 export * from "./popover/index.js";
 export * from "./preview-card/index.js";
 export * from "./progress/index.js";

package/esm/index.js

@@ -1,5 +1,5 @@
 /**
- * @base-ui/react v1.3.0
+ * @base-ui/react v1.4.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -10,6 +10,8 @@ export * from "./alert-dialog/index.js";
 export * from "./autocomplete/index.js";
 export * from "./avatar/index.js";
 export * from "./button/index.js";
+// TODO Temporal: enable before public release
+// export * from './calendar';
 export * from "./checkbox/index.js";
 export * from "./checkbox-group/index.js";
 export * from "./collapsible/index.js";
@@ -29,6 +31,7 @@ export * from "./merge-props/index.js";
 export * from "./meter/index.js";
 export * from "./navigation-menu/index.js";
 export * from "./number-field/index.js";
+export * from "./otp-field/index.js";
 export * from "./popover/index.js";
 export * from "./preview-card/index.js";
 export * from "./progress/index.js";
@@ -40,6 +43,8 @@ export * from "./separator/index.js";
 export * from "./slider/index.js";
 export * from "./switch/index.js";
 export * from "./tabs/index.js";
+// TODO Temporal: enable before public release
+// export * from './localization-provider';
 export * from "./toast/index.js";
 export * from "./toggle/index.js";
 export * from "./toggle-group/index.js";

package/esm/input/Input.d.ts

@@ -12,7 +12,7 @@ export interface InputProps extends BaseUIComponentProps<'input', InputState> {
   /**
    * Callback fired when the `value` changes. Use when controlled.
    */
-  onValueChange?: Field.Control.Props['onValueChange'] | undefined;
+  onValueChange?: ((value: string, eventDetails: Input.ChangeEventDetails) => void) | undefined;
   /**
    * The default value of the input. Use when uncontrolled.
    */

package/esm/labelable-provider/useLabel.js

@@ -68,7 +68,6 @@ export function focusElementWithVisible(element) {
   element.focus({
     // Available from Chrome 144+ (January 2026).
     // Safari and Firefox already support it.
-    // @ts-expect-error not available in types yet
     focusVisible: true
   });
 }