@fundamental-ngx/cdk 0.38.3-rc.4

package/esm2020/utils/directives/focusable-item/fdk-focusable-item-provider.service.mjs

@@ -0,0 +1,97 @@
+import { ElementRef, Inject, Injectable, NgZone, Optional, Self, SkipSelf } from '@angular/core';
+import { BehaviorSubject, combineLatest, filter, firstValueFrom, ReplaySubject, Subject } from 'rxjs';
+import { FDK_FOCUSABLE_ITEM_DIRECTIVE } from './focusable.tokens';
+import { FocusableItemDirective } from './focusable-item.directive';
+import { FocusableObserver } from './focusable.observer';
+import { DefaultFocusableItemViewModifier } from './default-focusable-item-view-modifier';
+import { map, startWith, takeUntil, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./focusable.observer";
+import * as i2 from "./focusable-item.directive";
+export class FdkFocusableItemProvider extends ReplaySubject {
+    /** @hidden */
+    constructor(ngZone, elementRef, focusableObserver, selfFocusable$, parentFocusable$) {
+        super(1);
+        this.ngZone = ngZone;
+        this.elementRef = elementRef;
+        this.focusableObserver = focusableObserver;
+        this.selfFocusable$ = selfFocusable$;
+        this.parentFocusable$ = parentFocusable$;
+        /** @hidden */
+        this.focusable = true;
+        /** @hidden */
+        this._viewModifiers$ = new BehaviorSubject(this._getInitialViewModifiers());
+        /** @hidden */
+        this._focusableChange$ = this._getFocusableChange$();
+        /** @hidden */
+        this._destroy$ = new Subject();
+        combineLatest([this._focusableChange$, this._viewModifiers$])
+            .pipe(tap(([isFocusable]) => this.setFocusable(isFocusable)), takeUntil(this._destroy$))
+            .subscribe();
+        this._focusableChange$
+            .pipe(tap((isFocusable) => (this.focusable = isFocusable)), tap((isFocusable) => this.next(isFocusable)), takeUntil(this._destroy$))
+            .subscribe();
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+        this.complete();
+        if (this._focusableObserver$) {
+            this.focusableObserver.unobserve(this.elementRef);
+        }
+    }
+    /**
+     * Adds view modifier
+     * @param modifier
+     */
+    addViewModifier(modifier) {
+        const viewModifiers = [...new Set([...this._viewModifiers$.value, modifier]).values()];
+        this._viewModifiers$.next(viewModifiers);
+    }
+    /**
+     * Sets focusable state of the element.
+     * @param isReadonly
+     */
+    setFocusable(isReadonly) {
+        firstValueFrom(this.ngZone.onStable).then(() => {
+            this._viewModifiers$.value.forEach((viewModifier) => viewModifier.setFocusable(isReadonly));
+        });
+    }
+    /** @hidden */
+    _getInitialViewModifiers() {
+        return !this.selfFocusable$ ? [new DefaultFocusableItemViewModifier(this.elementRef)] : [this.selfFocusable$];
+    }
+    /** @hidden */
+    _getFocusableChange$() {
+        if (!this.selfFocusable$) {
+            this._focusableObserver$ = this.focusableObserver.observe(this.elementRef);
+        }
+        const self$ = (this.selfFocusable$ || this._focusableObserver$).pipe(startWith(this.focusable));
+        const disablingEvents = [self$];
+        if (this.parentFocusable$) {
+            disablingEvents.push(this.parentFocusable$);
+        }
+        return combineLatest(disablingEvents).pipe(map((focusableStates) => focusableStates.some(Boolean)), filter((isFocusable) => isFocusable !== this.focusable));
+    }
+}
+FdkFocusableItemProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FdkFocusableItemProvider, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i1.FocusableObserver }, { token: FDK_FOCUSABLE_ITEM_DIRECTIVE, optional: true, self: true }, { token: FDK_FOCUSABLE_ITEM_DIRECTIVE, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FdkFocusableItemProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FdkFocusableItemProvider });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FdkFocusableItemProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: i1.FocusableObserver }, { type: i2.FocusableItemDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [FDK_FOCUSABLE_ITEM_DIRECTIVE]
+                }] }, { type: i2.FocusableItemDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }, {
+                    type: Inject,
+                    args: [FDK_FOCUSABLE_ITEM_DIRECTIVE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fdk-focusable-item-provider.service.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/focusable-item/fdk-focusable-item-provider.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Inject, Injectable, NgZone, OnDestroy, Optional, Self, SkipSelf } from '@angular/core';\nimport { BehaviorSubject, combineLatest, filter, firstValueFrom, Observable, ReplaySubject, Subject } from 'rxjs';\nimport { FocusableItemViewModifier } from './focusable-item-view-modifier.interface';\nimport { FDK_FOCUSABLE_ITEM_DIRECTIVE } from './focusable.tokens';\nimport { FocusableItemDirective } from './focusable-item.directive';\nimport { FocusableObserver } from './focusable.observer';\nimport { DefaultFocusableItemViewModifier } from './default-focusable-item-view-modifier';\nimport { map, startWith, takeUntil, tap } from 'rxjs/operators';\n\n@Injectable()\nexport class FdkFocusableItemProvider extends ReplaySubject<boolean> implements FocusableItemViewModifier, OnDestroy {\n    /** @hidden */\n    focusable = true;\n    /** @hidden */\n    private readonly _viewModifiers$: BehaviorSubject<FocusableItemViewModifier[]> = new BehaviorSubject<\n        FocusableItemViewModifier[]\n    >(this._getInitialViewModifiers());\n    /** @hidden */\n    private readonly _focusableChange$: Observable<boolean> = this._getFocusableChange$();\n\n    /** @hidden */\n    private _focusableObserver$!: Observable<boolean>;\n\n    /** @hidden */\n    private readonly _destroy$ = new Subject<void>();\n\n    /** @hidden */\n    constructor(\n        private ngZone: NgZone,\n        private elementRef: ElementRef<HTMLElement>,\n        private focusableObserver: FocusableObserver,\n        @Optional() @Self() @Inject(FDK_FOCUSABLE_ITEM_DIRECTIVE) private selfFocusable$?: FocusableItemDirective,\n        @Optional() @SkipSelf() @Inject(FDK_FOCUSABLE_ITEM_DIRECTIVE) private parentFocusable$?: FocusableItemDirective\n    ) {\n        super(1);\n        combineLatest([this._focusableChange$, this._viewModifiers$])\n            .pipe(\n                tap(([isFocusable]) => this.setFocusable(isFocusable)),\n                takeUntil(this._destroy$)\n            )\n            .subscribe();\n        this._focusableChange$\n            .pipe(\n                tap((isFocusable) => (this.focusable = isFocusable)),\n                tap((isFocusable) => this.next(isFocusable)),\n                takeUntil(this._destroy$)\n            )\n            .subscribe();\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._destroy$.next();\n        this._destroy$.complete();\n        this.complete();\n        if (this._focusableObserver$) {\n            this.focusableObserver.unobserve(this.elementRef);\n        }\n    }\n\n    /**\n     * Adds view modifier\n     * @param modifier\n     */\n    addViewModifier(modifier: FocusableItemViewModifier): void {\n        const viewModifiers = [...new Set([...this._viewModifiers$.value, modifier]).values()];\n        this._viewModifiers$.next(viewModifiers);\n    }\n\n    /**\n     * Sets focusable state of the element.\n     * @param isReadonly\n     */\n    setFocusable(isReadonly: boolean): void {\n        firstValueFrom(this.ngZone.onStable).then(() => {\n            this._viewModifiers$.value.forEach((viewModifier) => viewModifier.setFocusable(isReadonly));\n        });\n    }\n\n    /** @hidden */\n    private _getInitialViewModifiers(): FocusableItemViewModifier[] {\n        return !this.selfFocusable$ ? [new DefaultFocusableItemViewModifier(this.elementRef)] : [this.selfFocusable$];\n    }\n\n    /** @hidden */\n    private _getFocusableChange$(): Observable<boolean> {\n        if (!this.selfFocusable$) {\n            this._focusableObserver$ = this.focusableObserver.observe(this.elementRef);\n        }\n        const self$ = (this.selfFocusable$ || this._focusableObserver$).pipe(startWith(this.focusable));\n        const disablingEvents: Observable<boolean>[] = [self$];\n        if (this.parentFocusable$) {\n            disablingEvents.push(this.parentFocusable$);\n        }\n        return combineLatest(disablingEvents).pipe(\n            map((focusableStates: boolean[]) => focusableStates.some(Boolean)),\n            filter((isFocusable) => isFocusable !== this.focusable)\n        );\n    }\n}\n"]}

package/esm2020/utils/directives/focusable-item/focusable-item-view-modifier.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXNhYmxlLWl0ZW0tdmlldy1tb2RpZmllci5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvZm9jdXNhYmxlLWl0ZW0vZm9jdXNhYmxlLWl0ZW0tdmlldy1tb2RpZmllci5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRm9jdXNhYmxlSXRlbVZpZXdNb2RpZmllciB7XG4gICAgc2V0Rm9jdXNhYmxlOiAoaXNGb2N1c2FibGU6IGJvb2xlYW4pID0+IHZvaWQ7XG59XG4iXX0=

package/esm2020/utils/directives/focusable-item/focusable-item.directive.mjs

@@ -0,0 +1,106 @@
+import { Directive, ElementRef, Input } from '@angular/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { BehaviorSubject, filter, first, ReplaySubject } from 'rxjs';
+import { FDK_FOCUSABLE_ITEM_DIRECTIVE } from './focusable.tokens';
+import { setFocusable } from './set-focusable';
+import { FocusableObserver } from './focusable.observer';
+import { takeUntil, tap } from 'rxjs/operators';
+import { DestroyedService } from '../../services/destroyed.service';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+import * as i1 from "./focusable.observer";
+import * as i2 from "../../services/destroyed.service";
+export class DeprecatedFocusableItemDirective extends DeprecatedSelector {
+}
+DeprecatedFocusableItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedFocusableItemDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DeprecatedFocusableItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DeprecatedFocusableItemDirective, isStandalone: true, selector: "[fnFocusableItem]", providers: [
+        {
+            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+            useValue: getDeprecatedModel('[fdkFocusableItem]', '[fnFocusableItem]')
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedFocusableItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fnFocusableItem]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkFocusableItem]', '[fnFocusableItem]')
+                        }
+                    ]
+                }]
+        }] });
+export class FocusableItemDirective extends ReplaySubject {
+    /** @hidden */
+    constructor(_elementRef, _focusableObserver, _destroy$) {
+        super(1);
+        this._elementRef = _elementRef;
+        this._focusableObserver = _focusableObserver;
+        this._destroy$ = _destroy$;
+        /** @hidden */
+        this._focusable = true;
+        /** @hidden */
+        this._viewInit$ = new BehaviorSubject(false);
+        /** Sets focusable state of the element. */
+        this.setFocusable = (isFocusable) => {
+            setFocusable(this, isFocusable);
+        };
+        this._focusableObserver
+            .observe(this._elementRef)
+            .pipe(tap((isFocusable) => {
+            if (isFocusable !== this._focusable) {
+                this.setFocusable(isFocusable);
+                this._focusable = isFocusable;
+                this.next(isFocusable);
+            }
+        }), takeUntil(this._destroy$))
+            .subscribe();
+    }
+    /** Whether the item is focusable. */
+    set fdkFocusableItem(val) {
+        this._viewInit$.pipe(filter(Boolean), first()).subscribe(() => this.setFocusable(coerceBooleanProperty(val)));
+    }
+    get fdkFocusableItem() {
+        return this._focusable;
+    }
+    /** @hidden */
+    ngAfterViewInit() {
+        this._viewInit$.next(true);
+    }
+    /** Element reference. */
+    elementRef() {
+        return this._elementRef;
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this.complete();
+    }
+}
+FocusableItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableItemDirective, deps: [{ token: i0.ElementRef }, { token: i1.FocusableObserver }, { token: i2.DestroyedService }], target: i0.ɵɵFactoryTarget.Directive });
+FocusableItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: FocusableItemDirective, isStandalone: true, selector: "[fdkFocusableItem]", inputs: { fdkFocusableItem: "fdkFocusableItem" }, providers: [
+        {
+            provide: FDK_FOCUSABLE_ITEM_DIRECTIVE,
+            useExisting: FocusableItemDirective
+        },
+        DestroyedService
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkFocusableItem]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FDK_FOCUSABLE_ITEM_DIRECTIVE,
+                            useExisting: FocusableItemDirective
+                        },
+                        DestroyedService
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusableObserver }, { type: i2.DestroyedService }]; }, propDecorators: { fdkFocusableItem: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/directives/focusable-item/focusable-item.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import { FocusableItemDirective, DeprecatedFocusableItemDirective } from './focusable-item.directive';
+import * as i0 from "@angular/core";
+export class FocusableItemModule {
+}
+FocusableItemModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableItemModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FocusableItemModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: FocusableItemModule, imports: [FocusableItemDirective, DeprecatedFocusableItemDirective], exports: [FocusableItemDirective, DeprecatedFocusableItemDirective] });
+FocusableItemModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableItemModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableItemModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [FocusableItemDirective, DeprecatedFocusableItemDirective],
+                    exports: [FocusableItemDirective, DeprecatedFocusableItemDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXNhYmxlLWl0ZW0ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL2ZvY3VzYWJsZS1pdGVtL2ZvY3VzYWJsZS1pdGVtLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLDRCQUE0QixDQUFDOztBQU10RyxNQUFNLE9BQU8sbUJBQW1COztnSEFBbkIsbUJBQW1CO2lIQUFuQixtQkFBbUIsWUFIbEIsc0JBQXNCLEVBQUUsZ0NBQWdDLGFBQ3hELHNCQUFzQixFQUFFLGdDQUFnQztpSEFFekQsbUJBQW1COzJGQUFuQixtQkFBbUI7a0JBSi9CLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLENBQUMsc0JBQXNCLEVBQUUsZ0NBQWdDLENBQUM7b0JBQ25FLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixFQUFFLGdDQUFnQyxDQUFDO2lCQUN0RSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb2N1c2FibGVJdGVtRGlyZWN0aXZlLCBEZXByZWNhdGVkRm9jdXNhYmxlSXRlbURpcmVjdGl2ZSB9IGZyb20gJy4vZm9jdXNhYmxlLWl0ZW0uZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbRm9jdXNhYmxlSXRlbURpcmVjdGl2ZSwgRGVwcmVjYXRlZEZvY3VzYWJsZUl0ZW1EaXJlY3RpdmVdLFxuICAgIGV4cG9ydHM6IFtGb2N1c2FibGVJdGVtRGlyZWN0aXZlLCBEZXByZWNhdGVkRm9jdXNhYmxlSXRlbURpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgRm9jdXNhYmxlSXRlbU1vZHVsZSB7fVxuIl19

package/esm2020/utils/directives/focusable-item/focusable.observer.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { isElementFocusableByDefault } from './is-element-focusable-by-default';
+import { getNativeElement } from '../../helpers/get-native-element';
+import { AttributeObserver } from '../../services/observers/attribute.observer';
+import { ReadonlyObserver } from '../readonly/readonly.observer';
+import { DisabledObserver } from '../disabled/disabled.observer';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/observers/attribute.observer";
+export class FocusableObserver {
+    /** @hidden */
+    constructor(_attributeObserver) {
+        this._attributeObserver = _attributeObserver;
+    }
+    /** @Hidden */
+    static isFocusable(element) {
+        if (ReadonlyObserver.isReadonly(element)) {
+            return false;
+        }
+        if (DisabledObserver.isDisabled(element)) {
+            return false;
+        }
+        const tabIndex = parseInt(element.getAttribute('tabindex') + '', 10);
+        if (isNaN(tabIndex)) {
+            return isElementFocusableByDefault(element);
+        }
+        return tabIndex > -1;
+    }
+    /** @hidden */
+    observe(element) {
+        const nativeElement = getNativeElement(element);
+        return this._attributeObserver.observe(nativeElement).pipe(map(() => FocusableObserver.isFocusable(nativeElement)), distinctUntilChanged());
+    }
+    /** @hidden */
+    unobserve(element) {
+        this._attributeObserver.unobserve(element);
+    }
+}
+FocusableObserver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableObserver, deps: [{ token: i1.AttributeObserver }], target: i0.ɵɵFactoryTarget.Injectable });
+FocusableObserver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableObserver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableObserver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AttributeObserver }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXNhYmxlLm9ic2VydmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL2ZvY3VzYWJsZS1pdGVtL2ZvY3VzYWJsZS5vYnNlcnZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWMsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXZELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUMzRCxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNoRixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUVwRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQztBQUNoRixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNqRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQzs7O0FBS2pFLE1BQU0sT0FBTyxpQkFBaUI7SUFDMUIsY0FBYztJQUNkLFlBQW9CLGtCQUFxQztRQUFyQyx1QkFBa0IsR0FBbEIsa0JBQWtCLENBQW1CO0lBQUcsQ0FBQztJQUU3RCxjQUFjO0lBQ2QsTUFBTSxDQUFDLFdBQVcsQ0FBQyxPQUFnQjtRQUMvQixJQUFJLGdCQUFnQixDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsRUFBRTtZQUN0QyxPQUFPLEtBQUssQ0FBQztTQUNoQjtRQUNELElBQUksZ0JBQWdCLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ3RDLE9BQU8sS0FBSyxDQUFDO1NBQ2hCO1FBQ0QsTUFBTSxRQUFRLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsVUFBVSxDQUFDLEdBQUcsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3JFLElBQUksS0FBSyxDQUFDLFFBQVEsQ0FBQyxFQUFFO1lBQ2pCLE9BQU8sMkJBQTJCLENBQUMsT0FBTyxDQUFDLENBQUM7U0FDL0M7UUFDRCxPQUFPLFFBQVEsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUN6QixDQUFDO0lBRUQsY0FBYztJQUNkLE9BQU8sQ0FBQyxPQUErRDtRQUNuRSxNQUFNLGFBQWEsR0FBRyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNoRCxPQUFPLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLENBQUMsSUFBSSxDQUN0RCxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsaUJBQWlCLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDLEVBQ3ZELG9CQUFvQixFQUFFLENBQ3pCLENBQUM7SUFDTixDQUFDO0lBRUQsY0FBYztJQUNkLFNBQVMsQ0FBQyxPQUErRDtRQUNyRSxJQUFJLENBQUMsa0JBQWtCLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQy9DLENBQUM7OzhHQS9CUSxpQkFBaUI7a0hBQWpCLGlCQUFpQixjQUZkLE1BQU07MkZBRVQsaUJBQWlCO2tCQUg3QixVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVsZW1lbnRSZWYsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IGRpc3RpbmN0VW50aWxDaGFuZ2VkLCBtYXAgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5pbXBvcnQgeyBpc0VsZW1lbnRGb2N1c2FibGVCeURlZmF1bHQgfSBmcm9tICcuL2lzLWVsZW1lbnQtZm9jdXNhYmxlLWJ5LWRlZmF1bHQnO1xuaW1wb3J0IHsgZ2V0TmF0aXZlRWxlbWVudCB9IGZyb20gJy4uLy4uL2hlbHBlcnMvZ2V0LW5hdGl2ZS1lbGVtZW50JztcbmltcG9ydCB7IEhhc0VsZW1lbnRSZWYgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2VzL2hhcy1lbGVtZW50LXJlZi5pbnRlcmZhY2UnO1xuaW1wb3J0IHsgQXR0cmlidXRlT2JzZXJ2ZXIgfSBmcm9tICcuLi8uLi9zZXJ2aWNlcy9vYnNlcnZlcnMvYXR0cmlidXRlLm9ic2VydmVyJztcbmltcG9ydCB7IFJlYWRvbmx5T2JzZXJ2ZXIgfSBmcm9tICcuLi9yZWFkb25seS9yZWFkb25seS5vYnNlcnZlcic7XG5pbXBvcnQgeyBEaXNhYmxlZE9ic2VydmVyIH0gZnJvbSAnLi4vZGlzYWJsZWQvZGlzYWJsZWQub2JzZXJ2ZXInO1xuXG5ASW5qZWN0YWJsZSh7XG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIEZvY3VzYWJsZU9ic2VydmVyIHtcbiAgICAvKiogQGhpZGRlbiAqL1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgX2F0dHJpYnV0ZU9ic2VydmVyOiBBdHRyaWJ1dGVPYnNlcnZlcikge31cblxuICAgIC8qKiBASGlkZGVuICovXG4gICAgc3RhdGljIGlzRm9jdXNhYmxlKGVsZW1lbnQ6IEVsZW1lbnQpOiBib29sZWFuIHtcbiAgICAgICAgaWYgKFJlYWRvbmx5T2JzZXJ2ZXIuaXNSZWFkb25seShlbGVtZW50KSkge1xuICAgICAgICAgICAgcmV0dXJuIGZhbHNlO1xuICAgICAgICB9XG4gICAgICAgIGlmIChEaXNhYmxlZE9ic2VydmVyLmlzRGlzYWJsZWQoZWxlbWVudCkpIHtcbiAgICAgICAgICAgIHJldHVybiBmYWxzZTtcbiAgICAgICAgfVxuICAgICAgICBjb25zdCB0YWJJbmRleCA9IHBhcnNlSW50KGVsZW1lbnQuZ2V0QXR0cmlidXRlKCd0YWJpbmRleCcpICsgJycsIDEwKTtcbiAgICAgICAgaWYgKGlzTmFOKHRhYkluZGV4KSkge1xuICAgICAgICAgICAgcmV0dXJuIGlzRWxlbWVudEZvY3VzYWJsZUJ5RGVmYXVsdChlbGVtZW50KTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gdGFiSW5kZXggPiAtMTtcbiAgICB9XG5cbiAgICAvKiogQGhpZGRlbiAqL1xuICAgIG9ic2VydmUoZWxlbWVudDogSGFzRWxlbWVudFJlZjxFbGVtZW50PiB8IEVsZW1lbnQgfCBFbGVtZW50UmVmPEVsZW1lbnQ+KTogT2JzZXJ2YWJsZTxib29sZWFuPiB7XG4gICAgICAgIGNvbnN0IG5hdGl2ZUVsZW1lbnQgPSBnZXROYXRpdmVFbGVtZW50KGVsZW1lbnQpO1xuICAgICAgICByZXR1cm4gdGhpcy5fYXR0cmlidXRlT2JzZXJ2ZXIub2JzZXJ2ZShuYXRpdmVFbGVtZW50KS5waXBlKFxuICAgICAgICAgICAgbWFwKCgpID0+IEZvY3VzYWJsZU9ic2VydmVyLmlzRm9jdXNhYmxlKG5hdGl2ZUVsZW1lbnQpKSxcbiAgICAgICAgICAgIGRpc3RpbmN0VW50aWxDaGFuZ2VkKClcbiAgICAgICAgKTtcbiAgICB9XG5cbiAgICAvKiogQGhpZGRlbiAqL1xuICAgIHVub2JzZXJ2ZShlbGVtZW50OiBIYXNFbGVtZW50UmVmPEVsZW1lbnQ+IHwgRWxlbWVudCB8IEVsZW1lbnRSZWY8RWxlbWVudD4pOiB2b2lkIHtcbiAgICAgICAgdGhpcy5fYXR0cmlidXRlT2JzZXJ2ZXIudW5vYnNlcnZlKGVsZW1lbnQpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/utils/directives/focusable-item/focusable.tokens.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const FDK_FOCUSABLE_ITEM_DIRECTIVE = new InjectionToken('Focusable directive token');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXNhYmxlLnRva2Vucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZGlyZWN0aXZlcy9mb2N1c2FibGUtaXRlbS9mb2N1c2FibGUudG9rZW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0MsTUFBTSxDQUFDLE1BQU0sNEJBQTRCLEdBQUcsSUFBSSxjQUFjLENBQUMsMkJBQTJCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBGREtfRk9DVVNBQkxFX0lURU1fRElSRUNUSVZFID0gbmV3IEluamVjdGlvblRva2VuKCdGb2N1c2FibGUgZGlyZWN0aXZlIHRva2VuJyk7XG4iXX0=

