@fundamental-ngx/cdk 0.38.3-rc.4

package/esm2020/utils/directives/disabled/disabled.observer.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { getNativeElement } from '../../helpers/get-native-element';
+import { AttributeObserver } from '../../services/observers/attribute.observer';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/observers/attribute.observer";
+export class DisabledObserver {
+    /** @hidden */
+    constructor(_attributeObserver) {
+        this._attributeObserver = _attributeObserver;
+    }
+    /** @hidden */
+    static isDisabled(el) {
+        return (el.hasAttribute('disabled') ||
+            el.getAttribute('aria-disabled') === 'true' ||
+            el.classList.contains('is-disabled'));
+    }
+    /** @hidden */
+    observe(element) {
+        return this._attributeObserver.observe(element).pipe(map(() => DisabledObserver.isDisabled(getNativeElement(element))), distinctUntilChanged());
+    }
+    /** @hidden */
+    unobserve(element) {
+        this._attributeObserver.unobserve(element);
+    }
+}
+DisabledObserver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DisabledObserver, deps: [{ token: i1.AttributeObserver }], target: i0.ɵɵFactoryTarget.Injectable });
+DisabledObserver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DisabledObserver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DisabledObserver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AttributeObserver }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/directives/disabled/fdk-disabled-provider.service.mjs

