@radix-ng/primitives 0.42.0 → 0.44.0

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

@@ -1,5 +1,7 @@
+import { isPlatformBrowser } from '@angular/common';
 import * as i0 from '@angular/core';
-import { inject, NgZone, ElementRef, EventEmitter, signal, booleanAttribute, Output, Input, Directive, computed } from '@angular/core';
+import { inject, PLATFORM_ID, ElementRef, input, booleanAttribute, model, output, linkedSignal, signal, effect, Directive, DestroyRef, computed } from '@angular/core';
+import { createContext } from '@radix-ng/primitives/core';
 
 const ENTRY_FOCUS = 'rovingFocusGroup.onEntryFocus';
 const EVENT_OPTIONS = { bubbles: false, cancelable: true };
@@ -48,45 +50,113 @@ function generateId() {
     return `rf-item-${Math.random().toString(36).slice(2, 11)}`;
 }
 
+const rootContext = () => {
+    const rovingFocusGroup = inject(RdxRovingFocusGroupDirective);
+    return {
+        loop: rovingFocusGroup.loop,
+        dir: rovingFocusGroup.dir,
+        orientation: rovingFocusGroup.orientation,
+        currentTabStopId: rovingFocusGroup.currentTabStopId,
+        focusableItems: rovingFocusGroup.focusableItems,
+        onItemFocus: (tabStopId) => {
+            rovingFocusGroup.currentTabStopId.set(tabStopId);
+        },
+        onItemShiftTab: () => {
+            rovingFocusGroup.isTabbingBackOut.set(true);
+        },
+        onFocusableItemAdd: () => {
+            rovingFocusGroup.focusableItemsCount.update((count) => count + 1);
+        },
+        onFocusableItemRemove: () => {
+            rovingFocusGroup.focusableItemsCount.update((count) => Math.max(0, count - 1));
+        },
+        registerItem: (item) => {
+            const currentItems = rovingFocusGroup.focusableItems();
+            rovingFocusGroup.focusableItems.set([...currentItems, item]);
+        },
+        unregisterItem: (item) => {
+            const currentItems = rovingFocusGroup.focusableItems();
+            rovingFocusGroup.focusableItems.set(currentItems.filter((el) => el !== item));
+        }
+    };
+};
+const [injectRovingFocusGroupContext, provideRovingFocusGroupContext] = createContext('RovingFocusGroupContext');
+/**
+ * @group Components
+ */
 class RdxRovingFocusGroupDirective {
     constructor() {
-        this.ngZone = inject(NgZone);
+        this.isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
         this.elementRef = inject(ElementRef);
-        this.dir = 'ltr';
-        this.loop = true;
-        this.preventScrollOnEntryFocus = false;
-        this.entryFocus = new EventEmitter();
-        this.currentTabStopIdChange = new EventEmitter();
-        /** @ignore */
-        this.currentTabStopId = signal(null);
-        /** @ignore */
-        this.focusableItems = signal([]);
-        this.isClickFocus = signal(false);
-        this.isTabbingBackOut = signal(false);
-        this.focusableItemsCount = signal(0);
+        /**
+         * The orientation of the group. Mainly so arrow navigation is done accordingly (left & right vs. up & down)
+         */
+        this.orientationInput = input('horizontal', ...(ngDevMode ? [{ debugName: "orientationInput", alias: 'orientation' }] : [{ alias: 'orientation' }]));
+        /**
+         * The direction of navigation between items.
+         */
+        this.dirInput = input('ltr', ...(ngDevMode ? [{ debugName: "dirInput", alias: 'dir' }] : [{ alias: 'dir' }]));
+        /**
+         * Whether keyboard navigation should loop around
+         */
+        this.loopInput = input(true, ...(ngDevMode ? [{ debugName: "loopInput", transform: booleanAttribute, alias: 'loop' }] : [{ transform: booleanAttribute, alias: 'loop' }]));
+        /**
+         * When `true`, will prevent scrolling to the focus item when focused.
+         * @group Props
+         */
+        this.preventScrollOnEntryFocus = input(false, ...(ngDevMode ? [{ debugName: "preventScrollOnEntryFocus", transform: booleanAttribute }] : [{ transform: booleanAttribute }]));
+        /**
+         * The value of the current stop item.
+         *
+         * Use when you do not need to control the state of the stop item.
+         * @group Props
+         */
+        this.defaultCurrentTabStopId = input(undefined, ...(ngDevMode ? [{ debugName: "defaultCurrentTabStopId" }] : []));
+        /**
+         * The controlled value of the current stop item. Can be binded as `model`.
+         * @group Props
+         */
+        this.currentTabStopId = model(undefined, ...(ngDevMode ? [{ debugName: "currentTabStopId" }] : []));
+        /**
+         * Event handler called when container is being focused. Can be prevented.
+         * @group Emits
+         */
+        this.entryFocus = output();
+        this._orientation = linkedSignal(() => this.orientationInput(), ...(ngDevMode ? [{ debugName: "_orientation" }] : []));
+        this.orientation = this._orientation.asReadonly();
+        this._dir = linkedSignal(() => this.dirInput(), ...(ngDevMode ? [{ debugName: "_dir" }] : []));
+        this.dir = this._dir.asReadonly();
+        this._loop = linkedSignal(() => this.loopInput(), ...(ngDevMode ? [{ debugName: "_loop" }] : []));
+        this.loop = this._loop.asReadonly();
+        this.focusableItems = signal([], ...(ngDevMode ? [{ debugName: "focusableItems" }] : []));
+        this.isClickFocus = signal(false, ...(ngDevMode ? [{ debugName: "isClickFocus" }] : []));
+        this.isTabbingBackOut = signal(false, ...(ngDevMode ? [{ debugName: "isTabbingBackOut" }] : []));
+        this.focusableItemsCount = signal(0, ...(ngDevMode ? [{ debugName: "focusableItemsCount" }] : []));
+        effect(() => {
+            if (this.currentTabStopId() === undefined) {
+                const def = this.defaultCurrentTabStopId();
+                if (def !== undefined) {
+                    this.currentTabStopId.set(def);
+                }
+            }
+        });
     }
-    /** @ignore */
-    get dataOrientation() {
-        return this.orientation || 'horizontal';
+    setOrientation(value) {
+        this._orientation.set(value);
     }
-    /** @ignore */
-    get tabIndex() {
-        return this.isTabbingBackOut() || this.getFocusableItemsCount() === 0 ? -1 : 0;
+    setDir(value) {
+        this._dir.set(value);
     }
-    /** @ignore */
-    handleBlur() {
-        this.isTabbingBackOut.set(false);
+    setLoop(value) {
+        this._loop.set(value);
     }
     /** @ignore */
     handleMouseUp() {
+        if (!this.isBrowser)
+            return;
         // reset `isClickFocus` after 1 tick because handleFocus might not triggered due to focused element
-        this.ngZone.runOutsideAngular(() => {
-            // eslint-disable-next-line promise/catch-or-return,promise/always-return
-            Promise.resolve().then(() => {
-                this.ngZone.run(() => {
-                    this.isClickFocus.set(false);
-                });
-            });
+        requestAnimationFrame(() => {
+            this.isClickFocus.set(false);
         });
     }
     /** @ignore */
@@ -106,141 +176,98 @@ class RdxRovingFocusGroupDirective {
             if (!entryFocusEvent.defaultPrevented) {
                 const items = this.focusableItems().filter((item) => item.dataset['disabled'] !== '');
                 const activeItem = items.find((item) => item.getAttribute('data-active') === 'true');
+                const highlightedItem = items.find((item) => item.getAttribute('data-highlighted') === '');
                 const currentItem = items.find((item) => item.id === this.currentTabStopId());
-                const candidateItems = [activeItem, currentItem, ...items].filter(Boolean);
-                focusFirst(candidateItems, this.preventScrollOnEntryFocus);
+                const candidateItems = [activeItem, highlightedItem, currentItem, ...items].filter(Boolean);
+                focusFirst(candidateItems, this.preventScrollOnEntryFocus());
             }
         }
         this.isClickFocus.set(false);
     }
-    /** @ignore */
-    handleMouseDown() {
-        this.isClickFocus.set(true);
-    }
-    /** @ignore */
-    onItemFocus(tabStopId) {
-        this.currentTabStopId.set(tabStopId);
-        this.currentTabStopIdChange.emit(tabStopId);
-    }
-    /** @ignore */
-    onItemShiftTab() {
-        this.isTabbingBackOut.set(true);
-    }
-    /** @ignore */
-    onFocusableItemAdd() {
-        this.focusableItemsCount.update((count) => count + 1);
-    }
-    /** @ignore */
-    onFocusableItemRemove() {
-        this.focusableItemsCount.update((count) => Math.max(0, count - 1));
-    }
-    /** @ignore */
-    registerItem(item) {
-        const currentItems = this.focusableItems();
-        this.focusableItems.set([...currentItems, item]);
-    }
-    /** @ignore */
-    unregisterItem(item) {
-        const currentItems = this.focusableItems();
-        this.focusableItems.set(currentItems.filter((el) => el !== item));
-    }
-    /** @ignore */
-    getFocusableItemsCount() {
-        return this.focusableItemsCount();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxRovingFocusGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "19.2.4", type: RdxRovingFocusGroupDirective, isStandalone: true, selector: "[rdxRovingFocusGroup]", inputs: { orientation: "orientation", dir: "dir", loop: ["loop", "loop", booleanAttribute], preventScrollOnEntryFocus: ["preventScrollOnEntryFocus", "preventScrollOnEntryFocus", booleanAttribute] }, outputs: { entryFocus: "entryFocus", currentTabStopIdChange: "currentTabStopIdChange" }, host: { listeners: { "focus": "handleFocus($event)", "blur": "handleBlur()", "mouseup": "handleMouseUp()", "mousedown": "handleMouseDown()" }, properties: { "attr.data-orientation": "dataOrientation", "attr.tabindex": "tabIndex", "attr.dir": "dir" }, styleAttribute: "outline: none;" }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxRovingFocusGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.3", type: RdxRovingFocusGroupDirective, isStandalone: true, selector: "[rdxRovingFocusGroup]", inputs: { orientationInput: { classPropertyName: "orientationInput", publicName: "orientation", isSignal: true, isRequired: false, transformFunction: null }, dirInput: { classPropertyName: "dirInput", publicName: "dir", isSignal: true, isRequired: false, transformFunction: null }, loopInput: { classPropertyName: "loopInput", publicName: "loop", isSignal: true, isRequired: false, transformFunction: null }, preventScrollOnEntryFocus: { classPropertyName: "preventScrollOnEntryFocus", publicName: "preventScrollOnEntryFocus", isSignal: true, isRequired: false, transformFunction: null }, defaultCurrentTabStopId: { classPropertyName: "defaultCurrentTabStopId", publicName: "defaultCurrentTabStopId", isSignal: true, isRequired: false, transformFunction: null }, currentTabStopId: { classPropertyName: "currentTabStopId", publicName: "currentTabStopId", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { currentTabStopId: "currentTabStopIdChange", entryFocus: "entryFocus" }, host: { listeners: { "focus": "handleFocus($event)", "blur": "isTabbingBackOut.set(false)", "mouseup": "handleMouseUp()", "mousedown": "isClickFocus.set(true)" }, properties: { "attr.data-orientation": "orientation()", "attr.tabindex": "isTabbingBackOut() || focusableItemsCount() === 0 ? -1 : 0", "attr.dir": "dir()" }, styleAttribute: "outline: none;" }, providers: [provideRovingFocusGroupContext(rootContext)], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxRovingFocusGroupDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxRovingFocusGroupDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxRovingFocusGroup]',
-                    standalone: true,
+                    providers: [provideRovingFocusGroupContext(rootContext)],
                     host: {
-                        '[attr.data-orientation]': 'dataOrientation',
-                        '[attr.tabindex]': 'tabIndex',
-                        '[attr.dir]': 'dir',
+                        '[attr.data-orientation]': 'orientation()',
+                        '[attr.tabindex]': 'isTabbingBackOut() || focusableItemsCount() === 0 ? -1 : 0',
+                        '[attr.dir]': 'dir()',
                         '(focus)': 'handleFocus($event)',
-                        '(blur)': 'handleBlur()',
+                        '(blur)': 'isTabbingBackOut.set(false)',
                         '(mouseup)': 'handleMouseUp()',
-                        '(mousedown)': 'handleMouseDown()',
+                        '(mousedown)': 'isClickFocus.set(true)',
                         style: 'outline: none;'
                     }
                 }]
-        }], propDecorators: { orientation: [{
-                type: Input
-            }], dir: [{
-                type: Input
-            }], loop: [{
-                type: Input,
-                args: [{ transform: booleanAttribute }]
-            }], preventScrollOnEntryFocus: [{
-                type: Input,
-                args: [{ transform: booleanAttribute }]
-            }], entryFocus: [{
-                type: Output
-            }], currentTabStopIdChange: [{
-                type: Output
-            }] } });
+        }], ctorParameters: () => [] });
 
