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

package/fesm2022/radix-ng-primitives-core.mjs

@@ -1,8 +1,8 @@
 import * as i0 from '@angular/core';
-import { forwardRef, input, booleanAttribute, output, linkedSignal, untracked, Directive, inject, ElementRef, NgZone, Input, DOCUMENT, DestroyRef, signal, afterNextRender, APP_ID, Injectable, InjectionToken, computed, effect } from '@angular/core';
-import { NG_VALUE_ACCESSOR, NgControl, FormControlDirective, FormControlName, NgModel } from '@angular/forms';
-import { Platform } from '@angular/cdk/platform';
+import { forwardRef, input, booleanAttribute, output, linkedSignal, untracked, Directive, inject, InjectionToken, computed, APP_ID, Injectable, DOCUMENT, PLATFORM_ID, DestroyRef, signal, afterNextRender, effect, ElementRef, Injector } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { getLocalTimeZone, CalendarDateTime, ZonedDateTime, getDayOfWeek, DateFormatter, createCalendar, toCalendar, CalendarDate, Time, startOfMonth, endOfMonth, today } from '@internationalized/date';
+import { isPlatformBrowser, DOCUMENT as DOCUMENT$1 } from '@angular/common';
 
 /**
  * Include in the providers section of a component which utilizes ControlValueAccessor to redundant code.
@@ -111,84 +111,6 @@ function injectControlValueAccessor() {
     return inject(RdxControlValueAccessor);
 }
 
-/*
- * <div [rdxAutoFocus]="true"></div>
- */
-class RdxAutoFocusDirective {
-    constructor() {
-        this.#elementRef = inject(ElementRef);
-        this.#ngZone = inject(NgZone);
-        this._autoSelect = false;
-    }
-    #elementRef;
-    #ngZone;
-    /**
-     * @default false
-     */
-    set autoFocus(value) {
-        if (value) {
-            // Note: Running this outside Angular's zone because `element.focus()` does not trigger change detection.
-            this.#ngZone.runOutsideAngular(() => 
-            // Note: `element.focus()` causes re-layout which might lead to frame drops on slower devices.
-            // https://gist.github.com/paulirish/5d52fb081b3570c81e3a#setting-focus
-            // `setTimeout` is a macrotask executed within the current rendering frame.
-            // Animation tasks are executed in the next rendering frame.
-            reqAnimationFrame(() => {
-                this.#elementRef.nativeElement.focus();
-                if (this._autoSelect && this.#elementRef.nativeElement.select) {
-                    this.#elementRef.nativeElement.select();
-                }
-            }));
-        }
-    }
-    // Setter for autoSelect attribute to enable text selection when autoFocus is true.
-    set autoSelect(value) {
-        this._autoSelect = value;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxAutoFocusDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "21.2.9", type: RdxAutoFocusDirective, isStandalone: true, selector: "[rdxAutoFocus]", inputs: { autoFocus: ["rdxAutoFocus", "autoFocus", booleanAttribute], autoSelect: ["autoSelect", "autoSelect", booleanAttribute] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxAutoFocusDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[rdxAutoFocus]',
-                    standalone: true
-                }]
-        }], propDecorators: { autoFocus: [{
-                type: Input,
-                args: [{ alias: 'rdxAutoFocus', transform: booleanAttribute }]
-            }], autoSelect: [{
-                type: Input,
-                args: [{ transform: booleanAttribute }]
-            }] } });
-const availablePrefixes = ['moz', 'ms', 'webkit'];
-function requestAnimationFramePolyfill() {
-    let lastTime = 0;
-    return function (callback) {
-        const currTime = new Date().getTime();
-        const timeToCall = Math.max(0, 16 - (currTime - lastTime));
-        const id = setTimeout(() => {
-            callback(currTime + timeToCall);
-        }, timeToCall);
-        lastTime = currTime + timeToCall;
-        return id;
-    };
-}
-// Function to get the appropriate requestAnimationFrame method with fallback to polyfill.
-function getRequestAnimationFrame() {
-    if (typeof window === 'undefined') {
-        return () => 0;
-    }
-    if (window.requestAnimationFrame) {
-        // https://github.com/vuejs/vue/issues/4465
-        return window.requestAnimationFrame.bind(window);
-    }
-    const prefix = availablePrefixes.filter((key) => `${key}RequestAnimationFrame` in window)[0];
-    return prefix ? window[`${prefix}RequestAnimationFrame`] : requestAnimationFramePolyfill();
-}
-// Get the requestAnimationFrame function or its polyfill.
-const reqAnimationFrame = getRequestAnimationFrame();
-
 /**
  * The `clamp` function restricts a number within a specified range by returning the value itself if it
  * falls within the range, or the closest boundary value if it exceeds the range.
@@ -259,444 +181,6 @@ function snapValueToStep(value, min, max, step) {
     return snappedValue;
 }
 
-function injectDocument() {
-    return inject(DOCUMENT);
-}
-
-function elementSize({ elementRef, injector }) {
-    const destroyRef = injector.get(DestroyRef);
-    const result = signal({
-        width: elementRef.nativeElement.offsetWidth,
-        height: elementRef.nativeElement.offsetHeight
-    }, ...(ngDevMode ? [{ debugName: "result" }] : /* istanbul ignore next */ []));
-    afterNextRender(() => {
-        const resizeObserver = new ResizeObserver((entries) => {
-            const entry = entries[0];
-            let width;
-            let height;
-            if ('borderBoxSize' in entry) {
-                const borderSizeEntry = entry['borderBoxSize'];
-                const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
-                width = borderSize['inlineSize'];
-                height = borderSize['blockSize'];
-            }
-            else {
-                width = elementRef.nativeElement.offsetWidth;
-                height = elementRef.nativeElement.offsetHeight;
-            }
-            result.set({ width, height });
-        });
-        destroyRef.onDestroy(() => resizeObserver.disconnect());
-    }, { injector: injector });
-    return result.asReadonly();
-}
-
-class RdxFocusInitialDirective {
-    constructor() {
-        /** @ignore */
-        this.nativeElement = inject(ElementRef).nativeElement;
-    }
-    /** @ignore */
-    focus() {
-        this.nativeElement.focus();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxFocusInitialDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: RdxFocusInitialDirective, isStandalone: true, selector: "[rdxFocusInitial]", ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxFocusInitialDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[rdxFocusInitial]'
-                }]
-        }] });
-
-function getActiveElement() {
-    let activeElement = document.activeElement;
-    if (activeElement == null) {
-        return null;
-    }
-    while (activeElement != null &&
-        activeElement.shadowRoot != null &&
-        activeElement.shadowRoot.activeElement != null) {
-        activeElement = activeElement.shadowRoot.activeElement;
-    }
-    return activeElement;
-}
-
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-/**
- * Keeps track of the ID count per prefix. This helps us make the IDs a bit more deterministic
- * like they were before the service was introduced. Note that ideally we wouldn't have to do
- * this, but there are some internal tests that rely on the IDs.
- */
-const counters = {};
-/** Service that generates unique IDs for DOM nodes. */
-class _IdGenerator {
-    constructor() {
-        this._appId = inject(APP_ID);
-    }
-    /**
-     * Generates a unique ID with a specific prefix.
-     * @param prefix Prefix to add to the ID.
-     */
-    getId(prefix) {
-        // Omit the app ID if it's the default `ng`. Since the vast majority of pages have one
-        // Angular app on them, we can reduce the amount of breakages by not adding it.
-        if (this._appId !== 'ng') {
-            prefix += this._appId;
-        }
-        if (!Object.prototype.hasOwnProperty.call(counters, prefix)) {
-            counters[prefix] = 0;
-        }
-        return `${prefix}${counters[prefix]++}`;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: _IdGenerator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: _IdGenerator, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: _IdGenerator, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-function injectNgControl(params) {
-    const ngControl = inject(NgControl, { self: true, optional: true });
-    if (!params?.optional && !ngControl)
-        throw new Error('NgControl not found');
-    if (ngControl instanceof FormControlDirective ||
-        ngControl instanceof FormControlName ||
-        ngControl instanceof NgModel) {
-        return ngControl;
-    }
-    if (params?.optional) {
-        return undefined;
-    }
-    throw new Error('NgControl is not an instance of FormControlDirective, FormControlName or NgModel');
-}
-
-function injectIsClient() {
-    return inject(Platform).isBrowser;
-}
-
-// Originally based on https://github.com/puleos/object-hash v3.0.0 (MIT)
-/**
- * Serializes any input value into a string for hashing.
- *
- * This method uses best efforts to generate stable serialized values.
- * However, it is not designed for security purposes.
- * Keep in mind that there is always a chance of intentional collisions caused by user input.
- *
- * @param input any value to serialize
- * @return {string} serialized string value
- */
-function serialize(input) {
-    if (typeof input === 'string') {
-        return `'${input}'`;
-    }
-    return new Serializer().serialize(input);
-}
-const Serializer = /*@__PURE__*/ (function () {
-    class Serializer {
-        #context = new Map();
-        compare(a, b) {
-            const typeA = typeof a;
-            const typeB = typeof b;
-            if (typeA === 'string' && typeB === 'string') {
-                return a.localeCompare(b);
-            }
-            if (typeA === 'number' && typeB === 'number') {
-                return a - b;
-            }
-            return String.prototype.localeCompare.call(this.serialize(a, true), this.serialize(b, true));
-        }
-        serialize(value, noQuotes) {
-            if (value === null) {
-                return 'null';
-            }
-            switch (typeof value) {
-                case 'string': {
-                    return noQuotes ? value : `'${value}'`;
-                }
-                case 'bigint': {
-                    return `${value}n`;
-                }
-                case 'object': {
-                    return this.$object(value);
-                }
-                case 'function': {
-                    return this.$function(value);
-                }
-            }
-            return String(value);
-        }
-        serializeObject(object) {
-            const objString = Object.prototype.toString.call(object);
-            if (objString !== '[object Object]') {
-                return this.serializeBuiltInType(objString.length < 10 /* '[object a]'.length === 10, the minimum */
-                    ? `unknown:${objString}`
-                    : objString.slice(8, -1) /* '[object '.length === 8 */, object);
-            }
-            const constructor = object.constructor;
-            const objName = constructor === Object || constructor === undefined ? '' : constructor.name;
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-expect-error
-            if (objName !== '' && globalThis[objName] === constructor) {
-                return this.serializeBuiltInType(objName, object);
-            }
-            if ('toJSON' in object && typeof object.toJSON === 'function') {
-                const json = object.toJSON();
-                return (objName +
-                    (json !== null && typeof json === 'object' ? this.$object(json) : `(${this.serialize(json)})`));
-            }
-            const keys = Object.keys(object).sort((a, b) => a.localeCompare(b));
-            let content = `${objName}{`;
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i];
-                content += `${key}:${this.serialize(object[key])}`;
-                if (i < keys.length - 1) {
-                    content += ',';
-                }
-            }
-            return content + '}';
-        }
-        serializeBuiltInType(type, object) {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-expect-error
-            const handler = this['$' + type];
-            if (handler) {
-                return handler.call(this, object);
-            }
-            if (typeof object.entries === 'function') {
-                return this.serializeObjectEntries(type, object.entries());
-            }
-            throw new Error(`Cannot serialize ${type}`);
-        }
-        serializeObjectEntries(type, entries) {
-            const sortedEntries = Array.from(entries).sort((a, b) => this.compare(a[0], b[0]));
-            let content = `${type}{`;
-            for (let i = 0; i < sortedEntries.length; i++) {
-                const [key, value] = sortedEntries[i];
-                content += `${this.serialize(key, true)}:${this.serialize(value)}`;
-                if (i < sortedEntries.length - 1) {
-                    content += ',';
-                }
-            }
-            return content + '}';
-        }
-        $object(object) {
-            let content = this.#context.get(object);
-            if (content === undefined) {
-                this.#context.set(object, `#${this.#context.size}`);
-                content = this.serializeObject(object);
-                this.#context.set(object, content);
-            }
-            return content;
-        }
-        $function(fn) {
-            const fnStr = Function.prototype.toString.call(fn);
-            if (fnStr.slice(-15 /* "[native code] }".length */) === '[native code] }') {
-                return `${fn.name || ''}()[native]`;
-            }
-            return `${fn.name}(${fn.length})${fnStr.replace(/\s*\n\s*/g, '')}`;
-        }
-        $Array(arr) {
-            let content = '[';
-            for (let i = 0; i < arr.length; i++) {
-                content += this.serialize(arr[i]);
-                if (i < arr.length - 1) {
-                    content += ',';
-                }
-            }
-            return content + ']';
-        }
-        $Date(date) {
-            try {
-                return `Date(${date.toISOString()})`;
-            }
-            catch {
-                return `Date(null)`;
-            }
-        }
-        $ArrayBuffer(arr) {
-            return `ArrayBuffer[${new Uint8Array(arr).join(',')}]`;
-        }
-        $Set(set) {
-            return `Set${this.$Array(Array.from(set).sort((a, b) => this.compare(a, b)))}`;
-        }
-        $Map(map) {
-            return this.serializeObjectEntries('Map', map.entries());
-        }
-    }
-    for (const type of ['Error', 'RegExp', 'URL']) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
-        Serializer.prototype['$' + type] = function (val) {
-            return `${type}(${val})`;
-        };
-    }
-    for (const type of [
-        'Int8Array',
-        'Uint8Array',
-        'Uint8ClampedArray',
-        'Int16Array',
-        'Uint16Array',
-        'Int32Array',
-        'Uint32Array',
-        'Float32Array',
-        'Float64Array'
-    ]) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
-        Serializer.prototype['$' + type] = function (arr) {
-            return `${type}[${arr.join(',')}]`;
-        };
-    }
-    for (const type of ['BigInt64Array', 'BigUint64Array']) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
-        Serializer.prototype['$' + type] = function (arr) {
-            return `${type}[${arr.join('n,')}${arr.length > 0 ? 'n' : ''}]`;
-        };
-    }
-    return Serializer;
-})();
-
-/**
- * Compare two objects using reference equality and stable deep hashing.
- * @param {any} object1 First object
- * @param {any} object2 Second object
- * @return {boolean} true if equal and false if not
- */
-function isEqual(object1, object2) {
-    if (object1 === object2) {
-        return true;
-    }
-    if (serialize(object1) === serialize(object2)) {
-        return true;
-    }
-    return false;
-}
-
-function isInsideForm(el) {
-    if (!el || !el.nativeElement) {
-        return true;
-    }
-    return Boolean(el.nativeElement.closest('form'));
-}
-
-function isNullish(value) {
-    return value === null || value === undefined;
-}
-
-const isNumber = (v) => typeof v === 'number';
-
-/**
- * The function `isValueEqualOrExist` checks if a value is equal to or exists in another value or
- * array.
- * @param {T | T[] | undefined} base - It represents the base value that you want to compare with the `current` value.
- * @param {T | T[] | undefined} current - The `current` parameter represents the current value that you want to compare with the `base` value or values.
- * @returns The `isValueEqualOrExist` function returns a boolean value. It checks if the `base` value
- * is equal to the `current` value or if the `current` value exists within the `base` value. The
- * function handles cases where `base` can be a single value, an array of values, or undefined.
- */
-function isValueEqualOrExist(base, current) {
-    if (isNullish(base))
-        return false;
-    if (Array.isArray(base)) {
-        return base.some((val) => isEqual(val, current));
-    }
-    else {
-        return isEqual(base, current);
-    }
-}
-
-const ALT = 'Alt';
-const ARROW_DOWN = 'ArrowDown';
-const ARROW_LEFT = 'ArrowLeft';
-const ARROW_RIGHT = 'ArrowRight';
-const ARROW_UP = 'ArrowUp';
-const BACKSPACE = 'Backspace';
-const CAPS_LOCK = 'CapsLock';
-const CONTROL = 'Control';
-const DELETE = 'Delete';
-const END = 'End';
-const ENTER = 'Enter';
-const ESCAPE = 'Escape';
-const F1 = 'F1';
-const F10 = 'F10';
-const F11 = 'F11';
-const F12 = 'F12';
-const F2 = 'F2';
-const F3 = 'F3';
-const F4 = 'F4';
-const F5 = 'F5';
-const F6 = 'F6';
-const F7 = 'F7';
-const F8 = 'F8';
-const F9 = 'F9';
-const HOME = 'Home';
-const META = 'Meta';
-const PAGE_DOWN = 'PageDown';
-const PAGE_UP = 'PageUp';
-const SHIFT = 'Shift';
-const SPACE = ' ';
-const TAB = 'Tab';
-const CTRL = 'Control';
-const ASTERISK = '*';
-const a = 'a';
-const P = 'P';
-const A = 'A';
-const p = 'p';
-const n = 'n';
-const j = 'j';
-const k = 'k';
-const SPACE_CODE = 'Space';
-
-/**
- * Creates an Angular provider that binds the given token to the existing instance
- * of the specified class. This is especially useful when you want multiple
- * tokens (or interfaces) to resolve to the same directive/component instance.
- *
- * @template T - The type associated with the injection token.
- * @param token - The InjectionToken or abstract type you want to provide.
- * @param type  - The class type whose existing instance will be used for this token.
- * @returns A Provider configuration object for Angular's DI system.
- *
- * @example
- *
- * @Directive({
- *   providers: [
- *     provideToken(RdxToggleGroupToken, RdxToggleGroupDirective),
- *     provideValueAccessor(RdxToggleGroupDirective)
- *   ]
- * })
- * export class RdxToggleGroupDirective {}
- */
-function provideToken(token, type) {
-    return {
-        provide: token,
-        useExisting: forwardRef(() => type)
-    };
-}
-
-const WINDOW = new InjectionToken('An abstraction over global window object', {
-    factory: () => {
-        const { defaultView } = injectDocument();
-        if (!defaultView) {
-            throw new Error('Window is not available');
-        }
-        return defaultView;
-    }
-});
-function injectWindow() {
-    return inject(WINDOW);
-}
-
 // Thanks for idea.
 // https://github.com/unovue/reka-ui/blob/v2/packages/core/src/shared/createContext.ts
 /**
@@ -1486,25 +970,67 @@ function createContent(props) {
     };
 }
 
-function isSegmentNavigationKey(key) {
-    if (key === ARROW_RIGHT || key === ARROW_LEFT)
-        return true;
-    return false;
-}
-function isNumberString(value) {
-    if (Number.isNaN(Number.parseInt(value)))
-        return false;
-    return true;
-}
-function isAcceptableSegmentKey(key) {
-    const acceptableSegmentKeys = [
-        ENTER,
-        ARROW_UP,
-        ARROW_DOWN,
-        ARROW_LEFT,
-        ARROW_RIGHT,
-        BACKSPACE,
-        SPACE,
+const ALT = 'Alt';
+const ARROW_DOWN = 'ArrowDown';
+const ARROW_LEFT = 'ArrowLeft';
+const ARROW_RIGHT = 'ArrowRight';
+const ARROW_UP = 'ArrowUp';
+const BACKSPACE = 'Backspace';
+const CAPS_LOCK = 'CapsLock';
+const CONTROL = 'Control';
+const DELETE = 'Delete';
+const END = 'End';
+const ENTER = 'Enter';
+const ESCAPE = 'Escape';
+const F1 = 'F1';
+const F10 = 'F10';
+const F11 = 'F11';
+const F12 = 'F12';
+const F2 = 'F2';
+const F3 = 'F3';
+const F4 = 'F4';
+const F5 = 'F5';
+const F6 = 'F6';
+const F7 = 'F7';
+const F8 = 'F8';
+const F9 = 'F9';
+const HOME = 'Home';
+const META = 'Meta';
+const PAGE_DOWN = 'PageDown';
+const PAGE_UP = 'PageUp';
+const SHIFT = 'Shift';
+const SPACE = ' ';
+const TAB = 'Tab';
+const CTRL = 'Control';
+const ASTERISK = '*';
+const a = 'a';
+const P = 'P';
+const A = 'A';
+const p = 'p';
+const n = 'n';
+const j = 'j';
+const k = 'k';
+const SPACE_CODE = 'Space';
+
+function isSegmentNavigationKey(key) {
+    if (key === ARROW_RIGHT || key === ARROW_LEFT)
+        return true;
+    return false;
+}
+function isNumberString(value) {
+    if (Number.isNaN(Number.parseInt(value)))
+        return false;
+    return true;
+}
+function isAcceptableSegmentKey(key) {
+    const acceptableSegmentKeys = [
+        ENTER,
+        ARROW_UP,
+        ARROW_DOWN,
+        ARROW_LEFT,
+        ARROW_RIGHT,
+        BACKSPACE,
+        SPACE,
         'a',
         'A',
         'p',
@@ -2297,219 +1823,353 @@ function handleAndDispatchCustomEvent(name, handler, detail) {
     target.dispatchEvent(event);
 }
 
-var RdxPositionSide;
-(function (RdxPositionSide) {
-    RdxPositionSide["Top"] = "top";
-    RdxPositionSide["Right"] = "right";
-    RdxPositionSide["Bottom"] = "bottom";
-    RdxPositionSide["Left"] = "left";
-})(RdxPositionSide || (RdxPositionSide = {}));
-var RdxPositionAlign;
-(function (RdxPositionAlign) {
-    RdxPositionAlign["Start"] = "start";
-    RdxPositionAlign["Center"] = "center";
-    RdxPositionAlign["End"] = "end";
-})(RdxPositionAlign || (RdxPositionAlign = {}));
+/**
+ * Per-prefix counters, kept module-global so generated IDs stay deterministic within a run.
+ * Determinism keeps server and client renders in sync, which matters for hydration.
+ */
+const counters = new Map();
+/**
+ * Generates unique, SSR-stable IDs for DOM nodes.
+ *
+ * IDs are deterministic per prefix (a monotonic counter) so the server and the client produce the
+ * same sequence and hydration does not mismatch. The application's `APP_ID` is folded into the
+ * prefix so multiple Angular apps on one page don't collide; the default `ng` app id is omitted to
+ * keep IDs short for the common single-app case.
+ *
+ * Prefer the {@link injectId} hook at call sites; inject this service directly only when you need to
+ * generate IDs lazily outside an injection context.
+ */
+class RdxIdGenerator {
+    constructor() {
+        this.appId = inject(APP_ID);
+    }
+    /** Generates a unique ID with the given prefix. */
+    getId(prefix) {
+        const key = this.appId === 'ng' ? prefix : prefix + this.appId;
+        const next = counters.get(key) ?? 0;
+        counters.set(key, next + 1);
+        return `${key}${next}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxIdGenerator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxIdGenerator, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxIdGenerator, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * Returns a unique, SSR-stable ID for the given prefix — the Angular counterpart of React's
+ * `useId`. Must be called in an injection context (e.g. a field initializer or constructor).
+ *
+ * @example
+ * readonly contentId = injectId('rdx-dialog-content-');
+ */
+function injectId(prefix) {
+    return inject(RdxIdGenerator).getId(prefix);
+}
 
-const RDX_POSITIONS = {
-    [RdxPositionSide.Top]: {
-        [RdxPositionAlign.Center]: {
-            originX: 'center',
-            originY: 'top',
-            overlayX: 'center',
-            overlayY: 'bottom'
-        },
-        [RdxPositionAlign.Start]: {
-            originX: 'start',
-            originY: 'top',
-            overlayX: 'start',
-            overlayY: 'bottom'
-        },
-        [RdxPositionAlign.End]: {
-            originX: 'end',
-            originY: 'top',
-            overlayX: 'end',
-            overlayY: 'bottom'
+/**
+ * Announces messages to screen readers through an `aria-live` region, without moving focus.
+ *
+ * Own replacement for CDK's `LiveAnnouncer` — lazily appends a visually hidden live region to
+ * the document body and writes messages into it. No-op on the server.
+ */
+class RdxLiveAnnouncer {
+    constructor() {
+        this.document = inject(DOCUMENT);
+        this.isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+        this.liveElement = null;
+        inject(DestroyRef).onDestroy(() => {
+            clearTimeout(this.previousTimeout);
+            this.liveElement?.remove();
+            this.liveElement = null;
+        });
+    }
+    /**
+     * Announces a message to screen readers.
+     *
+     * @param message The message to announce.
+     * @param politeness The politeness of the announcer element (defaults to `'polite'`).
+     * @param duration If provided, the message is cleared after this many milliseconds.
+     */
+    announce(message, politeness = 'polite', duration) {
+        if (!this.isBrowser) {
+            return;
         }
-    },
-    [RdxPositionSide.Right]: {
-        [RdxPositionAlign.Center]: {
-            originX: 'end',
-            originY: 'center',
-            overlayX: 'start',
-            overlayY: 'center'
-        },
-        [RdxPositionAlign.Start]: {
-            originX: 'end',
-            originY: 'top',
-            overlayX: 'start',
-            overlayY: 'top'
-        },
-        [RdxPositionAlign.End]: {
-            originX: 'end',
-            originY: 'bottom',
-            overlayX: 'start',
-            overlayY: 'bottom'
+        const liveElement = this.getLiveElement();
+        clearTimeout(this.previousTimeout);
+        liveElement.setAttribute('aria-live', politeness);
+        // Clear the live element first, then set the message after a tick so that screen
+        // readers reliably pick up the change even when the text is identical.
+        liveElement.textContent = '';
+        this.previousTimeout = setTimeout(() => {
+            liveElement.textContent = message;
+            if (typeof duration === 'number') {
+                this.previousTimeout = setTimeout(() => (liveElement.textContent = ''), duration);
+            }
+        });
+    }
+    /** Clears the current announcement. */
+    clear() {
+        if (this.liveElement) {
+            this.liveElement.textContent = '';
+        }
+    }
+    getLiveElement() {
+        if (this.liveElement) {
+            return this.liveElement;
+        }
+        const element = this.document.createElement('div');
+        element.classList.add('rdx-live-announcer');
+        element.setAttribute('aria-atomic', 'true');
+        element.setAttribute('aria-live', 'polite');
+        // Visually hide the region while keeping it available to assistive technology.
+        element.style.position = 'absolute';
+        element.style.width = '1px';
+        element.style.height = '1px';
+        element.style.margin = '-1px';
+        element.style.padding = '0';
+        element.style.border = '0';
+        element.style.overflow = 'hidden';
+        element.style.clip = 'rect(0 0 0 0)';
+        element.style.clipPath = 'inset(100%)';
+        element.style.whiteSpace = 'nowrap';
+        this.document.body.appendChild(element);
+        this.liveElement = element;
+        return element;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxLiveAnnouncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxLiveAnnouncer, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxLiveAnnouncer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+/** Narrows to `null | undefined`. */
+function isNullish(value) {
+    return value === null || value === undefined;
+}
+/**
+ * Structural equality for the value shapes a primitive can hold: primitives (incl. `NaN`), arrays,
+ * plain objects, and the common built-ins `Date`, `RegExp`, `Map`, and `Set`. Reference cycles are
+ * handled. Other opaque objects (e.g. class instances with no own enumerable properties) fall back
+ * to per-key comparison and so only match when they expose equal enumerable state.
+ */
+function isEqual(a, b) {
+    return equals(a, b, new WeakMap());
+}
+function equals(a, b, seen) {
+    if (a === b) {
+        return true;
+    }
+    // NaN is the one primitive that is not reference-equal to itself.
+    if (typeof a === 'number' && typeof b === 'number') {
+        return Number.isNaN(a) && Number.isNaN(b);
+    }
+    if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') {
+        return false;
+    }
+    // Different prototypes (Date vs plain object, class A vs class B, …) are never structurally equal.
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
+        return false;
+    }
+    // Break reference cycles: if this exact pair is already being compared on the current path,
+    // the structure has matched so far — treat it as equal. Cleared on ascent so sibling branches
+    // start fresh.
+    if (seen.get(a) === b) {
+        return true;
+    }
+    seen.set(a, b);
+    try {
+        if (a instanceof Date) {
+            return a.getTime() === b.getTime();
         }
-    },
-    [RdxPositionSide.Bottom]: {
-        [RdxPositionAlign.Center]: {
-            originX: 'center',
-            originY: 'bottom',
-            overlayX: 'center',
-            overlayY: 'top'
-        },
-        [RdxPositionAlign.Start]: {
-            originX: 'start',
-            originY: 'bottom',
-            overlayX: 'start',
-            overlayY: 'top'
-        },
-        [RdxPositionAlign.End]: {
-            originX: 'end',
-            originY: 'bottom',
-            overlayX: 'end',
-            overlayY: 'top'
+        if (a instanceof RegExp) {
+            return a.source === b.source && a.flags === b.flags;
         }
-    },
-    [RdxPositionSide.Left]: {
-        [RdxPositionAlign.Center]: {
-            originX: 'start',
-            originY: 'center',
-            overlayX: 'end',
-            overlayY: 'center'
-        },
-        [RdxPositionAlign.Start]: {
-            originX: 'start',
-            originY: 'top',
-            overlayX: 'end',
-            overlayY: 'top'
-        },
-        [RdxPositionAlign.End]: {
-            originX: 'start',
-            originY: 'bottom',
-            overlayX: 'end',
-            overlayY: 'bottom'
+        if (Array.isArray(a)) {
+            return a.length === b.length && a.every((item, index) => equals(item, b[index], seen));
         }
-    }
-};
-const RDX_POSITIONING_DEFAULTS = {
-    offsets: {
-        side: 4,
-        align: 0
-    },
-    arrow: {
-        width: 8,
-        height: 6
-    }
-};
-
-function getContentPosition(sideAndAlignWithOffsets) {
-    const { side, align, sideOffset, alignOffset } = sideAndAlignWithOffsets;
-    const position = {
-        ...(RDX_POSITIONS[side]?.[align] ?? RDX_POSITIONS[RdxPositionSide.Top][RdxPositionAlign.Center])
-    };
-    if (sideOffset || alignOffset) {
-        if ([RdxPositionSide.Top, RdxPositionSide.Bottom].includes(side)) {
-            if (sideOffset) {
-                position.offsetY = side === RdxPositionSide.Top ? -sideOffset : sideOffset;
+        if (a instanceof Map) {
+            if (a.size !== b.size) {
+                return false;
             }
-            if (alignOffset) {
-                position.offsetX = alignOffset;
+            for (const [key, value] of a) {
+                if (!b.has(key) || !equals(value, b.get(key), seen)) {
+                    return false;
+                }
             }
+            return true;
         }
-        else {
-            if (sideOffset) {
-                position.offsetX = side === RdxPositionSide.Left ? -sideOffset : sideOffset;
+        if (a instanceof Set) {
+            if (a.size !== b.size) {
+                return false;
             }
-            if (alignOffset) {
-                position.offsetY = alignOffset;
+            for (const value of a) {
+                if (!b.has(value)) {
+                    return false;
+                }
             }
+            return true;
         }
+        const keys = Object.keys(a);
+        if (keys.length !== Object.keys(b).length) {
+            return false;
+        }
+        return keys.every((key) => Object.prototype.hasOwnProperty.call(b, key) && equals(a[key], b[key], seen));
     }
-    return position;
-}
-let allPossibleConnectedPositions;
-function getAllPossibleConnectedPositions() {
-    if (!allPossibleConnectedPositions) {
-        allPossibleConnectedPositions = new Map();
+    finally {
+        seen.delete(a);
     }
-    if (allPossibleConnectedPositions.size < 1) {
-        for (const [side, aligns] of Object.entries(RDX_POSITIONS)) {
-            for (const [align, position] of Object.entries(aligns)) {
-                allPossibleConnectedPositions.set(`${side}|${align}`, position);
+}
+
+/**
+ * Creates an Angular provider that binds the given token to the existing instance
+ * of the specified class. This is especially useful when you want multiple
+ * tokens (or interfaces) to resolve to the same directive/component instance.
+ *
+ * @template T - The type associated with the injection token.
+ * @param token - The InjectionToken or abstract type you want to provide.
+ * @param type  - The class type whose existing instance will be used for this token.
+ * @returns A Provider configuration object for Angular's DI system.
+ *
+ * @example
+ *
+ * @Directive({
+ *   providers: [
+ *     provideToken(RdxFooToken, RdxFooDirective),
+ *     provideValueAccessor(RdxFooDirective)
+ *   ]
+ * })
+ * export class RdxFooDirective {}
+ */
+function provideToken(token, type) {
+    return {
+        provide: token,
+        useExisting: forwardRef(() => type)
+    };
+}
+
+function injectDocument() {
+    return inject(DOCUMENT);
+}
+
+function elementSize({ elementRef, injector }) {
+    const destroyRef = injector.get(DestroyRef);
+    const result = signal({
+        width: elementRef.nativeElement.offsetWidth,
+        height: elementRef.nativeElement.offsetHeight
+    }, ...(ngDevMode ? [{ debugName: "result" }] : /* istanbul ignore next */ []));
+    afterNextRender(() => {
+        const resizeObserver = new ResizeObserver((entries) => {
+            const entry = entries[0];
+            let width;
+            let height;
+            if ('borderBoxSize' in entry) {
+                const borderSizeEntry = entry['borderBoxSize'];
+                const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+                width = borderSize['inlineSize'];
+                height = borderSize['blockSize'];
             }
-        }
+            else {
+                width = elementRef.nativeElement.offsetWidth;
+                height = elementRef.nativeElement.offsetHeight;
+            }
+            result.set({ width, height });
+        });
+        destroyRef.onDestroy(() => resizeObserver.disconnect());
+    }, { injector: injector });
+    return result.asReadonly();
+}
+
+function getActiveElement() {
+    let activeElement = document.activeElement;
+    if (activeElement == null) {
+        return null;
     }
-    return allPossibleConnectedPositions;
-}
-function getSideAndAlignFromAllPossibleConnectedPositions(position) {
-    const allPossibleConnectedPositions = getAllPossibleConnectedPositions();
-    let sideAndAlign;
-    allPossibleConnectedPositions.forEach((value, key) => {
-        if (position.originX === value.originX &&
-            position.originY === value.originY &&
-            position.overlayX === value.overlayX &&
-            position.overlayY === value.overlayY) {
-            const sideAndAlignArray = key.split('|');
-            sideAndAlign = {
-                side: sideAndAlignArray[0],
-                align: sideAndAlignArray[1]
-            };
-        }
-    });
-    if (!sideAndAlign) {
-        throw Error(`[Rdx positioning] cannot infer both side and align from the given position (${JSON.stringify(position)})`);
+    while (activeElement != null &&
+        activeElement.shadowRoot != null &&
+        activeElement.shadowRoot.activeElement != null) {
+        activeElement = activeElement.shadowRoot.activeElement;
     }
-    return sideAndAlign;
+    return activeElement;
 }
-function getArrowPositionParams(sideAndAlign, arrowWidthAndHeight, triggerWidthAndHeight) {
-    const posParams = {
-        top: '',
-        left: '',
-        transform: '',
-        transformOrigin: 'center center 0px'
-    };
-    if ([RdxPositionSide.Top, RdxPositionSide.Bottom].includes(sideAndAlign.side)) {
-        if (sideAndAlign.side === RdxPositionSide.Top) {
-            posParams.top = '100%';
-        }
-        else {
-            posParams.top = `-${arrowWidthAndHeight.height}px`;
-            posParams.transform = `rotate(180deg)`;
+
+/**
+ * Creates a resize observer effect for element
+ *
+ * @param options Configuration options
+ * @param options.injector Angular injector
+ * @param options.element Signal returning the element to observe
+ * @param options.onResize Callback when element is resized
+ * @returns EffectRef that can be destroyed when needed
+ */
+function resizeEffect(options) {
+    return effect((onCleanup) => {
+        const elementOrRef = options.element();
+        if (!elementOrRef)
+            return;
+        // Extract native element from ElementRef or use directly if it's HTMLElement
+        const element = elementOrRef instanceof ElementRef ? elementOrRef.nativeElement : elementOrRef;
+        const resizeObserver = new ResizeObserver(options.onResize);
+        resizeObserver.observe(element);
+        onCleanup(() => resizeObserver.disconnect());
+    }, { injector: options.injector });
+}
+
+/**
+ * Process-wide ownership of `document.body`'s overflow while one or more overlays lock scrolling.
+ *
+ * A single shared counter across every primitive that locks scroll is essential: with separate
+ * per-primitive counters, a popover and a dialog open at the same time would each capture the
+ * other's already-locked `overflow: hidden` as the "original" value and restore it on close,
+ * leaving the page permanently unscrollable.
+ */
+let originalBodyOverflow = null;
+let scrollLockCount = 0;
+/**
+ * Locks `document.body` scrolling while `active()` is `true`, and restores the original overflow
+ * when it becomes `false` or the calling context is destroyed.
+ *
+ * Lock ownership is shared across all callers via a single module-level counter, so nested or
+ * concurrent overlays compose correctly. Must be called in an injection context.
+ */
+function useScrollLock(active) {
+    const document = inject(DOCUMENT$1);
+    let isLocked = false;
+    const lock = () => {
+        if (isLocked) {
+            return;
         }
-        if (sideAndAlign.align === RdxPositionAlign.Start) {
-            posParams.left = `${(triggerWidthAndHeight.width - arrowWidthAndHeight.width) / 2}px`;
+        const body = document.body;
+        if (scrollLockCount === 0) {
+            originalBodyOverflow = body.style.overflow;
+            body.style.overflow = 'hidden';
         }
-        else if (sideAndAlign.align === RdxPositionAlign.Center) {
-            posParams.left = `calc(50% - ${arrowWidthAndHeight.width / 2}px)`;
+        scrollLockCount++;
+        isLocked = true;
+    };
+    const unlock = () => {
+        if (!isLocked) {
+            return;
         }
-        else if (sideAndAlign.align === RdxPositionAlign.End) {
-            posParams.left = `calc(100% - ${(triggerWidthAndHeight.width + arrowWidthAndHeight.width) / 2}px)`;
+        scrollLockCount--;
+        isLocked = false;
+        if (scrollLockCount === 0 && originalBodyOverflow !== null) {
+            document.body.style.overflow = originalBodyOverflow;
+            originalBodyOverflow = null;
         }
-    }
-    else if ([RdxPositionSide.Left, RdxPositionSide.Right].includes(sideAndAlign.side)) {
-        if (sideAndAlign.side === RdxPositionSide.Left) {
-            posParams.left = `calc(100% - ${arrowWidthAndHeight.width}px)`;
-            posParams.transform = `rotate(-90deg)`;
-            posParams.transformOrigin = 'top right 0px';
+    };
+    effect(() => {
+        if (active()) {
+            lock();
         }
         else {
-            posParams.left = `0`;
-            posParams.transform = `rotate(90deg)`;
-            posParams.transformOrigin = 'top left 0px';
-        }
-        if (sideAndAlign.align === RdxPositionAlign.Start) {
-            posParams.top = `${(triggerWidthAndHeight.height - arrowWidthAndHeight.width) / 2}px`;
-        }
-        else if (sideAndAlign.align === RdxPositionAlign.Center) {
-            posParams.top = `calc(50% - ${arrowWidthAndHeight.width / 2}px)`;
-        }
-        else if (sideAndAlign.align === RdxPositionAlign.End) {
-            posParams.top = `calc(100% - ${(triggerWidthAndHeight.height + arrowWidthAndHeight.width) / 2}px)`;
+            unlock();
         }
-    }
-    return posParams;
+    });
+    inject(DestroyRef).onDestroy(unlock);
 }
 
 // made by https://reka-ui.com/
@@ -2596,26 +2256,343 @@ function findNextFocusableElement(elements, currentElement, options, iterations
     return candidate;
 }
 
+const graceAreaContainers = new WeakMap();
+function createSignalEvent() {
+    const handlers = new Set();
+    return {
+        on(callback) {
+            handlers.add(callback);
+            return () => handlers.delete(callback);
+        },
+        emitVoid() {
+            handlers.forEach((handler) => handler(undefined));
+        }
+    };
+}
 /**
- * Creates a resize observer effect for element
+ * Keeps hover content open while the pointer crosses the gap between a trigger and a popup.
+ */
+function useGraceArea(triggerEl, containerEl, resetMs = 300) {
+    const isPointerInTransit = signal(false, ...(ngDevMode ? [{ debugName: "isPointerInTransit" }] : /* istanbul ignore next */ []));
+    const pointerExit = createSignalEvent();
+    let pointerGraceArea = null;
+    let resetTimer = null;
+    function armInTransitAutoReset() {
+        if (resetTimer !== null)
+            window.clearTimeout(resetTimer);
+        resetTimer = window.setTimeout(() => {
+            isPointerInTransit.set(false);
+            resetTimer = null;
+        }, resetMs);
+    }
+    function clearGraceArea() {
+        pointerGraceArea = null;
+        isPointerInTransit.set(false);
+        if (resetTimer !== null) {
+            window.clearTimeout(resetTimer);
+            resetTimer = null;
+        }
+    }
+    function createGraceArea(event, hoverTarget) {
+        const currentTarget = event.currentTarget;
+        const exitPoint = { x: event.clientX, y: event.clientY };
+        const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
+        const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);
+        const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
+        pointerGraceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
+        isPointerInTransit.set(true);
+        armInTransitAutoReset();
+    }
+    function trackPointerGrace(event) {
+        if (!pointerGraceArea || !(event.target instanceof HTMLElement))
+            return;
+        const trigger = triggerEl();
+        const container = containerEl();
+        if (!trigger || !container)
+            return;
+        const target = event.target;
+        const pointerPosition = { x: event.clientX, y: event.clientY };
+        const enteredContainer = target.closest('[data-grace-area-container]');
+        const nestedTrigger = enteredContainer ? graceAreaContainers.get(enteredContainer) : undefined;
+        const hasEnteredTarget = trigger.contains(target) ||
+            container.contains(target) ||
+            (nestedTrigger ? container.contains(nestedTrigger) : false);
+        const isOutsideGrace = !isPointInPolygon(pointerPosition, pointerGraceArea);
+        const isAnotherGraceAreaTrigger = !!target.closest('[data-grace-area-trigger]');
+        if (hasEnteredTarget) {
+            clearGraceArea();
+        }
+        else if (isOutsideGrace || isAnotherGraceAreaTrigger) {
+            clearGraceArea();
+            pointerExit.emitVoid();
+        }
+    }
+    effect((onCleanup) => {
+        const trigger = triggerEl();
+        const container = containerEl();
+        const onTriggerLeave = (event) => {
+            if (container)
+                createGraceArea(event, container);
+        };
+        const onContainerLeave = (event) => {
+            if (trigger)
+                createGraceArea(event, trigger);
+        };
+        onCleanup(() => {
+            const doc = trigger?.ownerDocument;
+            trigger?.removeEventListener('pointerleave', onTriggerLeave);
+            container?.removeEventListener('pointerleave', onContainerLeave);
+            doc?.removeEventListener('pointermove', trackPointerGrace);
+            trigger?.removeAttribute('data-grace-area-trigger');
+            container?.removeAttribute('data-grace-area-container');
+            if (container && graceAreaContainers.get(container) === trigger) {
+                graceAreaContainers.delete(container);
+            }
+            clearGraceArea();
+        });
+        if (!trigger || !container)
+            return;
+        trigger.setAttribute('data-grace-area-trigger', '');
+        container.setAttribute('data-grace-area-container', '');
+        graceAreaContainers.set(container, trigger);
+        trigger.addEventListener('pointerleave', onTriggerLeave, { passive: true });
+        container.addEventListener('pointerleave', onContainerLeave, { passive: true });
+        trigger.ownerDocument.addEventListener('pointermove', trackPointerGrace, { passive: true });
+    });
+    return {
+        isPointerInTransit: isPointerInTransit.asReadonly(),
+        onPointerExit: pointerExit.on
+    };
+}
+function getExitSideFromRect(point, rect) {
+    const top = Math.abs(rect.top - point.y);
+    const bottom = Math.abs(rect.bottom - point.y);
+    const right = Math.abs(rect.right - point.x);
+    const left = Math.abs(rect.left - point.x);
+    const min = Math.min(top, bottom, right, left);
+    if (!Number.isFinite(min)) {
+        return 'bottom';
+    }
+    switch (min) {
+        case left:
+            return 'left';
+        case right:
+            return 'right';
+        case top:
+            return 'top';
+        case bottom:
+            return 'bottom';
+        default:
+            throw new Error('unreachable');
+    }
+}
+function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
+    const points = [];
+    switch (exitSide) {
+        case 'top':
+            points.push({ x: exitPoint.x - padding, y: exitPoint.y + padding }, { x: exitPoint.x + padding, y: exitPoint.y + padding });
+            break;
+        case 'bottom':
+            points.push({ x: exitPoint.x - padding, y: exitPoint.y - padding }, { x: exitPoint.x + padding, y: exitPoint.y - padding });
+            break;
+        case 'left':
+            points.push({ x: exitPoint.x + padding, y: exitPoint.y - padding }, { x: exitPoint.x + padding, y: exitPoint.y + padding });
+            break;
+        case 'right':
+            points.push({ x: exitPoint.x - padding, y: exitPoint.y - padding }, { x: exitPoint.x - padding, y: exitPoint.y + padding });
+            break;
+    }
+    return points;
+}
+function getPointsFromRect(rect) {
+    const { top, right, bottom, left } = rect;
+    return [
+        { x: left, y: top },
+        { x: right, y: top },
+        { x: right, y: bottom },
+        { x: left, y: bottom }
+    ];
+}
+function isPointInPolygon(point, polygon) {
+    const { x, y } = point;
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const xi = polygon[i].x;
+        const yi = polygon[i].y;
+        const xj = polygon[j].x;
+        const yj = polygon[j].y;
+        const intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect)
+            inside = !inside;
+    }
+    return inside;
+}
+function getHull(points) {
+    const sortedPoints = points.slice();
+    sortedPoints.sort((a, b) => a.x - b.x || a.y - b.y);
+    return getHullPresorted(sortedPoints);
+}
+function getHullPresorted(points) {
+    if (points.length <= 1)
+        return points.slice();
+    const upper = [];
+    for (const point of points) {
+        while (upper.length >= 2) {
+            const q = upper[upper.length - 1];
+            const r = upper[upper.length - 2];
+            if ((q.x - r.x) * (point.y - r.y) >= (q.y - r.y) * (point.x - r.x))
+                upper.pop();
+            else
+                break;
+        }
+        upper.push(point);
+    }
+    upper.pop();
+    const lower = [];
+    for (let index = points.length - 1; index >= 0; index--) {
+        const point = points[index];
+        while (lower.length >= 2) {
+            const q = lower[lower.length - 1];
+            const r = lower[lower.length - 2];
+            if ((q.x - r.x) * (point.y - r.y) >= (q.y - r.y) * (point.x - r.x))
+                lower.pop();
+            else
+                break;
+        }
+        lower.push(point);
+    }
+    lower.pop();
+    if (upper.length === 1 && lower.length === 1 && upper[0].x === lower[0].x && upper[0].y === lower[0].y) {
+        return upper;
+    }
+    return upper.concat(lower);
+}
+
+/**
+ * Grace period (ms) added to an element's declared transition duration before the
+ * safety-net timer force-completes a transition. Only matters when the real
+ * `animationend`/`transitionend` never arrives (interrupted, replaced without a
+ * cancel event, reduced motion, …).
+ */
+const TRANSITION_FALLBACK_BUFFER = 50;
+/**
+ * Shared open/close transition state machine used by overlay primitives (dialog, popover, …).
  *
- * @param options Configuration options
- * @param options.injector Angular injector
- * @param options.element Signal returning the element to observe
- * @param options.onResize Callback when element is resized
- * @returns EffectRef that can be destroyed when needed
+ * On `start(open)` it flips `status` to `'starting'`/`'ending'`, then — after the next render and
+ * (for opening) one animation frame — clears it and waits for the registered element's running CSS
+ * animations/transitions to finish (via the Web Animations API) before invoking `onComplete(open)`.
+ * Completing on the real `animationend` rather than a duration timer keeps it from firing a frame
+ * late. A duration-based timer remains as a safety net, and if no element is registered or it has no
+ * animation (also SSR / jsdom, where computed durations are `0`) completion is synchronous.
+ *
+ * Must be called in an injection context (uses {@link Injector} and {@link DestroyRef}).
  */
-function resizeEffect(options) {
-    return effect((onCleanup) => {
-        const elementOrRef = options.element();
-        if (!elementOrRef)
+function useTransitionStatus(onComplete) {
+    const injector = inject(Injector);
+    const destroyRef = inject(DestroyRef);
+    const status = signal(undefined, ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+    let element;
+    let timer;
+    let frame;
+    let version = 0;
+    const clearTimers = () => {
+        if (frame !== undefined) {
+            cancelAnimationFrame(frame);
+            frame = undefined;
+        }
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    const complete = (open, currentVersion) => {
+        if (currentVersion !== version) {
             return;
-        // Extract native element from ElementRef or use directly if it's HTMLElement
-        const element = elementOrRef instanceof ElementRef ? elementOrRef.nativeElement : elementOrRef;
-        const resizeObserver = new ResizeObserver(options.onResize);
-        resizeObserver.observe(element);
-        onCleanup(() => resizeObserver.disconnect());
-    }, { injector: options.injector });
+        }
+        clearTimers();
+        status.set(undefined);
+        if (!destroyRef.destroyed) {
+            onComplete(open);
+        }
+    };
+    const waitForTransition = (open, currentVersion) => {
+        const node = element;
+        const duration = node ? getMaxTransitionDuration(node) : 0;
+        // Nothing animating (also the SSR / jsdom path, where computed durations are
+        // 0): settle synchronously, exactly as before.
+        if (!node || duration === 0) {
+            complete(open, currentVersion);
+            return;
+        }
+        // Prefer the Web Animations API so completion lands on the real
+        // `animationend` / `transitionend` instead of a timer that can fire a frame
+        // late — that lateness is what let a closing collapsible flash back to its
+        // natural size before `hidden` was applied.
+        const animations = typeof node.getAnimations === 'function' ? node.getAnimations() : [];
+        // Safety net: if an animation never settles (interrupted, replaced without a
+        // cancel event, reduced motion, or simply not exposed by the engine yet)
+        // still complete shortly after the declared duration.
+        timer = setTimeout(() => complete(open, currentVersion), duration + TRANSITION_FALLBACK_BUFFER);
+        if (animations.length === 0) {
+            return;
+        }
+        // A cancelled animation rejects `finished`; swallow it so reopening (which
+        // cancels the in-flight animation) still resolves and settles.
+        void Promise.all(animations.map((animation) => animation.finished.catch(() => undefined))).then(() => complete(open, currentVersion));
+    };
+    destroyRef.onDestroy(clearTimers);
+    return {
+        status: status.asReadonly(),
+        registerElement: (registered) => {
+            element = registered;
+            return () => {
+                if (element === registered) {
+                    element = undefined;
+                }
+            };
+        },
+        start: (open) => {
+            const currentVersion = ++version;
+            clearTimers();
+            status.set(open ? 'starting' : 'ending');
+            afterNextRender(() => {
+                if (destroyRef.destroyed || currentVersion !== version) {
+                    return;
+                }
+                if (open) {
+                    frame = requestAnimationFrame(() => {
+                        frame = undefined;
+                        if (destroyRef.destroyed || currentVersion !== version) {
+                            return;
+                        }
+                        status.set(undefined);
+                        waitForTransition(open, currentVersion);
+                    });
+                }
+                else {
+                    waitForTransition(open, currentVersion);
+                }
+            }, { injector });
+        }
+    };
+}
+/** Longest of an element's CSS transition / animation durations (including delays), in milliseconds. */
+function getMaxTransitionDuration(element) {
+    const styles = getComputedStyle(element);
+    return Math.max(getMaxCssDuration(styles.transitionDuration, styles.transitionDelay), getMaxCssDuration(styles.animationDuration, styles.animationDelay));
+}
+function getMaxCssDuration(durations, delays) {
+    const parsedDurations = durations.split(',').map(parseCssTime);
+    const parsedDelays = delays.split(',').map(parseCssTime);
+    return parsedDurations.reduce((max, duration, index) => Math.max(max, duration + parsedDelays[index % parsedDelays.length]), 0);
+}
+function parseCssTime(value) {
+    const trimmed = value.trim();
+    const parsed = Number.parseFloat(trimmed);
+    if (!Number.isFinite(parsed)) {
+        return 0;
+    }
+    return trimmed.endsWith('ms') ? parsed : parsed * 1000;
 }
 
 // https://ngxtension.netlify.app/utilities/signals/explicit-effect/
@@ -2655,9 +2632,23 @@ function watch(deps, fn, options) {
     }, options);
 }
 
+var RdxPositionSide;
+(function (RdxPositionSide) {
+    RdxPositionSide["Top"] = "top";
+    RdxPositionSide["Right"] = "right";
+    RdxPositionSide["Bottom"] = "bottom";
+    RdxPositionSide["Left"] = "left";
+})(RdxPositionSide || (RdxPositionSide = {}));
+var RdxPositionAlign;
+(function (RdxPositionAlign) {
+    RdxPositionAlign["Start"] = "start";
+    RdxPositionAlign["Center"] = "center";
+    RdxPositionAlign["End"] = "end";
+})(RdxPositionAlign || (RdxPositionAlign = {}));
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RDX_POSITIONING_DEFAULTS, RDX_POSITIONS, RdxAutoFocusDirective, RdxControlValueAccessor, RdxFocusInitialDirective, RdxPositionAlign, RdxPositionSide, SHIFT, SPACE, SPACE_CODE, TAB, WINDOW, _IdGenerator, a, areAllDaysBetweenValid, clamp, createContent, createContext, createFormatter, createMonth, createMonths, elementSize, getActiveElement, getAllPossibleConnectedPositions, getArrowPositionParams, getContentPosition, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getSideAndAlignFromAllPossibleConnectedPositions, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectIsClient, injectNgControl, injectWindow, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isInsideForm, isNullish, isNumber, isNumberString, isSegmentNavigationKey, isValueEqualOrExist, isZonedDateTime, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideToken, provideValueAccessor, resizeEffect, roundToStepPrecision, segmentBuilders, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useArrowNavigation, useDateField, watch };
+export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RdxControlValueAccessor, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, SHIFT, SPACE, SPACE_CODE, TAB, a, areAllDaysBetweenValid, clamp, createContent, createContext, createFormatter, createMonth, createMonths, elementSize, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isNullish, isNumberString, isSegmentNavigationKey, isZonedDateTime, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideToken, provideValueAccessor, resizeEffect, roundToStepPrecision, segmentBuilders, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useArrowNavigation, useDateField, useGraceArea, useScrollLock, useTransitionStatus, watch };
 //# sourceMappingURL=radix-ng-primitives-core.mjs.map