@tetacom/ng-components 1.0.36 → 1.0.39

package/esm2020/directive/drag-drop/drag-drop.module.mjs

@@ -0,0 +1,41 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DragContainerDirective } from './drag-container.directive';
+import { DragDirective } from './drag.directive';
+import { DragPreviewDirective } from './drag-preview.directive';
+import { DragPlaceholderDirective } from './drag-placeholder.directive';
+import * as i0 from "@angular/core";
+export class DragDropModule {
+}
+DragDropModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDropModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DragDropModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDropModule, declarations: [DragContainerDirective,
+        DragDirective,
+        DragPreviewDirective,
+        DragPlaceholderDirective], imports: [CommonModule], exports: [DragContainerDirective,
+        DragDirective,
+        DragPreviewDirective,
+        DragPlaceholderDirective] });
+DragDropModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDropModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDropModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        DragContainerDirective,
+                        DragDirective,
+                        DragPreviewDirective,
+                        DragPlaceholderDirective
+                    ],
+                    exports: [
+                        DragContainerDirective,
+                        DragDirective,
+                        DragPreviewDirective,
+                        DragPlaceholderDirective
+                    ],
+                    imports: [
+                        CommonModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/directive/drag-drop/drag-drop.service.mjs

@@ -0,0 +1,140 @@
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { BehaviorSubject, fromEvent, merge, Subject } from 'rxjs';
+import { filter, withLatestFrom } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class DragDropService {
+    constructor(_document, _rendererFactory) {
+        this._document = _document;
+        this._rendererFactory = _rendererFactory;
+        this.dropTarget$ = new BehaviorSubject(null);
+        this._delta = 10;
+        this.dropped$ = new Subject();
+        this._renderer = this._rendererFactory.createRenderer(null, null);
+        this.dropTarget = this.dropTarget$.asObservable();
+        this.dropped = this.dropped$.asObservable();
+        merge(fromEvent(this._document, 'mousemove'), fromEvent(this._document, 'touchmove')).pipe(filter(() => {
+            return this.startPosition != null;
+        })).subscribe((event) => {
+            if (!this.dragProcess && this.getDelta(event) > this._delta) {
+                this.startProcess();
+            }
+            if (this.dragProcess && this._preview) {
+                this.movePreview(event);
+            }
+        });
+        merge(fromEvent(this._document, 'mouseup'), fromEvent(this._document, 'touchend')).pipe(withLatestFrom(this.dropTarget)).subscribe((data) => {
+            const [event, target] = data;
+            if (target) {
+                this.dropped$.next({
+                    target,
+                    container: this.dragProcess.selection.container,
+                    data: [...this.dragProcess.selection.items]
+                });
+                this.cancelDrag();
+            }
+            this.stopProcess();
+        });
+        merge(fromEvent(this._document, 'visibilitychange'), fromEvent(window, 'blur'))
+            .subscribe(() => {
+            this.cancelDrag();
+        });
+    }
+    setDropTarget(target) {
+        if (this.dragProcess) {
+            this.dropTarget$.next(target);
+        }
+    }
+    setStartPosition(point) {
+        this.startPosition = point;
+    }
+    setSelection(instance, container) {
+        if (this.selection?.container === container && this.selection?.items?.indexOf(instance) >= 0) {
+            return;
+        }
+        this.selection = {
+            container,
+            items: [instance]
+        };
+    }
+    addSelection(instance, container) {
+        if (!this.selection) {
+            this.setSelection(instance, container);
+            return;
+        }
+        if (this.selection && this.selection.container !== container) {
+            return;
+        }
+        const index = this.selection.items.indexOf(instance);
+        if (index < 0) {
+            this.selection.items.push(instance);
+        }
+        else {
+            this.selection.items.splice(index, 1);
+        }
+    }
+    clearSelection() {
+        this.selection = null;
+    }
+    cancelDrag() {
+        this.setDropTarget(null);
+        this.clearSelection();
+        this.stopProcess();
+    }
+    startProcess() {
+        this.dragProcess = {
+            selection: this.selection
+        };
+        this._preview = this.createPreview();
+    }
+    stopProcess() {
+        this.destroyPreview();
+        this.dragProcess = null;
+        this.startPosition = null;
+    }
+    getDelta(event) {
+        return Math.max(Math.abs(this.startPosition.x - event.x), Math.abs(this.startPosition.y - event.y));
+    }
+    createPreview() {
+        if (this.dragProcess.selection.container.previewTemplate) {
+            this._previewRef = this.dragProcess.selection.container.viewContainer.createEmbeddedView(this.dragProcess.selection.container.previewTemplate, {
+                $implicit: this.dragProcess.selection.items,
+                data: this.dragProcess.selection.items
+            });
+            const preview = this._renderer.createElement('div');
+            this._renderer.setStyle(preview, 'position', 'fixed');
+            this._renderer.setStyle(preview, 'pointer-events', 'none');
+            this._renderer.setStyle(preview, 'top', '0');
+            this._renderer.setStyle(preview, 'left', '0');
+            this._renderer.appendChild(preview, this._previewRef.rootNodes[0]);
+            this._renderer.appendChild(document.body, preview);
+            return preview;
+        }
+        return null;
+    }
+    movePreview(event) {
+        if (this._preview) {
+            this._renderer.setStyle(this._preview, 'transform', `translate(${event.x}px, ${event.y}px)`);
+        }
+    }
+    destroyPreview() {
+        if (this._preview) {
+            this.dragProcess?.selection?.container?.viewContainer?.clear();
+            this._preview?.remove();
+            this._previewRef?.destroy();
+            this._preview = this._previewRef = null;
+        }
+    }
+}
+DragDropService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDropService, deps: [{ token: DOCUMENT }, { token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
+DragDropService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDropService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDropService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-drop.service.js","sourceRoot":"","sources":["../../../../src/directive/drag-drop/drag-drop.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {EmbeddedViewRef, Inject, Injectable, Renderer2, RendererFactory2} from '@angular/core';\nimport {DragInstance} from './model/drag-instance';\nimport {DragSelection} from './model/drag-selection';\nimport {DragContainerInstance} from './model/drag-container-instance';\nimport {Point} from './model/point';\nimport {DOCUMENT} from '@angular/common';\nimport {BehaviorSubject, fromEvent, merge, Observable, Subject, tap} from 'rxjs';\nimport {filter, withLatestFrom} from 'rxjs/operators';\nimport {DragProcess} from './model/drag-process';\nimport {DropTarget} from './model/drop-target';\nimport {DropEvent} from './model/drop-event';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DragDropService<T> {\n  selection: DragSelection<T>;\n  startPosition: Point;\n  dragProcess: DragProcess<T>;\n  dropTarget: Observable<DropTarget<T>>;\n  dropped: Observable<DropEvent<T>>;\n  private dropTarget$ = new BehaviorSubject<DropTarget<T>>(null);\n  private _delta = 10;\n  private _renderer: Renderer2;\n  private _preview: HTMLElement;\n  private _previewRef: EmbeddedViewRef<any>;\n  private dropped$ = new Subject<DropEvent<T>>();\n\n  constructor(@Inject(DOCUMENT) private _document: any,\n              private _rendererFactory: RendererFactory2) {\n    this._renderer = this._rendererFactory.createRenderer(null, null);\n    this.dropTarget = this.dropTarget$.asObservable();\n    this.dropped = this.dropped$.asObservable();\n    merge(\n      fromEvent(this._document, 'mousemove'),\n      fromEvent(this._document, 'touchmove')\n    ).pipe(\n      filter(() => {\n        return this.startPosition != null;\n      })\n    ).subscribe((event: MouseEvent) => {\n      if (!this.dragProcess && this.getDelta(event) > this._delta) {\n        this.startProcess();\n      }\n      if (this.dragProcess && this._preview) {\n        this.movePreview(event);\n      }\n    });\n\n    merge(\n      fromEvent(this._document, 'mouseup'),\n      fromEvent(this._document, 'touchend')\n    ).pipe(\n      withLatestFrom(this.dropTarget)\n    ).subscribe((data: [MouseEvent, DropTarget<T>]) => {\n      const [event, target] = data;\n      if (target) {\n        this.dropped$.next({\n          target,\n          container: this.dragProcess.selection.container,\n          data: [...this.dragProcess.selection.items]\n        });\n        this.cancelDrag();\n      }\n      this.stopProcess();\n    });\n\n    merge(fromEvent(this._document, 'visibilitychange'), fromEvent(window, 'blur'))\n      .subscribe(() => {\n        this.cancelDrag();\n      });\n  }\n\n  setDropTarget(target: DropTarget<T>) {\n    if (this.dragProcess) {\n      this.dropTarget$.next(target);\n    }\n  }\n\n  setStartPosition(point: Point) {\n    this.startPosition = point;\n  }\n\n  setSelection(instance: DragInstance<T>, container: DragContainerInstance<T>) {\n    if (this.selection?.container === container && this.selection?.items?.indexOf(instance) >= 0) {\n      return;\n    }\n    this.selection = {\n      container,\n      items: [instance]\n    };\n  }\n\n  addSelection(instance: DragInstance<T>, container: DragContainerInstance<T>) {\n    if (!this.selection) {\n      this.setSelection(instance, container);\n      return;\n    }\n    if (this.selection && this.selection.container !== container) {\n      return;\n    }\n\n    const index = this.selection.items.indexOf(instance);\n    if (index < 0) {\n      this.selection.items.push(instance);\n    } else {\n      this.selection.items.splice(index, 1);\n    }\n  }\n\n  clearSelection() {\n    this.selection = null;\n  }\n\n  cancelDrag() {\n    this.setDropTarget(null);\n    this.clearSelection();\n    this.stopProcess();\n  }\n\n  startProcess() {\n    this.dragProcess = {\n      selection: this.selection\n    };\n    this._preview = this.createPreview();\n  }\n\n  stopProcess() {\n    this.destroyPreview();\n    this.dragProcess = null;\n    this.startPosition = null;\n  }\n\n  private getDelta(event: MouseEvent) {\n    return Math.max(Math.abs(this.startPosition.x - event.x), Math.abs(this.startPosition.y - event.y));\n  }\n\n  private createPreview() {\n    if (this.dragProcess.selection.container.previewTemplate) {\n      this._previewRef = this.dragProcess.selection.container.viewContainer.createEmbeddedView(\n        this.dragProcess.selection.container.previewTemplate, {\n          $implicit: this.dragProcess.selection.items,\n          data: this.dragProcess.selection.items\n        });\n      const preview = this._renderer.createElement('div');\n      this._renderer.setStyle(preview, 'position', 'fixed');\n      this._renderer.setStyle(preview, 'pointer-events', 'none');\n      this._renderer.setStyle(preview, 'top', '0');\n      this._renderer.setStyle(preview, 'left', '0');\n      this._renderer.appendChild(preview, this._previewRef.rootNodes[0]);\n      this._renderer.appendChild(document.body, preview);\n      return preview;\n    }\n    return null;\n  }\n\n  private movePreview(event: MouseEvent) {\n    if (this._preview) {\n      this._renderer.setStyle(this._preview, 'transform', `translate(${event.x}px, ${event.y}px)`);\n    }\n  }\n\n  private destroyPreview() {\n    if (this._preview) {\n      this.dragProcess?.selection?.container?.viewContainer?.clear();\n      this._preview?.remove();\n      this._previewRef?.destroy();\n      this._preview = this._previewRef = null;\n    }\n  }\n}\n"]}

package/esm2020/directive/drag-drop/drag-placeholder.directive.mjs

@@ -0,0 +1,14 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DragPlaceholderDirective {
+    constructor() { }
+}
+DragPlaceholderDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragPlaceholderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+DragPlaceholderDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.1", type: DragPlaceholderDirective, selector: "[tetaDragPlaceholder]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragPlaceholderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaDragPlaceholder]'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1wbGFjZWhvbGRlci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGlyZWN0aXZlL2RyYWctZHJvcC9kcmFnLXBsYWNlaG9sZGVyLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUsxQyxNQUFNLE9BQU8sd0JBQXdCO0lBRW5DLGdCQUFnQixDQUFDOztxSEFGTix3QkFBd0I7eUdBQXhCLHdCQUF3QjsyRkFBeEIsd0JBQXdCO2tCQUhwQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSx1QkFBdUI7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1t0ZXRhRHJhZ1BsYWNlaG9sZGVyXSdcbn0pXG5leHBvcnQgY2xhc3MgRHJhZ1BsYWNlaG9sZGVyRGlyZWN0aXZlIHtcblxuICBjb25zdHJ1Y3RvcigpIHsgfVxuXG59XG4iXX0=

package/esm2020/directive/drag-drop/drag-preview.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DragPreviewDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+}
+DragPreviewDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragPreviewDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+DragPreviewDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.1", type: DragPreviewDirective, selector: "[tetaDragPreview]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragPreviewDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaDragPreview]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1wcmV2aWV3LmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvZHJhZy1kcm9wL2RyYWctcHJldmlldy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBYyxNQUFNLGVBQWUsQ0FBQzs7QUFLckQsTUFBTSxPQUFPLG9CQUFvQjtJQUMvQixZQUFtQixXQUE2QjtRQUE3QixnQkFBVyxHQUFYLFdBQVcsQ0FBa0I7SUFDaEQsQ0FBQzs7aUhBRlUsb0JBQW9CO3FHQUFwQixvQkFBb0I7MkZBQXBCLG9CQUFvQjtrQkFIaEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsbUJBQW1CO2lCQUM5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlLCBUZW1wbGF0ZVJlZn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1t0ZXRhRHJhZ1ByZXZpZXddJ1xufSlcbmV4cG9ydCBjbGFzcyBEcmFnUHJldmlld0RpcmVjdGl2ZSB7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB0ZW1wbGF0ZVJlZjogVGVtcGxhdGVSZWY8YW55Pikge1xuICB9XG59XG4iXX0=

