@base-ui/react 1.6.0 → 1.7.0

package/tooltip/provider/TooltipProviderContext.mjs

@@ -1,6 +1,10 @@
 'use client';
 
 import * as React from 'react';
+
+/**
+ * Holds the provider's `delay` value. `closeDelay` is handled by the delay group.
+ */
 export const TooltipProviderContext = /*#__PURE__*/React.createContext(undefined);
 if (process.env.NODE_ENV !== "production") TooltipProviderContext.displayName = "TooltipProviderContext";
 export function useTooltipProviderContext() {

package/tooltip/root/TooltipRoot.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.TooltipRoot = void 0;
 var React = _interopRequireWildcard(require("react"));
 var _fastHooks = require("@base-ui/utils/fastHooks");
+var _empty = require("@base-ui/utils/empty");
 var _useIsoLayoutEffect = require("@base-ui/utils/useIsoLayoutEffect");
 var _TooltipRootContext = require("./TooltipRootContext");
 var _floatingUiReact = require("../../floating-ui-react");
@@ -38,13 +39,12 @@ const TooltipRoot = exports.TooltipRoot = (0, _fastHooks.fastComponent)(function
     defaultTriggerId: defaultTriggerIdProp = null,
     children
   } = props;
-  const store = _TooltipStore.TooltipStore.useStore(handle?.store, {
+  const store = (0, _popups.usePopupRootStore)((floatingId, nested) => new _TooltipStore.TooltipStore({
     open: defaultOpen,
     openProp,
     activeTriggerId: defaultTriggerIdProp,
     triggerIdProp
-  });
-  (0, _popups.useInitialOpenSync)(store, openProp, defaultOpen, defaultTriggerIdProp);
+  }, floatingId, nested));
   store.useControlledProp('openProp', openProp);
   store.useControlledProp('triggerIdProp', triggerIdProp);
   store.useContextCallback('onOpenChange', onOpenChange);
@@ -56,9 +56,9 @@ const TooltipRoot = exports.TooltipRoot = (0, _fastHooks.fastComponent)(function
   const payload = store.useState('payload');
   store.useSyncedValues({
     trackCursorAxis,
-    disableHoverablePopup
+    disableHoverablePopup,
+    disabled
   });
-  store.useSyncedValue('disabled', disabled);
   (0, _popups.useImplicitActiveTrigger)(store, {
     closeOnActiveTriggerUnmount: true
   });
@@ -102,17 +102,17 @@ const TooltipRoot = exports.TooltipRoot = (0, _fastHooks.fastComponent)(function
       }
     }
   }, [store, activeTriggerId, open]);
