@stemy/ngx-utils 19.4.6 → 19.4.7

package/fesm2022/stemy-ngx-utils.mjs

@@ -6892,6 +6892,468 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImpor
                 }]
         }] });
 
+class InteractiveItemComponent {
+    set x(value) {
+        if (isNaN(value))
+            return;
+        this.pos = new Point(value, this.pos.y);
+    }
+    set y(value) {
+        if (isNaN(value))
+            return;
+        this.pos = new Point(this.pos.x, value);
+    }
+    set position(value) {
+        if (!(value instanceof Point))
+            return;
+        this.pos = value;
+    }
+    get shapes() {
+        return this.mShapes;
+    }
+    get canvas() {
+        return null;
+    }
+    get position() {
+        return this.pos;
+    }
+    get x() {
+        return this.pos.x;
+    }
+    get y() {
+        return this.pos.y;
+    }
+    get shape() {
+        return null;
+    }
+    constructor() {
+        this.onClick = new EventEmitter();
+        this.onPan = new EventEmitter();
+        this.onPanStart = new EventEmitter();
+        this.onPanEnd = new EventEmitter();
+        this.active = false;
+        this.index = -1;
+        this.basePan = 0;
+        this.pos = Point.Zero;
+        this.rotation = 0;
+        this.direction = "none";
+        this.mShapes = [];
+        this.subscription = ObservableUtils.multiSubscription(this.onPanStart.subscribe(() => {
+            this.deltaX = 0;
+            this.deltaY = 0;
+        }), this.onPan.subscribe(ev => {
+            const dx = ev.deltaX - this.deltaX;
+            const dy = ev.deltaY - this.deltaY;
+            switch (this.direction) {
+                case "free":
+                    this.x += dx;
+                    this.y += dy;
+                    break;
+                case "horizontal":
+                    this.x += dx;
+                    break;
+                case "vertical":
+                    this.y += dy;
+                    break;
+            }
+            if (this.direction !== "none") {
+                this.calcShapes();
+            }
+            this.deltaX = ev.deltaX;
+            this.deltaY = ev.deltaY;
+        }));
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    ngOnChanges() {
+        this.calcShapes();
+    }
+    calcShapes(basePan) {
+        const canvas = this.canvas;
+        const ratio = canvas.ratio;
+        const x = this.pos.x * ratio;
+        this.basePan = basePan ?? this.basePan;
+        this.mShapes = [0, 1, 2].map(cycle => {
+            const y = this.pos.y * ratio + this.basePan + cycle * canvas.fullHeight;
+            return this.calcShape(x, y);
+        });
+    }
+    hit(point) {
+        for (const shape of this.shapes) {
+            if (shape.distance(point) <= 0)
+                return true;
+        }
+        return false;
+    }
+    calcShape(x, y) {
+        return null;
+    }
+    draw(ctx, scale = 1) {
+        this.shapes.forEach(shape => {
+            ctx.beginPath();
+            ctx.arc(shape.x, shape.y, 3 * scale, 0, Math.PI * 2);
+            ctx.closePath();
+            ctx.fill();
+            ctx.stroke();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: InteractiveItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.1.5", type: InteractiveItemComponent, isStandalone: false, selector: "__interactive-item__", inputs: { x: "x", y: "y", position: "position", rotation: "rotation", direction: "direction", disabled: "disabled" }, outputs: { onClick: "onClick", onPan: "onPan", onPanStart: "onPanStart", onPanEnd: "onPanEnd" }, usesOnChanges: true, ngImport: i0, template: "", isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: InteractiveItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "__interactive-item__",
+                    template: ""
+                }]
+        }], ctorParameters: () => [], propDecorators: { x: [{
+                type: Input
+            }], y: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], rotation: [{
+                type: Input
+            }], direction: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], onClick: [{
+                type: Output
+            }], onPan: [{
+                type: Output
+            }], onPanStart: [{
+                type: Output
+            }], onPanEnd: [{
+                type: Output
+            }] } });
+
+class InteractiveCanvasComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.horizontal = false;
+        this.selectedIndex = 0;
+        this.resizeMode = "fit";
+        this.onDraw = () => { };
+        this.selectedIndexChange = new EventEmitter();
+        this.shouldDraw = true;
+        this.panOffset = 0;
+        this.pan = 0;
+        this.rotation = 0;
+        this.canvasWidth = 0;
+        this.canvasHeight = 0;
+        this.hoveredItem = null;
+        this.selectedItem = null;
+        this.items = [];
+        this.touched = false;
+        this.panFrom = 0;
+    }
+    ngOnInit() {
+        this.redraw();
+    }
+    ngOnDestroy() {
+        this.shouldDraw = false;
+        this.subscription?.unsubscribe();
+    }
+    ngOnChanges() {
+        this.resize();
+    }
+    ngAfterViewInit() {
+        this.subscription = this.itemList.changes.subscribe(() => this.fixItems());
+        this.fixItems();
+    }
+    resize() {
+        if (!this.canvasElem || !this.containerElem || !this.realWidth || !this.realWidth)
+            return;
+        const canvas = this.canvasElem.nativeElement;
+        const container = this.containerElem.nativeElement;
+        // Calculate canvas size
+        const axisX = this.horizontal ? "height" : "width";
+        const axisY = this.horizontal ? "width" : "height";
+        const resize = this.resizeMode == "fit" ? Math.min : Math.max;
+        canvas.width = container.clientWidth;
+        canvas.height = container.clientHeight;
+        this.ratio = resize(canvas[axisX] / this.realWidth, canvas[axisY] / this.realHeight);
+        if (this.resizeMode == "fit") {
+            canvas[axisX] = this.realWidth * this.ratio;
+            canvas[axisY] = this.realHeight * this.ratio;
+        }
+        this.canvasWidth = canvas[axisX];
+        this.canvasHeight = canvas[axisY];
+        this.fullHeight = this.realHeight * this.ratio;
+        this.panOffset = -this.fullHeight;
+        this.fixPan();
+    }
+    onTouchStart($event) {
+        this.hoveredItem = this.getItemUnderPointer($event.touches.item(0));
+        this.touched = true;
+    }
+    onTouchEnd($event) {
+        this.selectItem($event.touches.item(0));
+    }
+    onMouseDown() {
+        this.touched = true;
+    }
+    onMouseUp($event) {
+        this.selectItem($event);
+    }
+    onMouseMove($event) {
+        if (this.touched)
+            return;
+        this.hoveredItem = this.getItemUnderPointer($event);
+        this.updateCursor();
+    }
+    onMouseLeave() {
+        this.hoveredItem = null;
+        this.updateCursor();
+    }
+    onPanStart($event) {
+        this.lockedItem = this.getItemUnderPointer($event?.pointers[0]);
+        this.lockedItem?.onPanStart.emit(this.lockedItem);
+        this.panFrom = this.pan;
+    }
+    onPan($event) {
+        if (this.lockedItem) {
+            const data = this.horizontal
+                ? { pointers: $event.pointers, deltaX: -$event.deltaY / this.ratio, deltaY: $event.deltaX / this.ratio }
+                : { pointers: $event.pointers, deltaX: $event.deltaX / this.ratio, deltaY: $event.deltaY / this.ratio };
+            data.item = this.lockedItem;
+            this.lockedItem.onPan.emit(data);
+            return;
+        }
+        // if (this.useCanvasRatio) return;
+        // this.pan = this.panFrom + (this.horizontal ? $event.deltaX : $event.deltaY);
+        // this.fixPan();
+    }
+    onPanEnd() {
+        this.lockedItem?.onPanEnd.emit(this.lockedItem);
+        this.lockedItem = null;
+        this.panFrom = this.pan;
+    }
+    fixPan() {
+        if (this.fullHeight <= 0)
+            return;
+        while (this.pan > 0) {
+            this.pan -= this.fullHeight;
+        }
+        while (this.pan < -this.fullHeight) {
+            this.pan += this.fullHeight;
+        }
+        this.rotation = Math.round(this.pan / this.fullHeight * 360);
+        const basePan = (this.rotation / 360 - 1) * this.fullHeight;
+        this.items.forEach(item => {
+            item.calcShapes(basePan);
+        });
+    }
+    fixItems() {
+        this.items = this.itemList.toArray();
+        this.items.forEach((item, ix) => {
+            item.index = ix;
+        });
+        this.fixPan();
+    }
+    selectItem(pointer) {
+        const selected = this.getItemUnderPointer(pointer);
+        this.touched = false;
+        this.selectedItem = selected;
+        if (selected) {
+            selected.active = !selected.active;
+            const items = Array.from(this.items);
+            this.selectedIndex = items.indexOf(selected);
+            this.selectedIndexChange.emit(this.selectedIndex);
+        }
+    }
+    getItemUnderPointer(pointer) {
+        if (!pointer || !this.canvasElem || !this.items)
+            return null;
+        const canvasRect = this.canvasElem.nativeElement.getBoundingClientRect();
+        const point = this.horizontal
+            ? new Point(canvasRect.bottom - pointer.clientY, pointer.clientX - canvasRect.left)
+            : new Point(pointer.clientX - canvasRect.left, pointer.clientY - canvasRect.top);
+        for (const item of this.items) {
+            if (item?.hit(point)) {
+                return item.disabled ? null : item;
+            }
+        }
+        return null;
+    }
+    updateCursor() {
+        const cursor = this.getCursor();
+        this.renderer.setStyle(this.canvasElem.nativeElement, "cursor", cursor);
+        this.renderer.setStyle(this.containerElem.nativeElement, "cursor", cursor);
+    }
+    getCursor() {
+        if (!this.hoveredItem)
+            return "default";
+        switch (this.hoveredItem.direction) {
+            case "free":
+                return "all-scroll";
+            case "horizontal":
+                return "";
+            case "vertical":
+                return "row-resize";
+        }
+        return "pointer";
+    }
+    redraw() {
+        if (!this.shouldDraw)
+            return;
+        this.ctx = this.canvasElem.nativeElement?.getContext("2d");
+        if (!this.ctx) {
+            requestAnimationFrame(() => this.redraw());
+            return;
+        }
+        this.draw().then(() => {
+            requestAnimationFrame(() => this.redraw());
+        });
+    }
+    async draw() {
+        const ctx = this.ctx;
+        const canvas = ctx.canvas;
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        ctx.save();
+        const width = this.realWidth * this.ratio;
+        const height = this.realHeight * this.ratio;
+        const x = canvas.width / 2 - width / 2;
+        const y = canvas.height / 2 - height / 2;
+        if (this.horizontal) {
+            ctx.rotate(-Math.PI / 2);
+            ctx.translate(-this.canvasWidth, 0);
+        }
+        await this.onDraw(this, this.items);
+        ctx.restore();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: InteractiveCanvasComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.1.5", type: InteractiveCanvasComponent, isStandalone: false, selector: "interactive-canvas", inputs: { horizontal: "horizontal", selectedIndex: "selectedIndex", resizeMode: "resizeMode", realWidth: "realWidth", realHeight: "realHeight", onDraw: "onDraw" }, outputs: { selectedIndexChange: "selectedIndexChange" }, host: { listeners: { "window:touchend": "onTouchEnd($event)", "window:mouseup": "onMouseUp($event)" } }, queries: [{ propertyName: "itemList", predicate: InteractiveItemComponent }], viewQueries: [{ propertyName: "containerElem", first: true, predicate: ["containerElem"], descendants: true, static: true }, { propertyName: "canvasElem", first: true, predicate: ["canvasElem"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<div #containerElem\n     [ngClass]=\"['interactive-canvas-wrapper', horizontal ? 'horizontal' : 'vertical']\"\n     (resize)=\"resize()\"\n     (touchstart)=\"onTouchStart($event)\"\n     (mousedown)=\"onMouseDown()\"\n     (mousemove)=\"onMouseMove($event)\"\n     (mouseleave)=\"onMouseLeave()\"\n     (panend)=\"onPanEnd()\"\n     (panmove)=\"onPan($event)\"\n     (panstart)=\"onPanStart($event)\">\n    <canvas #canvasElem class=\"interactive-canvas-element\"></canvas>\n</div>\n", styles: [".interactive-canvas-wrapper{width:100%;height:100%;position:relative;display:flex;align-items:center;justify-content:center}.interactive-canvas-wrapper .interactive-canvas-element{position:absolute;pointer-events:none}\n"], dependencies: [{ kind: "directive", type: i1$3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: InteractiveCanvasComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: false, selector: "interactive-canvas", template: "<div #containerElem\n     [ngClass]=\"['interactive-canvas-wrapper', horizontal ? 'horizontal' : 'vertical']\"\n     (resize)=\"resize()\"\n     (touchstart)=\"onTouchStart($event)\"\n     (mousedown)=\"onMouseDown()\"\n     (mousemove)=\"onMouseMove($event)\"\n     (mouseleave)=\"onMouseLeave()\"\n     (panend)=\"onPanEnd()\"\n     (panmove)=\"onPan($event)\"\n     (panstart)=\"onPanStart($event)\">\n    <canvas #canvasElem class=\"interactive-canvas-element\"></canvas>\n</div>\n", styles: [".interactive-canvas-wrapper{width:100%;height:100%;position:relative;display:flex;align-items:center;justify-content:center}.interactive-canvas-wrapper .interactive-canvas-element{position:absolute;pointer-events:none}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }], propDecorators: { horizontal: [{
+                type: Input
+            }], selectedIndex: [{
+                type: Input
+            }], resizeMode: [{
+                type: Input
+            }], realWidth: [{
+                type: Input
+            }], realHeight: [{
+                type: Input
+            }], onDraw: [{
+                type: Input
+            }], selectedIndexChange: [{
+                type: Output
+            }], containerElem: [{
+                type: ViewChild,
+                args: ["containerElem", { static: true }]
+            }], canvasElem: [{
+                type: ViewChild,
+                args: ["canvasElem", { static: true }]
+            }], itemList: [{
+                type: ContentChildren,
+                args: [InteractiveItemComponent]
+            }], onTouchEnd: [{
+                type: HostListener,
+                args: ["window:touchend", ["$event"]]
+            }], onMouseUp: [{
+                type: HostListener,
+                args: ["window:mouseup", ["$event"]]
+            }] } });
+
+class InteractiveCircleComponent extends InteractiveItemComponent {
+    get canvas() {
+        return this.iCanvas;
+    }
+    get shape() {
+        return "circle";
+    }
+    constructor(iCanvas) {
+        super();
+        this.iCanvas = iCanvas;
+    }
+    calcShape(x, y) {
+        const ratio = this.canvas.ratio;
+        return new Circle(x, y, this.radius * ratio);
+    }
+    draw(ctx, scale = 1) {
+        const radius = this.radius * this.canvas.ratio * scale;
+        this.shapes.forEach(shape => {
+            ctx.beginPath();
+            ctx.arc(shape.x, shape.y, radius, 0, Math.PI * 2);
+            ctx.closePath();
+            ctx.fill();
+            ctx.stroke();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: InteractiveCircleComponent, deps: [{ token: InteractiveCanvasComponent }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.1.5", type: InteractiveCircleComponent, isStandalone: false, selector: "interactive-circle", inputs: { radius: "radius" }, providers: [
+            { provide: InteractiveItemComponent, useExisting: InteractiveCircleComponent },
+        ], usesInheritance: true, ngImport: i0, template: "", isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: InteractiveCircleComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "interactive-circle",
+                    template: "",
+                    providers: [
+                        { provide: InteractiveItemComponent, useExisting: InteractiveCircleComponent },
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: InteractiveCanvasComponent }], propDecorators: { radius: [{
+                type: Input
+            }] } });
+
+class InteractiveRectComponent extends InteractiveItemComponent {
+    get canvas() {
+        return this.iCanvas;
+    }
+    get shape() {
+        return "rect";
+    }
+    constructor(iCanvas) {
+        super();
+        this.iCanvas = iCanvas;
+    }
+    calcShape(x, y) {
+        const ratio = this.canvas.ratio;
+        return new Rect(x, y, this.width * ratio, this.height * ratio, this.rotation);
+    }
+    draw(ctx, scale = 1) {
+        scale *= this.canvas.ratio;
+        const width = this.width * scale;
+        const height = this.height * scale;
+        this.shapes.forEach(shape => {
+            ctx.beginPath();
+            ctx.rect(shape.x - width / 2, shape.y - height / 2, width, height);
+            ctx.closePath();
+            ctx.fill();
+            ctx.stroke();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: InteractiveRectComponent, deps: [{ token: InteractiveCanvasComponent }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.1.5", type: InteractiveRectComponent, isStandalone: false, selector: "interactive-rect", inputs: { width: "width", height: "height" }, providers: [
+            { provide: InteractiveItemComponent, useExisting: InteractiveRectComponent },
+        ], usesInheritance: true, ngImport: i0, template: "", isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: InteractiveRectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "interactive-rect",
+                    template: "",
+                    providers: [
+                        { provide: InteractiveItemComponent, useExisting: InteractiveRectComponent },
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: InteractiveCanvasComponent }], propDecorators: { width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }] } });
+
 class UnorderedListComponent {
     constructor(cdr) {
         this.cdr = cdr;
@@ -7251,6 +7713,10 @@ const components = [
     DynamicTableComponent,
     FakeModuleComponent,
     PaginationMenuComponent,
+    InteractiveCanvasComponent,
+    InteractiveItemComponent,
+    InteractiveCircleComponent,
+    InteractiveRectComponent,
     UnorderedListComponent,
     UploadComponent
 ];
@@ -7624,8 +8090,8 @@ class NgxUtilsModule {
     constructor() {
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: NgxUtilsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.1.5", ngImport: i0, type: NgxUtilsModule, declarations: [ChunkPipe, EntriesPipe, ExtraItemPropertiesPipe, FilterPipe, FindPipe, FormatNumberPipe, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplatePipe, GroupByPipe, IncludesPipe, IsTypePipe, JoinPipe, KeysPipe, MapPipe, MaxPipe, MinPipe, PopPipe, ReducePipe, RemapPipe, ReplacePipe, ReversePipe, RoundPipe, SafeHtmlPipe, ShiftPipe, SplitPipe, TranslatePipe, ValuesPipe, AsyncMethodBase, AsyncMethodDirective, BackgroundDirective, ComponentLoaderDirective, DynamicTableTemplateDirective, GlobalTemplateDirective, IconDirective, NgxTemplateOutletDirective, PaginationDirective, PaginationItemDirective, ResourceIfDirective, StickyDirective, StickyClassDirective, DropdownDirective, DropdownContentDirective, DropdownToggleDirective, UnorderedListItemDirective, UnorderedListTemplateDirective, DropListComponent, DropdownBoxComponent, DynamicTableComponent, FakeModuleComponent, PaginationMenuComponent, UnorderedListComponent, UploadComponent], imports: [CommonModule,
-            FormsModule], exports: [ChunkPipe, EntriesPipe, ExtraItemPropertiesPipe, FilterPipe, FindPipe, FormatNumberPipe, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplatePipe, GroupByPipe, IncludesPipe, IsTypePipe, JoinPipe, KeysPipe, MapPipe, MaxPipe, MinPipe, PopPipe, ReducePipe, RemapPipe, ReplacePipe, ReversePipe, RoundPipe, SafeHtmlPipe, ShiftPipe, SplitPipe, TranslatePipe, ValuesPipe, AsyncMethodBase, AsyncMethodDirective, BackgroundDirective, ComponentLoaderDirective, DynamicTableTemplateDirective, GlobalTemplateDirective, IconDirective, NgxTemplateOutletDirective, PaginationDirective, PaginationItemDirective, ResourceIfDirective, StickyDirective, StickyClassDirective, DropdownDirective, DropdownContentDirective, DropdownToggleDirective, UnorderedListItemDirective, UnorderedListTemplateDirective, DropListComponent, DropdownBoxComponent, DynamicTableComponent, FakeModuleComponent, PaginationMenuComponent, UnorderedListComponent, UploadComponent, FormsModule] }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.1.5", ngImport: i0, type: NgxUtilsModule, declarations: [ChunkPipe, EntriesPipe, ExtraItemPropertiesPipe, FilterPipe, FindPipe, FormatNumberPipe, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplatePipe, GroupByPipe, IncludesPipe, IsTypePipe, JoinPipe, KeysPipe, MapPipe, MaxPipe, MinPipe, PopPipe, ReducePipe, RemapPipe, ReplacePipe, ReversePipe, RoundPipe, SafeHtmlPipe, ShiftPipe, SplitPipe, TranslatePipe, ValuesPipe, AsyncMethodBase, AsyncMethodDirective, BackgroundDirective, ComponentLoaderDirective, DynamicTableTemplateDirective, GlobalTemplateDirective, IconDirective, NgxTemplateOutletDirective, PaginationDirective, PaginationItemDirective, ResourceIfDirective, StickyDirective, StickyClassDirective, DropdownDirective, DropdownContentDirective, DropdownToggleDirective, UnorderedListItemDirective, UnorderedListTemplateDirective, DropListComponent, DropdownBoxComponent, DynamicTableComponent, FakeModuleComponent, PaginationMenuComponent, InteractiveCanvasComponent, InteractiveItemComponent, InteractiveCircleComponent, InteractiveRectComponent, UnorderedListComponent, UploadComponent], imports: [CommonModule,
+            FormsModule], exports: [ChunkPipe, EntriesPipe, ExtraItemPropertiesPipe, FilterPipe, FindPipe, FormatNumberPipe, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplatePipe, GroupByPipe, IncludesPipe, IsTypePipe, JoinPipe, KeysPipe, MapPipe, MaxPipe, MinPipe, PopPipe, ReducePipe, RemapPipe, ReplacePipe, ReversePipe, RoundPipe, SafeHtmlPipe, ShiftPipe, SplitPipe, TranslatePipe, ValuesPipe, AsyncMethodBase, AsyncMethodDirective, BackgroundDirective, ComponentLoaderDirective, DynamicTableTemplateDirective, GlobalTemplateDirective, IconDirective, NgxTemplateOutletDirective, PaginationDirective, PaginationItemDirective, ResourceIfDirective, StickyDirective, StickyClassDirective, DropdownDirective, DropdownContentDirective, DropdownToggleDirective, UnorderedListItemDirective, UnorderedListTemplateDirective, DropListComponent, DropdownBoxComponent, DynamicTableComponent, FakeModuleComponent, PaginationMenuComponent, InteractiveCanvasComponent, InteractiveItemComponent, InteractiveCircleComponent, InteractiveRectComponent, UnorderedListComponent, UploadComponent, FormsModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: NgxUtilsModule, providers: pipes, imports: [CommonModule,
             FormsModule, FormsModule] }); }
 }
