ng-primitives 0.0.5

package/esm2022/roving-focus/roving-focus-group/roving-focus-group.directive.mjs

@@ -0,0 +1,244 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { Directive, Input, booleanAttribute, inject, input, signal } from '@angular/core';
+import { NgpRovingFocusGroupToken } from './roving-focus-group.token';
+import * as i0 from "@angular/core";
+export class NgpRovingFocusGroup {
+    constructor() {
+        /**
+         * Access the directionality service.
+         */
+        this.directionality = inject(Directionality);
+        /**
+         * Determine the orientation of the roving focus group.
+         * @default 'vertical'
+         * @summary This does not use a signal as we need this to be programmatically settable when used as a host directive.
+         */
+        this.orientation = 'vertical';
+        /**
+         * Determine if focus should wrap when the end or beginning is reached.
+         */
+        this.wrap = input(true, {
+            alias: 'ngpRovingFocusGroupWrap',
+            transform: booleanAttribute,
+        });
+        /**
+         * Determine if the home and end keys should navigate to the first and last items.
+         */
+        this.homeEnd = input(true, {
+            alias: 'ngpRovingFocusGroupHomeEnd',
+            transform: booleanAttribute,
+        });
+        /**
+         * Determine if the roving focus group is disabled.
+         */
+        this.disabled = input(false, {
+            alias: 'ngpRovingFocusGroupDisabled',
+            transform: booleanAttribute,
+        });
+        /**
+         * Store the items in the roving focus group.
+         */
+        this.items = signal([]);
+        /**
+         * Store the active item in the roving focus group.
+         * @internal
+         */
+        this.activeItem = signal(null);
+    }
+    /**
+     * Get the items in the roving focus group sorted by order.
+     */
+    get sortedItems() {
+        return this.items().sort((a, b) => {
+            // sort the items by their position in the document
+            return a.elementRef.nativeElement.compareDocumentPosition(b.elementRef.nativeElement) &
+                Node.DOCUMENT_POSITION_FOLLOWING
+                ? -1
+                : 1;
+        });
+    }
+    /**
+     * Register an item with the roving focus group.
+     * @param item The item to register
+     * @internal
+     */
+    register(item) {
+        this.items.update(items => [...items, item]);
+        // if there is no active item, make the first item the tabbable item
+        if (!this.activeItem()) {
+            this.activeItem.set(item);
+        }
+    }
+    /**
+     * Unregister an item with the roving focus group.
+     * @param item The item to unregister
+     * @internal
+     */
+    unregister(item) {
+        this.items.update(items => items.filter(i => i !== item));
+        // check if the unregistered item is the active item
+        if (this.activeItem() === item) {
+            // if the active item is unregistered, activate the first item
+            this.activeItem.set(this.items()[0] ?? null);
+        }
+    }
+    /**
+     * Activate an item in the roving focus group.
+     * @param item The item to activate
+     * @param origin The origin of the focus change
+     */
+    setActiveItem(item, origin = 'program') {
+        this.activeItem.set(item);
+        item?.focus(origin);
+    }
+    /**
+     * Activate the first item in the roving focus group.
+     * @param origin The origin of the focus change
+     */
+    activateFirstItem(origin) {
+        // find the first item that is not disabled
+        const item = this.sortedItems.find(i => !i.disabled()) ?? null;
+        // set the first item as the active item
+        this.setActiveItem(item, origin);
+    }
+    /**
+     * Activate the last item in the roving focus group.
+     * @param origin The origin of the focus change
+     */
+    activateLastItem(origin) {
+        // find the last item that is not disabled
+        const item = [...this.sortedItems].reverse().find(i => !i.disabled()) ?? null;
+        // set the last item as the active item
+        this.setActiveItem(item, origin);
+    }
+    /**
+     * Activate the next item in the roving focus group.
+     * @param origin The origin of the focus change
+     */
+    activateNextItem(origin) {
+        const activeItem = this.activeItem();
+        // if there is no active item, activate the first item
+        if (!activeItem) {
+            this.activateFirstItem(origin);
+            return;
+        }
+        // find the index of the active item
+        const index = this.sortedItems.indexOf(activeItem);
+        // find the next item that is not disabled
+        const item = this.sortedItems.slice(index + 1).find(i => !i.disabled()) ?? null;
+        // if we are at the end of the list, wrap to the beginning
+        if (!item && this.wrap()) {
+            this.activateFirstItem(origin);
+            return;
+        }
+        // if there is no next item, do nothing
+        if (!item) {
+            return;
+        }
+        // set the next item as the active item
+        this.setActiveItem(item, origin);
+    }
+    /**
+     * Activate the previous item in the roving focus group.
+     * @param origin The origin of the focus change
+     */
+    activatePreviousItem(origin) {
+        const activeItem = this.activeItem();
+        // if there is no active item, activate the last item
+        if (!activeItem) {
+            this.activateLastItem(origin);
+            return;
+        }
+        // find the index of the active item
+        const index = this.sortedItems.indexOf(activeItem);
+        // find the previous item that is not disabled
+        const item = this.sortedItems
+            .slice(0, index)
+            .reverse()
+            .find(i => !i.disabled()) ?? null;
+        // if we are at the beginning of the list, wrap to the end
+        if (!item && this.wrap()) {
+            this.activateLastItem(origin);
+            return;
+        }
+        // if there is no previous item, do nothing
+        if (!item) {
+            return;
+        }
+        // set the previous item as the active item
+        this.setActiveItem(item, origin);
+    }
+    /**
+     * Handle keyboard navigation for the roving focus group.
+     * @param event The keyboard event
+     * @internal
+     */
+    onKeydown(event) {
+        if (this.disabled()) {
+            return;
+        }
+        switch (event.key) {
+            case 'ArrowUp':
+                if (this.orientation === 'vertical') {
+                    event.preventDefault();
+                    this.activatePreviousItem('keyboard');
+                }
+                break;
+            case 'ArrowDown':
+                if (this.orientation === 'vertical') {
+                    event.preventDefault();
+                    this.activateNextItem('keyboard');
+                }
+                break;
+            case 'ArrowLeft':
+                if (this.orientation === 'horizontal') {
+                    event.preventDefault();
+                    if (this.directionality.value === 'ltr') {
+                        this.activatePreviousItem('keyboard');
+                    }
+                    else {
+                        this.activateNextItem('keyboard');
+                    }
+                }
+                break;
+            case 'ArrowRight':
+                if (this.orientation === 'horizontal') {
+                    event.preventDefault();
+                    if (this.directionality.value === 'ltr') {
+                        this.activateNextItem('keyboard');
+                    }
+                    else {
+                        this.activatePreviousItem('keyboard');
+                    }
+                }
+                break;
+            case 'Home':
+                if (this.homeEnd()) {
+                    event.preventDefault();
+                    this.activateFirstItem('keyboard');
+                }
+                break;
+            case 'End':
+                if (this.homeEnd()) {
+                    event.preventDefault();
+                    this.activateLastItem('keyboard');
+                }
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpRovingFocusGroup, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.2", type: NgpRovingFocusGroup, isStandalone: true, selector: "[ngpRovingFocusGroup]", inputs: { orientation: { classPropertyName: "orientation", publicName: "ngpRovingFocusGroupOrientation", isSignal: false, isRequired: false, transformFunction: null }, wrap: { classPropertyName: "wrap", publicName: "ngpRovingFocusGroupWrap", isSignal: true, isRequired: false, transformFunction: null }, homeEnd: { classPropertyName: "homeEnd", publicName: "ngpRovingFocusGroupHomeEnd", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "ngpRovingFocusGroupDisabled", isSignal: true, isRequired: false, transformFunction: null } }, providers: [{ provide: NgpRovingFocusGroupToken, useExisting: NgpRovingFocusGroup }], exportAs: ["ngpRovingFocusGroup"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpRovingFocusGroup, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpRovingFocusGroup]',
+                    exportAs: 'ngpRovingFocusGroup',
+                    providers: [{ provide: NgpRovingFocusGroupToken, useExisting: NgpRovingFocusGroup }],
+                }]
+        }], propDecorators: { orientation: [{
+                type: Input,
+                args: [{ alias: 'ngpRovingFocusGroupOrientation' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"roving-focus-group.directive.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/roving-focus/src/roving-focus-group/roving-focus-group.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright © 2024 Angular Primitives.\n * https://github.com/ng-primitives/ng-primitives\n *\n * This source code is licensed under the CC BY-ND 4.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\nimport { FocusOrigin } from '@angular/cdk/a11y';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { BooleanInput } from '@angular/cdk/coercion';\nimport { Directive, Input, booleanAttribute, inject, input, signal } from '@angular/core';\nimport { NgpRovingFocusItem } from '../roving-focus-item/roving-focus-item.directive';\nimport { NgpRovingFocusGroupToken } from './roving-focus-group.token';\n\n@Directive({\n  standalone: true,\n  selector: '[ngpRovingFocusGroup]',\n  exportAs: 'ngpRovingFocusGroup',\n  providers: [{ provide: NgpRovingFocusGroupToken, useExisting: NgpRovingFocusGroup }],\n})\nexport class NgpRovingFocusGroup {\n  /**\n   * Access the directionality service.\n   */\n  private readonly directionality = inject(Directionality);\n\n  /**\n   * Determine the orientation of the roving focus group.\n   * @default 'vertical'\n   * @summary This does not use a signal as we need this to be programmatically settable when used as a host directive.\n   */\n  @Input({ alias: 'ngpRovingFocusGroupOrientation' }) orientation: 'horizontal' | 'vertical' =\n    'vertical';\n\n  /**\n   * Determine if focus should wrap when the end or beginning is reached.\n   */\n  readonly wrap = input<boolean, BooleanInput>(true, {\n    alias: 'ngpRovingFocusGroupWrap',\n    transform: booleanAttribute,\n  });\n\n  /**\n   * Determine if the home and end keys should navigate to the first and last items.\n   */\n  readonly homeEnd = input<boolean, BooleanInput>(true, {\n    alias: 'ngpRovingFocusGroupHomeEnd',\n    transform: booleanAttribute,\n  });\n\n  /**\n   * Determine if the roving focus group is disabled.\n   */\n  readonly disabled = input<boolean, BooleanInput>(false, {\n    alias: 'ngpRovingFocusGroupDisabled',\n    transform: booleanAttribute,\n  });\n\n  /**\n   * Store the items in the roving focus group.\n   */\n  private readonly items = signal<NgpRovingFocusItem[]>([]);\n\n  /**\n   * Get the items in the roving focus group sorted by order.\n   */\n  private get sortedItems() {\n    return this.items().sort((a, b) => {\n      // sort the items by their position in the document\n      return a.elementRef.nativeElement.compareDocumentPosition(b.elementRef.nativeElement) &\n        Node.DOCUMENT_POSITION_FOLLOWING\n        ? -1\n        : 1;\n    });\n  }\n\n  /**\n   * Store the active item in the roving focus group.\n   * @internal\n   */\n  readonly activeItem = signal<NgpRovingFocusItem | null>(null);\n\n  /**\n   * Register an item with the roving focus group.\n   * @param item The item to register\n   * @internal\n   */\n  register(item: NgpRovingFocusItem): void {\n    this.items.update(items => [...items, item]);\n\n    // if there is no active item, make the first item the tabbable item\n    if (!this.activeItem()) {\n      this.activeItem.set(item);\n    }\n  }\n\n  /**\n   * Unregister an item with the roving focus group.\n   * @param item The item to unregister\n   * @internal\n   */\n  unregister(item: NgpRovingFocusItem): void {\n    this.items.update(items => items.filter(i => i !== item));\n\n    // check if the unregistered item is the active item\n    if (this.activeItem() === item) {\n      // if the active item is unregistered, activate the first item\n      this.activeItem.set(this.items()[0] ?? null);\n    }\n  }\n\n  /**\n   * Activate an item in the roving focus group.\n   * @param item The item to activate\n   * @param origin The origin of the focus change\n   */\n  setActiveItem(item: NgpRovingFocusItem | null, origin: FocusOrigin = 'program'): void {\n    this.activeItem.set(item);\n    item?.focus(origin);\n  }\n\n  /**\n   * Activate the first item in the roving focus group.\n   * @param origin The origin of the focus change\n   */\n  private activateFirstItem(origin: FocusOrigin): void {\n    // find the first item that is not disabled\n    const item = this.sortedItems.find(i => !i.disabled()) ?? null;\n\n    // set the first item as the active item\n    this.setActiveItem(item, origin);\n  }\n\n  /**\n   * Activate the last item in the roving focus group.\n   * @param origin The origin of the focus change\n   */\n  private activateLastItem(origin: FocusOrigin): void {\n    // find the last item that is not disabled\n    const item = [...this.sortedItems].reverse().find(i => !i.disabled()) ?? null;\n\n    // set the last item as the active item\n    this.setActiveItem(item, origin);\n  }\n\n  /**\n   * Activate the next item in the roving focus group.\n   * @param origin The origin of the focus change\n   */\n  private activateNextItem(origin: FocusOrigin): void {\n    const activeItem = this.activeItem();\n\n    // if there is no active item, activate the first item\n    if (!activeItem) {\n      this.activateFirstItem(origin);\n      return;\n    }\n\n    // find the index of the active item\n    const index = this.sortedItems.indexOf(activeItem);\n\n    // find the next item that is not disabled\n    const item = this.sortedItems.slice(index + 1).find(i => !i.disabled()) ?? null;\n\n    // if we are at the end of the list, wrap to the beginning\n    if (!item && this.wrap()) {\n      this.activateFirstItem(origin);\n      return;\n    }\n\n    // if there is no next item, do nothing\n    if (!item) {\n      return;\n    }\n\n    // set the next item as the active item\n    this.setActiveItem(item, origin);\n  }\n\n  /**\n   * Activate the previous item in the roving focus group.\n   * @param origin The origin of the focus change\n   */\n  private activatePreviousItem(origin: FocusOrigin): void {\n    const activeItem = this.activeItem();\n\n    // if there is no active item, activate the last item\n    if (!activeItem) {\n      this.activateLastItem(origin);\n      return;\n    }\n\n    // find the index of the active item\n    const index = this.sortedItems.indexOf(activeItem);\n\n    // find the previous item that is not disabled\n    const item =\n      this.sortedItems\n        .slice(0, index)\n        .reverse()\n        .find(i => !i.disabled()) ?? null;\n\n    // if we are at the beginning of the list, wrap to the end\n    if (!item && this.wrap()) {\n      this.activateLastItem(origin);\n      return;\n    }\n\n    // if there is no previous item, do nothing\n    if (!item) {\n      return;\n    }\n\n    // set the previous item as the active item\n    this.setActiveItem(item, origin);\n  }\n\n  /**\n   * Handle keyboard navigation for the roving focus group.\n   * @param event The keyboard event\n   * @internal\n   */\n  onKeydown(event: KeyboardEvent): void {\n    if (this.disabled()) {\n      return;\n    }\n\n    switch (event.key) {\n      case 'ArrowUp':\n        if (this.orientation === 'vertical') {\n          event.preventDefault();\n          this.activatePreviousItem('keyboard');\n        }\n        break;\n      case 'ArrowDown':\n        if (this.orientation === 'vertical') {\n          event.preventDefault();\n          this.activateNextItem('keyboard');\n        }\n        break;\n      case 'ArrowLeft':\n        if (this.orientation === 'horizontal') {\n          event.preventDefault();\n\n          if (this.directionality.value === 'ltr') {\n            this.activatePreviousItem('keyboard');\n          } else {\n            this.activateNextItem('keyboard');\n          }\n        }\n        break;\n      case 'ArrowRight':\n        if (this.orientation === 'horizontal') {\n          event.preventDefault();\n\n          if (this.directionality.value === 'ltr') {\n            this.activateNextItem('keyboard');\n          } else {\n            this.activatePreviousItem('keyboard');\n          }\n        }\n        break;\n      case 'Home':\n        if (this.homeEnd()) {\n          event.preventDefault();\n          this.activateFirstItem('keyboard');\n        }\n        break;\n      case 'End':\n        if (this.homeEnd()) {\n          event.preventDefault();\n          this.activateLastItem('keyboard');\n        }\n        break;\n    }\n  }\n}\n"]}

package/esm2022/roving-focus/roving-focus-group/roving-focus-group.token.mjs

@@ -0,0 +1,17 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the CC BY-ND 4.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { InjectionToken, inject } from '@angular/core';
+export const NgpRovingFocusGroupToken = new InjectionToken('NgpRovingFocusGroupToken');
+/**
+ * Inject the RovingFocusGroup directive instance
+ * @returns The RovingFocusGroup directive instance
+ */
+export function injectRovingFocusGroup() {
+    return inject(NgpRovingFocusGroupToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm92aW5nLWZvY3VzLWdyb3VwLnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctcHJpbWl0aXZlcy9yb3ZpbmctZm9jdXMvc3JjL3JvdmluZy1mb2N1cy1ncm91cC9yb3ZpbmctZm9jdXMtZ3JvdXAudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHdkQsTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBQUcsSUFBSSxjQUFjLENBQ3hELDBCQUEwQixDQUMzQixDQUFDO0FBRUY7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLHNCQUFzQjtJQUNwQyxPQUFPLE1BQU0sQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0FBQzFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCDCqSAyMDI0IEFuZ3VsYXIgUHJpbWl0aXZlcy5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9uZy1wcmltaXRpdmVzL25nLXByaW1pdGl2ZXNcbiAqXG4gKiBUaGlzIHNvdXJjZSBjb2RlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBDQyBCWS1ORCA0LjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHR5cGUgeyBOZ3BSb3ZpbmdGb2N1c0dyb3VwIH0gZnJvbSAnLi9yb3ZpbmctZm9jdXMtZ3JvdXAuZGlyZWN0aXZlJztcblxuZXhwb3J0IGNvbnN0IE5ncFJvdmluZ0ZvY3VzR3JvdXBUb2tlbiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxOZ3BSb3ZpbmdGb2N1c0dyb3VwPihcbiAgJ05ncFJvdmluZ0ZvY3VzR3JvdXBUb2tlbicsXG4pO1xuXG4vKipcbiAqIEluamVjdCB0aGUgUm92aW5nRm9jdXNHcm91cCBkaXJlY3RpdmUgaW5zdGFuY2VcbiAqIEByZXR1cm5zIFRoZSBSb3ZpbmdGb2N1c0dyb3VwIGRpcmVjdGl2ZSBpbnN0YW5jZVxuICovXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0Um92aW5nRm9jdXNHcm91cCgpOiBOZ3BSb3ZpbmdGb2N1c0dyb3VwIHtcbiAgcmV0dXJuIGluamVjdChOZ3BSb3ZpbmdGb2N1c0dyb3VwVG9rZW4pO1xufVxuIl19

package/esm2022/roving-focus/roving-focus-item/roving-focus-item.directive.mjs

@@ -0,0 +1,98 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the CC BY-ND 4.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { Directive, ElementRef, HostListener, booleanAttribute, computed, inject, input, } from '@angular/core';
+import { injectRovingFocusGroup } from '../roving-focus-group/roving-focus-group.token';
+import { NgpRovingFocusItemToken } from './roving-focus-item.token';
+import * as i0 from "@angular/core";
+export class NgpRovingFocusItem {
+    constructor() {
+        /**
+         * Access the group the roving focus item belongs to.
+         */
+        this.group = injectRovingFocusGroup();
+        /**
+         * Access the focus monitor service.
+         */
+        this.focusMonitor = inject(FocusMonitor);
+        /**
+         * Access the element the roving focus item is attached to.
+         */
+        this.elementRef = inject(ElementRef);
+        /**
+         * Define if the item is disabled.
+         */
+        this.disabled = input(false, {
+            alias: 'ngpRovingFocusItemDisabled',
+            transform: booleanAttribute,
+        });
+        /**
+         * Derive the tabindex of the roving focus item.
+         */
+        this.tabindex = computed(() => !this.group.disabled() && this.group.activeItem() === this ? 0 : -1);
+    }
+    /**
+     * Initialize the roving focus item.
+     */
+    ngOnInit() {
+        this.group.register(this);
+    }
+    /**
+     * Clean up the roving focus item.
+     */
+    ngOnDestroy() {
+        this.group.unregister(this);
+    }
+    /**
+     * Forward the keydown event to the roving focus group.
+     * @param event The keyboard event
+     */
+    onKeydown(event) {
+        if (this.disabled()) {
+            return;
+        }
+        this.group.onKeydown(event);
+    }
+    /**
+     * Activate the roving focus item on click.
+     */
+    activate() {
+        if (this.disabled()) {
+            return;
+        }
+        this.group.setActiveItem(this, 'mouse');
+    }
+    /**
+     * Focus the roving focus item.
+     * @param origin The origin of the focus
+     */
+    focus(origin) {
+        this.focusMonitor.focusVia(this.elementRef, origin);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpRovingFocusItem, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.2", type: NgpRovingFocusItem, isStandalone: true, selector: "[ngpRovingFocusItem]", inputs: { disabled: { classPropertyName: "disabled", publicName: "ngpRovingFocusItemDisabled", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "keydown": "onKeydown($event)", "click": "activate()" }, properties: { "attr.tabindex": "tabindex()" } }, providers: [{ provide: NgpRovingFocusItemToken, useExisting: NgpRovingFocusItem }], exportAs: ["ngpRovingFocusItem"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpRovingFocusItem, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpRovingFocusItem]',
+                    exportAs: 'ngpRovingFocusItem',
+                    providers: [{ provide: NgpRovingFocusItemToken, useExisting: NgpRovingFocusItem }],
+                    host: {
+                        '[attr.tabindex]': 'tabindex()',
+                    },
+                }]
+        }], propDecorators: { onKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], activate: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/roving-focus/roving-focus-item/roving-focus-item.token.mjs

@@ -0,0 +1,17 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the CC BY-ND 4.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { InjectionToken, inject } from '@angular/core';
+export const NgpRovingFocusItemToken = new InjectionToken('NgpRovingFocusItemToken');
+/**
+ * Inject the RovingFocusItem directive instance
+ * @returns The RovingFocusItem directive instance
+ */
+export function injectRovingFocusItem() {
+    return inject(NgpRovingFocusItemToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm92aW5nLWZvY3VzLWl0ZW0udG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL3JvdmluZy1mb2N1cy9zcmMvcm92aW5nLWZvY3VzLWl0ZW0vcm92aW5nLWZvY3VzLWl0ZW0udG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHdkQsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsSUFBSSxjQUFjLENBQ3ZELHlCQUF5QixDQUMxQixDQUFDO0FBRUY7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQjtJQUNuQyxPQUFPLE1BQU0sQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO0FBQ3pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCDCqSAyMDI0IEFuZ3VsYXIgUHJpbWl0aXZlcy5cbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9uZy1wcmltaXRpdmVzL25nLXByaW1pdGl2ZXNcbiAqXG4gKiBUaGlzIHNvdXJjZSBjb2RlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBDQyBCWS1ORCA0LjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHR5cGUgeyBOZ3BSb3ZpbmdGb2N1c0l0ZW0gfSBmcm9tICcuL3JvdmluZy1mb2N1cy1pdGVtLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCBjb25zdCBOZ3BSb3ZpbmdGb2N1c0l0ZW1Ub2tlbiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxOZ3BSb3ZpbmdGb2N1c0l0ZW0+KFxuICAnTmdwUm92aW5nRm9jdXNJdGVtVG9rZW4nLFxuKTtcblxuLyoqXG4gKiBJbmplY3QgdGhlIFJvdmluZ0ZvY3VzSXRlbSBkaXJlY3RpdmUgaW5zdGFuY2VcbiAqIEByZXR1cm5zIFRoZSBSb3ZpbmdGb2N1c0l0ZW0gZGlyZWN0aXZlIGluc3RhbmNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3RSb3ZpbmdGb2N1c0l0ZW0oKTogTmdwUm92aW5nRm9jdXNJdGVtIHtcbiAgcmV0dXJuIGluamVjdChOZ3BSb3ZpbmdGb2N1c0l0ZW1Ub2tlbik7XG59XG4iXX0=

package/esm2022/select/index.mjs

@@ -0,0 +1,16 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the CC BY-ND 4.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export { NgpSelectButton } from './select-button/select-button.directive';
+export { NgpSelectButtonToken } from './select-button/select-button.token';
+export { NgpSelectOption } from './select-option/select-option.directive';
+export { NgpSelectOptionToken } from './select-option/select-option.token';
+export { NgpSelectOptions } from './select-options/select-options.directive';
+export { NgpSelectOptionsToken } from './select-options/select-options.token';
+export { NgpSelect } from './select/select.directive';
+export { NgpSelectToken } from './select/select.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL3NlbGVjdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQzFFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzNFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQUMxRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUMzRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUM3RSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDdEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgwqkgMjAyNCBBbmd1bGFyIFByaW1pdGl2ZXMuXG4gKiBodHRwczovL2dpdGh1Yi5jb20vbmctcHJpbWl0aXZlcy9uZy1wcmltaXRpdmVzXG4gKlxuICogVGhpcyBzb3VyY2UgY29kZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQ0MgQlktTkQgNC4wIGxpY2Vuc2UgZm91bmQgaW4gdGhlXG4gKiBMSUNFTlNFIGZpbGUgaW4gdGhlIHJvb3QgZGlyZWN0b3J5IG9mIHRoaXMgc291cmNlIHRyZWUuXG4gKi9cblxuZXhwb3J0IHsgTmdwU2VsZWN0QnV0dG9uIH0gZnJvbSAnLi9zZWxlY3QtYnV0dG9uL3NlbGVjdC1idXR0b24uZGlyZWN0aXZlJztcbmV4cG9ydCB7IE5ncFNlbGVjdEJ1dHRvblRva2VuIH0gZnJvbSAnLi9zZWxlY3QtYnV0dG9uL3NlbGVjdC1idXR0b24udG9rZW4nO1xuZXhwb3J0IHsgTmdwU2VsZWN0T3B0aW9uIH0gZnJvbSAnLi9zZWxlY3Qtb3B0aW9uL3NlbGVjdC1vcHRpb24uZGlyZWN0aXZlJztcbmV4cG9ydCB7IE5ncFNlbGVjdE9wdGlvblRva2VuIH0gZnJvbSAnLi9zZWxlY3Qtb3B0aW9uL3NlbGVjdC1vcHRpb24udG9rZW4nO1xuZXhwb3J0IHsgTmdwU2VsZWN0T3B0aW9ucyB9IGZyb20gJy4vc2VsZWN0LW9wdGlvbnMvc2VsZWN0LW9wdGlvbnMuZGlyZWN0aXZlJztcbmV4cG9ydCB7IE5ncFNlbGVjdE9wdGlvbnNUb2tlbiB9IGZyb20gJy4vc2VsZWN0LW9wdGlvbnMvc2VsZWN0LW9wdGlvbnMudG9rZW4nO1xuZXhwb3J0IHsgTmdwU2VsZWN0IH0gZnJvbSAnLi9zZWxlY3Qvc2VsZWN0LmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBOZ3BTZWxlY3RUb2tlbiB9IGZyb20gJy4vc2VsZWN0L3NlbGVjdC50b2tlbic7XG4iXX0=

package/esm2022/select/ng-primitives-select.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctcHJpbWl0aXZlcy1zZWxlY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL3NlbGVjdC9zcmMvbmctcHJpbWl0aXZlcy1zZWxlY3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/select/select/select.directive.mjs

@@ -0,0 +1,54 @@
+import { Directive, booleanAttribute, contentChild, input, model } from '@angular/core';
+import { NgpSelectButtonToken } from '../select-button/select-button.token';
+import { NgpSelectOptionsToken } from '../select-options/select-options.token';
+import { NgpSelectToken } from './select.token';
+import * as i0 from "@angular/core";
+export class NgpSelect {
+    constructor() {
+        /**
+         * The selected value.
+         */
+        this.value = model.required({
+            alias: 'ngpSelectValue',
+        });
+        /**
+         * Whether the select dropdown is open.
+         */
+        this.open = model(false, {
+            alias: 'ngpSelectOpen',
+        });
+        /**
+         * Disable the select component.
+         */
+        this.disabled = input(false, {
+            alias: 'ngpSelectDisabled',
+            transform: booleanAttribute,
+        });
+        /**
+         * Access the select button instance.
+         * @internal
+         */
+        this.button = contentChild.required(NgpSelectButtonToken, {
+            descendants: true,
+        });
+        /**
+         * Access the select options instance.
+         * @internal
+         */
+        this.options = contentChild.required(NgpSelectOptionsToken, {
+            descendants: true,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpSelect, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.0.2", type: NgpSelect, isStandalone: true, selector: "[ngpSelect]", inputs: { value: { classPropertyName: "value", publicName: "ngpSelectValue", isSignal: true, isRequired: true, transformFunction: null }, open: { classPropertyName: "open", publicName: "ngpSelectOpen", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "ngpSelectDisabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "ngpSelectValueChange", open: "ngpSelectOpenChange" }, providers: [{ provide: NgpSelectToken, useExisting: NgpSelect }], queries: [{ propertyName: "button", first: true, predicate: NgpSelectButtonToken, descendants: true, isSignal: true }, { propertyName: "options", first: true, predicate: NgpSelectOptionsToken, descendants: true, isSignal: true }], exportAs: ["ngpSelect"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpSelect, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpSelect]',
+                    exportAs: 'ngpSelect',
+                    providers: [{ provide: NgpSelectToken, useExisting: NgpSelect }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/select/select/select.token.mjs

@@ -0,0 +1,16 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the CC BY-ND 4.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { InjectionToken, inject } from '@angular/core';
+export const NgpSelectToken = new InjectionToken('NgpSelectToken');
+/**
+ * Inject the Select directive instance
+ */
+export function injectSelect() {
+    return inject(NgpSelectToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctcHJpbWl0aXZlcy9zZWxlY3Qvc3JjL3NlbGVjdC9zZWxlY3QudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHdkQsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLElBQUksY0FBYyxDQUFxQixnQkFBZ0IsQ0FBQyxDQUFDO0FBRXZGOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFlBQVk7SUFDMUIsT0FBTyxNQUFNLENBQWUsY0FBYyxDQUFDLENBQUM7QUFDOUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIENDIEJZLU5EIDQuMCBsaWNlbnNlIGZvdW5kIGluIHRoZVxuICogTElDRU5TRSBmaWxlIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHNvdXJjZSB0cmVlLlxuICovXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgdHlwZSB7IE5ncFNlbGVjdCB9IGZyb20gJy4vc2VsZWN0LmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCBjb25zdCBOZ3BTZWxlY3RUb2tlbiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxOZ3BTZWxlY3Q8dW5rbm93bj4+KCdOZ3BTZWxlY3RUb2tlbicpO1xuXG4vKipcbiAqIEluamVjdCB0aGUgU2VsZWN0IGRpcmVjdGl2ZSBpbnN0YW5jZVxuICovXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0U2VsZWN0PFQ+KCk6IE5ncFNlbGVjdDxUPiB7XG4gIHJldHVybiBpbmplY3Q8TmdwU2VsZWN0PFQ+PihOZ3BTZWxlY3RUb2tlbik7XG59XG4iXX0=

package/esm2022/select/select-button/select-button.directive.mjs

@@ -0,0 +1,84 @@
+import { Directive, ElementRef, inject, input } from '@angular/core';
+import { FocusManager, injectDisposables, uniqueId } from 'ng-primitives/utils';
+import { injectSelect } from '../select/select.token';
+import { NgpSelectButtonToken } from './select-button.token';
+import * as i0 from "@angular/core";
+export class NgpSelectButton {
+    constructor() {
+        /**
+         * Access the parent select component.
+         */
+        this.select = injectSelect();
+        /**
+         * Access the disposable helpers.
+         */
+        this.disposables = injectDisposables();
+        /**
+         * Access the element reference.
+         * @internal
+         */
+        this.element = inject(ElementRef);
+        /**
+         * Access the focus manager
+         */
+        this.focusManager = inject(FocusManager);
+        /**
+         * Optionally define an id for the button. By default, the id is generated.
+         */
+        this.id = input(uniqueId('select-button'));
+    }
+    /**
+     * Toggle the select open state.
+     */
+    toggle() {
+        this.select.open.update(open => !open);
+    }
+    /**
+     * Handle keyboard events. If the list is closed, open it when the user presses the arrow keys.
+     * If the list is open then we navigate using active descendant.
+     * @param event
+     */
+    keydown(event) {
+        if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+            this.select.open.set(true);
+            // stop the event from triggering scrolling on the dropdown
+            event.preventDefault();
+        }
+        // if the escape key is pressed, close the dropdown
+        if (event.key === 'Escape') {
+            this.select.open.set(false);
+        }
+    }
+    /**
+     * Focus the button element.
+     * @param origin
+     * @internal
+     */
+    focus(origin) {
+        // we run after the next tick to ensure any in-progress events do not get
+        // redirected to the button element
+        this.disposables.requestAnimationFrame(() => this.focusManager.focus(this.element, origin));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpSelectButton, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.2", type: NgpSelectButton, isStandalone: true, selector: "button[ngpSelectButton]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "type": "button", "aria-haspopup": "listbox" }, listeners: { "click": "toggle()", "keydown": "keydown($event)" }, properties: { "attr.id": "id()", "attr.aria-expanded": "select.open()", "attr.aria-controls": "select.open() ? select.options()?.id() : null", "attr.data-state": "select.open() ? \"open\" : \"closed\"" } }, providers: [{ provide: NgpSelectButtonToken, useExisting: NgpSelectButton }], exportAs: ["ngpSelectButton"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgpSelectButton, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'button[ngpSelectButton]',
+                    exportAs: 'ngpSelectButton',
+                    providers: [{ provide: NgpSelectButtonToken, useExisting: NgpSelectButton }],
+                    host: {
+                        type: 'button',
+                        'aria-haspopup': 'listbox',
+                        '[attr.id]': 'id()',
+                        '[attr.aria-expanded]': 'select.open()',
+                        '[attr.aria-controls]': 'select.open() ? select.options()?.id() : null',
+                        '[attr.data-state]': 'select.open() ? "open" : "closed"',
+                        '(click)': 'toggle()',
+                        '(keydown)': 'keydown($event)',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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