package/esm2020/utils/directives/focusable-item/index.mjs

@@ -0,0 +1,9 @@
+export * from './focusable-item.module';
+export * from './focusable-item.directive';
+export * from './focusable.tokens';
+export * from './set-focusable';
+export * from './focusable-item-view-modifier.interface';
+export * from './focusable.observer';
+export * from './default-focusable-item-view-modifier';
+export * from './fdk-focusable-item-provider.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvZm9jdXNhYmxlLWl0ZW0vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDBDQUEwQyxDQUFDO0FBQ3pELGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mb2N1c2FibGUtaXRlbS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9mb2N1c2FibGUtaXRlbS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9mb2N1c2FibGUudG9rZW5zJztcbmV4cG9ydCAqIGZyb20gJy4vc2V0LWZvY3VzYWJsZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZvY3VzYWJsZS1pdGVtLXZpZXctbW9kaWZpZXIuaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9jdXNhYmxlLm9ic2VydmVyJztcbmV4cG9ydCAqIGZyb20gJy4vZGVmYXVsdC1mb2N1c2FibGUtaXRlbS12aWV3LW1vZGlmaWVyJztcbmV4cG9ydCAqIGZyb20gJy4vZmRrLWZvY3VzYWJsZS1pdGVtLXByb3ZpZGVyLnNlcnZpY2UnO1xuIl19