-  const handleImperativeClose = React.useCallback(() => {
-    store.setOpen(false, (0, _createBaseUIEventDetails.createChangeEventDetails)(_reasons.REASONS.imperativeAction));
-  }, [store]);
   React.useImperativeHandle(actionsRef, () => ({
     unmount: forceUnmount,
-    close: handleImperativeClose
-  }), [forceUnmount, handleImperativeClose]);
+    close: () => store.setOpen(false, (0, _createBaseUIEventDetails.createChangeEventDetails)(_reasons.REASONS.imperativeAction))
+  }), [forceUnmount, store]);
   const shouldRenderInteractions = open || mounted || !disabled && trackCursorAxis !== 'none';
   return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_TooltipRootContext.TooltipRootContext.Provider, {
     value: store,
-    children: [shouldRenderInteractions && /*#__PURE__*/(0, _jsxRuntime.jsx)(TooltipInteractions, {
+    children: [handle && /*#__PURE__*/(0, _jsxRuntime.jsx)(_popups.PopupHandleAttachment, {
+      handle: handle,
+      store: store
+    }), shouldRenderInteractions && /*#__PURE__*/(0, _jsxRuntime.jsx)(TooltipInteractions, {
       store: store,
       disabled: disabled,
       trackCursorAxis: trackCursorAxis
@@ -136,13 +136,14 @@ function TooltipInteractions({
     enabled: !disabled && trackCursorAxis !== 'none',
     axis: trackCursorAxis === 'none' ? undefined : trackCursorAxis
   });
-  const activeTriggerProps = React.useMemo(() => (0, _mergeProps.mergeProps)(clientPoint.reference, dismiss.reference), [clientPoint.reference, dismiss.reference]);
-  const inactiveTriggerProps = React.useMemo(() => (0, _mergeProps.mergeProps)(clientPoint.trigger, dismiss.trigger), [clientPoint.trigger, dismiss.trigger]);
-  const popupProps = React.useMemo(() => (0, _mergeProps.mergeProps)(_popups.FOCUSABLE_POPUP_PROPS, clientPoint.floating, dismiss.floating), [clientPoint.floating, dismiss.floating]);
+
+  // Both hooks return `trigger: reference` (same object identity), so the active and
+  // inactive trigger props can never differ. `useClientPoint` has no floating-side props.
+  const triggerProps = React.useMemo(() => (0, _mergeProps.mergeProps)(clientPoint.reference, dismiss.reference), [clientPoint.reference, dismiss.reference]);
   (0, _popups.usePopupInteractionProps)(store, {
-    activeTriggerProps,
-    inactiveTriggerProps,
-    popupProps
+    activeTriggerProps: triggerProps,
+    inactiveTriggerProps: triggerProps,
+    popupProps: dismiss.floating ?? _empty.EMPTY_OBJECT
   });
   return null;
 }

package/tooltip/root/TooltipRoot.mjs

@@ -2,11 +2,12 @@
 
 import * as React from 'react';
 import { fastComponent } from '@base-ui/utils/fastHooks';
+import { EMPTY_OBJECT } from '@base-ui/utils/empty';
 import { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';
 import { TooltipRootContext } from "./TooltipRootContext.mjs";
 import { useClientPoint, useDismiss } from "../../floating-ui-react/index.mjs";
 import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.mjs";
-import { FOCUSABLE_POPUP_PROPS, useImplicitActiveTrigger, useInitialOpenSync, useOpenStateTransitions, usePopupInteractionProps } from "../../utils/popups/index.mjs";
+import { PopupHandleAttachment, useImplicitActiveTrigger, usePopupRootStore, useOpenStateTransitions, usePopupInteractionProps } from "../../utils/popups/index.mjs";
 import { mergeProps } from "../../merge-props/index.mjs";
 import { TooltipStore } from "../store/TooltipStore.mjs";
 import { REASONS } from "../../internals/reasons.mjs";
@@ -33,13 +34,12 @@ export const TooltipRoot = fastComponent(function TooltipRoot(props) {
     defaultTriggerId: defaultTriggerIdProp = null,
     children
   } = props;
-  const store = TooltipStore.useStore(handle?.store, {
+  const store = usePopupRootStore((floatingId, nested) => new TooltipStore({
     open: defaultOpen,
     openProp,
     activeTriggerId: defaultTriggerIdProp,
     triggerIdProp
-  });
-  useInitialOpenSync(store, openProp, defaultOpen, defaultTriggerIdProp);
+  }, floatingId, nested));
   store.useControlledProp('openProp', openProp);
   store.useControlledProp('triggerIdProp', triggerIdProp);
   store.useContextCallback('onOpenChange', onOpenChange);
@@ -51,9 +51,9 @@ export const TooltipRoot = fastComponent(function TooltipRoot(props) {
   const payload = store.useState('payload');
   store.useSyncedValues({
     trackCursorAxis,
-    disableHoverablePopup
+    disableHoverablePopup,
+    disabled
   });
-  store.useSyncedValue('disabled', disabled);
   useImplicitActiveTrigger(store, {
     closeOnActiveTriggerUnmount: true
   });
@@ -97,17 +97,17 @@ export const TooltipRoot = fastComponent(function TooltipRoot(props) {
       }
     }
   }, [store, activeTriggerId, open]);
-  const handleImperativeClose = React.useCallback(() => {
-    store.setOpen(false, createChangeEventDetails(REASONS.imperativeAction));
-  }, [store]);
   React.useImperativeHandle(actionsRef, () => ({
     unmount: forceUnmount,
-    close: handleImperativeClose
-  }), [forceUnmount, handleImperativeClose]);
+    close: () => store.setOpen(false, createChangeEventDetails(REASONS.imperativeAction))
+  }), [forceUnmount, store]);
   const shouldRenderInteractions = open || mounted || !disabled && trackCursorAxis !== 'none';
   return /*#__PURE__*/_jsxs(TooltipRootContext.Provider, {
     value: store,
-    children: [shouldRenderInteractions && /*#__PURE__*/_jsx(TooltipInteractions, {
+    children: [handle && /*#__PURE__*/_jsx(PopupHandleAttachment, {
+      handle: handle,
+      store: store
+    }), shouldRenderInteractions && /*#__PURE__*/_jsx(TooltipInteractions, {
       store: store,
       disabled: disabled,
       trackCursorAxis: trackCursorAxis
@@ -131,13 +131,14 @@ function TooltipInteractions({
     enabled: !disabled && trackCursorAxis !== 'none',
     axis: trackCursorAxis === 'none' ? undefined : trackCursorAxis
   });
-  const activeTriggerProps = React.useMemo(() => mergeProps(clientPoint.reference, dismiss.reference), [clientPoint.reference, dismiss.reference]);
-  const inactiveTriggerProps = React.useMemo(() => mergeProps(clientPoint.trigger, dismiss.trigger), [clientPoint.trigger, dismiss.trigger]);
-  const popupProps = React.useMemo(() => mergeProps(FOCUSABLE_POPUP_PROPS, clientPoint.floating, dismiss.floating), [clientPoint.floating, dismiss.floating]);
+
+  // Both hooks return `trigger: reference` (same object identity), so the active and
+  // inactive trigger props can never differ. `useClientPoint` has no floating-side props.
+  const triggerProps = React.useMemo(() => mergeProps(clientPoint.reference, dismiss.reference), [clientPoint.reference, dismiss.reference]);
   usePopupInteractionProps(store, {
-    activeTriggerProps,
-    inactiveTriggerProps,
-    popupProps
+    activeTriggerProps: triggerProps,
+    inactiveTriggerProps: triggerProps,
+    popupProps: dismiss.floating ?? EMPTY_OBJECT
   });
   return null;
 }

package/tooltip/store/TooltipHandle.d.mts

@@ -1,29 +1,32 @@
-import { TooltipStore } from "./TooltipStore.mjs";
+import { TooltipStore, type TooltipHandleStore } from "./TooltipStore.mjs";
+import { BasePopupHandle } from "../../utils/popups/popupHandle.mjs";
 /**
- * A handle to control a tooltip imperatively and to associate detached triggers with it.
+ * Controls a Tooltip imperatively and associates detached `Tooltip.Trigger` components with a
+ * `Tooltip.Root`. Create one with `Tooltip.createHandle()` and pass it to the `handle` prop of the
+ * root and of any triggers rendered outside of it.
+ *
+ * The imperative methods take effect only while a root using this handle is mounted; calls made
+ * before a root attaches (or after it unmounts) are ignored.
  */
-export declare class TooltipHandle<Payload> {
-  /**
-   * Internal store holding the tooltip state.
-   * @internal
-   */
-  readonly store: TooltipStore<Payload>;
+export declare class TooltipHandle<Payload> extends BasePopupHandle<TooltipHandleStore<Payload>, TooltipStore<Payload>> {
   constructor();
   /**
-   * Opens the tooltip and associates it with the trigger with the given ID.
-   * The trigger must be a Tooltip.Trigger component with this handle passed as a prop.
+   * Opens the tooltip and associates it with the trigger with the given id.
    *
    * This method should only be called in an event handler or an effect (not during rendering).
    *
-   * @param triggerId ID of the trigger to associate with the tooltip.
+   * @param triggerId ID of the trigger to associate with the tooltip. The trigger must be a matching
+   * `Tooltip.Trigger` with this handle passed as a prop.
    */
   open(triggerId: string): void;
   /**
    * Closes the tooltip.
+   *
+   * This method should only be called in an event handler or an effect (not during rendering).
    */
   close(): void;
   /**
-   * Indicates whether the tooltip is currently open.
+   * Whether the tooltip is currently open. Returns `false` while no root is attached to the handle.
    */
   get isOpen(): boolean;
 }

package/tooltip/store/TooltipHandle.d.ts

@@ -1,29 +1,32 @@
-import { TooltipStore } from "./TooltipStore.js";
+import { TooltipStore, type TooltipHandleStore } from "./TooltipStore.js";
+import { BasePopupHandle } from "../../utils/popups/popupHandle.js";
 /**
- * A handle to control a tooltip imperatively and to associate detached triggers with it.
+ * Controls a Tooltip imperatively and associates detached `Tooltip.Trigger` components with a
+ * `Tooltip.Root`. Create one with `Tooltip.createHandle()` and pass it to the `handle` prop of the
+ * root and of any triggers rendered outside of it.
+ *
+ * The imperative methods take effect only while a root using this handle is mounted; calls made
+ * before a root attaches (or after it unmounts) are ignored.
  */
-export declare class TooltipHandle<Payload> {
-  /**
-   * Internal store holding the tooltip state.
-   * @internal
-   */
-  readonly store: TooltipStore<Payload>;
+export declare class TooltipHandle<Payload> extends BasePopupHandle<TooltipHandleStore<Payload>, TooltipStore<Payload>> {
   constructor();
   /**
-   * Opens the tooltip and associates it with the trigger with the given ID.
-   * The trigger must be a Tooltip.Trigger component with this handle passed as a prop.
+   * Opens the tooltip and associates it with the trigger with the given id.
    *
    * This method should only be called in an event handler or an effect (not during rendering).
    *
-   * @param triggerId ID of the trigger to associate with the tooltip.
+   * @param triggerId ID of the trigger to associate with the tooltip. The trigger must be a matching
+   * `Tooltip.Trigger` with this handle passed as a prop.
    */
   open(triggerId: string): void;
   /**
    * Closes the tooltip.
+   *
+   * This method should only be called in an event handler or an effect (not during rendering).
    */
   close(): void;
   /**
-   * Indicates whether the tooltip is currently open.
+   * Whether the tooltip is currently open. Returns `false` while no root is attached to the handle.
    */
   get isOpen(): boolean;
 }

package/tooltip/store/TooltipHandle.js

@@ -1,56 +1,51 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.TooltipHandle = void 0;
 exports.createTooltipHandle = createTooltipHandle;
-var _formatErrorMessage2 = _interopRequireDefault(require("@base-ui/utils/formatErrorMessage"));
 var _TooltipStore = require("./TooltipStore");
-var _createBaseUIEventDetails = require("../../internals/createBaseUIEventDetails");
-var _reasons = require("../../internals/reasons");
+var _popupHandle = require("../../utils/popups/popupHandle");
 /**
- * A handle to control a tooltip imperatively and to associate detached triggers with it.
+ * Controls a Tooltip imperatively and associates detached `Tooltip.Trigger` components with a
+ * `Tooltip.Root`. Create one with `Tooltip.createHandle()` and pass it to the `handle` prop of the
+ * root and of any triggers rendered outside of it.
+ *
+ * The imperative methods take effect only while a root using this handle is mounted; calls made
+ * before a root attaches (or after it unmounts) are ignored.
  */
-class TooltipHandle {
-  /**
-   * Internal store holding the tooltip state.
-   * @internal
-   */
-
+class TooltipHandle extends _popupHandle.BasePopupHandle {
   constructor() {
-    this.store = new _TooltipStore.TooltipStore();
+    super((0, _TooltipStore.createNullTooltipStore)(), 'Tooltip');
   }
 
   /**
-   * Opens the tooltip and associates it with the trigger with the given ID.
-   * The trigger must be a Tooltip.Trigger component with this handle passed as a prop.
+   * Opens the tooltip and associates it with the trigger with the given id.
    *
    * This method should only be called in an event handler or an effect (not during rendering).
    *
-   * @param triggerId ID of the trigger to associate with the tooltip.
+   * @param triggerId ID of the trigger to associate with the tooltip. The trigger must be a matching
+   * `Tooltip.Trigger` with this handle passed as a prop.
    */
   open(triggerId) {
-    const triggerElement = triggerId ? this.store.context.triggerElements.getById(triggerId) : undefined;
-    if (triggerId && !triggerElement) {
-      throw new Error(process.env.NODE_ENV !== "production" ? `Base UI: TooltipHandle.open: No trigger found with id "${triggerId}".` : (0, _formatErrorMessage2.default)(81, triggerId));
-    }
-    this.store.setOpen(true, (0, _createBaseUIEventDetails.createChangeEventDetails)(_reasons.REASONS.imperativeAction, undefined, triggerElement));
+    this.openByTrigger(triggerId);
   }
 
   /**
    * Closes the tooltip.
+   *
+   * This method should only be called in an event handler or an effect (not during rendering).
    */
   close() {
-    this.store.setOpen(false, (0, _createBaseUIEventDetails.createChangeEventDetails)(_reasons.REASONS.imperativeAction, undefined, undefined));
+    this.closePopup();
   }
 
   /**
-   * Indicates whether the tooltip is currently open.
+   * Whether the tooltip is currently open. Returns `false` while no root is attached to the handle.
    */
   get isOpen() {
-    return this.store.select('open');
+    return this.attachedStore?.select('open') ?? false;
   }
 }
 

package/tooltip/store/TooltipHandle.mjs

@@ -1,49 +1,45 @@
-import _formatErrorMessage from "@base-ui/utils/formatErrorMessage";
-import { TooltipStore } from "./TooltipStore.mjs";
-import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.mjs";
-import { REASONS } from "../../internals/reasons.mjs";
+import { createNullTooltipStore } from "./TooltipStore.mjs";
+import { BasePopupHandle } from "../../utils/popups/popupHandle.mjs";
 
 /**
- * A handle to control a tooltip imperatively and to associate detached triggers with it.
+ * Controls a Tooltip imperatively and associates detached `Tooltip.Trigger` components with a
+ * `Tooltip.Root`. Create one with `Tooltip.createHandle()` and pass it to the `handle` prop of the
+ * root and of any triggers rendered outside of it.
+ *
+ * The imperative methods take effect only while a root using this handle is mounted; calls made
+ * before a root attaches (or after it unmounts) are ignored.
  */
-export class TooltipHandle {
-  /**
-   * Internal store holding the tooltip state.
-   * @internal
-   */
-
+export class TooltipHandle extends BasePopupHandle {
   constructor() {
-    this.store = new TooltipStore();
+    super(createNullTooltipStore(), 'Tooltip');
   }
 
   /**
-   * Opens the tooltip and associates it with the trigger with the given ID.
-   * The trigger must be a Tooltip.Trigger component with this handle passed as a prop.
+   * Opens the tooltip and associates it with the trigger with the given id.
    *
    * This method should only be called in an event handler or an effect (not during rendering).
    *
-   * @param triggerId ID of the trigger to associate with the tooltip.
+   * @param triggerId ID of the trigger to associate with the tooltip. The trigger must be a matching
+   * `Tooltip.Trigger` with this handle passed as a prop.
    */
   open(triggerId) {
-    const triggerElement = triggerId ? this.store.context.triggerElements.getById(triggerId) : undefined;
-    if (triggerId && !triggerElement) {
-      throw new Error(process.env.NODE_ENV !== "production" ? `Base UI: TooltipHandle.open: No trigger found with id "${triggerId}".` : _formatErrorMessage(81, triggerId));
-    }
-    this.store.setOpen(true, createChangeEventDetails(REASONS.imperativeAction, undefined, triggerElement));
+    this.openByTrigger(triggerId);
   }
 
   /**
    * Closes the tooltip.
+   *
+   * This method should only be called in an event handler or an effect (not during rendering).
    */
   close() {
-    this.store.setOpen(false, createChangeEventDetails(REASONS.imperativeAction, undefined, undefined));
+    this.closePopup();
   }
 
   /**
-   * Indicates whether the tooltip is currently open.
+   * Whether the tooltip is currently open. Returns `false` while no root is attached to the handle.
    */
   get isOpen() {
-    return this.store.select('open');
+    return this.attachedStore?.select('open') ?? false;
   }
 }
 

package/tooltip/store/TooltipStore.d.mts

@@ -1,7 +1,8 @@
 import * as React from 'react';
 import { ReactStore } from '@base-ui/utils/store';
 import { type TooltipRoot } from "../root/TooltipRoot.mjs";
-import { PopupStoreContext, PopupStoreState } from "../../utils/popups/index.mjs";
+import type { AdaptiveOriginMiddleware } from "../../utils/adaptiveOriginConstants.mjs";
+import { PopupStoreContext, PopupStoreState, type PopupTriggerStoreKeys } from "../../utils/popups/index.mjs";
 export type State<Payload> = PopupStoreState<Payload> & {
   disabled: boolean;
   instantType: 'delay' | 'dismiss' | 'focus' | undefined;
@@ -11,7 +12,7 @@ export type State<Payload> = PopupStoreState<Payload> & {
   openChangeReason: TooltipRoot.ChangeEventReason | null;
   closeOnClick: boolean;
   closeDelay: number;
-  hasViewport: boolean;
+  adaptiveOrigin: AdaptiveOriginMiddleware | undefined;
 };
 export type Context = PopupStoreContext<TooltipRoot.ChangeEventDetails> & {
   readonly popupRef: React.RefObject<HTMLElement | null>;
@@ -367,12 +368,29 @@ declare const selectors: {
   lastOpenChangeReason: (state: State<unknown>) => import("../index.mjs").TooltipRootChangeEventReason | null;
   closeOnClick: (state: State<unknown>) => boolean;
   closeDelay: (state: State<unknown>) => number;
-  hasViewport: (state: State<unknown>) => boolean;
+  adaptiveOrigin: (state: State<unknown>) => AdaptiveOriginMiddleware | undefined;
 };
-export declare class TooltipStore<Payload> extends ReactStore<Readonly<State<Payload>>, Context, typeof selectors> {
-  constructor(initialState?: Partial<State<Payload>>, floatingId?: string | undefined, nested?: boolean);
+type Selectors = typeof selectors;
+/**
+ * The store view that detached handle-backed triggers read from. Both the real `TooltipStore` and
+ * the inert fallback store satisfy it, so a trigger can read from whichever store the handle
+ * currently exposes. Narrowed to the members a trigger actually uses — the trigger-data members plus
+ * `setOpen`/`cancelPendingOpen` (called directly by the trigger) and `useSyncedValue` — so the
+ * exposed surface can't bypass the open-change pipeline; on the detached fallback store every one of
+ * these mutations is a no-op.
+ */
+export type TooltipHandleStore<Payload> = Pick<TooltipStore<Payload>, PopupTriggerStoreKeys | 'setOpen' | 'cancelPendingOpen' | 'useSyncedValue'>;
+export declare class TooltipStore<Payload> extends ReactStore<Readonly<State<Payload>>, Context, Selectors> {
+  constructor(initialState: Partial<State<Payload>>, floatingId: string | undefined, nested: boolean);
   setOpen: (nextOpen: boolean, eventDetails: Omit<TooltipRoot.ChangeEventDetails, 'preventUnmountOnClose'>) => void;
   cancelPendingOpen(event: MouseEvent | PointerEvent): void;
-  static useStore<Payload>(externalStore: TooltipStore<Payload> | undefined, initialState?: Partial<State<Payload>>): TooltipStore<Payload>;
 }
+/**
+ * Creates the inert fallback store used by detached handle-backed triggers while no `Tooltip.Root`
+ * is attached. It preserves a tooltip-specific trigger registry in context so detached triggers can
+ * register before migrating to the live root store. `setOpen`/`cancelPendingOpen` are no-ops
+ * (matching the inert reads/writes of `NullStore`), so a trigger can call them from hover/click
+ * handlers while detached without any effect.
+ */
+export declare function createNullTooltipStore<Payload>(): TooltipHandleStore<Payload>;
 export {};

package/tooltip/store/TooltipStore.d.ts

@@ -1,7 +1,8 @@
 import * as React from 'react';
 import { ReactStore } from '@base-ui/utils/store';
 import { type TooltipRoot } from "../root/TooltipRoot.js";
-import { PopupStoreContext, PopupStoreState } from "../../utils/popups/index.js";
+import type { AdaptiveOriginMiddleware } from "../../utils/adaptiveOriginConstants.js";
+import { PopupStoreContext, PopupStoreState, type PopupTriggerStoreKeys } from "../../utils/popups/index.js";
 export type State<Payload> = PopupStoreState<Payload> & {
   disabled: boolean;
   instantType: 'delay' | 'dismiss' | 'focus' | undefined;
@@ -11,7 +12,7 @@ export type State<Payload> = PopupStoreState<Payload> & {
   openChangeReason: TooltipRoot.ChangeEventReason | null;
   closeOnClick: boolean;
   closeDelay: number;
-  hasViewport: boolean;
+  adaptiveOrigin: AdaptiveOriginMiddleware | undefined;
 };
 export type Context = PopupStoreContext<TooltipRoot.ChangeEventDetails> & {
   readonly popupRef: React.RefObject<HTMLElement | null>;
@@ -367,12 +368,29 @@ declare const selectors: {
   lastOpenChangeReason: (state: State<unknown>) => import("../index.js").TooltipRootChangeEventReason | null;
   closeOnClick: (state: State<unknown>) => boolean;
   closeDelay: (state: State<unknown>) => number;
-  hasViewport: (state: State<unknown>) => boolean;
+  adaptiveOrigin: (state: State<unknown>) => AdaptiveOriginMiddleware | undefined;
 };
-export declare class TooltipStore<Payload> extends ReactStore<Readonly<State<Payload>>, Context, typeof selectors> {
-  constructor(initialState?: Partial<State<Payload>>, floatingId?: string | undefined, nested?: boolean);
+type Selectors = typeof selectors;
+/**
+ * The store view that detached handle-backed triggers read from. Both the real `TooltipStore` and
+ * the inert fallback store satisfy it, so a trigger can read from whichever store the handle
+ * currently exposes. Narrowed to the members a trigger actually uses — the trigger-data members plus
+ * `setOpen`/`cancelPendingOpen` (called directly by the trigger) and `useSyncedValue` — so the
+ * exposed surface can't bypass the open-change pipeline; on the detached fallback store every one of
+ * these mutations is a no-op.
+ */
+export type TooltipHandleStore<Payload> = Pick<TooltipStore<Payload>, PopupTriggerStoreKeys | 'setOpen' | 'cancelPendingOpen' | 'useSyncedValue'>;
+export declare class TooltipStore<Payload> extends ReactStore<Readonly<State<Payload>>, Context, Selectors> {
+  constructor(initialState: Partial<State<Payload>>, floatingId: string | undefined, nested: boolean);
   setOpen: (nextOpen: boolean, eventDetails: Omit<TooltipRoot.ChangeEventDetails, 'preventUnmountOnClose'>) => void;
   cancelPendingOpen(event: MouseEvent | PointerEvent): void;
-  static useStore<Payload>(externalStore: TooltipStore<Payload> | undefined, initialState?: Partial<State<Payload>>): TooltipStore<Payload>;
 }
+/**
+ * Creates the inert fallback store used by detached handle-backed triggers while no `Tooltip.Root`
+ * is attached. It preserves a tooltip-specific trigger registry in context so detached triggers can
+ * register before migrating to the live root store. `setOpen`/`cancelPendingOpen` are no-ops
+ * (matching the inert reads/writes of `NullStore`), so a trigger can call them from hover/click
+ * handlers while detached without any effect.
+ */
+export declare function createNullTooltipStore<Payload>(): TooltipHandleStore<Payload>;
 export {};

package/tooltip/store/TooltipStore.js

@@ -5,37 +5,40 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.TooltipStore = void 0;
+exports.createNullTooltipStore = createNullTooltipStore;
 var React = _interopRequireWildcard(require("react"));
 var _store = require("@base-ui/utils/store");
+var _empty = require("@base-ui/utils/empty");
 var _createBaseUIEventDetails = require("../../internals/createBaseUIEventDetails");
 var _reasons = require("../../internals/reasons");
+var _NullStore = require("../../utils/NullStore");
 var _popups = require("../../utils/popups");
 const selectors = {
   ..._popups.popupStoreSelectors,
-  disabled: (0, _store.createSelector)(state => state.disabled),
-  instantType: (0, _store.createSelector)(state => state.instantType),
-  isInstantPhase: (0, _store.createSelector)(state => state.isInstantPhase),
-  trackCursorAxis: (0, _store.createSelector)(state => state.trackCursorAxis),
-  disableHoverablePopup: (0, _store.createSelector)(state => state.disableHoverablePopup),
-  lastOpenChangeReason: (0, _store.createSelector)(state => state.openChangeReason),
-  closeOnClick: (0, _store.createSelector)(state => state.closeOnClick),
-  closeDelay: (0, _store.createSelector)(state => state.closeDelay),
-  hasViewport: (0, _store.createSelector)(state => state.hasViewport)
+  disabled: state => state.disabled,
+  instantType: state => state.instantType,
+  isInstantPhase: state => state.isInstantPhase,
+  trackCursorAxis: state => state.trackCursorAxis,
+  disableHoverablePopup: state => state.disableHoverablePopup,
+  lastOpenChangeReason: state => state.openChangeReason,
+  closeOnClick: state => state.closeOnClick,
+  closeDelay: state => state.closeDelay,
+  adaptiveOrigin: state => state.adaptiveOrigin
 };
+
+/**
+ * The store view that detached handle-backed triggers read from. Both the real `TooltipStore` and
+ * the inert fallback store satisfy it, so a trigger can read from whichever store the handle
+ * currently exposes. Narrowed to the members a trigger actually uses — the trigger-data members plus
+ * `setOpen`/`cancelPendingOpen` (called directly by the trigger) and `useSyncedValue` — so the
+ * exposed surface can't bypass the open-change pipeline; on the detached fallback store every one of
+ * these mutations is a no-op.
+ */
+
 class TooltipStore extends _store.ReactStore {
-  constructor(initialState, floatingId, nested = false) {
+  constructor(initialState, floatingId, nested) {
     const triggerElements = new _popups.PopupTriggerMap();
-    const state = {
-      ...createInitialState(),
-      ...initialState
-    };
-    state.floatingRootContext = (0, _popups.createPopupFloatingRootContext)(triggerElements, floatingId, nested);
-    super(state, {
-      popupRef: /*#__PURE__*/React.createRef(),
-      onOpenChange: undefined,
-      onOpenChangeComplete: undefined,
-      triggerElements
-    }, selectors);
+    super(createInitialState(initialState, triggerElements, floatingId, nested), createInitialContext(triggerElements), selectors);
   }
   setOpen = (nextOpen, eventDetails) => {
     (0, _popups.applyPopupOpenChange)(this, nextOpen, eventDetails, {
@@ -49,17 +52,26 @@ class TooltipStore extends _store.ReactStore {
   cancelPendingOpen(event) {
     this.state.floatingRootContext.dispatchOpenChange(false, (0, _createBaseUIEventDetails.createChangeEventDetails)(_reasons.REASONS.triggerPress, event));
   }
-  static useStore(externalStore, initialState) {
-    /* eslint-disable react-hooks/rules-of-hooks */
-    const store = (0, _popups.usePopupStore)(externalStore, (floatingId, nested) => new TooltipStore(initialState, floatingId, nested)).store;
-    /* eslint-enable react-hooks/rules-of-hooks */
-
-    return store;
-  }
 }
+
+/**
+ * Creates the inert fallback store used by detached handle-backed triggers while no `Tooltip.Root`
+ * is attached. It preserves a tooltip-specific trigger registry in context so detached triggers can
+ * register before migrating to the live root store. `setOpen`/`cancelPendingOpen` are no-ops
+ * (matching the inert reads/writes of `NullStore`), so a trigger can call them from hover/click
+ * handlers while detached without any effect.
+ */
 exports.TooltipStore = TooltipStore;
-function createInitialState() {
-  return {
+function createNullTooltipStore() {
+  const triggerElements = new _popups.PopupTriggerMap();
+  const store = new _NullStore.NullStore(Object.freeze(createInitialState(undefined, triggerElements)), Object.freeze(createInitialContext(triggerElements)), selectors);
+  return Object.assign(store, {
+    setOpen: _empty.NOOP,
+    cancelPendingOpen: _empty.NOOP
+  });
+}
+function createInitialState(initialState, triggerElements, floatingId, nested = false) {
+  const state = {
     ...(0, _popups.createInitialPopupStoreState)(),
     disabled: false,
     instantType: undefined,
@@ -69,6 +81,17 @@ function createInitialState() {
     openChangeReason: null,
     closeOnClick: true,
     closeDelay: 0,
-    hasViewport: false
+    adaptiveOrigin: undefined,
+    ...initialState
+  };
+  state.floatingRootContext = (0, _popups.createPopupFloatingRootContext)(triggerElements, floatingId, nested);
+  return state;
+}
+function createInitialContext(triggerElements) {
+  return {
+    popupRef: /*#__PURE__*/React.createRef(),
+    onOpenChange: undefined,
+    onOpenChangeComplete: undefined,
+    triggerElements
   };
 }