+/**
+ * @group Components
+ */
 class RdxRovingFocusItemDirective {
     constructor() {
+        this.isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+        this.destroyRef = inject(DestroyRef);
         this.elementRef = inject(ElementRef);
-        this.ngZone = inject(NgZone);
-        this.parent = inject(RdxRovingFocusGroupDirective);
-        this.focusable = true;
-        this.active = true;
-        this.allowShiftKey = false;
-        this.id = computed(() => this.tabStopId || generateId());
-        /** @ignore */
-        this.isCurrentTabStop = computed(() => this.parent.currentTabStopId() === this.id());
-    }
-    /**
-     * Lifecycle hook triggered on initialization.
-     * Registers the element with the parent roving focus group if it is focusable.
-     * @ignore
-     */
-    ngOnInit() {
-        if (this.focusable) {
-            this.parent.registerItem(this.elementRef.nativeElement);
-            this.parent.onFocusableItemAdd();
+        this.rootContext = injectRovingFocusGroupContext();
+        /**
+         * When false, item will not be focusable.
+         * @group Props
+         */
+        this.focusableInput = input(true, ...(ngDevMode ? [{ debugName: "focusableInput", transform: booleanAttribute, alias: 'focusable' }] : [{ transform: booleanAttribute, alias: 'focusable' }]));
+        /**
+         * When `true`, item will be initially focused.
+         * @group Props
+         */
+        this.activeInput = input(true, ...(ngDevMode ? [{ debugName: "activeInput", transform: booleanAttribute, alias: 'active' }] : [{ transform: booleanAttribute, alias: 'active' }]));
+        /**
+         * @group Props
+         */
+        this.tabStopIdInput = input(undefined, ...(ngDevMode ? [{ debugName: "tabStopIdInput", alias: 'tabStopId' }] : [{ alias: 'tabStopId' }]));
+        /**
+         * When true, shift + arrow key will allow focusing on next/previous item.
+         * @group Props
+         */
+        this.allowShiftKey = input(false, ...(ngDevMode ? [{ debugName: "allowShiftKey", transform: booleanAttribute }] : [{ transform: booleanAttribute }]));
+        this.id = computed(() => this.tabStopId() || generateId(), ...(ngDevMode ? [{ debugName: "id" }] : []));
+        this.isCurrentTabStop = computed(() => this.rootContext.currentTabStopId() === this.id(), ...(ngDevMode ? [{ debugName: "isCurrentTabStop" }] : []));
+        this.focusable = linkedSignal(() => this.focusableInput(), ...(ngDevMode ? [{ debugName: "focusable" }] : []));
+        this.active = linkedSignal(() => this.activeInput(), ...(ngDevMode ? [{ debugName: "active" }] : []));
+        this.tabStopId = linkedSignal(() => this.tabStopIdInput(), ...(ngDevMode ? [{ debugName: "tabStopId" }] : []));
+        if (this.focusable()) {
+            this.rootContext.registerItem(this.elementRef.nativeElement);
+            this.rootContext.onFocusableItemAdd();
+            this.destroyRef.onDestroy(() => {
+                this.rootContext.unregisterItem(this.elementRef.nativeElement);
+                this.rootContext.onFocusableItemRemove();
+            });
         }
     }
-    /**
-     * Lifecycle hook triggered on destruction.
-     * Unregisters the element from the parent roving focus group if it is focusable.
-     * @ignore
-     */
-    ngOnDestroy() {
-        if (this.focusable) {
-            this.parent.unregisterItem(this.elementRef.nativeElement);
-            this.parent.onFocusableItemRemove();
-        }
+    setFocusable(value) {
+        this.focusable.set(value);
     }
-    /**
-     * Determines the `tabIndex` of the element.
-     * Returns `0` if the element is the current tab stop; otherwise, returns `-1`.
-     * @ignore
-     */
-    get tabIndex() {
-        return this.isCurrentTabStop() ? 0 : -1;
+    setActive(value) {
+        this.active.set(value);
+    }
+    setTabStopId(value) {
+        this.tabStopId.set(value);
     }
     /** @ignore */
     handleMouseDown(event) {
-        if (!this.focusable) {
+        if (!this.focusable()) {
             // We prevent focusing non-focusable items on `mousedown`.
             // Even though the item has tabIndex={-1}, that only means take it out of the tab order.
             event.preventDefault();
         }
         else {
             // Safari doesn't focus a button when clicked so we run our logic on mousedown also
-            this.parent.onItemFocus(this.id());
+            this.rootContext.onItemFocus(this.id());
         }
     }
-    /** @ignore */
-    onFocus() {
-        this.parent.onItemFocus(this.id());
-    }
     /**
      * Handles the `keydown` event for keyboard navigation within the roving focus group.
      * Supports navigation based on orientation and direction, and focuses appropriate elements.
@@ -250,18 +277,18 @@ class RdxRovingFocusItemDirective {
      */
     handleKeydown(event) {
         if (event.key === 'Tab' && event.shiftKey) {
-            this.parent.onItemShiftTab();
+            this.rootContext.onItemShiftTab();
             return;
         }
         if (event.target !== this.elementRef.nativeElement)
             return;
-        const focusIntent = getFocusIntent(event, this.parent.orientation, this.parent.dir);
+        const focusIntent = getFocusIntent(event, this.rootContext.orientation(), this.rootContext.dir());
         if (focusIntent !== undefined) {
-            if (event.metaKey || event.ctrlKey || event.altKey || (this.allowShiftKey ? false : event.shiftKey)) {
+            if (event.metaKey || event.ctrlKey || event.altKey || (this.allowShiftKey() ? false : event.shiftKey)) {
                 return;
             }
             event.preventDefault();
-            let candidateNodes = this.parent.focusableItems().filter((item) => item.dataset['disabled'] !== '');
+            let candidateNodes = this.rootContext.focusableItems().filter((item) => item.dataset['disabled'] !== '');
             if (focusIntent === 'last') {
                 candidateNodes.reverse();
             }
@@ -269,52 +296,41 @@ class RdxRovingFocusItemDirective {
                 if (focusIntent === 'prev')
                     candidateNodes.reverse();
                 const currentIndex = candidateNodes.indexOf(this.elementRef.nativeElement);
-                candidateNodes = this.parent.loop
+                candidateNodes = this.rootContext.loop()
                     ? wrapArray(candidateNodes, currentIndex + 1)
                     : candidateNodes.slice(currentIndex + 1);
             }
-            this.ngZone.runOutsideAngular(() => {
-                // eslint-disable-next-line promise/always-return,promise/catch-or-return
-                Promise.resolve().then(() => {
+            queueMicrotask(() => {
+                if (this.isBrowser) {
                     focusFirst(candidateNodes, false, this.elementRef.nativeElement);
-                });
+                }
             });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxRovingFocusItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "19.2.4", type: RdxRovingFocusItemDirective, isStandalone: true, selector: "[rdxRovingFocusItem]", inputs: { focusable: ["focusable", "focusable", booleanAttribute], active: ["active", "active", booleanAttribute], tabStopId: "tabStopId", allowShiftKey: ["allowShiftKey", "allowShiftKey", booleanAttribute] }, host: { listeners: { "mousedown": "handleMouseDown($event)", "keydown": "handleKeydown($event)", "focus": "onFocus()" }, properties: { "attr.tabindex": "tabIndex", "attr.data-orientation": "parent.orientation", "attr.data-active": "active", "attr.data-disabled": "!focusable ? \"\" : undefined" } }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxRovingFocusItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.3", type: RdxRovingFocusItemDirective, isStandalone: true, selector: "[rdxRovingFocusItem]", inputs: { focusableInput: { classPropertyName: "focusableInput", publicName: "focusable", isSignal: true, isRequired: false, transformFunction: null }, activeInput: { classPropertyName: "activeInput", publicName: "active", isSignal: true, isRequired: false, transformFunction: null }, tabStopIdInput: { classPropertyName: "tabStopIdInput", publicName: "tabStopId", isSignal: true, isRequired: false, transformFunction: null }, allowShiftKey: { classPropertyName: "allowShiftKey", publicName: "allowShiftKey", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "mousedown": "handleMouseDown($event)", "keydown": "handleKeydown($event)", "focus": "rootContext.onItemFocus(id())" }, properties: { "attr.tabindex": "isCurrentTabStop() ? 0 : -1", "attr.data-orientation": "rootContext.orientation", "attr.data-active": "active()", "attr.data-disabled": "!focusable() ? \"\" : undefined" } }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: RdxRovingFocusItemDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: RdxRovingFocusItemDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxRovingFocusItem]',
-                    standalone: true,
                     host: {
-                        '[attr.tabindex]': 'tabIndex',
-                        '[attr.data-orientation]': 'parent.orientation',
-                        '[attr.data-active]': 'active',
-                        '[attr.data-disabled]': '!focusable ? "" : undefined',
+                        '[attr.tabindex]': 'isCurrentTabStop() ? 0 : -1',
+                        '[attr.data-orientation]': 'rootContext.orientation',
+                        '[attr.data-active]': 'active()',
+                        '[attr.data-disabled]': '!focusable() ? "" : undefined',
                         '(mousedown)': 'handleMouseDown($event)',
                         '(keydown)': 'handleKeydown($event)',
-                        '(focus)': 'onFocus()'
+                        '(focus)': 'rootContext.onItemFocus(id())'
                     }
                 }]
-        }], propDecorators: { focusable: [{
-                type: Input,
-                args: [{ transform: booleanAttribute }]
-            }], active: [{
-                type: Input,
-                args: [{ transform: booleanAttribute }]
-            }], tabStopId: [{
-                type: Input
-            }], allowShiftKey: [{
-                type: Input,
-                args: [{ transform: booleanAttribute }]
-            }] } });
+        }], ctorParameters: () => [] });
+
+const rovingFocusImports = [RdxRovingFocusGroupDirective, RdxRovingFocusItemDirective];
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { RdxRovingFocusGroupDirective, RdxRovingFocusItemDirective };
+export { RdxRovingFocusGroupDirective, RdxRovingFocusItemDirective, injectRovingFocusGroupContext, provideRovingFocusGroupContext, rovingFocusImports };
 //# sourceMappingURL=radix-ng-primitives-roving-focus.mjs.map