@@ -0,0 +1,101 @@
+import { ElementRef, Inject, Injectable, NgZone, Optional, Self, SkipSelf } from '@angular/core';
+import { BehaviorSubject, combineLatest, firstValueFrom, ReplaySubject, Subject } from 'rxjs';
+import { distinctUntilChanged, startWith, takeUntil, tap } from 'rxjs/operators';
+import { FDK_DISABLED_DIRECTIVE } from './fdk-disabled.token';
+import { DisabledObserver } from './disabled.observer';
+import { DefaultDisabledViewModifier } from './default-disabled-view-modifier';
+import * as i0 from "@angular/core";
+import * as i1 from "./disabled.observer";
+export class FdkDisabledProvider extends ReplaySubject {
+    /** @hidden */
+    constructor(ngZone, elementRef, disabledObserver, selfDisabled$, parentDisabled$) {
+        super(1);
+        this.ngZone = ngZone;
+        this.elementRef = elementRef;
+        this.disabledObserver = disabledObserver;
+        this.selfDisabled$ = selfDisabled$;
+        this.parentDisabled$ = parentDisabled$;
+        /** @Hidden */
+        this.fdkDisabled = false;
+        /** @Hidden */
+        this._destroy$ = new Subject();
+        /** @hidden */
+        this._viewModifiers$ = new BehaviorSubject(this._getInitialViewModifiers());
+        /** @hidden */
+        this._disabledChange$ = this._getDisabledChange$();
+        combineLatest([this._disabledChange$, this._viewModifiers$])
+            .pipe(tap(([isDisabled]) => this.setDisabledState(isDisabled)), takeUntil(this._destroy$))
+            .subscribe();
+        this._disabledChange$
+            .pipe(tap((isDisabled) => (this.fdkDisabled = isDisabled)), tap((isDisabled) => this.next(isDisabled)), takeUntil(this._destroy$))
+            .subscribe();
+    }
+    /** @hidden */
+    addViewModifier(modifier) {
+        const viewModifiers = [...new Set([...this._viewModifiers$.value, modifier]).values()];
+        this._viewModifiers$.next(viewModifiers);
+    }
+    /** @hidden */
+    setDisabledState(isDisabled) {
+        firstValueFrom(this.ngZone.onStable).then(() => {
+            this._viewModifiers$.value.forEach((viewModifier) => viewModifier.setDisabledState(isDisabled));
+        });
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this.complete();
+        this._destroy$.next();
+        this.disabledObserver.unobserve(this.elementRef);
+    }
+    /** @hidden */
+    _getDisabledChange$() {
+        let selfDisabled = false;
+        let parentDisabled = false;
+        if (this.parentDisabled$) {
+            this.parentDisabled$
+                .pipe(startWith(this.parentDisabled$.fdkDisabled), tap((d) => (parentDisabled = d)), distinctUntilChanged(), tap(() => {
+                if (parentDisabled) {
+                    this.setDisabledState(true);
+                }
+                if (!selfDisabled && !parentDisabled) {
+                    this.setDisabledState(false);
+                }
+            }), takeUntil(this._destroy$))
+                .subscribe();
+        }
+        if (this.selfDisabled$) {
+            this.selfDisabled$
+                .pipe(startWith(this.selfDisabled$.fdkDisabled), tap((d) => (selfDisabled = d)), distinctUntilChanged(), tap((isDisabled) => {
+                if (!parentDisabled) {
+                    this.setDisabledState(isDisabled);
+                }
+            }), takeUntil(this._destroy$))
+                .subscribe();
+        }
+        return this.disabledObserver.observe(this.elementRef).pipe(distinctUntilChanged());
+    }
+    /** @hidden */
+    _getInitialViewModifiers() {
+        return !this.selfDisabled$ ? [new DefaultDisabledViewModifier(this.elementRef)] : [this.selfDisabled$];
+    }
+}
+FdkDisabledProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FdkDisabledProvider, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i1.DisabledObserver }, { token: FDK_DISABLED_DIRECTIVE, optional: true, self: true }, { token: FDK_DISABLED_DIRECTIVE, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FdkDisabledProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FdkDisabledProvider });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FdkDisabledProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: i1.DisabledObserver }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [FDK_DISABLED_DIRECTIVE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }, {
+                    type: Inject,
+                    args: [FDK_DISABLED_DIRECTIVE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fdk-disabled-provider.service.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/disabled/fdk-disabled-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, firstValueFrom, Observable, ReplaySubject, Subject } from 'rxjs';\nimport { distinctUntilChanged, startWith, takeUntil, tap } from 'rxjs/operators';\nimport { FDK_DISABLED_DIRECTIVE } from './fdk-disabled.token';\nimport { DisabledObserver } from './disabled.observer';\nimport { DisabledBehavior } from './disabled-behavior.interface';\nimport { DisabledViewModifier } from './disabled-view-modifier.interface';\nimport { DefaultDisabledViewModifier } from './default-disabled-view-modifier';\n\n@Injectable()\nexport class FdkDisabledProvider extends ReplaySubject<boolean> implements DisabledBehavior, OnDestroy {\n    /** @Hidden */\n    fdkDisabled = false;\n    /** @Hidden */\n    private readonly _destroy$ = new Subject<void>();\n    /** @hidden */\n    private readonly _viewModifiers$: BehaviorSubject<DisabledViewModifier[]> = new BehaviorSubject<\n        DisabledViewModifier[]\n    >(this._getInitialViewModifiers());\n    /** @hidden */\n    private _disabledChange$: Observable<boolean> = this._getDisabledChange$();\n\n    /** @hidden */\n    constructor(\n        private ngZone: NgZone,\n        private elementRef: ElementRef<HTMLElement>,\n        private disabledObserver: DisabledObserver,\n        @Optional() @Self() @Inject(FDK_DISABLED_DIRECTIVE) private selfDisabled$?: DisabledBehavior,\n        @Optional() @SkipSelf() @Inject(FDK_DISABLED_DIRECTIVE) private parentDisabled$?: DisabledBehavior\n    ) {\n        super(1);\n        combineLatest([this._disabledChange$, this._viewModifiers$])\n            .pipe(\n                tap(([isDisabled]) => this.setDisabledState(isDisabled)),\n                takeUntil(this._destroy$)\n            )\n            .subscribe();\n        this._disabledChange$\n            .pipe(\n                tap((isDisabled) => (this.fdkDisabled = isDisabled)),\n                tap((isDisabled) => this.next(isDisabled)),\n                takeUntil(this._destroy$)\n            )\n            .subscribe();\n    }\n\n    /** @hidden */\n    addViewModifier(modifier: DisabledViewModifier): void {\n        const viewModifiers = [...new Set([...this._viewModifiers$.value, modifier]).values()];\n        this._viewModifiers$.next(viewModifiers);\n    }\n\n    /** @hidden */\n    setDisabledState(isDisabled: boolean): void {\n        firstValueFrom(this.ngZone.onStable).then(() => {\n            this._viewModifiers$.value.forEach((viewModifier) => viewModifier.setDisabledState(isDisabled));\n        });\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this.complete();\n        this._destroy$.next();\n        this.disabledObserver.unobserve(this.elementRef);\n    }\n\n    /** @hidden */\n    private _getDisabledChange$(): Observable<boolean> {\n        let selfDisabled = false;\n        let parentDisabled = false;\n\n        if (this.parentDisabled$) {\n            this.parentDisabled$\n                .pipe(\n                    startWith(this.parentDisabled$.fdkDisabled),\n                    tap((d) => (parentDisabled = d)),\n                    distinctUntilChanged(),\n                    tap(() => {\n                        if (parentDisabled) {\n                            this.setDisabledState(true);\n                        }\n                        if (!selfDisabled && !parentDisabled) {\n                            this.setDisabledState(false);\n                        }\n                    }),\n                    takeUntil(this._destroy$)\n                )\n                .subscribe();\n        }\n        if (this.selfDisabled$) {\n            this.selfDisabled$\n                .pipe(\n                    startWith(this.selfDisabled$.fdkDisabled),\n                    tap((d) => (selfDisabled = d)),\n                    distinctUntilChanged(),\n                    tap((isDisabled) => {\n                        if (!parentDisabled) {\n                            this.setDisabledState(isDisabled);\n                        }\n                    }),\n                    takeUntil(this._destroy$)\n                )\n                .subscribe();\n        }\n        return this.disabledObserver.observe(this.elementRef).pipe(distinctUntilChanged());\n    }\n\n    /** @hidden */\n    private _getInitialViewModifiers(): DisabledViewModifier[] {\n        return !this.selfDisabled$ ? [new DefaultDisabledViewModifier(this.elementRef)] : [this.selfDisabled$];\n    }\n}\n"]}

package/esm2020/utils/directives/disabled/fdk-disabled.token.mjs

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

package/esm2020/utils/directives/disabled/index.mjs

@@ -0,0 +1,9 @@
+export * from './disabled-behavior.directive';
+export * from './disabled-behavior.module';
+export * from './set-disabled-state';
+export * from './disabled-behavior.interface';
+export * from './disabled-view-modifier.interface';
+export * from './disabled.observer';
+export * from './fdk-disabled.token';
+export * from './fdk-disabled-provider.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvZGlzYWJsZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaXNhYmxlZC1iZWhhdmlvci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNhYmxlZC1iZWhhdmlvci5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXQtZGlzYWJsZWQtc3RhdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNhYmxlZC1iZWhhdmlvci5pbnRlcmZhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXNhYmxlZC12aWV3LW1vZGlmaWVyLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2Rpc2FibGVkLm9ic2VydmVyJztcbmV4cG9ydCAqIGZyb20gJy4vZmRrLWRpc2FibGVkLnRva2VuJztcbmV4cG9ydCAqIGZyb20gJy4vZmRrLWRpc2FibGVkLXByb3ZpZGVyLnNlcnZpY2UnO1xuIl19

package/esm2020/utils/directives/disabled/set-disabled-state.mjs

@@ -0,0 +1,16 @@
+import { getNativeElement } from '../../helpers/get-native-element';
+/** @hidden */
+export function setDisabledState(element, isDisabled) {
+    const htmlElement = getNativeElement(element);
+    if (isDisabled) {
+        htmlElement.classList.add('is-disabled');
+        htmlElement.setAttribute('disabled', '');
+        htmlElement.setAttribute('aria-disabled', 'true');
+    }
+    else {
+        htmlElement.classList.remove('is-disabled');
+        htmlElement.removeAttribute('disabled');
+        htmlElement.removeAttribute('aria-disabled');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0LWRpc2FibGVkLXN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL2Rpc2FibGVkL3NldC1kaXNhYmxlZC1zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUdwRSxjQUFjO0FBQ2QsTUFBTSxVQUFVLGdCQUFnQixDQUM1QixPQUErRCxFQUMvRCxVQUFtQjtJQUVuQixNQUFNLFdBQVcsR0FBRyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM5QyxJQUFJLFVBQVUsRUFBRTtRQUNaLFdBQVcsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQ3pDLFdBQVcsQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3pDLFdBQVcsQ0FBQyxZQUFZLENBQUMsZUFBZSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0tBQ3JEO1NBQU07UUFDSCxXQUFXLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUM1QyxXQUFXLENBQUMsZUFBZSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ3hDLFdBQVcsQ0FBQyxlQUFlLENBQUMsZUFBZSxDQUFDLENBQUM7S0FDaEQ7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRWxlbWVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgZ2V0TmF0aXZlRWxlbWVudCB9IGZyb20gJy4uLy4uL2hlbHBlcnMvZ2V0LW5hdGl2ZS1lbGVtZW50JztcbmltcG9ydCB7IEhhc0VsZW1lbnRSZWYgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2VzL2hhcy1lbGVtZW50LXJlZi5pbnRlcmZhY2UnO1xuXG4vKiogQGhpZGRlbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNldERpc2FibGVkU3RhdGUoXG4gICAgZWxlbWVudDogSGFzRWxlbWVudFJlZjxFbGVtZW50PiB8IEVsZW1lbnQgfCBFbGVtZW50UmVmPEVsZW1lbnQ+LFxuICAgIGlzRGlzYWJsZWQ6IGJvb2xlYW5cbik6IHZvaWQge1xuICAgIGNvbnN0IGh0bWxFbGVtZW50ID0gZ2V0TmF0aXZlRWxlbWVudChlbGVtZW50KTtcbiAgICBpZiAoaXNEaXNhYmxlZCkge1xuICAgICAgICBodG1sRWxlbWVudC5jbGFzc0xpc3QuYWRkKCdpcy1kaXNhYmxlZCcpO1xuICAgICAgICBodG1sRWxlbWVudC5zZXRBdHRyaWJ1dGUoJ2Rpc2FibGVkJywgJycpO1xuICAgICAgICBodG1sRWxlbWVudC5zZXRBdHRyaWJ1dGUoJ2FyaWEtZGlzYWJsZWQnLCAndHJ1ZScpO1xuICAgIH0gZWxzZSB7XG4gICAgICAgIGh0bWxFbGVtZW50LmNsYXNzTGlzdC5yZW1vdmUoJ2lzLWRpc2FibGVkJyk7XG4gICAgICAgIGh0bWxFbGVtZW50LnJlbW92ZUF0dHJpYnV0ZSgnZGlzYWJsZWQnKTtcbiAgICAgICAgaHRtbEVsZW1lbnQucmVtb3ZlQXR0cmlidXRlKCdhcmlhLWRpc2FibGVkJyk7XG4gICAgfVxufVxuIl19

package/esm2020/utils/directives/focus-key-manager/focus-key-manager-helpers.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { FocusKeyManagerItemDirective, DeprecatedFocusKeyManagerItemDirective } from './focus-key-manager-item.directive';
+import { DeprecatedFocusKeyManagerListDirective, FocusKeyManagerListDirective } from './focus-key-manager-list.directive';
+import * as i0 from "@angular/core";
+export class FocusKeyManagerHelpersModule {
+}
+FocusKeyManagerHelpersModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusKeyManagerHelpersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FocusKeyManagerHelpersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: FocusKeyManagerHelpersModule, imports: [FocusKeyManagerItemDirective,
+        FocusKeyManagerListDirective,
+        DeprecatedFocusKeyManagerItemDirective,
+        DeprecatedFocusKeyManagerListDirective], exports: [FocusKeyManagerItemDirective,
+        FocusKeyManagerListDirective,
+        DeprecatedFocusKeyManagerItemDirective,
+        DeprecatedFocusKeyManagerListDirective] });
+FocusKeyManagerHelpersModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusKeyManagerHelpersModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusKeyManagerHelpersModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        FocusKeyManagerItemDirective,
+                        FocusKeyManagerListDirective,
+                        DeprecatedFocusKeyManagerItemDirective,
+                        DeprecatedFocusKeyManagerListDirective
+                    ],
+                    exports: [
+                        FocusKeyManagerItemDirective,
+                        FocusKeyManagerListDirective,
+                        DeprecatedFocusKeyManagerItemDirective,
+                        DeprecatedFocusKeyManagerListDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/directives/focus-key-manager/focus-key-manager-item.directive.mjs

@@ -0,0 +1,98 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, ElementRef, forwardRef, HostBinding, HostListener, Input } from '@angular/core';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import { FocusKeyManagerListDirective } from './focus-key-manager-list.directive';
+import { FOCUSABLE_ITEM } from './focus-key-manager.tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "./focus-key-manager-list.directive";
+export class DeprecatedFocusKeyManagerItemDirective extends DeprecatedSelector {
+}
+DeprecatedFocusKeyManagerItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedFocusKeyManagerItemDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DeprecatedFocusKeyManagerItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DeprecatedFocusKeyManagerItemDirective, isStandalone: true, selector: "[fd-focus-key-manager-item], [fdFocusKeyManagerItem]", providers: [
+        {
+            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+            useValue: getDeprecatedModel('[fdkFocusKeyManagerItem]', '[fd-focus-key-manager-item], [fdFocusKeyManagerItem]')
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedFocusKeyManagerItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fd-focus-key-manager-item], [fdFocusKeyManagerItem]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkFocusKeyManagerItem]', '[fd-focus-key-manager-item], [fdFocusKeyManagerItem]')
+                        }
+                    ]
+                }]
+        }] });
+/** Directive to apply Angular Material FocusKeyManager to lists.
+ * To be used with FocusKeyManagerItemDirective
+ */
+export class FocusKeyManagerItemDirective {
+    /** @hidden */
+    constructor(_list, _elRef) {
+        this._list = _list;
+        this._elRef = _elRef;
+        /** @hidden */
+        this._initialFocus = false;
+    }
+    /** Whether item should be initially focused */
+    set initialFocus(value) {
+        this._initialFocus = coerceBooleanProperty(value);
+    }
+    /** @hidden */
+    get _tabindex() {
+        if (this._initialFocus) {
+            return 0;
+        }
+        return this.nativeElement?.tabIndex ?? -1;
+    }
+    /** Native element of the item */
+    get nativeElement() {
+        return this._elRef?.nativeElement;
+    }
+    /** @hidden */
+    get _focusKeyManager() {
+        return this._list.focusKeyManager;
+    }
+    /** @hidden */
+    _onFocus() {
+        // For cases where initially selected item doesn't have 0 index
+        this._focusKeyManager?.updateActiveItem(this);
+    }
+    /** @hidden */
+    _onKeydown(event) {
+        this._focusKeyManager?.onKeydown(event);
+    }
+    /** Focus current item native element */
+    focus() {
+        this._elRef?.nativeElement.focus();
+    }
+}
+FocusKeyManagerItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusKeyManagerItemDirective, deps: [{ token: i1.FocusKeyManagerListDirective }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+FocusKeyManagerItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: FocusKeyManagerItemDirective, isStandalone: true, selector: "[fdkFocusKeyManagerItem], [fd-focus-key-manager-item], [fdFocusKeyManagerItem]", inputs: { initialFocus: "initialFocus", _tabindex: "_tabindex" }, host: { listeners: { "focus": "_onFocus()", "keydown": "_onKeydown($event)" }, properties: { "attr.tabindex": "this._tabindex" } }, providers: [{ provide: FOCUSABLE_ITEM, useExisting: forwardRef(() => FocusKeyManagerItemDirective) }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusKeyManagerItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkFocusKeyManagerItem], [fd-focus-key-manager-item], [fdFocusKeyManagerItem]',
+                    standalone: true,
+                    providers: [{ provide: FOCUSABLE_ITEM, useExisting: forwardRef(() => FocusKeyManagerItemDirective) }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FocusKeyManagerListDirective }, { type: i0.ElementRef }]; }, propDecorators: { initialFocus: [{
+                type: Input
+            }], _tabindex: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], _onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }], _onKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/directives/focus-key-manager/focus-key-manager-list.directive.mjs

