@fundamental-ngx/cdk 0.38.3-rc.4

package/esm2020/utils/drag-and-drop/dnd-list/dnd-list.directive.mjs

@@ -0,0 +1,220 @@
+import { ContentChildren, Directive, EventEmitter, forwardRef, Input, Output, QueryList } from '@angular/core';
+import { merge, Subject } from 'rxjs';
+import { startWith, takeUntil } from 'rxjs/operators';
+import { DND_ITEM, DND_LIST } from '../tokens';
+import * as i0 from "@angular/core";
+export class DndListDirective {
+    constructor() {
+        /**
+         * Defines if the the element is allowed to be dragged in 2 dimensions,
+         * When true - replace indicator will be displayed vertically
+         */
+        this.gridMode = false;
+        /** When enabled, replace indicator will appear on whole element, instead of horizontal/vertical line before/after element */
+        this.replaceMode = false;
+        /** Event that is thrown, when items are reordered */
+        this.itemsChange = new EventEmitter();
+        /** Event that is thrown, when the item is dropped */
+        this.itemDropped = new EventEmitter();
+        /** @hidden */
+        this._closestItemIndex = null;
+        /** @hidden */
+        this._closestItemPosition = null;
+        /** An RxJS Subject that will kill the current data stream (for unsubscribing)  */
+        this._refresh$ = new Subject();
+        /** @hidden */
+        this._onDestroy$ = new Subject();
+        /** @hidden */
+        this._draggable = true;
+    }
+    /** Defines if drag and drop feature should be enabled for list items */
+    set draggable(draggable) {
+        this._draggable = draggable;
+        this._changeDraggableState(draggable);
+    }
+    /** @hidden */
+    ngAfterContentInit() {
+        this._changeDraggableState(this._draggable);
+        this.dndItems.changes.pipe(takeUntil(this._onDestroy$), startWith(0)).subscribe(() => this._refreshQueryList());
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._onDestroy$.next();
+        this._onDestroy$.complete();
+    }
+    /** Method called, when the item is being moved by 1 px */
+    onMove(mousePosition, draggedItemIndex) {
+        /** Temporary object, to store lowest distance values */
+        let closestItemIndex = null;
+        const closestItem = this._elementsCoordinates.find((element, index) => {
+            /** Check if element can be replaced */
+            if (!element.stickToPosition && closestItemIndex !== index) {
+                const isMouseOnElement = _isMouseOnElement(element, mousePosition);
+                if (isMouseOnElement) {
+                    closestItemIndex = index;
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (!closestItem) {
+            closestItemIndex = null;
+        }
+        /** If the closest element is different than the old one, new one is picked. It prevents from performance issues */
+        if ((closestItemIndex || closestItemIndex === 0) && closestItemIndex !== this._closestItemIndex) {
+            this._closestItemIndex = closestItemIndex;
+            this._closestItemPosition = this._elementsCoordinates[closestItemIndex].position;
+            // If closest item index is same as dragged item, just remove indicators
+            if (closestItemIndex === draggedItemIndex) {
+                this._removeAllLines();
+                this._removeAllReplaceIndicators();
+                return;
+            }
+            /** Generating line, that shows where the element will be placed, on drop */
+            if (this.replaceMode) {
+                this._createReplaceIndicator(this._closestItemIndex);
+            }
+            else {
+                this._createLine(this._closestItemIndex, this._closestItemPosition);
+            }
+        }
+    }
+    /** Method called, when element is started to be dragged */
+    dragStart(index) {
+        const draggedItemElement = this._dndItemReference[index].elementRef;
+        /** Counting all of the elements's chords */
+        this._elementsCoordinates = this._dndItemReference.map((item) => item.getElementCoordinates(this._isBefore(draggedItemElement, item.elementRef), this.gridMode));
+    }
+    /** Method called, when element is released */
+    dragEnd(draggedItemIndex) {
+        const items = this.items.slice();
+        const replacedItemIndex = this._closestItemIndex;
+        const draggedItem = items[draggedItemIndex];
+        if (!replacedItemIndex) {
+            return;
+        }
+        if (draggedItemIndex !== replacedItemIndex) {
+            if (draggedItemIndex < replacedItemIndex) {
+                for (let i = draggedItemIndex; i < replacedItemIndex; i++) {
+                    items[i] = items[i + 1];
+                }
+            }
+            else {
+                for (let i = draggedItemIndex; i > replacedItemIndex; i--) {
+                    items[i] = items[i - 1];
+                }
+            }
+            /** Replacing items */
+            items[replacedItemIndex] = draggedItem;
+            this.itemsChange.emit(items);
+        }
+        this.itemDropped.emit({
+            replacedItemIndex,
+            draggedItemIndex,
+            items
+        });
+        this._removeAllLines();
+        this._removeAllReplaceIndicators();
+        /** Reset */
+        this._elementsCoordinates = [];
+        this._closestItemIndex = null;
+        this._closestItemPosition = null;
+    }
+    /** @hidden */
+    _removeAllLines() {
+        this.dndItems.forEach((item) => item.removeLine());
+    }
+    /** @hidden */
+    _removeAllReplaceIndicators() {
+        this.dndItems.forEach((item) => item.removeReplaceIndicator());
+    }
+    /** @hidden */
+    _createLine(closestItemIndex, linkPosition) {
+        this._removeAllLines();
+        this._dndItemReference[closestItemIndex].createLine(linkPosition, this.gridMode);
+    }
+    /** @hidden */
+    _createReplaceIndicator(closestItemIndex) {
+        this._removeAllReplaceIndicators();
+        this._dndItemReference[closestItemIndex].createReplaceIndicator();
+    }
+    /** @hidden */
+    _refreshQueryList() {
+        const refresh$ = merge(this._refresh$, this._onDestroy$);
+        this._refresh$.next();
+        this._dndItemReference = this.dndItems.toArray();
+        this._changeDraggableState(this._draggable);
+        this.dndItems.forEach((item, index) => {
+            item.moved.pipe(takeUntil(refresh$)).subscribe((position) => this.onMove(position, index));
+            item.started.pipe(takeUntil(refresh$)).subscribe(() => this.dragStart(index));
+            item.released.pipe(takeUntil(refresh$)).subscribe(() => this.dragEnd(index));
+        });
+    }
+    /**
+     *  @hidden
+     * Return information if element is placed before the dragged element
+     */
+    _isBefore(draggedElement, targetElement) {
+        /** Sometimes the element are not straight in one column, that's why offset is needed */
+        const VERTICAL_OFFSET = 20;
+        /** Distances from the top of screen */
+        const draggedElementBound = draggedElement.nativeElement.getBoundingClientRect();
+        const targetElementBound = targetElement.nativeElement.getBoundingClientRect();
+        if (draggedElementBound.top - targetElementBound.top > VERTICAL_OFFSET) {
+            /** If element is higher than the dragged element, it's for sure before */
+            return true;
+        }
+        else if (targetElementBound.top - draggedElementBound.top > VERTICAL_OFFSET) {
+            /** If element is lower than the dragged element, it's for sure after */
+            return false;
+        }
+        else {
+            /** If elements are in same level, the horizontal position decides if it's before/after */
+            return draggedElementBound.left - targetElementBound.left > 0;
+        }
+    }
+    /** @hidden */
+    _changeDraggableState(draggable) {
+        if (this.dndItems) {
+            this.dndItems.forEach((item) => {
+                item.listDraggable = draggable;
+                item.changeCDKDragState();
+            });
+        }
+    }
+}
+DndListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DndListDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+DndListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DndListDirective, selector: "[fdkDndList], [fd-dnd-list]", inputs: { gridMode: "gridMode", replaceMode: "replaceMode", items: "items", draggable: "draggable" }, outputs: { itemsChange: "itemsChange", itemDropped: "itemDropped" }, providers: [{ provide: DND_LIST, useExisting: forwardRef(() => DndListDirective) }], queries: [{ propertyName: "dndItems", predicate: DND_ITEM }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DndListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkDndList], [fd-dnd-list]',
+                    providers: [{ provide: DND_LIST, useExisting: forwardRef(() => DndListDirective) }]
+                }]
+        }], propDecorators: { gridMode: [{
+                type: Input
+            }], replaceMode: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], itemsChange: [{
+                type: Output
+            }], itemDropped: [{
+                type: Output
+            }], dndItems: [{
+                type: ContentChildren,
+                args: [DND_ITEM]
+            }] } });
+function _isMouseOnElement(element, mousePosition) {
+    const startX = element.x;
+    const endX = element.x + element.width;
+    const startY = element.y;
+    const endY = element.y + element.height;
+    return _between(mousePosition.x, startX, endX) && _between(mousePosition.y, startY, endY);
+}
+function _between(x, min, max) {
+    return x >= min && x <= max;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dnd-list.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/drag-and-drop/dnd-list/dnd-list.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    ContentChildren,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    forwardRef,\n    Input,\n    OnDestroy,\n    Output,\n    QueryList\n} from '@angular/core';\nimport { merge, Subject } from 'rxjs';\nimport { startWith, takeUntil } from 'rxjs/operators';\nimport { ElementChord, FdDropEvent, LinkPosition, ElementPosition, DndItem } from '../dnd.interfaces';\nimport { DND_ITEM, DND_LIST } from '../tokens';\n\n@Directive({\n    selector: '[fdkDndList], [fd-dnd-list]',\n    providers: [{ provide: DND_LIST, useExisting: forwardRef(() => DndListDirective) }]\n})\nexport class DndListDirective<T> implements AfterContentInit, OnDestroy {\n    /**\n     * Defines if the the element is allowed to be dragged in 2 dimensions,\n     * When true - replace indicator will be displayed vertically\n     */\n    @Input()\n    gridMode = false;\n\n    /** When enabled, replace indicator will appear on whole element, instead of horizontal/vertical line before/after element */\n    @Input()\n    replaceMode = false;\n\n    /** Array of items, that will be sorted */\n    @Input()\n    items: Array<T>;\n\n    /** Defines if drag and drop feature should be enabled for list items */\n    @Input()\n    set draggable(draggable: boolean) {\n        this._draggable = draggable;\n        this._changeDraggableState(draggable);\n    }\n\n    /** Event that is thrown, when items are reordered */\n    @Output()\n    readonly itemsChange = new EventEmitter<Array<T>>();\n\n    /** Event that is thrown, when the item is dropped */\n    @Output()\n    readonly itemDropped = new EventEmitter<FdDropEvent<T>>();\n\n    /** @hidden */\n    @ContentChildren(DND_ITEM)\n    dndItems: QueryList<DndItem>;\n\n    /** @hidden */\n    private _elementsCoordinates: ElementChord[];\n\n    /** @hidden */\n    private _closestItemIndex: number | null = null;\n\n    /** @hidden */\n    private _closestItemPosition: 'before' | 'after' | null = null;\n\n    /** An RxJS Subject that will kill the current data stream (for unsubscribing)  */\n    private readonly _refresh$ = new Subject<void>();\n\n    /** @hidden */\n    private readonly _onDestroy$ = new Subject<void>();\n\n    /** @hidden  */\n    private _dndItemReference: DndItem[];\n\n    /** @hidden */\n    private _draggable = true;\n\n    /** @hidden */\n    ngAfterContentInit(): void {\n        this._changeDraggableState(this._draggable);\n        this.dndItems.changes.pipe(takeUntil(this._onDestroy$), startWith(0)).subscribe(() => this._refreshQueryList());\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._onDestroy$.next();\n        this._onDestroy$.complete();\n    }\n\n    /** Method called, when the item is being moved by 1 px */\n    onMove(mousePosition: ElementPosition, draggedItemIndex: number): void {\n        /** Temporary object, to store lowest distance values */\n        let closestItemIndex: number | null = null;\n\n        const closestItem = this._elementsCoordinates.find((element, index) => {\n            /** Check if element can be replaced */\n            if (!element.stickToPosition && closestItemIndex !== index) {\n                const isMouseOnElement = _isMouseOnElement(element, mousePosition);\n                if (isMouseOnElement) {\n                    closestItemIndex = index;\n\n                    return true;\n                }\n            }\n            return false;\n        });\n\n        if (!closestItem) {\n            closestItemIndex = null;\n        }\n\n        /** If the closest element is different than the old one, new one is picked. It prevents from performance issues */\n        if ((closestItemIndex || closestItemIndex === 0) && closestItemIndex !== this._closestItemIndex) {\n            this._closestItemIndex = closestItemIndex;\n            this._closestItemPosition = this._elementsCoordinates[closestItemIndex].position;\n            // If closest item index is same as dragged item, just remove indicators\n            if (closestItemIndex === draggedItemIndex) {\n                this._removeAllLines();\n                this._removeAllReplaceIndicators();\n                return;\n            }\n            /** Generating line, that shows where the element will be placed, on drop */\n            if (this.replaceMode) {\n                this._createReplaceIndicator(this._closestItemIndex);\n            } else {\n                this._createLine(this._closestItemIndex, this._closestItemPosition);\n            }\n        }\n    }\n\n    /** Method called, when element is started to be dragged */\n    dragStart(index: number): void {\n        const draggedItemElement = this._dndItemReference[index].elementRef;\n        /** Counting all of the elements's chords */\n        this._elementsCoordinates = this._dndItemReference.map((item: DndItem) =>\n            item.getElementCoordinates(this._isBefore(draggedItemElement, item.elementRef), this.gridMode)\n        );\n    }\n\n    /** Method called, when element is released */\n    dragEnd(draggedItemIndex: number): void {\n        const items = this.items.slice();\n        const replacedItemIndex = this._closestItemIndex;\n        const draggedItem = items[draggedItemIndex];\n\n        if (!replacedItemIndex) {\n            return;\n        }\n\n        if (draggedItemIndex !== replacedItemIndex) {\n            if (draggedItemIndex < replacedItemIndex) {\n                for (let i = draggedItemIndex; i < replacedItemIndex; i++) {\n                    items[i] = items[i + 1];\n                }\n            } else {\n                for (let i = draggedItemIndex; i > replacedItemIndex; i--) {\n                    items[i] = items[i - 1];\n                }\n            }\n\n            /** Replacing items */\n            items[replacedItemIndex] = draggedItem;\n\n            this.itemsChange.emit(items);\n        }\n\n        this.itemDropped.emit({\n            replacedItemIndex,\n            draggedItemIndex,\n            items\n        });\n\n        this._removeAllLines();\n        this._removeAllReplaceIndicators();\n\n        /** Reset */\n        this._elementsCoordinates = [];\n        this._closestItemIndex = null;\n        this._closestItemPosition = null;\n    }\n\n    /** @hidden */\n    private _removeAllLines(): void {\n        this.dndItems.forEach((item) => item.removeLine());\n    }\n\n    /** @hidden */\n    private _removeAllReplaceIndicators(): void {\n        this.dndItems.forEach((item) => item.removeReplaceIndicator());\n    }\n\n    /** @hidden */\n    private _createLine(closestItemIndex: number, linkPosition: LinkPosition): void {\n        this._removeAllLines();\n        this._dndItemReference[closestItemIndex].createLine(linkPosition, this.gridMode);\n    }\n\n    /** @hidden */\n    private _createReplaceIndicator(closestItemIndex: number): void {\n        this._removeAllReplaceIndicators();\n        this._dndItemReference[closestItemIndex].createReplaceIndicator();\n    }\n\n    /** @hidden */\n    private _refreshQueryList(): void {\n        const refresh$ = merge(this._refresh$, this._onDestroy$);\n        this._refresh$.next();\n\n        this._dndItemReference = this.dndItems.toArray();\n\n        this._changeDraggableState(this._draggable);\n\n        this.dndItems.forEach((item, index) => {\n            item.moved.pipe(takeUntil(refresh$)).subscribe((position: ElementPosition) => this.onMove(position, index));\n            item.started.pipe(takeUntil(refresh$)).subscribe(() => this.dragStart(index));\n            item.released.pipe(takeUntil(refresh$)).subscribe(() => this.dragEnd(index));\n        });\n    }\n\n    /**\n     *  @hidden\n     * Return information if element is placed before the dragged element\n     */\n    private _isBefore(draggedElement: ElementRef, targetElement: ElementRef): boolean {\n        /** Sometimes the element are not straight in one column, that's why offset is needed */\n        const VERTICAL_OFFSET = 20;\n\n        /** Distances from the top of screen */\n        const draggedElementBound = <DOMRect>draggedElement.nativeElement.getBoundingClientRect();\n        const targetElementBound = <DOMRect>targetElement.nativeElement.getBoundingClientRect();\n\n        if (draggedElementBound.top - targetElementBound.top > VERTICAL_OFFSET) {\n            /** If element is higher than the dragged element, it's for sure before */\n            return true;\n        } else if (targetElementBound.top - draggedElementBound.top > VERTICAL_OFFSET) {\n            /** If element is lower than the dragged element, it's for sure after */\n            return false;\n        } else {\n            /** If elements are in same level, the horizontal position decides if it's before/after */\n            return draggedElementBound.left - targetElementBound.left > 0;\n        }\n    }\n\n    /** @hidden */\n    private _changeDraggableState(draggable: boolean): void {\n        if (this.dndItems) {\n            this.dndItems.forEach((item) => {\n                item.listDraggable = draggable;\n                item.changeCDKDragState();\n            });\n        }\n    }\n}\n\nfunction _isMouseOnElement(element: ElementChord, mousePosition: ElementPosition): boolean {\n    const startX = element.x;\n    const endX = element.x + element.width;\n\n    const startY = element.y;\n    const endY = element.y + element.height;\n\n    return _between(mousePosition.x, startX, endX) && _between(mousePosition.y, startY, endY);\n}\n\nfunction _between(x: number, min: number, max: number): boolean {\n    return x >= min && x <= max;\n}\n"]}

package/esm2020/utils/drag-and-drop/dnd.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5kLmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RyYWctYW5kLWRyb3AvZG5kLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVsZW1lbnRSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuZXhwb3J0IHR5cGUgTGlua1Bvc2l0aW9uID0gJ2FmdGVyJyB8ICdiZWZvcmUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEVsZW1lbnRDaG9yZCB7XG4gICAgeDogbnVtYmVyO1xuICAgIHk6IG51bWJlcjtcbiAgICBwb3NpdGlvbjogTGlua1Bvc2l0aW9uO1xuICAgIHN0aWNrVG9Qb3NpdGlvbj86IGJvb2xlYW47XG4gICAgd2lkdGg6IG51bWJlcjtcbiAgICBoZWlnaHQ6IG51bWJlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGZERyb3BFdmVudDxUPiB7XG4gICAgaXRlbXM6IEFycmF5PFQ+O1xuICAgIHJlcGxhY2VkSXRlbUluZGV4OiBudW1iZXI7XG4gICAgZHJhZ2dlZEl0ZW1JbmRleDogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEVsZW1lbnRQb3NpdGlvbiB7XG4gICAgeDogbnVtYmVyO1xuICAgIHk6IG51bWJlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEbmRJdGVtIHtcbiAgICBlbGVtZW50UmVmOiBFbGVtZW50UmVmO1xuICAgIGdldEVsZW1lbnRDb29yZGluYXRlczogKGlzQmVmb3JlOiBib29sZWFuLCBncmlkTW9kZTogYm9vbGVhbikgPT4gRWxlbWVudENob3JkO1xuICAgIHJlbW92ZUxpbmU6ICgpID0+IHZvaWQ7XG4gICAgcmVtb3ZlUmVwbGFjZUluZGljYXRvcjogKCkgPT4gdm9pZDtcbiAgICBjcmVhdGVMaW5lOiAobGlua1Bvc2l0aW9uOiBMaW5rUG9zaXRpb24sIGdyaWRNb2RlOiBib29sZWFuKSA9PiB2b2lkO1xuICAgIGNyZWF0ZVJlcGxhY2VJbmRpY2F0b3I6ICgpID0+IHZvaWQ7XG4gICAgbW92ZWQ6IE9ic2VydmFibGU8RWxlbWVudFBvc2l0aW9uPjtcbiAgICByZWxlYXNlZDogT2JzZXJ2YWJsZTx2b2lkPjtcbiAgICBzdGFydGVkOiBPYnNlcnZhYmxlPHZvaWQ+O1xuICAgIGxpc3REcmFnZ2FibGU6IGJvb2xlYW47XG4gICAgY2hhbmdlQ0RLRHJhZ1N0YXRlOiAoKSA9PiB2b2lkO1xufVxuIl19

package/esm2020/utils/drag-and-drop/drag-and-drop.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DndListDirective } from './dnd-list/dnd-list.directive';
+import { DndItemDirective } from './dnd-item/dnd-item.directive';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { DndKeyboardItemDirective } from './dnd-keyboard-item/dnd-keyboard-item.directive';
+import { DndKeyboardGroupDirective } from './dnd-keyboard-group/dnd-keyboard-group.directive';
+import * as i0 from "@angular/core";
+export class DragAndDropModule {
+}
+DragAndDropModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DragAndDropModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DragAndDropModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: DragAndDropModule, declarations: [DndItemDirective, DndListDirective, DndKeyboardGroupDirective, DndKeyboardItemDirective], imports: [CommonModule, DragDropModule], exports: [DndItemDirective, DndListDirective, DndKeyboardGroupDirective, DndKeyboardItemDirective] });
+DragAndDropModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DragAndDropModule, imports: [CommonModule, DragDropModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DragAndDropModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, DragDropModule],
+                    exports: [DndItemDirective, DndListDirective, DndKeyboardGroupDirective, DndKeyboardItemDirective],
+                    declarations: [DndItemDirective, DndListDirective, DndKeyboardGroupDirective, DndKeyboardItemDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1hbmQtZHJvcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RyYWctYW5kLWRyb3AvZHJhZy1hbmQtZHJvcC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDakUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDakUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3hELE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBQzNGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLG1EQUFtRCxDQUFDOztBQU85RixNQUFNLE9BQU8saUJBQWlCOzs4R0FBakIsaUJBQWlCOytHQUFqQixpQkFBaUIsaUJBRlgsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQUUseUJBQXlCLEVBQUUsd0JBQXdCLGFBRjVGLFlBQVksRUFBRSxjQUFjLGFBQzVCLGdCQUFnQixFQUFFLGdCQUFnQixFQUFFLHlCQUF5QixFQUFFLHdCQUF3QjsrR0FHeEYsaUJBQWlCLFlBSmhCLFlBQVksRUFBRSxjQUFjOzJGQUk3QixpQkFBaUI7a0JBTDdCLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGNBQWMsQ0FBQztvQkFDdkMsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQUUseUJBQXlCLEVBQUUsd0JBQXdCLENBQUM7b0JBQ2xHLFlBQVksRUFBRSxDQUFDLGdCQUFnQixFQUFFLGdCQUFnQixFQUFFLHlCQUF5QixFQUFFLHdCQUF3QixDQUFDO2lCQUMxRyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgRG5kTGlzdERpcmVjdGl2ZSB9IGZyb20gJy4vZG5kLWxpc3QvZG5kLWxpc3QuZGlyZWN0aXZlJztcbmltcG9ydCB7IERuZEl0ZW1EaXJlY3RpdmUgfSBmcm9tICcuL2RuZC1pdGVtL2RuZC1pdGVtLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBEcmFnRHJvcE1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9kcmFnLWRyb3AnO1xuaW1wb3J0IHsgRG5kS2V5Ym9hcmRJdGVtRGlyZWN0aXZlIH0gZnJvbSAnLi9kbmQta2V5Ym9hcmQtaXRlbS9kbmQta2V5Ym9hcmQtaXRlbS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgRG5kS2V5Ym9hcmRHcm91cERpcmVjdGl2ZSB9IGZyb20gJy4vZG5kLWtleWJvYXJkLWdyb3VwL2RuZC1rZXlib2FyZC1ncm91cC5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIERyYWdEcm9wTW9kdWxlXSxcbiAgICBleHBvcnRzOiBbRG5kSXRlbURpcmVjdGl2ZSwgRG5kTGlzdERpcmVjdGl2ZSwgRG5kS2V5Ym9hcmRHcm91cERpcmVjdGl2ZSwgRG5kS2V5Ym9hcmRJdGVtRGlyZWN0aXZlXSxcbiAgICBkZWNsYXJhdGlvbnM6IFtEbmRJdGVtRGlyZWN0aXZlLCBEbmRMaXN0RGlyZWN0aXZlLCBEbmRLZXlib2FyZEdyb3VwRGlyZWN0aXZlLCBEbmRLZXlib2FyZEl0ZW1EaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIERyYWdBbmREcm9wTW9kdWxlIHt9XG4iXX0=

package/esm2020/utils/drag-and-drop/index.mjs

@@ -0,0 +1,8 @@
+export * from './dnd-item/dnd-item.directive';
+export * from './dnd-keyboard-group/dnd-keyboard-group.directive';
+export * from './dnd-keyboard-item/dnd-keyboard-item.directive';
+export * from './dnd-list/dnd-list.directive';
+export * from './dnd.interfaces';
+export * from './drag-and-drop.module';
+export * from './tokens';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RyYWctYW5kLWRyb3AvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMsaURBQWlELENBQUM7QUFDaEUsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RuZC1pdGVtL2RuZC1pdGVtLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2RuZC1rZXlib2FyZC1ncm91cC9kbmQta2V5Ym9hcmQtZ3JvdXAuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZG5kLWtleWJvYXJkLWl0ZW0vZG5kLWtleWJvYXJkLWl0ZW0uZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZG5kLWxpc3QvZG5kLWxpc3QuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZG5kLmludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWFuZC1kcm9wLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3Rva2Vucyc7XG4iXX0=

package/esm2020/utils/drag-and-drop/tokens.mjs

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+export const DND_ITEM = new InjectionToken('Drag and drop Item');
+export const DND_LIST = new InjectionToken('Drag and drop List');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kcmFnLWFuZC1kcm9wL3Rva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxJQUFJLGNBQWMsQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO0FBQ2pFLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxJQUFJLGNBQWMsQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IERORF9JVEVNID0gbmV3IEluamVjdGlvblRva2VuKCdEcmFnIGFuZCBkcm9wIEl0ZW0nKTtcbmV4cG9ydCBjb25zdCBETkRfTElTVCA9IG5ldyBJbmplY3Rpb25Ub2tlbignRHJhZyBhbmQgZHJvcCBMaXN0Jyk7XG4iXX0=

package/esm2020/utils/dynamic-component/dynamic-component-config.mjs

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

package/esm2020/utils/dynamic-component/dynamic-component-container.mjs

@@ -0,0 +1,21 @@
+export class DynamicComponentContainer {
+    /** @hidden */
+    constructor(_elementRef, _componentFactoryResolver) {
+        this._elementRef = _elementRef;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        /** @hidden */
+        this.childContent = undefined;
+    }
+    /** @hidden Load received content as component */
+    _createFromComponent(content) {
+        this.containerRef.clear();
+        const componentFactory = this._componentFactoryResolver.resolveComponentFactory(content);
+        this._componentRef = this.containerRef.createComponent(componentFactory);
+    }
+    /** @hidden Load received content as embedded view */
+    _createFromTemplate(content, context) {
+        this.containerRef.clear();
+        this._componentRef = this.containerRef.createEmbeddedView(content, context);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/dynamic-component/dynamic-component-injector.mjs

@@ -0,0 +1,20 @@
+export class DynamicComponentInjector {
+    /** @hidden */
+    constructor(_parentInjector, _additionalTokens) {
+        this._parentInjector = _parentInjector;
+        this._additionalTokens = _additionalTokens;
+    }
+    /**
+     *
+     * @param token
+     * @param notFoundValue
+     */
+    get(token, notFoundValue) {
+        const value = this._additionalTokens.get(token);
+        if (value) {
+            return value;
+        }
+        return this._parentInjector.get(token, notFoundValue);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1jb21wb25lbnQtaW5qZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2R5bmFtaWMtY29tcG9uZW50L2R5bmFtaWMtY29tcG9uZW50LWluamVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyx3QkFBd0I7SUFDakMsY0FBYztJQUNkLFlBQW9CLGVBQXlCLEVBQVUsaUJBQW9DO1FBQXZFLG9CQUFlLEdBQWYsZUFBZSxDQUFVO1FBQVUsc0JBQWlCLEdBQWpCLGlCQUFpQixDQUFtQjtJQUFHLENBQUM7SUFFL0Y7Ozs7T0FJRztJQUNILEdBQUcsQ0FBQyxLQUFVLEVBQUUsYUFBbUI7UUFDL0IsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUVoRCxJQUFJLEtBQUssRUFBRTtZQUNQLE9BQU8sS0FBSyxDQUFDO1NBQ2hCO1FBRUQsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLEdBQUcsQ0FBTSxLQUFLLEVBQUUsYUFBYSxDQUFDLENBQUM7SUFDL0QsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNsYXNzIER5bmFtaWNDb21wb25lbnRJbmplY3RvciBpbXBsZW1lbnRzIEluamVjdG9yIHtcbiAgICAvKiogQGhpZGRlbiAqL1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgX3BhcmVudEluamVjdG9yOiBJbmplY3RvciwgcHJpdmF0ZSBfYWRkaXRpb25hbFRva2VuczogV2Vha01hcDxhbnksIGFueT4pIHt9XG5cbiAgICAvKipcbiAgICAgKlxuICAgICAqIEBwYXJhbSB0b2tlblxuICAgICAqIEBwYXJhbSBub3RGb3VuZFZhbHVlXG4gICAgICovXG4gICAgZ2V0KHRva2VuOiBhbnksIG5vdEZvdW5kVmFsdWU/OiBhbnkpOiB2b2lkIHtcbiAgICAgICAgY29uc3QgdmFsdWUgPSB0aGlzLl9hZGRpdGlvbmFsVG9rZW5zLmdldCh0b2tlbik7XG5cbiAgICAgICAgaWYgKHZhbHVlKSB7XG4gICAgICAgICAgICByZXR1cm4gdmFsdWU7XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gdGhpcy5fcGFyZW50SW5qZWN0b3IuZ2V0PGFueT4odG9rZW4sIG5vdEZvdW5kVmFsdWUpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/utils/dynamic-component/dynamic-component.service.mjs

@@ -0,0 +1,90 @@
+import { ComponentFactoryResolver, Injectable, ApplicationRef, Injector, Compiler, NgModuleFactory } from '@angular/core';
+import { DynamicComponentInjector } from './dynamic-component-injector';
+import * as i0 from "@angular/core";
+/**
+ * Service used to dynamically generate components like dialogs/alerts/notifications
+ */
+export class DynamicComponentService {
+    /** @hidden */
+    constructor(_componentFactoryResolver, _applicationRef, _injector, _compiler) {
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._applicationRef = _applicationRef;
+        this._injector = _injector;
+        this._compiler = _compiler;
+    }
+    /**
+     * Function that creates dynamic component and injects services to allow communication between component and outside
+     * @param content Type of the component content
+     * @param componentType Type of component that should be rendered.
+     * @param config Configuration that will be passed to the component.
+     * @param inject  enables to provide preconfigured component injector and dependencies
+     */
+    createDynamicComponent(content, componentType, config, inject = {}) {
+        const { injector, services } = inject;
+        const dependenciesMap = this._createDependencyMap(services);
+        const componentRef = this._createComponent(componentType, dependenciesMap, injector);
+        this._passExternalContent(componentRef, content);
+        this._attachToContainer(componentRef, config);
+        return componentRef;
+    }
+    /**
+     * Function that creates dynamic component and injects services to allow communication between component and outside
+     * @param content Type of the component content
+     * @param moduleType Type of module that should be compiled.
+     * @param componentType Type of component that should be rendered.
+     * @param containerRef The container that the dynamic component is appended to.
+     * @param injector enables to provide preconfigured component injector
+     */
+    async createDynamicModule(content, moduleType, componentType, containerRef, injector) {
+        const moduleFactory = moduleType instanceof NgModuleFactory ? moduleType : await this._compiler.compileModuleAsync(moduleType);
+        const moduleRef = moduleFactory.create(injector || this._injector);
+        const componentFactory = moduleRef.componentFactoryResolver.resolveComponentFactory(componentType);
+        containerRef.clear();
+        const componentRef = containerRef.createComponent(componentFactory);
+        this._passExternalContent(componentRef, content);
+        return componentRef;
+    }
+    /** Function that destroys dynamic component */
+    destroyComponent(componentRef) {
+        this._applicationRef.detachView(componentRef.hostView);
+        componentRef.destroy();
+    }
+    /** @hidden */
+    _createDependencyMap(services = []) {
+        const dependencyMap = new WeakMap();
+        services.filter((service) => !!service).forEach((service) => dependencyMap.set(service.constructor, service));
+        return dependencyMap;
+    }
+    /** @hidden */
+    _attachToContainer(componentRef, config) {
+        const configObj = Object.assign({}, config);
+        const componentEl = componentRef.hostView.rootNodes[0];
+        if (configObj.container !== 'body') {
+            configObj.container?.appendChild(componentEl);
+        }
+        else {
+            document.body.appendChild(componentEl);
+        }
+    }
+    /** @hidden */
+    _createComponent(componentType, dependenciesMap, injector) {
+        const dynamicComponentInjector = new DynamicComponentInjector(injector || this._injector, dependenciesMap);
+        const componentFactory = this._componentFactoryResolver.resolveComponentFactory(componentType);
+        const componentRef = componentFactory.create(dynamicComponentInjector);
+        this._applicationRef.attachView(componentRef.hostView);
+        return componentRef;
+    }
+    /** @hidden */
+    _passExternalContent(componentRef, content) {
+        // TODO: this approach should be revisited, it can cause issues, that is really hard to debug
+        if (Object.prototype.hasOwnProperty.call(componentRef.instance, 'childContent')) {
+            componentRef.instance.childContent = content;
+        }
+    }
+}
+DynamicComponentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DynamicComponentService, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.ApplicationRef }, { token: i0.Injector }, { token: i0.Compiler }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicComponentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DynamicComponentService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DynamicComponentService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i0.Injector }, { type: i0.Compiler }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-component.service.js","sourceRoot":"","sources":["../../../../../../libs/cdk/src/lib/utils/dynamic-component/dynamic-component.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ComponentFactoryResolver,\n    Injectable,\n    ApplicationRef,\n    Injector,\n    EmbeddedViewRef,\n    ComponentRef,\n    TemplateRef,\n    Type,\n    Compiler,\n    NgModuleFactory,\n    ViewContainerRef\n} from '@angular/core';\nimport { DynamicComponentInjector } from './dynamic-component-injector';\nimport { DynamicComponentConfig } from './dynamic-component-config';\n\n/**\n * Service used to dynamically generate components like dialogs/alerts/notifications\n */\n@Injectable()\nexport class DynamicComponentService {\n    /** @hidden */\n    constructor(\n        private readonly _componentFactoryResolver: ComponentFactoryResolver,\n        private readonly _applicationRef: ApplicationRef,\n        private readonly _injector: Injector,\n        private readonly _compiler: Compiler\n    ) {}\n\n    /**\n     * Function that creates dynamic component and injects services to allow communication between component and outside\n     * @param content Type of the component content\n     * @param componentType Type of component that should be rendered.\n     * @param config Configuration that will be passed to the component.\n     * @param inject  enables to provide preconfigured component injector and dependencies\n     */\n    public createDynamicComponent<T>(\n        content: TemplateRef<any> | Type<any> | string | Record<string, any>,\n        componentType: Type<T>,\n        config: DynamicComponentConfig,\n        inject: { injector?: Injector; services?: any[] } = {}\n    ): ComponentRef<T> {\n        const { injector, services } = inject;\n        const dependenciesMap = this._createDependencyMap(services);\n        const componentRef = this._createComponent<T>(componentType, dependenciesMap, injector);\n        this._passExternalContent<T>(componentRef, content);\n        this._attachToContainer<T>(componentRef, config);\n\n        return componentRef;\n    }\n\n    /**\n     * Function that creates dynamic component and injects services to allow communication between component and outside\n     * @param content Type of the component content\n     * @param moduleType Type of module that should be compiled.\n     * @param componentType Type of component that should be rendered.\n     * @param containerRef The container that the dynamic component is appended to.\n     * @param injector enables to provide preconfigured component injector\n     */\n    async createDynamicModule<M, C>(\n        content: TemplateRef<any> | Type<any> | string | Record<string, any>,\n        moduleType: Type<M> | NgModuleFactory<M>,\n        componentType: Type<C>,\n        containerRef: ViewContainerRef,\n        injector?: Injector\n    ): Promise<ComponentRef<C>> {\n        const moduleFactory =\n            moduleType instanceof NgModuleFactory ? moduleType : await this._compiler.compileModuleAsync<M>(moduleType);\n        const moduleRef = moduleFactory.create(injector || this._injector);\n        const componentFactory = moduleRef.componentFactoryResolver.resolveComponentFactory(componentType);\n\n        containerRef.clear();\n\n        const componentRef: ComponentRef<C> = containerRef.createComponent(componentFactory);\n\n        this._passExternalContent<C>(componentRef, content);\n\n        return componentRef;\n    }\n\n    /** Function that destroys dynamic component */\n    public destroyComponent(componentRef: ComponentRef<any>): void {\n        this._applicationRef.detachView(componentRef.hostView);\n        componentRef.destroy();\n    }\n\n    /** @hidden */\n    private _createDependencyMap(services: any[] = []): WeakMap<any, any> {\n        const dependencyMap = new WeakMap();\n        services.filter((service) => !!service).forEach((service) => dependencyMap.set(service.constructor, service));\n        return dependencyMap;\n    }\n\n    /** @hidden */\n    private _attachToContainer<V>(componentRef: ComponentRef<V>, config: DynamicComponentConfig): void {\n        const configObj = Object.assign({}, config);\n        const componentEl = (componentRef.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;\n        if (configObj.container !== 'body') {\n            configObj.container?.appendChild(componentEl);\n        } else {\n            document.body.appendChild(componentEl);\n        }\n    }\n\n    /** @hidden */\n    private _createComponent<V>(\n        componentType: Type<V>,\n        dependenciesMap: WeakMap<any, any>,\n        injector?: Injector\n    ): ComponentRef<V> {\n        const dynamicComponentInjector = new DynamicComponentInjector(injector || this._injector, dependenciesMap);\n        const componentFactory = this._componentFactoryResolver.resolveComponentFactory(componentType);\n        const componentRef = componentFactory.create(dynamicComponentInjector);\n        this._applicationRef.attachView(componentRef.hostView);\n        return componentRef;\n    }\n\n    /** @hidden */\n    private _passExternalContent<V>(\n        componentRef: ComponentRef<V>,\n        content: TemplateRef<any> | Type<any> | string | Record<string, any>\n    ): void {\n        // TODO: this approach should be revisited, it can cause issues, that is really hard to debug\n        if (Object.prototype.hasOwnProperty.call(componentRef.instance, 'childContent')) {\n            (componentRef.instance as any).childContent = content;\n        }\n    }\n}\n"]}

package/esm2020/utils/dynamic-component/index.mjs

@@ -0,0 +1,5 @@
+export * from './dynamic-component-config';
+export * from './dynamic-component-container';
+export * from './dynamic-component-injector';
+export * from './dynamic-component.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2R5bmFtaWMtY29tcG9uZW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtY29tcG9uZW50LWNvbmZpZyc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtY29tcG9uZW50LWNvbnRhaW5lcic7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtY29tcG9uZW50LWluamVjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1jb21wb25lbnQuc2VydmljZSc7XG4iXX0=

package/esm2020/utils/functions/consumer-provider-factory.mjs

@@ -0,0 +1,12 @@
+import { INJECTOR } from '@angular/core';
+/**
+ * Creates provider for ConsumerClass
+ */
+export function consumerProviderFactory(ConsumerClass, providedConfiguration) {
+    return {
+        provide: ConsumerClass,
+        useFactory: (injector) => new ConsumerClass(injector, providedConfiguration),
+        deps: [INJECTOR]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3VtZXItcHJvdmlkZXItZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZnVuY3Rpb25zL2NvbnN1bWVyLXByb3ZpZGVyLWZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBc0IsTUFBTSxlQUFlLENBQUM7QUFFN0Q7O0dBRUc7QUFDSCxNQUFNLFVBQVUsdUJBQXVCLENBQ25DLGFBQTRGLEVBQzVGLHFCQUF3QztJQUV4QyxPQUFPO1FBQ0gsT0FBTyxFQUFFLGFBQWE7UUFDdEIsVUFBVSxFQUFFLENBQUMsUUFBa0IsRUFBRSxFQUFFLENBQUMsSUFBSSxhQUFhLENBQUMsUUFBUSxFQUFFLHFCQUFxQixDQUFDO1FBQ3RGLElBQUksRUFBRSxDQUFDLFFBQVEsQ0FBQztLQUNuQixDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElOSkVDVE9SLCBJbmplY3RvciwgUHJvdmlkZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBDcmVhdGVzIHByb3ZpZGVyIGZvciBDb25zdW1lckNsYXNzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjb25zdW1lclByb3ZpZGVyRmFjdG9yeTxUID0gYW55PihcbiAgICBDb25zdW1lckNsYXNzOiBuZXcgKGluamVjdG9yOiBJbmplY3RvciwgYWRkaXRpb25hbENvbmZpZzogUmVjb3JkPGFueSwgYW55PiB8IHVuZGVmaW5lZCkgPT4gVCxcbiAgICBwcm92aWRlZENvbmZpZ3VyYXRpb24/OiBSZWNvcmQ8YW55LCBhbnk+XG4pOiBQcm92aWRlciB7XG4gICAgcmV0dXJuIHtcbiAgICAgICAgcHJvdmlkZTogQ29uc3VtZXJDbGFzcyxcbiAgICAgICAgdXNlRmFjdG9yeTogKGluamVjdG9yOiBJbmplY3RvcikgPT4gbmV3IENvbnN1bWVyQ2xhc3MoaW5qZWN0b3IsIHByb3ZpZGVkQ29uZmlndXJhdGlvbiksXG4gICAgICAgIGRlcHM6IFtJTkpFQ1RPUl1cbiAgICB9O1xufVxuIl19

package/esm2020/utils/functions/element-size.mjs

@@ -0,0 +1,23 @@
+import { ElementRef } from '@angular/core';
+export const pxToNum = (pixels) => Number(pixels.replace('px', '')) || 0;
+export const toNativeElement = (element) => element instanceof ElementRef ? element.nativeElement : element;
+/** Return elements capacity (width subtract by element padding)
+ * @param element - HTMLelement or element reference
+ * */
+export function getElementCapacity(element) {
+    const _element = toNativeElement(element);
+    const computedStyle = window.getComputedStyle(_element);
+    return pxToNum(computedStyle.width) - pxToNum(computedStyle.paddingLeft) - pxToNum(computedStyle.paddingRight);
+}
+/** Return elements width
+ * @param element - HTMLelement or element reference
+ * @param withMargin - weather to add element margins to width
+ * */
+export function getElementWidth(element, withMargin) {
+    const _element = toNativeElement(element);
+    const computedStyle = getComputedStyle(_element);
+    return withMargin
+        ? pxToNum(computedStyle.width) + pxToNum(computedStyle.marginLeft) + pxToNum(computedStyle.marginRight)
+        : pxToNum(computedStyle.width);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/functions/get-document-font-size.mjs

@@ -0,0 +1,5 @@
+/** Get document font size in pixels. */
+export function getDocumentFontSize() {
+    return document?.documentElement ? parseFloat(getComputedStyle(document.documentElement).fontSize) : 16;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWRvY3VtZW50LWZvbnQtc2l6ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZnVuY3Rpb25zL2dldC1kb2N1bWVudC1mb250LXNpemUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0NBQXdDO0FBQ3hDLE1BQU0sVUFBVSxtQkFBbUI7SUFDL0IsT0FBTyxRQUFRLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxDQUFDLGVBQWUsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7QUFDNUcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBHZXQgZG9jdW1lbnQgZm9udCBzaXplIGluIHBpeGVscy4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXREb2N1bWVudEZvbnRTaXplKCk6IG51bWJlciB7XG4gICAgcmV0dXJuIGRvY3VtZW50Py5kb2N1bWVudEVsZW1lbnQgPyBwYXJzZUZsb2F0KGdldENvbXB1dGVkU3R5bGUoZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50KS5mb250U2l6ZSkgOiAxNjtcbn1cbiJdfQ==

package/esm2020/utils/functions/index.mjs

@@ -0,0 +1,13 @@
+export * from './key-util';
+export * from './element-size';
+export * from './uuidv4-generator';
+export * from './parser-file-size';
+export * from './scroll';
+export * from './random-color-accent';
+export * from './resize-observable';
+export * from './intersection-observable';
+export * from './is-compact-density';
+export * from './module-deprecations-provider';
+export * from './consumer-provider-factory';
+export * from './get-document-font-size';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2Z1bmN0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9rZXktdXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL2VsZW1lbnQtc2l6ZSc7XG5leHBvcnQgKiBmcm9tICcuL3V1aWR2NC1nZW5lcmF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9wYXJzZXItZmlsZS1zaXplJztcbmV4cG9ydCAqIGZyb20gJy4vc2Nyb2xsJztcbmV4cG9ydCAqIGZyb20gJy4vcmFuZG9tLWNvbG9yLWFjY2VudCc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc2l6ZS1vYnNlcnZhYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJzZWN0aW9uLW9ic2VydmFibGUnO1xuZXhwb3J0ICogZnJvbSAnLi9pcy1jb21wYWN0LWRlbnNpdHknO1xuZXhwb3J0ICogZnJvbSAnLi9tb2R1bGUtZGVwcmVjYXRpb25zLXByb3ZpZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3VtZXItcHJvdmlkZXItZmFjdG9yeSc7XG5leHBvcnQgKiBmcm9tICcuL2dldC1kb2N1bWVudC1mb250LXNpemUnO1xuIl19

package/esm2020/utils/functions/intersection-observable.mjs

@@ -0,0 +1,26 @@
+import { NEVER, Observable } from 'rxjs';
+/**
+ * RxJS wrapper for IntersectionObserver class.
+ * @param target HTML element to spy on.
+ * @param options @see {IntersectionObserverInit}
+ * @returns {Observable} with observer entries.
+ */
+export function intersectionObservable(target, options) {
+    if ('IntersectionObserver' in window) {
+        return new Observable((subscriber) => {
+            const io = new IntersectionObserver((entries) => {
+                subscriber.next(entries);
+            }, options);
+            io.observe(target);
+            return function unsubscribe() {
+                io.disconnect();
+            };
+        });
+    }
+    else {
+        // If browser doesn't support IntersectionObserver API never emit a value
+        // since we're not supporting IE11 and any other browser should have it.
+        return NEVER;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/functions/is-compact-density.mjs

@@ -0,0 +1,11 @@
+/** Determines whether provided value is valid content density */
+export function isValidContentDensity(size) {
+    return size === 'cozy' || size === 'compact' || size === 'condensed';
+}
+/**
+ * Determines if "compact" styles should be applied based on provided content density
+ */
+export function isCompactDensity(size) {
+    return isValidContentDensity(size) && size !== 'cozy';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtY29tcGFjdC1kZW5zaXR5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9mdW5jdGlvbnMvaXMtY29tcGFjdC1kZW5zaXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLGlFQUFpRTtBQUNqRSxNQUFNLFVBQVUscUJBQXFCLENBQUMsSUFBUztJQUMzQyxPQUFPLElBQUksS0FBSyxNQUFNLElBQUksSUFBSSxLQUFLLFNBQVMsSUFBSSxJQUFJLEtBQUssV0FBVyxDQUFDO0FBQ3pFLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxJQUFvQjtJQUNqRCxPQUFPLHFCQUFxQixDQUFDLElBQUksQ0FBQyxJQUFJLElBQUksS0FBSyxNQUFNLENBQUM7QUFDMUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbnRlbnREZW5zaXR5IH0gZnJvbSAnLi4vaW50ZXJmYWNlcy9jb250ZW50LWRlbnNpdHknO1xuXG4vKiogRGV0ZXJtaW5lcyB3aGV0aGVyIHByb3ZpZGVkIHZhbHVlIGlzIHZhbGlkIGNvbnRlbnQgZGVuc2l0eSAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzVmFsaWRDb250ZW50RGVuc2l0eShzaXplOiBhbnkpOiBzaXplIGlzIENvbnRlbnREZW5zaXR5IHtcbiAgICByZXR1cm4gc2l6ZSA9PT0gJ2NvenknIHx8IHNpemUgPT09ICdjb21wYWN0JyB8fCBzaXplID09PSAnY29uZGVuc2VkJztcbn1cblxuLyoqXG4gKiBEZXRlcm1pbmVzIGlmIFwiY29tcGFjdFwiIHN0eWxlcyBzaG91bGQgYmUgYXBwbGllZCBiYXNlZCBvbiBwcm92aWRlZCBjb250ZW50IGRlbnNpdHlcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzQ29tcGFjdERlbnNpdHkoc2l6ZTogQ29udGVudERlbnNpdHkpOiBib29sZWFuIHtcbiAgICByZXR1cm4gaXNWYWxpZENvbnRlbnREZW5zaXR5KHNpemUpICYmIHNpemUgIT09ICdjb3p5Jztcbn1cbiJdfQ==