@radix-ng/primitives 0.51.0 → 1.0.0-beta.0

package/types/radix-ng-primitives-drawer.d.ts

@@ -0,0 +1,448 @@
+import * as i0 from '@angular/core';
+import { Signal, Provider } from '@angular/core';
+import { BooleanInput } from '@radix-ng/primitives/core';
+import * as i1 from '@radix-ng/primitives/dialog';
+import { RdxDialogHandle } from '@radix-ng/primitives/dialog';
+import * as _radix_ng_primitives_drawer from '@radix-ng/primitives/drawer';
+
+/** A single open drawer's registration with the {@link RdxDrawerProvider}. */
+interface RdxDrawerRegistration {
+    /** Stable id of the registered drawer root. */
+    id: string;
+    /** The drawer popup's measured size (px) along its dismiss axis. */
+    height: Signal<number>;
+}
+/**
+ * App-level coordinator that tracks every open drawer so background content can react to them
+ * (the page-scale / indent effect). Provide it once near the app root with
+ * {@link provideRdxDrawerProvider} or the `[rdxDrawerProvider]` directive; drawers that find it in
+ * their injector register while open. It is optional — drawers work without it.
+ */
+declare class RdxDrawerProvider {
+    private readonly stack;
+    /** Number of open drawers. */
+    readonly count: Signal<number>;
+    /** Whether any drawer is open. */
+    readonly active: Signal<boolean>;
+    /** The most recently opened (frontmost) drawer, or `null`. */
+    readonly frontmost: Signal<RdxDrawerRegistration | null>;
+    /** The frontmost drawer's measured size (px), or `0` when none is open. */
+    readonly frontmostHeight: Signal<number>;
+    /** Register an open drawer; returns a disposer that removes it. */
+    register(registration: RdxDrawerRegistration): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RdxDrawerProvider>;
+}
+/** Provide a {@link RdxDrawerProvider} for an app (e.g. in `app.config.ts`). */
+declare function provideRdxDrawerProvider(): Provider[];
+/**
+ * Hosts a {@link RdxDrawerProvider} for its subtree. Put it on a wrapping element so descendant
+ * drawer roots and `rdxDrawerIndent*` parts share one coordinator.
+ */
+declare class RdxDrawerProviderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerProviderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerProviderDirective, "[rdxDrawerProvider]", ["rdxDrawerProvider"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Direction a swipe travels to dismiss the drawer. Mirrors Base UI's `swipeDirection`:
+ * `'down'` is the default (bottom sheet). The *visual* side of the drawer is consumer CSS;
+ * this only controls the dismiss gesture and the data/CSS-variable contract below.
+ */
+type RdxDrawerSwipeDirection = 'up' | 'down' | 'left' | 'right';
+/** The decision a release resolves to: dismiss the drawer, or rest at a snap offset (px). */
+type RdxDrawerRelease = {
+    type: 'dismiss';
+} | {
+    type: 'snap';
+    offset: number;
+};
+interface RdxDrawerSwipeConfig {
+    /** The popup element the gesture lives on (CSS variables + data attributes are written here). */
+    element: () => HTMLElement;
+    /** Active swipe direction. */
+    direction: Signal<RdxDrawerSwipeDirection>;
+    /** Whether the gesture is currently armed (typically `open`). */
+    enabled: Signal<boolean>;
+    /**
+     * Resting translate magnitude (px toward dismissal) of the active snap point; `0` is fully open
+     * and the default when there are no snap points. The popup keeps this in sync with snap state.
+     */
+    restingOffset: Signal<number>;
+    /**
+     * Decide where a release lands. `projected` is the resting offset the drag reached (px toward
+     * dismissal, may be negative past fully-open); `velocity` is signed px/ms toward dismissal;
+     * `canDismiss` is false for a cancelled gesture or a closed drawer.
+     */
+    resolveRelease: (projected: number, velocity: number, canDismiss: boolean) => RdxDrawerRelease;
+    /** Called once per release that resolves to dismissal. */
+    onDismiss: (event: PointerEvent) => void;
+    /** Called with the 0..1 live dismiss progress so siblings (backdrop) can react; `0` at rest. */
+    onProgress?: (strength: number) => void;
+}
+/**
+ * Headless swipe gesture for the drawer popup: dismiss, snap-back, and movement between snap points.
+ *
+ * Writes a small contract the consumer styles against (no transform is applied for you, keeping the
+ * primitive headless):
+ * - `--drawer-swipe-movement-x` / `--drawer-swipe-movement-y` — signed px offset along the axis,
+ *   including the active snap point's resting offset while idle.
+ * - `--drawer-swipe-strength` — 0..1 live dismiss progress (`0` at rest).
+ * - `[data-swiping]` — present while a gesture is active (drive `transition: none` off this).
+ * - `[data-swipe-direction]` — the active direction.
+ * - `[data-swipe-dismiss]` — present briefly when a release commits to dismissal.
+ *
+ * While idle the movement variables hold the active snap offset; releasing without dismissing writes
+ * the target offset so the consumer's `transition` animates between snap points and home.
+ *
+ * Must be called from an injection context (a directive/component constructor).
+ */
+declare function useDrawerSwipe(config: RdxDrawerSwipeConfig): void;
+
+/**
+ * A resting position for the drawer along the dismiss axis.
+ *
+ * - a number in `(0, 1]` — a fraction of the drawer's size (`1` = fully open);
+ * - a number `> 1` — an absolute amount of the drawer revealed, in pixels;
+ * - a string — `'148px'` (pixels), `'30rem'` (root-em), `'40%'` (fraction of size), or a bare number
+ *   as above.
+ *
+ * Order the `snapPoints` array ascending by openness; the last entry is treated as "most open" and
+ * is the default the drawer opens to when `defaultSnapPoint` is not set.
+ */
+type RdxDrawerSnapPoint = number | string;
+/**
+ * Resolve a snap point to the number of pixels of the drawer revealed at that point. `rootFontSize`
+ * (px) resolves `rem` units; it defaults to the CSS initial value of `16`.
+ */
+declare function snapPointReveal(value: RdxDrawerSnapPoint, size: number, rootFontSize?: number): number;
+interface RdxDrawerSnapEntry {
+    value: RdxDrawerSnapPoint;
+    /** Pixels of the drawer revealed at this point. */
+    reveal: number;
+    /** Translate magnitude (px) toward dismissal from fully-open; `0` is fully open. */
+    offset: number;
+}
+/**
+ * Build the snap entries for a given drawer size, sorted by openness (most open / smallest offset
+ * first). `offset = size - reveal`, so a fully-revealed point sits at offset `0`.
+ */
+declare function buildSnapEntries(values: readonly RdxDrawerSnapPoint[], size: number, rootFontSize?: number): RdxDrawerSnapEntry[];
+type RdxDrawerSnapTarget = {
+    dismiss: true;
+} | {
+    index: number;
+};
+interface RdxDrawerSnapResolveOptions {
+    /** Snap offsets (px), ascending; index-aligned to the sorted entries. */
+    offsets: readonly number[];
+    /** Index of the currently active offset. */
+    activeIndex: number;
+    /** Projected resting offset (px toward dismissal) at release. */
+    projected: number;
+    /** Signed release velocity (px/ms), positive toward dismissal. */
+    velocity: number;
+    /** Drawer size (px); the dismiss target sits here (fully hidden). */
+    size: number;
+    /** Step at most one snap point per release instead of velocity-skipping. */
+    sequential: boolean;
+    /** Whether passing the most-closed point may dismiss the drawer. */
+    canDismiss: boolean;
+}
+/** Pick the snap point (or dismissal) a release lands on. */
+declare function resolveSnapTarget(options: RdxDrawerSnapResolveOptions): RdxDrawerSnapTarget;
+/** The unit translate vector pointing toward dismissal for a direction. */
+declare function dismissUnitVector(direction: RdxDrawerSwipeDirection): {
+    x: number;
+    y: number;
+};
+
+interface RdxDrawerRootContext {
+    /** Direction a swipe travels to dismiss the drawer. */
+    swipeDirection: Signal<RdxDrawerSwipeDirection>;
+    /** 0..1 progress of the active dismiss gesture; siblings (e.g. backdrop) react to it. */
+    swipeProgress: Signal<number>;
+    /** Reports gesture progress from the popup's swipe engine. */
+    setSwipeProgress: (value: number) => void;
+    /** Configured snap points (empty when the drawer has none). */
+    snapPoints: Signal<readonly RdxDrawerSnapPoint[]>;
+    /** Whether the drawer rests at discrete snap points. */
+    hasSnapPoints: Signal<boolean>;
+    /** The active snap point, or `null` when none is set / the drawer is closed. */
+    activeSnapPoint: Signal<RdxDrawerSnapPoint | null>;
+    /** Step at most one snap point per release instead of velocity-skipping. */
+    sequentialSnap: Signal<boolean>;
+    /** Sets the active snap point, optionally emitting `onSnapPointChange`. */
+    setActiveSnapPoint: (value: RdxDrawerSnapPoint, emit: boolean) => void;
+    /** Whether a drawer nested inside this one is open. */
+    nestedDrawerOpen: Signal<boolean>;
+    /** Number of drawers nested inside this one that are open. */
+    nestedDrawerCount: Signal<number>;
+    /** The app-wide frontmost drawer's measured size (px), via the optional provider. */
+    frontmostHeight: Signal<number>;
+    /** Reports the popup's measured size (px) so the provider can expose it. */
+    reportPopupHeight: (height: number) => void;
+}
+declare const injectRdxDrawerRootContext: (optional?: boolean) => RdxDrawerRootContext | null;
+declare const provideRdxDrawerRootContext: (useFactory: () => RdxDrawerRootContext) => i0.Provider;
+/**
+ * Groups all parts of the drawer.
+ *
+ * Composes the Dialog primitive directly (modal-by-default but user-overridable) and layers the
+ * drawer-specific swipe and snap-point contract on top via {@link RdxDrawerRootContext}. Modality,
+ * dismissal and detached-trigger handling are the dialog's: the `modal`, `disablePointerDismissal`
+ * and `handle` inputs are proxied straight through, so a drawer is a modal dialog the user can make
+ * non-modal.
+ */
+declare class RdxDrawerRoot {
+    private readonly dialog;
+    private readonly provider;
+    /** The popup's measured size (px) along its dismiss axis, reported by the popup. */
+    readonly popupHeight: i0.WritableSignal<number>;
+    /**
+     * Direction a swipe travels to dismiss the drawer. The visual side of the drawer is consumer
+     * CSS; this controls the dismiss gesture and the `data-swipe-direction` styling hook.
+     */
+    readonly swipeDirection: i0.InputSignal<RdxDrawerSwipeDirection>;
+    /**
+     * Resting positions the drawer snaps to along the dismiss axis. Order ascending by openness; the
+     * last entry is the default the drawer opens to. Omit for a plain open/closed drawer.
+     */
+    readonly snapPoints: i0.InputSignal<readonly RdxDrawerSnapPoint[] | undefined>;
+    /** The active snap point (controlled / uncontrolled with `[(snapPoint)]`). */
+    readonly snapPoint: i0.ModelSignal<RdxDrawerSnapPoint | null>;
+    /** The snap point the drawer opens to when uncontrolled; defaults to the most open point. */
+    readonly defaultSnapPoint: i0.InputSignal<RdxDrawerSnapPoint | undefined>;
+    /** Step at most one snap point per release instead of letting velocity skip points. */
+    readonly snapToSequentialPoints: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Emits when the active snap point changes through a gesture. */
+    readonly onSnapPointChange: i0.OutputEmitterRef<RdxDrawerSnapPoint>;
+    /** 0..1 progress of the active dismiss gesture, written by the popup's swipe engine. */
+    readonly swipeProgress: i0.WritableSignal<number>;
+    readonly normalizedSnapPoints: Signal<readonly RdxDrawerSnapPoint[]>;
+    readonly hasSnapPoints: Signal<boolean>;
+    /** Whether a drawer nested inside this one is open (reuses the dialog's nesting detection). */
+    readonly nestedDrawerOpen: Signal<boolean>;
+    /** Number of open drawers nested inside this one. */
+    readonly nestedDrawerCount: Signal<number>;
+    /** The app-wide frontmost drawer's measured size (px); `0` without a provider. */
+    readonly frontmostHeight: Signal<number>;
+    /** Whether the drawer is open (read-only mirror of the composed dialog state). */
+    readonly open: i0.ModelSignal<boolean>;
+    /** The active trigger's id. */
+    readonly triggerId: i0.ModelSignal<string | null>;
+    /** Payload of the active trigger. */
+    readonly payload: i0.WritableSignal<unknown>;
+    constructor();
+    setActiveSnapPoint(value: RdxDrawerSnapPoint, emit: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerRoot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerRoot, "[rdxDrawerRoot]", ["rdxDrawerRoot"], { "swipeDirection": { "alias": "swipeDirection"; "required": false; "isSignal": true; }; "snapPoints": { "alias": "snapPoints"; "required": false; "isSignal": true; }; "snapPoint": { "alias": "snapPoint"; "required": false; "isSignal": true; }; "defaultSnapPoint": { "alias": "defaultSnapPoint"; "required": false; "isSignal": true; }; "snapToSequentialPoints": { "alias": "snapToSequentialPoints"; "required": false; "isSignal": true; }; }, { "snapPoint": "snapPointChange"; "onSnapPointChange": "onSnapPointChange"; }, never, never, true, [{ directive: typeof i1.RdxDialogRoot; inputs: { "open": "open"; "defaultOpen": "defaultOpen"; "triggerId": "triggerId"; "defaultTriggerId": "defaultTriggerId"; "handle": "handle"; "modal": "modal"; "disablePointerDismissal": "disablePointerDismissal"; }; outputs: { "openChange": "openChange"; "triggerIdChange": "triggerIdChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }; }]>;
+}
+
+/**
+ * A button that opens the drawer. Behaves exactly like the dialog trigger.
+ */
+declare class RdxDrawerTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerTrigger, "button[rdxDrawerTrigger]", ["rdxDrawerTrigger"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogTrigger; inputs: { "handle": "handle"; "payload": "payload"; "id": "id"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * An off-canvas region (typically pinned to a screen edge) that opens the drawer when swiped inward.
+ *
+ * Phase 1 opens on a threshold crossing rather than following the pointer live (the popup is not
+ * mounted while closed); the live-follow open will land with snap points. Shares the drawer's
+ * pointer-drag lifecycle so capture/cancel handling stays consistent with the popup gesture.
+ */
+declare class RdxDrawerSwipeArea {
+    private readonly drawerContext;
+    private readonly dialogContext;
+    /** Direction the swipe area opens from; defaults to the root's `swipeDirection`. */
+    readonly swipeDirection: i0.InputSignal<RdxDrawerSwipeDirection | undefined>;
+    /** Whether the swipe area should ignore user interaction. */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly isOpen: i0.Signal<boolean>;
+    protected readonly direction: i0.Signal<RdxDrawerSwipeDirection>;
+    protected readonly swiping: i0.WritableSignal<boolean>;
+    private startX;
+    private startY;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerSwipeArea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerSwipeArea, "[rdxDrawerSwipeArea]", ["rdxDrawerSwipeArea"], { "swipeDirection": { "alias": "swipeDirection"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Mounts the portal while the drawer is open and waits for CSS exit keyframes before unmounting.
+ */
+declare class RdxDrawerPortalPresence {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerPortalPresence, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerPortalPresence, "ng-template[rdxDrawerPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPortalPresence; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Moves the drawer to a different part of the DOM. Defaults to `document.body`.
+ */
+declare class RdxDrawerPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerPortal, "[rdxDrawerPortal]", ["rdxDrawerPortal"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+/**
+ * An overlay displayed beneath the drawer popup.
+ *
+ * Composes the dialog backdrop and additionally exposes `--drawer-swipe-progress` (0..1) so the
+ * consumer can fade it in step with the dismiss gesture.
+ */
+declare class RdxDrawerBackdrop {
+    protected readonly drawerContext: _radix_ng_primitives_drawer.RdxDrawerRootContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerBackdrop, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerBackdrop, "[rdxDrawerBackdrop]", ["rdxDrawerBackdrop"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogBackdrop; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A positioning container for the drawer popup that can be made scrollable.
+ *
+ * Exposes the dialog viewport's `data-nested` / `data-nested-dialog-open` state for styling.
+ */
+declare class RdxDrawerViewport {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerViewport, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerViewport, "[rdxDrawerViewport]", ["rdxDrawerViewport"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogViewport; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A container for the drawer contents.
+ *
+ * Composes the dialog popup (focus trap, dismissal, scroll lock, a11y wiring) and owns the drawer
+ * gesture on top of it: swipe-to-dismiss, snap-back, and movement between snap points. The gesture
+ * publishes a CSS-variable / data-attribute contract (see {@link useDrawerSwipe}); the consumer
+ * styles the actual transform and snap-back transition off it, keeping the primitive headless.
+ */
+declare class RdxDrawerPopup {
+    protected readonly drawerContext: _radix_ng_primitives_drawer.RdxDrawerRootContext;
+    private readonly dialogContext;
+    private readonly elementRef;
+    private readonly element;
+    /** Live popup size (px); a ResizeObserver keeps it current so snap geometry never goes stale. */
+    private readonly size;
+    /** Snap entries for the current size; built once and shared by the offset/expanded reads. */
+    private readonly snapEntries;
+    /** Resting translate magnitude (px) of the active snap point; `0` when fully open / no snaps. */
+    readonly restingOffset: i0.Signal<number>;
+    /** Whether the active snap point is the most open one. */
+    protected readonly expanded: i0.Signal<boolean>;
+    /** The frontmost nested drawer's height for `--drawer-frontmost-height`, or unset when none. */
+    protected readonly frontmostHeightPx: i0.Signal<string | null>;
+    constructor();
+    private axisSize;
+    private resolveRelease;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerPopup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerPopup, "[rdxDrawerPopup]", ["rdxDrawerPopup"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPopup; inputs: {}; outputs: { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }; }]>;
+}
+
+/**
+ * The scrollable body of the drawer.
+ *
+ * A structural marker so the anatomy matches Base UI. The popup's swipe engine yields to scrolling
+ * inside this region automatically (it only starts a dismiss gesture when the scroll is at its
+ * edge), so no extra wiring is needed. Opt individual elements out of swiping with the
+ * `data-base-ui-swipe-ignore` attribute.
+ */
+declare class RdxDrawerContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerContent, "[rdxDrawerContent]", ["rdxDrawerContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * An accessible title announced when the drawer is opened.
+ */
+declare class RdxDrawerTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerTitle, "[rdxDrawerTitle]", ["rdxDrawerTitle"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogTitle; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * An accessible description announced when the drawer is opened.
+ */
+declare class RdxDrawerDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerDescription, "[rdxDrawerDescription]", ["rdxDrawerDescription"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogDescription; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A button that closes the drawer.
+ */
+declare class RdxDrawerClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerClose, "button[rdxDrawerClose]", ["rdxDrawerClose"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogClose; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Background content that scales/indents while any drawer is open.
+ *
+ * Reads the nearest {@link RdxDrawerProvider} and exposes styling hooks; the visual transform is
+ * consumer CSS (headless):
+ * - `[data-active]` — present while at least one drawer is open.
+ * - `--nested-drawers` — the number of open drawers.
+ * - `--drawer-frontmost-height` — the frontmost drawer's measured size, in pixels.
+ */
+declare class RdxDrawerIndent {
+    protected readonly provider: RdxDrawerProvider | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerIndent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerIndent, "[rdxDrawerIndent]", ["rdxDrawerIndent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The page background layer that scales/indents while any drawer is open.
+ *
+ * Behaves like {@link RdxDrawerIndent} (same `[data-active]` / `--nested-drawers` /
+ * `--drawer-frontmost-height` contract); kept as a distinct part so the page backdrop and the
+ * indented content can be styled independently, mirroring Base UI.
+ */
+declare class RdxDrawerIndentBackground {
+    protected readonly provider: RdxDrawerProvider | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerIndentBackground, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDrawerIndentBackground, "[rdxDrawerIndentBackground]", ["rdxDrawerIndentBackground"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Connects a drawer root with trigger elements rendered elsewhere in the DOM.
+ *
+ * Drawers reuse the dialog handle implementation unchanged.
+ */
+declare const RdxDrawerHandle: typeof RdxDialogHandle;
+type RdxDrawerHandle<Payload = unknown> = RdxDialogHandle<Payload>;
+declare function createRdxDrawerHandle<Payload = unknown>(): RdxDrawerHandle<Payload>;
+
+interface RdxPointerDragHandlers {
+    /** Whether a press may begin a drag (e.g. enabled, not on an opt-out element, at a scroll edge). */
+    canStart: (event: PointerEvent) => boolean;
+    /** A drag actually began (the pointer moved past the start threshold). */
+    onStart: (event: PointerEvent) => void;
+    /** Pointer moved during a drag. Return `false` to end the gesture early (treated as not committed). */
+    onMove: (event: PointerEvent) => void | boolean;
+    /** The drag ended. `committed` is true only for a normal `pointerup`, false for cancel/lost-capture/early-stop. */
+    onEnd: (event: PointerEvent, committed: boolean) => void;
+}
+/**
+ * Shared pointer-drag lifecycle for the drawer gestures (popup swipe and swipe-area open).
+ *
+ * A press only becomes a drag once the pointer moves past {@link DRAG_THRESHOLD}; until then it is a
+ * plain tap, so clicks on buttons inside the drawer keep working (the gesture never captures the
+ * pointer for a tap). Once dragging, the pointer is captured so a drag that leaves the element still
+ * completes, and `lostpointercapture` / `pointercancel` count as a non-committed end — a swallowed
+ * `pointerup` (native context menu, OS gesture, tab switch) can never wedge the gesture. No-op
+ * outside the browser, keeping SSR safe.
+ *
+ * Must be called from an injection context (a directive/component constructor).
+ */
+declare function usePointerDrag(handlers: RdxPointerDragHandlers): void;
+
+declare const drawerImports: (typeof RdxDrawerProviderDirective)[];
+declare class RdxDrawerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxDrawerModule, never, [typeof RdxDrawerProviderDirective, typeof RdxDrawerRoot, typeof RdxDrawerTrigger, typeof RdxDrawerSwipeArea, typeof RdxDrawerPortalPresence, typeof RdxDrawerPortal, typeof RdxDrawerBackdrop, typeof RdxDrawerViewport, typeof RdxDrawerPopup, typeof RdxDrawerContent, typeof RdxDrawerTitle, typeof RdxDrawerDescription, typeof RdxDrawerClose, typeof RdxDrawerIndent, typeof RdxDrawerIndentBackground], [typeof RdxDrawerProviderDirective, typeof RdxDrawerRoot, typeof RdxDrawerTrigger, typeof RdxDrawerSwipeArea, typeof RdxDrawerPortalPresence, typeof RdxDrawerPortal, typeof RdxDrawerBackdrop, typeof RdxDrawerViewport, typeof RdxDrawerPopup, typeof RdxDrawerContent, typeof RdxDrawerTitle, typeof RdxDrawerDescription, typeof RdxDrawerClose, typeof RdxDrawerIndent, typeof RdxDrawerIndentBackground]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxDrawerModule>;
+}
+
+export { RdxDrawerBackdrop, RdxDrawerClose, RdxDrawerContent, RdxDrawerDescription, RdxDrawerHandle, RdxDrawerIndent, RdxDrawerIndentBackground, RdxDrawerModule, RdxDrawerPopup, RdxDrawerPortal, RdxDrawerPortalPresence, RdxDrawerProvider, RdxDrawerProviderDirective, RdxDrawerRoot, RdxDrawerSwipeArea, RdxDrawerTitle, RdxDrawerTrigger, RdxDrawerViewport, buildSnapEntries, createRdxDrawerHandle, dismissUnitVector, drawerImports, injectRdxDrawerRootContext, provideRdxDrawerProvider, provideRdxDrawerRootContext, resolveSnapTarget, snapPointReveal, useDrawerSwipe, usePointerDrag };
+export type { RdxDrawerRegistration, RdxDrawerRelease, RdxDrawerRootContext, RdxDrawerSnapEntry, RdxDrawerSnapPoint, RdxDrawerSnapResolveOptions, RdxDrawerSnapTarget, RdxDrawerSwipeConfig, RdxDrawerSwipeDirection, RdxPointerDragHandlers };

package/types/radix-ng-primitives-editable.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal } from '@angular/core';
-import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/dismissable-layer';
 import { RdxPointerDownOutside } from '@radix-ng/primitives/dismissable-layer';