@fundamental-ngx/cdk 0.38.3-rc.4

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

@@ -0,0 +1,255 @@
+import { Directive, ElementRef, EventEmitter, forwardRef, HostBinding, Input, Output } from '@angular/core';
+import { DragDrop } from '@angular/cdk/drag-drop';
+import { Subscription } from 'rxjs';
+import { delay } from 'rxjs/operators';
+import { DND_ITEM } from '../tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/drag-drop";
+export class DndItemDirective {
+    /** @hidden */
+    constructor(elementRef, _dragDrop) {
+        this.elementRef = elementRef;
+        this._dragDrop = _dragDrop;
+        /**
+         * Whether to apply "fd-dnd-item" class.
+         * @default true
+         */
+        this.applyDragItemClass = true;
+        /** Event thrown when the element is moved by 1px */
+        this.moved = new EventEmitter();
+        /** Event thrown when the element is released */
+        this.released = new EventEmitter();
+        /** Event thrown when the element is started to be dragged */
+        this.started = new EventEmitter();
+        /**
+         *  Defines if the item is prevented from being moved by other elements.
+         * So nothing can be placed just before and just after it
+         */
+        this.stickInPlace = false;
+        /** Class added to element, when it's dragged. */
+        this.classWhenElementDragged = 'fd-dnd-on-drag';
+        /** Defines if every element in list is draggable */
+        this.listDraggable = true;
+        /** @hidden */
+        this._draggable = true;
+        /** @hidden */
+        this._subscriptions = new Subscription();
+    }
+    /** Defines if element is draggable */
+    set draggable(draggable) {
+        this._draggable = draggable;
+        this.changeCDKDragState();
+    }
+    /** @hidden */
+    getElementCoordinates(isBefore) {
+        /** Takes distance from the beginning of window page */
+        const rect = this.elementRef.nativeElement.getBoundingClientRect();
+        const position = isBefore ? 'before' : 'after';
+        /** Vertically distance is counted by distance from top of the side + half of the element height */
+        return {
+            x: rect.left,
+            position,
+            y: rect.top,
+            stickToPosition: this.stickInPlace,
+            width: rect.width,
+            height: rect.height
+        };
+    }
+    /** @hidden */
+    ngAfterContentInit() {
+        this._setCDKDrag();
+        this._listenElementEvents();
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+    }
+    /** @hidden */
+    onCdkMove(position) {
+        this.moved.emit(position);
+    }
+    /** @hidden */
+    onCdkDragReleased() {
+        /** Remove class which is added, when element is dragged */
+        this.elementRef.nativeElement.classList.remove(this.classWhenElementDragged);
+        this.released.emit();
+        /** Resets the position of element. */
+        this._dragRef.reset();
+        /** Removes placeholder element */
+        this.removePlaceholder();
+    }
+    /** @hidden */
+    onCdkDragStart() {
+        /** Adds class */
+        this.elementRef.nativeElement.classList.add(this.classWhenElementDragged);
+        if (!this._placeholderElement) {
+            this.createPlaceholder();
+        }
+        this.started.emit();
+    }
+    /** @hidden */
+    removePlaceholder() {
+        if (this._placeholderElement && this._placeholderElement.parentNode) {
+            // IE11 workaround
+            this._placeholderElement.parentNode.removeChild(this._placeholderElement);
+            this._placeholderElement = null;
+        }
+    }
+    /** @hidden */
+    removeLine() {
+        if (this._lineElement && this._lineElement.parentNode) {
+            // IE11 workaround
+            this._lineElement.parentNode.removeChild(this._lineElement);
+            this._lineElement = null;
+        }
+    }
+    /** @hidden */
+    removeReplaceIndicator() {
+        if (this._replaceIndicator && this._replaceIndicator.parentNode) {
+            // IE11 workaround
+            this._replaceIndicator.parentNode.removeChild(this._replaceIndicator);
+            this._replaceIndicator = null;
+        }
+    }
+    /** @hidden */
+    createReplaceIndicator() {
+        this._replaceIndicator = document.createElement('DIV');
+        this._replaceIndicator.classList.add('fd-replace-indicator');
+        let container = this.elementRef.nativeElement;
+        if (this.containerSelector) {
+            const newContainer = this.elementRef.nativeElement.querySelector(this.containerSelector);
+            if (newContainer) {
+                container = newContainer;
+            }
+        }
+        container.appendChild(this._replaceIndicator);
+    }
+    /** @hidden */
+    createLine(position, gridMode) {
+        /** Creating of line element */
+        this._lineElement = document.createElement('div');
+        this._lineElement.classList.add('drop-area__line');
+        if (gridMode) {
+            this._lineElement.classList.add('drop-area__line--vertical');
+        }
+        else {
+            this._lineElement.classList.add('drop-area__line--horizontal');
+        }
+        if (position === 'after') {
+            this._lineElement.classList.add('after');
+        }
+        if (position === 'before') {
+            this._lineElement.classList.add('before');
+        }
+        /** Putting element to the container */
+        let container = this.elementRef.nativeElement;
+        if (this.containerSelector) {
+            const newContainer = this.elementRef.nativeElement.querySelector(this.containerSelector);
+            if (newContainer) {
+                container = newContainer;
+            }
+        }
+        container.appendChild(this._lineElement);
+    }
+    /** @hidden */
+    changeCDKDragState() {
+        if (this._dragRef) {
+            this._dragRef.disabled = !(this._draggable && this.listDraggable);
+        }
+    }
+    /** @hidden */
+    createPlaceholder() {
+        const placeholder = this.elementRef.nativeElement.cloneNode(true);
+        /** Cloning container element */
+        this._placeholderElement = placeholder;
+        placeholder.classList.add('fd-dnd-placeholder');
+        this._setPlaceholderStyles();
+        /** Including element to the container
+         *  IE11 equivalent to `this.element.nativeElement.after(clone);`
+         */
+        this._placeAfter(this.elementRef.nativeElement, placeholder);
+    }
+    /** @hidden */
+    _setPlaceholderStyles() {
+        const offset = this._getOffsetToParent(this.elementRef.nativeElement);
+        if (!offset || !this._placeholderElement) {
+            return;
+        }
+        this._placeholderElement.style.top = offset.y + 'px';
+        this._placeholderElement.style.left = offset.x + 'px';
+        this._placeholderElement.style.position = 'absolute';
+        this._placeholderElement.style.zIndex = '0';
+        this._placeholderElement.style.opacity = '0.3';
+        this._placeholderElement.style.width = this.elementRef.nativeElement.offsetWidth + 'px';
+        this._placeholderElement.style.height = this.elementRef.nativeElement.offsetHeight + 'px';
+    }
+    /** @hidden */
+    _getOffsetToParent(element) {
+        const parentElement = element.parentElement;
+        if (!parentElement) {
+            return;
+        }
+        const parentTop = parentElement.getBoundingClientRect().top;
+        const parentLeft = parentElement.getBoundingClientRect().left;
+        return {
+            x: Math.abs(element.getBoundingClientRect().left - parentLeft),
+            y: Math.abs(element.getBoundingClientRect().top - parentTop)
+        };
+    }
+    /** @hidden */
+    _setCDKDrag() {
+        this._dragRef = this._dragDrop.createDrag(this.elementRef);
+        this._dragRef.disabled = !this._draggable;
+        this._subscriptions.add(this._dragRef.moved.subscribe((event) => this.onCdkMove(event.pointerPosition)));
+        this._subscriptions.add(this._dragRef.released.subscribe(() => this.onCdkDragReleased()));
+        this._subscriptions.add(this._dragRef.started.subscribe(() => this.onCdkDragStart()));
+    }
+    /** IE11 equivalent of Node.after() Method */
+    _placeAfter(element, cloneNode) {
+        const docFrag = document.createDocumentFragment();
+        docFrag.appendChild(cloneNode);
+        element.parentNode?.insertBefore(docFrag, element.nextSibling);
+    }
+    /** @hidden */
+    _listenElementEvents() {
+        this._subscriptions.add(this.released
+            .pipe(
+        // postpone blur
+        delay(0))
+            .subscribe(() => {
+            if (this.containerSelector) {
+                this.elementRef.nativeElement.children[0].blur();
+            }
+            this.elementRef.nativeElement.blur();
+        }));
+    }
+}
+DndItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DndItemDirective, deps: [{ token: i0.ElementRef }, { token: i1.DragDrop }], target: i0.ɵɵFactoryTarget.Directive });
+DndItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DndItemDirective, selector: "[fdkDndItem], [fd-dnd-item]", inputs: { applyDragItemClass: "applyDragItemClass", containerSelector: "containerSelector", stickInPlace: "stickInPlace", draggable: "draggable", classWhenElementDragged: "classWhenElementDragged" }, outputs: { moved: "moved", released: "released", started: "started" }, host: { properties: { "class.fd-dnd-item": "this.applyDragItemClass" } }, providers: [DragDrop, { provide: DND_ITEM, useExisting: forwardRef(() => DndItemDirective) }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DndItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkDndItem], [fd-dnd-item]',
+                    providers: [DragDrop, { provide: DND_ITEM, useExisting: forwardRef(() => DndItemDirective) }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.DragDrop }]; }, propDecorators: { applyDragItemClass: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.fd-dnd-item']
+            }], containerSelector: [{
+                type: Input
+            }], moved: [{
+                type: Output
+            }], released: [{
+                type: Output
+            }], started: [{
+                type: Output
+            }], stickInPlace: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], classWhenElementDragged: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dnd-item.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/drag-and-drop/dnd-item/dnd-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    forwardRef,\n    HostBinding,\n    Input,\n    OnDestroy,\n    Output\n} from '@angular/core';\nimport { DragDrop, DragRef } from '@angular/cdk/drag-drop';\nimport { DndItem, ElementChord, ElementPosition, LinkPosition } from '../dnd.interfaces';\nimport { Subscription } from 'rxjs';\nimport { delay } from 'rxjs/operators';\nimport { DND_ITEM } from '../tokens';\n\n@Directive({\n    selector: '[fdkDndItem], [fd-dnd-item]',\n    providers: [DragDrop, { provide: DND_ITEM, useExisting: forwardRef(() => DndItemDirective) }]\n})\nexport class DndItemDirective implements DndItem, AfterContentInit, OnDestroy {\n    /**\n     * Whether to apply \"fd-dnd-item\" class.\n     * @default true\n     */\n    @Input()\n    @HostBinding('class.fd-dnd-item')\n    applyDragItemClass = true;\n\n    /** Container selector */\n    @Input()\n    containerSelector?: string;\n\n    /** Event thrown when the element is moved by 1px */\n    @Output()\n    readonly moved = new EventEmitter<ElementPosition>();\n\n    /** Event thrown when the element is released */\n    @Output()\n    readonly released = new EventEmitter<void>();\n\n    /** Event thrown when the element is started to be dragged */\n    @Output()\n    readonly started = new EventEmitter<void>();\n\n    /**\n     *  Defines if the item is prevented from being moved by other elements.\n     * So nothing can be placed just before and just after it\n     */\n    @Input()\n    stickInPlace = false;\n\n    /** Defines if element is draggable */\n    @Input()\n    set draggable(draggable: boolean) {\n        this._draggable = draggable;\n        this.changeCDKDragState();\n    }\n\n    /** Class added to element, when it's dragged. */\n    @Input()\n    classWhenElementDragged = 'fd-dnd-on-drag';\n\n    /** Defines if every element in list is draggable */\n    listDraggable = true;\n\n    /** @hidden\n     * Drag reference, object created from DND CDK Service\n     */\n    private _dragRef: DragRef;\n\n    /** @hidden */\n    private _draggable = true;\n\n    /** @hidden */\n    private _subscriptions = new Subscription();\n\n    /** @hidden */\n    private _placeholderElement: HTMLElement | null;\n\n    /** @hidden */\n    private _lineElement: HTMLElement | null;\n\n    /** @hidden */\n    private _replaceIndicator: HTMLElement | null;\n\n    /** @hidden */\n    constructor(public elementRef: ElementRef, private _dragDrop: DragDrop) {}\n\n    /** @hidden */\n    getElementCoordinates(isBefore: boolean): ElementChord {\n        /** Takes distance from the beginning of window page */\n        const rect: DOMRect = this.elementRef.nativeElement.getBoundingClientRect();\n\n        const position: LinkPosition = isBefore ? 'before' : 'after';\n\n        /** Vertically distance is counted by distance from top of the side + half of the element height */\n        return {\n            x: rect.left,\n            position,\n            y: rect.top,\n            stickToPosition: this.stickInPlace,\n            width: rect.width,\n            height: rect.height\n        };\n    }\n\n    /** @hidden */\n    ngAfterContentInit(): void {\n        this._setCDKDrag();\n        this._listenElementEvents();\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._subscriptions.unsubscribe();\n    }\n\n    /** @hidden */\n    onCdkMove(position: ElementPosition): void {\n        this.moved.emit(position);\n    }\n\n    /** @hidden */\n    onCdkDragReleased(): void {\n        /** Remove class which is added, when element is dragged */\n        this.elementRef.nativeElement.classList.remove(this.classWhenElementDragged);\n        this.released.emit();\n\n        /** Resets the position of element. */\n        this._dragRef.reset();\n\n        /** Removes placeholder element */\n        this.removePlaceholder();\n    }\n\n    /** @hidden */\n    onCdkDragStart(): void {\n        /** Adds class */\n        this.elementRef.nativeElement.classList.add(this.classWhenElementDragged);\n\n        if (!this._placeholderElement) {\n            this.createPlaceholder();\n        }\n        this.started.emit();\n    }\n\n    /** @hidden */\n    removePlaceholder(): void {\n        if (this._placeholderElement && this._placeholderElement.parentNode) {\n            // IE11 workaround\n            this._placeholderElement.parentNode.removeChild(this._placeholderElement);\n            this._placeholderElement = null;\n        }\n    }\n\n    /** @hidden */\n    removeLine(): void {\n        if (this._lineElement && this._lineElement.parentNode) {\n            // IE11 workaround\n            this._lineElement.parentNode.removeChild(this._lineElement);\n            this._lineElement = null;\n        }\n    }\n\n    /** @hidden */\n    removeReplaceIndicator(): void {\n        if (this._replaceIndicator && this._replaceIndicator.parentNode) {\n            // IE11 workaround\n            this._replaceIndicator.parentNode.removeChild(this._replaceIndicator);\n            this._replaceIndicator = null;\n        }\n    }\n\n    /** @hidden */\n    createReplaceIndicator(): void {\n        this._replaceIndicator = document.createElement('DIV');\n        this._replaceIndicator.classList.add('fd-replace-indicator');\n\n        let container = this.elementRef.nativeElement;\n        if (this.containerSelector) {\n            const newContainer = this.elementRef.nativeElement.querySelector(this.containerSelector);\n            if (newContainer) {\n                container = newContainer;\n            }\n        }\n\n        container.appendChild(this._replaceIndicator);\n    }\n\n    /** @hidden */\n    createLine(position: LinkPosition, gridMode: boolean): void {\n        /** Creating of line element */\n        this._lineElement = document.createElement('div');\n        this._lineElement.classList.add('drop-area__line');\n\n        if (gridMode) {\n            this._lineElement.classList.add('drop-area__line--vertical');\n        } else {\n            this._lineElement.classList.add('drop-area__line--horizontal');\n        }\n        if (position === 'after') {\n            this._lineElement.classList.add('after');\n        }\n        if (position === 'before') {\n            this._lineElement.classList.add('before');\n        }\n\n        /** Putting element to the container */\n        let container = this.elementRef.nativeElement;\n        if (this.containerSelector) {\n            const newContainer = this.elementRef.nativeElement.querySelector(this.containerSelector);\n            if (newContainer) {\n                container = newContainer;\n            }\n        }\n\n        container.appendChild(this._lineElement);\n    }\n\n    /** @hidden */\n    changeCDKDragState(): void {\n        if (this._dragRef) {\n            this._dragRef.disabled = !(this._draggable && this.listDraggable);\n        }\n    }\n\n    /** @hidden */\n    private createPlaceholder(): void {\n        const placeholder = this.elementRef.nativeElement.cloneNode(true);\n        /** Cloning container element */\n        this._placeholderElement = placeholder;\n\n        placeholder.classList.add('fd-dnd-placeholder');\n        this._setPlaceholderStyles();\n\n        /** Including element to the container\n         *  IE11 equivalent to `this.element.nativeElement.after(clone);`\n         */\n        this._placeAfter(this.elementRef.nativeElement, placeholder);\n    }\n\n    /** @hidden */\n    private _setPlaceholderStyles(): void {\n        const offset = this._getOffsetToParent(this.elementRef.nativeElement);\n\n        if (!offset || !this._placeholderElement) {\n            return;\n        }\n\n        this._placeholderElement.style.top = offset.y + 'px';\n        this._placeholderElement.style.left = offset.x + 'px';\n        this._placeholderElement.style.position = 'absolute';\n        this._placeholderElement.style.zIndex = '0';\n        this._placeholderElement.style.opacity = '0.3';\n\n        this._placeholderElement.style.width = this.elementRef.nativeElement.offsetWidth + 'px';\n        this._placeholderElement.style.height = this.elementRef.nativeElement.offsetHeight + 'px';\n    }\n\n    /** @hidden */\n    private _getOffsetToParent(element: Element): { x: number; y: number } | undefined {\n        const parentElement = element.parentElement;\n        if (!parentElement) {\n            return;\n        }\n\n        const parentTop = parentElement.getBoundingClientRect().top;\n        const parentLeft = parentElement.getBoundingClientRect().left;\n\n        return {\n            x: Math.abs(element.getBoundingClientRect().left - parentLeft),\n            y: Math.abs(element.getBoundingClientRect().top - parentTop)\n        };\n    }\n\n    /** @hidden */\n    private _setCDKDrag(): void {\n        this._dragRef = this._dragDrop.createDrag(this.elementRef);\n        this._dragRef.disabled = !this._draggable;\n        this._subscriptions.add(this._dragRef.moved.subscribe((event) => this.onCdkMove(event.pointerPosition)));\n        this._subscriptions.add(this._dragRef.released.subscribe(() => this.onCdkDragReleased()));\n        this._subscriptions.add(this._dragRef.started.subscribe(() => this.onCdkDragStart()));\n    }\n\n    /** IE11 equivalent of Node.after() Method */\n    private _placeAfter(element: Element, cloneNode: Node): void {\n        const docFrag = document.createDocumentFragment();\n        docFrag.appendChild(cloneNode);\n        element.parentNode?.insertBefore(docFrag, element.nextSibling);\n    }\n\n    /** @hidden */\n    private _listenElementEvents(): void {\n        this._subscriptions.add(\n            this.released\n                .pipe(\n                    // postpone blur\n                    delay(0)\n                )\n                .subscribe(() => {\n                    if (this.containerSelector) {\n                        this.elementRef.nativeElement.children[0].blur();\n                    }\n                    this.elementRef.nativeElement.blur();\n                })\n        );\n    }\n}\n"]}

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

@@ -0,0 +1,88 @@
+import { moveItemInArray, transferArrayItem } from '@angular/cdk/drag-drop';
+import { DOWN_ARROW, LEFT_ARROW, RIGHT_ARROW, UP_ARROW } from '@angular/cdk/keycodes';
+import { ChangeDetectorRef, Directive, Input, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import { KeyUtil } from '../../functions';
+import { RtlService } from '../../services/rtl.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/rtl.service";
+/**
+ * This directive is used to provide drag & drop with keyboard support.
+ * It should be used together with directive fdDndKeyboardItem.
+ */
+export class DndKeyboardGroupDirective {
+    /** @hidden */
+    constructor(_cdr, _rtlService) {
+        this._cdr = _cdr;
+        this._rtlService = _rtlService;
+        /** Whether to disable drag & drop */
+        this.disableKeyboardDragDrop = false;
+        /** Used to apply indexes when moving between groups */
+        this.orientation = 'vertical';
+        /** @hidden */
+        this._onDndItemFocus$ = new Subject();
+        /** Custom function to call when moving item inside the group */
+        this.customMoveFn = (group, fromIndex, toIndex) => moveItemInArray(group, fromIndex, toIndex);
+        /** Custom function to call when moving item between groups */
+        this.customTransferFn = (group, nextGroup, fromIndex, toIndex) => transferArrayItem(group, nextGroup, fromIndex, toIndex);
+    }
+    /** Process drag & drop */
+    processDragDrop(event, itemIndex, groupIndex) {
+        if (this.disableKeyboardDragDrop || !event.altKey) {
+            return;
+        }
+        const isRtl = this._rtlService.rtl.value;
+        const group = this.groups[groupIndex];
+        const indexInNextGroup = this.orientation === 'vertical' ? 0 : itemIndex;
+        const nextGroupExists = this.groups.length > groupIndex + 1;
+        const prevGroupExists = !!groupIndex;
+        if (KeyUtil.isKeyCode(event, RIGHT_ARROW) && (isRtl ? prevGroupExists : nextGroupExists)) {
+            event.preventDefault();
+            const nextGroupIndex = groupIndex + (isRtl ? -1 : 1);
+            const nextGroup = this.groups[nextGroupIndex];
+            this.customTransferFn(group, nextGroup, itemIndex, indexInNextGroup);
+            this._focusDndItem(nextGroupIndex, indexInNextGroup);
+        }
+        else if (KeyUtil.isKeyCode(event, LEFT_ARROW) && (isRtl ? nextGroupExists : prevGroupExists)) {
+            event.preventDefault();
+            const nextGroupIndex = groupIndex + (isRtl ? 1 : -1);
+            const nextGroup = this.groups[nextGroupIndex];
+            this.customTransferFn(group, nextGroup, itemIndex, indexInNextGroup);
+            this._focusDndItem(nextGroupIndex, indexInNextGroup);
+        }
+        else if (KeyUtil.isKeyCode(event, DOWN_ARROW)) {
+            event.preventDefault();
+            this.customMoveFn(group, itemIndex, itemIndex + 1);
+            this._focusDndItem(groupIndex, itemIndex + 1);
+        }
+        else if (KeyUtil.isKeyCode(event, UP_ARROW)) {
+            event.preventDefault();
+            this.customMoveFn(group, itemIndex, itemIndex - 1);
+            this._focusDndItem(groupIndex, itemIndex - 1);
+        }
+    }
+    /** @hidden Focus after moving elements with keyboard */
+    _focusDndItem(groupIndex, itemIndex) {
+        this._cdr.detectChanges();
+        this._onDndItemFocus$.next([groupIndex, itemIndex]);
+    }
+}
+DndKeyboardGroupDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DndKeyboardGroupDirective, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.RtlService, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+DndKeyboardGroupDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DndKeyboardGroupDirective, selector: "[fdkDndKeyboardGroup], [fdDndKeyboardGroup]", inputs: { groups: "groups", disableKeyboardDragDrop: "disableKeyboardDragDrop", orientation: "orientation", customMoveFn: "customMoveFn", customTransferFn: "customTransferFn" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DndKeyboardGroupDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[fdkDndKeyboardGroup], [fdDndKeyboardGroup]' }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.RtlService, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { groups: [{
+                type: Input
+            }], disableKeyboardDragDrop: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], customMoveFn: [{
+                type: Input
+            }], customTransferFn: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dnd-keyboard-group.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/drag-and-drop/dnd-keyboard-group/dnd-keyboard-group.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { moveItemInArray, transferArrayItem } from '@angular/cdk/drag-drop';\nimport { DOWN_ARROW, LEFT_ARROW, RIGHT_ARROW, UP_ARROW } from '@angular/cdk/keycodes';\nimport { ChangeDetectorRef, Directive, Input, Optional } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { KeyUtil } from '../../functions';\nimport { RtlService } from '../../services/rtl.service';\n\n/**\n * This directive is used to provide drag & drop with keyboard support.\n * It should be used together with directive fdDndKeyboardItem.\n */\n@Directive({ selector: '[fdkDndKeyboardGroup], [fdDndKeyboardGroup]' })\nexport class DndKeyboardGroupDirective {\n    /** Group of items */\n    @Input()\n    groups: any[][];\n\n    /** Whether to disable drag & drop */\n    @Input()\n    disableKeyboardDragDrop = false;\n\n    /** Used to apply indexes when moving between groups */\n    @Input()\n    orientation: 'horizontal' | 'vertical' = 'vertical';\n\n    /** @hidden */\n    _onDndItemFocus$ = new Subject<[number, number]>();\n\n    /** Custom function to call when moving item inside the group */\n    @Input()\n    customMoveFn = (group: any[], fromIndex: number, toIndex: number): void =>\n        moveItemInArray(group, fromIndex, toIndex);\n\n    /** Custom function to call when moving item between groups */\n    @Input()\n    customTransferFn = (group: any[], nextGroup: any[], fromIndex: number, toIndex: number): void =>\n        transferArrayItem(group, nextGroup, fromIndex, toIndex);\n\n    /** @hidden */\n    constructor(private readonly _cdr: ChangeDetectorRef, @Optional() private readonly _rtlService: RtlService) {}\n\n    /** Process drag & drop */\n    processDragDrop(event: KeyboardEvent, itemIndex: number, groupIndex: number): void {\n        if (this.disableKeyboardDragDrop || !event.altKey) {\n            return;\n        }\n\n        const isRtl = this._rtlService.rtl.value;\n\n        const group = this.groups[groupIndex];\n        const indexInNextGroup = this.orientation === 'vertical' ? 0 : itemIndex;\n\n        const nextGroupExists = this.groups.length > groupIndex + 1;\n        const prevGroupExists = !!groupIndex;\n\n        if (KeyUtil.isKeyCode(event, RIGHT_ARROW) && (isRtl ? prevGroupExists : nextGroupExists)) {\n            event.preventDefault();\n\n            const nextGroupIndex = groupIndex + (isRtl ? -1 : 1);\n            const nextGroup = this.groups[nextGroupIndex];\n\n            this.customTransferFn(group, nextGroup, itemIndex, indexInNextGroup);\n            this._focusDndItem(nextGroupIndex, indexInNextGroup);\n        } else if (KeyUtil.isKeyCode(event, LEFT_ARROW) && (isRtl ? nextGroupExists : prevGroupExists)) {\n            event.preventDefault();\n\n            const nextGroupIndex = groupIndex + (isRtl ? 1 : -1);\n            const nextGroup = this.groups[nextGroupIndex];\n\n            this.customTransferFn(group, nextGroup, itemIndex, indexInNextGroup);\n            this._focusDndItem(nextGroupIndex, indexInNextGroup);\n        } else if (KeyUtil.isKeyCode(event, DOWN_ARROW)) {\n            event.preventDefault();\n\n            this.customMoveFn(group, itemIndex, itemIndex + 1);\n            this._focusDndItem(groupIndex, itemIndex + 1);\n        } else if (KeyUtil.isKeyCode(event, UP_ARROW)) {\n            event.preventDefault();\n\n            this.customMoveFn(group, itemIndex, itemIndex - 1);\n            this._focusDndItem(groupIndex, itemIndex - 1);\n        }\n    }\n\n    /** @hidden Focus after moving elements with keyboard */\n    private _focusDndItem(groupIndex: number, itemIndex: number): void {\n        this._cdr.detectChanges();\n\n        this._onDndItemFocus$.next([groupIndex, itemIndex]);\n    }\n}\n"]}

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

@@ -0,0 +1,83 @@
+import { Directive, ElementRef, HostListener, Input } from '@angular/core';
+import { Subject } from 'rxjs';
+import { DndKeyboardGroupDirective } from '../dnd-keyboard-group/dnd-keyboard-group.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../dnd-keyboard-group/dnd-keyboard-group.directive";
+/**
+ * This directive is used to provide drag & drop with keyboard support.
+ * It should be used together with directive fdDndKeyboardGroup.
+ * We are using _groups from fdDndKeyboardGroup and adding a possibility to move cards.
+ * Please see example below:
+ * @Component({
+ * selector: 'cdk-drag-drop-example',
+ * template: `<div
+ *               cdkDragListGroup
+ *               fdDndKeyboardGroup
+ *               [groups]="groups"
+ *           >
+ *               <div
+ *                   *ngFor="let group of groups; let groupIndex = index"
+ *                   cdkDragList
+ *               >
+ *                   Group #{{ groupIndex }}
+ *                   <div
+ *                       *ngFor="let item of group; let index = index"
+ *                       cdkDrag
+ *                       fdDndKeyboardItem
+ *                       [itemIndex]="index"
+ *                       [groupIndex]="groupIndex"
+ *                       [dndKeyboardDisabled]="flag for disable/enable keyboard navigation if needed"
+ *                       tabindex="0"
+ *                   >
+ *                       Item #{{ item }}
+ *                   </div>
+ *               </div>
+ *           </div>`,
+ * })
+ * export class CdkDragDropExample {
+ *   groups = [
+ *        [1, 2, 3],
+ *        [4, 5, 6],
+ *      ];
+ *   }
+ */
+export class DndKeyboardItemDirective {
+    /** @hidden */
+    constructor(_dndGroup, _elementRef) {
+        this._dndGroup = _dndGroup;
+        this._elementRef = _elementRef;
+        /** @hidden */
+        this._onDestroy$ = new Subject();
+    }
+    /** @hidden */
+    ngOnInit() {
+        this._dndGroup._onDndItemFocus$.subscribe(([groupIndex, itemIndex]) => {
+            if (this.groupIndex === groupIndex && this.itemIndex === itemIndex) {
+                this._elementRef.nativeElement.focus();
+            }
+        });
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._onDestroy$.next();
+        this._onDestroy$.complete();
+    }
+    /** @hidden */
+    _onKeyDown(event) {
+        this._dndGroup.processDragDrop(event, this.itemIndex, this.groupIndex);
+    }
+}
+DndKeyboardItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DndKeyboardItemDirective, deps: [{ token: i1.DndKeyboardGroupDirective }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+DndKeyboardItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DndKeyboardItemDirective, selector: "[fdkDndKeyboardItem], [fdDndKeyboardItem]", inputs: { itemIndex: "itemIndex", groupIndex: "groupIndex" }, host: { listeners: { "keydown": "_onKeyDown($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DndKeyboardItemDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[fdkDndKeyboardItem], [fdDndKeyboardItem]' }]
+        }], ctorParameters: function () { return [{ type: i1.DndKeyboardGroupDirective }, { type: i0.ElementRef }]; }, propDecorators: { itemIndex: [{
+                type: Input
+            }], groupIndex: [{
+                type: Input
+            }], _onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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