@radix-ng/primitives 1.0.9 → 1.0.10

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

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef, Provider, Type, InjectionToken } from '@angular/core';
+import { ElementRef, Signal, Provider, Type, InjectionToken } from '@angular/core';
 import { ReferenceElement, Placement, Middleware, VirtualElement } from '@floating-ui/dom';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { NumberInput, BooleanInput } from '@radix-ng/primitives/core';
@@ -48,6 +48,45 @@ declare const SIDE_OPTIONS: readonly ["top", "right", "bottom", "left"];
 declare const ALIGN_OPTIONS: readonly ["start", "center", "end"];
 type Side = (typeof SIDE_OPTIONS)[number];
 type Align = (typeof ALIGN_OPTIONS)[number];
+/**
+ * How the popper avoids collisions with the boundary edges (Base UI `collisionAvoidance`).
+ *
+ * - `side` — behavior on the **preferred placement axis** (`top`/`bottom` or `left`/`right`):
+ *   `'flip'` swaps to the opposite side when it doesn't fit, `'shift'` keeps the side and nudges the
+ *   popup within the boundary, `'none'` leaves side-axis overflow uncorrected.
+ * - `align` — behavior on the **alignment axis** (`start`/`center`/`end`): `'flip'` swaps `start`/`end`,
+ *   `'shift'` nudges the popup along the alignment axis, `'none'` leaves it uncorrected.
+ * - `fallbackAxisSide` — when neither preferred side fits, whether to fall back to the perpendicular
+ *   axis and which logical side to prefer (`'start'` / `'end'`), or `'none'` to stay on the axis.
+ *
+ * Any omitted field falls back to the wrapper default (`side: 'flip'`, `align: 'flip'`,
+ * `fallbackAxisSide: 'end'`), matching Base UI.
+ */
+interface RdxCollisionAvoidance {
+    side?: 'flip' | 'shift' | 'none';
+    align?: 'flip' | 'shift' | 'none';
+    fallbackAxisSide?: 'start' | 'end' | 'none';
+}
+/** Fully-resolved {@link RdxCollisionAvoidance} — every field present (no wrapper-default fallback left). */
+type ResolvedCollisionAvoidance = Required<RdxCollisionAvoidance>;
+/**
+ * Function form of `sideOffset` / `alignOffset` (Base UI `OffsetFunction`). Receives the resolved
+ * placement and the measured anchor / positioner dimensions, and returns the offset in pixels — e.g.
+ * `({ anchor }) => anchor.width` to offset by the trigger's own width. `side` is the physical side the
+ * popup is placed against.
+ */
+type OffsetFunction = (data: {
+    side: Side;
+    align: Align;
+    anchor: {
+        width: number;
+        height: number;
+    };
+    positioner: {
+        width: number;
+        height: number;
+    };
+}) => number;
 declare function isNotNull<T>(value: T | null): value is T;
 declare function transformOrigin(options: {
     arrowWidth: number;
@@ -57,32 +96,32 @@ declare function getSideAndAlignFromPlacement(placement: Placement): readonly ["
 
 type RdxPopperAnchorElement = Element | ElementRef<Element> | VirtualElement | (() => Element | VirtualElement | null) | null | undefined;
 declare const context: () => {
-    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
-    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    arrowX: _angular_core.Signal<number | undefined>;
-    arrowY: _angular_core.Signal<number | undefined>;
-    shouldHideArrow: _angular_core.Signal<boolean>;
-    isPositioned: _angular_core.Signal<boolean>;
-    anchorHidden: _angular_core.Signal<boolean>;
+    placedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: Signal<"start" | "center" | "end" | undefined>;
+    arrowX: Signal<number | undefined>;
+    arrowY: Signal<number | undefined>;
+    shouldHideArrow: Signal<boolean>;
+    isPositioned: Signal<boolean>;
+    anchorHidden: Signal<boolean>;
 };
 type PopperContentWrapperContext = ReturnType<typeof context>;
 declare const injectPopperContentWrapperContext: _radix_ng_primitives_core.InjectContext<{
-    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
-    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    arrowX: _angular_core.Signal<number | undefined>;
-    arrowY: _angular_core.Signal<number | undefined>;
-    shouldHideArrow: _angular_core.Signal<boolean>;
-    isPositioned: _angular_core.Signal<boolean>;
-    anchorHidden: _angular_core.Signal<boolean>;
+    placedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: Signal<"start" | "center" | "end" | undefined>;
+    arrowX: Signal<number | undefined>;
+    arrowY: Signal<number | undefined>;
+    shouldHideArrow: Signal<boolean>;
+    isPositioned: Signal<boolean>;
+    anchorHidden: Signal<boolean>;
 }>;
 declare const providePopperContentWrapperContext: (useFactory: () => {
-    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
-    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    arrowX: _angular_core.Signal<number | undefined>;
-    arrowY: _angular_core.Signal<number | undefined>;
-    shouldHideArrow: _angular_core.Signal<boolean>;
-    isPositioned: _angular_core.Signal<boolean>;
-    anchorHidden: _angular_core.Signal<boolean>;
+    placedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: Signal<"start" | "center" | "end" | undefined>;
+    arrowX: Signal<number | undefined>;
+    arrowY: Signal<number | undefined>;
+    shouldHideArrow: Signal<boolean>;
+    isPositioned: Signal<boolean>;
+    anchorHidden: Signal<boolean>;
 }) => Provider;
 declare class RdxPopperContentWrapper {
     private readonly elementRef;
@@ -100,22 +139,44 @@ declare class RdxPopperContentWrapper {
      */
     readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
     /**
-     * Distance between the anchor and the popup in pixels.
+     * Distance between the anchor and the popup in pixels. Also accepts an {@link OffsetFunction} that
+     * reads the anchor / positioner dimensions and the resolved side / align.
      */
-    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number | OffsetFunction, string | number | OffsetFunction | null | undefined>;
     /**
      * How to align the popup relative to the specified side. May change when collisions occur.
      */
     readonly align: _angular_core.InputSignal<"start" | "center" | "end">;
-    /** An offset in pixels from the `start` or `end` alignment options. */
-    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * An offset in pixels from the `start` or `end` alignment options. Also accepts an
+     * {@link OffsetFunction} (same signature as `sideOffset`).
+     */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number | OffsetFunction, string | number | OffsetFunction | null | undefined>;
     /**
      * Minimum distance to maintain between the arrow and the edges of the popup.
      * If your content has border-radius, this will prevent it from overflowing the corners.
      */
     readonly arrowPadding: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /** When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges. */
+    /**
+     * When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges.
+     *
+     * @deprecated Use {@link collisionAvoidance} for fine-grained control (Base UI parity). Still honored:
+     * `false` disables all avoidance (unless a `collisionAvoidance` object is provided, which wins).
+     */
     readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * How the popup avoids colliding with the boundary edges, per axis (Base UI `collisionAvoidance`).
+     * Overrides the deprecated `avoidCollisions` and any per-primitive preset. An object here **fully
+     * replaces** the preset — omitted fields fall back to `side: 'flip'`, `align: 'flip'`,
+     * `fallbackAxisSide: 'end'`, never to the preset. See {@link RdxCollisionAvoidance}.
+     */
+    readonly collisionAvoidance: _angular_core.InputSignal<RdxCollisionAvoidance | undefined>;
+    /**
+     * Collision avoidance resolved against the deprecated `avoidCollisions` flag, the per-primitive
+     * config preset, and the wrapper defaults. Precedence: an explicit `collisionAvoidance` input →
+     * a legacy `avoidCollisions=false` (disables everything) → the config preset → the Base UI defaults.
+     */
+    private readonly effectiveCollisionAvoidance;
     /**
      * The element used as the collision boundary.
      * By default this is the viewport, though you can provide additional element(s) to be included in this check.
@@ -149,19 +210,19 @@ declare class RdxPopperContentWrapper {
      * Emits when the element is placed.
      */
     readonly placed: _angular_core.OutputEmitterRef<void>;
-    readonly arrow: _angular_core.Signal<any>;
+    readonly arrow: Signal<any>;
     /**
      * When `true`, the content is rendered click/hover-through (`pointer-events: none`). Used for
      * cursor-following content (e.g. a tooltip tracking the pointer) that must never intercept the
      * pointer and steal hover from its trigger.
      */
     readonly nonInteractive: _angular_core.WritableSignal<boolean>;
-    readonly shouldHideArrow: _angular_core.Signal<boolean>;
+    readonly shouldHideArrow: Signal<boolean>;
     /** Whether the arrow could not be centered on the anchor because the popup was shifted. */
-    readonly arrowUncentered: _angular_core.Signal<boolean>;
-    readonly arrowX: _angular_core.Signal<number | undefined>;
-    readonly arrowY: _angular_core.Signal<number | undefined>;
-    readonly anchorHidden: _angular_core.Signal<boolean>;
+    readonly arrowUncentered: Signal<boolean>;
+    readonly arrowX: Signal<number | undefined>;
+    readonly arrowY: Signal<number | undefined>;
+    readonly anchorHidden: Signal<boolean>;
     private readonly desiredPlacement;
     private readonly arrowSize;
     private readonly boundary;
@@ -183,23 +244,23 @@ declare class RdxPopperContentWrapper {
     /**
      * Whether the panel is positioned.
      */
-    readonly isPositioned: _angular_core.Signal<boolean>;
+    readonly isPositioned: Signal<boolean>;
     /**
      * The current placement of the panel.
      */
-    readonly placement: _angular_core.Signal<{
+    readonly placement: Signal<{
         side: Side;
         align: Align;
     } | undefined>;
     /**
      * The side the panel is currently placed against.
      */
-    readonly placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    readonly placedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
     /**
      * The current alignment of the panel.
      */
-    readonly placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    protected readonly style: _angular_core.Signal<{
+    readonly placedAlign: Signal<"start" | "center" | "end" | undefined>;
+    protected readonly style: Signal<{
         visibility: string;
         pointerEvents: string;
         position: "fixed" | "absolute";
@@ -218,10 +279,20 @@ declare class RdxPopperContentWrapper {
         '--positioner-height': string;
         '--transform-origin': string;
     }>;
+    /**
+     * Whether the positioner should actively track its anchor (recompute + `autoUpdate`). Defaults to
+     * always-on — the historical behavior, correct for a positioner that unmounts when its layer closes.
+     * A positioner that can stay mounted while closed (`keepMounted`) **overrides** this with its
+     * open/presence signal so a closed, hidden positioner doesn't spin an endless `autoUpdate`
+     * `requestAnimationFrame` loop (only relevant when `updatePositionStrategy: 'always'`). It's a
+     * reassignable field (not `readonly`) because the render effect below reads it lazily, after the
+     * subclass constructor has swapped it in.
+     */
+    protected positioningActive: Signal<boolean>;
     private readonly afterRenderEffect;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperContentWrapper, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionAvoidance": { "alias": "collisionAvoidance"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow"], never, true, never>;
 }
 /**
  * Providers a "thin" positioner that `extends RdxPopperContentWrapper` must include. Angular
@@ -282,20 +353,42 @@ declare class RdxPopperArrow {
 interface RdxPopperContentConfig {
     side?: Side;
     align?: Align;
-    sideOffset?: number;
-    alignOffset?: number;
+    sideOffset?: number | OffsetFunction;
+    alignOffset?: number | OffsetFunction;
     arrowPadding?: number;
+    /**
+     * @deprecated Use {@link collisionAvoidance} instead. Kept for back-compat: `false` disables all
+     * collision avoidance (equivalent to `{ side: 'none', align: 'none', fallbackAxisSide: 'none' }`).
+     */
     avoidCollisions?: boolean;
+    /** Per-primitive collision-avoidance default (Base UI parity). See {@link RdxCollisionAvoidance}. */
+    collisionAvoidance?: RdxCollisionAvoidance;
     collisionPadding?: number | Partial<Record<Side, number>>;
     sticky?: 'partial' | 'always';
     hideWhenDetached?: boolean;
     positionStrategy?: 'fixed' | 'absolute';
     updatePositionStrategy?: 'optimized' | 'always';
 }
+/**
+ * Collision-avoidance preset for dropdown-style popups (Base UI `DROPDOWN_COLLISION_AVOIDANCE`).
+ *
+ * Dropdowns (select / combobox / autocomplete / menu) strictly prefer their top/bottom placement and
+ * cap their height with `var(--available-height)`, so they must **not** fall back to the perpendicular
+ * (left/right) axis. `side`/`align` fall back to the wrapper default (`'flip'`).
+ */
+declare const DROPDOWN_COLLISION_AVOIDANCE: RdxCollisionAvoidance;
+/**
+ * Collision-avoidance preset for regular popups (Base UI `POPUP_COLLISION_AVOIDANCE`).
+ *
+ * Popovers / tooltips / preview cards aren't height-capped and may freely flip to the perpendicular
+ * axis, preferring the logical end side. This equals the wrapper's built-in default; it is exported so
+ * popups can state the intent explicitly.
+ */
+declare const POPUP_COLLISION_AVOIDANCE: RdxCollisionAvoidance;
 declare const RdxPopperContentConfigToken: InjectionToken<RdxPopperContentConfig>;
 declare function provideRdxPopperContentConfig(config: RdxPopperContentConfig): Provider;
 
 declare const popperImports: (typeof RdxPopperAnchor | typeof RdxPopper | typeof RdxPopperContentWrapper | typeof RdxPopperContent)[];
 
-export { RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, legacyPopperVars, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, provideRdxPopperContentWrapper, transformOrigin };
-export type { Align, PopperContentWrapperContext, RdxPopperAnchorElement, RdxPopperContentConfig, Side };
+export { DROPDOWN_COLLISION_AVOIDANCE, POPUP_COLLISION_AVOIDANCE, RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, legacyPopperVars, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, provideRdxPopperContentWrapper, transformOrigin };
+export type { Align, OffsetFunction, PopperContentWrapperContext, RdxCollisionAvoidance, RdxPopperAnchorElement, RdxPopperContentConfig, ResolvedCollisionAvoidance, Side };

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

@@ -1,4 +1,4 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { ElementRef } from '@angular/core';
 
 /**
@@ -22,14 +22,14 @@ declare class RdxPortal {
      * Specify a container to portal the content into. Can be an `ElementRef`, a native element, or a
      * CSS selector. Defaults to `document.body` when not set (or when a selector matches nothing).
      */
-    readonly container: i0.InputSignal<RdxPortalContainer | undefined>;
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
     private readonly _computedContainer;
-    readonly computedContainer: i0.Signal<RdxPortalContainer | undefined>;
+    readonly computedContainer: _angular_core.Signal<RdxPortalContainer | undefined>;
     private readonly elementContainer;
     constructor();
     setContainer(container: RdxPortalContainer): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPortal, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPortal, "[rdxPortal]", ["rdxPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPortal, "[rdxPortal]", ["rdxPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -56,7 +56,17 @@ declare class RdxPortalPresence {
      * Container to portal the content into. Can be an `ElementRef`, a native element, or a CSS
      * selector. Defaults to `document.body` (or when a selector matches nothing).
      */
-    readonly container: i0.InputSignal<RdxPortalContainer | undefined>;
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
+    /**
+     * Keep the portal mounted (in the container) while the layer is closed. When `true` the content
+     * stays in the DOM regardless of the {@link RDX_PRESENCE_CONTEXT} `present` flag — the consumer is
+     * responsible for hiding it while closed (typically via the `data-closed` / `data-open` state on the
+     * positioner). Any `*rdxXxxPortal` wrapper opts in by mapping this input in its `hostDirectives`.
+     */
+    readonly keepMounted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The layer's own open/present flag, OR'd with {@link keepMounted} to gate mount/unmount. */
+    private readonly contextPresent;
+    private readonly present;
     private readonly _computedContainer;
     private readonly elementContainer;
     /** The live view's root nodes, exposed as a signal so the relocation effect re-runs on (re)mount. */
@@ -67,8 +77,8 @@ declare class RdxPortalPresence {
     setContainer(container: RdxPortalContainer): void;
     private mountView;
     private destroyView;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPortalPresence, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPortalPresence, never, never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPortalPresence, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPortalPresence, never, never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { RdxPortal, RdxPortalPresence, resolvePortalContainer };

package/types/radix-ng-primitives-time-field.d.ts

@@ -60,6 +60,13 @@ declare class RdxTimeFieldRootDirective extends RdxFormUiControlBase implements
      * The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view
      */
     readonly placeholder: _angular_core.ModelSignal<TimeValue | undefined>;
+    /**
+     * Always-defined placeholder used for segment math. A controlled `[placeholder]` can be reset to
+     * `undefined`; fall back to the default time so the converted placeholder is never built from
+     * `undefined`.
+     * @ignore
+     */
+    readonly effectivePlaceholder: Signal<TimeValue>;
     /**
      * Segment input parts, collected from the projected content in DOM order. This
      * stays in sync with `segmentContents()` (granularity / locale / value changes
@@ -222,16 +229,17 @@ declare class RdxTimeFieldInputDirective {
 interface TimeFieldContextToken {
     locale: InputSignal<string>;
     value: ModelSignal<TimeValue | undefined>;
-    placeholder: ModelSignal<TimeValue>;
+    /** The controlled placeholder; may be `undefined`. Use `convertedPlaceholder` for segment math. */
+    placeholder: Signal<TimeValue | undefined>;
     isInvalid: Signal<boolean>;
     /** Effective invalid: the built-in range check OR the form-driven invalid state. */
     invalidState: Signal<boolean>;
     /** Tri-state displayed validity (`true`/`false`/`null`): the field's gated state inside a Field, else own. */
     displayValid: Signal<boolean | null>;
-    disabled: InputSignal<boolean>;
-    readonly: InputSignal<boolean>;
+    disabled: Signal<boolean>;
+    readonly: Signal<boolean>;
     formatter: Signal<Formatter>;
-    hourCycle: InputSignal<HourCycle>;
+    hourCycle: Signal<HourCycle | undefined>;
     segmentValues: WritableSignal<SegmentValueObj>;
     focusNext: () => void;
     setFocusedElement: (el: HTMLElement) => void;

package/fesm2022/radix-ng-primitives-focus-guards.mjs

@@ -1,53 +0,0 @@
-import * as i0 from '@angular/core';
-import { inject, Injector, afterNextRender, effect, Directive } from '@angular/core';
-
-/** Number of components which have requested interest to have focus guards */
-let count = 0;
-/**
- * Injects a pair of focus guards at the edges of the whole DOM tree
- * to ensure `focusin` & `focusout` events can be caught consistently.
- */
-class RdxFocusGuards {
-    constructor() {
-        this.injector = inject(Injector);
-        afterNextRender(() => {
-            effect((onCleanup) => {
-                const edgeGuards = document.querySelectorAll('[data-radix-focus-guard]');
-                document.body.insertAdjacentElement('afterbegin', edgeGuards[0] ?? this.createFocusGuard());
-                document.body.insertAdjacentElement('beforeend', edgeGuards[1] ?? this.createFocusGuard());
-                count++;
-                onCleanup(() => {
-                    if (count === 1) {
-                        document.querySelectorAll('[data-radix-focus-guard]').forEach((node) => node.remove());
-                    }
-                    count--;
-                });
-            }, { injector: this.injector });
-        });
-    }
-    createFocusGuard() {
-        const element = document.createElement('span');
-        element.setAttribute('data-radix-focus-guard', '');
-        element.tabIndex = 0;
-        element.style.outline = 'none';
-        element.style.opacity = '0';
-        element.style.position = 'fixed';
-        element.style.pointerEvents = 'none';
-        return element;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.2", ngImport: i0, type: RdxFocusGuards, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.2", type: RdxFocusGuards, isStandalone: true, selector: "[rdxFocusGuards]", ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.2", ngImport: i0, type: RdxFocusGuards, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[rdxFocusGuards]'
-                }]
-        }], ctorParameters: () => [] });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { RdxFocusGuards };
-//# sourceMappingURL=radix-ng-primitives-focus-guards.mjs.map

package/fesm2022/radix-ng-primitives-focus-guards.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"radix-ng-primitives-focus-guards.mjs","sources":["../../../packages/primitives/focus-guards/src/focus-guards.ts","../../../packages/primitives/focus-guards/radix-ng-primitives-focus-guards.ts"],"sourcesContent":["import { afterNextRender, Directive, effect, inject, Injector } from '@angular/core';\n\n/** Number of components which have requested interest to have focus guards */\nlet count = 0;\n\n/**\n * Injects a pair of focus guards at the edges of the whole DOM tree\n * to ensure `focusin` & `focusout` events can be caught consistently.\n */\n@Directive({\n    selector: '[rdxFocusGuards]'\n})\nexport class RdxFocusGuards {\n    private readonly injector = inject(Injector);\n\n    constructor() {\n        afterNextRender(() => {\n            effect(\n                (onCleanup) => {\n                    const edgeGuards = document.querySelectorAll('[data-radix-focus-guard]');\n\n                    document.body.insertAdjacentElement('afterbegin', edgeGuards[0] ?? this.createFocusGuard());\n\n                    document.body.insertAdjacentElement('beforeend', edgeGuards[1] ?? this.createFocusGuard());\n\n                    count++;\n\n                    onCleanup(() => {\n                        if (count === 1) {\n                            document.querySelectorAll('[data-radix-focus-guard]').forEach((node) => node.remove());\n                        }\n\n                        count--;\n                    });\n                },\n                { injector: this.injector }\n            );\n        });\n    }\n\n    createFocusGuard() {\n        const element = document.createElement('span');\n        element.setAttribute('data-radix-focus-guard', '');\n        element.tabIndex = 0;\n        element.style.outline = 'none';\n        element.style.opacity = '0';\n        element.style.position = 'fixed';\n        element.style.pointerEvents = 'none';\n        return element;\n    }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;AAEA;AACA,IAAI,KAAK,GAAG,CAAC;AAEb;;;AAGG;MAIU,cAAc,CAAA;AAGvB,IAAA,WAAA,GAAA;AAFiB,QAAA,IAAA,CAAA,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAGxC,eAAe,CAAC,MAAK;AACjB,YAAA,MAAM,CACF,CAAC,SAAS,KAAI;gBACV,MAAM,UAAU,GAAG,QAAQ,CAAC,gBAAgB,CAAC,0BAA0B,CAAC;AAExE,gBAAA,QAAQ,CAAC,IAAI,CAAC,qBAAqB,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;AAE3F,gBAAA,QAAQ,CAAC,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;AAE1F,gBAAA,KAAK,EAAE;gBAEP,SAAS,CAAC,MAAK;AACX,oBAAA,IAAI,KAAK,KAAK,CAAC,EAAE;AACb,wBAAA,QAAQ,CAAC,gBAAgB,CAAC,0BAA0B,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;oBAC1F;AAEA,oBAAA,KAAK,EAAE;AACX,gBAAA,CAAC,CAAC;YACN,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC9B;AACL,QAAA,CAAC,CAAC;IACN;IAEA,gBAAgB,GAAA;QACZ,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC;AAC9C,QAAA,OAAO,CAAC,YAAY,CAAC,wBAAwB,EAAE,EAAE,CAAC;AAClD,QAAA,OAAO,CAAC,QAAQ,GAAG,CAAC;AACpB,QAAA,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM;AAC9B,QAAA,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG,GAAG;AAC3B,QAAA,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO;AAChC,QAAA,OAAO,CAAC,KAAK,CAAC,aAAa,GAAG,MAAM;AACpC,QAAA,OAAO,OAAO;IAClB;8GArCS,cAAc,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,SAAA,EAAA,CAAA,CAAA;kGAAd,cAAc,EAAA,YAAA,EAAA,IAAA,EAAA,QAAA,EAAA,kBAAA,EAAA,QAAA,EAAA,EAAA,EAAA,CAAA,CAAA;;2FAAd,cAAc,EAAA,UAAA,EAAA,CAAA;kBAH1B,SAAS;AAAC,YAAA,IAAA,EAAA,CAAA;AACP,oBAAA,QAAQ,EAAE;AACb,iBAAA;;;ACXD;;AAEG;;;;"}

package/focus-guards/README.md

@@ -1 +0,0 @@
-# @radix-ng/primitives/focus-guards

package/types/radix-ng-primitives-focus-guards.d.ts

@@ -1,15 +0,0 @@
-import * as i0 from '@angular/core';
-
-/**
- * Injects a pair of focus guards at the edges of the whole DOM tree
- * to ensure `focusin` & `focusout` events can be caught consistently.
- */
-declare class RdxFocusGuards {
-    private readonly injector;
-    constructor();
-    createFocusGuard(): HTMLSpanElement;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxFocusGuards, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxFocusGuards, "[rdxFocusGuards]", never, {}, {}, never, never, true, never>;
-}
-
-export { RdxFocusGuards };