@jobber/components 8.21.1 → 8.22.0

package/Dialog.d.ts

@@ -0,0 +1 @@
+export * from "./dist/Dialog";

package/Dialog.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+
+var Dialog = require("./dist/Dialog");
+
+Object.keys(Dialog).forEach(function(key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return Dialog[key];
+    },
+  });
+});

package/dist/BottomSheet-cjs.js

@@ -35,6 +35,15 @@ function resolveBottomSheetTriggerRender({ children, render, }) {
         React.createElement(Button.Button.Label, null, children)));
 }
 
+/**
+ * Whether `BottomSheet.Popup` renders its own built-in scroll area (with the
+ * bottom fade). Defaults to `true` — the popup wraps its `children` in a
+ * scrollable viewport. A consumer that manages its own scroll region (e.g.
+ * `Dialog`, which pins a header/footer outside a single scroll area) provides
+ * `false` to opt out. Mirrors how `Dialog.Body` decides whether to wrap itself
+ * via context rather than a prop.
+ */
+const BottomSheetScrollAreaContext = React.createContext(true);
 function BottomSheetTrigger(_a) {
     var { children, render, className } = _a, triggerProps = tslib_es6.__rest(_a, ["children", "render", "className"]);
     return (React.createElement(ScrollAreaViewport.DrawerTrigger, Object.assign({}, triggerProps, { className: className, render: resolveBottomSheetTriggerRender({ children, render }) })));
@@ -50,14 +59,30 @@ function BottomSheetRoot(_a) {
 }
 function BottomSheetPopup(_a) {
     var { children, className, initialFocus, finalFocus, ref } = _a, popupProps = tslib_es6.__rest(_a, ["children", "className", "initialFocus", "finalFocus", "ref"]);
+    // Defaults to wrapping; a consumer managing its own scroll region provides
+    // `BottomSheetScrollAreaContext` = false.
+    const renderScrollArea = React.useContext(BottomSheetScrollAreaContext);
     return (React.createElement(ScrollAreaViewport.DrawerPortal, null,
-        React.createElement(ScrollAreaViewport.DrawerBackdrop, { forceRender: true, className: styles.backdrop }),
-        React.createElement(ScrollAreaViewport.DrawerPopup, Object.assign({}, popupProps, { ref: ref, className: classnames(styles.popup, className), initialFocus: initialFocus, finalFocus: finalFocus }),
-            React.createElement(ScrollAreaViewport.ScrollAreaRoot, { className: styles.scrollRoot },
-                React.createElement(ScrollAreaViewport.ScrollAreaViewport, { className: styles.scrollArea, "data-testid": "ATL-BottomSheet-ScrollArea", 
-                    // BaseUI sets overflow: scroll in the style prop by default. This is to override that because adding it to the className doesn't work.
-                    style: { overflow: "auto" } }, children),
-                React.createElement("div", { "aria-hidden": "true", className: styles.bottomFade, "data-testid": "ATL-BottomSheet-Fade" })))));
+        React.createElement(ScrollAreaViewport.DrawerBackdrop, { forceRender: true, className: styles.backdrop, "data-testid": "ATL-BottomSheet-Backdrop" }),
+        React.createElement(ScrollAreaViewport.DrawerPopup, Object.assign({}, popupProps, { ref: ref, className: classnames(styles.popup, className), initialFocus: initialFocus, finalFocus: finalFocus }), !renderScrollArea ? (
+        // The consumer manages its own scroll region (e.g. Dialog pins a
+        // header/footer outside a single scroll area) — often by composing
+        // `BottomSheet.ScrollArea` itself.
+        children) : (React.createElement(BottomSheetScrollArea, null, children)))));
+}
+/**
+ * The sheet's scroll region: a styled BaseUI `ScrollArea` (native scrollbar) with
+ * a bottom fade that hints at more content while the viewport can scroll further.
+ * `BottomSheet.Popup` renders this automatically unless a consumer opts out via
+ * `BottomSheetScrollAreaContext` and composes it (or its own scroll region)
+ * directly.
+ */
+function BottomSheetScrollArea({ children, className, style, }) {
+    return (React.createElement(ScrollAreaViewport.ScrollAreaRoot, { className: classnames(styles.scrollRoot, className), style: style },
+        React.createElement(ScrollAreaViewport.ScrollAreaViewport, { className: styles.scrollArea, "data-testid": "ATL-BottomSheet-ScrollArea", 
+            // BaseUI sets overflow: scroll in the style prop by default. This is to override that because adding it to the className doesn't work.
+            style: { overflow: "auto" } }, children),
+        React.createElement("div", { "aria-hidden": "true", className: styles.bottomFade, "data-testid": "ATL-BottomSheet-Fade" })));
 }
 function BottomSheetContent(_a) {
     var { children, className, ref } = _a, contentProps = tslib_es6.__rest(_a, ["children", "className", "ref"]);
@@ -74,6 +99,8 @@ const BottomSheet = Object.assign(BottomSheetComponent, {
     Trigger: BottomSheetTrigger,
     Popup: BottomSheetPopup,
     Content: BottomSheetContent,
+    ScrollArea: BottomSheetScrollArea,
 });
 
 exports.BottomSheet = BottomSheet;
+exports.BottomSheetScrollAreaContext = BottomSheetScrollAreaContext;

package/dist/BottomSheet-es.js

@@ -33,6 +33,15 @@ function resolveBottomSheetTriggerRender({ children, render, }) {
         React__default.createElement(Button.Label, null, children)));
 }
 
