@fundamental-ngx/cdk 0.43.1 → 0.44.0-rc.0

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

@@ -0,0 +1,217 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, ElementRef, EventEmitter, HostBinding, inject, Input, NgZone, Output } from '@angular/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ENTER, ESCAPE, F2, MAC_ENTER } from '@angular/cdk/keycodes';
+import { FDK_FOCUSABLE_ITEM_DIRECTIVE } from './focusable-item.tokens';
+import { DestroyedService, TabbableElementService } from '../../services';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import { LiveAnnouncer } from '@angular/cdk/a11y';
+import { FocusableObserver } from './focusable.observer';
+import { fromEvent, Subject, takeUntil } from 'rxjs';
+import { KeyUtil } from '../../functions';
+import * as i0 from "@angular/core";
+export class DeprecatedFocusableItemDirective extends DeprecatedSelector {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: DeprecatedFocusableItemDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.0", 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: "16.1.0", 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 {
+    /** Whether the item is focusable. Default is true. */
+    set fdkFocusableItem(val) {
+        this._focusable = coerceBooleanProperty(val);
+        this.setTabbable(this._focusable);
+    }
+    get fdkFocusableItem() {
+        return this._focusable;
+    }
+    /** @hidden */
+    get _tabindex() {
+        return this._tabbable ? 0 : -1;
+    }
+    /** @hidden */
+    constructor() {
+        /** Function, which returns a string to be announced by screen-reader whenever an item which is in grid receives focus. */
+        this.cellFocusedEventAnnouncer = this._defaultItemFocusedEventAnnouncer;
+        /** Event emitted when the cell receives focus, not being emitted when focus moves between item's children. */
+        this.cellFocused = new EventEmitter();
+        /** @hidden */
+        this._keydown$ = new Subject();
+        /** @hidden */
+        this._focusable = true;
+        /** @hidden */
+        this._tabbableElements = new Map();
+        /** @hidden */
+        this._tabbable = true;
+        /** Element reference. */
+        this.elementRef = inject(ElementRef);
+        /** @hidden */
+        this._focusableObserver = inject(FocusableObserver);
+        /** @hidden */
+        this._destroy$ = inject(DestroyedService);
+        /** @hidden */
+        this._tabbableElementService = inject(TabbableElementService);
+        /** @hidden */
+        this._liveAnnouncer = inject(LiveAnnouncer);
+        /** @hidden */
+        this._zone = inject(NgZone);
+        /** @hidden */
+        this._document = inject(DOCUMENT);
+        this._focusableObserver
+            .observe(this.elementRef, false)
+            .pipe(takeUntil(this._destroy$))
+            .subscribe((isFocusable) => {
+            if (!isFocusable && isFocusable !== this.fdkFocusableItem) {
+                this.fdkFocusableItem = isFocusable;
+            }
+        });
+        this._zone.runOutsideAngular(() => {
+            fromEvent(this.elementRef.nativeElement, 'focusin')
+                .pipe(takeUntil(this._destroy$))
+                .subscribe(async () => {
+                await this._onFocusin();
+            });
+            fromEvent(this.elementRef.nativeElement, 'focusout')
+                .pipe(takeUntil(this._destroy$))
+                .subscribe(() => {
+                this._onFocusout();
+            });
+            fromEvent(this.elementRef.nativeElement, 'keydown')
+                .pipe(takeUntil(this._destroy$))
+                .subscribe((event) => {
+                this._onKeydown(event);
+            });
+        });
+    }
+    /** Set tabbable state */
+    setTabbable(state) {
+        this._tabbable = state;
+        if (state) {
+            this._enableTabbableElements();
+        }
+        else {
+            this._disableTabbableElements();
+        }
+    }
+    /** @hidden */
+    async _onFocusin() {
+        if (!this.fdkFocusableItem) {
+            return;
+        }
+        if (this._timerId != null) {
+            clearTimeout(this._timerId);
+            this._timerId = null;
+            return;
+        }
+        if (this._position) {
+            this.cellFocused.next(this._position);
+            if (this.cellFocusedEventAnnouncer) {
+                this._liveAnnouncer.clear();
+                await this._liveAnnouncer.announce(this.cellFocusedEventAnnouncer(this._position));
+            }
+        }
+    }
+    /** @hidden */
+    _onFocusout() {
+        if (!this.fdkFocusableItem) {
+            return;
+        }
+        // Timeout is needed to prevent focusout event from being emitted when focus moves between item's children.
+        this._timerId = setTimeout(() => (this._timerId = null));
+    }
+    /** @hidden */
+    _onKeydown(event) {
+        if (!this.fdkFocusableItem) {
+            return;
+        }
+        const isFocused = this._document.activeElement === this.elementRef.nativeElement;
+        const shouldFocusChild = KeyUtil.isKeyCode(event, [ENTER, MAC_ENTER, F2]) && !event.shiftKey && isFocused;
+        const shouldFocusCell = ((KeyUtil.isKeyCode(event, F2) && event.shiftKey) || KeyUtil.isKeyCode(event, ESCAPE)) && !isFocused;
+        if (shouldFocusChild) {
+            event.stopPropagation();
+            const tabbableElement = this._tabbableElementService.getTabbableElement(this.elementRef.nativeElement, false, true);
+            tabbableElement?.focus();
+            return;
+        }
+        else if (shouldFocusCell) {
+            event.stopPropagation();
+            this.elementRef.nativeElement.focus();
+            return;
+        }
+        if (isFocused) {
+            this._keydown$.next(event);
+        }
+    }
+    /** @hidden */
+    _enableTabbableElements() {
+        if (this._tabbableElements.size === 0) {
+            return;
+        }
+        this._tabbableElements.forEach((tabIndex, element) => (element.tabIndex = tabIndex));
+        this._tabbable = false;
+    }
+    /** @hidden */
+    _disableTabbableElements() {
+        // Since we cannot select by tabindex attribute (links, inputs, buttons might not have one but still can be focusable),
+        // Select all elements from the cell and filter by tabIndex property.
+        Array.from(this.elementRef.nativeElement.querySelectorAll('*'))
+            .filter((elm) => elm.tabIndex >= 0)
+            .forEach((elm) => {
+            this._tabbableElements.set(elm, elm.tabIndex);
+            elm.tabIndex = -1;
+        });
+    }
+    /** @hidden */
+    _defaultItemFocusedEventAnnouncer(position) {
+        return `Column ${position.colIndex + 1} of ${position.totalCols}, row: ${position.rowIndex + 1} of ${position.totalRows}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.0", type: FocusableItemDirective, isStandalone: true, selector: "[fdkFocusableItem]", inputs: { fdkFocusableItem: "fdkFocusableItem", cellFocusedEventAnnouncer: "cellFocusedEventAnnouncer" }, outputs: { cellFocused: "cellFocused" }, host: { properties: { "attr.tabindex": "this._tabindex" } }, providers: [
+            {
+                provide: FDK_FOCUSABLE_ITEM_DIRECTIVE,
+                useExisting: FocusableItemDirective
+            },
+            DestroyedService
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkFocusableItem]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FDK_FOCUSABLE_ITEM_DIRECTIVE,
+                            useExisting: FocusableItemDirective
+                        },
+                        DestroyedService
+                    ]
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { fdkFocusableItem: [{
+                type: Input
+            }], cellFocusedEventAnnouncer: [{
+                type: Input
+            }], cellFocused: [{
+                type: Output
+            }], _tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"focusable-item.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/focusable-item/focusable-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { Directive, ElementRef, EventEmitter, HostBinding, inject, Input, NgZone, Output } from '@angular/core';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ENTER, ESCAPE, F2, MAC_ENTER } from '@angular/cdk/keycodes';\nimport { FDK_FOCUSABLE_ITEM_DIRECTIVE } from './focusable-item.tokens';\nimport { DestroyedService, TabbableElementService } from '../../services';\nimport { HasElementRef } from '../../interfaces';\nimport {\n    DeprecatedSelector,\n    FD_DEPRECATED_DIRECTIVE_SELECTOR,\n    getDeprecatedModel\n} from '../../deprecated-selector.class';\nimport { LiveAnnouncer } from '@angular/cdk/a11y';\nimport { FocusableObserver } from './focusable.observer';\nimport { fromEvent, Subject, takeUntil } from 'rxjs';\nimport { Nullable } from '../../models/nullable';\nimport { KeyUtil } from '../../functions';\n\nexport type CellFocusedEventAnnouncer = Nullable<(position: FocusableItemPosition) => string>;\n\nexport interface FocusableItemPosition {\n    rowIndex: number;\n    colIndex: number;\n    totalRows: number;\n    totalCols: number;\n}\n\n@Directive({\n    // eslint-disable-next-line @angular-eslint/directive-selector\n    selector: '[fnFocusableItem]',\n    standalone: true,\n    providers: [\n        {\n            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,\n            useValue: getDeprecatedModel('[fdkFocusableItem]', '[fnFocusableItem]')\n        }\n    ]\n})\nexport class DeprecatedFocusableItemDirective extends DeprecatedSelector {}\n\n@Directive({\n    selector: '[fdkFocusableItem]',\n    standalone: true,\n    providers: [\n        {\n            provide: FDK_FOCUSABLE_ITEM_DIRECTIVE,\n            useExisting: FocusableItemDirective\n        },\n        DestroyedService\n    ]\n})\nexport class FocusableItemDirective implements HasElementRef {\n    /** Whether the item is focusable. Default is true. */\n    @Input()\n    set fdkFocusableItem(val: BooleanInput) {\n        this._focusable = coerceBooleanProperty(val);\n        this.setTabbable(this._focusable);\n    }\n\n    get fdkFocusableItem(): boolean {\n        return this._focusable;\n    }\n\n    /** Function, which returns a string to be announced by screen-reader whenever an item which is in grid receives focus. */\n    @Input()\n    cellFocusedEventAnnouncer: CellFocusedEventAnnouncer = this._defaultItemFocusedEventAnnouncer;\n\n    /** Event emitted when the cell receives focus, not being emitted when focus moves between item's children. */\n    @Output()\n    readonly cellFocused = new EventEmitter<FocusableItemPosition>();\n\n    /** @hidden */\n    public readonly _keydown$ = new Subject<KeyboardEvent>();\n\n    /** @hidden */\n    _position: FocusableItemPosition;\n\n    /** @hidden */\n    private _focusable = true;\n\n    /** @hidden */\n    private _tabbableElements = new Map<HTMLElement, number>();\n\n    /** @hidden */\n    private _tabbable = true;\n\n    /** @hidden */\n    private _timerId: ReturnType<typeof setTimeout> | null;\n\n    /** @hidden */\n    @HostBinding('attr.tabindex')\n    get _tabindex(): number {\n        return this._tabbable ? 0 : -1;\n    }\n\n    /** Element reference. */\n    public readonly elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n    /** @hidden */\n    private readonly _focusableObserver = inject(FocusableObserver);\n    /** @hidden */\n    protected readonly _destroy$ = inject(DestroyedService);\n    /** @hidden */\n    private readonly _tabbableElementService = inject(TabbableElementService);\n    /** @hidden */\n    private readonly _liveAnnouncer = inject(LiveAnnouncer);\n    /** @hidden */\n    protected readonly _zone = inject(NgZone);\n    /** @hidden */\n    private readonly _document = inject(DOCUMENT);\n\n    /** @hidden */\n    constructor() {\n        this._focusableObserver\n            .observe(this.elementRef, false)\n            .pipe(takeUntil(this._destroy$))\n            .subscribe((isFocusable) => {\n                if (!isFocusable && isFocusable !== this.fdkFocusableItem) {\n                    this.fdkFocusableItem = isFocusable;\n                }\n            });\n\n        this._zone.runOutsideAngular(() => {\n            fromEvent(this.elementRef.nativeElement, 'focusin')\n                .pipe(takeUntil(this._destroy$))\n                .subscribe(async () => {\n                    await this._onFocusin();\n                });\n\n            fromEvent(this.elementRef.nativeElement, 'focusout')\n                .pipe(takeUntil(this._destroy$))\n                .subscribe(() => {\n                    this._onFocusout();\n                });\n\n            fromEvent<KeyboardEvent>(this.elementRef.nativeElement, 'keydown')\n                .pipe(takeUntil(this._destroy$))\n                .subscribe((event) => {\n                    this._onKeydown(event);\n                });\n        });\n    }\n\n    /** Set tabbable state */\n    setTabbable(state: boolean): void {\n        this._tabbable = state;\n\n        if (state) {\n            this._enableTabbableElements();\n        } else {\n            this._disableTabbableElements();\n        }\n    }\n\n    /** @hidden */\n    private async _onFocusin(): Promise<void> {\n        if (!this.fdkFocusableItem) {\n            return;\n        }\n\n        if (this._timerId != null) {\n            clearTimeout(this._timerId);\n            this._timerId = null;\n            return;\n        }\n\n        if (this._position) {\n            this.cellFocused.next(this._position);\n\n            if (this.cellFocusedEventAnnouncer) {\n                this._liveAnnouncer.clear();\n                await this._liveAnnouncer.announce(this.cellFocusedEventAnnouncer(this._position));\n            }\n        }\n    }\n\n    /** @hidden */\n    private _onFocusout(): void {\n        if (!this.fdkFocusableItem) {\n            return;\n        }\n\n        // Timeout is needed to prevent focusout event from being emitted when focus moves between item's children.\n        this._timerId = setTimeout(() => (this._timerId = null));\n    }\n\n    /** @hidden */\n    private _onKeydown(event: KeyboardEvent): void {\n        if (!this.fdkFocusableItem) {\n            return;\n        }\n\n        const isFocused = this._document.activeElement === this.elementRef.nativeElement;\n        const shouldFocusChild = KeyUtil.isKeyCode(event, [ENTER, MAC_ENTER, F2]) && !event.shiftKey && isFocused;\n        const shouldFocusCell =\n            ((KeyUtil.isKeyCode(event, F2) && event.shiftKey) || KeyUtil.isKeyCode(event, ESCAPE)) && !isFocused;\n\n        if (shouldFocusChild) {\n            event.stopPropagation();\n\n            const tabbableElement = this._tabbableElementService.getTabbableElement(\n                this.elementRef.nativeElement,\n                false,\n                true\n            );\n\n            tabbableElement?.focus();\n\n            return;\n        } else if (shouldFocusCell) {\n            event.stopPropagation();\n\n            this.elementRef.nativeElement.focus();\n\n            return;\n        }\n\n        if (isFocused) {\n            this._keydown$.next(event);\n        }\n    }\n\n    /** @hidden */\n    private _enableTabbableElements(): void {\n        if (this._tabbableElements.size === 0) {\n            return;\n        }\n\n        this._tabbableElements.forEach((tabIndex, element) => (element.tabIndex = tabIndex));\n        this._tabbable = false;\n    }\n\n    /** @hidden */\n    private _disableTabbableElements(): void {\n        // Since we cannot select by tabindex attribute (links, inputs, buttons might not have one but still can be focusable),\n        // Select all elements from the cell and filter by tabIndex property.\n        Array.from(this.elementRef.nativeElement.querySelectorAll<HTMLElement>('*'))\n            .filter((elm) => elm.tabIndex >= 0)\n            .forEach((elm) => {\n                this._tabbableElements.set(elm, elm.tabIndex);\n                elm.tabIndex = -1;\n            });\n    }\n\n    /** @hidden */\n    private _defaultItemFocusedEventAnnouncer(position: FocusableItemPosition): string {\n        return `Column ${position.colIndex + 1} of ${position.totalCols}, row: ${position.rowIndex + 1} of ${\n            position.totalRows\n        }`;\n    }\n}\n"]}

package/{esm2020 → esm2022}/utils/directives/focusable-item/focusable-item.module.mjs

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

package/{esm2020 → esm2022}/utils/directives/focusable-item/focusable.observer.mjs

@@ -34,13 +34,13 @@ export class FocusableObserver {
     unobserve(element) {
         this._attributeObserver.unobserve(element);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableObserver, deps: [{ token: i1.AttributeObserver }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableObserver, providedIn: 'root' }); }
 }
-FocusableObserver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FocusableObserver, deps: [{ token: i1.AttributeObserver }], target: i0.ɵɵFactoryTarget.Injectable });
-FocusableObserver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FocusableObserver, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FocusableObserver, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: FocusableObserver, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.AttributeObserver }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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