@ascentgl/ads-ui 0.0.1

package/esm2022/src/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/src/lib/components/drag-and-drop-list/drag-and-drop-list.enums.mjs

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

package/esm2022/src/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1hbmQtZHJvcC1saXN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYWRzLXVpL3NyYy9saWIvY29tcG9uZW50cy9kcmFnLWFuZC1kcm9wLWxpc3QvZHJhZy1hbmQtZHJvcC1saXN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7QUFPN0UsTUFBTSxPQUFPLHdCQUF3Qjs4R0FBeEIsd0JBQXdCOytHQUF4Qix3QkFBd0IsaUJBRnBCLDJCQUEyQixhQUZoQyxZQUFZLGFBQ1osMkJBQTJCOytHQUcxQix3QkFBd0IsWUFKekIsWUFBWTs7MkZBSVgsd0JBQXdCO2tCQUxwQyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsMkJBQTJCLENBQUM7b0JBQ3RDLFlBQVksRUFBRSxDQUFDLDJCQUEyQixDQUFDO2lCQUM1QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQWRzRHJhZ0FuZERyb3BMaXN0Q29tcG9uZW50IH0gZnJvbSAnLi9kcmFnLWFuZC1kcm9wLWxpc3QuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGV4cG9ydHM6IFtBZHNEcmFnQW5kRHJvcExpc3RDb21wb25lbnRdLFxuICBkZWNsYXJhdGlvbnM6IFtBZHNEcmFnQW5kRHJvcExpc3RDb21wb25lbnRdLFxufSlcbmV4cG9ydCBjbGFzcyBBZHNEcmFnQW5kRHJvcExpc3RNb2R1bGUge31cbiJdfQ==

package/esm2022/src/lib/components/drag-and-drop-list/dragged.placeholder.mjs

