@tale-ui/react 0.0.3

package/esm/drawer/provider/DrawerProvider.js

@@ -0,0 +1,95 @@
+'use client';
+
+import * as React from 'react';
+import { useStableCallback } from '@tale-ui/utils/useStableCallback';
+import { DrawerProviderContext } from "./DrawerProviderContext.js";
+
+/**
+ * Provides a shared context for coordinating global Drawer UI, such as indent/background effects based on whether any Drawer is open.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Tale UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export function DrawerProvider(props) {
+  const {
+    children
+  } = props;
+  const [openById, setOpenById] = React.useState(() => new Map());
+  const [visualStateStore] = React.useState(createVisualStateStore);
+  const setDrawerOpen = useStableCallback((drawerId, open) => {
+    setOpenById(prev => {
+      const prevOpen = prev.get(drawerId);
+      if (prevOpen === open) {
+        return prev;
+      }
+      const next = new Map(prev);
+      next.set(drawerId, open);
+      return next;
+    });
+  });
+  const removeDrawer = useStableCallback(drawerId => {
+    setOpenById(prev => {
+      if (!prev.has(drawerId)) {
+        return prev;
+      }
+      const next = new Map(prev);
+      next.delete(drawerId);
+      return next;
+    });
+  });
+  const active = React.useMemo(() => {
+    for (const open of openById.values()) {
+      if (open) {
+        return true;
+      }
+    }
+    return false;
+  }, [openById]);
+  const contextValue = React.useMemo(() => ({
+    setDrawerOpen,
+    removeDrawer,
+    active,
+    visualStateStore
+  }), [active, removeDrawer, setDrawerOpen, visualStateStore]);
+  return /*#__PURE__*/_jsx(DrawerProviderContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+}
+function createVisualStateStore() {
+  let state = {
+    swipeProgress: 0,
+    frontmostHeight: 0
+  };
+  const listeners = new Set();
+  return {
+    getSnapshot: () => state,
+    set(nextState) {
+      let nextSwipeProgress = state.swipeProgress;
+      if (nextState.swipeProgress !== undefined) {
+        nextSwipeProgress = Number.isFinite(nextState.swipeProgress) ? nextState.swipeProgress : 0;
+      }
+      let nextFrontmostHeight = state.frontmostHeight;
+      if (nextState.frontmostHeight !== undefined) {
+        nextFrontmostHeight = Number.isFinite(nextState.frontmostHeight) ? nextState.frontmostHeight : 0;
+      }
+      if (nextSwipeProgress === state.swipeProgress && nextFrontmostHeight === state.frontmostHeight) {
+        return;
+      }
+      state = {
+        swipeProgress: nextSwipeProgress,
+        frontmostHeight: nextFrontmostHeight
+      };
+      listeners.forEach(listener => {
+        listener();
+      });
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}

package/esm/drawer/provider/DrawerProviderContext.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+export interface DrawerProviderContext {
+  setDrawerOpen: (drawerId: string, open: boolean) => void;
+  removeDrawer: (drawerId: string) => void;
+  active: boolean;
+  visualStateStore: DrawerVisualStateStore;
+}
+export declare const DrawerProviderContext: React.Context<DrawerProviderContext | undefined>;
+export interface DrawerVisualState {
+  swipeProgress: number;
+  frontmostHeight: number;
+}
+export interface DrawerVisualStateStore {
+  getSnapshot: () => DrawerVisualState;
+  subscribe: (listener: () => void) => () => void;
+  set: (state: Partial<DrawerVisualState>) => void;
+}
+export declare function useDrawerProviderContext(optional?: false): DrawerProviderContext;
+export declare function useDrawerProviderContext(optional: true): DrawerProviderContext | undefined;

package/esm/drawer/provider/DrawerProviderContext.js

@@ -0,0 +1,12 @@
+'use client';
+
+import * as React from 'react';
+export const DrawerProviderContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== "production") DrawerProviderContext.displayName = "DrawerProviderContext";
+export function useDrawerProviderContext(optional) {
+  const context = React.useContext(DrawerProviderContext);
+  if (optional === false && context === undefined) {
+    throw /* FIXME (minify-errors-in-prod): Unminified error message in production build! */new Error('Tale UI: DrawerProviderContext is missing. Use <Drawer.Provider>.');
+  }
+  return context;
+}

package/esm/drawer/root/DrawerRoot.d.ts

@@ -0,0 +1,124 @@
+import * as React from 'react';
+import { type DrawerSwipeDirection, type DrawerSnapPoint } from "./DrawerRootContext.js";
+import { type TaleUIChangeEventDetails } from "../../utils/createTaleUIEventDetails.js";
+import { REASONS } from "../../utils/reasons.js";
+import type { DialogHandle } from "../../dialog/store/DialogHandle.js";
+import type { PayloadChildRenderFunction } from "../../utils/popups/index.js";
+/**
+ * Groups all parts of the drawer.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Tale UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export declare function DrawerRoot<Payload = unknown>(props: DrawerRoot.Props<Payload>): import("react/jsx-runtime").JSX.Element;
+export interface DrawerRootProps<Payload = unknown> {
+  /**
+   * Whether the drawer is currently open.
+   */
+  open?: boolean | undefined;
+  /**
+   * Whether the drawer is initially open.
+   *
+   * To render a controlled drawer, use the `open` prop instead.
+   * @default false
+   */
+  defaultOpen?: boolean | undefined;
+  /**
+   * Determines if the drawer enters a modal state when open.
+   * - `true`: user interaction is limited to just the drawer: focus is trapped, document page scroll is locked, and pointer interactions on outside elements are disabled.
+   * - `false`: user interaction with the rest of the document is allowed.
+   * - `'trap-focus'`: focus is trapped inside the drawer, but document page scroll is not locked and pointer interactions outside of it remain enabled.
+   * @default true
+   */
+  modal?: boolean | 'trap-focus' | undefined;
+  /**
+   * Event handler called when the drawer is opened or closed.
+   */
+  onOpenChange?: ((open: boolean, eventDetails: DrawerRoot.ChangeEventDetails) => void) | undefined;
+  /**
+   * Event handler called after any animations complete when the drawer is opened or closed.
+   */
+  onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+  /**
+   * Determines whether the drawer should close on outside clicks.
+   * @default false
+   */
+  disablePointerDismissal?: boolean | undefined;
+  /**
+   * A ref to imperative actions.
+   * - `unmount`: When specified, the drawer will not be unmounted when closed.
+   * Instead, the `unmount` function must be called to unmount the drawer manually.
+   * Useful when the drawer's animation is controlled by an external library.
+   * - `close`: Closes the drawer imperatively when called.
+   */
+  actionsRef?: React.RefObject<DrawerRoot.Actions | null> | undefined;
+  /**
+   * A handle to associate the drawer with a trigger.
+   * If specified, allows detached triggers to control the drawer's open state.
+   * Can be created with the Drawer.createHandle() method.
+   */
+  handle?: DialogHandle<Payload> | undefined;
+  /**
+   * ID of the trigger that the drawer is associated with.
+   * This is useful in conjunction with the `open` prop to create a controlled drawer.
+   * There's no need to specify this prop when the drawer is uncontrolled (i.e. when the `open` prop is not set).
+   */
+  triggerId?: string | null | undefined;
+  /**
+   * ID of the trigger that the drawer is associated with.
+   * This is useful in conjunction with the `defaultOpen` prop to create an initially open drawer.
+   */
+  defaultTriggerId?: string | null | undefined;
+  /**
+   * The content of the drawer.
+   */
+  children?: React.ReactNode | PayloadChildRenderFunction<Payload>;
+  /**
+   * The swipe direction used to dismiss the drawer.
+   * @default 'down'
+   */
+  swipeDirection?: DrawerSwipeDirection | undefined;
+  /**
+   * Snap points used to position the drawer.
+   * Use numbers between 0 and 1 to represent fractions of the viewport height,
+   * numbers greater than 1 as pixel values, or strings in `px`/`rem` units
+   * (for example, `'148px'` or `'30rem'`).
+   */
+  snapPoints?: DrawerSnapPoint[] | undefined;
+  /**
+   * Disables velocity-based snap skipping so drag distance determines the next snap point.
+   * @default false
+   */
+  snapToSequentialPoints?: boolean | undefined;
+  /**
+   * The currently active snap point. Use with `onSnapPointChange` to control the snap point.
+   */
+  snapPoint?: DrawerSnapPoint | null | undefined;
+  /**
+   * The initial snap point value when uncontrolled.
+   */
+  defaultSnapPoint?: DrawerSnapPoint | null | undefined;
+  /**
+   * Callback fired when the snap point changes.
+   */
+  onSnapPointChange?: ((snapPoint: DrawerSnapPoint | null, eventDetails: DrawerRoot.SnapPointChangeEventDetails) => void) | undefined;
+}
+export interface DrawerRootActions {
+  unmount: () => void;
+  close: () => void;
+}
+export type DrawerRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.closeWatcher | typeof REASONS.closePress | typeof REASONS.focusOut | typeof REASONS.imperativeAction | typeof REASONS.swipe | typeof REASONS.none;
+export type DrawerRootChangeEventDetails = TaleUIChangeEventDetails<DrawerRoot.ChangeEventReason> & {
+  preventUnmountOnClose(): void;
+};
+export type DrawerRootSnapPointChangeEventReason = DrawerRootChangeEventReason;
+export type DrawerRootSnapPointChangeEventDetails = TaleUIChangeEventDetails<DrawerRootSnapPointChangeEventReason>;
+export declare namespace DrawerRoot {
+  type Props<Payload = unknown> = DrawerRootProps<Payload>;
+  type Actions = DrawerRootActions;
+  type ChangeEventReason = DrawerRootChangeEventReason;
+  type ChangeEventDetails = DrawerRootChangeEventDetails;
+  type SnapPointChangeEventReason = DrawerRootSnapPointChangeEventReason;
+  type SnapPointChangeEventDetails = DrawerRootSnapPointChangeEventDetails;
+  type SnapPoint = DrawerSnapPoint;
+}

