@fundamental-ngx/cdk 0.38.3-rc.4

package/esm2020/utils/directives/resize/resize.directive.mjs

@@ -0,0 +1,231 @@
+import { ContentChild, Directive, ElementRef, EventEmitter, Input, Optional, Output } from '@angular/core';
+import { ResizeHandleDirective } from './resize-handle.directive';
+import { fromEvent, merge, Subscription } from 'rxjs';
+import { filter, map, mapTo, pairwise, takeUntil, tap } from 'rxjs/operators';
+import { RtlService } from '../../services/rtl.service';
+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 DeprecatedResizeDirective extends DeprecatedSelector {
+}
+DeprecatedResizeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedResizeDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DeprecatedResizeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DeprecatedResizeDirective, isStandalone: true, selector: "[fdResize], [fd-resize]", providers: [
+        {
+            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+            useValue: getDeprecatedModel('[fdkResize]', '[fdResize], [fd-resize]')
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedResizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fdResize], [fd-resize]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkResize]', '[fdResize], [fd-resize]')
+                        }
+                    ]
+                }]
+        }] });
+export class ResizeDirective {
+    /** @hidden */
+    constructor(_elementRef, _rtlService) {
+        this._elementRef = _elementRef;
+        this._rtlService = _rtlService;
+        /** Element limiting resizable container growth */
+        // eslint-disable-next-line @angular-eslint/no-input-rename
+        this.resizeBoundary = 'body';
+        /** Whether resizable behaviour should be disabled */
+        // eslint-disable-next-line @angular-eslint/no-input-rename
+        this.disabled = false;
+        /** Localization of resize handle inside resizable container */
+        // eslint-disable-next-line @angular-eslint/no-input-rename
+        this.resizeHandleLocation = 'bottom-right';
+        /** Emits event when resizing has tarted */
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        this.onResizeStart = new EventEmitter();
+        /** Emits event when resizing has ended */
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        this.onResizeEnd = new EventEmitter();
+        /** @hidden */
+        this._subscriptions = new Subscription();
+        /** @hidden */
+        this._isRtl = false;
+    }
+    /** Resize handle reference - should be used if Resize handle is not a ContentChild of resizable container */
+    // eslint-disable-next-line @angular-eslint/no-input-rename
+    set setResizeHandleReference(value) {
+        this.resizeHandleReference = value;
+    }
+    /** @hidden */
+    ngOnChanges(changes) {
+        if (changes['disabled']) {
+            if (changes['disabled'].previousValue === false && changes['disabled'].currentValue === true) {
+                this._subscriptions.unsubscribe();
+            }
+            else if (changes['disabled'].previousValue === true && changes['disabled'].currentValue === false) {
+                this._setResizeListeners();
+            }
+        }
+    }
+    /** @hidden */
+    ngAfterContentInit() {
+        if (this._rtlService) {
+            this._subscriptions.add(this._rtlService.rtl.subscribe((isRtl) => (this._isRtl = isRtl)));
+        }
+        if (!this.disabled) {
+            this._setResizeListeners();
+        }
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+    }
+    /** @hidden */
+    get _direction() {
+        return this._isRtl ? -1 : 1;
+    }
+    /** @hidden Sets Resize listeners */
+    _setResizeListeners() {
+        const resize = this._getResizeFunction();
+        const moveOffset = this._getMoveOffsetFunction();
+        const resizeContainer = this._findResizeContainer();
+        if (!resizeContainer) {
+            return;
+        }
+        const isBoundaryOverflow = this._getBoundaryOverflowFunction(resizeContainer);
+        const mouseUpEvent$ = fromEvent(window, 'mouseup');
+        const mouseMoveEvent$ = fromEvent(resizeContainer, 'mousemove');
+        const mouseDownEvent$ = fromEvent(this.resizeHandleReference.elementRef.nativeElement, 'mousedown');
+        const resizeActive$ = merge(mouseDownEvent$.pipe(mapTo(true)), mouseUpEvent$.pipe(mapTo(false)));
+        const emitResizableEvents$ = this._getResizeEventsNotifiers(resizeActive$);
+        const preventOtherPointerEvents$ = this._blockOtherPointerEvents(resizeActive$);
+        const resizingCursorMovement$ = mouseMoveEvent$.pipe(pairwise(), map(([event1, event2]) => moveOffset(event1, event2)), filter((move) => isBoundaryOverflow(move)));
+        const setupResizer = () => {
+            resizingCursorMovement$.pipe(takeUntil(mouseUpEvent$)).subscribe((event) => resize(event));
+        };
+        const setupResize$ = resizeActive$.pipe(filter((isActive) => isActive), tap(() => setupResizer()));
+        this._subscriptions.add(setupResize$.subscribe());
+        this._subscriptions.add(emitResizableEvents$.subscribe());
+        this._subscriptions.add(preventOtherPointerEvents$.subscribe());
+    }
+    /** @hidden Creates resize function*/
+    _getResizeFunction() {
+        return (move) => {
+            this._elementRef.nativeElement.style.width = `${this._elementRef.nativeElement.offsetWidth + move.x}px`;
+            this._elementRef.nativeElement.style.height = `${this._elementRef.nativeElement.offsetHeight + move.y}px`;
+        };
+    }
+    /** @hidden Creates move function */
+    _getMoveOffsetFunction() {
+        let verticalModifier;
+        let horizontalModifier;
+        switch (this.resizeHandleLocation) {
+            case 'top-left':
+                horizontalModifier = -1;
+                verticalModifier = -1;
+                break;
+            case 'top-right':
+                horizontalModifier = -1;
+                verticalModifier = 1;
+                break;
+            case 'bottom-left':
+                horizontalModifier = 1;
+                verticalModifier = -1;
+                break;
+            case 'bottom-right':
+                horizontalModifier = 1;
+                verticalModifier = 1;
+                break;
+        }
+        return (event1, event2) => {
+            const x = (event2.screenX - event1.screenX) * this._direction;
+            const y = event2.screenY - event1.screenY;
+            return {
+                x: x * verticalModifier,
+                y: y * horizontalModifier
+            };
+        };
+    }
+    /** @hidden Return boundary container */
+    _findResizeContainer() {
+        let resizeContainer;
+        if (typeof this.resizeBoundary === 'string') {
+            resizeContainer = this._elementRef.nativeElement.closest(this.resizeBoundary);
+        }
+        else {
+            resizeContainer = this.resizeBoundary;
+        }
+        if (resizeContainer) {
+            return resizeContainer;
+        }
+        else {
+            console.warn(`fdResize - Cannot find "${this.resizeBoundary}", falling back to "body"`);
+            return document.querySelector('body');
+        }
+    }
+    /** @hidden Check whether resizable container is overflowing boundary container */
+    _getBoundaryOverflowFunction(resizeContainer) {
+        return (move) => {
+            const containerPosition = resizeContainer.getBoundingClientRect();
+            const elementPosition = this._elementRef.nativeElement.getBoundingClientRect();
+            switch (this.resizeHandleLocation) {
+                case 'top-left':
+                    return (containerPosition.top < elementPosition.top + move.y &&
+                        containerPosition.left < elementPosition.left + move.x);
+                case 'top-right':
+                    return (containerPosition.top < elementPosition.top + move.y &&
+                        containerPosition.right > elementPosition.right + move.x);
+                case 'bottom-left':
+                    return (containerPosition.bottom > elementPosition.bottom + move.y &&
+                        containerPosition.left < elementPosition.left + move.x);
+                case 'bottom-right':
+                    return (containerPosition.bottom > elementPosition.bottom + move.y &&
+                        containerPosition.right > elementPosition.right + move.x);
+            }
+        };
+    }
+    /** @hidden Create Observable notifying on resize actions */
+    _getResizeEventsNotifiers(trigger$) {
+        const emitResizableStart$ = trigger$.pipe(filter((isActive) => isActive), tap(() => this.onResizeStart.emit()));
+        const emitResizableEnd$ = trigger$.pipe(filter((isActive) => !isActive), tap(() => this.onResizeEnd.emit()));
+        return merge(emitResizableStart$, emitResizableEnd$);
+    }
+    /** @hidden Block resizable container pointer events when resizing  */
+    _blockOtherPointerEvents(trigger$) {
+        return trigger$.pipe(map((isActive) => (isActive ? 'none' : 'auto')), tap((value) => (this._elementRef.nativeElement.style.pointerEvents = value)));
+    }
+}
+ResizeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeDirective, deps: [{ token: i0.ElementRef }, { token: i1.RtlService, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ResizeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: ResizeDirective, isStandalone: true, selector: "[fdkResize], [fdResize], [fd-resize]", inputs: { resizeBoundary: ["fdkResizeBoundary", "resizeBoundary"], disabled: ["fdkResizeDisabled", "disabled"], resizeHandleLocation: ["fdkResizeHandleLocation", "resizeHandleLocation"], setResizeHandleReference: ["fdkResizeResizeHandleRef", "setResizeHandleReference"] }, outputs: { onResizeStart: "onResizeStart", onResizeEnd: "onResizeEnd" }, queries: [{ propertyName: "resizeHandleReference", first: true, predicate: ResizeHandleDirective, descendants: true }], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkResize], [fdResize], [fd-resize]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.RtlService, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { resizeBoundary: [{
+                type: Input,
+                args: ['fdkResizeBoundary']
+            }], disabled: [{
+                type: Input,
+                args: ['fdkResizeDisabled']
+            }], resizeHandleLocation: [{
+                type: Input,
+                args: ['fdkResizeHandleLocation']
+            }], setResizeHandleReference: [{
+                type: Input,
+                args: ['fdkResizeResizeHandleRef']
+            }], onResizeStart: [{
+                type: Output
+            }], onResizeEnd: [{
+                type: Output
+            }], resizeHandleReference: [{
+                type: ContentChild,
+                args: [ResizeHandleDirective, { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resize.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/resize/resize.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    ContentChild,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    Input,\n    OnChanges,\n    OnDestroy,\n    Optional,\n    Output,\n    SimpleChanges\n} from '@angular/core';\nimport { ResizeHandleDirective } from './resize-handle.directive';\nimport { fromEvent, merge, Observable, Subscription } from 'rxjs';\nimport { filter, map, mapTo, pairwise, takeUntil, tap } from 'rxjs/operators';\nimport { RtlService } from '../../services/rtl.service';\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: '[fdResize], [fd-resize]',\n    standalone: true,\n    providers: [\n        {\n            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,\n            useValue: getDeprecatedModel('[fdkResize]', '[fdResize], [fd-resize]')\n        }\n    ]\n})\nexport class DeprecatedResizeDirective extends DeprecatedSelector {}\n\ninterface ResizeMove {\n    x: number;\n    y: number;\n}\n\n@Directive({\n    selector: '[fdkResize], [fdResize], [fd-resize]',\n    standalone: true\n})\nexport class ResizeDirective implements OnChanges, AfterContentInit, OnDestroy {\n    /** Element limiting resizable container growth */\n    // eslint-disable-next-line @angular-eslint/no-input-rename\n    @Input('fdkResizeBoundary') resizeBoundary: string | HTMLElement = 'body';\n\n    /** Whether resizable behaviour should be disabled */\n    // eslint-disable-next-line @angular-eslint/no-input-rename\n    @Input('fdkResizeDisabled') disabled = false;\n\n    /** Localization of resize handle inside resizable container */\n    // eslint-disable-next-line @angular-eslint/no-input-rename\n    @Input('fdkResizeHandleLocation') resizeHandleLocation: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' =\n        'bottom-right';\n\n    /** Resize handle reference - should be used if Resize handle is not a ContentChild of resizable container */\n    // eslint-disable-next-line @angular-eslint/no-input-rename\n    @Input('fdkResizeResizeHandleRef') set setResizeHandleReference(value: ResizeHandleDirective) {\n        this.resizeHandleReference = value;\n    }\n\n    /** Emits event when resizing has tarted */\n    // eslint-disable-next-line @angular-eslint/no-output-on-prefix\n    @Output() onResizeStart = new EventEmitter<void>();\n\n    /** Emits event when resizing has ended */\n    // eslint-disable-next-line @angular-eslint/no-output-on-prefix\n    @Output() onResizeEnd = new EventEmitter<void>();\n\n    /** @hidden Reference to Resize handle */\n    @ContentChild(ResizeHandleDirective, { static: false }) resizeHandleReference;\n\n    /** @hidden */\n    private _subscriptions = new Subscription();\n\n    /** @hidden */\n    private _isRtl = false;\n\n    /** @hidden */\n    constructor(private _elementRef: ElementRef<HTMLElement>, @Optional() private _rtlService: RtlService) {}\n\n    /** @hidden */\n    ngOnChanges(changes: SimpleChanges): void {\n        if (changes['disabled']) {\n            if (changes['disabled'].previousValue === false && changes['disabled'].currentValue === true) {\n                this._subscriptions.unsubscribe();\n            } else if (changes['disabled'].previousValue === true && changes['disabled'].currentValue === false) {\n                this._setResizeListeners();\n            }\n        }\n    }\n\n    /** @hidden */\n    ngAfterContentInit(): void {\n        if (this._rtlService) {\n            this._subscriptions.add(this._rtlService.rtl.subscribe((isRtl) => (this._isRtl = isRtl)));\n        }\n\n        if (!this.disabled) {\n            this._setResizeListeners();\n        }\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._subscriptions.unsubscribe();\n    }\n\n    /** @hidden */\n    private get _direction(): number {\n        return this._isRtl ? -1 : 1;\n    }\n\n    /** @hidden Sets Resize listeners */\n    private _setResizeListeners(): void {\n        const resize = this._getResizeFunction();\n        const moveOffset = this._getMoveOffsetFunction();\n        const resizeContainer = this._findResizeContainer();\n        if (!resizeContainer) {\n            return;\n        }\n        const isBoundaryOverflow = this._getBoundaryOverflowFunction(resizeContainer);\n\n        const mouseUpEvent$ = fromEvent<MouseEvent>(window, 'mouseup');\n        const mouseMoveEvent$ = fromEvent<MouseEvent>(resizeContainer, 'mousemove');\n        const mouseDownEvent$ = fromEvent<MouseEvent>(this.resizeHandleReference.elementRef.nativeElement, 'mousedown');\n\n        const resizeActive$ = merge(mouseDownEvent$.pipe(mapTo(true)), mouseUpEvent$.pipe(mapTo(false)));\n        const emitResizableEvents$ = this._getResizeEventsNotifiers(resizeActive$);\n        const preventOtherPointerEvents$ = this._blockOtherPointerEvents(resizeActive$);\n\n        const resizingCursorMovement$ = mouseMoveEvent$.pipe(\n            pairwise(),\n            map(([event1, event2]: [MouseEvent, MouseEvent]) => moveOffset(event1, event2)),\n            filter((move) => isBoundaryOverflow(move))\n        );\n\n        const setupResizer = (): void => {\n            resizingCursorMovement$.pipe(takeUntil(mouseUpEvent$)).subscribe((event) => resize(event));\n        };\n        const setupResize$ = resizeActive$.pipe(\n            filter((isActive) => isActive),\n            tap(() => setupResizer())\n        );\n\n        this._subscriptions.add(setupResize$.subscribe());\n        this._subscriptions.add(emitResizableEvents$.subscribe());\n        this._subscriptions.add(preventOtherPointerEvents$.subscribe());\n    }\n\n    /** @hidden Creates resize function*/\n    private _getResizeFunction(): (move: ResizeMove) => void {\n        return (move: ResizeMove) => {\n            this._elementRef.nativeElement.style.width = `${this._elementRef.nativeElement.offsetWidth + move.x}px`;\n            this._elementRef.nativeElement.style.height = `${this._elementRef.nativeElement.offsetHeight + move.y}px`;\n        };\n    }\n\n    /** @hidden Creates move function */\n    private _getMoveOffsetFunction(): (event1: MouseEvent, event2: MouseEvent) => ResizeMove {\n        let verticalModifier: 1 | -1;\n        let horizontalModifier: 1 | -1;\n\n        switch (this.resizeHandleLocation) {\n            case 'top-left':\n                horizontalModifier = -1;\n                verticalModifier = -1;\n                break;\n            case 'top-right':\n                horizontalModifier = -1;\n                verticalModifier = 1;\n                break;\n            case 'bottom-left':\n                horizontalModifier = 1;\n                verticalModifier = -1;\n                break;\n            case 'bottom-right':\n                horizontalModifier = 1;\n                verticalModifier = 1;\n                break;\n        }\n\n        return (event1: MouseEvent, event2: MouseEvent) => {\n            const x = (event2.screenX - event1.screenX) * this._direction;\n            const y = event2.screenY - event1.screenY;\n\n            return {\n                x: x * verticalModifier,\n                y: y * horizontalModifier\n            };\n        };\n    }\n\n    /** @hidden Return boundary container */\n    private _findResizeContainer(): Element | null {\n        let resizeContainer: Element | null;\n        if (typeof this.resizeBoundary === 'string') {\n            resizeContainer = this._elementRef.nativeElement.closest(this.resizeBoundary);\n        } else {\n            resizeContainer = this.resizeBoundary;\n        }\n\n        if (resizeContainer) {\n            return resizeContainer;\n        } else {\n            console.warn(`fdResize - Cannot find \"${this.resizeBoundary}\", falling back to \"body\"`);\n            return document.querySelector('body');\n        }\n    }\n\n    /** @hidden Check whether resizable container is overflowing boundary container */\n    private _getBoundaryOverflowFunction(resizeContainer: Element): (move: ResizeMove) => boolean {\n        return (move: ResizeMove) => {\n            const containerPosition = resizeContainer.getBoundingClientRect();\n            const elementPosition = this._elementRef.nativeElement.getBoundingClientRect();\n\n            switch (this.resizeHandleLocation) {\n                case 'top-left':\n                    return (\n                        containerPosition.top < elementPosition.top + move.y &&\n                        containerPosition.left < elementPosition.left + move.x\n                    );\n                case 'top-right':\n                    return (\n                        containerPosition.top < elementPosition.top + move.y &&\n                        containerPosition.right > elementPosition.right + move.x\n                    );\n                case 'bottom-left':\n                    return (\n                        containerPosition.bottom > elementPosition.bottom + move.y &&\n                        containerPosition.left < elementPosition.left + move.x\n                    );\n                case 'bottom-right':\n                    return (\n                        containerPosition.bottom > elementPosition.bottom + move.y &&\n                        containerPosition.right > elementPosition.right + move.x\n                    );\n            }\n        };\n    }\n\n    /** @hidden Create Observable notifying on resize actions */\n    private _getResizeEventsNotifiers(trigger$: Observable<boolean>): Observable<any> {\n        const emitResizableStart$ = trigger$.pipe(\n            filter((isActive) => isActive),\n            tap(() => this.onResizeStart.emit())\n        );\n\n        const emitResizableEnd$ = trigger$.pipe(\n            filter((isActive) => !isActive),\n            tap(() => this.onResizeEnd.emit())\n        );\n\n        return merge(emitResizableStart$, emitResizableEnd$);\n    }\n\n    /** @hidden Block resizable container pointer events when resizing  */\n    private _blockOtherPointerEvents(trigger$: Observable<boolean>): Observable<any> {\n        return trigger$.pipe(\n            map((isActive) => (isActive ? 'none' : 'auto')),\n            tap((value) => (this._elementRef.nativeElement.style.pointerEvents = value))\n        );\n    }\n}\n"]}

package/esm2020/utils/directives/resize/resize.module.mjs

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { ResizeDirective, DeprecatedResizeDirective } from './resize.directive';
+import { ResizeHandleDirective, DeprecatedResizeHandleDirective } from './resize-handle.directive';
+import * as i0 from "@angular/core";
+export class ResizeModule {
+}
+ResizeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ResizeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: ResizeModule, imports: [ResizeDirective, DeprecatedResizeDirective, ResizeHandleDirective, DeprecatedResizeHandleDirective], exports: [ResizeDirective, DeprecatedResizeDirective, ResizeHandleDirective, DeprecatedResizeHandleDirective] });
+ResizeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ResizeDirective, DeprecatedResizeDirective, ResizeHandleDirective, DeprecatedResizeHandleDirective],
+                    exports: [ResizeDirective, DeprecatedResizeDirective, ResizeHandleDirective, DeprecatedResizeHandleDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzaXplLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZGlyZWN0aXZlcy9yZXNpemUvcmVzaXplLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxlQUFlLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNoRixPQUFPLEVBQUUscUJBQXFCLEVBQUUsK0JBQStCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQzs7QUFNbkcsTUFBTSxPQUFPLFlBQVk7O3lHQUFaLFlBQVk7MEdBQVosWUFBWSxZQUhYLGVBQWUsRUFBRSx5QkFBeUIsRUFBRSxxQkFBcUIsRUFBRSwrQkFBK0IsYUFDbEcsZUFBZSxFQUFFLHlCQUF5QixFQUFFLHFCQUFxQixFQUFFLCtCQUErQjswR0FFbkcsWUFBWTsyRkFBWixZQUFZO2tCQUp4QixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRSxDQUFDLGVBQWUsRUFBRSx5QkFBeUIsRUFBRSxxQkFBcUIsRUFBRSwrQkFBK0IsQ0FBQztvQkFDN0csT0FBTyxFQUFFLENBQUMsZUFBZSxFQUFFLHlCQUF5QixFQUFFLHFCQUFxQixFQUFFLCtCQUErQixDQUFDO2lCQUNoSCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZXNpemVEaXJlY3RpdmUsIERlcHJlY2F0ZWRSZXNpemVEaXJlY3RpdmUgfSBmcm9tICcuL3Jlc2l6ZS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgUmVzaXplSGFuZGxlRGlyZWN0aXZlLCBEZXByZWNhdGVkUmVzaXplSGFuZGxlRGlyZWN0aXZlIH0gZnJvbSAnLi9yZXNpemUtaGFuZGxlLmRpcmVjdGl2ZSc7XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1Jlc2l6ZURpcmVjdGl2ZSwgRGVwcmVjYXRlZFJlc2l6ZURpcmVjdGl2ZSwgUmVzaXplSGFuZGxlRGlyZWN0aXZlLCBEZXByZWNhdGVkUmVzaXplSGFuZGxlRGlyZWN0aXZlXSxcbiAgICBleHBvcnRzOiBbUmVzaXplRGlyZWN0aXZlLCBEZXByZWNhdGVkUmVzaXplRGlyZWN0aXZlLCBSZXNpemVIYW5kbGVEaXJlY3RpdmUsIERlcHJlY2F0ZWRSZXNpemVIYW5kbGVEaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIFJlc2l6ZU1vZHVsZSB7fVxuIl19

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

@@ -0,0 +1,8 @@
+export * from './selection.service';
+export * from './selectable-list.directive';
+export * from './selectable-item.directive';
+export * from './selectable-list.module';
+export * from './selectable-list.tokens';
+export * from './selectable-item.token';
+export * from './select-component-root.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvc2VsZWN0YWJsZS1saXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlbGVjdGlvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VsZWN0YWJsZS1saXN0LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlbGVjdGFibGUtaXRlbS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWxlY3RhYmxlLWxpc3QubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VsZWN0YWJsZS1saXN0LnRva2Vucyc7XG5leHBvcnQgKiBmcm9tICcuL3NlbGVjdGFibGUtaXRlbS50b2tlbic7XG5leHBvcnQgKiBmcm9tICcuL3NlbGVjdC1jb21wb25lbnQtcm9vdC50b2tlbic7XG4iXX0=

package/esm2020/utils/directives/selectable-list/select-component-root.token.mjs

@@ -0,0 +1,3 @@
+export class SelectComponentRootToken {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LWNvbXBvbmVudC1yb290LnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL3NlbGVjdGFibGUtbGlzdC9zZWxlY3QtY29tcG9uZW50LXJvb3QudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsTUFBTSxPQUFnQix3QkFBd0I7Q0FNN0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCb29sZWFuSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgdHlwZSBTZWxlY3RhYmxlTGlzdFZhbHVlVHlwZTxUPiA9IFQgZXh0ZW5kcyBhbnlbXSA/IEFycmF5PGFueT4gOiBhbnk7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBTZWxlY3RDb21wb25lbnRSb290VG9rZW48VCA9IGFueT4ge1xuICAgIGFic3RyYWN0IHNlbGVjdGVkPzogU2VsZWN0YWJsZUxpc3RWYWx1ZVR5cGU8VD47XG4gICAgYWJzdHJhY3Qgc2VsZWN0ZWRDaGFuZ2U6IE9ic2VydmFibGU8U2VsZWN0YWJsZUxpc3RWYWx1ZVR5cGU8VD4+O1xuICAgIGFic3RyYWN0IG11bHRpcGxlPzogQm9vbGVhbklucHV0O1xuICAgIGFic3RyYWN0IHRvZ2dsZT86IEJvb2xlYW5JbnB1dDtcbiAgICBhYnN0cmFjdCBvbkNoYW5nZTogKHZhbHVlOiBTZWxlY3RhYmxlTGlzdFZhbHVlVHlwZTxUPikgPT4gdm9pZDtcbn1cbiJdfQ==

package/esm2020/utils/directives/selectable-list/selectable-item.directive.mjs

@@ -0,0 +1,147 @@
+import { ChangeDetectorRef, Directive, ElementRef, Inject, Input, Optional, Output } from '@angular/core';
+import { merge, Observable } from 'rxjs';
+import { SelectableItemToken } from './selectable-item.token';
+import { FDK_SELECTABLE_ITEM_PROVIDER } from './selectable-list.tokens';
+import { FdkDisabledProvider } from '../disabled';
+import { FdkReadonlyProvider } from '../readonly';
+import { SelectionService } from './selection.service';
+import { FdkClickedProvider } from '../clicked';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "../disabled";
+import * as i2 from "../readonly";
+import * as i3 from "./selection.service";
+import * as i4 from "../clicked";
+export class SelectableItemDirective {
+    /** @hidden */
+    constructor(provider, disabled$, readonly$, selectionService, _elementRef, _cd, _clicked) {
+        this.provider = provider;
+        this.disabled$ = disabled$;
+        this.readonly$ = readonly$;
+        this.selectionService = selectionService;
+        this._elementRef = _elementRef;
+        this._cd = _cd;
+        /** @hidden */
+        this._selected = false;
+        /** @hidden */
+        this._selectable = true;
+        this.clicked = this.provider?.clicked || _clicked.asObservable();
+        this._listenToDisablingEvents();
+    }
+    /** @hidden */
+    set value(val) {
+        this._value = val;
+    }
+    get value() {
+        if (this.provider && this.provider.value) {
+            return this.provider.value;
+        }
+        return this._value;
+    }
+    /** @hidden */
+    set fdkSelectableItem(value) {
+        const isSelectable = coerceBooleanProperty(value);
+        if (isSelectable !== this._selectable) {
+            this._selectable = isSelectable;
+        }
+    }
+    get fdkSelectableItem() {
+        let selectable = this._selectable;
+        if (typeof this.provider?.fdkSelectableItem !== 'undefined') {
+            selectable = this.provider.fdkSelectableItem;
+        }
+        return (selectable &&
+            (!this.disabled$ || !this.disabled$?.fdkDisabled) &&
+            (!this.readonly$ || !this.readonly$?.fdkReadonly));
+    }
+    /** @hidden */
+    getSelected() {
+        if (this.provider?.getSelected) {
+            return this.provider.getSelected();
+        }
+        return this._selected;
+    }
+    /** @hidden */
+    setSelected(isSelected) {
+        if (this.provider?.setSelected) {
+            this.provider.setSelected(isSelected);
+        }
+        else {
+            this._selected = isSelected;
+            const htmlElement = this._elementRef.nativeElement;
+            const { classList } = htmlElement;
+            if (isSelected) {
+                classList.add('is-selected');
+            }
+            else {
+                classList.remove('is-selected');
+            }
+            htmlElement.setAttribute('aria-selected', `${isSelected}`);
+        }
+    }
+    /** @hidden */
+    elementRef() {
+        return this._elementRef;
+    }
+    /** @hidden */
+    _listenToDisablingEvents() {
+        const disablingEvents$ = [];
+        if (this.disabled$) {
+            disablingEvents$.push(this.disabled$);
+        }
+        if (this.readonly$) {
+            disablingEvents$.push(this.readonly$);
+        }
+        merge(...disablingEvents$).subscribe(() => this._updateSelectionAndSelectableWatcher());
+    }
+    /** @hidden */
+    _updateSelectionAndSelectableWatcher() {
+        if (this.disabled$?.fdkDisabled) {
+            this.selectionService.deselectItem(this);
+        }
+        this._updateSelectableWatcher();
+    }
+    /** @hidden */
+    _updateSelectableWatcher() {
+        this.selectionService.listenToItemInteractions();
+    }
+}
+SelectableItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: SelectableItemDirective, deps: [{ token: FDK_SELECTABLE_ITEM_PROVIDER, optional: true }, { token: i1.FdkDisabledProvider }, { token: i2.FdkReadonlyProvider }, { token: i3.SelectionService }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i4.FdkClickedProvider }], target: i0.ɵɵFactoryTarget.Directive });
+SelectableItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: SelectableItemDirective, isStandalone: true, selector: "[fdkSelectableItem]", inputs: { value: "value", fdkSelectableItem: "fdkSelectableItem" }, outputs: { clicked: "clicked" }, providers: [
+        {
+            provide: SelectableItemToken,
+            useExisting: SelectableItemDirective
+        },
+        FdkReadonlyProvider,
+        FdkDisabledProvider,
+        FdkClickedProvider
+    ], exportAs: ["fdkSelectableItem"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: SelectableItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkSelectableItem]',
+                    exportAs: 'fdkSelectableItem',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: SelectableItemToken,
+                            useExisting: SelectableItemDirective
+                        },
+                        FdkReadonlyProvider,
+                        FdkDisabledProvider,
+                        FdkClickedProvider
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FDK_SELECTABLE_ITEM_PROVIDER]
+                }] }, { type: i1.FdkDisabledProvider }, { type: i2.FdkReadonlyProvider }, { type: i3.SelectionService }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i4.FdkClickedProvider }]; }, propDecorators: { value: [{
+                type: Input
+            }], fdkSelectableItem: [{
+                type: Input
+            }], clicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selectable-item.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/selectable-list/selectable-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Directive, ElementRef, Inject, Input, Optional, Output } from '@angular/core';\nimport { merge, Observable } from 'rxjs';\nimport { SelectableItemToken } from './selectable-item.token';\nimport { FDK_SELECTABLE_ITEM_PROVIDER } from './selectable-list.tokens';\nimport { FdkDisabledProvider } from '../disabled';\nimport { FdkReadonlyProvider } from '../readonly';\nimport { SelectionService } from './selection.service';\nimport { FdkClickedProvider } from '../clicked';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\n\n@Directive({\n    selector: '[fdkSelectableItem]',\n    exportAs: 'fdkSelectableItem',\n    standalone: true,\n    providers: [\n        {\n            provide: SelectableItemToken,\n            useExisting: SelectableItemDirective\n        },\n        FdkReadonlyProvider,\n        FdkDisabledProvider,\n        FdkClickedProvider\n    ]\n})\nexport class SelectableItemDirective<ElementType extends Element = HTMLElement, ValueType = any>\n    implements SelectableItemToken<ElementType, ValueType>\n{\n    /** @hidden */\n    @Input()\n    set value(val: ValueType) {\n        this._value = val;\n    }\n    get value(): ValueType {\n        if (this.provider && this.provider.value) {\n            return this.provider.value;\n        }\n        return this._value;\n    }\n\n    /** @hidden */\n    @Input()\n    set fdkSelectableItem(value: BooleanInput) {\n        const isSelectable = coerceBooleanProperty(value);\n        if (isSelectable !== this._selectable) {\n            this._selectable = isSelectable;\n        }\n    }\n\n    get fdkSelectableItem(): boolean {\n        let selectable = this._selectable;\n        if (typeof this.provider?.fdkSelectableItem !== 'undefined') {\n            selectable = this.provider.fdkSelectableItem;\n        }\n        return (\n            selectable &&\n            (!this.disabled$ || !this.disabled$?.fdkDisabled) &&\n            (!this.readonly$ || !this.readonly$?.fdkReadonly)\n        );\n    }\n\n    /** @hidden */\n    @Output()\n    clicked: Observable<MouseEvent | KeyboardEvent>;\n\n    /** @hidden */\n    private _value!: ValueType;\n    /** @hidden */\n    private _selected = false;\n    /** @hidden */\n    private _selectable = true;\n\n    /** @hidden */\n    constructor(\n        @Optional()\n        @Inject(FDK_SELECTABLE_ITEM_PROVIDER)\n        private provider: Partial<SelectableItemToken<ElementType, ValueType>>,\n        private disabled$: FdkDisabledProvider,\n        private readonly$: FdkReadonlyProvider,\n        private selectionService: SelectionService<ElementType, ValueType>,\n        private _elementRef: ElementRef<ElementType>,\n        private _cd: ChangeDetectorRef,\n        _clicked: FdkClickedProvider\n    ) {\n        this.clicked = this.provider?.clicked || _clicked.asObservable();\n        this._listenToDisablingEvents();\n    }\n\n    /** @hidden */\n    getSelected(): boolean {\n        if (this.provider?.getSelected) {\n            return this.provider.getSelected();\n        }\n        return this._selected;\n    }\n\n    /** @hidden */\n    setSelected(isSelected: boolean): void {\n        if (this.provider?.setSelected) {\n            this.provider.setSelected(isSelected);\n        } else {\n            this._selected = isSelected;\n            const htmlElement = this._elementRef.nativeElement;\n            const { classList } = htmlElement;\n            if (isSelected) {\n                classList.add('is-selected');\n            } else {\n                classList.remove('is-selected');\n            }\n            htmlElement.setAttribute('aria-selected', `${isSelected}`);\n        }\n    }\n\n    /** @hidden */\n    elementRef(): ElementRef<ElementType> {\n        return this._elementRef;\n    }\n\n    /** @hidden */\n    private _listenToDisablingEvents(): void {\n        const disablingEvents$: Observable<boolean>[] = [];\n        if (this.disabled$) {\n            disablingEvents$.push(this.disabled$);\n        }\n        if (this.readonly$) {\n            disablingEvents$.push(this.readonly$);\n        }\n        merge(...disablingEvents$).subscribe(() => this._updateSelectionAndSelectableWatcher());\n    }\n\n    /** @hidden */\n    private _updateSelectionAndSelectableWatcher(): void {\n        if (this.disabled$?.fdkDisabled) {\n            this.selectionService.deselectItem(this);\n        }\n        this._updateSelectableWatcher();\n    }\n\n    /** @hidden */\n    private _updateSelectableWatcher(): void {\n        this.selectionService.listenToItemInteractions();\n    }\n}\n"]}

