@yuuvis/client-framework 0.6.5

package/esm2022/common/lib/directives/drag-select.directive.mjs

@@ -0,0 +1,114 @@
+import { computed, contentChildren, Directive, ElementRef, HostListener, inject, input, output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DragSelectDirective {
+    constructor() {
+        this.#selectStartX = 0;
+        this.#selectStartY = 0;
+        this.#selection = [];
+        this.items = contentChildren(DragSelectItemDirective);
+        this.#selectables = computed(() => this.items().map((item) => item.el));
+        this.yuvDragSelect = input();
+        this.dragSelectChange = output();
+        this.dragSelect = output();
+        this.#onPointerUp = () => {
+            removeEventListener('pointermove', this.#resize);
+            removeEventListener('pointerup', this.#onPointerUp);
+            if (this.#selection.length)
+                this.dragSelect.emit(this.#selection);
+            if (this.#selector)
+                this.#selector.remove();
+        };
+        this.#resize = (event) => {
+            if (!this.#selector)
+                return;
+            const diffX = event.pageX - this.#selectStartX;
+            const diffY = event.pageY - this.#selectStartY;
+            this.#selector.style.left = diffX < 0 ? this.#selectStartX + diffX + 'px' : this.#selectStartX + 'px';
+            this.#selector.style.top = diffY < 0 ? this.#selectStartY + diffY + 'px' : this.#selectStartY + 'px';
+            this.#selector.style.height = Math.abs(diffY) + 'px';
+            this.#selector.style.width = Math.abs(diffX) + 'px';
+            this.#selector.style.border = `1px solid ${this.yuvDragSelect()?.selectorColor || 'var(--color-accent'}`;
+            this.#checkSelected();
+        };
+        this.#checkSelected = () => {
+            if (!this.#selector)
+                return;
+            const select = this.#selector.getBoundingClientRect();
+            const { x, y, height, width } = select;
+            if (!height || !width)
+                return;
+            const currSelectionLength = this.#selection.length;
+            this.#selectables().forEach((selectable, idx) => {
+                const r1 = { x: x + window.scrollX, y: y + window.scrollY, height, width };
+                const r2 = selectable.getBoundingClientRect();
+                this.#selection = this.#selection.filter((s) => s !== idx);
+                if (this.#checkRectIntersection(r1, r2)) {
+                    this.#selection.push(idx);
+                }
+            });
+            if (currSelectionLength !== this.#selection.length) {
+                this.dragSelectChange.emit(this.#selection);
+            }
+        };
+        this.#checkRectIntersection = (r1, r2) => {
+            return !(r1.x + r1.width < r2.x || r2.x + r2.width < r1.x || r1.y + r1.height < r2.y || r2.y + r2.height < r1.y);
+        };
+    }
+    #selector;
+    #selectStartX;
+    #selectStartY;
+    #selection;
+    onPointerDown(event) {
+        if (this.yuvDragSelect()?.disabled)
+            return;
+        event.preventDefault();
+        this.#selectStartX = event.pageX;
+        this.#selectStartY = event.pageY;
+        const div = document.createElement('div');
+        div.style.position = 'absolute';
+        div.style.width = '0';
+        div.style.height = '0';
+        div.style.left = this.#selectStartX + 'px';
+        div.style.top = this.#selectStartY + 'px';
+        div.classList.add('drag-select');
+        this.#selector = div;
+        document.body.append(this.#selector);
+        this.#selection = [];
+        addEventListener('pointermove', this.#resize);
+        addEventListener('pointerup', this.#onPointerUp);
+    }
+    #selectables;
+    #onPointerUp;
+    #resize;
+    #checkSelected;
+    #checkRectIntersection;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragSelectDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.2.13", type: DragSelectDirective, isStandalone: true, selector: "[yuvDragSelect]", inputs: { yuvDragSelect: { classPropertyName: "yuvDragSelect", publicName: "yuvDragSelect", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { dragSelectChange: "dragSelectChange", dragSelect: "dragSelect" }, host: { listeners: { "pointerdown": "onPointerDown($event)" } }, queries: [{ propertyName: "items", predicate: DragSelectItemDirective, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragSelectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[yuvDragSelect]',
+                    standalone: true
+                }]
+        }], propDecorators: { onPointerDown: [{
+                type: HostListener,
+                args: ['pointerdown', ['$event']]
+            }] } });
+export class DragSelectItemDirective {
+    constructor() {
+        this.#elRef = inject(ElementRef);
+        this.el = this.#elRef.nativeElement;
+    }
+    #elRef;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragSelectItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DragSelectItemDirective, isStandalone: true, selector: "[yuvDragSelectItem]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragSelectItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[yuvDragSelectItem]',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-select.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-framework/common/src/lib/directives/drag-select.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, contentChildren, Directive, ElementRef, HostListener, inject, input, output } from '@angular/core';\n\ninterface SelectableRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nexport interface DragSelectOptions {\n  disabled?: boolean;\n  selectorColor?: string;\n}\n\n@Directive({\n  selector: '[yuvDragSelect]',\n  standalone: true\n})\nexport class DragSelectDirective {\n  #selector?: HTMLDivElement;\n  #selectStartX = 0;\n  #selectStartY = 0;\n\n  #selection: number[] = [];\n\n  @HostListener('pointerdown', ['$event']) onPointerDown(event: PointerEvent) {\n    if (this.yuvDragSelect()?.disabled) return;\n    event.preventDefault();\n    this.#selectStartX = event.pageX;\n    this.#selectStartY = event.pageY;\n\n    const div = document.createElement('div');\n    div.style.position = 'absolute';\n    div.style.width = '0';\n    div.style.height = '0';\n    div.style.left = this.#selectStartX + 'px';\n    div.style.top = this.#selectStartY + 'px';\n    div.classList.add('drag-select');\n    this.#selector = div;\n    document.body.append(this.#selector);\n\n    this.#selection = [];\n    addEventListener('pointermove', this.#resize);\n    addEventListener('pointerup', this.#onPointerUp);\n  }\n\n  items = contentChildren(DragSelectItemDirective);\n  #selectables = computed(() => this.items().map((item) => item.el));\n\n  yuvDragSelect = input<DragSelectOptions>();\n  dragSelectChange = output<number[]>();\n  dragSelect = output<number[]>();\n\n  #onPointerUp = () => {\n    removeEventListener('pointermove', this.#resize);\n    removeEventListener('pointerup', this.#onPointerUp);\n    if (this.#selection.length) this.dragSelect.emit(this.#selection);\n    if (this.#selector) this.#selector.remove();\n  };\n\n  #resize = (event: PointerEvent) => {\n    if (!this.#selector) return;\n    const diffX = event.pageX - this.#selectStartX;\n    const diffY = event.pageY - this.#selectStartY;\n    this.#selector.style.left = diffX < 0 ? this.#selectStartX + diffX + 'px' : this.#selectStartX + 'px';\n    this.#selector.style.top = diffY < 0 ? this.#selectStartY + diffY + 'px' : this.#selectStartY + 'px';\n    this.#selector.style.height = Math.abs(diffY) + 'px';\n    this.#selector.style.width = Math.abs(diffX) + 'px';\n\n    this.#selector.style.border = `1px solid ${this.yuvDragSelect()?.selectorColor || 'var(--color-accent'}`;\n    this.#checkSelected();\n  };\n\n  #checkSelected = () => {\n    if (!this.#selector) return;\n    const select = this.#selector.getBoundingClientRect();\n    const { x, y, height, width } = select;\n    if (!height || !width) return;\n\n    const currSelectionLength = this.#selection.length;\n    this.#selectables().forEach((selectable, idx) => {\n      const r1: SelectableRect = { x: x + window.scrollX, y: y + window.scrollY, height, width };\n      const r2: SelectableRect = selectable.getBoundingClientRect();\n      this.#selection = this.#selection.filter((s) => s !== idx);\n      if (this.#checkRectIntersection(r1, r2)) {\n        this.#selection.push(idx);\n      }\n    });\n\n    if (currSelectionLength !== this.#selection.length) {\n      this.dragSelectChange.emit(this.#selection);\n    }\n  };\n\n  #checkRectIntersection = (r1: SelectableRect, r2: SelectableRect) => {\n    return !(r1.x + r1.width < r2.x || r2.x + r2.width < r1.x || r1.y + r1.height < r2.y || r2.y + r2.height < r1.y);\n  };\n}\n\n@Directive({\n  selector: '[yuvDragSelectItem]',\n  standalone: true\n})\nexport class DragSelectItemDirective {\n  #elRef = inject(ElementRef);\n  el = this.#elRef.nativeElement as HTMLElement;\n}\n"]}

package/esm2022/common/lib/directives/file-drop-zone/file-drop-zone.directive.mjs

@@ -0,0 +1,153 @@
+import { Directive, ElementRef, HostListener, inject, input, output } from '@angular/core';
+import { Utils } from '@yuuvis/client-core';
+import * as i0 from "@angular/core";
+export class FileDropZoneDirective {
+    constructor() {
+        this.#elRef = inject(ElementRef);
+        this.#fileOver = false;
+        this.#defaultDragOverCoverStyles = {
+            outline: '2px dashed var(--color-accent)',
+            display: 'flex',
+            transition: 'background-color .3s ease-in-out',
+            'z-index': '500',
+            'align-items': 'center',
+            'justify-content': 'center',
+            'outline-offset': '-2px',
+            'background-color': 'rgba(var(--color-accent-rgb), .5)'
+        };
+        this.#defaultDragOverCoverLabelStyles = {
+            outline: '1px solid var(--color-accent)',
+            padding: 'var(--app-pane-padding, 16px)',
+            'background-color': 'rgba(var(--color-accent-rgb), .9)',
+            color: 'var(--color-accent-tone)'
+        };
+        this.yuvFileDropZone = input();
+        this.fileDropDisabled = input(false);
+        this.fileDrop = output();
+        this.fileDropOver = output();
+    }
+    #elRef;
+    #coverElement;
+    #fileOver;
+    set fileOver(fo) {
+        if (fo !== this.#fileOver) {
+            this.#fileOver = fo;
+            this.fileDropOver.emit(fo);
+            this.#toggleCover();
+        }
+    }
+    get fileOver() {
+        return this.#fileOver;
+    }
+    #defaultDragOverCoverStyles;
+    #defaultDragOverCoverLabelStyles;
+    onDrop(event) {
+        if (this.fileDropDisabled())
+            return;
+        event.preventDefault();
+        event.stopPropagation();
+        this.fileOver = false;
+        const dataTransfer = event.dataTransfer;
+        if (dataTransfer) {
+            if (dataTransfer?.items) {
+                const files = [];
+                for (let i = 0; i < dataTransfer.items.length; i++) {
+                    // If dropped items aren't files, reject them
+                    if (dataTransfer.items[i].kind === 'file') {
+                        const file = dataTransfer.items[i].getAsFile();
+                        if (file)
+                            files.push(file);
+                    }
+                }
+                dataTransfer.items.clear();
+                this.fileDrop.emit(files);
+            }
+            else {
+                const files = dataTransfer.files;
+                dataTransfer.clearData();
+                this.fileDrop.emit(Array.from(files));
+            }
+        }
+    }
+    onDragOver(event) {
+        if (this.fileDropDisabled())
+            return;
+        event.stopPropagation();
+        event.preventDefault();
+        this.fileOver = true;
+    }
+    onDragLeave(event) {
+        if (this.fileDropDisabled())
+            return;
+        if (event.target.getAttribute('id') === this.#coverElement?.getAttribute('id')) {
+            this.fileOver = false;
+        }
+    }
+    onBodyDragOver(event) {
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    onBodyDrop(event) {
+        event.preventDefault();
+    }
+    #toggleCover() {
+        const el = this.#elRef.nativeElement;
+        if (this.#coverElement) {
+            el.style.position = 'initial';
+            this.#coverElement.remove();
+            this.#coverElement = undefined;
+        }
+        if (this.#fileOver) {
+            el.style.position = 'relative';
+            this.#coverElement = this.#createCoverElement();
+            el.append(this.#coverElement);
+        }
+    }
+    #createCoverElement() {
+        const coverElement = document.createElement('div');
+        coverElement.setAttribute('id', Utils.uuid());
+        coverElement.style.position = 'absolute';
+        coverElement.style.inset = '0';
+        const styles = this.yuvFileDropZone()?.coverStyles || this.#defaultDragOverCoverStyles;
+        Object.keys(styles).forEach((k) => {
+            coverElement.style[k] = styles[k];
+        });
+        const label = this.yuvFileDropZone()?.label;
+        if (label) {
+            const coverLabelElement = document.createElement('div');
+            coverLabelElement.innerText = label;
+            const labelStyles = this.yuvFileDropZone()?.coverLabelStyles || this.#defaultDragOverCoverLabelStyles;
+            Object.keys(labelStyles).forEach((k) => {
+                coverLabelElement.style[k] = labelStyles[k];
+            });
+            coverLabelElement.style.pointerEvents = 'none';
+            coverElement.append(coverLabelElement);
+        }
+        return coverElement;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FileDropZoneDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: FileDropZoneDirective, isStandalone: true, selector: "[yuvFileDropZone]", inputs: { yuvFileDropZone: { classPropertyName: "yuvFileDropZone", publicName: "yuvFileDropZone", isSignal: true, isRequired: false, transformFunction: null }, fileDropDisabled: { classPropertyName: "fileDropDisabled", publicName: "fileDropDisabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { fileDrop: "fileDrop", fileDropOver: "fileDropOver" }, host: { listeners: { "drop": "onDrop($event)", "dragover": "onDragOver($event)", "dragleave": "onDragLeave($event)", "body:dragover": "onBodyDragOver($event)", "body:drop": "onBodyDrop($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FileDropZoneDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[yuvFileDropZone]',
+                    standalone: true
+                }]
+        }], propDecorators: { onDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }], onDragOver: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], onDragLeave: [{
+                type: HostListener,
+                args: ['dragleave', ['$event']]
+            }], onBodyDragOver: [{
+                type: HostListener,
+                args: ['body:dragover', ['$event']]
+            }], onBodyDrop: [{
+                type: HostListener,
+                args: ['body:drop', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-drop-zone.directive.js","sourceRoot":"","sources":["../../../../../../../../../libs/yuuvis/client-framework/common/src/lib/directives/file-drop-zone/file-drop-zone.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;;AAO5C,MAAM,OAAO,qBAAqB;IAJlC;QAKE,WAAM,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAI5B,cAAS,GAAG,KAAK,CAAC;QAYlB,gCAA2B,GAA2B;YACpD,OAAO,EAAE,gCAAgC;YACzC,OAAO,EAAE,MAAM;YACf,UAAU,EAAE,kCAAkC;YAC9C,SAAS,EAAE,KAAK;YAChB,aAAa,EAAE,QAAQ;YACvB,iBAAiB,EAAE,QAAQ;YAC3B,gBAAgB,EAAE,MAAM;YACxB,kBAAkB,EAAE,mCAAmC;SACxD,CAAC;QAEF,qCAAgC,GAA2B;YACzD,OAAO,EAAE,+BAA+B;YAExC,OAAO,EAAE,+BAA+B;YACxC,kBAAkB,EAAE,mCAAmC;YACvD,KAAK,EAAE,0BAA0B;SAClC,CAAC;QAEF,oBAAe,GAAG,KAAK,EAAuB,CAAC;QAC/C,qBAAgB,GAAG,KAAK,CAAU,KAAK,CAAC,CAAC;QAEzC,aAAQ,GAAG,MAAM,EAAU,CAAC;QAC5B,iBAAY,GAAG,MAAM,EAAW,CAAC;KA+FlC;IAtIC,MAAM,CAAsB;IAE5B,aAAa,CAAe;IAE5B,SAAS,CAAS;IAClB,IAAI,QAAQ,CAAC,EAAW;QACtB,IAAI,EAAE,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YAC1B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;YACpB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC3B,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;IACH,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,2BAA2B,CASzB;IAEF,gCAAgC,CAM9B;IASF,MAAM,CAAC,KAAgB;QACrB,IAAI,IAAI,CAAC,gBAAgB,EAAE;YAAE,OAAO;QACpC,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,KAAK,CAAC,eAAe,EAAE,CAAC;QACxB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QAEtB,MAAM,YAAY,GAAwB,KAAK,CAAC,YAAY,CAAC;QAE7D,IAAI,YAAY,EAAE,CAAC;YACjB,IAAI,YAAY,EAAE,KAAK,EAAE,CAAC;gBACxB,MAAM,KAAK,GAAW,EAAE,CAAC;gBACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACnD,6CAA6C;oBAC7C,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;wBAC1C,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;wBAC/C,IAAI,IAAI;4BAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC7B,CAAC;gBACH,CAAC;gBACD,YAAY,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;gBAC3B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC5B,CAAC;iBAAM,CAAC;gBACN,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC;gBACjC,YAAY,CAAC,SAAS,EAAE,CAAC;gBACzB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YACxC,CAAC;QACH,CAAC;IACH,CAAC;IAGD,UAAU,CAAC,KAAgB;QACzB,IAAI,IAAI,CAAC,gBAAgB,EAAE;YAAE,OAAO;QACpC,KAAK,CAAC,eAAe,EAAE,CAAC;QACxB,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACvB,CAAC;IAGD,WAAW,CAAC,KAAgB;QAC1B,IAAI,IAAI,CAAC,gBAAgB,EAAE;YAAE,OAAO;QACpC,IAAK,KAAK,CAAC,MAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;YAChG,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACxB,CAAC;IACH,CAAC;IAGD,cAAc,CAAC,KAAgB;QAC7B,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,KAAK,CAAC,eAAe,EAAE,CAAC;IAC1B,CAAC;IAED,UAAU,CAAC,KAAgB;QACzB,KAAK,CAAC,cAAc,EAAE,CAAC;IACzB,CAAC;IAED,YAAY;QACV,MAAM,EAAE,GAAgB,IAAI,CAAC,MAAM,CAAC,aAA4B,CAAC;QAEjE,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,EAAE,CAAC,KAAK,CAAC,QAAQ,GAAG,SAAS,CAAC;YAC9B,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;YAC5B,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QACjC,CAAC;QACD,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,EAAE,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC;YAC/B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAChD,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED,mBAAmB;QACjB,MAAM,YAAY,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACnD,YAAY,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QAC9C,YAAY,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC;QACzC,YAAY,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC;QAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,EAAE,WAAW,IAAI,IAAI,CAAC,2BAA2B,CAAC;QACvF,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAS,EAAE,EAAE;YACvC,YAAY,CAAC,KAAa,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,EAAE,KAAK,CAAC;QAC5C,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,iBAAiB,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YACxD,iBAAiB,CAAC,SAAS,GAAG,KAAK,CAAC;YACpC,MAAM,WAAW,GAAG,IAAI,CAAC,eAAe,EAAE,EAAE,gBAAgB,IAAI,IAAI,CAAC,gCAAgC,CAAC;YACtG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,CAAS,EAAE,EAAE;gBAC5C,iBAAiB,CAAC,KAAa,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;YACvD,CAAC,CAAC,CAAC;YACH,iBAAiB,CAAC,KAAK,CAAC,aAAa,GAAG,MAAM,CAAC;YAC/C,YAAY,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;QACzC,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;+GAtIU,qBAAqB;mGAArB,qBAAqB;;4FAArB,qBAAqB;kBAJjC,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,UAAU,EAAE,IAAI;iBACjB;8BA4CC,MAAM;sBADL,YAAY;uBAAC,MAAM,EAAE,CAAC,QAAQ,CAAC;gBA8BhC,UAAU;sBADT,YAAY;uBAAC,UAAU,EAAE,CAAC,QAAQ,CAAC;gBASpC,WAAW;sBADV,YAAY;uBAAC,WAAW,EAAE,CAAC,QAAQ,CAAC;gBASrC,cAAc;sBADb,YAAY;uBAAC,eAAe,EAAE,CAAC,QAAQ,CAAC;gBAMzC,UAAU;sBADT,YAAY;uBAAC,WAAW,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["import { Directive, ElementRef, HostListener, inject, input, output } from '@angular/core';\nimport { Utils } from '@yuuvis/client-core';\nimport { FileDropZoneOptions } from './file-drop-zone.interface';\n\n@Directive({\n  selector: '[yuvFileDropZone]',\n  standalone: true\n})\nexport class FileDropZoneDirective {\n  #elRef = inject(ElementRef);\n\n  #coverElement?: HTMLElement;\n\n  #fileOver = false;\n  set fileOver(fo: boolean) {\n    if (fo !== this.#fileOver) {\n      this.#fileOver = fo;\n      this.fileDropOver.emit(fo);\n      this.#toggleCover();\n    }\n  }\n  get fileOver() {\n    return this.#fileOver;\n  }\n\n  #defaultDragOverCoverStyles: Record<string, string> = {\n    outline: '2px dashed var(--color-accent)',\n    display: 'flex',\n    transition: 'background-color .3s ease-in-out',\n    'z-index': '500',\n    'align-items': 'center',\n    'justify-content': 'center',\n    'outline-offset': '-2px',\n    'background-color': 'rgba(var(--color-accent-rgb), .5)'\n  };\n\n  #defaultDragOverCoverLabelStyles: Record<string, string> = {\n    outline: '1px solid var(--color-accent)',\n\n    padding: 'var(--app-pane-padding, 16px)',\n    'background-color': 'rgba(var(--color-accent-rgb), .9)',\n    color: 'var(--color-accent-tone)'\n  };\n\n  yuvFileDropZone = input<FileDropZoneOptions>();\n  fileDropDisabled = input<boolean>(false);\n\n  fileDrop = output<File[]>();\n  fileDropOver = output<boolean>();\n\n  @HostListener('drop', ['$event'])\n  onDrop(event: DragEvent) {\n    if (this.fileDropDisabled()) return;\n    event.preventDefault();\n    event.stopPropagation();\n    this.fileOver = false;\n\n    const dataTransfer: DataTransfer | null = event.dataTransfer;\n\n    if (dataTransfer) {\n      if (dataTransfer?.items) {\n        const files: File[] = [];\n        for (let i = 0; i < dataTransfer.items.length; i++) {\n          // If dropped items aren't files, reject them\n          if (dataTransfer.items[i].kind === 'file') {\n            const file = dataTransfer.items[i].getAsFile();\n            if (file) files.push(file);\n          }\n        }\n        dataTransfer.items.clear();\n        this.fileDrop.emit(files);\n      } else {\n        const files = dataTransfer.files;\n        dataTransfer.clearData();\n        this.fileDrop.emit(Array.from(files));\n      }\n    }\n  }\n\n  @HostListener('dragover', ['$event'])\n  onDragOver(event: DragEvent) {\n    if (this.fileDropDisabled()) return;\n    event.stopPropagation();\n    event.preventDefault();\n    this.fileOver = true;\n  }\n\n  @HostListener('dragleave', ['$event'])\n  onDragLeave(event: DragEvent) {\n    if (this.fileDropDisabled()) return;\n    if ((event.target as HTMLElement).getAttribute('id') === this.#coverElement?.getAttribute('id')) {\n      this.fileOver = false;\n    }\n  }\n\n  @HostListener('body:dragover', ['$event'])\n  onBodyDragOver(event: DragEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n  }\n  @HostListener('body:drop', ['$event'])\n  onBodyDrop(event: DragEvent) {\n    event.preventDefault();\n  }\n\n  #toggleCover() {\n    const el: HTMLElement = this.#elRef.nativeElement as HTMLElement;\n\n    if (this.#coverElement) {\n      el.style.position = 'initial';\n      this.#coverElement.remove();\n      this.#coverElement = undefined;\n    }\n    if (this.#fileOver) {\n      el.style.position = 'relative';\n      this.#coverElement = this.#createCoverElement();\n      el.append(this.#coverElement);\n    }\n  }\n\n  #createCoverElement(): HTMLElement {\n    const coverElement = document.createElement('div');\n    coverElement.setAttribute('id', Utils.uuid());\n    coverElement.style.position = 'absolute';\n    coverElement.style.inset = '0';\n    const styles = this.yuvFileDropZone()?.coverStyles || this.#defaultDragOverCoverStyles;\n    Object.keys(styles).forEach((k: string) => {\n      (coverElement.style as any)[k] = styles[k];\n    });\n\n    const label = this.yuvFileDropZone()?.label;\n    if (label) {\n      const coverLabelElement = document.createElement('div');\n      coverLabelElement.innerText = label;\n      const labelStyles = this.yuvFileDropZone()?.coverLabelStyles || this.#defaultDragOverCoverLabelStyles;\n      Object.keys(labelStyles).forEach((k: string) => {\n        (coverLabelElement.style as any)[k] = labelStyles[k];\n      });\n      coverLabelElement.style.pointerEvents = 'none';\n      coverElement.append(coverLabelElement);\n    }\n    return coverElement;\n  }\n}\n"]}

package/esm2022/common/lib/directives/file-drop-zone/file-drop-zone.interface.mjs

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

package/esm2022/common/lib/directives/focus-within.directive.mjs

@@ -0,0 +1,81 @@
+import { Directive, ElementRef, EventEmitter, HostBinding, HostListener, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive keeping track of the focus beeing within a component. Once the component or
+ * any of its child components gain focus, a class of `focusWithin` will be set on the
+ * host component in order to allow styling it while beeing focused. Furthermore you can
+ * register callbacks once the component gets or looses focus.
+ *
+ * @example
+ * // just set the css class
+ * <some-component yuvFocusWithin></some-component>
+ * // set the css class and listen to focus changes
+ * <some-component (yuvFocusWithin)="onFocusEnter()" (yuvFocusWithinBlur)="onFocusLeave()"></some-component>
+ */
+export class FocusWithinDirective {
+    onFocusIn(evt) {
+        const hadFocusWithin = this.hasFocusWithin;
+        this.hasFocusWithin = this.matchesFocusWithin();
+        if (!hadFocusWithin && this.hasFocusWithin) {
+            this.yuvFocusWithin.emit();
+        }
+    }
+    onFocusOut(evt) {
+        const hadFocusWithin = this.hasFocusWithin;
+        this.hasFocusWithin = this.matchesFocusWithin();
+        if (hadFocusWithin && !this.hasFocusWithin) {
+            this.yuvFocusWithinBlur.emit();
+        }
+    }
+    /**
+     * @ignore
+     */
+    constructor(elRef) {
+        this.elRef = elRef;
+        this.eventCount = 0;
+        this.hasFocusWithin = false;
+        /**
+         * Emitted once the component or any of its child components gains focus.
+         */
+        this.yuvFocusWithin = new EventEmitter();
+        /**
+         * Emitted once the component (incl. any of its child components) looses focus.
+         */
+        this.yuvFocusWithinBlur = new EventEmitter();
+    }
+    // Determine if the given node matches the given selector.
+    // @see: https://www.bennadel.com/blog/3476-checking-to-see-if-an-element-has-a-css-pseudo-class-in-javascript.htm
+    matchesFocusWithin() {
+        const node = this.elRef.nativeElement;
+        var nativeMatches = node.matches || node.msMatchesSelector;
+        try {
+            return nativeMatches.call(node, ':focus-within');
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FocusWithinDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FocusWithinDirective, isStandalone: true, selector: "[yuvFocusWithin]", outputs: { yuvFocusWithin: "yuvFocusWithin", yuvFocusWithinBlur: "yuvFocusWithinBlur" }, host: { listeners: { "focusin": "onFocusIn($event)", "focusout": "onFocusOut($event)" }, properties: { "class.focusWithin": "this.hasFocusWithin" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FocusWithinDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[yuvFocusWithin]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { hasFocusWithin: [{
+                type: HostBinding,
+                args: ['class.focusWithin']
+            }], onFocusIn: [{
+                type: HostListener,
+                args: ['focusin', ['$event']]
+            }], onFocusOut: [{
+                type: HostListener,
+                args: ['focusout', ['$event']]
+            }], yuvFocusWithin: [{
+                type: Output
+            }], yuvFocusWithinBlur: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/lib/directives/index.mjs

@@ -0,0 +1,9 @@
+export * from './busy-overlay.directive';
+export * from './focus-within.directive';
+export * from './file-drop-zone/file-drop-zone.directive';
+export * from './click-double.directive';
+export * from './light-dismiss.directive';
+export * from './container-size.directive';
+export * from './longpress.directive';
+export * from './drag-select.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3l1dXZpcy9jbGllbnQtZnJhbWV3b3JrL2NvbW1vbi9zcmMvbGliL2RpcmVjdGl2ZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9idXN5LW92ZXJsYXkuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9jdXMtd2l0aGluLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbGUtZHJvcC16b25lL2ZpbGUtZHJvcC16b25lLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2NsaWNrLWRvdWJsZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWdodC1kaXNtaXNzLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRhaW5lci1zaXplLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xvbmdwcmVzcy5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLXNlbGVjdC5kaXJlY3RpdmUnO1xuIl19

package/esm2022/common/lib/directives/light-dismiss.directive.mjs

@@ -0,0 +1,44 @@
+import { Directive, ElementRef, HostListener, inject, output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive for applying light dismiss actions. Adding this directive will trigger
+ * the given function when the user clicks outside the component or hits escape.
+ *
+ * ```ts
+ * <div class="notifications" (yuvLightDismiss)="close()">
+ *   ...
+ * </div>
+ * ```
+ */
+export class LightDismissDirective {
+    constructor() {
+        this.elRef = inject(ElementRef);
+        this.yuvLightDismiss = output();
+    }
+    onKeydownHandler(event) {
+        if (!event.defaultPrevented) {
+            this.yuvLightDismiss.emit();
+        }
+    }
+    onMousedown(event) {
+        if (!this.elRef.nativeElement.contains(event.target)) {
+            this.yuvLightDismiss.emit();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LightDismissDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LightDismissDirective, isStandalone: true, selector: "[yuvLightDismiss]", outputs: { yuvLightDismiss: "yuvLightDismiss" }, host: { listeners: { "document:keydown.escape": "onKeydownHandler($event)", "document:mousedown": "onMousedown($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LightDismissDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[yuvLightDismiss]',
+                    standalone: true
+                }]
+        }], propDecorators: { onKeydownHandler: [{
+                type: HostListener,
+                args: ['document:keydown.escape', ['$event']]
+            }], onMousedown: [{
+                type: HostListener,
+                args: ['document:mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/lib/directives/longpress.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, ElementRef, inject, input, output } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { fromEvent, merge, of, timer } from 'rxjs';
+import { filter, map, switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class LongPressDirective {
+    constructor() {
+        this.elRef = inject(ElementRef);
+        this.threshold = 500;
+        this.yuvLongPress = input({
+            enabled: false
+        });
+        this.longpress = output();
+        const mousedown = fromEvent(this.elRef.nativeElement, 'mousedown').pipe(takeUntilDestroyed(), filter((event) => event.button == 0), // Only allow left button (Primary button)
+        map(() => true) // turn on threshold counter
+        );
+        const touchstart = fromEvent(this.elRef.nativeElement, 'touchstart').pipe(takeUntilDestroyed(), map(() => true));
+        const touchEnd = fromEvent(this.elRef.nativeElement, 'touchend').pipe(takeUntilDestroyed(), map(() => false));
+        const mouseup = fromEvent(window, 'mouseup').pipe(takeUntilDestroyed(), filter((event) => event.button == 0), // Only allow left button (Primary button)
+        map(() => false) // reset threshold counter
+        );
+        merge(mousedown, mouseup, touchstart, touchEnd)
+            .pipe(takeUntilDestroyed(), switchMap((state) => (state ? timer(this.threshold, 100) : of(null))), filter((value) => !!value))
+            .subscribe(() => this.longpress.emit());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LongPressDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: LongPressDirective, isStandalone: true, selector: "[yuvLongPress]", inputs: { yuvLongPress: { classPropertyName: "yuvLongPress", publicName: "yuvLongPress", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { longpress: "longpress" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LongPressDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[yuvLongPress]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/lib/directives/noop-value-accessor.directive.mjs

@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { Directive, forwardRef, inject } from '@angular/core';
+import { FormControlDirective, FormControlName, NG_VALUE_ACCESSOR, NgControl, NgModel } from '@angular/forms';
+import * as i0 from "@angular/core";
+// @see: https://netbasal.com/forwarding-form-controls-to-custom-control-components-in-angular-701e8406cc55
+export class NoopValueAccessorDirective {
+    writeValue(obj) { }
+    registerOnChange(fn) { }
+    registerOnTouched(fn) { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NoopValueAccessorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: NoopValueAccessorDirective, isStandalone: true, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                multi: true,
+                useExisting: forwardRef(() => NoopValueAccessorDirective),
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NoopValueAccessorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            multi: true,
+                            useExisting: forwardRef(() => NoopValueAccessorDirective),
+                        },
+                    ],
+                }]
+        }] });
+export function injectNgControl() {
+    const ngControl = inject(NgControl, { self: true, optional: true });
+    if (!ngControl)
+        throw new Error('...');
+    if (ngControl instanceof FormControlDirective || ngControl instanceof FormControlName || ngControl instanceof NgModel) {
+        return ngControl;
+    }
+    throw new Error('...');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/yuuvis-client-framework-common.mjs

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

package/esm2022/forms/index.mjs

@@ -0,0 +1,19 @@
+export { CatalogComponent } from './lib/elements/catalog/catalog.component';
+// export { CheckboxComponent } from './lib/elements/checkbox/checkbox.component';
+export { DatetimeRangeComponent } from './lib/elements/datetime-range/datetime-range.component';
+// export { DatepickerComponent } from './lib/elements/datetime/datepicker/datepicker.component';
+export { DatetimeComponent } from './lib/elements/datetime/datetime.component';
+// export { YearRangeDirective } from './lib/elements/datetime/year-range/year-range.directive';
+// export { DynamicCatalogManagementComponent } from './lib/elements/dynamic-catalog/dynamic-catalog-management/dynamic-catalog-management.component';
+// export { DynamicCatalogComponent } from './lib/elements/dynamic-catalog/dynamic-catalog.component';
+export { NumberRangeComponent } from './lib/elements/number-range/number-range.component';
+export { NumberComponent } from './lib/elements/number/number.component';
+// export { OrganizationSetComponent } from './lib/elements/organization-set/organization-set.component';
+export { OrganizationComponent } from './lib/elements/organization/organization.component';
+// export { ReferenceItemComponent } from './lib/elements/reference/reference-item/reference-item.component';
+// export { ReferenceComponent } from './lib/elements/reference/reference.component';
+// export * from './lib/elements/reference/reference.interface';
+export { StringComponent } from './lib/elements/string/string.component';
+export { FormInputComponent } from './lib/form-input/form-input.component';
+export * from './lib/forms.module';
+//# sourceMappingURL=data:application/json;base64,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