@@ -0,0 +1,63 @@
+export class DraggedPlaceholder {
+    constructor(element, container, event, renderer) {
+        this.renderer = renderer;
+        this.positions = { x: 0, y: 0 };
+        this.cursorPos = { x: 0, y: 0 };
+        this.domElement = element.clone();
+        /**
+         * get target element DOMRect data
+         */
+        const targetRect = element.dom.getBoundingClientRect();
+        /**
+         * save cursor position relative to target element
+         * this will help calculate dragged item position relative to the cursor
+         */
+        this.positions = {
+            x: event.clientX - targetRect.left,
+            y: event.clientY - targetRect.top,
+        };
+        this.hideDefaultDragPlaceholder(event);
+        /**
+         * add clone to the list
+         */
+        container.append(this.domElement);
+        this.scrollUnsubscribeFunction = this.renderer.listen('document', 'scroll', () => {
+            this.setDomPosition();
+        });
+        /**
+         * make initial placeholder positioning
+         */
+        this.reposition(event);
+    }
+    remove() {
+        this.domElement.remove();
+        if (this.scrollUnsubscribeFunction) {
+            this.scrollUnsubscribeFunction();
+        }
+    }
+    reposition(event) {
+        this.cursorPos = { x: event.clientX, y: event.clientY };
+        this.setDomPosition();
+    }
+    setDomPosition() {
+        /**
+         * position placeholder relative to the cursor
+         */
+        this.domElement.style.left = this.cursorPos.x - this.positions.x + 'px';
+        this.domElement.style.top = this.cursorPos.y - this.positions.y + 'px';
+    }
+    hideDefaultDragPlaceholder(event) {
+        const placeholder = document.createElement('img');
+        placeholder.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==';
+        Object.assign(placeholder.style, {
+            display: 'block',
+            width: '0',
+            height: '0',
+        });
+        /**
+         * replace default browser drag placeholder with transparent image
+         */
+        event.dataTransfer?.setDragImage(placeholder, 0, 0);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/components/drag-and-drop-list/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './drag-and-drop-list.component';
+export * from './drag-and-drop-list.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYWRzLXVpL3NyYy9saWIvY29tcG9uZW50cy9kcmFnLWFuZC1kcm9wLWxpc3QvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RyYWctYW5kLWRyb3AtbGlzdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWFuZC1kcm9wLWxpc3QubW9kdWxlJztcbiJdfQ==

package/esm2022/src/lib/components/error-page/error-page-code/ascentgl-ads-ui-src-lib-components-error-page-error-page-code.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNjZW50Z2wtYWRzLXVpLXNyYy1saWItY29tcG9uZW50cy1lcnJvci1wYWdlLWVycm9yLXBhZ2UtY29kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYWRzLXVpL3NyYy9saWIvY29tcG9uZW50cy9lcnJvci1wYWdlL2Vycm9yLXBhZ2UtY29kZS9hc2NlbnRnbC1hZHMtdWktc3JjLWxpYi1jb21wb25lbnRzLWVycm9yLXBhZ2UtZXJyb3ItcGFnZS1jb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/src/lib/components/error-page/error-page-code/error-page-code.component.mjs

@@ -0,0 +1,14 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AdsErrorPageCodeComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsErrorPageCodeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: AdsErrorPageCodeComponent, selector: "ads-error-page-code", ngImport: i0, template: ``, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsErrorPageCodeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ads-error-page-code',
+                    template: ``,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3ItcGFnZS1jb2RlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYWRzLXVpL3NyYy9saWIvY29tcG9uZW50cy9lcnJvci1wYWdlL2Vycm9yLXBhZ2UtY29kZS9lcnJvci1wYWdlLWNvZGUuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTTFDLE1BQU0sT0FBTyx5QkFBeUI7OEdBQXpCLHlCQUF5QjtrR0FBekIseUJBQXlCLDJEQUYxQixFQUFFOzsyRkFFRCx5QkFBeUI7a0JBSnJDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHFCQUFxQjtvQkFDL0IsUUFBUSxFQUFFLEVBQUU7aUJBQ2IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYWRzLWVycm9yLXBhZ2UtY29kZScsXG4gIHRlbXBsYXRlOiBgYCxcbn0pXG5leHBvcnQgY2xhc3MgQWRzRXJyb3JQYWdlQ29kZUNvbXBvbmVudCB7fVxuIl19

package/esm2022/src/lib/components/error-page/error-page-code/error-page-code.module.mjs

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

package/esm2022/src/lib/components/error-page/error-page-code/public-api.mjs

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

package/esm2022/src/lib/components/footer/ascentgl-ads-ui-src-lib-components-footer.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNjZW50Z2wtYWRzLXVpLXNyYy1saWItY29tcG9uZW50cy1mb290ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Fkcy11aS9zcmMvbGliL2NvbXBvbmVudHMvZm9vdGVyL2FzY2VudGdsLWFkcy11aS1zcmMtbGliLWNvbXBvbmVudHMtZm9vdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/src/lib/components/footer/container/ascentgl-ads-ui-src-lib-components-footer-container.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNjZW50Z2wtYWRzLXVpLXNyYy1saWItY29tcG9uZW50cy1mb290ZXItY29udGFpbmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hZHMtdWkvc3JjL2xpYi9jb21wb25lbnRzL2Zvb3Rlci9jb250YWluZXIvYXNjZW50Z2wtYWRzLXVpLXNyYy1saWItY29tcG9uZW50cy1mb290ZXItY29udGFpbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/src/lib/components/footer/container/footer-container.component.mjs

@@ -0,0 +1,11 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AdsFooterContainerComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsFooterContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: AdsFooterContainerComponent, selector: "ads-footer-container", ngImport: i0, template: "<footer>\n  <ng-content></ng-content>\n</footer>\n", styles: ["footer{height:107px;box-sizing:border-box;padding:24px;border-top:1px solid var(--color-light);background-color:var(--color-muted-50);width:100%}@media screen and (max-width: 959px){footer{height:auto}}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsFooterContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ads-footer-container', template: "<footer>\n  <ng-content></ng-content>\n</footer>\n", styles: ["footer{height:107px;box-sizing:border-box;padding:24px;border-top:1px solid var(--color-light);background-color:var(--color-muted-50);width:100%}@media screen and (max-width: 959px){footer{height:auto}}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9vdGVyLWNvbnRhaW5lci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Fkcy11aS9zcmMvbGliL2NvbXBvbmVudHMvZm9vdGVyL2NvbnRhaW5lci9mb290ZXItY29udGFpbmVyLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYWRzLXVpL3NyYy9saWIvY29tcG9uZW50cy9mb290ZXIvY29udGFpbmVyL2Zvb3Rlci1jb250YWluZXIuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFPMUMsTUFBTSxPQUFPLDJCQUEyQjs4R0FBM0IsMkJBQTJCO2tHQUEzQiwyQkFBMkIsNERDUHhDLG9EQUdBOzsyRkRJYSwyQkFBMkI7a0JBTHZDLFNBQVM7K0JBQ0Usc0JBQXNCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2Fkcy1mb290ZXItY29udGFpbmVyJyxcbiAgc3R5bGVVcmxzOiBbJ2Zvb3Rlci1jb250YWluZXIuY29tcG9uZW50LnNjc3MnXSxcbiAgdGVtcGxhdGVVcmw6ICdmb290ZXItY29udGFpbmVyLmNvbXBvbmVudC5odG1sJyxcbn0pXG5leHBvcnQgY2xhc3MgQWRzRm9vdGVyQ29udGFpbmVyQ29tcG9uZW50IHt9XG4iLCI8Zm9vdGVyPlxuICA8bmctY29udGVudD48L25nLWNvbnRlbnQ+XG48L2Zvb3Rlcj5cbiJdfQ==

package/esm2022/src/lib/components/footer/container/footer-container.module.mjs

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

package/esm2022/src/lib/components/footer/container/public-api.mjs

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