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

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

@@ -29,7 +29,7 @@ declare const context$2: () => {
     itemTextRefCallback: (node: any, value: any, disabled: any) => void;
 };
 type RdxSelectContentContext = ReturnType<typeof context$2>;
-declare const injectSelectContentContext: (optional?: boolean) => {
+declare const injectSelectContentContext: _radix_ng_primitives_core.InjectContext<{
     content: _angular_core.WritableSignal<HTMLElement | null>;
     viewport: _angular_core.WritableSignal<HTMLElement | undefined>;
     isPositioned: _angular_core.WritableSignal<boolean>;
@@ -39,7 +39,7 @@ declare const injectSelectContentContext: (optional?: boolean) => {
     onItemLeave: () => void;
     itemRefCallback: (node: any, value: any, disabled: boolean) => void;
     itemTextRefCallback: (node: any, value: any, disabled: any) => void;
-} | null;
+}>;
 declare const provideSelectContentContext: (useFactory: () => {
     content: _angular_core.WritableSignal<HTMLElement | null>;
     viewport: _angular_core.WritableSignal<HTMLElement | undefined>;
@@ -119,13 +119,13 @@ declare const context$1: () => {
     onItemTextChange: (node: any) => void;
 };
 type RdxSelectItemContext = ReturnType<typeof context$1>;
-declare const injectSelectItemContext: (optional?: boolean) => {
+declare const injectSelectItemContext: _radix_ng_primitives_core.InjectContext<{
     value: _angular_core.InputSignal<any>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     isSelected: _angular_core.Signal<boolean>;
     textId: string;
     onItemTextChange: (node: any) => void;
-} | null;
+}>;
 declare const provideSelectItemContext: (useFactory: () => {
     value: _angular_core.InputSignal<any>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
@@ -352,7 +352,7 @@ declare const context: () => {
     onOpenChange: (value: any) => void;
 };
 type RdxSelectRootContext = ReturnType<typeof context>;
-declare const injectSelectRootContext: (optional?: boolean) => {
+declare const injectSelectRootContext: _radix_ng_primitives_core.InjectContext<{
     triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
     valueElement: _angular_core.WritableSignal<HTMLElement | null>;
     triggerPointerDownPosRef: _angular_core.WritableSignal<{
@@ -373,7 +373,7 @@ declare const injectSelectRootContext: (optional?: boolean) => {
     onTriggerChange: (node: any) => void;
     onValueElementChange: (node: any) => void;
     onOpenChange: (value: any) => void;
-} | null;
+}>;
 declare const provideSelectRootContext: (useFactory: () => {
     triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
     valueElement: _angular_core.WritableSignal<HTMLElement | null>;

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

@@ -364,7 +364,7 @@ declare class RdxSliderValue {
  *
  * @see https://base-ui.com/react/components/slider
  */
-declare const injectSliderRootContext: (optional?: boolean) => RdxSliderRoot | null;
+declare const injectSliderRootContext: i1.InjectContext<RdxSliderRoot>;
 declare const provideSliderRootContext: (useFactory: () => RdxSliderRoot) => _angular_core.Provider;
 
 declare class RdxSliderModule {

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

@@ -107,7 +107,7 @@ interface RdxSwitchContext {
     readonly ariaLabelledBy: Signal<string | undefined>;
     markAsTouched(): void;
 }
-declare const injectSwitchContext: (optional?: boolean) => RdxSwitchContext | null;
+declare const injectSwitchContext: i1.InjectContext<RdxSwitchContext>;
 declare const provideSwitchContext: (useFactory: () => RdxSwitchContext) => _angular_core.Provider;
 
 declare const switchImports: (typeof RdxSwitchInput | typeof RdxSwitchRoot | typeof RdxSwitchThumb)[];

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

@@ -233,7 +233,7 @@ interface RdxTabsRootContext {
     /** Register the list host element. */
     setTabListElement(element: HTMLElement | null): void;
 }
-declare const injectTabsRootContext: (optional?: boolean) => RdxTabsRootContext | null;
+declare const injectTabsRootContext: _radix_ng_primitives_core.InjectContext<RdxTabsRootContext>;
 declare const provideTabsRootContext: (useFactory: () => RdxTabsRootContext) => _angular_core.Provider;
 
 declare const tabsImports: (typeof RdxTabsPanelPresence)[];

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

@@ -0,0 +1,378 @@
+import * as i0 from '@angular/core';
+import { Provider } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/portal';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { RdxTransitionStatus } from '@radix-ng/primitives/core';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import { RdxPopperAnchorElement, Side, Align, RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
+import * as _radix_ng_primitives_toast from '@radix-ng/primitives/toast';
+
+/**
+ * Moves the toast viewport to a different part of the DOM — the Angular counterpart of
+ * `<Toast.Portal>`. Defaults to `document.body`; pass `container` to target another element.
+ */
+declare class RdxToastPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastPortal, "[rdxToastPortal]", ["rdxToastPortal"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+/** Relative ordering hint for a toast. `high` toasts are announced assertively. */
+type RdxToastPriority = 'low' | 'high';
+/** Action-button options carried on a toast and read back by the consumer (e.g. an "Undo" button). */
+interface RdxToastActionProps {
+    /** Visible button label. */
+    label?: string;
+    /** Invoked when the action button is clicked. */
+    onClick?: (event: MouseEvent) => void;
+}
+/**
+ * Anchoring options for a toast rendered through `rdxToastPositioner` instead of the stack. The
+ * `anchor` is any popper-compatible reference (element, `ElementRef`, or virtual element).
+ */
+interface RdxToastPositionerProps {
+    anchor: RdxPopperAnchorElement;
+    side?: Side;
+    sideOffset?: number;
+    align?: Align;
+    alignOffset?: number;
+}
+/**
+ * A single toast in the {@link RdxToastManager} queue. `id` is stable for the toast's lifetime;
+ * `transitionStatus` reflects the enter/leave animation phase (mirrors Base UI's transition system).
+ */
+interface RdxToastObject<Data = unknown> {
+    /** Stable id; generated by the manager when omitted from {@link RdxToastAddOptions}. */
+    id: string;
+    /** Short heading text. */
+    title?: string;
+    /** Supporting body text. */
+    description?: string;
+    /** Caller-defined category (e.g. `'success' | 'error'`) for styling/branching. */
+    type?: string;
+    /** Auto-dismiss delay in ms. `0` (or a negative value) disables auto-dismiss. */
+    timeout?: number;
+    /** Announcement priority. `high` → `role="alert"` (assertive); `low` → `role="status"`. */
+    priority?: RdxToastPriority;
+    /** Arbitrary caller payload, surfaced back to templates/handlers. */
+    data?: Data;
+    /** Enter/leave phase, set by the manager while a toast mounts or is being removed. */
+    transitionStatus?: RdxTransitionStatus;
+    /** Set while a `promise()` toast is awaiting its source promise. */
+    loading?: boolean;
+    /** Action-button options surfaced to the template. */
+    actionProps?: RdxToastActionProps;
+    /** Anchoring options; when present the toast is positioned with `rdxToastPositioner`. */
+    positionerProps?: RdxToastPositionerProps;
+    /** Bump on an upsert (same `id`) to replay the enter animation. */
+    updateKey?: number | string;
+    /** Invoked when the toast is dismissed (by timeout, swipe, or `close()`). */
+    onClose?: () => void;
+    /** Invoked after the leave animation completes and the toast leaves the queue. */
+    onRemove?: () => void;
+}
+/** Options accepted by {@link RdxToastManager.add} / {@link RdxToastManager.update}. */
+interface RdxToastAddOptions<Data = unknown> {
+    id?: string;
+    title?: string;
+    description?: string;
+    type?: string;
+    timeout?: number;
+    priority?: RdxToastPriority;
+    data?: Data;
+    /** Marks the toast as pending (used by `promise()`); pending toasts skip auto-dismiss. */
+    loading?: boolean;
+    actionProps?: RdxToastActionProps;
+    positionerProps?: RdxToastPositionerProps;
+    updateKey?: number | string;
+    onClose?: () => void;
+    onRemove?: () => void;
+}
+/** Per-state copy used by {@link RdxToastManager.promise}. */
+interface RdxToastPromiseOptions<Value = unknown, Data = unknown> {
+    loading: RdxToastAddOptions<Data> | string;
+    success: RdxToastAddOptions<Data> | string | ((value: Value) => RdxToastAddOptions<Data> | string);
+    error: RdxToastAddOptions<Data> | string | ((error: unknown) => RdxToastAddOptions<Data> | string);
+}
+
+/**
+ * App-level coordinator and imperative API for toasts — the Angular counterpart of Base UI's
+ * `<Toast.Provider>` plus `useToastManager()`. Holds the queue as a signal that `RdxToastViewport`
+ * renders, owns each toast's auto-dismiss timer (pausable while the viewport is hovered/focused),
+ * and exposes `add` / `update` / `close` / `promise`.
+ *
+ * Provide it once near the app root with {@link provideRdxToastManager} or the `[rdxToastProvider]`
+ * directive, then inject `RdxToastManager` anywhere to push toasts.
+ */
+declare class RdxToastManager {
+    private readonly idGenerator;
+    private readonly _toasts;
+    /** The live queue, oldest first. Render it in `RdxToastViewport` (e.g. via `@for`). */
+    readonly toasts: i0.Signal<RdxToastObject<unknown>[]>;
+    /** Whether any toast is currently in the queue. */
+    readonly hasToasts: i0.Signal<boolean>;
+    private readonly _expanded;
+    /** Whether the stack is expanded (viewport hovered or focused) — drives `data-expanded`. */
+    readonly expanded: i0.Signal<boolean>;
+    private readonly _heights;
+    /** Measured heights (px) per toast id, reported by each `RdxToastRoot` for expanded-stack offsets. */
+    readonly heights: i0.Signal<Record<string, number>>;
+    /**
+     * Per-toast stacking metrics, computed once for the whole queue (front = newest, index `0`):
+     * `index` is the distance from the front and `offsetY` is the combined height of the toasts
+     * stacked in front. Roots read this by id instead of each rescanning the queue (O(n) vs O(n²)).
+     */
+    readonly layout: i0.Signal<Record<string, {
+        index: number;
+        offsetY: number;
+    }>>;
+    /** Max number of simultaneously visible toasts. Configurable via `[rdxToastProvider]`. */
+    limit: number;
+    /** Default auto-dismiss delay (ms) for toasts that omit `timeout`. Set via `[rdxToastProvider]`. */
+    defaultTimeout: number;
+    private readonly timers;
+    /** Nested-pause depth so overlapping holds (hover + swipe) resume only when all release. */
+    private pauseDepth;
+    /** Queue a new toast. Returns its id (generated when not supplied). */
+    add<Data = unknown>(options: RdxToastAddOptions<Data>): string;
+    /** Merge new options into an existing toast (no-op if the id is unknown). */
+    update<Data = unknown>(id: string, options: Partial<RdxToastAddOptions<Data>>): void;
+    /**
+     * Begin dismissing a toast: fire `onClose`, then remove it after the leave animation.
+     * Omit `id` to dismiss every toast at once (mirrors Base UI's `close()`).
+     */
+    close(id?: string): void;
+    /**
+     * Remove a toast from the queue immediately. `RdxToastRoot` calls this once its leave animation
+     * has finished; call it directly only when there is no exit animation.
+     */
+    remove(id: string): void;
+    /** Toggle the expanded (hover/focus) state of the stack. Called by the viewport. */
+    setExpanded(expanded: boolean): void;
+    /** Record a toast's measured height (px) for expanded-stack offset math. Called by each root. */
+    setHeight(id: string, height: number): void;
+    /** Pause every auto-dismiss timer (e.g. while the viewport is hovered, focused, or being swiped). */
+    pauseAll(): void;
+    /** Release one pause; auto-dismiss timers resume only once every hold has released. */
+    resumeAll(): void;
+    /**
+     * Drive a toast through a promise's lifecycle: show `loading`, then swap to `success` or
+     * `error` copy when it settles. Returns the original promise for chaining.
+     */
+    promise<Value, Data = unknown>(promise: Promise<Value>, options: RdxToastPromiseOptions<Value, Data>): Promise<Value>;
+    private scheduleTimeout;
+    private clearTimer;
+    private clearHeight;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RdxToastManager>;
+}
+/** Provide a {@link RdxToastManager} for an app (e.g. in `app.config.ts`). */
+declare function provideRdxToastManager(): Provider[];
+/**
+ * Hosts a {@link RdxToastManager} for its subtree. Put it on a wrapping element (or the app root)
+ * so descendant viewports and components share one queue. `limit` caps simultaneously visible toasts.
+ */
+declare class RdxToastProvider {
+    private readonly manager;
+    /** Max number of toasts shown at once. */
+    readonly limit: i0.InputSignal<number>;
+    /** Default auto-dismiss delay (ms) for toasts that omit their own `timeout`. `0` disables it. */
+    readonly timeout: i0.InputSignal<number>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastProvider, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastProvider, "[rdxToastProvider]", ["rdxToastProvider"], { "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "timeout": { "alias": "timeout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The positioned region that holds the visible toasts — the Angular counterpart of
+ * `<Toast.Viewport>`. Exposes the queue for templates to render, and while it is hovered or focused
+ * it expands the stack (`data-expanded` on each root) and pauses every auto-dismiss timer, resuming
+ * once neither hover nor focus remains — matching Base UI.
+ *
+ * Headless: it carries no positioning styles. Consumers position it (e.g. fixed bottom-right) and
+ * iterate `viewport.toasts()` with `@for`.
+ */
+declare class RdxToastViewport {
+    protected readonly manager: RdxToastManager;
+    /** The live toast queue to render. */
+    readonly toasts: i0.Signal<_radix_ng_primitives_toast.RdxToastObject<unknown>[]>;
+    protected readonly hovered: i0.WritableSignal<boolean>;
+    protected readonly focused: i0.WritableSignal<boolean>;
+    /** Tracks the last expanded state so pause/resume stay balanced across transitions. */
+    private wasExpanded;
+    constructor();
+    protected onFocusOut(event: FocusEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastViewport, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastViewport, "[rdxToastViewport]", ["rdxToastViewport"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Positions an anchored toast against an element — the Angular counterpart of `<Toast.Positioner>`.
+ * Composes the popper machinery so a toast can point at a trigger instead of living in the stack.
+ *
+ * Bind `anchor` (and optionally `side`/`align`/offsets) — typically from a toast's `positionerProps`.
+ * It hosts its own `RdxPopper` so it is self-contained (no surrounding `rdxPopperRoot` needed), and
+ * mirrors the popper measurements as friendlier CSS variables plus `data-side` / `data-align`.
+ */
+declare class RdxToastPositioner {
+    protected readonly wrapper: RdxPopperContentWrapper;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastPositioner, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastPositioner, "[rdxToastPositioner]", ["rdxToastPositioner"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }, { directive: typeof i1$1.RdxPopperContentWrapper; inputs: { "anchor": "anchor"; "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "positionStrategy": "positionStrategy"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
+}
+
+/** Direction a swipe travels to dismiss a toast. */
+type RdxToastSwipeDirection = 'up' | 'down' | 'left' | 'right';
+interface RdxToastSwipeConfig {
+    /** The toast element the gesture lives on (CSS variables + data attributes are written here). */
+    element: () => HTMLElement;
+    /** Allowed dismiss directions; the gesture follows whichever the user drags toward most. */
+    directions: () => RdxToastSwipeDirection[];
+    /** Whether the gesture is armed (false while the toast is leaving). */
+    enabled: () => boolean;
+    /** Travel (px) past which a release dismisses. Defaults to {@link DEFAULT_THRESHOLD}. */
+    threshold?: number;
+    /** Called once per release that commits to dismissal. */
+    onDismiss: (event: PointerEvent) => void;
+    /** Called when a swipe actually begins (e.g. to pause auto-dismiss timers). */
+    onPress?: () => void;
+    /** Called when a started swipe ends, dismissing or not (balances {@link RdxToastSwipeConfig.onPress}). */
+    onRelease?: () => void;
+}
+/**
+ * Headless swipe-to-dismiss for a toast, built on the shared {@link usePointerDrag} lifecycle (which
+ * owns pointer capture, the start threshold, window listeners, and tap/cancel handling). This layer
+ * adds the toast-specific direction projection, rubber-banding, flick detection, and the styling
+ * contract — it applies no transform itself:
+ *
+ * - `--toast-swipe-movement-x` / `--toast-swipe-movement-y` — signed px offset along the active axis.
+ * - `[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.
+ *
+ * Mark inner interactive regions with `[data-toast-swipe-ignore]` to opt them out of the gesture.
+ * `RdxToastRoot` (the gesture host) sets `touch-action: none` so a touch-drag is not stolen by native
+ * scrolling — without it the gesture only works with a mouse, not on touch devices.
+ * Must be called from an injection context (a directive constructor).
+ */
+declare function useToastSwipe(config: RdxToastSwipeConfig): void;
+
+interface RdxToastRootContext {
+    /** The toast model this part tree renders. */
+    readonly toast: () => RdxToastObject;
+    /** `id` of the title element, wired to `aria-labelledby` once a title registers. */
+    readonly titleId: string;
+    /** `id` of the description element, wired to `aria-describedby` once a description registers. */
+    readonly descriptionId: string;
+    /** Register/unregister the title part so the root only points `aria-labelledby` at a real element. */
+    readonly setTitlePresent: (present: boolean) => void;
+    /** Register/unregister the description part so `aria-describedby` only targets a real element. */
+    readonly setDescriptionPresent: (present: boolean) => void;
+    /** Begin dismissing this toast. */
+    readonly close: () => void;
+}
+declare const injectRdxToastRootContext: _radix_ng_primitives_core.InjectContext<RdxToastRootContext>;
+declare const provideRdxToastRootContext: (useFactory: () => RdxToastRootContext) => i0.Provider;
+/**
+ * A single toast — the Angular counterpart of `<Toast.Root>`. Bind the toast model from the
+ * viewport's `@for`; this directive owns the announcement `role`, the `data-state` enter/leave
+ * contract, swipe-to-dismiss, and the stacking variables consumers style against.
+ *
+ * Stacking / styling contract written to the host (no transform is applied for you):
+ * - `--toast-index` — position from the front (`0` = frontmost).
+ * - `--toast-height` — this toast's measured height (px).
+ * - `--toast-offset-y` — combined height (px) of the toasts stacked in front, for expanded layout.
+ * - `--toast-swipe-movement-x` / `--toast-swipe-movement-y` — live swipe offset (px).
+ * - `[data-front]` — present on the frontmost toast.
+ * - `[data-expanded]` — present while the viewport is hovered/focused.
+ * - `[data-state]` — `open` while visible, `closed` once dismissal begins.
+ * - `[data-swiping]` / `[data-swipe-direction]` / `[data-swipe-dismiss]` — gesture state.
+ *
+ * When the leave animation (driven by `data-state="closed"`) ends, the toast leaves the queue.
+ */
+declare class RdxToastRoot {
+    protected readonly manager: RdxToastManager;
+    private readonly elementRef;
+    private readonly injector;
+    /** The toast model to render — pass the item from the viewport's `@for`. */
+    readonly toast: i0.InputSignal<RdxToastObject<unknown>>;
+    /** Allowed swipe-to-dismiss directions. Accepts a single direction or a list. */
+    readonly swipeDirection: i0.InputSignal<RdxToastSwipeDirection | RdxToastSwipeDirection[]>;
+    readonly titleId: string;
+    readonly descriptionId: string;
+    /** Whether a title / description part has registered, gating the aria-* references. */
+    readonly titlePresent: i0.WritableSignal<boolean>;
+    readonly descriptionPresent: i0.WritableSignal<boolean>;
+    private readonly size;
+    /** This toast's measured height (px). */
+    readonly height: i0.Signal<number>;
+    /** Position from the front of the stack — `0` is the newest/frontmost toast. */
+    readonly index: i0.Signal<number>;
+    /** Combined height (px) of the toasts stacked in front of this one (for expanded layout). */
+    readonly offsetY: i0.Signal<number>;
+    /** `alert` (assertive) for high-priority toasts, otherwise `status`. */
+    readonly role: i0.Signal<"alert" | "status">;
+    /** `open` while visible, `closed` once dismissal begins — drives enter/leave animations. */
+    readonly dataState: i0.Signal<"closed" | "open">;
+    private readonly directions;
+    constructor();
+    close(): void;
+    protected onAnimationEnd(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastRoot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastRoot, "[rdxToastRoot]", ["rdxToastRoot"], { "toast": { "alias": "toast"; "required": true; "isSignal": true; }; "swipeDirection": { "alias": "swipeDirection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Wraps a toast's inner parts (title, description, actions) — the Angular counterpart of
+ * `<Toast.Content>`. Headless: it carries no styles; consumers apply `overflow: hidden` to clip
+ * taller toasts during the stack/expand animation. It mirrors the root's `data-state` so content
+ * can transition together with the root.
+ */
+declare class RdxToastContent {
+    protected readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastContent, "[rdxToastContent]", ["rdxToastContent"], {}, {}, never, never, true, never>;
+}
+
+/** Accessible title for a toast; registers so the root only points `aria-labelledby` at a real node. */
+declare class RdxToastTitle {
+    protected readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastTitle, "[rdxToastTitle]", ["rdxToastTitle"], {}, {}, never, never, true, never>;
+}
+
+/** Supporting body text for a toast; registers so `aria-describedby` only targets a real node. */
+declare class RdxToastDescription {
+    protected readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastDescription, "[rdxToastDescription]", ["rdxToastDescription"], {}, {}, never, never, true, never>;
+}
+
+/** Button that dismisses its toast. Put it on a native `<button>` for built-in semantics. */
+declare class RdxToastClose {
+    protected readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastClose, "[rdxToastClose]", ["rdxToastClose"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * An action button inside a toast (e.g. "Undo"). Unlike {@link RdxToastClose} it does not dismiss
+ * on its own — wire your handler with `(click)` and call `close()` from the exposed context when
+ * the action should also close the toast.
+ */
+declare class RdxToastAction {
+    /** The toast root context, so handlers can read the toast or dismiss it after acting. */
+    readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastAction, "[rdxToastAction]", ["rdxToastAction"], {}, {}, never, never, true, never>;
+}
+
+declare const toastImports: (typeof RdxToastPortal)[];
+declare class RdxToastModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxToastModule, never, [typeof RdxToastProvider, typeof RdxToastPortal, typeof RdxToastViewport, typeof RdxToastPositioner, typeof RdxToastRoot, typeof RdxToastContent, typeof RdxToastTitle, typeof RdxToastDescription, typeof RdxToastClose, typeof RdxToastAction], [typeof RdxToastProvider, typeof RdxToastPortal, typeof RdxToastViewport, typeof RdxToastPositioner, typeof RdxToastRoot, typeof RdxToastContent, typeof RdxToastTitle, typeof RdxToastDescription, typeof RdxToastClose, typeof RdxToastAction]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxToastModule>;
+}
+
+export { RdxToastAction, RdxToastClose, RdxToastContent, RdxToastDescription, RdxToastManager, RdxToastModule, RdxToastPortal, RdxToastPositioner, RdxToastProvider, RdxToastRoot, RdxToastTitle, RdxToastViewport, injectRdxToastRootContext, provideRdxToastManager, provideRdxToastRootContext, toastImports, useToastSwipe };
+export type { RdxToastActionProps, RdxToastAddOptions, RdxToastObject, RdxToastPositionerProps, RdxToastPriority, RdxToastPromiseOptions, RdxToastRootContext, RdxToastSwipeConfig, RdxToastSwipeDirection };

package/types/radix-ng-primitives-toggle-group.d.ts

@@ -1,5 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { Signal } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { DataOrientation, BooleanInput } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/roving-focus';
 import { Direction } from '@radix-ng/primitives/roving-focus';
@@ -20,7 +21,7 @@ interface RdxToggleGroupContext {
     /** Toggle the pressed state of `value` within the group. */
     toggle(value: string): void;
 }
-declare const injectToggleGroupContext: (optional?: boolean) => RdxToggleGroupContext | null;
+declare const injectToggleGroupContext: _radix_ng_primitives_core.InjectContext<RdxToggleGroupContext>;
 declare const provideToggleGroupContext: (useFactory: () => RdxToggleGroupContext) => _angular_core.Provider;
 
 /** Builds the shared context a {@link RdxToggle} reads when it belongs to this group. */

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

@@ -1,6 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { Signal } from '@angular/core';
 import * as i1 from '@radix-ng/primitives/separator';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { DataOrientation, BooleanInput } from '@radix-ng/primitives/core';
 import * as i1$1 from '@radix-ng/primitives/roving-focus';
 import { Direction } from '@radix-ng/primitives/roving-focus';
@@ -160,13 +161,13 @@ interface RdxToolbarRootContext {
     /** Whether the whole toolbar is disabled. */
     readonly disabled: Signal<boolean>;
 }
-declare const injectToolbarRootContext: (optional?: boolean) => RdxToolbarRootContext | null;
+declare const injectToolbarRootContext: _radix_ng_primitives_core.InjectContext<RdxToolbarRootContext>;
 declare const provideToolbarRootContext: (useFactory: () => RdxToolbarRootContext) => _angular_core.Provider;
 interface RdxToolbarGroupContext {
     /** Whether the group (and therefore its items) is disabled. */
     readonly disabled: Signal<boolean>;
 }
-declare const injectToolbarGroupContext: (optional?: boolean) => RdxToolbarGroupContext | null;
+declare const injectToolbarGroupContext: _radix_ng_primitives_core.InjectContext<RdxToolbarGroupContext>;
 declare const provideToolbarGroupContext: (useFactory: () => RdxToolbarGroupContext) => _angular_core.Provider;
 
 declare const toolbarImports: (typeof RdxToolbarSeparator)[];

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

@@ -1,6 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { InjectionToken, Provider, Signal, ElementRef } from '@angular/core';
 import * as i1 from '@radix-ng/primitives/presence';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
 import * as i1$1 from '@radix-ng/primitives/popper';
 import { RdxPopperContentWrapper, RdxPopperAnchorElement } from '@radix-ng/primitives/popper';
@@ -84,7 +85,7 @@ interface RdxTooltipContext {
     } | undefined) => void;
     setDelays: (delay: number | undefined, closeDelay: number | undefined) => void;
 }
-declare const injectRdxTooltipContext: (optional?: boolean) => RdxTooltipContext | null;
+declare const injectRdxTooltipContext: _radix_ng_primitives_core.InjectContext<RdxTooltipContext>;
 declare const provideRdxTooltipContext: (useFactory: () => RdxTooltipContext) => _angular_core.Provider;
 declare class RdxTooltip {
     private readonly defaultConfig;
@@ -309,7 +310,7 @@ interface RdxTooltipProviderContext {
     /** Notifies the group that a tooltip has closed. */
     onClose: () => void;
 }
-declare const injectRdxTooltipProviderContext: (optional?: boolean) => RdxTooltipProviderContext | null;
+declare const injectRdxTooltipProviderContext: _radix_ng_primitives_core.InjectContext<RdxTooltipProviderContext>;
 declare const provideRdxTooltipProviderContext: (useFactory: () => RdxTooltipProviderContext) => _angular_core.Provider;
 /**
  * Shares delay configuration and an instant-open window across a group of tooltips.