@deenruv/admin-ui 1.0.0

package/esm2022/core/shared/components/dropdown/dropdown-menu.component.mjs

@@ -0,0 +1,202 @@
+import { TemplatePortal } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, Component, HostListener, Input, ViewChild, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "./dropdown.component";
+import * as i3 from "../../../providers/localization/localization.service";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/cdk/bidi";
+import * as i6 from "@angular/cdk/a11y";
+/**
+ * A dropdown menu modelled on the Clarity Dropdown component (https://v1.clarity.design/dropdowns).
+ *
+ * This was created because the Clarity implementation (at this time) does not handle edge detection. Instead
+ * we make use of the Angular CDK's Overlay module to manage the positioning.
+ *
+ * The API of this component (and its related Components & Directives) are based on the Clarity version,
+ * albeit only a subset which is currently used in this application.
+ */
+export class DropdownMenuComponent {
+    onEscapeKeydown(event) {
+        if (this.dropdown.isOpen) {
+            if (this.overlayRef.overlayElement.contains(document.activeElement)) {
+                this.dropdown.toggleOpen();
+            }
+        }
+    }
+    onArrowKey(event) {
+        if (this.dropdown.isOpen &&
+            document.activeElement instanceof HTMLElement &&
+            (event.key === 'ArrowDown' || event.key === 'ArrowUp')) {
+            const dropdownItems = Array.from(this.overlayRef.overlayElement.querySelectorAll('.dropdown-item'));
+            const currentIndex = dropdownItems.indexOf(document.activeElement);
+            if (currentIndex === -1) {
+                return;
+            }
+            if (event.key === 'ArrowDown') {
+                const nextItem = dropdownItems[(currentIndex + 1) % dropdownItems.length];
+                nextItem.focus();
+            }
+            if (event.key === 'ArrowUp') {
+                const previousItem = dropdownItems[(currentIndex - 1 + dropdownItems.length) % dropdownItems.length];
+                previousItem.focus();
+            }
+        }
+    }
+    constructor(overlay, viewContainerRef, dropdown, localizationService, changeDetector) {
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.dropdown = dropdown;
+        this.localizationService = localizationService;
+        this.changeDetector = changeDetector;
+        this.position = 'bottom-left';
+        this.resizeObserver = new ResizeObserver(entries => {
+            const margin = 12;
+            for (const entry of entries) {
+                const contentWrapper = entry.target.querySelector('.dropdown-content-wrapper');
+                if (contentWrapper) {
+                    const { bottom, top } = contentWrapper?.getBoundingClientRect();
+                    if (bottom > window.innerHeight - margin) {
+                        // dropdown is going off the bottom of the screen
+                        this.maxHeight = window.innerHeight - top - margin;
+                        this.changeDetector.markForCheck();
+                    }
+                    if (top < margin) {
+                        // dropdown is going off the top of the screen
+                        this.maxHeight = bottom - margin;
+                        this.changeDetector.markForCheck();
+                    }
+                }
+            }
+        });
+    }
+    ngOnInit() {
+        this.direction$ = this.localizationService.direction$;
+        this.dropdown.onOpenChange(isOpen => {
+            if (isOpen) {
+                this.overlayRef.attach(this.menuPortal);
+                this.resizeObserver.observe(this.overlayRef.overlayElement);
+            }
+            else {
+                this.overlayRef.detach();
+                this.resizeObserver.unobserve(this.overlayRef.overlayElement);
+                this.maxHeight = undefined;
+            }
+        });
+    }
+    ngAfterViewInit() {
+        this.overlayRef = this.overlay.create({
+            hasBackdrop: true,
+            backdropClass: 'clear-backdrop',
+            positionStrategy: this.getPositionStrategy(),
+            maxHeight: '70vh',
+        });
+        this.menuPortal = new TemplatePortal(this.menuTemplate, this.viewContainerRef);
+        this.backdropClickSub = this.overlayRef.backdropClick().subscribe(() => {
+            this.dropdown.toggleOpen();
+        });
+    }
+    ngOnDestroy() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+        }
+        if (this.backdropClickSub) {
+            this.backdropClickSub.unsubscribe();
+        }
+    }
+    getPositionStrategy() {
+        const position = {
+            ['top-left']: {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom',
+            },
+            ['top-right']: {
+                originX: 'end',
+                originY: 'top',
+                overlayX: 'end',
+                overlayY: 'bottom',
+            },
+            ['bottom-left']: {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top',
+            },
+            ['bottom-right']: {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+            },
+        };
+        const pos = position[this.position];
+        return this.overlay
+            .position()
+            .flexibleConnectedTo(this.dropdown.trigger)
+            .withPositions([pos, this.invertPosition(pos)])
+            .withViewportMargin(12)
+            .withPush(true);
+    }
+    /** Inverts an overlay position. */
+    invertPosition(pos) {
+        const inverted = { ...pos };
+        inverted.originY = pos.originY === 'top' ? 'bottom' : 'top';
+        inverted.overlayY = pos.overlayY === 'top' ? 'bottom' : 'top';
+        return inverted;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DropdownMenuComponent, deps: [{ token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i2.DropdownComponent }, { token: i3.LocalizationService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DropdownMenuComponent, selector: "vdr-dropdown-menu", inputs: { position: ["vdrPosition", "position"], customClasses: "customClasses" }, host: { listeners: { "window:keydown.escape": "onEscapeKeydown($event)", "window:keydown": "onArrowKey($event)" } }, viewQueries: [{ propertyName: "menuTemplate", first: true, predicate: ["menu"], descendants: true, static: true }], ngImport: i0, template: `
+        <ng-template #menu>
+            <div [dir]="direction$ | async">
+                <div class="dropdown open">
+                    <div class="dropdown-menu" [ngClass]="customClasses" [style.maxHeight.px]="maxHeight">
+                        <div
+                            class="dropdown-content-wrapper"
+                            [cdkTrapFocus]="true"
+                            [cdkTrapFocusAutoCapture]="true"
+                        >
+                            <ng-content></ng-content>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </ng-template>
+    `, isInline: true, styles: [".clear-backdrop{background-color:#ff69b4}::ng-deep .dropdown-menu{max-width:initial}::ng-deep .dropdown-menu .dropdown-item{display:flex;align-items:center;padding:3px 24px}::ng-deep .dropdown-menu .dropdown-item clr-icon{margin-inline-end:3px}::ng-deep .dropdown-menu .dropdown-item:focus{outline:var(--color-dropdown-item-focus-outline) solid 1px;outline-offset:1px 0}.dropdown.open>.dropdown-menu{position:relative;top:0;height:100%;overflow-y:auto}:host{opacity:1;transition:opacity .3s}\n"], dependencies: [{ kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.Dir, selector: "[dir]", inputs: ["dir"], outputs: ["dirChange"], exportAs: ["dir"] }, { kind: "directive", type: i6.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DropdownMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-dropdown-menu', template: `
+        <ng-template #menu>
+            <div [dir]="direction$ | async">
+                <div class="dropdown open">
+                    <div class="dropdown-menu" [ngClass]="customClasses" [style.maxHeight.px]="maxHeight">
+                        <div
+                            class="dropdown-content-wrapper"
+                            [cdkTrapFocus]="true"
+                            [cdkTrapFocusAutoCapture]="true"
+                        >
+                            <ng-content></ng-content>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </ng-template>
+    `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".clear-backdrop{background-color:#ff69b4}::ng-deep .dropdown-menu{max-width:initial}::ng-deep .dropdown-menu .dropdown-item{display:flex;align-items:center;padding:3px 24px}::ng-deep .dropdown-menu .dropdown-item clr-icon{margin-inline-end:3px}::ng-deep .dropdown-menu .dropdown-item:focus{outline:var(--color-dropdown-item-focus-outline) solid 1px;outline-offset:1px 0}.dropdown.open>.dropdown-menu{position:relative;top:0;height:100%;overflow-y:auto}:host{opacity:1;transition:opacity .3s}\n"] }]
+        }], ctorParameters: () => [{ type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i2.DropdownComponent }, { type: i3.LocalizationService }, { type: i0.ChangeDetectorRef }], propDecorators: { position: [{
+                type: Input,
+                args: ['vdrPosition']
+            }], customClasses: [{
+                type: Input
+            }], menuTemplate: [{
+                type: ViewChild,
+                args: ['menu', { static: true }]
+            }], onEscapeKeydown: [{
+                type: HostListener,
+                args: ['window:keydown.escape', ['$event']]
+            }], onArrowKey: [{
+                type: HostListener,
+                args: ['window:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown-menu.component.js","sourceRoot":"","sources":["../../../../../../src/lib/core/src/shared/components/dropdown/dropdown-menu.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ConnectedPosition, Overlay, OverlayRef, PositionStrategy } from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport {\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    HostListener,\n    Input,\n    OnDestroy,\n    OnInit,\n    TemplateRef,\n    ViewChild,\n    ViewContainerRef,\n} from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport {\n    LocalizationDirectionType,\n    LocalizationService,\n} from '../../../providers/localization/localization.service';\nimport { DropdownComponent } from './dropdown.component';\n\nexport type DropdownPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';\n\n/**\n * A dropdown menu modelled on the Clarity Dropdown component (https://v1.clarity.design/dropdowns).\n *\n * This was created because the Clarity implementation (at this time) does not handle edge detection. Instead\n * we make use of the Angular CDK's Overlay module to manage the positioning.\n *\n * The API of this component (and its related Components & Directives) are based on the Clarity version,\n * albeit only a subset which is currently used in this application.\n */\n@Component({\n    selector: 'vdr-dropdown-menu',\n    template: `\n        <ng-template #menu>\n            <div [dir]=\"direction$ | async\">\n                <div class=\"dropdown open\">\n                    <div class=\"dropdown-menu\" [ngClass]=\"customClasses\" [style.maxHeight.px]=\"maxHeight\">\n                        <div\n                            class=\"dropdown-content-wrapper\"\n                            [cdkTrapFocus]=\"true\"\n                            [cdkTrapFocusAutoCapture]=\"true\"\n                        >\n                            <ng-content></ng-content>\n                        </div>\n                    </div>\n                </div>\n            </div>\n        </ng-template>\n    `,\n    styleUrls: ['./dropdown-menu.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class DropdownMenuComponent implements AfterViewInit, OnInit, OnDestroy {\n    direction$: LocalizationDirectionType;\n\n    @Input('vdrPosition') private position: DropdownPosition = 'bottom-left';\n    @Input() customClasses: string;\n    @ViewChild('menu', { static: true }) private menuTemplate: TemplateRef<any>;\n    private menuPortal: TemplatePortal;\n    private overlayRef: OverlayRef;\n    private backdropClickSub: Subscription;\n    protected maxHeight: number | undefined;\n\n    private resizeObserver = new ResizeObserver(entries => {\n        const margin = 12;\n        for (const entry of entries) {\n            const contentWrapper = entry.target.querySelector('.dropdown-content-wrapper');\n            if (contentWrapper) {\n                const { bottom, top } = contentWrapper?.getBoundingClientRect();\n                if (bottom > window.innerHeight - margin) {\n                    // dropdown is going off the bottom of the screen\n                    this.maxHeight = window.innerHeight - top - margin;\n                    this.changeDetector.markForCheck();\n                }\n                if (top < margin) {\n                    // dropdown is going off the top of the screen\n                    this.maxHeight = bottom - margin;\n                    this.changeDetector.markForCheck();\n                }\n            }\n        }\n    });\n\n    @HostListener('window:keydown.escape', ['$event'])\n    onEscapeKeydown(event: KeyboardEvent) {\n        if (this.dropdown.isOpen) {\n            if (this.overlayRef.overlayElement.contains(document.activeElement)) {\n                this.dropdown.toggleOpen();\n            }\n        }\n    }\n\n    @HostListener('window:keydown', ['$event'])\n    onArrowKey(event: KeyboardEvent) {\n        if (\n            this.dropdown.isOpen &&\n            document.activeElement instanceof HTMLElement &&\n            (event.key === 'ArrowDown' || event.key === 'ArrowUp')\n        ) {\n            const dropdownItems = Array.from(\n                this.overlayRef.overlayElement.querySelectorAll<HTMLElement>('.dropdown-item'),\n            );\n            const currentIndex = dropdownItems.indexOf(document.activeElement);\n            if (currentIndex === -1) {\n                return;\n            }\n            if (event.key === 'ArrowDown') {\n                const nextItem = dropdownItems[(currentIndex + 1) % dropdownItems.length];\n                nextItem.focus();\n            }\n            if (event.key === 'ArrowUp') {\n                const previousItem =\n                    dropdownItems[(currentIndex - 1 + dropdownItems.length) % dropdownItems.length];\n                previousItem.focus();\n            }\n        }\n    }\n\n    constructor(\n        private overlay: Overlay,\n        private viewContainerRef: ViewContainerRef,\n        private dropdown: DropdownComponent,\n        private localizationService: LocalizationService,\n        private changeDetector: ChangeDetectorRef,\n    ) {}\n\n    ngOnInit(): void {\n        this.direction$ = this.localizationService.direction$;\n\n        this.dropdown.onOpenChange(isOpen => {\n            if (isOpen) {\n                this.overlayRef.attach(this.menuPortal);\n                this.resizeObserver.observe(this.overlayRef.overlayElement);\n            } else {\n                this.overlayRef.detach();\n                this.resizeObserver.unobserve(this.overlayRef.overlayElement);\n                this.maxHeight = undefined;\n            }\n        });\n    }\n\n    ngAfterViewInit() {\n        this.overlayRef = this.overlay.create({\n            hasBackdrop: true,\n            backdropClass: 'clear-backdrop',\n            positionStrategy: this.getPositionStrategy(),\n            maxHeight: '70vh',\n        });\n\n        this.menuPortal = new TemplatePortal(this.menuTemplate, this.viewContainerRef);\n        this.backdropClickSub = this.overlayRef.backdropClick().subscribe(() => {\n            this.dropdown.toggleOpen();\n        });\n    }\n\n    ngOnDestroy(): void {\n        if (this.overlayRef) {\n            this.overlayRef.dispose();\n        }\n        if (this.backdropClickSub) {\n            this.backdropClickSub.unsubscribe();\n        }\n    }\n\n    private getPositionStrategy(): PositionStrategy {\n        const position: { [K in DropdownPosition]: ConnectedPosition } = {\n            ['top-left']: {\n                originX: 'start',\n                originY: 'top',\n                overlayX: 'start',\n                overlayY: 'bottom',\n            },\n            ['top-right']: {\n                originX: 'end',\n                originY: 'top',\n                overlayX: 'end',\n                overlayY: 'bottom',\n            },\n            ['bottom-left']: {\n                originX: 'start',\n                originY: 'bottom',\n                overlayX: 'start',\n                overlayY: 'top',\n            },\n            ['bottom-right']: {\n                originX: 'end',\n                originY: 'bottom',\n                overlayX: 'end',\n                overlayY: 'top',\n            },\n        };\n\n        const pos = position[this.position];\n\n        return this.overlay\n            .position()\n            .flexibleConnectedTo(this.dropdown.trigger)\n            .withPositions([pos, this.invertPosition(pos)])\n            .withViewportMargin(12)\n            .withPush(true);\n    }\n\n    /** Inverts an overlay position. */\n    private invertPosition(pos: ConnectedPosition): ConnectedPosition {\n        const inverted = { ...pos };\n        inverted.originY = pos.originY === 'top' ? 'bottom' : 'top';\n        inverted.overlayY = pos.overlayY === 'top' ? 'bottom' : 'top';\n\n        return inverted;\n    }\n}\n"]}

package/esm2022/core/shared/components/dropdown/dropdown-trigger.directive.mjs

@@ -0,0 +1,25 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./dropdown.component";
+export class DropdownTriggerDirective {
+    constructor(dropdown, elementRef) {
+        this.dropdown = dropdown;
+        this.elementRef = elementRef;
+        dropdown.setTriggerElement(this.elementRef);
+    }
+    onDropdownTriggerClick(event) {
+        this.dropdown.toggleOpen();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DropdownTriggerDirective, deps: [{ token: i1.DropdownComponent }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: DropdownTriggerDirective, selector: "[vdrDropdownTrigger]", host: { listeners: { "click": "onDropdownTriggerClick($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DropdownTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vdrDropdownTrigger]',
+                }]
+        }], ctorParameters: () => [{ type: i1.DropdownComponent }, { type: i0.ElementRef }], propDecorators: { onDropdownTriggerClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24tdHJpZ2dlci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL2Ryb3Bkb3duL2Ryb3Bkb3duLXRyaWdnZXIuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWMsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFPcEUsTUFBTSxPQUFPLHdCQUF3QjtJQUNqQyxZQUFvQixRQUEyQixFQUFVLFVBQXNCO1FBQTNELGFBQVEsR0FBUixRQUFRLENBQW1CO1FBQVUsZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUMzRSxRQUFRLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQ2hELENBQUM7SUFHRCxzQkFBc0IsQ0FBQyxLQUFVO1FBQzdCLElBQUksQ0FBQyxRQUFRLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDL0IsQ0FBQzsrR0FSUSx3QkFBd0I7bUdBQXhCLHdCQUF3Qjs7NEZBQXhCLHdCQUF3QjtrQkFIcEMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsc0JBQXNCO2lCQUNuQzsrR0FPRyxzQkFBc0I7c0JBRHJCLFlBQVk7dUJBQUMsT0FBTyxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBIb3N0TGlzdGVuZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgRHJvcGRvd25Db21wb25lbnQgfSBmcm9tICcuL2Ryb3Bkb3duLmNvbXBvbmVudCc7XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnW3ZkckRyb3Bkb3duVHJpZ2dlcl0nLFxufSlcbmV4cG9ydCBjbGFzcyBEcm9wZG93blRyaWdnZXJEaXJlY3RpdmUge1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgZHJvcGRvd246IERyb3Bkb3duQ29tcG9uZW50LCBwcml2YXRlIGVsZW1lbnRSZWY6IEVsZW1lbnRSZWYpIHtcbiAgICAgICAgZHJvcGRvd24uc2V0VHJpZ2dlckVsZW1lbnQodGhpcy5lbGVtZW50UmVmKTtcbiAgICB9XG5cbiAgICBASG9zdExpc3RlbmVyKCdjbGljaycsIFsnJGV2ZW50J10pXG4gICAgb25Ecm9wZG93blRyaWdnZXJDbGljayhldmVudDogYW55KTogdm9pZCB7XG4gICAgICAgIHRoaXMuZHJvcGRvd24udG9nZ2xlT3BlbigpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/core/shared/components/dropdown/dropdown.component.mjs

@@ -0,0 +1,58 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * Used for building dropdown menus.
+ *
+ * @example
+ * ```HTML
+ * <vdr-dropdown>
+ *   <button class="btn btn-outline" vdrDropdownTrigger>
+ *       <clr-icon shape="plus"></clr-icon>
+ *       Select type
+ *   </button>
+ *   <vdr-dropdown-menu vdrPosition="bottom-left">
+ *     <button
+ *       *ngFor="let typeName of allTypes"
+ *       type="button"
+ *       vdrDropdownItem
+ *       (click)="selectType(typeName)"
+ *     >
+ *       typeName
+ *     </button>
+ *   </vdr-dropdown-menu>
+ * </vdr-dropdown>
+ * ```
+ * @docsCategory components
+ */
+export class DropdownComponent {
+    constructor() {
+        this.isOpen = false;
+        this.onOpenChangeCallbacks = [];
+        this.manualToggle = false;
+    }
+    onClick() {
+        if (!this.manualToggle) {
+            this.toggleOpen();
+        }
+    }
+    toggleOpen() {
+        this.isOpen = !this.isOpen;
+        this.onOpenChangeCallbacks.forEach(fn => fn(this.isOpen));
+    }
+    onOpenChange(callback) {
+        this.onOpenChangeCallbacks.push(callback);
+    }
+    setTriggerElement(elementRef) {
+        this.trigger = elementRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DropdownComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DropdownComponent, selector: "vdr-dropdown", inputs: { manualToggle: "manualToggle" }, ngImport: i0, template: "<ng-content></ng-content>\n", styles: [""], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-dropdown', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>\n" }]
+        }], propDecorators: { manualToggle: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb3JlL3NyYy9zaGFyZWQvY29tcG9uZW50cy9kcm9wZG93bi9kcm9wZG93bi5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL2Ryb3Bkb3duL2Ryb3Bkb3duLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQWMsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUV0Rjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBd0JHO0FBT0gsTUFBTSxPQUFPLGlCQUFpQjtJQU45QjtRQU9JLFdBQU0sR0FBRyxLQUFLLENBQUM7UUFDUCwwQkFBcUIsR0FBcUMsRUFBRSxDQUFDO1FBRTVELGlCQUFZLEdBQUcsS0FBSyxDQUFDO0tBb0JqQztJQWxCRyxPQUFPO1FBQ0gsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUNyQixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDdEIsQ0FBQztJQUNMLENBQUM7SUFFRCxVQUFVO1FBQ04sSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDM0IsSUFBSSxDQUFDLHFCQUFxQixDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRUQsWUFBWSxDQUFDLFFBQW1DO1FBQzVDLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVELGlCQUFpQixDQUFDLFVBQXNCO1FBQ3BDLElBQUksQ0FBQyxPQUFPLEdBQUcsVUFBVSxDQUFDO0lBQzlCLENBQUM7K0dBdkJRLGlCQUFpQjttR0FBakIsaUJBQWlCLDhGQ2pDOUIsNkJBQ0E7OzRGRGdDYSxpQkFBaUI7a0JBTjdCLFNBQVM7K0JBQ0ksY0FBYyxtQkFHUCx1QkFBdUIsQ0FBQyxNQUFNOzhCQU10QyxZQUFZO3NCQUFwQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgRWxlbWVudFJlZiwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBAZGVzY3JpcHRpb25cbiAqIFVzZWQgZm9yIGJ1aWxkaW5nIGRyb3Bkb3duIG1lbnVzLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGBIVE1MXG4gKiA8dmRyLWRyb3Bkb3duPlxuICogICA8YnV0dG9uIGNsYXNzPVwiYnRuIGJ0bi1vdXRsaW5lXCIgdmRyRHJvcGRvd25UcmlnZ2VyPlxuICogICAgICAgPGNsci1pY29uIHNoYXBlPVwicGx1c1wiPjwvY2xyLWljb24+XG4gKiAgICAgICBTZWxlY3QgdHlwZVxuICogICA8L2J1dHRvbj5cbiAqICAgPHZkci1kcm9wZG93bi1tZW51IHZkclBvc2l0aW9uPVwiYm90dG9tLWxlZnRcIj5cbiAqICAgICA8YnV0dG9uXG4gKiAgICAgICAqbmdGb3I9XCJsZXQgdHlwZU5hbWUgb2YgYWxsVHlwZXNcIlxuICogICAgICAgdHlwZT1cImJ1dHRvblwiXG4gKiAgICAgICB2ZHJEcm9wZG93bkl0ZW1cbiAqICAgICAgIChjbGljayk9XCJzZWxlY3RUeXBlKHR5cGVOYW1lKVwiXG4gKiAgICAgPlxuICogICAgICAgdHlwZU5hbWVcbiAqICAgICA8L2J1dHRvbj5cbiAqICAgPC92ZHItZHJvcGRvd24tbWVudT5cbiAqIDwvdmRyLWRyb3Bkb3duPlxuICogYGBgXG4gKiBAZG9jc0NhdGVnb3J5IGNvbXBvbmVudHNcbiAqL1xuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICd2ZHItZHJvcGRvd24nLFxuICAgIHRlbXBsYXRlVXJsOiAnLi9kcm9wZG93bi5jb21wb25lbnQuaHRtbCcsXG4gICAgc3R5bGVVcmxzOiBbJy4vZHJvcGRvd24uY29tcG9uZW50LnNjc3MnXSxcbiAgICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbn0pXG5leHBvcnQgY2xhc3MgRHJvcGRvd25Db21wb25lbnQge1xuICAgIGlzT3BlbiA9IGZhbHNlO1xuICAgIHByaXZhdGUgb25PcGVuQ2hhbmdlQ2FsbGJhY2tzOiBBcnJheTwoaXNPcGVuOiBib29sZWFuKSA9PiB2b2lkPiA9IFtdO1xuICAgIHB1YmxpYyB0cmlnZ2VyOiBFbGVtZW50UmVmO1xuICAgIEBJbnB1dCgpIG1hbnVhbFRvZ2dsZSA9IGZhbHNlO1xuXG4gICAgb25DbGljaygpIHtcbiAgICAgICAgaWYgKCF0aGlzLm1hbnVhbFRvZ2dsZSkge1xuICAgICAgICAgICAgdGhpcy50b2dnbGVPcGVuKCk7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICB0b2dnbGVPcGVuKCkge1xuICAgICAgICB0aGlzLmlzT3BlbiA9ICF0aGlzLmlzT3BlbjtcbiAgICAgICAgdGhpcy5vbk9wZW5DaGFuZ2VDYWxsYmFja3MuZm9yRWFjaChmbiA9PiBmbih0aGlzLmlzT3BlbikpO1xuICAgIH1cblxuICAgIG9uT3BlbkNoYW5nZShjYWxsYmFjazogKGlzT3BlbjogYm9vbGVhbikgPT4gdm9pZCkge1xuICAgICAgICB0aGlzLm9uT3BlbkNoYW5nZUNhbGxiYWNrcy5wdXNoKGNhbGxiYWNrKTtcbiAgICB9XG5cbiAgICBzZXRUcmlnZ2VyRWxlbWVudChlbGVtZW50UmVmOiBFbGVtZW50UmVmKSB7XG4gICAgICAgIHRoaXMudHJpZ2dlciA9IGVsZW1lbnRSZWY7XG4gICAgfVxufVxuIiwiPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxuIl19

package/esm2022/core/shared/components/duplicate-entity-dialog/duplicate-entity-dialog.component.mjs

@@ -0,0 +1,111 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { assertNever } from '@deenruv/common/lib/shared-utils';
+import { lastValueFrom } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { DuplicateEntityDocument, GetEntityDuplicatorsDocument, } from '../../../common/generated-types';
+import { configurableDefinitionToInstance, toConfigurableOperationInput, } from '../../../common/utilities/configurable-operation-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../data/providers/data.service";
+import * as i2 from "../../../providers/notification/notification.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "../configurable-input/configurable-input.component";
+import * as i6 from "../form-field/form-field-control.directive";
+import * as i7 from "../modal-dialog/dialog-buttons.directive";
+import * as i8 from "../modal-dialog/dialog-title.directive";
+import * as i9 from "@ngx-translate/core";
+export class DuplicateEntityDialogComponent {
+    constructor(dataService, notificationService, changeDetectorRef) {
+        this.dataService = dataService;
+        this.notificationService = notificationService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.formGroup = new FormControl({
+            code: '',
+            args: [],
+        });
+    }
+    ngOnInit() {
+        this.entityDuplicators$ = this.dataService
+            .query(GetEntityDuplicatorsDocument)
+            .mapSingle(data => data.entityDuplicators.filter(d => d.forEntities.includes(this.entityName)))
+            .pipe(tap(duplicators => {
+            if (0 < duplicators.length) {
+                this.setSelectedDuplicator(duplicators[0]);
+            }
+        }));
+    }
+    setSelectedDuplicator(duplicator) {
+        this.selectedDuplicator = duplicator;
+        this.duplicatorInstance = configurableDefinitionToInstance(this.selectedDuplicator);
+        this.formGroup.patchValue(this.duplicatorInstance);
+        this.changeDetectorRef.markForCheck();
+    }
+    async duplicate() {
+        const selectedDuplicator = this.selectedDuplicator;
+        const formValue = this.formGroup.value;
+        if (!selectedDuplicator || !formValue) {
+            return;
+        }
+        const duplicatorInput = toConfigurableOperationInput(this.duplicatorInstance, formValue);
+        const succeeded = [];
+        const failed = [];
+        for (const entity of this.entities) {
+            const { duplicateEntity } = await lastValueFrom(this.dataService.mutate(DuplicateEntityDocument, {
+                input: {
+                    entityId: entity.id,
+                    entityName: this.entityName,
+                    duplicatorInput,
+                },
+            }));
+            switch (duplicateEntity.__typename) {
+                case 'DuplicateEntitySuccess':
+                    succeeded.push(this.getEntityName(entity));
+                    break;
+                case 'DuplicateEntityError':
+                    failed.push({
+                        name: this.getEntityName(entity),
+                        message: duplicateEntity.duplicationError,
+                    });
+                    break;
+                case undefined:
+                    break;
+                default:
+                    assertNever(duplicateEntity);
+            }
+        }
+        if (0 < succeeded.length) {
+            this.notificationService.success(_('common.notify-duplicate-success'), {
+                count: succeeded.length,
+                names: succeeded.join(', '),
+            });
+        }
+        if (0 < failed.length) {
+            const failedCount = failed.length;
+            const maxNotices = 5;
+            const excess = failedCount - maxNotices;
+            for (let i = 0; i < Math.min(failedCount, maxNotices); i++) {
+                const failedItem = failed[i];
+                this.notificationService.error(_('common.notify-duplicate-error'), {
+                    name: failedItem.name,
+                    error: failedItem.message,
+                });
+            }
+            if (excess > 0) {
+                this.notificationService.error(_('common.notify-duplicate-error-excess'), { count: excess });
+            }
+        }
+        this.resolveWith(true);
+    }
+    cancel() {
+        this.resolveWith();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DuplicateEntityDialogComponent, deps: [{ token: i1.DataService }, { token: i2.NotificationService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DuplicateEntityDialogComponent, selector: "vdr-duplicate-entity-dialog", ngImport: i0, template: "<ng-template vdrDialogTitle>\n    {{ title || 'common.duplicate-entity' | translate }}\n</ng-template>\n<div class=\"\">\n    <ul>\n        <li *ngFor=\"let entity of entities\">\n            {{ getEntityName(entity) }}\n        </li>\n    </ul>\n    <ng-container *ngIf=\"entityDuplicators$ | async as duplicators\">\n        <select\n            name=\"\"\n            id=\"\"\n            *ngIf=\"1 < duplicators.length\"\n            class=\"mt-4\"\n            [ngModel]=\"selectedDuplicator\"\n            (ngModelChange)=\"setSelectedDuplicator($event)\"\n        >\n            <option *ngFor=\"let duplicator of duplicators\" [ngValue]=\"duplicator\">\n                {{ duplicator.description }} ({{ duplicator.code }})\n            </option>\n        </select>\n    </ng-container>\n    <ng-container *ngIf=\"selectedDuplicator as duplicator\">\n        <vdr-configurable-input\n            *ngIf=\"duplicator.args.length > 0\"\n            [hideDescription]=\"true\"\n            [operation]=\"duplicatorInstance\"\n            [operationDefinition]=\"duplicator\"\n            [removable]=\"false\"\n            [formControl]=\"formGroup\"\n        ></vdr-configurable-input>\n    </ng-container>\n</div>\n\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\n    <button type=\"submit\" (click)=\"duplicate()\" [disabled]=\"!selectedDuplicator\" class=\"btn btn-primary\">\n        {{ 'common.duplicate' | translate }}\n    </button>\n</ng-template>\n", styles: [""], dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i4.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i4.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: i5.ConfigurableInputComponent, selector: "vdr-configurable-input", inputs: ["operation", "operationDefinition", "readonly", "removable", "position", "hideDescription"], outputs: ["remove"] }, { kind: "directive", type: i6.FormFieldControlDirective, selector: "input, textarea, select, vdr-currency-input" }, { kind: "directive", type: i7.DialogButtonsDirective, selector: "[vdrDialogButtons]" }, { kind: "directive", type: i8.DialogTitleDirective, selector: "[vdrDialogTitle]" }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i9.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DuplicateEntityDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-duplicate-entity-dialog', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-template vdrDialogTitle>\n    {{ title || 'common.duplicate-entity' | translate }}\n</ng-template>\n<div class=\"\">\n    <ul>\n        <li *ngFor=\"let entity of entities\">\n            {{ getEntityName(entity) }}\n        </li>\n    </ul>\n    <ng-container *ngIf=\"entityDuplicators$ | async as duplicators\">\n        <select\n            name=\"\"\n            id=\"\"\n            *ngIf=\"1 < duplicators.length\"\n            class=\"mt-4\"\n            [ngModel]=\"selectedDuplicator\"\n            (ngModelChange)=\"setSelectedDuplicator($event)\"\n        >\n            <option *ngFor=\"let duplicator of duplicators\" [ngValue]=\"duplicator\">\n                {{ duplicator.description }} ({{ duplicator.code }})\n            </option>\n        </select>\n    </ng-container>\n    <ng-container *ngIf=\"selectedDuplicator as duplicator\">\n        <vdr-configurable-input\n            *ngIf=\"duplicator.args.length > 0\"\n            [hideDescription]=\"true\"\n            [operation]=\"duplicatorInstance\"\n            [operationDefinition]=\"duplicator\"\n            [removable]=\"false\"\n            [formControl]=\"formGroup\"\n        ></vdr-configurable-input>\n    </ng-container>\n</div>\n\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\n    <button type=\"submit\" (click)=\"duplicate()\" [disabled]=\"!selectedDuplicator\" class=\"btn btn-primary\">\n        {{ 'common.duplicate' | translate }}\n    </button>\n</ng-template>\n" }]
+        }], ctorParameters: () => [{ type: i1.DataService }, { type: i2.NotificationService }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"duplicate-entity-dialog.component.js","sourceRoot":"","sources":["../../../../../../src/lib/core/src/shared/components/duplicate-entity-dialog/duplicate-entity-dialog.component.ts","../../../../../../src/lib/core/src/shared/components/duplicate-entity-dialog/duplicate-entity-dialog.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, OnInit } from '@angular/core';\nimport { FormControl } from '@angular/forms';\nimport { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\nimport { assertNever } from '@deenruv/common/lib/shared-utils';\n\nimport { lastValueFrom, Observable } from 'rxjs';\nimport { tap } from 'rxjs/operators';\nimport {\n    ConfigurableOperation,\n    DuplicateEntityDocument,\n    GetEntityDuplicatorsDocument,\n    GetEntityDuplicatorsQuery,\n} from '../../../common/generated-types';\nimport {\n    configurableDefinitionToInstance,\n    toConfigurableOperationInput,\n} from '../../../common/utilities/configurable-operation-utils';\nimport { DataService } from '../../../data/providers/data.service';\nimport { Dialog } from '../../../providers/modal/modal.types';\nimport { NotificationService } from '../../../providers/notification/notification.service';\n\ntype EntityDuplicatorDef = GetEntityDuplicatorsQuery['entityDuplicators'][0];\n\n@Component({\n    selector: 'vdr-duplicate-entity-dialog',\n    templateUrl: './duplicate-entity-dialog.component.html',\n    styleUrls: ['./duplicate-entity-dialog.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class DuplicateEntityDialogComponent<T extends { id: string }> implements OnInit, Dialog<boolean> {\n    resolveWith: (result?: boolean | undefined) => void;\n    protected entityDuplicators$: Observable<EntityDuplicatorDef[]>;\n    protected selectedDuplicator: EntityDuplicatorDef | undefined;\n    protected duplicatorInstance: ConfigurableOperation;\n    protected formGroup = new FormControl<ConfigurableOperation>({\n        code: '',\n        args: [],\n    });\n\n    title?: string;\n    entities: T[];\n    entityName: string;\n    getEntityName: (entity: T) => string;\n\n    constructor(\n        private dataService: DataService,\n        private notificationService: NotificationService,\n        private changeDetectorRef: ChangeDetectorRef,\n    ) {}\n\n    ngOnInit() {\n        this.entityDuplicators$ = this.dataService\n            .query(GetEntityDuplicatorsDocument)\n            .mapSingle(data => data.entityDuplicators.filter(d => d.forEntities.includes(this.entityName)))\n            .pipe(\n                tap(duplicators => {\n                    if (0 < duplicators.length) {\n                        this.setSelectedDuplicator(duplicators[0]);\n                    }\n                }),\n            );\n    }\n\n    setSelectedDuplicator(duplicator: EntityDuplicatorDef) {\n        this.selectedDuplicator = duplicator;\n        this.duplicatorInstance = configurableDefinitionToInstance(this.selectedDuplicator);\n        this.formGroup.patchValue(this.duplicatorInstance);\n        this.changeDetectorRef.markForCheck();\n    }\n\n    async duplicate() {\n        const selectedDuplicator = this.selectedDuplicator;\n        const formValue = this.formGroup.value;\n        if (!selectedDuplicator || !formValue) {\n            return;\n        }\n        const duplicatorInput = toConfigurableOperationInput(this.duplicatorInstance, formValue);\n\n        const succeeded: string[] = [];\n        const failed: Array<{ name: string; message: string }> = [];\n        for (const entity of this.entities) {\n            const { duplicateEntity } = await lastValueFrom(\n                this.dataService.mutate(DuplicateEntityDocument, {\n                    input: {\n                        entityId: entity.id,\n                        entityName: this.entityName,\n                        duplicatorInput,\n                    },\n                }),\n            );\n            switch (duplicateEntity.__typename) {\n                case 'DuplicateEntitySuccess':\n                    succeeded.push(this.getEntityName(entity));\n                    break;\n                case 'DuplicateEntityError':\n                    failed.push({\n                        name: this.getEntityName(entity),\n                        message: duplicateEntity.duplicationError,\n                    });\n                    break;\n                case undefined:\n                    break;\n                default:\n                    assertNever(duplicateEntity);\n            }\n        }\n        if (0 < succeeded.length) {\n            this.notificationService.success(_('common.notify-duplicate-success'), {\n                count: succeeded.length,\n                names: succeeded.join(', '),\n            });\n        }\n        if (0 < failed.length) {\n            const failedCount = failed.length;\n            const maxNotices = 5;\n            const excess = failedCount - maxNotices;\n            for (let i = 0; i < Math.min(failedCount, maxNotices); i++) {\n                const failedItem = failed[i];\n                this.notificationService.error(_('common.notify-duplicate-error'), {\n                    name: failedItem.name,\n                    error: failedItem.message,\n                });\n            }\n            if (excess > 0) {\n                this.notificationService.error(_('common.notify-duplicate-error-excess'), { count: excess });\n            }\n        }\n        this.resolveWith(true);\n    }\n\n    cancel() {\n        this.resolveWith();\n    }\n}\n","<ng-template vdrDialogTitle>\n    {{ title || 'common.duplicate-entity' | translate }}\n</ng-template>\n<div class=\"\">\n    <ul>\n        <li *ngFor=\"let entity of entities\">\n            {{ getEntityName(entity) }}\n        </li>\n    </ul>\n    <ng-container *ngIf=\"entityDuplicators$ | async as duplicators\">\n        <select\n            name=\"\"\n            id=\"\"\n            *ngIf=\"1 < duplicators.length\"\n            class=\"mt-4\"\n            [ngModel]=\"selectedDuplicator\"\n            (ngModelChange)=\"setSelectedDuplicator($event)\"\n        >\n            <option *ngFor=\"let duplicator of duplicators\" [ngValue]=\"duplicator\">\n                {{ duplicator.description }} ({{ duplicator.code }})\n            </option>\n        </select>\n    </ng-container>\n    <ng-container *ngIf=\"selectedDuplicator as duplicator\">\n        <vdr-configurable-input\n            *ngIf=\"duplicator.args.length > 0\"\n            [hideDescription]=\"true\"\n            [operation]=\"duplicatorInstance\"\n            [operationDefinition]=\"duplicator\"\n            [removable]=\"false\"\n            [formControl]=\"formGroup\"\n        ></vdr-configurable-input>\n    </ng-container>\n</div>\n\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\n    <button type=\"submit\" (click)=\"duplicate()\" [disabled]=\"!selectedDuplicator\" class=\"btn btn-primary\">\n        {{ 'common.duplicate' | translate }}\n    </button>\n</ng-template>\n"]}

package/esm2022/core/shared/components/duplicate-entity-dialog/duplicate-entity-dialog.graphql.mjs

@@ -0,0 +1,38 @@
+import { gql } from 'apollo-angular';
+export const GET_ENTITY_DUPLICATORS = gql `
+    query GetEntityDuplicators {
+        entityDuplicators {
+            code
+            description
+            forEntities
+            requiresPermission
+            args {
+                name
+                type
+                required
+                defaultValue
+                list
+                ui
+                label
+                description
+            }
+        }
+    }
+`;
+export const DUPLICATE_ENTITY = gql `
+    mutation DuplicateEntity($input: DuplicateEntityInput!) {
+        duplicateEntity(input: $input) {
+            ... on DuplicateEntitySuccess {
+                newEntityId
+            }
+            ... on ErrorResult {
+                errorCode
+                message
+            }
+            ... on DuplicateEntityError {
+                duplicationError
+            }
+        }
+    }
+`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHVwbGljYXRlLWVudGl0eS1kaWFsb2cuZ3JhcGhxbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvc2hhcmVkL2NvbXBvbmVudHMvZHVwbGljYXRlLWVudGl0eS1kaWFsb2cvZHVwbGljYXRlLWVudGl0eS1kaWFsb2cuZ3JhcGhxbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFckMsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsR0FBRyxDQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBbUJ4QyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsR0FBRyxDQUFBOzs7Ozs7Ozs7Ozs7Ozs7Q0FlbEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdxbCB9IGZyb20gJ2Fwb2xsby1hbmd1bGFyJztcblxuZXhwb3J0IGNvbnN0IEdFVF9FTlRJVFlfRFVQTElDQVRPUlMgPSBncWxgXG4gICAgcXVlcnkgR2V0RW50aXR5RHVwbGljYXRvcnMge1xuICAgICAgICBlbnRpdHlEdXBsaWNhdG9ycyB7XG4gICAgICAgICAgICBjb2RlXG4gICAgICAgICAgICBkZXNjcmlwdGlvblxuICAgICAgICAgICAgZm9yRW50aXRpZXNcbiAgICAgICAgICAgIHJlcXVpcmVzUGVybWlzc2lvblxuICAgICAgICAgICAgYXJncyB7XG4gICAgICAgICAgICAgICAgbmFtZVxuICAgICAgICAgICAgICAgIHR5cGVcbiAgICAgICAgICAgICAgICByZXF1aXJlZFxuICAgICAgICAgICAgICAgIGRlZmF1bHRWYWx1ZVxuICAgICAgICAgICAgICAgIGxpc3RcbiAgICAgICAgICAgICAgICB1aVxuICAgICAgICAgICAgICAgIGxhYmVsXG4gICAgICAgICAgICAgICAgZGVzY3JpcHRpb25cbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgIH1cbmA7XG5cbmV4cG9ydCBjb25zdCBEVVBMSUNBVEVfRU5USVRZID0gZ3FsYFxuICAgIG11dGF0aW9uIER1cGxpY2F0ZUVudGl0eSgkaW5wdXQ6IER1cGxpY2F0ZUVudGl0eUlucHV0ISkge1xuICAgICAgICBkdXBsaWNhdGVFbnRpdHkoaW5wdXQ6ICRpbnB1dCkge1xuICAgICAgICAgICAgLi4uIG9uIER1cGxpY2F0ZUVudGl0eVN1Y2Nlc3Mge1xuICAgICAgICAgICAgICAgIG5ld0VudGl0eUlkXG4gICAgICAgICAgICB9XG4gICAgICAgICAgICAuLi4gb24gRXJyb3JSZXN1bHQge1xuICAgICAgICAgICAgICAgIGVycm9yQ29kZVxuICAgICAgICAgICAgICAgIG1lc3NhZ2VcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIC4uLiBvbiBEdXBsaWNhdGVFbnRpdHlFcnJvciB7XG4gICAgICAgICAgICAgICAgZHVwbGljYXRpb25FcnJvclxuICAgICAgICAgICAgfVxuICAgICAgICB9XG4gICAgfVxuYDtcbiJdfQ==

package/esm2022/core/shared/components/edit-note-dialog/edit-note-dialog.component.mjs

@@ -0,0 +1,32 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@clr/angular";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "../form-field/form-field-control.directive";
+import * as i5 from "../modal-dialog/dialog-buttons.directive";
+import * as i6 from "../modal-dialog/dialog-title.directive";
+import * as i7 from "@ngx-translate/core";
+export class EditNoteDialogComponent {
+    constructor() {
+        this.displayPrivacyControls = true;
+        this.noteIsPrivate = true;
+        this.note = '';
+    }
+    confirm() {
+        this.resolveWith({
+            note: this.note,
+            isPrivate: this.noteIsPrivate,
+        });
+    }
+    cancel() {
+        this.resolveWith();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EditNoteDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: EditNoteDialogComponent, selector: "vdr-edit-note-dialog", ngImport: i0, template: "<ng-template vdrDialogTitle>\n    {{ 'common.edit-note' | translate }}\n</ng-template>\n\n<textarea [(ngModel)]=\"note\" name=\"note\" class=\"note\"></textarea>\n<div class=\"visibility-select\" *ngIf=\"displayPrivacyControls\">\n    <clr-checkbox-wrapper>\n        <input type=\"checkbox\" clrCheckbox [(ngModel)]=\"noteIsPrivate\" />\n        <label>{{ 'order.note-is-private' | translate }}</label>\n    </clr-checkbox-wrapper>\n    <span *ngIf=\"noteIsPrivate\" class=\"private\">\n        {{ 'order.note-only-visible-to-administrators' | translate }}\n    </span>\n    <span *ngIf=\"!noteIsPrivate\" class=\"public\">\n        {{ 'order.note-visible-to-customer' | translate }}\n    </span>\n</div>\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\n    <button type=\"submit\" (click)=\"confirm()\" class=\"btn btn-primary\" [disabled]=\"note.length === 0\">\n        {{ 'common.confirm' | translate }}\n    </button>\n</ng-template>\n", styles: [".visibility-select{display:flex;justify-content:space-between;align-items:baseline}.visibility-select .public{color:var(--color-warning-500)}.visibility-select .private{color:var(--color-success-500)}textarea.note{width:100%;height:72px;border-radius:3px;margin-inline-end:6px}\n"], dependencies: [{ kind: "directive", type: i1.ClrLabel, selector: "label", inputs: ["id", "for"] }, { kind: "directive", type: i1.ClrCheckbox, selector: "[clrCheckbox],[clrToggle]" }, { kind: "component", type: i1.ClrCheckboxWrapper, selector: "clr-checkbox-wrapper,clr-toggle-wrapper" }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i4.FormFieldControlDirective, selector: "input, textarea, select, vdr-currency-input" }, { kind: "directive", type: i5.DialogButtonsDirective, selector: "[vdrDialogButtons]" }, { kind: "directive", type: i6.DialogTitleDirective, selector: "[vdrDialogTitle]" }, { kind: "pipe", type: i7.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EditNoteDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-edit-note-dialog', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-template vdrDialogTitle>\n    {{ 'common.edit-note' | translate }}\n</ng-template>\n\n<textarea [(ngModel)]=\"note\" name=\"note\" class=\"note\"></textarea>\n<div class=\"visibility-select\" *ngIf=\"displayPrivacyControls\">\n    <clr-checkbox-wrapper>\n        <input type=\"checkbox\" clrCheckbox [(ngModel)]=\"noteIsPrivate\" />\n        <label>{{ 'order.note-is-private' | translate }}</label>\n    </clr-checkbox-wrapper>\n    <span *ngIf=\"noteIsPrivate\" class=\"private\">\n        {{ 'order.note-only-visible-to-administrators' | translate }}\n    </span>\n    <span *ngIf=\"!noteIsPrivate\" class=\"public\">\n        {{ 'order.note-visible-to-customer' | translate }}\n    </span>\n</div>\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\n    <button type=\"submit\" (click)=\"confirm()\" class=\"btn btn-primary\" [disabled]=\"note.length === 0\">\n        {{ 'common.confirm' | translate }}\n    </button>\n</ng-template>\n", styles: [".visibility-select{display:flex;justify-content:space-between;align-items:baseline}.visibility-select .public{color:var(--color-warning-500)}.visibility-select .private{color:var(--color-success-500)}textarea.note{width:100%;height:72px;border-radius:3px;margin-inline-end:6px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/shared/components/empty-placeholder/empty-placeholder.component.mjs

@@ -0,0 +1,16 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@clr/angular";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+export class EmptyPlaceholderComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EmptyPlaceholderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: EmptyPlaceholderComponent, selector: "vdr-empty-placeholder", inputs: { emptyStateLabel: "emptyStateLabel" }, ngImport: i0, template: "<div class=\"empty-state\">\n    <clr-icon shape=\"bubble-exclamation\" size=\"64\"></clr-icon>\n    <div class=\"empty-label\">\n        <ng-container *ngIf=\"emptyStateLabel; else defaultEmptyLabel\">{{ emptyStateLabel }}</ng-container>\n        <ng-template #defaultEmptyLabel>{{ 'common.no-results' | translate }}</ng-template>\n    </div>\n</div>\n", styles: [":host{display:block}.empty-state{text-align:center;padding:60px;color:var(--color-grey-400);width:100%}.empty-state .empty-label{margin-top:12px;font-size:22px}\n"], dependencies: [{ kind: "directive", type: i1.ClrIconCustomTag, selector: "clr-icon" }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EmptyPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-empty-placeholder', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"empty-state\">\n    <clr-icon shape=\"bubble-exclamation\" size=\"64\"></clr-icon>\n    <div class=\"empty-label\">\n        <ng-container *ngIf=\"emptyStateLabel; else defaultEmptyLabel\">{{ emptyStateLabel }}</ng-container>\n        <ng-template #defaultEmptyLabel>{{ 'common.no-results' | translate }}</ng-template>\n    </div>\n</div>\n", styles: [":host{display:block}.empty-state{text-align:center;padding:60px;color:var(--color-grey-400);width:100%}.empty-state .empty-label{margin-top:12px;font-size:22px}\n"] }]
+        }], propDecorators: { emptyStateLabel: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHktcGxhY2Vob2xkZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb3JlL3NyYy9zaGFyZWQvY29tcG9uZW50cy9lbXB0eS1wbGFjZWhvbGRlci9lbXB0eS1wbGFjZWhvbGRlci5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL2VtcHR5LXBsYWNlaG9sZGVyL2VtcHR5LXBsYWNlaG9sZGVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7OztBQVExRSxNQUFNLE9BQU8seUJBQXlCOytHQUF6Qix5QkFBeUI7bUdBQXpCLHlCQUF5Qiw2R0NSdEMsbVdBT0E7OzRGRENhLHlCQUF5QjtrQkFOckMsU0FBUzsrQkFDSSx1QkFBdUIsbUJBR2hCLHVCQUF1QixDQUFDLE1BQU07OEJBR3RDLGVBQWU7c0JBQXZCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ3Zkci1lbXB0eS1wbGFjZWhvbGRlcicsXG4gICAgdGVtcGxhdGVVcmw6ICcuL2VtcHR5LXBsYWNlaG9sZGVyLmNvbXBvbmVudC5odG1sJyxcbiAgICBzdHlsZVVybHM6IFsnLi9lbXB0eS1wbGFjZWhvbGRlci5jb21wb25lbnQuc2NzcyddLFxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxufSlcbmV4cG9ydCBjbGFzcyBFbXB0eVBsYWNlaG9sZGVyQ29tcG9uZW50IHtcbiAgICBASW5wdXQoKSBlbXB0eVN0YXRlTGFiZWw6IHN0cmluZztcbn1cbiIsIjxkaXYgY2xhc3M9XCJlbXB0eS1zdGF0ZVwiPlxuICAgIDxjbHItaWNvbiBzaGFwZT1cImJ1YmJsZS1leGNsYW1hdGlvblwiIHNpemU9XCI2NFwiPjwvY2xyLWljb24+XG4gICAgPGRpdiBjbGFzcz1cImVtcHR5LWxhYmVsXCI+XG4gICAgICAgIDxuZy1jb250YWluZXIgKm5nSWY9XCJlbXB0eVN0YXRlTGFiZWw7IGVsc2UgZGVmYXVsdEVtcHR5TGFiZWxcIj57eyBlbXB0eVN0YXRlTGFiZWwgfX08L25nLWNvbnRhaW5lcj5cbiAgICAgICAgPG5nLXRlbXBsYXRlICNkZWZhdWx0RW1wdHlMYWJlbD57eyAnY29tbW9uLm5vLXJlc3VsdHMnIHwgdHJhbnNsYXRlIH19PC9uZy10ZW1wbGF0ZT5cbiAgICA8L2Rpdj5cbjwvZGl2PlxuIl19