@morozeckiy/dd-lib 0.1.1 → 0.1.2

package/esm2022/lib/common/lib-common-button.mjs

@@ -0,0 +1,62 @@
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LibCommonButtonComponent {
+    constructor() {
+        this.size = '';
+        this.autofocus = false;
+        this.btnColor = 'green';
+        this.active = false;
+        this.disabled = false;
+        this.showLoader = false;
+        this.buttonType = 'button';
+        this.clickEvent = new EventEmitter();
+    }
+    onClick(event) {
+        if (this.disabled || this.showLoader || this.active) {
+            event.stopPropagation();
+            event.preventDefault();
+        }
+        else {
+            this.clickEvent.emit();
+            const el = document.activeElement;
+            el?.blur();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibCommonButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LibCommonButtonComponent, selector: "ng-component", inputs: { width: "width", height: "height", size: "size", fontSize: "fontSize", autofocus: "autofocus", btnColor: "btnColor", active: "active", disabled: "disabled", showLoader: "showLoader", buttonType: "buttonType" }, outputs: { clickEvent: "clickEvent" }, viewQueries: [{ propertyName: "content", first: true, predicate: ["contentData"], descendants: true }, { propertyName: "button", first: true, predicate: ["btn"], descendants: true }], ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibCommonButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], propDecorators: { width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], fontSize: [{
+                type: Input
+            }], autofocus: [{
+                type: Input
+            }], btnColor: [{
+                type: Input
+            }], active: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], showLoader: [{
+                type: Input
+            }], buttonType: [{
+                type: Input
+            }], content: [{
+                type: ViewChild,
+                args: ['contentData', { static: false }]
+            }], button: [{
+                type: ViewChild,
+                args: ['btn', { static: false }]
+            }], clickEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/lib-common-input-text.mjs

@@ -0,0 +1,172 @@
+import { Component, EventEmitter, forwardRef, Input, Output, ViewChild, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class LibCommonInputTextComponent {
+    get id() {
+        return this._ID;
+    }
+    constructor(changeDetection) {
+        this.maxlength = 700;
+        this.required = false;
+        this.disabled = false;
+        this.commitOnInput = true; // коммитить по input или по change
+        this.clearable = false;
+        this.uppercase = false;
+        this.invalid = false;
+        this.cleared = new EventEmitter();
+        this.focus = new EventEmitter();
+        this.blur = new EventEmitter();
+        this.focused = false;
+        this.touched = false;
+        this.value = '';
+        this.destroyed = false;
+        this._ID = '';
+        this.changeDetection = changeDetection;
+    }
+    handleInput(_e) {
+        if (this.commitOnInput) {
+            this.commit(this.value);
+        }
+    }
+    notifyFocusEvent(e) {
+        // this.focusManager.notifyFocusMayChanged(this, e.type === 'focus');
+    }
+    // public writeValue(value: string | number | null): void {
+    //   this.value = value === null || value === undefined ? '' : '' + value;
+    //   if (!this.destroyed) {
+    //     this.changeDetection.detectChanges();
+    //   }
+    // }
+    // public clearValue(e: Event): void {
+    //   if (!this.disabled) {
+    //     this.writeValue(null);
+    //     this.commit(null);
+    //     this.cleared.emit();
+    //     this.returnFocus(e);
+    //   }
+    //   e.stopPropagation();
+    // }
+    handleBlur() {
+        this.focused = false;
+        if (this.onTouchedCallback) {
+            this.onTouchedCallback();
+        }
+        this.blur.emit();
+        this.changeDetection.detectChanges();
+    }
+    handleFocus() {
+        this.focused = this.touched = true;
+        if (this.onTouchedCallback) {
+            this.onTouchedCallback();
+        }
+        this.focus.emit();
+    }
+    returnFocus(e) {
+        if (this.inputElement &&
+            this.inputElement.nativeElement &&
+            (!e || e.target !== this.inputElement.nativeElement)) {
+            this.inputElement.nativeElement.focus();
+            // HelperService.resetSelection(this.inputElement.nativeElement);
+        }
+    }
+    loseFocus() {
+        this.inputElement?.nativeElement.blur();
+    }
+    forceChange() {
+        if (this.inputElement) {
+            // this.inputElement.nativeElement.dispatchEvent(HelperService.createEvent('change', true, false));
+        }
+    }
+    registerOnChange(fn) {
+        this.commit = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        if (!this.destroyed) {
+            this.changeDetection.detectChanges();
+        }
+    }
+    handleChange() {
+        if (!this.commitOnInput) {
+            this.commit(this.value);
+        }
+    }
+    commit(_value) { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibCommonInputTextComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LibCommonInputTextComponent, selector: "dd-lib-common-input", inputs: { name: "name", label: "label", formControlName: "formControlName", type: "type", contextClass: "contextClass", minlength: "minlength", maxlength: "maxlength", placeholder: "placeholder", autocomplete: "autocomplete", tabIndex: "tabIndex", readOnly: "readOnly", required: "required", disabled: "disabled", commitOnInput: "commitOnInput", clearable: "clearable", uppercase: "uppercase", invalid: "invalid", errorText: "errorText" }, outputs: { cleared: "cleared", focus: "focus", blur: "blur" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => LibCommonInputTextComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "inputSearchElement", first: true, predicate: ["searchInput"], descendants: true }, { propertyName: "inputElement", first: true, predicate: ["input"], descendants: true }, { propertyName: "textAreaElement", first: true, predicate: ["textarea"], descendants: true }], ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibCommonInputTextComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dd-lib-common-input',
+                    template: '',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => LibCommonInputTextComponent),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { inputSearchElement: [{
+                type: ViewChild,
+                args: ['searchInput']
+            }], inputElement: [{
+                type: ViewChild,
+                args: ['input']
+            }], textAreaElement: [{
+                type: ViewChild,
+                args: ['textarea']
+            }], name: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], formControlName: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], contextClass: [{
+                type: Input
+            }], minlength: [{
+                type: Input
+            }], maxlength: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], autocomplete: [{
+                type: Input
+            }], tabIndex: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], commitOnInput: [{
+                type: Input
+            }], clearable: [{
+                type: Input
+            }], uppercase: [{
+                type: Input
+            }], invalid: [{
+                type: Input
+            }], errorText: [{
+                type: Input
+            }], cleared: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], blur: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lib-common-input-text.js","sourceRoot":"","sources":["../../../../../projects/dd-lib/src/lib/common/lib-common-input-text.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter,\r\n  forwardRef,\r\n  Input,\r\n  Output,\r\n  ViewChild,\r\n} from '@angular/core';\r\nimport { AbstractControl, NG_VALUE_ACCESSOR } from '@angular/forms';\r\n\r\n@Component({\r\n  selector: 'dd-lib-common-input',\r\n  template: '',\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => LibCommonInputTextComponent),\r\n      multi: true,\r\n    },\r\n  ],\r\n})\r\nexport abstract class LibCommonInputTextComponent {\r\n  @ViewChild('searchInput') protected inputSearchElement: ElementRef<HTMLInputElement> | undefined;\r\n  @ViewChild('input') protected inputElement: ElementRef<HTMLInputElement> | undefined;\r\n  @ViewChild('textarea') protected textAreaElement: ElementRef<HTMLTextAreaElement> | undefined;\r\n  @Input() public name: string | undefined;\r\n  @Input() public label: string | undefined;\r\n  @Input() public formControlName: string | undefined;\r\n  @Input() public type: 'password' | 'email' | 'number' | 'text' | undefined;\r\n  @Input() public contextClass: string | undefined; // класс разметки для deep стилей\r\n  @Input() public minlength: string | number | undefined;\r\n  @Input() public maxlength = 700;\r\n  @Input() public placeholder?: string;\r\n  @Input() public autocomplete?: string;\r\n  @Input() public tabIndex?: string | number;\r\n  @Input() public readOnly?: boolean;\r\n  @Input() public required = false;\r\n  @Input() public disabled = false;\r\n  @Input() public commitOnInput = true; // коммитить по input или по change\r\n  @Input() public clearable = false;\r\n  @Input() public uppercase = false;\r\n  @Input() public invalid = false;\r\n  @Input() public errorText: string | undefined;\r\n  @Output() public cleared = new EventEmitter<void>();\r\n  @Output() public focus = new EventEmitter<any>();\r\n  @Output() public blur = new EventEmitter<any>();\r\n  public get id() {\r\n    return this._ID;\r\n  }\r\n  public focused = false;\r\n  public touched = false;\r\n  public control: AbstractControl | undefined | null;\r\n  public value: string | undefined = '';\r\n  public changeDetection: ChangeDetectorRef;\r\n\r\n  protected destroyed = false;\r\n  protected onTouchedCallback: (() => void) | undefined;\r\n  private _ID = '';\r\n\r\n  protected constructor(changeDetection: ChangeDetectorRef) {\r\n    this.changeDetection = changeDetection;\r\n  }\r\n\r\n  public handleInput(_e: Event): void {\r\n    if (this.commitOnInput) {\r\n      this.commit(this.value);\r\n    }\r\n  }\r\n\r\n  public notifyFocusEvent(e: Event): void {\r\n    // this.focusManager.notifyFocusMayChanged(this, e.type === 'focus');\r\n  }\r\n\r\n  // public writeValue(value: string | number | null): void {\r\n  //   this.value = value === null || value === undefined ? '' : '' + value;\r\n  //   if (!this.destroyed) {\r\n  //     this.changeDetection.detectChanges();\r\n  //   }\r\n  // }\r\n\r\n  // public clearValue(e: Event): void {\r\n  //   if (!this.disabled) {\r\n  //     this.writeValue(null);\r\n  //     this.commit(null);\r\n  //     this.cleared.emit();\r\n  //     this.returnFocus(e);\r\n  //   }\r\n  //   e.stopPropagation();\r\n  // }\r\n\r\n  public handleBlur(): void {\r\n    this.focused = false;\r\n    if (this.onTouchedCallback) {\r\n      this.onTouchedCallback();\r\n    }\r\n\r\n    this.blur.emit();\r\n    this.changeDetection.detectChanges();\r\n  }\r\n\r\n  public handleFocus(): void {\r\n    this.focused = this.touched = true;\r\n    if (this.onTouchedCallback) {\r\n      this.onTouchedCallback();\r\n    }\r\n    this.focus.emit();\r\n  }\r\n\r\n  public returnFocus(e?: Event): void {\r\n    if (\r\n      this.inputElement &&\r\n      this.inputElement.nativeElement &&\r\n      (!e || e.target !== this.inputElement.nativeElement)\r\n    ) {\r\n      this.inputElement.nativeElement.focus();\r\n      // HelperService.resetSelection(this.inputElement.nativeElement);\r\n    }\r\n  }\r\n\r\n  public loseFocus(): void {\r\n    this.inputElement?.nativeElement.blur();\r\n  }\r\n\r\n  public forceChange(): void {\r\n    if (this.inputElement) {\r\n      // this.inputElement.nativeElement.dispatchEvent(HelperService.createEvent('change', true, false));\r\n    }\r\n  }\r\n\r\n  public registerOnChange(fn: any): void {\r\n    this.commit = fn;\r\n  }\r\n\r\n  public registerOnTouched(fn: any): void {\r\n    this.onTouchedCallback = fn;\r\n  }\r\n\r\n  public setDisabledState(isDisabled: boolean): void {\r\n    this.disabled = isDisabled;\r\n    if (!this.destroyed) {\r\n      this.changeDetection.detectChanges();\r\n    }\r\n  }\r\n\r\n  public handleChange(): void {\r\n    if (!this.commitOnInput) {\r\n      this.commit(this.value);\r\n    }\r\n  }\r\n\r\n  public commit(_value: string | null | undefined): void {}\r\n}\r\n"]}

package/esm2022/lib/core/dialog/dialog-config.mjs

@@ -0,0 +1,15 @@
+import { InjectionToken } from '@angular/core';
+export const DIALOG_CONFIG = new InjectionToken('Default options');
+export class DialogConfig {
+    constructor(config) {
+        this.hasBackdrop = true;
+        this.backdropClass = 'modal-overlay';
+        this.dialogClass = '';
+        this.closeOnBackdropClick = true;
+        this.closeOnEsc = true;
+        this.hasScroll = false;
+        this.autoFocus = true;
+        Object.assign(this, config);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RkLWxpYi9zcmMvbGliL2NvcmUvZGlhbG9nL2RpYWxvZy1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBb0IsTUFBTSxlQUFlLENBQUM7QUFFakUsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLElBQUksY0FBYyxDQUFlLGlCQUFpQixDQUFDLENBQUM7QUFFakYsTUFBTSxPQUFPLFlBQVk7SUFXdkIsWUFBWSxNQUE2QjtRQVZsQyxnQkFBVyxHQUFHLElBQUksQ0FBQztRQUNuQixrQkFBYSxHQUFHLGVBQWUsQ0FBQztRQUNoQyxnQkFBVyxHQUFHLEVBQUUsQ0FBQztRQUNqQix5QkFBb0IsR0FBRyxJQUFJLENBQUM7UUFDNUIsZUFBVSxHQUFHLElBQUksQ0FBQztRQUNsQixjQUFTLEdBQUcsS0FBSyxDQUFDO1FBQ2xCLGNBQVMsR0FBRyxJQUFJLENBQUM7UUFLdEIsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDOUIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIFZpZXdDb250YWluZXJSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmV4cG9ydCBjb25zdCBESUFMT0dfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPERpYWxvZ0NvbmZpZz4oJ0RlZmF1bHQgb3B0aW9ucycpO1xyXG5cclxuZXhwb3J0IGNsYXNzIERpYWxvZ0NvbmZpZzxEID0gYW55PiB7XHJcbiAgcHVibGljIGhhc0JhY2tkcm9wID0gdHJ1ZTtcclxuICBwdWJsaWMgYmFja2Ryb3BDbGFzcyA9ICdtb2RhbC1vdmVybGF5JztcclxuICBwdWJsaWMgZGlhbG9nQ2xhc3MgPSAnJztcclxuICBwdWJsaWMgY2xvc2VPbkJhY2tkcm9wQ2xpY2sgPSB0cnVlO1xyXG4gIHB1YmxpYyBjbG9zZU9uRXNjID0gdHJ1ZTtcclxuICBwdWJsaWMgaGFzU2Nyb2xsID0gZmFsc2U7XHJcbiAgcHVibGljIGF1dG9Gb2N1cyA9IHRydWU7XHJcbiAgcHVibGljIHZpZXdDb250YWluZXJSZWY6IFZpZXdDb250YWluZXJSZWYgfCB1bmRlZmluZWQ7XHJcbiAgcHVibGljIGNvbnRleHQ6IEQgfCB1bmRlZmluZWQ7XHJcblxyXG4gIGNvbnN0cnVjdG9yKGNvbmZpZzogUGFydGlhbDxEaWFsb2dDb25maWc+KSB7XHJcbiAgICBPYmplY3QuYXNzaWduKHRoaXMsIGNvbmZpZyk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2022/lib/core/dialog/dialog-container.component.mjs

@@ -0,0 +1,40 @@
+import { Component, ViewChild } from '@angular/core';
+import { CdkPortalOutlet } from '@angular/cdk/portal';
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog-config";
+import * as i2 from "@angular/cdk/a11y";
+export class DialogContainerComponent {
+    constructor(config, elementRef, focusTrapFactory) {
+        this.config = config;
+        this.elementRef = elementRef;
+        this.focusTrapFactory = focusTrapFactory;
+    }
+    ngOnInit() {
+        if (this.config.autoFocus) {
+            this.focusTrap = this.focusTrapFactory.create(this.elementRef.nativeElement);
+            // this.focusTrap.blurPreviouslyFocusedElement();
+            this.focusTrap.focusInitialElement();
+        }
+    }
+    attachComponentPortal(portal) {
+        return this.portalOutlet.attachComponentPortal(portal);
+    }
+    attachTemplatePortal(portal) {
+        return this.portalOutlet.attachTemplatePortal(portal);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogContainerComponent, deps: [{ token: i1.DialogConfig }, { token: i0.ElementRef }, { token: i2.FocusTrapFactory }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DialogContainerComponent, isStandalone: true, selector: "dd-dialog-container", viewQueries: [{ propertyName: "portalOutlet", first: true, predicate: CdkPortalOutlet, descendants: true, static: true }], ngImport: i0, template: '<ng-template cdkPortalOutlet></ng-template>', isInline: true, dependencies: [{ kind: "directive", type: CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dd-dialog-container',
+                    standalone: true,
+                    imports: [CdkPortalOutlet],
+                    template: '<ng-template cdkPortalOutlet></ng-template>',
+                }]
+        }], ctorParameters: () => [{ type: i1.DialogConfig }, { type: i0.ElementRef }, { type: i2.FocusTrapFactory }], propDecorators: { portalOutlet: [{
+                type: ViewChild,
+                args: [CdkPortalOutlet, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/dialog/dialog-ref.mjs

@@ -0,0 +1,19 @@
+import { Subject } from 'rxjs';
+export class DDDialogRef {
+    constructor(overlayRef) {
+        this.overlayRef = overlayRef;
+        this.onClose$ = new Subject();
+        this.onClose = this.onClose$.asObservable();
+        this.onBackdropClick = this.overlayRef.backdropClick();
+    }
+    /**
+     * Hides dialog.
+     * */
+    close(res) {
+        this.overlayRef.detach();
+        this.overlayRef.dispose();
+        this.onClose$.next(res);
+        this.onClose$.complete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLXJlZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RkLWxpYi9zcmMvbGliL2NvcmUvZGlhbG9nL2RpYWxvZy1yZWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFjLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUczQyxNQUFNLE9BQU8sV0FBVztJQVV0QixZQUFzQixVQUFzQjtRQUF0QixlQUFVLEdBQVYsVUFBVSxDQUFZO1FBSGxDLGFBQVEsR0FBaUIsSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUNqQyxZQUFPLEdBQW9CLElBQUksQ0FBQyxRQUFRLENBQUMsWUFBWSxFQUFFLENBQUM7UUFHdEUsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsRUFBRSxDQUFDO0lBQ3pELENBQUM7SUFFRDs7U0FFSztJQUNFLEtBQUssQ0FBQyxHQUFTO1FBQ3BCLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDekIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUMxQixJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUN4QixJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQzNCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlLCBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IE92ZXJsYXlSZWYgfSBmcm9tICdAYW5ndWxhci9jZGsvb3ZlcmxheSc7XHJcblxyXG5leHBvcnQgY2xhc3MgREREaWFsb2dSZWY8VD4ge1xyXG4gIHB1YmxpYyBjb21wb25lbnRSZWY6IENvbXBvbmVudFJlZjxUPiB8IHVuZGVmaW5lZDtcclxuXHJcbiAgLyoqXHJcbiAgICogU3RyZWFtIG9mIGJhY2tkcm9wIGNsaWNrIGV2ZW50cy5cclxuICAgKiAqL1xyXG4gIHB1YmxpYyByZWFkb25seSBvbkJhY2tkcm9wQ2xpY2s6IE9ic2VydmFibGU8TW91c2VFdmVudD47XHJcbiAgcHJvdGVjdGVkIG9uQ2xvc2UkOiBTdWJqZWN0PGFueT4gPSBuZXcgU3ViamVjdCgpO1xyXG4gIHB1YmxpYyByZWFkb25seSBvbkNsb3NlOiBPYnNlcnZhYmxlPGFueT4gPSB0aGlzLm9uQ2xvc2UkLmFzT2JzZXJ2YWJsZSgpO1xyXG5cclxuICBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgb3ZlcmxheVJlZjogT3ZlcmxheVJlZikge1xyXG4gICAgdGhpcy5vbkJhY2tkcm9wQ2xpY2sgPSB0aGlzLm92ZXJsYXlSZWYuYmFja2Ryb3BDbGljaygpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogSGlkZXMgZGlhbG9nLlxyXG4gICAqICovXHJcbiAgcHVibGljIGNsb3NlKHJlcz86IGFueSkge1xyXG4gICAgdGhpcy5vdmVybGF5UmVmLmRldGFjaCgpO1xyXG4gICAgdGhpcy5vdmVybGF5UmVmLmRpc3Bvc2UoKTtcclxuICAgIHRoaXMub25DbG9zZSQubmV4dChyZXMpO1xyXG4gICAgdGhpcy5vbkNsb3NlJC5jb21wbGV0ZSgpO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/lib/core/dialog/dialog.service.mjs

@@ -0,0 +1,106 @@
+import { Inject, Injectable, TemplateRef, } from '@angular/core';
+import { DDDialogRef as DialogRef } from './dialog-ref';
+import { DIALOG_CONFIG, DialogConfig } from './dialog-config';
+import { DOCUMENT } from '@angular/common';
+import { GlobalPositionStrategy, } from '@angular/cdk/overlay';
+import { ComponentPortal, PortalInjector, TemplatePortal } from '@angular/cdk/portal';
+import { DialogContainerComponent } from './dialog-container.component';
+import { fromEvent } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "./dialog-config";
+export class DialogService {
+    constructor(document, globalConfig, overlay, injector, cfr) {
+        this.document = document;
+        this.globalConfig = globalConfig;
+        this.overlay = overlay;
+        this.injector = injector;
+        this.cfr = cfr;
+    }
+    open(content, userConfig = {}) {
+        const config = new DialogConfig({ ...this.globalConfig, ...userConfig });
+        const overlayRef = this.createOverlay(config);
+        const dialogRef = new DialogRef(overlayRef);
+        this.dialogRef = dialogRef;
+        const container = this.createContainer(config, overlayRef);
+        this.createContent(config, content, container, dialogRef);
+        this.registerCloseListeners(config, overlayRef, dialogRef);
+        return dialogRef;
+    }
+    createOverlay(config) {
+        const positionStrategy = this.createPositionStrategy();
+        const scrollStrategy = this.createScrollStrategy(config.hasScroll);
+        return this.overlay.create({
+            positionStrategy,
+            scrollStrategy,
+            hasBackdrop: config.hasBackdrop,
+            backdropClass: config.backdropClass,
+            panelClass: config.dialogClass,
+        });
+    }
+    createPositionStrategy() {
+        return new GlobalPositionStrategy().centerVertically().centerHorizontally();
+    }
+    createScrollStrategy(hasScroll) {
+        if (hasScroll) {
+            return this.overlay.scrollStrategies.noop();
+        }
+        else {
+            return this.overlay.scrollStrategies.block();
+        }
+    }
+    createContainer(config, overlayRef) {
+        const injector = new PortalInjector(this.createInjector(config), new WeakMap([[DialogConfig, config]]));
+        const containerPortal = new ComponentPortal(DialogContainerComponent, null, injector, this.cfr);
+        const containerRef = overlayRef.attach(containerPortal);
+        return containerRef.instance;
+    }
+    createInjector(config) {
+        return (config.viewContainerRef && config.viewContainerRef.injector) || this.injector;
+    }
+    createContent(config, content, container, dialogRef) {
+        if (content instanceof TemplateRef) {
+            const portal = this.createTemplatePortal(config, content, dialogRef);
+            container.attachTemplatePortal(portal);
+        }
+        else {
+            const portal = this.createComponentPortal(config, content, dialogRef);
+            dialogRef.componentRef = container.attachComponentPortal(portal);
+            if (config.context) {
+                Object.assign(dialogRef.componentRef.instance, { ...config.context });
+            }
+        }
+    }
+    createTemplatePortal(config, content, dialogRef) {
+        return new TemplatePortal(content, {}, { $implicit: config.context, dialogRef });
+    }
+    createComponentPortal(config, content, dialogRef) {
+        const injector = this.createInjector(config);
+        const portalInjector = new PortalInjector(injector, new WeakMap([[DialogRef, dialogRef]]));
+        return new ComponentPortal(content, config.viewContainerRef, portalInjector);
+    }
+    registerCloseListeners(config, overlayRef, dialogRef) {
+        if (config.closeOnBackdropClick) {
+            overlayRef.backdropClick().subscribe(() => dialogRef.close());
+        }
+        if (config.closeOnEsc) {
+            fromEvent(this.document, 'keyup')
+                .pipe(filter((event) => event.keyCode === 27), takeUntil(dialogRef.onClose))
+                .subscribe(() => dialogRef.close());
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, deps: [{ token: DOCUMENT }, { token: DIALOG_CONFIG }, { token: i1.Overlay }, { token: i0.Injector }, { token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i2.DialogConfig, decorators: [{
+                    type: Inject,
+                    args: [DIALOG_CONFIG]
+                }] }, { type: i1.Overlay }, { type: i0.Injector }, { type: i0.ComponentFactoryResolver }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../../projects/dd-lib/src/lib/core/dialog/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ComponentFactoryResolver,\r\n  Inject,\r\n  Injectable,\r\n  Injector,\r\n  TemplateRef,\r\n  Type,\r\n  ViewContainerRef,\r\n} from '@angular/core';\r\nimport { DDDialogRef as DialogRef } from './dialog-ref';\r\nimport { DIALOG_CONFIG, DialogConfig } from './dialog-config';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport {\r\n  GlobalPositionStrategy,\r\n  Overlay,\r\n  OverlayRef,\r\n  PositionStrategy,\r\n  ScrollStrategy,\r\n} from '@angular/cdk/overlay';\r\nimport { ComponentPortal, PortalInjector, TemplatePortal } from '@angular/cdk/portal';\r\nimport { DialogContainerComponent } from './dialog-container.component';\r\nimport { fromEvent } from 'rxjs';\r\nimport { filter, takeUntil } from 'rxjs/operators';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class DialogService {\r\n  public dialogRef: DialogRef<any> | undefined;\r\n\r\n  constructor(\r\n    @Inject(DOCUMENT) protected document: Document,\r\n    @Inject(DIALOG_CONFIG) protected globalConfig: DialogConfig,\r\n    protected overlay: Overlay,\r\n    protected injector: Injector,\r\n    protected cfr: ComponentFactoryResolver,\r\n  ) {}\r\n\r\n  public open<T, R = any>(\r\n    content: Type<T> | TemplateRef<T>,\r\n    userConfig: Partial<DialogConfig<Partial<R> | string>> = {},\r\n  ): DialogRef<T> {\r\n    const config = new DialogConfig({ ...this.globalConfig, ...userConfig });\r\n    const overlayRef = this.createOverlay(config);\r\n    const dialogRef = new DialogRef<T>(overlayRef);\r\n    this.dialogRef = dialogRef;\r\n    const container = this.createContainer(config, overlayRef);\r\n    this.createContent(config, content, container, dialogRef);\r\n\r\n    this.registerCloseListeners(config, overlayRef, dialogRef);\r\n\r\n    return dialogRef;\r\n  }\r\n\r\n  protected createOverlay(config: DialogConfig): OverlayRef {\r\n    const positionStrategy = this.createPositionStrategy();\r\n    const scrollStrategy = this.createScrollStrategy(config.hasScroll);\r\n\r\n    return this.overlay.create({\r\n      positionStrategy,\r\n      scrollStrategy,\r\n      hasBackdrop: config.hasBackdrop,\r\n      backdropClass: config.backdropClass,\r\n      panelClass: config.dialogClass,\r\n    });\r\n  }\r\n\r\n  protected createPositionStrategy(): PositionStrategy {\r\n    return new GlobalPositionStrategy().centerVertically().centerHorizontally();\r\n  }\r\n\r\n  protected createScrollStrategy(hasScroll: boolean): ScrollStrategy {\r\n    if (hasScroll) {\r\n      return this.overlay.scrollStrategies.noop();\r\n    } else {\r\n      return this.overlay.scrollStrategies.block();\r\n    }\r\n  }\r\n\r\n  protected createContainer(config: DialogConfig, overlayRef: OverlayRef): DialogContainerComponent {\r\n    const injector = new PortalInjector(this.createInjector(config), new WeakMap([[DialogConfig, config]]));\r\n    const containerPortal = new ComponentPortal(DialogContainerComponent, null, injector, this.cfr);\r\n    const containerRef = overlayRef.attach(containerPortal);\r\n    return containerRef.instance;\r\n  }\r\n\r\n  protected createInjector(config: DialogConfig): Injector {\r\n    return (config.viewContainerRef && config.viewContainerRef.injector) || this.injector;\r\n  }\r\n\r\n  protected createContent<T>(\r\n    config: DialogConfig,\r\n    content: Type<T> | TemplateRef<T>,\r\n    container: DialogContainerComponent,\r\n    dialogRef: DialogRef<T>,\r\n  ) {\r\n    if (content instanceof TemplateRef) {\r\n      const portal = this.createTemplatePortal(config, content, dialogRef);\r\n      container.attachTemplatePortal(portal);\r\n    } else {\r\n      const portal = this.createComponentPortal(config, content, dialogRef);\r\n      dialogRef.componentRef = container.attachComponentPortal(portal);\r\n\r\n      if (config.context) {\r\n        Object.assign(dialogRef.componentRef.instance as any, { ...config.context });\r\n      }\r\n    }\r\n  }\r\n\r\n  protected createTemplatePortal<T>(\r\n    config: DialogConfig,\r\n    content: TemplateRef<T>,\r\n    dialogRef: DialogRef<T>,\r\n  ): TemplatePortal {\r\n    return new TemplatePortal(\r\n      content,\r\n      {} as ViewContainerRef,\r\n      { $implicit: config.context, dialogRef } as any,\r\n    );\r\n  }\r\n\r\n  protected createComponentPortal<T>(\r\n    config: DialogConfig,\r\n    content: Type<T>,\r\n    dialogRef: DialogRef<T>,\r\n  ): ComponentPortal<T> {\r\n    const injector = this.createInjector(config);\r\n    const portalInjector = new PortalInjector(injector, new WeakMap([[DialogRef, dialogRef]]));\r\n    return new ComponentPortal(content, config.viewContainerRef, portalInjector);\r\n  }\r\n\r\n  protected registerCloseListeners<T>(config: DialogConfig, overlayRef: OverlayRef, dialogRef: DialogRef<T>) {\r\n    if (config.closeOnBackdropClick) {\r\n      overlayRef.backdropClick().subscribe(() => dialogRef.close());\r\n    }\r\n\r\n    if (config.closeOnEsc) {\r\n      fromEvent<KeyboardEvent>(this.document, 'keyup')\r\n        .pipe(\r\n          filter((event: KeyboardEvent) => event.keyCode === 27),\r\n          takeUntil(dialogRef.onClose),\r\n        )\r\n        .subscribe(() => dialogRef.close());\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/directives/auto-height.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AutoHeightDirective {
+    constructor(el, rdr) {
+        this.el = el;
+        this.rdr = rdr;
+    }
+    ngOnInit() {
+        setTimeout(() => {
+            if (this.ddAutoHeight) {
+                let i = 1;
+                let parent;
+                while (i <= this.ddAutoHeight) {
+                    parent = parent ? parent.parentNode : this.el.nativeElement.parentNode;
+                    i++;
+                }
+                const height = parent.clientHeight;
+                if (height) {
+                    this.rdr.setStyle(this.el.nativeElement, 'height', height + 'px');
+                }
+            }
+        }, 0);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AutoHeightDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AutoHeightDirective, isStandalone: true, selector: "[ddAutoHeight]", inputs: { ddAutoHeight: "ddAutoHeight" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AutoHeightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ddAutoHeight]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { ddAutoHeight: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1oZWlnaHQuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGQtbGliL3NyYy9saWIvY29yZS9kaXJlY3RpdmVzL2F1dG8taGVpZ2h0LmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFjLEtBQUssRUFBcUIsTUFBTSxlQUFlLENBQUM7O0FBTWhGLE1BQU0sT0FBTyxtQkFBbUI7SUFJOUIsWUFBb0IsRUFBYyxFQUFVLEdBQWM7UUFBdEMsT0FBRSxHQUFGLEVBQUUsQ0FBWTtRQUFVLFFBQUcsR0FBSCxHQUFHLENBQVc7SUFBRyxDQUFDO0lBRXZELFFBQVE7UUFDYixVQUFVLENBQUMsR0FBRyxFQUFFO1lBQ2QsSUFBSSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7Z0JBQ3RCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFDVixJQUFJLE1BQVcsQ0FBQztnQkFDaEIsT0FBTyxDQUFDLElBQUksSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO29CQUM5QixNQUFNLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUM7b0JBQ3ZFLENBQUMsRUFBRSxDQUFDO2dCQUNOLENBQUM7Z0JBQ0QsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLFlBQVksQ0FBQztnQkFDbkMsSUFBSSxNQUFNLEVBQUUsQ0FBQztvQkFDWCxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsRUFBRSxRQUFRLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FBQyxDQUFDO2dCQUNwRSxDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNSLENBQUM7K0dBckJVLG1CQUFtQjttR0FBbkIsbUJBQW1COzs0RkFBbkIsbUJBQW1CO2tCQUovQixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQjt1R0FHaUIsWUFBWTtzQkFBM0IsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSW5wdXQsIE9uSW5pdCwgUmVuZGVyZXIyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tkZEF1dG9IZWlnaHRdJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgQXV0b0hlaWdodERpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gIC8vINGD0YDQvtCy0LXQvdGMINC00L4g0YDQvtC00LjRgtC10LvRj1xuICBASW5wdXQoKSBwdWJsaWMgZGRBdXRvSGVpZ2h0OiBudW1iZXIgfCB1bmRlZmluZWQ7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBlbDogRWxlbWVudFJlZiwgcHJpdmF0ZSByZHI6IFJlbmRlcmVyMikge31cblxuICBwdWJsaWMgbmdPbkluaXQoKTogdm9pZCB7XG4gICAgc2V0VGltZW91dCgoKSA9PiB7XG4gICAgICBpZiAodGhpcy5kZEF1dG9IZWlnaHQpIHtcbiAgICAgICAgbGV0IGkgPSAxO1xuICAgICAgICBsZXQgcGFyZW50OiBhbnk7XG4gICAgICAgIHdoaWxlIChpIDw9IHRoaXMuZGRBdXRvSGVpZ2h0KSB7XG4gICAgICAgICAgcGFyZW50ID0gcGFyZW50ID8gcGFyZW50LnBhcmVudE5vZGUgOiB0aGlzLmVsLm5hdGl2ZUVsZW1lbnQucGFyZW50Tm9kZTtcbiAgICAgICAgICBpKys7XG4gICAgICAgIH1cbiAgICAgICAgY29uc3QgaGVpZ2h0ID0gcGFyZW50LmNsaWVudEhlaWdodDtcbiAgICAgICAgaWYgKGhlaWdodCkge1xuICAgICAgICAgIHRoaXMucmRyLnNldFN0eWxlKHRoaXMuZWwubmF0aXZlRWxlbWVudCwgJ2hlaWdodCcsIGhlaWdodCArICdweCcpO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfSwgMCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/core/directives/click-outside.directive.mjs

@@ -0,0 +1,42 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickOutsideDirective {
+    constructor(el) {
+        this.el = el;
+        this.ddClickOutside = new EventEmitter();
+    }
+    onClick(targetElement) {
+        let clickedElemInside = false;
+        if (this.elements?.length) {
+            this.elements.forEach(el => {
+                if (el) {
+                    const elem = document.getElementById(el);
+                    if (elem && !clickedElemInside) {
+                        clickedElemInside = elem.contains(targetElement.target);
+                    }
+                }
+            });
+        }
+        const clickedInside = this.el.nativeElement.contains(targetElement.target);
+        if (!clickedElemInside) {
+            this.ddClickOutside.emit(clickedInside);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ClickOutsideDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ClickOutsideDirective, isStandalone: true, selector: "[ddClickOutside]", inputs: { elements: "elements" }, outputs: { ddClickOutside: "ddClickOutside" }, host: { listeners: { "document:click": "onClick($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ClickOutsideDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ddClickOutside]',
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { elements: [{
+                type: Input
+            }], ddClickOutside: [{
+                type: Output
+            }], onClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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