package/esm2020/utils/directives/selectable-list/selectable-item.token.mjs

@@ -0,0 +1,3 @@
+export class SelectableItemToken {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0YWJsZS1pdGVtLnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL3NlbGVjdGFibGUtbGlzdC9zZWxlY3RhYmxlLWl0ZW0udG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsTUFBTSxPQUFnQixtQkFBbUI7Q0FheEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbGVtZW50UmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBIYXNFbGVtZW50UmVmIH0gZnJvbSAnLi4vLi4vaW50ZXJmYWNlcy9oYXMtZWxlbWVudC1yZWYuaW50ZXJmYWNlJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFNlbGVjdGFibGVJdGVtVG9rZW48RWxlbWVudFR5cGUgZXh0ZW5kcyBFbGVtZW50ID0gSFRNTEVsZW1lbnQsIFRWYWx1ZSA9IEVsZW1lbnRUeXBlPlxuICAgIGltcGxlbWVudHMgSGFzRWxlbWVudFJlZjxFbGVtZW50VHlwZT5cbntcbiAgICBhYnN0cmFjdCB2YWx1ZTogVFZhbHVlO1xuICAgIGFic3RyYWN0IGZka1NlbGVjdGFibGVJdGVtPzogYm9vbGVhbjtcblxuICAgIGFic3RyYWN0IGVsZW1lbnRSZWYoKTogRWxlbWVudFJlZjxFbGVtZW50VHlwZT47XG5cbiAgICBhYnN0cmFjdCBzZXRTZWxlY3RlZChpc1NlbGVjdGVkOiBib29sZWFuKTogdm9pZDtcblxuICAgIGFic3RyYWN0IGdldFNlbGVjdGVkKCk6IGJvb2xlYW47XG5cbiAgICBhYnN0cmFjdCBjbGlja2VkOiBPYnNlcnZhYmxlPE1vdXNlRXZlbnQgfCBLZXlib2FyZEV2ZW50Pjtcbn1cbiJdfQ==

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

@@ -0,0 +1,93 @@
+import { __decorate, __metadata } from "tslib";
+import { ContentChildren, Directive, EventEmitter, Input, Output, QueryList } from '@angular/core';
+import { SelectionService } from './selection.service';
+import { SelectComponentRootToken } from './select-component-root.token';
+import { SelectableItemToken } from './selectable-item.token';
+import { coerceBoolean } from '../../decorators/coerce-boolean';
+import * as i0 from "@angular/core";
+import * as i1 from "./selection.service";
+export class SelectableListDirective {
+    /** @hidden */
+    constructor(_selectionService) {
+        this._selectionService = _selectionService;
+        /** @hidden */
+        this.selectedChange = new EventEmitter();
+        /** @hidden */
+        this.toggle = false;
+        /** @hidden */
+        this.multiple = false;
+        this._selectionService.registerRootComponent(this);
+    }
+    /** @hidden */
+    set selected(value) {
+        this._selectionService.setValue(value);
+    }
+    /** @hidden */
+    select(item) {
+        this._selectionService.selectItem(item);
+    }
+    /** @hidden */
+    deselect(item) {
+        this._selectionService.deselectItem(item);
+    }
+    /** @hidden */
+    toggleSelect(item) {
+        if (item.getSelected()) {
+            this.deselect(item);
+        }
+        else {
+            this.select(item);
+        }
+    }
+    /** @hidden */
+    onChange(value) {
+        this.selectedChange.emit(value);
+    }
+    /** @hidden */
+    ngAfterViewInit() {
+        this._selectionService.initialize(this.selectableItems);
+    }
+}
+SelectableListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: SelectableListDirective, deps: [{ token: i1.SelectionService }], target: i0.ɵɵFactoryTarget.Directive });
+SelectableListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: SelectableListDirective, isStandalone: true, selector: "[fdkSelectableList]", inputs: { toggle: "toggle", multiple: "multiple", selected: "selected" }, outputs: { selectedChange: "selectedChange" }, providers: [
+        {
+            provide: SelectComponentRootToken,
+            useExisting: SelectableListDirective
+        },
+        SelectionService
+    ], queries: [{ propertyName: "selectableItems", predicate: SelectableItemToken }], exportAs: ["fdkSelectableList"], ngImport: i0 });
+__decorate([
+    coerceBoolean,
+    __metadata("design:type", Object)
+], SelectableListDirective.prototype, "toggle", void 0);
+__decorate([
+    coerceBoolean,
+    __metadata("design:type", Object)
+], SelectableListDirective.prototype, "multiple", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: SelectableListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkSelectableList]',
+                    exportAs: 'fdkSelectableList',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: SelectComponentRootToken,
+                            useExisting: SelectableListDirective
+                        },
+                        SelectionService
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SelectionService }]; }, propDecorators: { selectedChange: [{
+                type: Output
+            }], toggle: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], selectableItems: [{
+                type: ContentChildren,
+                args: [SelectableItemToken]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/esm2020/utils/directives/selectable-list/selectable-list.tokens.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const FDK_SELECTABLE_ITEM_PROVIDER = new InjectionToken('Token for providing custom behaviors to the SelectableListItem');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0YWJsZS1saXN0LnRva2Vucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZGlyZWN0aXZlcy9zZWxlY3RhYmxlLWxpc3Qvc2VsZWN0YWJsZS1saXN0LnRva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLDRCQUE0QixHQUFHLElBQUksY0FBYyxDQUMxRCxnRUFBZ0UsQ0FDbkUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBGREtfU0VMRUNUQUJMRV9JVEVNX1BST1ZJREVSID0gbmV3IEluamVjdGlvblRva2VuKFxuICAgICdUb2tlbiBmb3IgcHJvdmlkaW5nIGN1c3RvbSBiZWhhdmlvcnMgdG8gdGhlIFNlbGVjdGFibGVMaXN0SXRlbSdcbik7XG4iXX0=