@tetacom/ng-components 1.1.2 → 1.1.4

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

@@ -0,0 +1,143 @@
+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 {
+    _container;
+    _dragService;
+    _zone;
+    _cdr;
+    data;
+    allowDrag = true;
+    allowDrop = true;
+    allowDropPredicate;
+    tetaDragEnter = new EventEmitter();
+    tetaDrop = new EventEmitter();
+    dropTarget;
+    instance;
+    get selection() {
+        return this._dragService?.selection?.items?.indexOf(this.instance) >= 0;
+    }
+    get isDropTarget() {
+        return this.dropTarget === this.instance && this.allowDrop;
+    }
+    _alive = true;
+    mousedown(event) {
+        if (!this.allowDrag) {
+            return;
+        }
+        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();
+            if (this.allowDropPredicate === undefined || this.allowDropPredicate(this._dragService.selection, this.data)) {
+                this._dragService.setDropTarget(this.instance);
+            }
+        }
+    }
+    mouseleave(event) {
+        this._dragService.setDropTarget(null);
+    }
+    constructor(_container, _dragService, _zone, _cdr) {
+        this._container = _container;
+        this._dragService = _dragService;
+        this._zone = _zone;
+        this._cdr = _cdr;
+    }
+    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;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DragDirective, deps: [{ token: DragContainerDirective, optional: true, skipSelf: true }, { token: i1.DragDropService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DragDirective, selector: "[tetaDrag]", inputs: { data: ["tetaDrag", "data"], allowDrag: "allowDrag", allowDrop: "allowDrop", allowDropPredicate: "allowDropPredicate" }, 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: "16.1.4", 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
+            }], allowDropPredicate: [{
+                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';\nimport {DragSelection} from './model/drag-selection';\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  @Input() allowDropPredicate: (data: DragSelection<T>, target: T) => boolean;\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 && this.allowDrop;\n  }\n\n  private _alive = true;\n\n  @HostListener('mousedown', ['$event'])\n  @HostListener('touchstart', ['$event'])\n  mousedown(event) {\n    if(!this.allowDrag) {\n      return;\n    }\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      if(this.allowDropPredicate === undefined || this.allowDropPredicate(this._dragService.selection, this.data)) {\n        this._dragService.setDropTarget(this.instance);\n      }\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/esm2022/directive/drag-drop/model/drag-container-instance.mjs

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

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

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

package/esm2022/directive/drag-sort/drag-sort-container.directive.mjs

@@ -0,0 +1,68 @@
+import { 
+// ContentChildren,
+Directive, EventEmitter, HostListener, Input, Output,
+// QueryList,
+ } from '@angular/core';
+import * as i0 from "@angular/core";
+// import {DragSortItemDirective} from './drag-sort-item.directive';
+export class DragSortContainerDirective {
+    dragSortList;
+    dragSorted = new EventEmitter();
+    // @ContentChildren(DragSortItemDirective, {descendants: true})
+    // private items: QueryList<DragSortItemDirective<T>>;
+    _dragItem;
+    constructor() {
+    }
+    drop(event) {
+        event.stopPropagation();
+        event.preventDefault();
+    }
+    setDragItem(item) {
+        this._dragItem = item;
+    }
+    getDragItem() {
+        return this._dragItem;
+    }
+    getList() {
+        return this.dragSortList;
+    }
+    setList(list) {
+        this.dragSortList = list;
+    }
+    updateSortOrder(source, target, insertBefore) {
+        if (source === target) {
+            return;
+        }
+        const list = this.getList();
+        const sourceIndex = list.indexOf(source);
+        const targetIndex = list.indexOf(target);
+        if ((insertBefore && sourceIndex + 1 === targetIndex) ||
+            (!insertBefore && sourceIndex === targetIndex + 1)) {
+            return;
+        }
+        const newIndex = list.indexOf(target) + (insertBefore ? 0 : 1);
+        this.dragSorted.emit({
+            list,
+            source,
+            target,
+            newIndex,
+            previousIndex: sourceIndex,
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DragSortContainerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DragSortContainerDirective, selector: "[tetaDragSortContainer]", inputs: { dragSortList: "dragSortList" }, outputs: { dragSorted: "dragSorted" }, host: { listeners: { "drop": "drop($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DragSortContainerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaDragSortContainer]',
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { dragSortList: [{
+                type: Input
+            }], dragSorted: [{
+                type: Output
+            }], drop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directive/drag-sort/drag-sort-item.directive.mjs

@@ -0,0 +1,121 @@
+import { Directive, Host, HostBinding, HostListener, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./drag-sort-container.directive";
+export class DragSortItemDirective {
+    _container;
+    _elementRef;
+    _renderer;
+    tetaDragSortItem;
+    dragSortDirection = 'horizontal';
+    draggable = true;
+    relative = true;
+    _dragElement;
+    rect;
+    constructor(_container, _elementRef, _renderer) {
+        this._container = _container;
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+    }
+    dragstart(event) {
+        this._container.setDragItem(this.tetaDragSortItem);
+    }
+    dragenter(event) {
+        this.rect = this._elementRef.nativeElement.getBoundingClientRect();
+    }
+    dragover(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (this.rect && this._container.getDragItem()) {
+            this.showDrag(this.getDropPosition(event));
+        }
+    }
+    dragleave(event) {
+        event.preventDefault();
+        this.hideDrag();
+    }
+    dragend(event) {
+        this._container.setDragItem(null);
+        this.hideDrag();
+    }
+    drop(event) {
+        event.stopPropagation();
+        this._container.updateSortOrder(this._container.getDragItem(), this.tetaDragSortItem, this.getDropPosition(event) === 'start');
+        this.hideDrag();
+    }
+    ngOnInit() {
+        this.createDrag();
+    }
+    ngOnDestroy() {
+        this.destroyDrag();
+    }
+    showDrag(position) {
+        this.hideDrag();
+        this._renderer.addClass(this._dragElement, `drop-direction-${position}`);
+    }
+    hideDrag() {
+        this._renderer.removeClass(this._dragElement, 'drop-direction-start');
+        this._renderer.removeClass(this._dragElement, 'drop-direction-end');
+    }
+    createDrag() {
+        this._dragElement = this._renderer.createElement('div');
+        this._renderer.appendChild(this._elementRef.nativeElement, this._dragElement);
+        this._renderer.addClass(this._dragElement, 'drop-direction');
+        this._renderer.addClass(this._dragElement, this.dragSortDirection === 'horizontal'
+            ? 'drop-direction-horizontal'
+            : 'drop-direction-vertical');
+    }
+    destroyDrag() {
+        this._renderer.removeChild(this._renderer, this._dragElement);
+    }
+    getDropPosition(event) {
+        if (this.dragSortDirection === 'horizontal') {
+            return event.clientX >= this.rect.x + this.rect.width / 2
+                ? 'end'
+                : 'start';
+        }
+        else {
+            return event.clientY >= this.rect.y + this.rect.height / 2
+                ? 'end'
+                : 'start';
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DragSortItemDirective, deps: [{ token: i1.DragSortContainerDirective, host: true }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DragSortItemDirective, selector: "[tetaDragSortItem]", inputs: { tetaDragSortItem: "tetaDragSortItem", dragSortDirection: "dragSortDirection" }, host: { listeners: { "dragstart": "dragstart($event)", "dragenter": "dragenter($event)", "dragover": "dragover($event)", "dragleave": "dragleave($event)", "dragend": "dragend($event)", "drop": "drop($event)" }, properties: { "attr.draggable": "this.draggable", "class.position-relative": "this.relative" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DragSortItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaDragSortItem]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DragSortContainerDirective, decorators: [{
+                    type: Host
+                }] }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { tetaDragSortItem: [{
+                type: Input
+            }], dragSortDirection: [{
+                type: Input
+            }], draggable: [{
+                type: HostBinding,
+                args: ['attr.draggable']
+            }], relative: [{
+                type: HostBinding,
+                args: ['class.position-relative']
+            }], dragstart: [{
+                type: HostListener,
+                args: ['dragstart', ['$event']]
+            }], dragenter: [{
+                type: HostListener,
+                args: ['dragenter', ['$event']]
+            }], dragover: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], dragleave: [{
+                type: HostListener,
+                args: ['dragleave', ['$event']]
+            }], dragend: [{
+                type: HostListener,
+                args: ['dragend', ['$event']]
+            }], drop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-sort-item.directive.js","sourceRoot":"","sources":["../../../../src/directive/drag-sort/drag-sort-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  Host,\n  HostBinding,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  Renderer2,\n} from '@angular/core';\nimport {DragSortContainerDirective} from './drag-sort-container.directive';\n\n@Directive({\n  selector: '[tetaDragSortItem]',\n})\nexport class DragSortItemDirective<T> implements OnInit, OnDestroy {\n  @Input() tetaDragSortItem: T;\n  @Input() dragSortDirection: 'horizontal' | 'vertical' = 'horizontal';\n\n  @HostBinding('attr.draggable') private readonly draggable = true;\n  @HostBinding('class.position-relative') private readonly relative = true;\n\n  private _dragElement: HTMLElement;\n\n  private rect: any;\n\n  constructor(\n    @Host() private _container: DragSortContainerDirective<T>,\n    private _elementRef: ElementRef,\n    private _renderer: Renderer2\n  ) {\n  }\n\n  @HostListener('dragstart', ['$event']) dragstart(event: DragEvent): void {\n    this._container.setDragItem(this.tetaDragSortItem);\n  }\n\n  @HostListener('dragenter', ['$event']) dragenter(event: DragEvent): void {\n    this.rect = this._elementRef.nativeElement.getBoundingClientRect();\n  }\n\n  @HostListener('dragover', ['$event']) dragover(event: DragEvent): void {\n    event.preventDefault();\n    event.stopPropagation();\n    if (this.rect && this._container.getDragItem()) {\n      this.showDrag(this.getDropPosition(event));\n    }\n  }\n\n  @HostListener('dragleave', ['$event']) dragleave(event: DragEvent): void {\n    event.preventDefault();\n    this.hideDrag();\n  }\n\n  @HostListener('dragend', ['$event']) dragend(event: DragEvent): void {\n    this._container.setDragItem(null);\n    this.hideDrag();\n  }\n\n  @HostListener('drop', ['$event']) drop(event: DragEvent): void {\n    event.stopPropagation();\n    this._container.updateSortOrder(\n      this._container.getDragItem(),\n      this.tetaDragSortItem,\n      this.getDropPosition(event) === 'start'\n    );\n    this.hideDrag();\n  }\n\n  ngOnInit() {\n    this.createDrag();\n  }\n\n  ngOnDestroy() {\n    this.destroyDrag();\n  }\n\n  private showDrag(position: 'start' | 'end') {\n    this.hideDrag();\n    this._renderer.addClass(this._dragElement, `drop-direction-${position}`);\n  }\n\n  private hideDrag() {\n    this._renderer.removeClass(this._dragElement, 'drop-direction-start');\n    this._renderer.removeClass(this._dragElement, 'drop-direction-end');\n  }\n\n  private createDrag() {\n    this._dragElement = this._renderer.createElement('div');\n    this._renderer.appendChild(\n      this._elementRef.nativeElement,\n      this._dragElement\n    );\n    this._renderer.addClass(this._dragElement, 'drop-direction');\n    this._renderer.addClass(\n      this._dragElement,\n      this.dragSortDirection === 'horizontal'\n        ? 'drop-direction-horizontal'\n        : 'drop-direction-vertical'\n    );\n  }\n\n  private destroyDrag() {\n    this._renderer.removeChild(this._renderer, this._dragElement);\n  }\n\n  private getDropPosition(event: DragEvent) {\n    if (this.dragSortDirection === 'horizontal') {\n      return event.clientX >= this.rect.x + this.rect.width / 2\n        ? 'end'\n        : 'start';\n    } else {\n      return event.clientY >= this.rect.y + this.rect.height / 2\n        ? 'end'\n        : 'start';\n    }\n  }\n}\n"]}

package/{esm2020 → esm2022}/directive/drag-sort/drag-sort.module.mjs

@@ -4,11 +4,11 @@ import { DragSortContainerDirective } from './drag-sort-container.directive';
 import { DragSortItemDirective } from './drag-sort-item.directive';
 import * as i0 from "@angular/core";
 export class DragSortModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DragSortModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: DragSortModule, declarations: [DragSortContainerDirective, DragSortItemDirective], imports: [CommonModule], exports: [DragSortContainerDirective, DragSortItemDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DragSortModule, imports: [CommonModule] });
 }
-DragSortModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: DragSortModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-DragSortModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.2", ngImport: i0, type: DragSortModule, declarations: [DragSortContainerDirective, DragSortItemDirective], imports: [CommonModule], exports: [DragSortContainerDirective, DragSortItemDirective] });
-DragSortModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: DragSortModule, imports: [CommonModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: DragSortModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DragSortModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [DragSortContainerDirective, DragSortItemDirective],
@@ -16,4 +16,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImpor
                     imports: [CommonModule],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1zb3J0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvZHJhZy1zb3J0L2RyYWctc29ydC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDN0UsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7O0FBT25FLE1BQU0sT0FBTyxjQUFjOzsyR0FBZCxjQUFjOzRHQUFkLGNBQWMsaUJBSlYsMEJBQTBCLEVBQUUscUJBQXFCLGFBRXRELFlBQVksYUFEWiwwQkFBMEIsRUFBRSxxQkFBcUI7NEdBR2hELGNBQWMsWUFGZixZQUFZOzJGQUVYLGNBQWM7a0JBTDFCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsMEJBQTBCLEVBQUUscUJBQXFCLENBQUM7b0JBQ2pFLE9BQU8sRUFBRSxDQUFDLDBCQUEwQixFQUFFLHFCQUFxQixDQUFDO29CQUM1RCxPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7aUJBQ3hCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBEcmFnU29ydENvbnRhaW5lckRpcmVjdGl2ZSB9IGZyb20gJy4vZHJhZy1zb3J0LWNvbnRhaW5lci5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgRHJhZ1NvcnRJdGVtRGlyZWN0aXZlIH0gZnJvbSAnLi9kcmFnLXNvcnQtaXRlbS5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtEcmFnU29ydENvbnRhaW5lckRpcmVjdGl2ZSwgRHJhZ1NvcnRJdGVtRGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW0RyYWdTb3J0Q29udGFpbmVyRGlyZWN0aXZlLCBEcmFnU29ydEl0ZW1EaXJlY3RpdmVdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbn0pXG5leHBvcnQgY2xhc3MgRHJhZ1NvcnRNb2R1bGUge31cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1zb3J0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmUvZHJhZy1zb3J0L2RyYWctc29ydC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDN0UsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7O0FBT25FLE1BQU0sT0FBTyxjQUFjO3VHQUFkLGNBQWM7d0dBQWQsY0FBYyxpQkFKViwwQkFBMEIsRUFBRSxxQkFBcUIsYUFFdEQsWUFBWSxhQURaLDBCQUEwQixFQUFFLHFCQUFxQjt3R0FHaEQsY0FBYyxZQUZmLFlBQVk7OzJGQUVYLGNBQWM7a0JBTDFCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsMEJBQTBCLEVBQUUscUJBQXFCLENBQUM7b0JBQ2pFLE9BQU8sRUFBRSxDQUFDLDBCQUEwQixFQUFFLHFCQUFxQixDQUFDO29CQUM1RCxPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7aUJBQ3hCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBEcmFnU29ydENvbnRhaW5lckRpcmVjdGl2ZSB9IGZyb20gJy4vZHJhZy1zb3J0LWNvbnRhaW5lci5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgRHJhZ1NvcnRJdGVtRGlyZWN0aXZlIH0gZnJvbSAnLi9kcmFnLXNvcnQtaXRlbS5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtEcmFnU29ydENvbnRhaW5lckRpcmVjdGl2ZSwgRHJhZ1NvcnRJdGVtRGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW0RyYWdTb3J0Q29udGFpbmVyRGlyZWN0aXZlLCBEcmFnU29ydEl0ZW1EaXJlY3RpdmVdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbn0pXG5leHBvcnQgY2xhc3MgRHJhZ1NvcnRNb2R1bGUge31cbiJdfQ==

package/esm2022/directive/dynamic-content-base.directive.mjs

@@ -0,0 +1,91 @@
+import { Directive, EventEmitter, Input, Output, } from '@angular/core';
+import { Align } from '../common/enum/align.enum';
+import { VerticalAlign } from '../common/enum/vertical-align.enum';
+import { filter, takeWhile } from 'rxjs/operators';
+import { PopupContentComponent } from '../component/dynamic-component/popup-content/popup-content.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../common/service/dynamic-component.service";
+export class DynamicContentBaseDirective {
+    _document;
+    _elementRef;
+    _service;
+    _injector;
+    _zone;
+    _cdr;
+    data;
+    className;
+    align = Align.left;
+    verticalAlign = VerticalAlign.auto;
+    appendToBody;
+    set open(open) {
+        this._open = open;
+        if (this._open) {
+            this.createContentRef();
+        }
+        else {
+            this.destroyContentRef();
+        }
+    }
+    openChange = new EventEmitter();
+    _alive = true;
+    _componentRef;
+    _content;
+    _open = false;
+    constructor(_document, _elementRef, _service, _injector, _zone, _cdr) {
+        this._document = _document;
+        this._elementRef = _elementRef;
+        this._service = _service;
+        this._injector = _injector;
+        this._zone = _zone;
+        this._cdr = _cdr;
+        this._zone.onStable
+            .pipe(takeWhile((_) => this._alive), filter((_) => this._open))
+            .subscribe((_) => {
+            this.setPosition();
+        });
+    }
+    ngOnDestroy() {
+        this._alive = false;
+        this.destroyContentRef();
+    }
+    ngOnInit() {
+    }
+    createContentRef(className) {
+        if (!this._componentRef) {
+            this._open = true;
+            const injector = this._service.getInjector(this.data, this._injector);
+            const context = this._service.getContext(this._dynamicContent, this.data);
+            this._content = this._service.createContent(this._dynamicContent, this._injector, context);
+            this._componentRef = this._service.createComponent(PopupContentComponent, this._content, injector, this.appendToBody ? this._document.body : this._elementRef.nativeElement);
+            if (className) {
+                this._componentRef.instance.addClass(className);
+            }
+        }
+        return this._componentRef;
+    }
+    destroyContentRef() {
+        this._open = false;
+        this._service.destroy(this._componentRef, this._content, this.appendToBody ? this._document.body : this._elementRef.nativeElement);
+        this._componentRef = null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DynamicContentBaseDirective, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DynamicContentBaseDirective, inputs: { data: "data", className: "className", align: "align", verticalAlign: "verticalAlign", appendToBody: "appendToBody", open: "open" }, outputs: { openChange: "openChange" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DynamicContentBaseDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: i0.ElementRef }, { type: i1.DynamicComponentService }, { type: i0.Injector }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { data: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], verticalAlign: [{
+                type: Input
+            }], appendToBody: [{
+                type: Input
+            }], open: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directive/highlight/highlight.directive.mjs

@@ -0,0 +1,73 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HighlightDirective {
+    elementRef;
+    set tetaHighlight(text) {
+        setTimeout(() => {
+            if (this._initialElement) {
+                this.elementRef.nativeElement.innerHTML = this._initialElement;
+            }
+            if (!text) {
+                return;
+            }
+            const pattern = /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g;
+            const searchWithOutRegExp = text
+                .toLowerCase()
+                .replace(pattern, '\\$&')
+                .split(' ')
+                .filter(t => t.length > 0)
+                .join('|');
+            this._initialElement = this.elementRef.nativeElement.innerHTML;
+            this.recursiveReplaceNode(this.elementRef.nativeElement.childNodes, searchWithOutRegExp);
+        }, 10);
+    }
+    _initialElement = null;
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    recursiveReplaceNode(nodes, searchWithOutRegExp) {
+        let match = false;
+        const cacheNodes = [];
+        nodes.forEach((node) => {
+            cacheNodes.push(node);
+        });
+        cacheNodes.forEach(node => {
+            if (node.nodeType === 3) {
+                if (node.nodeValue && node.nodeValue.search(new RegExp(searchWithOutRegExp, 'i')) > -1) {
+                    match = true;
+                    this.wrapNode(node, searchWithOutRegExp);
+                }
+            }
+            else {
+                match = this.recursiveReplaceNode(node.childNodes, searchWithOutRegExp) || match;
+            }
+        });
+        return match;
+    }
+    wrapNode(textNode, searchWithOutRegExp) {
+        if (!textNode || !textNode.nodeValue) {
+            return;
+        }
+        const tempDiv = document.createElement('div');
+        tempDiv.innerHTML = textNode.nodeValue
+            .replace(new RegExp(searchWithOutRegExp, 'gi'), match => `<mark>${match}</mark>`);
+        const parentNode = textNode.parentNode;
+        if (parentNode) {
+            while (tempDiv.firstChild) {
+                parentNode.insertBefore(tempDiv.firstChild, textNode);
+            }
+            parentNode.removeChild(textNode);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: HighlightDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: HighlightDirective, selector: "[tetaHighlight]", inputs: { tetaHighlight: "tetaHighlight" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: HighlightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaHighlight]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { tetaHighlight: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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