@@ -7655,5 +8121,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AuthGuard, BASE_CONFIG, BackgroundDirective, BaseDialogService, BaseHttpClient, BaseHttpService, BaseToasterService, CONFIG_SERVICE, CanvasColor, CanvasUtils, ChunkPipe, Circle, ComponentLoaderDirective, ComponentLoaderService, ConfigService, DIALOG_SERVICE, DateUtils, DragDropEventPlugin, DropListComponent, DropdownBoxComponent, DropdownContentDirective, DropdownDirective, DropdownToggleDirective, DynamicTableComponent, DynamicTableTemplateDirective, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FakeModuleComponent, FileSystemEntry, FileUtils, FilterPipe, FindPipe, FormatNumberPipe, FormatterService, GenericValue, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, HttpPromise, ICON_SERVICE, IConfiguration, IconDirective, IconService, IncludesPipe, Initializer, IsTypePipe, JSONfn, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, LocalHttpService, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, OPTIONS_TOKEN, ObjectType, ObjectUtils, ObservableUtils, OpenApiService, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, RESIZE_DELAY, RESIZE_STRATEGY, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SocketClient, SocketService, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyClassDirective, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UploadComponent, ValuedPromise, ValuesPipe, Vector, WASI_IMPLEMENTATION, WasmService, cachedFactory, cancelablePromise, checkTransitions, getComponentDef, impatientPromise, parseSelector, provideEntryComponents, provideWithOptions, selectorMatchesList };
+export { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AuthGuard, BASE_CONFIG, BackgroundDirective, BaseDialogService, BaseHttpClient, BaseHttpService, BaseToasterService, CONFIG_SERVICE, CanvasColor, CanvasUtils, ChunkPipe, Circle, ComponentLoaderDirective, ComponentLoaderService, ConfigService, DIALOG_SERVICE, DateUtils, DragDropEventPlugin, DropListComponent, DropdownBoxComponent, DropdownContentDirective, DropdownDirective, DropdownToggleDirective, DynamicTableComponent, DynamicTableTemplateDirective, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FakeModuleComponent, FileSystemEntry, FileUtils, FilterPipe, FindPipe, FormatNumberPipe, FormatterService, GenericValue, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, HttpPromise, ICON_SERVICE, IConfiguration, IconDirective, IconService, IncludesPipe, Initializer, InteractiveCanvasComponent, InteractiveCircleComponent, InteractiveItemComponent, InteractiveRectComponent, IsTypePipe, JSONfn, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, LocalHttpService, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, OPTIONS_TOKEN, ObjectType, ObjectUtils, ObservableUtils, OpenApiService, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, RESIZE_DELAY, RESIZE_STRATEGY, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SocketClient, SocketService, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyClassDirective, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UploadComponent, ValuedPromise, ValuesPipe, Vector, WASI_IMPLEMENTATION, WasmService, cachedFactory, cancelablePromise, checkTransitions, getComponentDef, impatientPromise, parseSelector, provideEntryComponents, provideWithOptions, selectorMatchesList };
 //# sourceMappingURL=stemy-ngx-utils.mjs.map