package/esm2020/utils/directives/focusable-item/is-element-focusable-by-default.mjs

@@ -0,0 +1,32 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { getNativeElement } from '../../helpers/get-native-element';
+const focusableTagnamesByDefault = new Set(['select', 'textarea', 'input', 'button', 'audio', 'video']);
+const focusableTagOptions = [
+    {
+        tag: 'div',
+        attributes: [
+            {
+                name: 'contenteditable',
+                valueMatcher: (value) => coerceBooleanProperty(value)
+            }
+        ]
+    }
+];
+/** @hidden */
+export function isElementFocusableByDefault(el) {
+    const element = getNativeElement(el);
+    const tagName = element.tagName.toLowerCase();
+    if (focusableTagnamesByDefault.has(tagName)) {
+        return true;
+    }
+    return focusableTagOptions.some((tagOptions) => {
+        if (tagOptions.tag === tagName) {
+            return tagOptions.attributes.some((attribute) => {
+                const attrVal = element.getAttribute(attribute.name);
+                return attrVal && attribute.valueMatcher(attrVal);
+            });
+        }
+        return false;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/directives/focusable-item/set-focusable.mjs

@@ -0,0 +1,12 @@
+import { getNativeElement } from '../../helpers/get-native-element';
+/** @Hidden */
+export function setFocusable(element, isFocusable) {
+    const htmlElement = getNativeElement(element);
+    if (isFocusable) {
+        htmlElement.setAttribute('tabindex', '0');
+    }
+    else {
+        htmlElement.setAttribute('tabindex', '-1');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0LWZvY3VzYWJsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZGlyZWN0aXZlcy9mb2N1c2FibGUtaXRlbS9zZXQtZm9jdXNhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBR3BFLGNBQWM7QUFDZCxNQUFNLFVBQVUsWUFBWSxDQUN4QixPQUErRCxFQUMvRCxXQUFvQjtJQUVwQixNQUFNLFdBQVcsR0FBRyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM5QyxJQUFJLFdBQVcsRUFBRTtRQUNiLFdBQVcsQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0tBQzdDO1NBQU07UUFDSCxXQUFXLENBQUMsWUFBWSxDQUFDLFVBQVUsRUFBRSxJQUFJLENBQUMsQ0FBQztLQUM5QztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbGVtZW50UmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBnZXROYXRpdmVFbGVtZW50IH0gZnJvbSAnLi4vLi4vaGVscGVycy9nZXQtbmF0aXZlLWVsZW1lbnQnO1xuaW1wb3J0IHsgSGFzRWxlbWVudFJlZiB9IGZyb20gJy4uLy4uL2ludGVyZmFjZXMvaGFzLWVsZW1lbnQtcmVmLmludGVyZmFjZSc7XG5cbi8qKiBASGlkZGVuICovXG5leHBvcnQgZnVuY3Rpb24gc2V0Rm9jdXNhYmxlKFxuICAgIGVsZW1lbnQ6IEhhc0VsZW1lbnRSZWY8RWxlbWVudD4gfCBFbGVtZW50IHwgRWxlbWVudFJlZjxFbGVtZW50PixcbiAgICBpc0ZvY3VzYWJsZTogYm9vbGVhblxuKTogdm9pZCB7XG4gICAgY29uc3QgaHRtbEVsZW1lbnQgPSBnZXROYXRpdmVFbGVtZW50KGVsZW1lbnQpO1xuICAgIGlmIChpc0ZvY3VzYWJsZSkge1xuICAgICAgICBodG1sRWxlbWVudC5zZXRBdHRyaWJ1dGUoJ3RhYmluZGV4JywgJzAnKTtcbiAgICB9IGVsc2Uge1xuICAgICAgICBodG1sRWxlbWVudC5zZXRBdHRyaWJ1dGUoJ3RhYmluZGV4JywgJy0xJyk7XG4gICAgfVxufVxuIl19

package/esm2020/utils/directives/focusable-list/focusable-list.directive.mjs

@@ -0,0 +1,79 @@
+import { ContentChildren, Directive, Input, QueryList } from '@angular/core';
+import { map, startWith, takeUntil, tap } from 'rxjs/operators';
+import { FocusableListService } from './focusable-list.service';
+import { FocusableItemDirective } from '../focusable-item/focusable-item.directive';
+import { DestroyedService } from '../../services/destroyed.service';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+import * as i1 from "./focusable-list.service";
+import * as i2 from "../../services/destroyed.service";
+export class DeprecatedFocusableListDirective extends DeprecatedSelector {
+}
+DeprecatedFocusableListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedFocusableListDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DeprecatedFocusableListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DeprecatedFocusableListDirective, isStandalone: true, selector: "[fnFocusableList]", providers: [
+        {
+            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+            useValue: getDeprecatedModel('[fdkFocusableList]', '[fnFocusableList]')
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedFocusableListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fnFocusableList]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkFocusableList]', '[fnFocusableList]')
+                        }
+                    ]
+                }]
+        }] });
+export class FocusableListDirective {
+    /** @hidden */
+    constructor(_focusableListService, _destroy$) {
+        this._focusableListService = _focusableListService;
+        this._destroy$ = _destroy$;
+        /** Direction of navigation. */
+        this.navigationDirection = 'vertical';
+        /** Direction of the content. */
+        this.contentDirection = 'ltr';
+    }
+    /** @hidden */
+    ngAfterViewInit() {
+        this._focusableItems.changes
+            .pipe(startWith(this._focusableItems), map((queryList) => queryList.toArray()), tap((items) => {
+            const focusableItems = items.map((item, index) => ({
+                index,
+                focusable: () => item.fdkFocusableItem,
+                elementRef: () => item.elementRef(),
+                focus: () => item.elementRef().nativeElement.focus()
+            }));
+            this._focusableListService.initialize(focusableItems, {
+                direction: this.navigationDirection,
+                contentDirection: this.contentDirection
+            });
+        }), takeUntil(this._destroy$))
+            .subscribe();
+    }
+}
+FocusableListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableListDirective, deps: [{ token: i1.FocusableListService }, { token: i2.DestroyedService }], target: i0.ɵɵFactoryTarget.Directive });
+FocusableListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: FocusableListDirective, isStandalone: true, selector: "[fdkFocusableList]", inputs: { navigationDirection: "navigationDirection", contentDirection: "contentDirection" }, providers: [FocusableListService, DestroyedService], queries: [{ propertyName: "_focusableItems", predicate: FocusableItemDirective }], exportAs: ["fdkFocusableList"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkFocusableList]',
+                    exportAs: 'fdkFocusableList',
+                    standalone: true,
+                    providers: [FocusableListService, DestroyedService]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FocusableListService }, { type: i2.DestroyedService }]; }, propDecorators: { navigationDirection: [{
+                type: Input
+            }], contentDirection: [{
+                type: Input
+            }], _focusableItems: [{
+                type: ContentChildren,
+                args: [FocusableItemDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/directives/focusable-list/focusable-list.module.mjs

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { FocusableListDirective, DeprecatedFocusableListDirective } from './focusable-list.directive';
+import { FocusableItemModule } from '../focusable-item';
+import * as i0 from "@angular/core";
+export class FocusableListModule {
+}
+FocusableListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FocusableListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: FocusableListModule, imports: [FocusableItemModule, FocusableListDirective, DeprecatedFocusableListDirective], exports: [FocusableListDirective, FocusableItemModule, DeprecatedFocusableListDirective] });
+FocusableListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableListModule, imports: [FocusableItemModule, FocusableItemModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [FocusableItemModule, FocusableListDirective, DeprecatedFocusableListDirective],
+                    exports: [FocusableListDirective, FocusableItemModule, DeprecatedFocusableListDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXNhYmxlLWxpc3QubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL2ZvY3VzYWJsZS1saXN0L2ZvY3VzYWJsZS1saXN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ3RHLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDOztBQU14RCxNQUFNLE9BQU8sbUJBQW1COztnSEFBbkIsbUJBQW1CO2lIQUFuQixtQkFBbUIsWUFIbEIsbUJBQW1CLEVBQUUsc0JBQXNCLEVBQUUsZ0NBQWdDLGFBQzdFLHNCQUFzQixFQUFFLG1CQUFtQixFQUFFLGdDQUFnQztpSEFFOUUsbUJBQW1CLFlBSGxCLG1CQUFtQixFQUNLLG1CQUFtQjsyRkFFNUMsbUJBQW1CO2tCQUovQixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRSxDQUFDLG1CQUFtQixFQUFFLHNCQUFzQixFQUFFLGdDQUFnQyxDQUFDO29CQUN4RixPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxtQkFBbUIsRUFBRSxnQ0FBZ0MsQ0FBQztpQkFDM0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9jdXNhYmxlTGlzdERpcmVjdGl2ZSwgRGVwcmVjYXRlZEZvY3VzYWJsZUxpc3REaXJlY3RpdmUgfSBmcm9tICcuL2ZvY3VzYWJsZS1saXN0LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBGb2N1c2FibGVJdGVtTW9kdWxlIH0gZnJvbSAnLi4vZm9jdXNhYmxlLWl0ZW0nO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtGb2N1c2FibGVJdGVtTW9kdWxlLCBGb2N1c2FibGVMaXN0RGlyZWN0aXZlLCBEZXByZWNhdGVkRm9jdXNhYmxlTGlzdERpcmVjdGl2ZV0sXG4gICAgZXhwb3J0czogW0ZvY3VzYWJsZUxpc3REaXJlY3RpdmUsIEZvY3VzYWJsZUl0ZW1Nb2R1bGUsIERlcHJlY2F0ZWRGb2N1c2FibGVMaXN0RGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBGb2N1c2FibGVMaXN0TW9kdWxlIHt9XG4iXX0=

package/esm2020/utils/directives/focusable-list/focusable-list.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable, Renderer2 } from '@angular/core';
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { finalize, fromEvent, merge, Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import { getNativeElement } from '../../helpers/get-native-element';
+import * as i0 from "@angular/core";
+export class FocusableListService {
+    /** @hidden */
+    constructor(_renderer) {
+        this._renderer = _renderer;
+        /** @hidden */
+        this._refresh$ = new Subject();
+        /** @hidden */
+        this._destroy$ = new Subject();
+    }
+    /**
+     * Initializes the focusable list service with items and configuration.
+     * @param items Focusable list items.
+     * @param config Initialization configuration.
+     */
+    initialize(items, config = {}) {
+        this._refresh$.next();
+        let keyManager = new FocusKeyManager(items);
+        if (config.wrap !== false) {
+            keyManager = keyManager.withWrap();
+        }
+        if (config.direction === 'horizontal') {
+            keyManager = keyManager.withHorizontalOrientation(config.contentDirection || 'ltr'); // should be replaced
+        }
+        keyManager.skipPredicate((item) => {
+            const focusable = typeof item.focusable === 'boolean' ? item.focusable : item.focusable();
+            return !focusable;
+        });
+        this.keyManager = keyManager;
+        const events$ = items.map((item) => fromEvent(getNativeElement(item), 'keydown'));
+        const focusListenerDestroyers = items.map((item) => this._renderer.listen(getNativeElement(item), 'focus', () => this.keyManager?.setActiveItem(item.index)));
+        merge(...events$)
+            .pipe(tap((keydownEvent) => this.keyManager?.onKeydown(keydownEvent)), takeUntil(merge(this._refresh$, this._destroy$)), finalize(() => {
+            focusListenerDestroyers.forEach((d) => d());
+        }))
+            .subscribe();
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+}
+FocusableListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableListService, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Injectable });
+FocusableListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableListService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusableListService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/directives/focusable-list/index.mjs

@@ -0,0 +1,4 @@
+export * from './focusable-list.service';
+export * from './focusable-list.module';
+export * from './focusable-list.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvZm9jdXNhYmxlLWxpc3QvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ZvY3VzYWJsZS1saXN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mb2N1c2FibGUtbGlzdC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9mb2N1c2FibGUtbGlzdC5kaXJlY3RpdmUnO1xuIl19