+/**
+ * Whether `BottomSheet.Popup` renders its own built-in scroll area (with the
+ * bottom fade). Defaults to `true` — the popup wraps its `children` in a
+ * scrollable viewport. A consumer that manages its own scroll region (e.g.
+ * `Dialog`, which pins a header/footer outside a single scroll area) provides
+ * `false` to opt out. Mirrors how `Dialog.Body` decides whether to wrap itself
+ * via context rather than a prop.
+ */
+const BottomSheetScrollAreaContext = React__default.createContext(true);
 function BottomSheetTrigger(_a) {
     var { children, render, className } = _a, triggerProps = __rest(_a, ["children", "render", "className"]);
     return (React__default.createElement(DrawerTrigger, Object.assign({}, triggerProps, { className: className, render: resolveBottomSheetTriggerRender({ children, render }) })));
@@ -48,14 +57,30 @@ function BottomSheetRoot(_a) {
 }
 function BottomSheetPopup(_a) {
     var { children, className, initialFocus, finalFocus, ref } = _a, popupProps = __rest(_a, ["children", "className", "initialFocus", "finalFocus", "ref"]);
+    // Defaults to wrapping; a consumer managing its own scroll region provides
+    // `BottomSheetScrollAreaContext` = false.
+    const renderScrollArea = React__default.useContext(BottomSheetScrollAreaContext);
     return (React__default.createElement(DrawerPortal, null,
-        React__default.createElement(DrawerBackdrop, { forceRender: true, className: styles.backdrop }),
-        React__default.createElement(DrawerPopup, Object.assign({}, popupProps, { ref: ref, className: classnames(styles.popup, className), initialFocus: initialFocus, finalFocus: finalFocus }),
-            React__default.createElement(ScrollAreaRoot, { className: styles.scrollRoot },
-                React__default.createElement(ScrollAreaViewport, { className: styles.scrollArea, "data-testid": "ATL-BottomSheet-ScrollArea", 
-                    // BaseUI sets overflow: scroll in the style prop by default. This is to override that because adding it to the className doesn't work.
-                    style: { overflow: "auto" } }, children),
-                React__default.createElement("div", { "aria-hidden": "true", className: styles.bottomFade, "data-testid": "ATL-BottomSheet-Fade" })))));
+        React__default.createElement(DrawerBackdrop, { forceRender: true, className: styles.backdrop, "data-testid": "ATL-BottomSheet-Backdrop" }),
+        React__default.createElement(DrawerPopup, Object.assign({}, popupProps, { ref: ref, className: classnames(styles.popup, className), initialFocus: initialFocus, finalFocus: finalFocus }), !renderScrollArea ? (
+        // The consumer manages its own scroll region (e.g. Dialog pins a
+        // header/footer outside a single scroll area) — often by composing
+        // `BottomSheet.ScrollArea` itself.
+        children) : (React__default.createElement(BottomSheetScrollArea, null, children)))));
+}
+/**
+ * The sheet's scroll region: a styled BaseUI `ScrollArea` (native scrollbar) with
+ * a bottom fade that hints at more content while the viewport can scroll further.
+ * `BottomSheet.Popup` renders this automatically unless a consumer opts out via
+ * `BottomSheetScrollAreaContext` and composes it (or its own scroll region)
+ * directly.
+ */
+function BottomSheetScrollArea({ children, className, style, }) {
+    return (React__default.createElement(ScrollAreaRoot, { className: classnames(styles.scrollRoot, className), style: style },
+        React__default.createElement(ScrollAreaViewport, { className: styles.scrollArea, "data-testid": "ATL-BottomSheet-ScrollArea", 
+            // BaseUI sets overflow: scroll in the style prop by default. This is to override that because adding it to the className doesn't work.
+            style: { overflow: "auto" } }, children),
+        React__default.createElement("div", { "aria-hidden": "true", className: styles.bottomFade, "data-testid": "ATL-BottomSheet-Fade" })));
 }
 function BottomSheetContent(_a) {
     var { children, className, ref } = _a, contentProps = __rest(_a, ["children", "className", "ref"]);
@@ -72,6 +97,7 @@ const BottomSheet = Object.assign(BottomSheetComponent, {
     Trigger: BottomSheetTrigger,
     Popup: BottomSheetPopup,
     Content: BottomSheetContent,
+    ScrollArea: BottomSheetScrollArea,
 });
 
-export { BottomSheet as B };
+export { BottomSheetScrollAreaContext as B, BottomSheet as a };

package/dist/Card/index.cjs

@@ -30,6 +30,7 @@ require('../useButton-cjs.js');
 require('../clamp-cjs.js');
 require('../OverlaySeparator-cjs.js');
 require('../Separator-cjs.js');
+require('../DrawerTitle-cjs.js');
 require('../MenuSubmenuTrigger-cjs.js');
 require('../useCompositeListItem-cjs.js');
 

package/dist/Card/index.mjs

@@ -28,5 +28,6 @@ import '../useButton-es.js';
 import '../clamp-es.js';
 import '../OverlaySeparator-es.js';
 import '../Separator-es.js';
+import '../DrawerTitle-es.js';
 import '../MenuSubmenuTrigger-es.js';
 import '../useCompositeListItem-es.js';

package/dist/ComboboxChipRemove-es.js

@@ -1,9 +1,9 @@
 import * as React from 'react';
-import { B as useControlled, a as useStableCallback, j as useValueAsRef, c as useTransitionStatus, d as useIsoLayoutEffect, K as createGenericEventDetails, H as inputClear, G as inputChange, n as createChangeEventDetails, v as focusOut, a7 as outsidePress, g as getTarget, a6 as itemPress, f as useOpenChangeComplete, O as useValueChanged, D as none, an as inputPress, E as visuallyHiddenInput, F as visuallyHidden, m as contains, b as useTimeout, N as useButton, o as ownerDocument, s as stopEvent, p as listNavigation, a5 as closePress, u as useBaseUiId, R as isAndroid, ao as isFirefox, a2 as escapeKey, ap as clearPress, t as transitionStatusMapping, S as SafeReact, e as error, aq as chipRemovePress } from './useButton-es.js';
-import { f as formatErrorMessage, d as EMPTY_ARRAY, a as useRefWithInit, b as useMergedRefs, N as NOOP, E as EMPTY_OBJECT, u as useRenderElement } from './useRenderElement-es.js';
+import { E as useControlled, e as useStableCallback, n as useValueAsRef, h as useTransitionStatus, j as useIsoLayoutEffect, N as createGenericEventDetails, K as inputClear, J as inputChange, c as createChangeEventDetails, y as focusOut, a4 as outsidePress, k as getTarget, a3 as itemPress, d as useOpenChangeComplete, Q as useValueChanged, G as none, ar as inputPress, H as visuallyHiddenInput, I as visuallyHidden, r as contains, f as useTimeout, u as useButton, o as ownerDocument, s as stopEvent, v as listNavigation, a as closePress, b as useBaseUiId, ag as isAndroid, ad as isFirefox, a0 as escapeKey, as as clearPress, t as transitionStatusMapping, S as SafeReact, g as error, at as chipRemovePress } from './useButton-es.js';
+import { f as formatErrorMessage, d as EMPTY_ARRAY, a as useRefWithInit, N as NOOP, E as EMPTY_OBJECT, b as useMergedRefs, u as useRenderElement } from './useRenderElement-es.js';
 import { a as useFormContext, b as useFieldRootContext, d as useLabelableId, e as useField, f as fieldValidityMapping, u as useLabelableContext, h as DEFAULT_FIELD_STATE_ATTRIBUTES, c as useLabel } from './useLabel-es.js';
 import { f as useFloatingRootContext, c as useListNavigation, d as useTypeahead, e as getPseudoElementBounds, C as CompositeList, a as useAnchorPositioning, g as getDisabledMountTransitionStyles, u as useCompositeListItem, I as IndexGuessBehavior } from './useCompositeListItem-es.js';
-import { n as createSelector, Z as useStore, s as useOpenInteractionType, y as useClick, t as useDismiss, w as useInteractions, x as useOnFirstRender, _ as Store, W as pressableTriggerOpenStateMapping, m as useDirection, A as triggerOpenStateMapping, q as FloatingPortal, p as popupStateMapping, v as useScrollLock, I as InternalBackdrop, r as inertValue, J as DROPDOWN_COLLISION_AVOIDANCE, o as FloatingFocusManager } from './InternalBackdrop-es.js';
+import { x as createSelector, _ as Store, $ as useStore, E as useOpenInteractionType, M as useClick, H as useDismiss, J as useInteractions, A as useOnFirstRender, U as pressableTriggerOpenStateMapping, n as useDirection, X as triggerOpenStateMapping, r as FloatingPortal, p as popupStateMapping, G as useScrollLock, I as InternalBackdrop, t as inertValue, w as DROPDOWN_COLLISION_AVOIDANCE, F as FloatingFocusManager } from './InternalBackdrop-es.js';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import * as ReactDOM from 'react-dom';
 

package/dist/DataDump/index.cjs

@@ -31,6 +31,7 @@ require('../useButton-cjs.js');
 require('../clamp-cjs.js');
 require('../OverlaySeparator-cjs.js');
 require('../Separator-cjs.js');
+require('../DrawerTitle-cjs.js');
 require('../MenuSubmenuTrigger-cjs.js');
 require('../useCompositeListItem-cjs.js');
 require('../Content-cjs.js');

package/dist/DataDump/index.mjs

@@ -29,6 +29,7 @@ import '../useButton-es.js';
 import '../clamp-es.js';
 import '../OverlaySeparator-es.js';
 import '../Separator-es.js';
+import '../DrawerTitle-es.js';
 import '../MenuSubmenuTrigger-es.js';
 import '../useCompositeListItem-es.js';
 import '../Content-es.js';

package/dist/Dialog/Dialog.d.ts

@@ -0,0 +1,3 @@
+import type { DialogComponent } from "./Dialog.types";
+declare const Dialog: DialogComponent;
+export { Dialog };

package/dist/Dialog/Dialog.types.d.ts

@@ -0,0 +1,205 @@
+import type { CSSProperties, ComponentPropsWithRef, ComponentPropsWithoutRef, FunctionComponent, ReactElement, ReactNode } from "react";
+import type { Dialog as BaseDialog } from "../unstyledPrimitives";
+import type { ButtonProps } from "../Button";
+type BaseUIPropsToExclude = "render" | "className" | "style" | "ref" | "children";
+/** Width of the dialog; `fullScreen` fills the viewport. */
+export type DialogSize = "small" | "base" | "large" | "fullScreen";
+/** `alertdialog` blocks outside/backdrop dismissal; `dialog` allows it. */
+export type DialogType = "dialog" | "alertdialog";
+/**
+ * Shared `className`/`style` contract for the composable Dialog parts.
+ */
+export interface DialogBaseProps {
+    /** Class name applied to the part's root element. */
+    readonly className?: string;
+    /** Inline styles applied to the part's root element. */
+    readonly style?: CSSProperties;
+}
+export type DialogHandle<Payload = unknown> = BaseDialog.Handle<Payload>;
+export interface DialogRootProps<Payload = unknown> extends Pick<BaseDialog.Root.Props<Payload>, "open" | "onOpenChange" | "handle" | "triggerId" | "defaultTriggerId" | "onOpenChangeComplete"> {
+    /**
+     * Called when the user asks to close (escape, backdrop, dismiss button).
+     * Receives BaseUI's change-event details (reason + originating event),
+     * matching how BaseUI types its open/close callbacks.
+     */
+    readonly onRequestClose?: (eventDetails: BaseDialog.Root.ChangeEventDetails) => void;
+    /**
+     * Width of the dialog.
+     * On mobile when this is set to "fullScreen" the bottom sheet will be full screen (100% height).
+     * @default "base"
+     */
+    readonly size?: DialogSize;
+    /**
+     * Type of the dialog. An `alertdialog` requires the user to choose an action
+     * before it can be closed (no outside/backdrop dismissal).
+     * @default "dialog"
+     */
+    readonly type?: DialogType;
+    /**
+     * @see {@link https://base-ui.com/react/components/dialog#DialogPopup-finalFocus}
+     * */
+    readonly finalFocus?: BaseDialog.Popup.Props["finalFocus"];
+    /**
+     * The content of the dialog. This can be a regular React node or a render function that receives the payload of the active trigger.
+     */
+    readonly children?: ReactNode | ((state: {
+        payload: Payload | undefined;
+    }) => ReactNode);
+}
+/** Props BaseUI passes to a `Dialog.Trigger` `render` callback. */
+export type DialogTriggerRenderProps = ComponentPropsWithRef<"button">;
+/** A custom trigger element, or a function that renders one from BaseUI props. */
+export type DialogTriggerRender = ReactElement | ((props: DialogTriggerRenderProps) => ReactElement);
+interface DialogTriggerSharedProps<Payload> extends DialogBaseProps, Omit<BaseDialog.Trigger.Props, BaseUIPropsToExclude | "handle" | "payload"> {
+    /**
+     * Links a detached trigger to a `Dialog` with the matching `handle`, when the
+     * trigger can't be nested inside the `Dialog`.
+     */
+    readonly handle?: DialogHandle<Payload>;
+    /**
+     * Data passed to the dialog when this trigger opens it (used with `handle`).
+     */
+    readonly payload?: Payload;
+}
+interface DialogTriggerDefaultProps<Payload> extends DialogTriggerSharedProps<Payload> {
+    /** Trigger content; an Atlantis `<Button>` or raw text. */
+    readonly children: ReactNode;
+    readonly render?: undefined;
+}
+interface DialogTriggerCustomRenderProps<Payload> extends DialogTriggerSharedProps<Payload> {
+    /** Optional content forwarded to the rendered element. */
+    readonly children?: ReactNode;
+    /** Renders a custom trigger element in place of the default `<Button>`. */
+    readonly render: DialogTriggerRender;
+}
+/**
+ * Either the default
+ * (`children` required, `render` omitted) or custom-render (`render` required,
+ * `children` optional).
+ */
+export type DialogTriggerProps<Payload = unknown> = DialogTriggerDefaultProps<Payload> | DialogTriggerCustomRenderProps<Payload>;
+export interface DialogContentProps extends DialogBaseProps, Omit<BaseDialog.Popup.Props, BaseUIPropsToExclude | "role" | "finalFocus" | "initialFocus"> {
+    readonly children: ReactNode;
+    /**
+     * @see {@link https://base-ui.com/react/components/dialog#DialogPopup-render}
+     */
+    readonly render?: BaseDialog.Popup.Props["render"];
+}
+export interface DialogHeaderProps extends DialogBaseProps, Omit<ComponentPropsWithoutRef<"div">, BaseUIPropsToExclude> {
+    /**
+     * Header content — commonly a `Dialog.Title` and a `Dialog.Close`. The header
+     * only owns layout; it does not impose typography or actions.
+     */
+    readonly children: ReactNode;
+}
+export interface DialogTitleProps extends DialogBaseProps, Omit<BaseDialog.Title.Props, BaseUIPropsToExclude> {
+    /**
+     * Title text. Rendered as a `Heading` and auto-wired to the dialog's
+     * `aria-labelledby`.
+     */
+    readonly children: ReactNode;
+}
+/** Props BaseUI passes to a `Dialog.Close` `render` callback. */
+export type DialogCloseRenderProps = ComponentPropsWithRef<"button">;
+/** A custom dismiss element, or a function that renders one from BaseUI props. */
+export type DialogCloseRender = ReactElement | ((props: DialogCloseRenderProps) => ReactElement);
+export interface DialogCloseProps extends DialogBaseProps, Omit<BaseDialog.Close.Props, BaseUIPropsToExclude> {
+    /**
+     * Optional content for the dismiss control. An Atlantis `<Button>` is adapted
+     * automatically; any other valid element is used as-is. The default ButtonDismiss is used if no children or render is provided.
+     */
+    readonly children?: ReactNode;
+    /**
+     * Renders a custom dismiss element in place of the default `ButtonDismiss`
+     * Pass an element or a function that receives the
+     * BaseUI close props (so the element stays wired to close the dialog).
+     */
+    readonly render?: DialogCloseRender;
+}
+export interface DialogBodyProps extends DialogBaseProps, Omit<BaseDialog.Description.Props, BaseUIPropsToExclude> {
+    /** Body content; describes the dialog (wired to `aria-describedby`). */
+    readonly children: ReactNode;
+    /**
+     * Removes body padding
+     * @default false
+     */
+    readonly fullBleed?: boolean;
+}
+export interface DialogFooterProps extends DialogBaseProps, Omit<ComponentPropsWithoutRef<"div">, BaseUIPropsToExclude> {
+    /**
+     * Footer content. Commonly a `Dialog.Actions`, but the footer is a generic
+     * region — it can hold anything (a note, a checkbox, a custom layout).
+     */
+    readonly children: ReactNode;
+}
+/**
+ * `Dialog.ScrollArea` — the advanced scroll region. Content placed inside it
+ * scrolls (and owns the scrollbar); parts left as siblings of it in
+ * `Dialog.Content` stay pinned. Most dialogs don't need it — `Dialog.Body` is
+ * the scroll region for the common case.
+ */
+export interface DialogScrollAreaProps extends DialogBaseProps {
+    /**
+     * Content that scrolls together — typically a `Dialog.Body` and a non-pinned
+     * `Dialog.Header`/`Dialog.Footer`.
+     */
+    readonly children: ReactNode;
+}
+export type DialogShellRootProps = BaseDialog.Root.Props;
+/** Value shared with the Dialog parts via context. */
+export interface DialogContextValue {
+    /** Dialog vs. alertdialog mode. */
+    readonly type: DialogType;
+    /** Configured dialog width. */
+    readonly size: DialogSize;
+    /**
+     * Whether the dialog should present as a mobile bottom sheet. Computed once at
+     * the root (like Menu's shell selection) and read by the parts.
+     */
+    readonly isMobile: boolean;
+    readonly finalFocus?: BaseDialog.Popup.Props["finalFocus"];
+}
+export interface DialogProviderProps extends DialogContextValue {
+    readonly children: ReactNode;
+}
+/** The assembled `Dialog` component: a root with the parts attached. */
+export interface DialogComponent {
+    <Payload = unknown>(props: DialogRootProps<Payload>): ReactElement;
+    Trigger: <Payload = unknown>(props: DialogTriggerProps<Payload>) => ReactElement;
+    Content: FunctionComponent<DialogContentProps>;
+    Header: FunctionComponent<DialogHeaderProps>;
+    Title: FunctionComponent<DialogTitleProps>;
+    Close: FunctionComponent<DialogCloseProps>;
+    Body: FunctionComponent<DialogBodyProps>;
+    Footer: FunctionComponent<DialogFooterProps>;
+    Actions: FunctionComponent<DialogActionsProps>;
+    ScrollArea: FunctionComponent<DialogScrollAreaProps>;
+    createHandle: <Payload = unknown>() => DialogHandle<Payload>;
+}
+export type DialogActionsAlign = "left" | "right" | "fullWidth";
+interface DialogActionsBaseProps extends DialogBaseProps, Omit<ComponentPropsWithoutRef<"div">, "className" | "style" | "children"> {
+    /** Primary action (right). */
+    readonly primary?: ButtonProps | ReactElement;
+    /** Secondary action (right, subtle). */
+    readonly secondary?: ButtonProps | ReactElement;
+    /** Tertiary/destructive action (left). */
+    readonly tertiary?: ButtonProps | ReactElement;
+    /**
+     * Layout for the right-hand action group.
+     * @default "right"
+     */
+    readonly align?: DialogActionsAlign;
+}
+/**
+ * At least one of `primary`, `secondary`, or `tertiary` is required; any other
+ * combination of the three is allowed. Modeled as a union where each member
+ * pins one action as required while the rest stay optional from the base.
+ */
+export type DialogActionsProps = (DialogActionsBaseProps & {
+    readonly primary: ButtonProps | ReactElement;
+}) | (DialogActionsBaseProps & {
+    readonly secondary: ButtonProps | ReactElement;
+}) | (DialogActionsBaseProps & {
+    readonly tertiary: ButtonProps | ReactElement;
+});
+export {};

package/dist/Dialog/DialogBottomSheet.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import type { DialogBodyProps, DialogCloseProps, DialogContentProps, DialogScrollAreaProps, DialogShellRootProps, DialogTitleProps, DialogTriggerProps } from "./Dialog.types";
+import { SharedDialogFooter, SharedDialogHeader } from "./dialogComposableShared";
+declare function DialogBottomSheetRoot(props: DialogShellRootProps): React.JSX.Element;
+declare function DialogBottomSheetTrigger<Payload = unknown>(props: DialogTriggerProps<Payload>): React.JSX.Element;
+declare function DialogBottomSheetContent({ children, className, style, ...rest }: DialogContentProps): React.JSX.Element;
+declare function DialogBottomSheetTitle({ children, ...rest }: DialogTitleProps): React.JSX.Element;
+declare function DialogBottomSheetClose({ children, render, ...rest }: DialogCloseProps): React.JSX.Element;
+/**
+ * The sheet's scroll region — backed by the BottomSheet primitive's styled
+ * scroll area (native scrollbar + bottom fade). Marks its content as inside a
+ * scroll area so a nested `Dialog.Body` renders plain and sticky regions know
+ * they scroll.
+ */
+declare function DialogBottomSheetScrollArea({ children, className, style, }: DialogScrollAreaProps): React.JSX.Element;
+declare function DialogBottomSheetBody({ children, fullBleed, className, style, ...rest }: DialogBodyProps): React.JSX.Element;
+/** Mobile shell: a bottom sheet built on the BottomSheet/Drawer primitives. */
+export declare const DialogBottomSheet: typeof DialogBottomSheetRoot & {
+    Trigger: typeof DialogBottomSheetTrigger;
+    Content: typeof DialogBottomSheetContent;
+    Header: typeof SharedDialogHeader;
+    Title: typeof DialogBottomSheetTitle;
+    Close: typeof DialogBottomSheetClose;
+    Body: typeof DialogBottomSheetBody;
+    Footer: typeof SharedDialogFooter;
+    ScrollArea: typeof DialogBottomSheetScrollArea;
+};
+export {};

package/dist/Dialog/DialogModal.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import type { DialogBodyProps, DialogCloseProps, DialogContentProps, DialogShellRootProps, DialogTitleProps, DialogTriggerProps } from "./Dialog.types";
+import { DialogScrollArea, SharedDialogFooter, SharedDialogHeader } from "./dialogComposableShared";
+declare function DialogModalRoot(props: DialogShellRootProps): React.JSX.Element;
+declare function DialogModalTrigger<Payload = unknown>({ children, render, handle, payload, className, style, ...rest }: DialogTriggerProps<Payload>): React.JSX.Element;
+declare function DialogModalContent({ children, className, style, ...rest }: DialogContentProps): React.JSX.Element;
+declare function DialogModalTitle({ children, ...rest }: DialogTitleProps): React.JSX.Element;
+declare function DialogModalClose({ children, render, ...rest }: DialogCloseProps): React.JSX.Element;
+declare function DialogModalBody({ children, fullBleed, className, style, ...rest }: DialogBodyProps): React.JSX.Element;
+export declare const DialogModal: typeof DialogModalRoot & {
+    Trigger: typeof DialogModalTrigger;
+    Content: typeof DialogModalContent;
+    Header: typeof SharedDialogHeader;
+    Title: typeof DialogModalTitle;
+    Close: typeof DialogModalClose;
+    Body: typeof DialogModalBody;
+    Footer: typeof SharedDialogFooter;
+    ScrollArea: typeof DialogScrollArea;
+};
+export {};

package/dist/Dialog/constants.d.ts

@@ -0,0 +1 @@
+export declare const SMALL_SCREEN_BREAKPOINT = 490;

package/dist/Dialog/dialogComposableShared.d.ts

@@ -0,0 +1,53 @@
+import React from "react";
+import type { DialogActionsProps, DialogCloseRender, DialogContextValue, DialogFooterProps, DialogHeaderProps, DialogProviderProps, DialogScrollAreaProps, DialogTriggerRender } from "./Dialog.types";
+/**
+ * Resolves the trigger element for `Dialog.Trigger`. Copied from Menu's
+ * `resolveMenuTriggerRender` so an Atlantis `<Button>` works as a trigger via
+ * `children` or `render` identically in both shells. Raw text children are
+ * wrapped in a default `Button`.
+ */
+export declare function resolveComposableTriggerRender({ children, render, }: {
+    readonly children?: React.ReactNode;
+    readonly render?: DialogTriggerRender;
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | ((props: React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>) => React.JSX.Element);
+/**
+ * Resolves the dismiss element for `Dialog.Close`, mirroring
+ * `resolveComposableTriggerRender` so a custom render works in both shells.
+ * Falls back to the subtle "remove" `ButtonDismiss` when neither `render` nor
+ * `children` are supplied. An Atlantis `<Button>`/`<ButtonDismiss>` passed via
+ * `render` or `children` is adapted; any other valid element is used as-is.
+ */
+export declare function resolveComposableCloseRender({ children, render, }: {
+    readonly children?: React.ReactNode;
+    readonly render?: DialogCloseRender;
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | ((props: React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>) => React.JSX.Element);
+/** Supplies the static config (type/size/isMobile/finalFocus) to the parts. */
+export declare function DialogProvider({ children, type, size, isMobile, finalFocus, }: DialogProviderProps): React.JSX.Element;
+/** Reads the Dialog config; throws if a part is used outside `<Dialog>`. */
+export declare function useDialogContext(): DialogContextValue;
+/**
+ * True when the current parts render inside a `Dialog.ScrollArea` (or the scroll
+ * region a `Dialog.Body` wraps itself in). Header/Footer read it to know whether
+ * they are sticky (not nested inside a `Dialog.ScrollArea`) or scroll (nested inside a `Dialog.ScrollArea`); `Dialog.Body`
+ * reads it to avoid creating a nested scroller.
+ */
+export declare const DialogScrollAreaContext: React.Context<boolean>;
+/** Whether the current part is nested inside a `Dialog.ScrollArea`. */
+export declare function useInsideDialogScrollArea(): boolean;
+/**
+ * The modal's scroll region — a BaseUI `ScrollArea` that scrolls its content
+ * with the browser's native scrollbar (re-enabled in Dialog.module.css). Content
+ * placed inside it scrolls and owns the scrollbar; `Dialog.Body` used on its own
+ * wraps itself in one. (The bottom sheet uses `DialogBottomSheetScrollArea`,
+ * backed by the BottomSheet primitive's scroll area, for its fade.)
+ */
+export declare function DialogScrollArea({ children, className, style, }: DialogScrollAreaProps): React.JSX.Element;
+/** Layout-only header row; sticky unless nested inside a `Dialog.ScrollArea`. */
+export declare function SharedDialogHeader({ children, className, style, ...rest }: DialogHeaderProps): React.JSX.Element;
+/** Generic footer region; sticky unless nested inside a `Dialog.ScrollArea`. */
+export declare function SharedDialogFooter({ children, className, style, ...rest }: DialogFooterProps): React.JSX.Element;
+/**
+ * The action-button layout: tertiary on the left, primary/secondary grouped on
+ * the right. Drop it inside a `Dialog.Footer`.
+ */
+export declare function DialogActions({ primary, secondary, tertiary, align, className, style, ...rest }: DialogActionsProps): React.JSX.Element;

package/dist/Dialog/dialogReturnFocus.d.ts

@@ -0,0 +1,43 @@
+import type { RefObject } from "react";
+/**
+ * The first focusable element within `container` (the container itself counts if
+ * it is focusable). Skips hidden elements. Returns `null` when nothing inside is
+ * focusable.
+ */
+export declare function getFirstFocusableWithin(container: HTMLElement | null): HTMLElement | null;
+/** Options for {@link getDialogReturnFocus}. */
+export interface DialogReturnFocusOptions {
+    /**
+     * The element focus should return to when it is still in the DOM at close
+     * time — typically the trigger (an autocomplete/combobox input, a button).
+     */
+    readonly trigger?: RefObject<HTMLElement | null> | null;
+    /**
+     * A container that stays mounted while the trigger may unmount. When the
+     * trigger is gone, focus returns to the first focusable element inside it —
+     * e.g. the card that replaced the trigger. Keep it scoped tightly around the
+     * region that swaps so the "closest" element is the one the user expects.
+     */
+    readonly boundary: RefObject<HTMLElement | null>;
+}
+/**
+ * Builds a `finalFocus` callback for `Dialog` that keeps keyboard focus near the
+ * trigger even when the trigger unmounts while the dialog is open (e.g. an
+ * autocomplete "Create" action whose row is replaced by a card on save).
+ *
+ * Resolution order on close:
+ * 1. the `trigger`, if it is still connected;
+ * 2. otherwise the first focusable element inside `boundary` (the "closest"
+ *    landing spot);
+ * 3. otherwise `null`, which lets BaseUI fall back to its default behavior.
+ *
+ * @example
+ * const triggerRef = useRef<HTMLInputElement>(null);
+ * const boundaryRef = useRef<HTMLDivElement>(null);
+ * <div ref={boundaryRef}>…</div>
+ * <Dialog
+ *   handle={handle}
+ *   finalFocus={getDialogReturnFocus({ trigger: triggerRef, boundary: boundaryRef })}
+ * >
+ */
+export declare function getDialogReturnFocus({ trigger, boundary, }: DialogReturnFocusOptions): () => HTMLElement | null;

package/dist/Dialog/index.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var dialogReturnFocus = require('../dialogReturnFocus-cjs.js');
+require('../tslib.es6-cjs.js');
+require('react');
+require('@jobber/hooks');
+require('classnames');
+require('../buttonRenderAdapter-cjs.js');
+require('../Button-cjs.js');
+require('react-router-dom');
+require('../Icon-cjs.js');
+require('@jobber/design');
+require('../Typography-cjs.js');
+require('../useRenderElement-cjs.js');
+require('../ScrollAreaViewport-cjs.js');
+require('../InternalBackdrop-cjs.js');
+require('../index.esm-cjs.js');
+require('../floating-ui.utils.dom-cjs.js');
+require('../useButton-cjs.js');
+require('react-dom');
+require('react/jsx-runtime');
+require('../clamp-cjs.js');
+require('../Heading-cjs.js');
+require('../BottomSheet-cjs.js');
+require('../DrawerTitle-cjs.js');
+require('../DrawerDescription-cjs.js');
+
+
+
+exports.Dialog = dialogReturnFocus.Dialog;
+exports.getDialogReturnFocus = dialogReturnFocus.getDialogReturnFocus;
+exports.getFirstFocusableWithin = dialogReturnFocus.getFirstFocusableWithin;

package/dist/Dialog/index.d.ts

@@ -0,0 +1,4 @@
+export { Dialog } from "./Dialog";
+export { getDialogReturnFocus, getFirstFocusableWithin, } from "./dialogReturnFocus";
+export type { DialogReturnFocusOptions } from "./dialogReturnFocus";
+export type { DialogBodyProps, DialogCloseProps, DialogCloseRender, DialogContentProps, DialogFooterProps, DialogHandle, DialogHeaderProps, DialogRootProps, DialogSize, DialogTitleProps, DialogTriggerProps, DialogTriggerRender, DialogType, } from "./Dialog.types";

package/dist/Dialog/index.mjs

@@ -0,0 +1,24 @@
+export { D as Dialog, g as getDialogReturnFocus, a as getFirstFocusableWithin } from '../dialogReturnFocus-es.js';
+import '../tslib.es6-es.js';
+import 'react';
+import '@jobber/hooks';
+import 'classnames';
+import '../buttonRenderAdapter-es.js';
+import '../Button-es.js';
+import 'react-router-dom';
+import '../Icon-es.js';
+import '@jobber/design';
+import '../Typography-es.js';
+import '../useRenderElement-es.js';
+import '../ScrollAreaViewport-es.js';
+import '../InternalBackdrop-es.js';
+import '../index.esm-es.js';
+import '../floating-ui.utils.dom-es.js';
+import '../useButton-es.js';
+import 'react-dom';
+import 'react/jsx-runtime';
+import '../clamp-es.js';
+import '../Heading-es.js';
+import '../BottomSheet-es.js';
+import '../DrawerTitle-es.js';
+import '../DrawerDescription-es.js';