package/esm/drawer/root/DrawerRoot.js

@@ -0,0 +1,233 @@
+'use client';
+
+var _DrawerProviderReport, _DrawerProviderReport2;
+import * as React from 'react';
+import { useControlled } from '@tale-ui/utils/useControlled';
+import { useStableCallback } from '@tale-ui/utils/useStableCallback';
+import { ownerWindow } from '@tale-ui/utils/owner';
+import { isAndroid } from '@tale-ui/utils/detectBrowser';
+import { useId } from '@tale-ui/utils/useId';
+import { DrawerRootContext, useDrawerRootContext } from "./DrawerRootContext.js";
+import { Dialog } from "../../dialog/index.js";
+import { createChangeEventDetails } from "../../utils/createTaleUIEventDetails.js";
+import { REASONS } from "../../utils/reasons.js";
+import { useDialogRootContext } from "../../dialog/root/DialogRootContext.js";
+import { useDrawerProviderContext } from "../provider/DrawerProviderContext.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Groups all parts of the drawer.
+ * Doesn't render its own HTML element.
+ *
+ * Documentation: [Tale UI Drawer](https://base-ui.com/react/components/drawer)
+ */
+export function DrawerRoot(props) {
+  const {
+    children,
+    open: openProp,
+    defaultOpen = false,
+    onOpenChange,
+    onOpenChangeComplete,
+    disablePointerDismissal = false,
+    modal = true,
+    actionsRef,
+    handle,
+    triggerId: triggerIdProp,
+    defaultTriggerId: defaultTriggerIdProp = null,
+    swipeDirection = 'down',
+    snapToSequentialPoints = false,
+    snapPoints,
+    snapPoint: snapPointProp,
+    defaultSnapPoint,
+    onSnapPointChange: onSnapPointChangeProp
+  } = props;
+  const onSnapPointChange = useStableCallback(onSnapPointChangeProp);
+  const parentDrawerRootContext = useDrawerRootContext(true);
+  const notifyParentSwipeProgressChange = parentDrawerRootContext?.onNestedSwipeProgressChange;
+  const notifyParentFrontmostHeight = parentDrawerRootContext?.onNestedFrontmostHeightChange;
+  const notifyParentSwipingChange = parentDrawerRootContext?.onNestedSwipingChange;
+  const notifyParentHasNestedDrawer = parentDrawerRootContext?.onNestedDrawerPresenceChange;
+  const [popupHeight, setPopupHeight] = React.useState(0);
+  const [frontmostHeight, setFrontmostHeight] = React.useState(0);
+  const [hasNestedDrawer, setHasNestedDrawer] = React.useState(false);
+  const [nestedSwiping, setNestedSwiping] = React.useState(false);
+  const [nestedSwipeProgressStore] = React.useState(createNestedSwipeProgressStore);
+  const resolvedDefaultSnapPoint = defaultSnapPoint !== undefined ? defaultSnapPoint : snapPoints?.[0] ?? null;
+  const isSnapPointControlled = snapPointProp !== undefined;
+  const [activeSnapPoint, setActiveSnapPointUnwrapped] = useControlled({
+    controlled: snapPointProp,
+    default: resolvedDefaultSnapPoint,
+    name: 'Drawer',
+    state: 'snapPoint'
+  });
+  const isNestedDrawerOpenRef = React.useRef(false);
+  const setActiveSnapPoint = useStableCallback((nextSnapPoint, eventDetails) => {
+    const resolvedEventDetails = eventDetails ?? createChangeEventDetails(REASONS.none);
+    onSnapPointChange?.(nextSnapPoint, resolvedEventDetails);
+    if (resolvedEventDetails.isCanceled) {
+      return;
+    }
+    setActiveSnapPointUnwrapped(nextSnapPoint);
+  });
+  const resolvedActiveSnapPoint = React.useMemo(() => {
+    if (isSnapPointControlled) {
+      return activeSnapPoint;
+    }
+    if (!snapPoints || snapPoints.length === 0) {
+      return activeSnapPoint;
+    }
+    if (activeSnapPoint === null || !snapPoints.some(snapPoint => Object.is(snapPoint, activeSnapPoint))) {
+      return resolvedDefaultSnapPoint;
+    }
+    return activeSnapPoint;
+  }, [activeSnapPoint, isSnapPointControlled, resolvedDefaultSnapPoint, snapPoints]);
+  const onPopupHeightChange = useStableCallback(height => {
+    setPopupHeight(height);
+    if (!isNestedDrawerOpenRef.current && height > 0) {
+      setFrontmostHeight(height);
+    }
+  });
+  const onNestedFrontmostHeightChange = useStableCallback(height => {
+    if (height > 0) {
+      isNestedDrawerOpenRef.current = true;
+      setFrontmostHeight(height);
+      return;
+    }
+    isNestedDrawerOpenRef.current = false;
+    if (popupHeight > 0) {
+      setFrontmostHeight(popupHeight);
+    }
+  });
+  const onNestedDrawerPresenceChange = useStableCallback(present => {
+    setHasNestedDrawer(present);
+  });
+  const onNestedSwipeProgressChange = useStableCallback(progress => {
+    nestedSwipeProgressStore.set(progress);
+    notifyParentSwipeProgressChange?.(progress);
+  });
+  const onNestedSwipingChange = useStableCallback(swiping => {
+    setNestedSwiping(swiping);
+    notifyParentSwipingChange?.(swiping);
+  });
+  const handleOpenChange = useStableCallback((nextOpen, eventDetails) => {
+    onOpenChange?.(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    if (!nextOpen && snapPoints && snapPoints.length > 0) {
+      setActiveSnapPoint(resolvedDefaultSnapPoint, createChangeEventDetails(eventDetails.reason, eventDetails.event, eventDetails.trigger));
+    }
+  });
+  const contextValue = React.useMemo(() => ({
+    swipeDirection,
+    snapToSequentialPoints,
+    snapPoints,
+    activeSnapPoint: resolvedActiveSnapPoint,
+    setActiveSnapPoint,
+    frontmostHeight,
+    popupHeight,
+    hasNestedDrawer,
+    nestedSwiping,
+    nestedSwipeProgressStore,
+    onNestedDrawerPresenceChange,
+    onPopupHeightChange,
+    onNestedFrontmostHeightChange,
+    onNestedSwipingChange,
+    onNestedSwipeProgressChange,
+    notifyParentFrontmostHeight,
+    notifyParentSwipingChange,
+    notifyParentSwipeProgressChange,
+    notifyParentHasNestedDrawer
+  }), [resolvedActiveSnapPoint, frontmostHeight, hasNestedDrawer, nestedSwiping, nestedSwipeProgressStore, notifyParentHasNestedDrawer, notifyParentSwipeProgressChange, notifyParentSwipingChange, notifyParentFrontmostHeight, onNestedDrawerPresenceChange, onNestedFrontmostHeightChange, onNestedSwipeProgressChange, onNestedSwipingChange, onPopupHeightChange, popupHeight, setActiveSnapPoint, snapPoints, snapToSequentialPoints, swipeDirection]);
+  const resolvedChildren = typeof children === 'function' ? payload => /*#__PURE__*/_jsxs(React.Fragment, {
+    children: [_DrawerProviderReport || (_DrawerProviderReport = /*#__PURE__*/_jsx(DrawerProviderReporter, {})), children(payload)]
+  }) : /*#__PURE__*/_jsxs(React.Fragment, {
+    children: [_DrawerProviderReport2 || (_DrawerProviderReport2 = /*#__PURE__*/_jsx(DrawerProviderReporter, {})), children]
+  });
+  return /*#__PURE__*/_jsx(DrawerRootContext.Provider, {
+    value: contextValue,
+    children: /*#__PURE__*/_jsx(Dialog.Root, {
+      open: openProp,
+      defaultOpen: defaultOpen,
+      onOpenChange: handleOpenChange,
+      onOpenChangeComplete: onOpenChangeComplete,
+      disablePointerDismissal: disablePointerDismissal,
+      modal: modal,
+      actionsRef: actionsRef,
+      handle: handle,
+      triggerId: triggerIdProp,
+      defaultTriggerId: defaultTriggerIdProp,
+      children: resolvedChildren
+    })
+  });
+}
+function createNestedSwipeProgressStore() {
+  let progress = 0;
+  const listeners = new Set();
+  return {
+    getSnapshot: () => progress,
+    set(nextProgress) {
+      const resolved = Number.isFinite(nextProgress) ? nextProgress : 0;
+      if (resolved === progress) {
+        return;
+      }
+      progress = resolved;
+      listeners.forEach(listener => {
+        listener();
+      });
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function DrawerProviderReporter() {
+  const drawerId = useId();
+  const providerContext = useDrawerProviderContext(true);
+  const dialogRootContext = useDialogRootContext(false);
+  const open = dialogRootContext.store.useState('open');
+  const nestedOpenDialogCount = dialogRootContext.store.useState('nestedOpenDialogCount');
+  const popupElement = dialogRootContext.store.useState('popupElement');
+  const isTopmost = nestedOpenDialogCount === 0;
+  React.useEffect(() => {
+    if (!providerContext || drawerId == null) {
+      return undefined;
+    }
+    return () => {
+      providerContext.removeDrawer(drawerId);
+    };
+  }, [drawerId, providerContext]);
+  React.useEffect(() => {
+    if (drawerId == null) {
+      return;
+    }
+    providerContext?.setDrawerOpen(drawerId, open);
+  }, [drawerId, open, providerContext]);
+  React.useEffect(() => {
+    // CloseWatcher enables the Android back gesture (Chromium-only).
+    // Keep this Android-only for now to avoid interfering with Escape/nesting semantics on desktop due to `useDismiss`.
+    if (!open || !isTopmost || !isAndroid) {
+      return undefined;
+    }
+    const win = ownerWindow(popupElement);
+    const CloseWatcherCtor = win.CloseWatcher;
+    if (!CloseWatcherCtor) {
+      return undefined;
+    }
+    function handleCloseWatcher(event) {
+      if (!dialogRootContext.store.select('open')) {
+        return;
+      }
+      dialogRootContext.store.setOpen(false, createChangeEventDetails(REASONS.closeWatcher, event));
+    }
+    const closeWatcher = new CloseWatcherCtor();
+    closeWatcher.addEventListener('close', handleCloseWatcher);
+    return () => {
+      closeWatcher.removeEventListener('close', handleCloseWatcher);
+      closeWatcher.destroy();
+    };
+  }, [dialogRootContext.store, isTopmost, open, popupElement]);
+  return null;
+}

package/esm/drawer/root/DrawerRootContext.d.ts

@@ -0,0 +1,89 @@
+import * as React from 'react';
+import type { SwipeDirection } from "../../utils/useSwipeDismiss.js";
+import type { DrawerRootSnapPointChangeEventDetails } from "./DrawerRoot.js";
+export type DrawerSwipeDirection = SwipeDirection;
+export type DrawerSnapPoint = number | string;
+export interface DrawerNestedSwipeProgressStore {
+  getSnapshot: () => number;
+  subscribe: (listener: () => void) => () => void;
+}
+export interface DrawerRootContext {
+  swipeDirection: DrawerSwipeDirection;
+  /**
+   * Whether snap points can be skipped based on swipe velocity.
+   */
+  snapToSequentialPoints: boolean;
+  /**
+   * Snap points used to size/position the drawer.
+   */
+  snapPoints?: DrawerSnapPoint[] | undefined;
+  /**
+   * The currently active snap point.
+   */
+  activeSnapPoint?: DrawerSnapPoint | null | undefined;
+  /**
+   * Updates the currently active snap point.
+   */
+  setActiveSnapPoint?: ((snapPoint: DrawerSnapPoint | null, eventDetails?: DrawerRootSnapPointChangeEventDetails) => void) | undefined;
+  /**
+   * The measured height of the frontmost open drawer within the current nested drawer stack.
+   */
+  frontmostHeight: number;
+  /**
+   * The measured height of the drawer popup element.
+   */
+  popupHeight: number;
+  /**
+   * Whether the current drawer has a nested drawer mounted in its stack (including while it is
+   * transitioning out).
+   */
+  hasNestedDrawer: boolean;
+  /**
+   * Whether a nested drawer is currently being swiped.
+   */
+  nestedSwiping: boolean;
+  /**
+   * Provides nested swipe progress without re-rendering the drawer tree.
+   */
+  nestedSwipeProgressStore: DrawerNestedSwipeProgressStore;
+  /**
+   * Called by a nested drawer to report whether it is still present (open or transitioning out).
+   */
+  onNestedDrawerPresenceChange: (present: boolean) => void;
+  /**
+   * Called by the drawer popup to report its own measured height.
+   */
+  onPopupHeightChange: (height: number) => void;
+  /**
+   * Called by a nested drawer to report the frontmost height of its own stack.
+   */
+  onNestedFrontmostHeightChange: (height: number) => void;
+  /**
+   * Called by a nested drawer to report whether it's being swiped.
+   */
+  onNestedSwipingChange: (swiping: boolean) => void;
+  /**
+   * Called by a nested drawer to report its swipe progress.
+   */
+  onNestedSwipeProgressChange: (progress: number) => void;
+  /**
+   * Provided to nested drawers so they can report their frontmost height to the parent drawer.
+   */
+  notifyParentFrontmostHeight?: ((height: number) => void) | undefined;
+  /**
+   * Provided to nested drawers so they can report swiping to the parent drawer.
+   */
+  notifyParentSwipingChange?: ((swiping: boolean) => void) | undefined;
+  /**
+   * Provided to nested drawers so they can report swipe progress to the parent drawer.
+   */
+  notifyParentSwipeProgressChange?: ((progress: number) => void) | undefined;
+  /**
+   * Provided to nested drawers so they can report whether they are still present (open or
+   * transitioning out) to the parent drawer.
+   */
+  notifyParentHasNestedDrawer?: ((present: boolean) => void) | undefined;
+}
+export declare const DrawerRootContext: React.Context<DrawerRootContext | undefined>;
+export declare function useDrawerRootContext(optional?: false): DrawerRootContext;
+export declare function useDrawerRootContext(optional: true): DrawerRootContext | undefined;

package/esm/drawer/root/DrawerRootContext.js

@@ -0,0 +1,12 @@
+'use client';
+
+import * as React from 'react';
+export const DrawerRootContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== "production") DrawerRootContext.displayName = "DrawerRootContext";
+export function useDrawerRootContext(optional) {
+  const drawerRootContext = React.useContext(DrawerRootContext);
+  if (optional === false && drawerRootContext === undefined) {
+    throw /* FIXME (minify-errors-in-prod): Unminified error message in production build! */new Error('Tale UI: DrawerRootContext is missing. Drawer parts must be placed within <Drawer.Root>.');
+  }
+  return drawerRootContext;
+}

package/esm/drawer/root/useDrawerSnapPoints.d.ts

@@ -0,0 +1,15 @@
+import type { DrawerSnapPoint } from "./DrawerRootContext.js";
+export interface ResolvedDrawerSnapPoint {
+  value: DrawerSnapPoint;
+  height: number;
+  offset: number;
+}
+export declare function useDrawerSnapPoints(): {
+  snapPoints: DrawerSnapPoint[] | undefined;
+  activeSnapPoint: DrawerSnapPoint | null | undefined;
+  setActiveSnapPoint: ((snapPoint: DrawerSnapPoint | null, eventDetails?: import("./DrawerRoot.js").DrawerRootSnapPointChangeEventDetails) => void) | undefined;
+  popupHeight: number;
+  viewportHeight: number;
+  resolvedSnapPoints: ResolvedDrawerSnapPoint[];
+  activeSnapPointOffset: number | null;
+};