@ascentgl/ads-ui 0.0.1

package/esm2022/lib/components/divider/divider.component.mjs

@@ -0,0 +1,43 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DividerComponent {
+    constructor() {
+        /**
+         * The divider left and right margin
+         */
+        this.margin = 0;
+        /**
+         * The divider color
+         */
+        this.color = 'light';
+        /** @ignore */
+        this.colors = {
+            primary: '--color-primary',
+            secondary: '--color-secondary',
+            light: '--color-light',
+        };
+    }
+    /** @ignore */
+    ngOnChanges() {
+        this.setDividerStyle();
+    }
+    /** @ignore */
+    setDividerStyle() {
+        this.style = {
+            margin: `0 ${this.margin}px`,
+            'background-color': `var(${this.colors[this.color] || this.colors['light']})`,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DividerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: DividerComponent, selector: "ads-divider", inputs: { margin: "margin", color: "color" }, usesOnChanges: true, ngImport: i0, template: "<div [ngStyle]=\"style\" class=\"ads-divider\"></div>\n", styles: [".ads-divider{height:1px}\n"], dependencies: [{ kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DividerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ads-divider', template: "<div [ngStyle]=\"style\" class=\"ads-divider\"></div>\n", styles: [".ads-divider{height:1px}\n"] }]
+        }], propDecorators: { margin: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/divider/divider.module.mjs

@@ -0,0 +1,18 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { DividerComponent } from './divider.component';
+import * as i0 from "@angular/core";
+export class AdsDividerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDividerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: AdsDividerModule, declarations: [DividerComponent], imports: [CommonModule], exports: [DividerComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDividerModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDividerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    exports: [DividerComponent],
+                    declarations: [DividerComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGl2aWRlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Fkcy11aS9zcmMvbGliL2NvbXBvbmVudHMvZGl2aWRlci9kaXZpZGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7QUFPdkQsTUFBTSxPQUFPLGdCQUFnQjs4R0FBaEIsZ0JBQWdCOytHQUFoQixnQkFBZ0IsaUJBRlosZ0JBQWdCLGFBRnJCLFlBQVksYUFDWixnQkFBZ0I7K0dBR2YsZ0JBQWdCLFlBSmpCLFlBQVk7OzJGQUlYLGdCQUFnQjtrQkFMNUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLE9BQU8sRUFBRSxDQUFDLGdCQUFnQixDQUFDO29CQUMzQixZQUFZLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztpQkFDakMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgRGl2aWRlckNvbXBvbmVudCB9IGZyb20gJy4vZGl2aWRlci5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgZXhwb3J0czogW0RpdmlkZXJDb21wb25lbnRdLFxuICBkZWNsYXJhdGlvbnM6IFtEaXZpZGVyQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgQWRzRGl2aWRlck1vZHVsZSB7fVxuIl19

package/esm2022/lib/components/divider/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Fkcy11aS9zcmMvbGliL2NvbXBvbmVudHMvZGl2aWRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/lib/components/divider/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './divider.component';
+export * from './divider.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYWRzLXVpL3NyYy9saWIvY29tcG9uZW50cy9kaXZpZGVyL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaXZpZGVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2RpdmlkZXIubW9kdWxlJztcbiJdfQ==

package/esm2022/lib/components/drag-and-drop-list/dom.element.mjs

@@ -0,0 +1,62 @@
+export class DomElement {
+    constructor(domElement) {
+        this.domElement = domElement;
+    }
+    get dom() {
+        return this.domElement;
+    }
+    canDrop() {
+        return !this.dom.classList.contains("no-drop" /* dragAndDropListClass.NO_DROP */);
+    }
+    canDrag() {
+        return !this.dom.classList.contains("no-drag" /* dragAndDropListClass.NO_DRAG */);
+    }
+    isDropBlocked() {
+        return this.dom.classList.contains("drop-blocked" /* dragAndDropListClass.DROP_BLOCKED */);
+    }
+    makeDraggable() {
+        this.dom.setAttribute('draggable', 'true');
+    }
+    makeUnDraggable() {
+        this.dom.removeAttribute('draggable');
+    }
+    unblockDrop() {
+        this.dom.classList.remove("drop-blocked" /* dragAndDropListClass.DROP_BLOCKED */);
+    }
+    clone() {
+        const clone = this.dom.cloneNode(true);
+        clone.classList.add("dragged-placeholder" /* dragAndDropListClass.DRAGGED_PLACEHOLDER */);
+        const targetRect = this.dom.getBoundingClientRect();
+        /**
+         * preserve target dimensions
+         */
+        clone.style.width = targetRect.width + 'px';
+        clone.style.height = targetRect.height + 'px';
+        /**
+         * modify clone styles
+         */
+        Object.assign(clone.style, {
+            position: 'fixed', //required to allow free dragging of the clone
+            pointerEvents: 'none', // required to allow drag events for items under the clone
+            zIndex: '1000', // required to make sure that draggable element is positioned over other elements
+        });
+        return clone;
+    }
+    blockDrop() {
+        this.dom.classList.add("drop-blocked" /* dragAndDropListClass.DROP_BLOCKED */);
+    }
+    draggedOver() {
+        this.dom.classList.add("dragged-over" /* dragAndDropListClass.DRAGGED_OVER */);
+    }
+    draggedOut() {
+        this.dom.classList.remove("dragged-over" /* dragAndDropListClass.DRAGGED_OVER */);
+        this.unblockDrop();
+    }
+    isDragged() {
+        this.dom.classList.add("is-dragged" /* dragAndDropListClass.IS_DRAGGED */);
+    }
+    isNotDragged() {
+        this.dom.classList.remove("is-dragged" /* dragAndDropListClass.IS_DRAGGED */);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/drag-and-drop-list/drag-and-drop-list.component.mjs

@@ -0,0 +1,349 @@
+import { Component, ElementRef, Input, Renderer2, ViewChild } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { DomElement } from './dom.element';
+import { DraggedPlaceholder } from './dragged.placeholder';
+import * as i0 from "@angular/core";
+export class AdsDragAndDropListComponent {
+    /** @ignore */
+    constructor(renderer) {
+        this.renderer = renderer;
+        /** If total items count is less than this value, drag&drop will be disabled */
+        this.minCountToDrag = 2;
+        /** Provide subject element, which will allow to refresh the list. NOTE: refreshing is required every time the list is updated from the outside  */
+        this.refresh = new Subject();
+        /** @ignore */
+        this.draggedElement = null;
+        /** @ignore */
+        this.draggedPlaceholder = null;
+        /** @ignore */
+        this.unsubscribeFunctions = new Map();
+        /** @ignore */
+        this.ngUnsubscribe = new Subject();
+        this.draggedOverElement = null;
+        /** @ignore */
+        this.onDragStart = (event) => {
+            /**
+             * NOTE: register dragover for document body to overcome Firefox issue where clientX and clientY are 0 in 'drag' event
+             */
+            this.unsubscribeFromDocumentDragOver = this.renderer.listen(document.body, 'dragover', this.onDragOverBody);
+            /**
+             * store currently dragged element
+             */
+            this.draggedElement = this.getElement(event);
+            /**
+             * replace default browser dragged element with the custom one
+             */
+            this.draggedPlaceholder = new DraggedPlaceholder(this.draggedElement, this.draggableList?.nativeElement, event, this.renderer);
+            /**
+             * mark dragged element with special class
+             */
+            this.draggedElement.isDragged();
+            /**
+             * block drop into the dragged element
+             */
+            this.draggedElement.blockDrop();
+        };
+        /** @ignore */
+        this.onDragEnd = () => {
+            /**
+             * remove special class from dragged element mark dragged element
+             */
+            this.draggedElement?.isNotDragged();
+            this.draggedElement = null;
+            /**
+             * if we subscribed to document dragover - unsubscribe from it
+             */
+            if (this.unsubscribeFromDocumentDragOver) {
+                this.unsubscribeFromDocumentDragOver();
+            }
+            /**
+             * remove dragged placeholder from DOM
+             */
+            this.draggedPlaceholder?.remove();
+            this.draggedPlaceholder = null;
+        };
+        /** @ignore
+         * NOTE: we rely on  onDragOver instead of DragEnter and DragLeave because those events also fire when we enter and leave
+         * child elements - the behavior we don't need
+         */
+        this.onDragOver = (event) => {
+            /**
+             * NOTE: this is required for "drop" event to work
+             */
+            event.preventDefault();
+            /**
+             * do nothing if we have no dragged element, or we are still over the same element
+             */
+            if (!this.draggedElement || this.draggedOverElement?.dom === event.currentTarget) {
+                return;
+            }
+            /**
+             * make sure previous dragged over element is marked as "dragged out"
+             */
+            this.unselectDraggedOverElement();
+            this.draggedOverElement = this.getElement(event);
+            /**
+             * do nothing if dragged element and element, we are dragging over is the same
+             */
+            if (this.isDraggingOverSelf(this.draggedOverElement)) {
+                return;
+            }
+            this.draggedOverElement.draggedOver();
+            /**
+             * if drop is blocked - add special class to the dragged element
+             */
+            if (this.canDrop()) {
+                this.draggedOverElement.unblockDrop();
+            }
+            else {
+                this.draggedOverElement.blockDrop();
+            }
+        };
+        /** @ignore */
+        this.onDrop = (event) => {
+            /**
+             * if drop is blocked - do nothing
+             */
+            if (!this.canDrop())
+                return;
+            this.unselectDraggedOverElement();
+            const target = this.getElement(event);
+            /**
+             * preserve drop blocked state before cleaning classes - it will be needed later
+             */
+            const isTargetBlocked = target.isDropBlocked();
+            this.getElement(event).draggedOut();
+            /**
+             * if we have no dragged element, we are dropping on self or target is blocked - do nothing
+             */
+            if (!this.draggedElement || this.isDraggingOverSelf(target) || isTargetBlocked) {
+                return;
+            }
+            const sourceIndex = this.getElementIndex(this.draggedElement);
+            const targetIndex = this.getElementIndex(target);
+            /**
+             * if source index is less than target index - means we are dragging down;
+             * otherwise we are dragging up
+             * NOTE: we utilise "before" method for element insertion in both cases, because "after" can
+             * break order of "drag-static" elements (if they are present)
+             */
+            if (sourceIndex < targetIndex) {
+                const allElements = this.getAllElements();
+                /**
+                 * loop through all element beginning with next to the currently dragged element
+                 * and ending with drop target element and move all of them up;
+                 * this will result in target element being moved down to required position
+                 */
+                for (let i = sourceIndex + 1; i <= targetIndex; i++) {
+                    const target = allElements[i];
+                    if (target) {
+                        this.draggedElement.dom.before(target);
+                    }
+                }
+            }
+            else {
+                target.dom.before(this.draggedElement.dom);
+            }
+            /**
+             * if possible emit indexes old and new indexes of the repositioned items
+             */
+            if (this.dropCallback) {
+                this.dropCallback({
+                    before: sourceIndex,
+                    after: this.getElementIndex(this.draggedElement),
+                }, {
+                    before: targetIndex,
+                    after: this.getElementIndex(target),
+                });
+            }
+        };
+        /** @ignore */
+        this.onMouseEnter = (event) => {
+            this.setCanDrag(this.getElement(event));
+        };
+        /** @ignore */
+        this.onDragOverBody = (event) => {
+            this.draggedPlaceholder?.reposition(event);
+        };
+    }
+    /** @ignore */
+    ngOnInit() {
+        /**
+         * if refresh command was emitted - refresh elements
+         * NOTE: we do it in timeout to allow DOM to redraw first
+         */
+        this.refresh.pipe(takeUntil(this.ngUnsubscribe)).subscribe(() => {
+            setTimeout(() => this.refreshElements());
+        });
+    }
+    /** @ignore */
+    ngAfterContentInit() {
+        this.refreshElements();
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this.unsubscribeFromEventListeners();
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    }
+    /** @ignore */
+    onListDragLeave(event) {
+        /**
+         * if we dragged out of the element - unselect it
+         */
+        if (event.relatedTarget instanceof HTMLElement &&
+            this.draggedOverElement &&
+            !this.draggedOverElement.dom.contains(event.relatedTarget)) {
+            this.unselectDraggedOverElement();
+        }
+    }
+    /** @ignore */
+    unselectDraggedOverElement() {
+        /**
+         * make sure previous dragged over element is marked as "dragged out"
+         */
+        this.draggedOverElement?.draggedOut();
+        this.draggedOverElement = null;
+    }
+    /** @ignore */
+    setCanDrag(element) {
+        /**
+         * if special class is set for the element - forbid dragging
+         */
+        if (!element.canDrag()) {
+            element.makeUnDraggable();
+            return;
+        }
+        /**
+         * make sure dragging the item is not forbidden by external function
+         */
+        if (this.canDragCallback) {
+            if (this.canDragCallback(this.getElementIndex(element))) {
+                element.makeDraggable();
+            }
+            else {
+                element.makeUnDraggable();
+            }
+            return;
+        }
+        element.makeDraggable();
+    }
+    /** @ignore */
+    canDrop() {
+        if (!this.draggedElement || !this.draggedOverElement)
+            return false;
+        /**
+         * if special class is set for the element - forbid dropping;
+         * otherwise make sure dropping over the item is not forbidden by external function
+         */
+        if (!this.draggedOverElement.canDrop()) {
+            return false;
+        }
+        else if (this.canDropCallback) {
+            return this.canDropCallback(this.getElementIndex(this.draggedElement), this.getElementIndex(this.draggedOverElement));
+        }
+        return true;
+    }
+    /** @ignore */
+    refreshElements() {
+        /**
+         * unsubscribe from all event listeners
+         */
+        this.unsubscribeFromEventListeners();
+        /**
+         * make sure no placeholder are still visible
+         */
+        document.querySelectorAll('.' + "dragged-placeholder" /* dragAndDropListClass.DRAGGED_PLACEHOLDER */).forEach((element) => {
+            element.remove();
+        });
+        /**
+         * get all elements that can participate in drag and drop
+         */
+        const elements = this.getAllElements();
+        /**
+         * make sure we have enough elements to continue
+         */
+        if (elements.length < this.minCountToDrag) {
+            return;
+        }
+        /**
+         * add required callbacks to all elements,
+         * preserving their unsubscribe functions
+         */
+        elements.forEach((element) => {
+            const functions = {};
+            functions['dragstart'] = this.renderer.listen(element, 'dragstart', this.onDragStart);
+            functions['dragend'] = this.renderer.listen(element, 'dragend', this.onDragEnd);
+            functions['dragover'] = this.renderer.listen(element, 'dragover', this.onDragOver);
+            functions['drop'] = this.renderer.listen(element, 'drop', this.onDrop);
+            functions['mouseenter'] = this.renderer.listen(element, 'mouseenter', this.onMouseEnter);
+            this.unsubscribeFunctions.set(element, functions);
+        });
+    }
+    /** @ignore */
+    unsubscribeFromEventListeners() {
+        this.unsubscribeFunctions.forEach((collection) => {
+            Object.values(collection).forEach((func) => func());
+        });
+        this.unsubscribeFunctions = new Map();
+    }
+    /** @ignore */
+    getAllElements() {
+        const result = [];
+        if (this.draggableList) {
+            /**
+             * loop through immediate children of the list
+             */
+            Array.from(this.draggableList.nativeElement.children).forEach((element) => {
+                /**
+                 * element is static if it has both "no-drop" and "no-drag" classes
+                 */
+                const isStatic = element.classList.contains("no-drop" /* dragAndDropListClass.NO_DROP */) &&
+                    element.classList.contains("no-drag" /* dragAndDropListClass.NO_DRAG */);
+                /**
+                 * ignore static elements and dragged placeholder element from the list
+                 */
+                if (!isStatic && !element.classList.contains("dragged-placeholder" /* dragAndDropListClass.DRAGGED_PLACEHOLDER */)) {
+                    result.push(element);
+                }
+            });
+        }
+        return result;
+    }
+    /** @ignore */
+    getElement(event) {
+        return new DomElement(event.currentTarget);
+    }
+    /** @ignore */
+    getElementIndex(element) {
+        return this.getAllElements().indexOf(element.dom);
+    }
+    /** @ignore */
+    isDraggingOverSelf(element) {
+        return this.draggedElement?.dom === element?.dom;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDragAndDropListComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: AdsDragAndDropListComponent, selector: "ads-drag-and-drop-list", inputs: { dropCallback: "dropCallback", canDropCallback: "canDropCallback", canDragCallback: "canDragCallback", minCountToDrag: "minCountToDrag", refresh: "refresh" }, viewQueries: [{ propertyName: "draggableList", first: true, predicate: ["draggableList"], descendants: true, read: ElementRef, static: true }, { propertyName: "dynamicContent", first: true, predicate: ["dynamicContent"], descendants: true, read: ElementRef, static: true }], ngImport: i0, template: "<div class=\"draggable-list\" #draggableList (dragleave)=\"onListDragLeave($event)\">\n  <ng-content></ng-content>\n</div>\n", styles: [":host{display:block}:host ::ng-deep .draggable-list>*{box-sizing:border-box;background-color:var(--color-white)}:host ::ng-deep .draggable-list>*[draggable=true]{cursor:move}:host ::ng-deep .draggable-list>*.is-dragged{opacity:.25}:host ::ng-deep .draggable-list>*:not(.drag-placeholder){width:100%}:host ::ng-deep .draggable-list>*.dragged-over:not(.drop-blocked){background-color:var(--color-light-30)}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDragAndDropListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ads-drag-and-drop-list', template: "<div class=\"draggable-list\" #draggableList (dragleave)=\"onListDragLeave($event)\">\n  <ng-content></ng-content>\n</div>\n", styles: [":host{display:block}:host ::ng-deep .draggable-list>*{box-sizing:border-box;background-color:var(--color-white)}:host ::ng-deep .draggable-list>*[draggable=true]{cursor:move}:host ::ng-deep .draggable-list>*.is-dragged{opacity:.25}:host ::ng-deep .draggable-list>*:not(.drag-placeholder){width:100%}:host ::ng-deep .draggable-list>*.dragged-over:not(.drop-blocked){background-color:var(--color-light-30)}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }], propDecorators: { draggableList: [{
+                type: ViewChild,
+                args: ['draggableList', { read: ElementRef, static: true }]
+            }], dynamicContent: [{
+                type: ViewChild,
+                args: ['dynamicContent', { read: ElementRef, static: true }]
+            }], dropCallback: [{
+                type: Input
+            }], canDropCallback: [{
+                type: Input
+            }], canDragCallback: [{
+                type: Input
+            }], minCountToDrag: [{
+                type: Input
+            }], refresh: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-and-drop-list.component.js","sourceRoot":"","sources":["../../../../../../../libs/ads-ui/src/lib/components/drag-and-drop-list/drag-and-drop-list.component.ts","../../../../../../../libs/ads-ui/src/lib/components/drag-and-drop-list/drag-and-drop-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, Component, ElementRef, Input, OnDestroy, OnInit, Renderer2, ViewChild } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { DomElement } from './dom.element';\nimport { DraggedPlaceholder } from './dragged.placeholder';\nimport { dragAndDropListClass } from './drag-and-drop-list.enums';\nimport { GENERIC_COLLECTION } from '@ascentgl/ads-utils';\n\nexport type DROP_CALLBACK_INDEXES = { before: number; after: number };\nexport type UNSUBSCRIBE_FUNCTIONS_COLLECTION = GENERIC_COLLECTION<() => void>;\n\n@Component({\n  selector: 'ads-drag-and-drop-list',\n  styleUrls: ['drag-and-drop-list.component.scss'],\n  templateUrl: 'drag-and-drop-list.component.html',\n})\nexport class AdsDragAndDropListComponent implements OnInit, AfterContentInit, OnDestroy {\n  /** @ignore */\n  @ViewChild('draggableList', { read: ElementRef, static: true }) draggableList?: ElementRef;\n  /** @ignore */\n  @ViewChild('dynamicContent', { read: ElementRef, static: true }) dynamicContent?: ElementRef;\n\n  /** This external method will be called after the item is dropped into new position */\n  @Input() dropCallback?: (sourceIndexes: DROP_CALLBACK_INDEXES, targetIndexes: DROP_CALLBACK_INDEXES) => void;\n\n  /** Callback function that can be used to determine if item can be dropped on the selected target */\n  @Input() canDropCallback?: (sourceIndex: number, targetIndex: number) => boolean;\n\n  /** Callback function that can be used to determine if item can be dragged */\n  @Input() canDragCallback?: (sourceIndex: number) => boolean;\n\n  /** If total items count is less than this value, drag&drop will be disabled */\n  @Input() minCountToDrag = 2;\n\n  /** Provide subject element, which will allow to refresh the list. NOTE: refreshing is required every time the list is updated from the outside  */\n  @Input() refresh: Subject<void> = new Subject<void>();\n\n  /** @ignore */\n  private draggedElement: DomElement | null = null;\n  /** @ignore */\n  private draggedPlaceholder: DraggedPlaceholder | null = null;\n  /** @ignore */\n  private unsubscribeFromDocumentDragOver?: () => void;\n  /** @ignore */\n  private unsubscribeFunctions: Map<HTMLElement, UNSUBSCRIBE_FUNCTIONS_COLLECTION> = new Map();\n  /** @ignore */\n  private ngUnsubscribe: Subject<void> = new Subject();\n\n  private draggedOverElement: DomElement | null = null;\n\n  /** @ignore */\n  constructor(private renderer: Renderer2) {}\n\n  /** @ignore */\n  ngOnInit(): void {\n    /**\n     * if refresh command was emitted - refresh elements\n     * NOTE: we do it in timeout to allow DOM to redraw first\n     */\n    this.refresh.pipe(takeUntil(this.ngUnsubscribe)).subscribe((): void => {\n      setTimeout(() => this.refreshElements());\n    });\n  }\n\n  /** @ignore */\n  ngAfterContentInit(): void {\n    this.refreshElements();\n  }\n\n  /** @ignore */\n  ngOnDestroy(): void {\n    this.unsubscribeFromEventListeners();\n    this.ngUnsubscribe.next();\n    this.ngUnsubscribe.complete();\n  }\n\n  /** @ignore */\n  onListDragLeave(event: DragEvent): void {\n    /**\n     * if we dragged out of the element - unselect it\n     */\n    if (\n      event.relatedTarget instanceof HTMLElement &&\n      this.draggedOverElement &&\n      !this.draggedOverElement.dom.contains(event.relatedTarget)\n    ) {\n      this.unselectDraggedOverElement();\n    }\n  }\n\n  /** @ignore */\n  onDragStart = (event: DragEvent): void => {\n    /**\n     * NOTE: register dragover for document body to overcome Firefox issue where clientX and clientY are 0 in 'drag' event\n     */\n    this.unsubscribeFromDocumentDragOver = this.renderer.listen(document.body, 'dragover', this.onDragOverBody);\n\n    /**\n     * store currently dragged element\n     */\n    this.draggedElement = this.getElement(event);\n\n    /**\n     * replace default browser dragged element with the custom one\n     */\n    this.draggedPlaceholder = new DraggedPlaceholder(\n      this.draggedElement,\n      this.draggableList?.nativeElement,\n      event,\n      this.renderer,\n    );\n\n    /**\n     * mark dragged element with special class\n     */\n    this.draggedElement.isDragged();\n\n    /**\n     * block drop into the dragged element\n     */\n    this.draggedElement.blockDrop();\n  };\n\n  /** @ignore */\n  onDragEnd = (): void => {\n    /**\n     * remove special class from dragged element mark dragged element\n     */\n    this.draggedElement?.isNotDragged();\n\n    this.draggedElement = null;\n\n    /**\n     * if we subscribed to document dragover - unsubscribe from it\n     */\n    if (this.unsubscribeFromDocumentDragOver) {\n      this.unsubscribeFromDocumentDragOver();\n    }\n\n    /**\n     * remove dragged placeholder from DOM\n     */\n    this.draggedPlaceholder?.remove();\n    this.draggedPlaceholder = null;\n  };\n\n  /** @ignore\n   * NOTE: we rely on  onDragOver instead of DragEnter and DragLeave because those events also fire when we enter and leave\n   * child elements - the behavior we don't need\n   */\n  onDragOver = (event: DragEvent): void => {\n    /**\n     * NOTE: this is required for \"drop\" event to work\n     */\n    event.preventDefault();\n\n    /**\n     * do nothing if we have no dragged element, or we are still over the same element\n     */\n    if (!this.draggedElement || this.draggedOverElement?.dom === event.currentTarget) {\n      return;\n    }\n\n    /**\n     * make sure previous dragged over element is marked as \"dragged out\"\n     */\n    this.unselectDraggedOverElement();\n\n    this.draggedOverElement = this.getElement(event);\n\n    /**\n     * do nothing if dragged element and element, we are dragging over is the same\n     */\n    if (this.isDraggingOverSelf(this.draggedOverElement)) {\n      return;\n    }\n\n    this.draggedOverElement.draggedOver();\n\n    /**\n     * if drop is blocked - add special class to the dragged element\n     */\n    if (this.canDrop()) {\n      this.draggedOverElement.unblockDrop();\n    } else {\n      this.draggedOverElement.blockDrop();\n    }\n  };\n\n  /** @ignore */\n  onDrop = (event: DragEvent): void => {\n    /**\n     * if drop is blocked - do nothing\n     */\n    if (!this.canDrop()) return;\n\n    this.unselectDraggedOverElement();\n\n    const target: DomElement = this.getElement(event);\n\n    /**\n     * preserve drop blocked state before cleaning classes - it will be needed later\n     */\n    const isTargetBlocked: boolean = target.isDropBlocked();\n\n    this.getElement(event).draggedOut();\n\n    /**\n     * if we have no dragged element, we are dropping on self or target is blocked - do nothing\n     */\n    if (!this.draggedElement || this.isDraggingOverSelf(target) || isTargetBlocked) {\n      return;\n    }\n\n    const sourceIndex: number = this.getElementIndex(this.draggedElement);\n    const targetIndex: number = this.getElementIndex(target);\n\n    /**\n     * if source index is less than target index - means we are dragging down;\n     * otherwise we are dragging up\n     * NOTE: we utilise \"before\" method for element insertion in both cases, because \"after\" can\n     * break order of \"drag-static\" elements (if they are present)\n     */\n    if (sourceIndex < targetIndex) {\n      const allElements: HTMLElement[] = this.getAllElements();\n\n      /**\n       * loop through all element beginning with next to the currently dragged element\n       * and ending with drop target element and move all of them up;\n       * this will result in target element being moved down to required position\n       */\n      for (let i: number = sourceIndex + 1; i <= targetIndex; i++) {\n        const target: HTMLElement = allElements[i];\n\n        if (target) {\n          this.draggedElement.dom.before(target);\n        }\n      }\n    } else {\n      target.dom.before(this.draggedElement.dom);\n    }\n\n    /**\n     * if possible emit indexes old and new indexes of the repositioned items\n     */\n    if (this.dropCallback) {\n      this.dropCallback(\n        {\n          before: sourceIndex,\n          after: this.getElementIndex(this.draggedElement),\n        },\n        {\n          before: targetIndex,\n          after: this.getElementIndex(target),\n        },\n      );\n    }\n  };\n\n  /** @ignore */\n  onMouseEnter = (event: MouseEvent): void => {\n    this.setCanDrag(this.getElement(event));\n  };\n\n  /** @ignore */\n  private unselectDraggedOverElement(): void {\n    /**\n     * make sure previous dragged over element is marked as \"dragged out\"\n     */\n    this.draggedOverElement?.draggedOut();\n    this.draggedOverElement = null;\n  }\n\n  /** @ignore */\n  private setCanDrag(element: DomElement): void {\n    /**\n     * if special class is set for the element - forbid dragging\n     */\n    if (!element.canDrag()) {\n      element.makeUnDraggable();\n      return;\n    }\n\n    /**\n     * make sure dragging the item is not forbidden by external function\n     */\n    if (this.canDragCallback) {\n      if (this.canDragCallback(this.getElementIndex(element))) {\n        element.makeDraggable();\n      } else {\n        element.makeUnDraggable();\n      }\n      return;\n    }\n    element.makeDraggable();\n  }\n\n  /** @ignore */\n  private onDragOverBody = (event: DragEvent): void => {\n    this.draggedPlaceholder?.reposition(event);\n  };\n\n  /** @ignore */\n  private canDrop(): boolean {\n    if (!this.draggedElement || !this.draggedOverElement) return false;\n\n    /**\n     * if special class is set for the element - forbid dropping;\n     * otherwise make sure dropping over the item is not forbidden by external function\n     */\n    if (!this.draggedOverElement.canDrop()) {\n      return false;\n    } else if (this.canDropCallback) {\n      return this.canDropCallback(\n        this.getElementIndex(this.draggedElement),\n        this.getElementIndex(this.draggedOverElement),\n      );\n    }\n\n    return true;\n  }\n\n  /** @ignore */\n  private refreshElements(): void {\n    /**\n     * unsubscribe from all event listeners\n     */\n    this.unsubscribeFromEventListeners();\n\n    /**\n     * make sure no placeholder are still visible\n     */\n    document.querySelectorAll('.' + dragAndDropListClass.DRAGGED_PLACEHOLDER).forEach((element) => {\n      element.remove();\n    });\n\n    /**\n     * get all elements that can participate in drag and drop\n     */\n    const elements: HTMLElement[] = this.getAllElements();\n\n    /**\n     * make sure we have enough elements to continue\n     */\n    if (elements.length < this.minCountToDrag) {\n      return;\n    }\n\n    /**\n     * add required callbacks to all elements,\n     * preserving their unsubscribe functions\n     */\n    elements.forEach((element: HTMLElement): void => {\n      const functions: UNSUBSCRIBE_FUNCTIONS_COLLECTION = {};\n\n      functions['dragstart'] = this.renderer.listen(element, 'dragstart', this.onDragStart);\n      functions['dragend'] = this.renderer.listen(element, 'dragend', this.onDragEnd);\n      functions['dragover'] = this.renderer.listen(element, 'dragover', this.onDragOver);\n      functions['drop'] = this.renderer.listen(element, 'drop', this.onDrop);\n      functions['mouseenter'] = this.renderer.listen(element, 'mouseenter', this.onMouseEnter);\n\n      this.unsubscribeFunctions.set(element, functions);\n    });\n  }\n\n  /** @ignore */\n  private unsubscribeFromEventListeners(): void {\n    this.unsubscribeFunctions.forEach((collection) => {\n      Object.values(collection).forEach((func) => func());\n    });\n\n    this.unsubscribeFunctions = new Map();\n  }\n\n  /** @ignore */\n  private getAllElements(): HTMLElement[] {\n    const result: HTMLElement[] = [];\n\n    if (this.draggableList) {\n      /**\n       * loop through immediate children of the list\n       */\n      (<HTMLElement[]>Array.from(this.draggableList.nativeElement.children)).forEach((element: HTMLElement): void => {\n        /**\n         * element is static if it has both \"no-drop\" and \"no-drag\" classes\n         */\n        const isStatic: boolean =\n          element.classList.contains(dragAndDropListClass.NO_DROP) &&\n          element.classList.contains(dragAndDropListClass.NO_DRAG);\n\n        /**\n         * ignore static elements and dragged placeholder element from the list\n         */\n        if (!isStatic && !element.classList.contains(dragAndDropListClass.DRAGGED_PLACEHOLDER)) {\n          result.push(element);\n        }\n      });\n    }\n\n    return result;\n  }\n\n  /** @ignore */\n  private getElement(event: DragEvent | MouseEvent): DomElement {\n    return new DomElement(<HTMLElement>event.currentTarget);\n  }\n\n  /** @ignore */\n  private getElementIndex(element: DomElement): number {\n    return this.getAllElements().indexOf(element.dom);\n  }\n\n  /** @ignore */\n  private isDraggingOverSelf(element: DomElement | null): boolean {\n    return this.draggedElement?.dom === element?.dom;\n  }\n}\n","<div class=\"draggable-list\" #draggableList (dragleave)=\"onListDragLeave($event)\">\n  <ng-content></ng-content>\n</div>\n"]}

package/esm2022/lib/components/drag-and-drop-list/drag-and-drop-list.enums.mjs

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

package/esm2022/lib/components/drag-and-drop-list/drag-and-drop-list.module.mjs

@@ -0,0 +1,18 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { AdsDragAndDropListComponent } from './drag-and-drop-list.component';
+import * as i0 from "@angular/core";
+export class AdsDragAndDropListModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDragAndDropListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: AdsDragAndDropListModule, declarations: [AdsDragAndDropListComponent], imports: [CommonModule], exports: [AdsDragAndDropListComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDragAndDropListModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDragAndDropListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    exports: [AdsDragAndDropListComponent],
+                    declarations: [AdsDragAndDropListComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1hbmQtZHJvcC1saXN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYWRzLXVpL3NyYy9saWIvY29tcG9uZW50cy9kcmFnLWFuZC1kcm9wLWxpc3QvZHJhZy1hbmQtZHJvcC1saXN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7QUFPN0UsTUFBTSxPQUFPLHdCQUF3Qjs4R0FBeEIsd0JBQXdCOytHQUF4Qix3QkFBd0IsaUJBRnBCLDJCQUEyQixhQUZoQyxZQUFZLGFBQ1osMkJBQTJCOytHQUcxQix3QkFBd0IsWUFKekIsWUFBWTs7MkZBSVgsd0JBQXdCO2tCQUxwQyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsMkJBQTJCLENBQUM7b0JBQ3RDLFlBQVksRUFBRSxDQUFDLDJCQUEyQixDQUFDO2lCQUM1QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQWRzRHJhZ0FuZERyb3BMaXN0Q29tcG9uZW50IH0gZnJvbSAnLi9kcmFnLWFuZC1kcm9wLWxpc3QuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGV4cG9ydHM6IFtBZHNEcmFnQW5kRHJvcExpc3RDb21wb25lbnRdLFxuICBkZWNsYXJhdGlvbnM6IFtBZHNEcmFnQW5kRHJvcExpc3RDb21wb25lbnRdLFxufSlcbmV4cG9ydCBjbGFzcyBBZHNEcmFnQW5kRHJvcExpc3RNb2R1bGUge31cbiJdfQ==