@@ -0,0 +1,113 @@
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { ChangeDetectorRef, ContentChildren, Directive, Input, Optional, QueryList } from '@angular/core';
+import { filter, takeUntil } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { RtlService } from '../../services/rtl.service';
+import { FOCUSABLE_ITEM } from './focus-key-manager.tokens';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/rtl.service";
+export class DeprecatedFocusKeyManagerListDirective extends DeprecatedSelector {
+}
+DeprecatedFocusKeyManagerListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedFocusKeyManagerListDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DeprecatedFocusKeyManagerListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DeprecatedFocusKeyManagerListDirective, isStandalone: true, selector: "[fd-focus-key-manager-list], [fdFocusKeyManagerList]", providers: [
+        {
+            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+            useValue: getDeprecatedModel('[fdkFocusKeyManagerList]', '[fd-focus-key-manager-list], [fdFocusKeyManagerList]')
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedFocusKeyManagerListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fd-focus-key-manager-list], [fdFocusKeyManagerList]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkFocusKeyManagerList]', '[fd-focus-key-manager-list], [fdFocusKeyManagerList]')
+                        }
+                    ]
+                }]
+        }] });
+/** Directive to apply Angular Material FocusKeyManager to lists.
+ * To be used with FocusKeyManagerItemDirective
+ */
+export class FocusKeyManagerListDirective {
+    /** @hidden */
+    constructor(_rtlService, _cdr) {
+        this._rtlService = _rtlService;
+        this._cdr = _cdr;
+        /** @hidden */
+        this._onDestroy$ = new Subject();
+    }
+    /** @hidden */
+    get focusKeyManager() {
+        return this._focusKeyManager;
+    }
+    /** @hidden */
+    ngOnChanges(changes) {
+        if (!this._focusKeyManager) {
+            return;
+        }
+        if ('orientation' in changes) {
+            this._applyOrientation();
+        }
+        if ('skiPredicate' in changes) {
+            this._focusKeyManager.skipPredicate(this.skipPredicate);
+        }
+    }
+    /** @hidden */
+    ngAfterContentInit() {
+        this._focusKeyManager = new FocusKeyManager(this._items).skipPredicate(this.skipPredicate);
+        this._applyOrientation();
+        this._cdr.detectChanges();
+        this._rtlService?.rtl
+            .pipe(filter(() => this.orientation === 'horizontal'), takeUntil(this._onDestroy$))
+            .subscribe(() => this._applyOrientation());
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._onDestroy$.next();
+        this._onDestroy$.complete();
+    }
+    /** Focus certain list's item */
+    focusItem(item) {
+        if (typeof item === 'number') {
+            this._focusKeyManager.setActiveItem(item);
+        }
+        else {
+            this._focusKeyManager.setActiveItem(item);
+        }
+    }
+    /** @hidden */
+    _applyOrientation() {
+        switch (this.orientation) {
+            case 'horizontal':
+                this._focusKeyManager.withHorizontalOrientation(this._rtlService?.rtl.value ? 'rtl' : 'ltr');
+                break;
+            case 'vertical':
+                this._focusKeyManager.withVerticalOrientation(true);
+                break;
+        }
+    }
+}
+FocusKeyManagerListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusKeyManagerListDirective, deps: [{ token: i1.RtlService, optional: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+FocusKeyManagerListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: FocusKeyManagerListDirective, isStandalone: true, selector: "[fdkFocusKeyManagerList], [fd-focus-key-manager-list], [fdFocusKeyManagerList]", inputs: { orientation: "orientation", skipPredicate: "skipPredicate" }, queries: [{ propertyName: "_items", predicate: FOCUSABLE_ITEM }], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FocusKeyManagerListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[fdkFocusKeyManagerList], [fd-focus-key-manager-list], [fdFocusKeyManagerList]`,
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.RtlService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { orientation: [{
+                type: Input
+            }], skipPredicate: [{
+                type: Input
+            }], _items: [{
+                type: ContentChildren,
+                args: [FOCUSABLE_ITEM]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"focus-key-manager-list.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/focus-key-manager/focus-key-manager-list.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusableOption, FocusKeyManager } from '@angular/cdk/a11y';\nimport {\n    AfterContentInit,\n    ChangeDetectorRef,\n    ContentChildren,\n    Directive,\n    Input,\n    OnChanges,\n    OnDestroy,\n    Optional,\n    QueryList,\n    SimpleChanges\n} from '@angular/core';\nimport { filter, takeUntil } from 'rxjs/operators';\nimport { Subject } from 'rxjs';\n\nimport { RtlService } from '../../services/rtl.service';\nimport { FOCUSABLE_ITEM } from './focus-key-manager.tokens';\nimport {\n    DeprecatedSelector,\n    FD_DEPRECATED_DIRECTIVE_SELECTOR,\n    getDeprecatedModel\n} from '../../deprecated-selector.class';\n\n@Directive({\n    // eslint-disable-next-line @angular-eslint/directive-selector\n    selector: '[fd-focus-key-manager-list], [fdFocusKeyManagerList]',\n    standalone: true,\n    providers: [\n        {\n            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,\n            useValue: getDeprecatedModel(\n                '[fdkFocusKeyManagerList]',\n                '[fd-focus-key-manager-list], [fdFocusKeyManagerList]'\n            )\n        }\n    ]\n})\nexport class DeprecatedFocusKeyManagerListDirective extends DeprecatedSelector {}\n\n/** Directive to apply Angular Material FocusKeyManager to lists.\n * To be used with FocusKeyManagerItemDirective\n */\n@Directive({\n    selector: `[fdkFocusKeyManagerList], [fd-focus-key-manager-list], [fdFocusKeyManagerList]`,\n    standalone: true\n})\nexport class FocusKeyManagerListDirective implements OnChanges, AfterContentInit, OnDestroy {\n    /** Orientation for the FocusKeyManager */\n    @Input()\n    orientation: 'horizontal' | 'vertical';\n\n    /** Skip predicate for the FocusKeyManager */\n    @Input()\n    skipPredicate: (item: Record<any, any> & FocusableOption) => boolean;\n\n    /** @hidden */\n    @ContentChildren(FOCUSABLE_ITEM)\n    readonly _items: QueryList<FocusableOption>;\n\n    /** @hidden */\n    get focusKeyManager(): FocusKeyManager<FocusableOption> {\n        return this._focusKeyManager;\n    }\n\n    /** @hidden */\n    private _focusKeyManager: FocusKeyManager<FocusableOption>;\n\n    /** @hidden */\n    private readonly _onDestroy$ = new Subject<void>();\n\n    /** @hidden */\n    constructor(@Optional() private readonly _rtlService: RtlService, private readonly _cdr: ChangeDetectorRef) {}\n\n    /** @hidden */\n    ngOnChanges(changes: SimpleChanges): void {\n        if (!this._focusKeyManager) {\n            return;\n        }\n\n        if ('orientation' in changes) {\n            this._applyOrientation();\n        }\n\n        if ('skiPredicate' in changes) {\n            this._focusKeyManager.skipPredicate(this.skipPredicate);\n        }\n    }\n\n    /** @hidden */\n    ngAfterContentInit(): void {\n        this._focusKeyManager = new FocusKeyManager<FocusableOption>(this._items).skipPredicate(this.skipPredicate);\n\n        this._applyOrientation();\n\n        this._cdr.detectChanges();\n\n        this._rtlService?.rtl\n            .pipe(\n                filter(() => this.orientation === 'horizontal'),\n                takeUntil(this._onDestroy$)\n            )\n            .subscribe(() => this._applyOrientation());\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._onDestroy$.next();\n        this._onDestroy$.complete();\n    }\n\n    /** Focus certain list's item */\n    focusItem(item: number | FocusableOption): any {\n        if (typeof item === 'number') {\n            this._focusKeyManager.setActiveItem(item);\n        } else {\n            this._focusKeyManager.setActiveItem(item);\n        }\n    }\n\n    /** @hidden */\n    private _applyOrientation(): void {\n        switch (this.orientation) {\n            case 'horizontal':\n                this._focusKeyManager.withHorizontalOrientation(this._rtlService?.rtl.value ? 'rtl' : 'ltr');\n                break;\n            case 'vertical':\n                this._focusKeyManager.withVerticalOrientation(true);\n                break;\n        }\n    }\n}\n"]}

package/esm2020/utils/directives/focus-key-manager/focus-key-manager.tokens.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const FOCUSABLE_ITEM = new InjectionToken('Focusable Option');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMta2V5LW1hbmFnZXIudG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL2ZvY3VzLWtleS1tYW5hZ2VyL2ZvY3VzLWtleS1tYW5hZ2VyLnRva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxJQUFJLGNBQWMsQ0FBa0Isa0JBQWtCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZvY3VzYWJsZU9wdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9hMTF5JztcbmltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBGT0NVU0FCTEVfSVRFTSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxGb2N1c2FibGVPcHRpb24+KCdGb2N1c2FibGUgT3B0aW9uJyk7XG4iXX0=

package/esm2020/utils/directives/focus-key-manager/index.mjs

@@ -0,0 +1,5 @@
+export * from './focus-key-manager-helpers.module';
+export * from './focus-key-manager-item.directive';
+export * from './focus-key-manager-list.directive';
+export * from './focus-key-manager.tokens';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvZm9jdXMta2V5LW1hbmFnZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZm9jdXMta2V5LW1hbmFnZXItaGVscGVycy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9mb2N1cy1rZXktbWFuYWdlci1pdGVtLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZvY3VzLWtleS1tYW5hZ2VyLWxpc3QuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9jdXMta2V5LW1hbmFnZXIudG9rZW5zJztcbiJdfQ==

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

@@ -0,0 +1,14 @@
+import { setFocusable } from './set-focusable';
+export class DefaultFocusableItemViewModifier {
+    /** @hidden */
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    /**
+     * Sets tabindex attribute value depending on whether element is focusable.
+     */
+    setFocusable(isFocusable) {
+        setFocusable(this.elementRef, isFocusable);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1mb2N1c2FibGUtaXRlbS12aWV3LW1vZGlmaWVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL2ZvY3VzYWJsZS1pdGVtL2RlZmF1bHQtZm9jdXNhYmxlLWl0ZW0tdmlldy1tb2RpZmllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFL0MsTUFBTSxPQUFPLGdDQUFnQztJQUN6QyxjQUFjO0lBQ2QsWUFBb0IsVUFBK0I7UUFBL0IsZUFBVSxHQUFWLFVBQVUsQ0FBcUI7SUFBRyxDQUFDO0lBRXZEOztPQUVHO0lBQ0gsWUFBWSxDQUFDLFdBQW9CO1FBQzdCLFlBQVksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLFdBQVcsQ0FBQyxDQUFDO0lBQy9DLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVsZW1lbnRSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZvY3VzYWJsZUl0ZW1WaWV3TW9kaWZpZXIgfSBmcm9tICcuL2ZvY3VzYWJsZS1pdGVtLXZpZXctbW9kaWZpZXIuaW50ZXJmYWNlJztcbmltcG9ydCB7IHNldEZvY3VzYWJsZSB9IGZyb20gJy4vc2V0LWZvY3VzYWJsZSc7XG5cbmV4cG9ydCBjbGFzcyBEZWZhdWx0Rm9jdXNhYmxlSXRlbVZpZXdNb2RpZmllciBpbXBsZW1lbnRzIEZvY3VzYWJsZUl0ZW1WaWV3TW9kaWZpZXIge1xuICAgIC8qKiBAaGlkZGVuICovXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBlbGVtZW50UmVmOiBFbGVtZW50UmVmPEVsZW1lbnQ+KSB7fVxuXG4gICAgLyoqXG4gICAgICogU2V0cyB0YWJpbmRleCBhdHRyaWJ1dGUgdmFsdWUgZGVwZW5kaW5nIG9uIHdoZXRoZXIgZWxlbWVudCBpcyBmb2N1c2FibGUuXG4gICAgICovXG4gICAgc2V0Rm9jdXNhYmxlKGlzRm9jdXNhYmxlOiBib29sZWFuKTogdm9pZCB7XG4gICAgICAgIHNldEZvY3VzYWJsZSh0aGlzLmVsZW1lbnRSZWYsIGlzRm9jdXNhYmxlKTtcbiAgICB9XG59XG4iXX0=