package/esm2020/directive/drag-drop/drag.directive.mjs

@@ -0,0 +1,128 @@
+import { Directive, EventEmitter, HostBinding, HostListener, Inject, Input, Optional, Output, SkipSelf } from '@angular/core';
+import { DragInstance } from './model/drag-instance';
+import { DragContainerDirective } from './drag-container.directive';
+import { filter, takeWhile } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./drag-drop.service";
+import * as i2 from "./drag-container.directive";
+export class DragDirective {
+    constructor(_container, _dragService, _zone, _cdr) {
+        this._container = _container;
+        this._dragService = _dragService;
+        this._zone = _zone;
+        this._cdr = _cdr;
+        this.allowDrag = true;
+        this.allowDrop = true;
+        this.tetaDragEnter = new EventEmitter();
+        this.tetaDrop = new EventEmitter();
+        this._alive = true;
+    }
+    get selection() {
+        return this._dragService?.selection?.items?.indexOf(this.instance) >= 0;
+    }
+    get isDropTarget() {
+        return this.dropTarget === this.instance;
+    }
+    mousedown(event) {
+        if (event.ctrlKey && this._container?.multiple) {
+            this._dragService.addSelection(this.instance, this._container.instance);
+        }
+        else {
+            this._dragService.setSelection(this.instance, this._container.instance);
+        }
+        this._dragService.setStartPosition({
+            x: event.x,
+            y: event.y
+        });
+    }
+    mouseenter(event) {
+        if (this.allowDrop) {
+            event.stopPropagation();
+            this._dragService.setDropTarget(this.instance);
+        }
+    }
+    mouseleave(event) {
+        this._dragService.setDropTarget(null);
+    }
+    ngOnInit() {
+        this.instance = new DragInstance({
+            container: this._container.instance,
+            data: this.data
+        });
+        this._dragService.dropTarget.pipe(takeWhile(() => this._alive))
+            .subscribe((target) => {
+            this.dropTarget = target;
+            if (target === this.instance) {
+                this.tetaDragEnter.emit(this.instance);
+            }
+            this._cdr.detectChanges();
+            this._cdr.markForCheck();
+        });
+        this._dragService.dropped.pipe(takeWhile(() => this._alive))
+            .pipe(filter((event) => {
+            return event.target === this.instance;
+        }))
+            .subscribe((event) => {
+            this.tetaDrop.emit(event);
+        });
+    }
+    ngOnDestroy() {
+        this._alive = false;
+    }
+}
+DragDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDirective, deps: [{ token: DragContainerDirective, optional: true, skipSelf: true }, { token: i1.DragDropService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+DragDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.1", type: DragDirective, selector: "[tetaDrag]", inputs: { data: ["tetaDrag", "data"], allowDrag: "allowDrag", allowDrop: "allowDrop" }, outputs: { tetaDragEnter: "tetaDragEnter", tetaDrop: "tetaDrop" }, host: { listeners: { "mousedown": "mousedown($event)", "touchstart": "mousedown($event)", "mouseenter": "mouseenter($event)", "mouseleave": "mouseleave($event)" }, properties: { "style.userSelect": "\"none\"", "class.teta-drag-item": "\"true\"", "class.teta_draggable_item": "this.allowDrag", "class.teta_droppable_item": "this.allowDrop", "class.teta-drag-selection": "this.selection", "class.teta-drop-target": "this.isDropTarget" } }, exportAs: ["drag"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DragDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaDrag]',
+                    exportAs: 'drag',
+                    host: {
+                        '[style.userSelect]': '"none"',
+                        '[class.teta-drag-item]': '"true"'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i2.DragContainerDirective, decorators: [{
+                    type: Inject,
+                    args: [DragContainerDirective]
+                }, {
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i1.DragDropService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { data: [{
+                type: Input,
+                args: ['tetaDrag']
+            }], allowDrag: [{
+                type: HostBinding,
+                args: ['class.teta_draggable_item']
+            }, {
+                type: Input
+            }], allowDrop: [{
+                type: HostBinding,
+                args: ['class.teta_droppable_item']
+            }, {
+                type: Input
+            }], tetaDragEnter: [{
+                type: Output
+            }], tetaDrop: [{
+                type: Output
+            }], selection: [{
+                type: HostBinding,
+                args: ['class.teta-drag-selection']
+            }], isDropTarget: [{
+                type: HostBinding,
+                args: ['class.teta-drop-target']
+            }], mousedown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['touchstart', ['$event']]
+            }], mouseenter: [{
+                type: HostListener,
+                args: ['mouseenter', ['$event']]
+            }], mouseleave: [{
+                type: HostListener,
+                args: ['mouseleave', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag.directive.js","sourceRoot":"","sources":["../../../../src/directive/drag-drop/drag.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Directive,\n  EventEmitter,\n  HostBinding,\n  HostListener,\n  Inject,\n  Input, NgZone, OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  SkipSelf\n} from '@angular/core';\nimport {DragInstance} from './model/drag-instance';\nimport {DragContainerDirective} from './drag-container.directive';\nimport {DragDropService} from './drag-drop.service';\nimport {DropTarget} from './model/drop-target';\nimport {filter, takeWhile} from 'rxjs/operators';\nimport {DropEvent} from './model/drop-event';\n\n@Directive({\n  selector: '[tetaDrag]',\n  exportAs: 'drag',\n  host: {\n    '[style.userSelect]': '\"none\"',\n    '[class.teta-drag-item]': '\"true\"'\n  }\n})\nexport class DragDirective<T> implements OnInit, OnDestroy {\n  @Input('tetaDrag') data: T;\n\n  @HostBinding('class.teta_draggable_item')\n  @Input() allowDrag = true;\n\n  @HostBinding('class.teta_droppable_item')\n  @Input() allowDrop = true;\n\n  @Output() tetaDragEnter = new EventEmitter<DragInstance<T>>();\n  @Output() tetaDrop = new EventEmitter<DropEvent<T>>();\n\n  dropTarget: DropTarget<T>;\n  instance: DragInstance<T>;\n\n  @HostBinding('class.teta-drag-selection')\n  get selection() {\n    return this._dragService?.selection?.items?.indexOf(this.instance) >= 0;\n  }\n\n  @HostBinding('class.teta-drop-target')\n  get isDropTarget() {\n    return this.dropTarget === this.instance;\n  }\n\n  private _alive = true;\n\n  @HostListener('mousedown', ['$event'])\n  @HostListener('touchstart', ['$event'])\n  mousedown(event) {\n    if (event.ctrlKey && this._container?.multiple) {\n      this._dragService.addSelection(this.instance, this._container.instance);\n    } else {\n      this._dragService.setSelection(this.instance, this._container.instance);\n    }\n    this._dragService.setStartPosition({\n      x: event.x,\n      y: event.y\n    });\n  }\n\n  @HostListener('mouseenter', ['$event'])\n  mouseenter(event: MouseEvent) {\n    if (this.allowDrop) {\n      event.stopPropagation();\n      this._dragService.setDropTarget(this.instance);\n    }\n  }\n\n  @HostListener('mouseleave', ['$event']) mouseleave(event) {\n    this._dragService.setDropTarget(null);\n  }\n\n  constructor(@Inject(DragContainerDirective) @Optional() @SkipSelf() private _container: DragContainerDirective<T>,\n              private _dragService: DragDropService<T>,\n              private _zone: NgZone,\n              private _cdr: ChangeDetectorRef) {\n  }\n\n  ngOnInit() {\n    this.instance = new DragInstance({\n      container: this._container.instance,\n      data: this.data\n    });\n    this._dragService.dropTarget.pipe(takeWhile(() => this._alive))\n      .subscribe((target) => {\n        this.dropTarget = target;\n        if (target === this.instance) {\n          this.tetaDragEnter.emit(this.instance);\n        }\n        this._cdr.detectChanges();\n        this._cdr.markForCheck();\n      });\n    this._dragService.dropped.pipe(takeWhile(() => this._alive))\n      .pipe(\n        filter((event: DropEvent<T>) => {\n          return event.target === this.instance;\n        }))\n      .subscribe((event) => {\n        this.tetaDrop.emit(event);\n      });\n  }\n\n  ngOnDestroy() {\n    this._alive = false;\n  }\n}\n"]}

package/esm2020/directive/drag-drop/model/drag-container-instance.mjs

@@ -0,0 +1,8 @@
+export class DragContainerInstance {
+    constructor(options) {
+        this.data = options.data;
+        this.previewTemplate = options.previewTemplate;
+        this.viewContainer = options.viewContainer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1jb250YWluZXItaW5zdGFuY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZGlyZWN0aXZlL2RyYWctZHJvcC9tb2RlbC9kcmFnLWNvbnRhaW5lci1pbnN0YW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8scUJBQXFCO0lBS2hDLFlBQVksT0FJWDtRQUNDLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQztRQUN6QixJQUFJLENBQUMsZUFBZSxHQUFHLE9BQU8sQ0FBQyxlQUFlLENBQUM7UUFDL0MsSUFBSSxDQUFDLGFBQWEsR0FBRyxPQUFPLENBQUMsYUFBYSxDQUFDO0lBQzdDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VGVtcGxhdGVSZWYsIFZpZXdDb250YWluZXJSZWZ9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgY2xhc3MgRHJhZ0NvbnRhaW5lckluc3RhbmNlPFQ+IHtcbiAgZGF0YTogVFtdO1xuICBwcmV2aWV3VGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT47XG4gIHZpZXdDb250YWluZXI6IFZpZXdDb250YWluZXJSZWY7XG5cbiAgY29uc3RydWN0b3Iob3B0aW9uczoge1xuICAgIGRhdGE6IFRbXSxcbiAgICBwcmV2aWV3VGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT4sXG4gICAgdmlld0NvbnRhaW5lcjogVmlld0NvbnRhaW5lclJlZlxuICB9KSB7XG4gICAgdGhpcy5kYXRhID0gb3B0aW9ucy5kYXRhO1xuICAgIHRoaXMucHJldmlld1RlbXBsYXRlID0gb3B0aW9ucy5wcmV2aWV3VGVtcGxhdGU7XG4gICAgdGhpcy52aWV3Q29udGFpbmVyID0gb3B0aW9ucy52aWV3Q29udGFpbmVyO1xuICB9XG59XG4iXX0=

package/esm2020/directive/drag-drop/model/drag-instance.mjs

@@ -0,0 +1,7 @@
+export class DragInstance {
+    constructor(options) {
+        this.container = options.container;
+        this.data = options.data;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1pbnN0YW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvZHJhZy1kcm9wL21vZGVsL2RyYWctaW5zdGFuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLFlBQVk7SUFJdkIsWUFBWSxPQUdYO1FBQ0MsSUFBSSxDQUFDLFNBQVMsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDO1FBQ25DLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQztJQUMzQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RyYWdDb250YWluZXJJbnN0YW5jZX0gZnJvbSAnLi9kcmFnLWNvbnRhaW5lci1pbnN0YW5jZSc7XG5cbmV4cG9ydCBjbGFzcyBEcmFnSW5zdGFuY2U8VD4ge1xuICBjb250YWluZXI6IERyYWdDb250YWluZXJJbnN0YW5jZTxUPjtcbiAgZGF0YTogVDtcblxuICBjb25zdHJ1Y3RvcihvcHRpb25zPzoge1xuICAgIGNvbnRhaW5lcjogRHJhZ0NvbnRhaW5lckluc3RhbmNlPFQ+LFxuICAgIGRhdGE6IFRcbiAgfSkge1xuICAgIHRoaXMuY29udGFpbmVyID0gb3B0aW9ucy5jb250YWluZXI7XG4gICAgdGhpcy5kYXRhID0gb3B0aW9ucy5kYXRhO1xuICB9XG59XG4iXX0=

package/esm2020/directive/drag-drop/model/drag-process.mjs

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

package/esm2020/directive/drag-drop/model/drag-selection.mjs

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

package/esm2020/directive/drag-drop/model/drop-event.mjs

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

package/esm2020/directive/drag-drop/model/drop-target.mjs

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

package/esm2020/directive/drag-drop/model/point.mjs

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

package/esm2020/directive/drag-drop/model/public-api.mjs

@@ -0,0 +1,8 @@
+export * from './drag-container-instance';
+export * from './drag-instance';
+export * from './drag-process';
+export * from './drag-selection';
+export * from './drop-event';
+export * from './drop-target';
+export * from './point';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvZHJhZy1kcm9wL21vZGVsL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZHJhZy1jb250YWluZXItaW5zdGFuY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWluc3RhbmNlJztcbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1wcm9jZXNzJztcbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1zZWxlY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9kcm9wLWV2ZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZHJvcC10YXJnZXQnO1xuZXhwb3J0ICogZnJvbSAnLi9wb2ludCc7XG4iXX0=

package/esm2020/directive/drag-drop/public-api.mjs

@@ -0,0 +1,8 @@
+export * from './drag.directive';
+export * from './drag-container.directive';
+export * from './drag-drop.module';
+export * from './drag-placeholder.directive';
+export * from './drag-preview.directive';
+export * from './drag-drop.service';
+export * from './model/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvZHJhZy1kcm9wL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDBCQUEwQixDQUFDO0FBRXpDLGNBQWMscUJBQXFCLENBQUM7QUFFcEMsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZHJhZy5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWNvbnRhaW5lci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWRyb3AubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1wbGFjZWhvbGRlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLXByZXZpZXcuZGlyZWN0aXZlJztcblxuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWRyb3Auc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbW9kZWwvcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/directive/let/let.directive.mjs

@@ -0,0 +1,38 @@
+import { Directive, Inject, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LetDirective {
+    constructor(viewContainer, templateRef) {
+        viewContainer.createEmbeddedView(templateRef, new LetContext(this));
+    }
+    static ngTemplateContextGuard(_dir, _ctx) {
+        return true;
+    }
+}
+LetDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: LetDirective, deps: [{ token: ViewContainerRef }, { token: TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+LetDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.1", type: LetDirective, selector: "[tetaLet]", inputs: { tetaLet: "tetaLet" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: LetDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaLet]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef, decorators: [{
+                    type: Inject,
+                    args: [ViewContainerRef]
+                }] }, { type: i0.TemplateRef, decorators: [{
+                    type: Inject,
+                    args: [TemplateRef]
+                }] }]; }, propDecorators: { tetaLet: [{
+                type: Input
+            }] } });
+export class LetContext {
+    constructor(internalDirectiveInstance) {
+        this.internalDirectiveInstance = internalDirectiveInstance;
+    }
+    get $implicit() {
+        return this.internalDirectiveInstance.tetaLet;
+    }
+    get tetaLet() {
+        return this.internalDirectiveInstance.tetaLet;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/directive/let/let.module.mjs

@@ -0,0 +1,25 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { LetDirective } from './let.directive';
+import * as i0 from "@angular/core";
+export class LetModule {
+}
+LetModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: LetModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LetModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: LetModule, declarations: [LetDirective], imports: [CommonModule], exports: [LetDirective] });
+LetModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: LetModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: LetModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        LetDirective
+                    ], exports: [
+                        LetDirective
+                    ],
+                    imports: [
+                        CommonModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGV0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvbGV0L2xldC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDOztBQVk3QyxNQUFNLE9BQU8sU0FBUzs7c0dBQVQsU0FBUzt1R0FBVCxTQUFTLGlCQVJsQixZQUFZLGFBS1osWUFBWSxhQUhaLFlBQVk7dUdBTUgsU0FBUyxZQUpYO1lBQ1AsWUFBWTtTQUNiOzJGQUVVLFNBQVM7a0JBVnJCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFO3dCQUNaLFlBQVk7cUJBQ2IsRUFBRSxPQUFPLEVBQUU7d0JBQ1YsWUFBWTtxQkFDYjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AsWUFBWTtxQkFDYjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQge0xldERpcmVjdGl2ZX0gZnJvbSAnLi9sZXQuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgTGV0RGlyZWN0aXZlXG4gIF0sIGV4cG9ydHM6IFtcbiAgICBMZXREaXJlY3RpdmVcbiAgXSxcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZVxuICBdXG59KVxuZXhwb3J0IGNsYXNzIExldE1vZHVsZSB7XG59XG4iXX0=

package/esm2020/directive/let/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './let.module';
+export * from './let.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvbGV0L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGV0Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xldC5kaXJlY3RpdmUnO1xuIl19

package/esm2020/directive/public-api.mjs

@@ -1,15 +1,17 @@
 export * from './click-outside/public-api';
 export * from './context-menu/public-api';
 export * from './disable-control/public-api';
+export * from './drag-drop/public-api';
 export * from './drag-sort/public-api';
 export * from './dynamic-content-base.directive';
 export * from './highlight/public-api';
 export * from './hint/public-api';
 export * from './loader/public-api';
 export * from './only-number/public-api';
-export * from '../component/resize-panel/public-api';
 export * from './teta-template/public-api';
 export * from './tooltip/public-api';
 export * from './no-autofill/public-api';
 export * from './resize-drag/public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NsaWNrLW91dHNpZGUvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQtbWVudS9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vZGlzYWJsZS1jb250cm9sL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLXNvcnQvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtY29udGVudC1iYXNlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2hpZ2hsaWdodC9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vaGludC9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vbG9hZGVyL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9vbmx5LW51bWJlci9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4uL2NvbXBvbmVudC9yZXNpemUtcGFuZWwvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3RldGEtdGVtcGxhdGUvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3Rvb2x0aXAvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL25vLWF1dG9maWxsL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNpemUtZHJhZy9wdWJsaWMtYXBpJztcbiJdfQ==
+export * from './let/public-api';
+export * from './scroll-into-view/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbGljay1vdXRzaWRlL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LW1lbnUvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2Rpc2FibGUtY29udHJvbC9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1kcm9wL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLXNvcnQvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtY29udGVudC1iYXNlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2hpZ2hsaWdodC9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vaGludC9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vbG9hZGVyL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9vbmx5LW51bWJlci9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vdGV0YS10ZW1wbGF0ZS9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vdG9vbHRpcC9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vbm8tYXV0b2ZpbGwvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc2l6ZS1kcmFnL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9sZXQvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3Njcm9sbC1pbnRvLXZpZXcvcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/directive/scroll-into-view/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './scroll-into-view.module';
+export * from './scroll-into-view.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvc2Nyb2xsLWludG8tdmlldy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw4QkFBOEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2Nyb2xsLWludG8tdmlldy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zY3JvbGwtaW50by12aWV3LmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2020/directive/scroll-into-view/scroll-into-view.directive.mjs

@@ -0,0 +1,40 @@
+import { Directive, Inject, Input, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export class ScrollIntoViewDirective {
+    constructor(platformId, elementRef) {
+        this.platformId = platformId;
+        this.elementRef = elementRef;
+        this.behavior = 'smooth';
+        this.block = 'end';
+    }
+    ngOnChanges(simpleChange) {
+        if (isPlatformBrowser(this.platformId)) {
+            if (coerceBooleanProperty(this.tetaScrollIntoView)) {
+                this.elementRef.nativeElement.scrollIntoView({
+                    behavior: 'smooth',
+                    block: 'end'
+                });
+            }
+        }
+    }
+}
+ScrollIntoViewDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ScrollIntoViewDirective, deps: [{ token: PLATFORM_ID }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ScrollIntoViewDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.1", type: ScrollIntoViewDirective, selector: "[tetaScrollIntoView]", inputs: { tetaScrollIntoView: "tetaScrollIntoView", behavior: "behavior", block: "block" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ScrollIntoViewDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaScrollIntoView]'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i0.ElementRef }]; }, propDecorators: { tetaScrollIntoView: [{
+                type: Input
+            }], behavior: [{
+                type: Input
+            }], block: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nyb2xsLWludG8tdmlldy5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGlyZWN0aXZlL3Njcm9sbC1pbnRvLXZpZXcvc2Nyb2xsLWludG8tdmlldy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBYyxNQUFNLEVBQUUsS0FBSyxFQUFhLFdBQVcsRUFBZ0IsTUFBTSxlQUFlLENBQUM7QUFDMUcsT0FBTyxFQUFDLGlCQUFpQixFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDbEQsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sdUJBQXVCLENBQUM7O0FBSzVELE1BQU0sT0FBTyx1QkFBdUI7SUFLbEMsWUFDK0IsVUFBZSxFQUNwQyxVQUFzQjtRQURELGVBQVUsR0FBVixVQUFVLENBQUs7UUFDcEMsZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUx2QixhQUFRLEdBQW1CLFFBQVEsQ0FBQztRQUNwQyxVQUFLLEdBQTBCLEtBQUssQ0FBQztJQU05QyxDQUFDO0lBRUQsV0FBVyxDQUFDLFlBQTJCO1FBQ3JDLElBQUksaUJBQWlCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQ3RDLElBQUkscUJBQXFCLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLEVBQUU7Z0JBQ2pELElBQUksQ0FBQyxVQUFVLENBQUMsYUFBa0MsQ0FBQyxjQUFjLENBQUM7b0JBQ2pFLFFBQVEsRUFBRSxRQUFRO29CQUNsQixLQUFLLEVBQUUsS0FBSztpQkFDYixDQUFDLENBQUM7YUFDSjtTQUNGO0lBQ0gsQ0FBQzs7b0hBcEJVLHVCQUF1QixrQkFNeEIsV0FBVzt3R0FOVix1QkFBdUI7MkZBQXZCLHVCQUF1QjtrQkFIbkMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsc0JBQXNCO2lCQUNqQzs7MEJBT0ksTUFBTTsyQkFBQyxXQUFXO3FFQUxaLGtCQUFrQjtzQkFBMUIsS0FBSztnQkFDRyxRQUFRO3NCQUFoQixLQUFLO2dCQUNHLEtBQUs7c0JBQWIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlLCBFbGVtZW50UmVmLCBJbmplY3QsIElucHV0LCBPbkNoYW5nZXMsIFBMQVRGT1JNX0lELCBTaW1wbGVDaGFuZ2VzfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7aXNQbGF0Zm9ybUJyb3dzZXJ9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQge2NvZXJjZUJvb2xlYW5Qcm9wZXJ0eX0gZnJvbSAnQGFuZ3VsYXIvY2RrL2NvZXJjaW9uJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3RldGFTY3JvbGxJbnRvVmlld10nXG59KVxuZXhwb3J0IGNsYXNzIFNjcm9sbEludG9WaWV3RGlyZWN0aXZlIGltcGxlbWVudHMgT25DaGFuZ2VzIHtcbiAgQElucHV0KCkgdGV0YVNjcm9sbEludG9WaWV3OiBib29sZWFuIHwgdW5kZWZpbmVkO1xuICBASW5wdXQoKSBiZWhhdmlvcjogU2Nyb2xsQmVoYXZpb3IgPSAnc21vb3RoJztcbiAgQElucHV0KCkgYmxvY2s6IFNjcm9sbExvZ2ljYWxQb3NpdGlvbiA9ICdlbmQnO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIEBJbmplY3QoUExBVEZPUk1fSUQpIHByaXZhdGUgcGxhdGZvcm1JZDogYW55LFxuICAgIHByaXZhdGUgZWxlbWVudFJlZjogRWxlbWVudFJlZlxuICApIHtcbiAgfVxuXG4gIG5nT25DaGFuZ2VzKHNpbXBsZUNoYW5nZTogU2ltcGxlQ2hhbmdlcykge1xuICAgIGlmIChpc1BsYXRmb3JtQnJvd3Nlcih0aGlzLnBsYXRmb3JtSWQpKSB7XG4gICAgICBpZiAoY29lcmNlQm9vbGVhblByb3BlcnR5KHRoaXMudGV0YVNjcm9sbEludG9WaWV3KSkge1xuICAgICAgICAodGhpcy5lbGVtZW50UmVmLm5hdGl2ZUVsZW1lbnQgYXMgSFRNTElucHV0RWxlbWVudCkuc2Nyb2xsSW50b1ZpZXcoe1xuICAgICAgICAgIGJlaGF2aW9yOiAnc21vb3RoJyxcbiAgICAgICAgICBibG9jazogJ2VuZCdcbiAgICAgICAgfSk7XG4gICAgICB9XG4gICAgfVxuICB9XG59XG4iXX0=