@simpleangularcontrols/sac-common 13.0.0-rc.5 → 16.0.0-rc.2

package/esm2022/controls/dialog/dialog.mjs

@@ -0,0 +1,222 @@
+import { EventEmitter, HostListener, Input, Output, ViewChild, Directive, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Base Komponente für Dialog
+ */
+class SacDialogCommon {
+    /**
+     * Implementation als Setter, da mit ngIf das Element bei Unsichtbarkeit UNDEFINED ist.
+     */
+    set dialogElementSetter(content) {
+        this.dialogElement = content;
+    }
+    /**
+     * Das Input akzeptiert sowohl default size-css-Klassen als auch custom Klassen.
+     * case insensitive.
+     * Die akzeptabel default-size-Klassen sind: 'small', 'large', 'extralarge', 'medium', ''.
+     * Wenn size ist NICHT gesetzt (oder 'medium' oder ''), default ist in medium size: max-width 500px.
+     */
+    set size(v) {
+        v = v.toLowerCase();
+        this._size = v;
+    }
+    /**
+     * Setter. Erhält das boolen Wert des _show property
+     */
+    set isvisible(v) {
+        if (v &&
+            !this.hasSetBodyTag &&
+            !document.body.classList.contains('modal-open')) {
+            document.body.classList.add('modal-open');
+            this.hasSetBodyTag = true;
+        }
+        if (!v &&
+            this.hasSetBodyTag &&
+            document.body.classList.contains('modal-open')) {
+            document.body.classList.remove('modal-open');
+            this.hasSetBodyTag = false;
+        }
+        this._show = v;
+    }
+    /**
+     * Getter. Ergibt das boolen Wert des _show property
+     */
+    get isvisible() {
+        return this._show;
+    }
+    /**
+     * Die Funktion prüft ob es ein default css classe für Size des Dialog durch den size Input gesetzt wurde.
+     */
+    issetdefaultsize() {
+        let result = false;
+        switch (this._size) {
+            case 'small':
+                result = true;
+                break;
+            case 'medium':
+                result = true;
+                break;
+            case 'large':
+                result = true;
+                break;
+            case 'extralarge':
+                result = true;
+                break;
+            case '':
+                result = true;
+                break;
+        }
+        return result;
+    }
+    // #endregion
+    // #region Constructor
+    /**
+     * Konstruktor
+     * Inject des Formulars
+     */
+    constructor(cdRef) {
+        this.cdRef = cdRef;
+        this.hasSetBodyTag = false;
+        /**
+         * Boolean Property definiert ob das Dialog angezeigt wird
+         */
+        this._show = false;
+        /**
+         * Das property enthielt (wenn überhaupt gesetzt) entweder keywords für sizing oder custom css Klassen.
+         * Die akzeptabel keywordssind: 'small', 'large', 'extralarge', 'medium', ''.
+         */
+        this._size = '';
+        // #region Properties
+        /**
+         * Input Property. Erhält den Title des Dialog. Default Value: 'Dialog'.
+         */
+        this.title = 'Dialog';
+        /**
+         * Das input property akzeptiert boolen Wert. Definiert ob das Dialog darf durch ESC geschlossen werden. Default ist true.
+         */
+        this.allowesc = true;
+        /**
+         * Das input property akzeptiert boolen Wert. Definiert ob das Dialog darf durch click außerhalb des Dialog-Fenster geschlossen werden. Default ist true.
+         */
+        this.backdrop = true;
+        /**
+         * Input Property. Erhält den Namen des Dialog - benutzt für das ID. Default Value: ''
+         */
+        this.name = '';
+        /**
+         * Steuert ob im Header des Dialogs ein Button angezeigt wird.
+         */
+        this.closebutton = true;
+        /**
+         * Input Property. Erhält die Breite des Dialog
+         */
+        this.width = null;
+        /**
+         * Definiert eine feste Höhe beim Dialog.
+         */
+        this.height = null;
+        /**
+         * Output Emitter. Wird aufgerufen, wenn das Wert des _show property geändert ist - damait das Dialog geöfnet/geschlossen wird.
+         */
+        this.isvisibleChange = new EventEmitter();
+    }
+    // #endregion
+    /**
+     * Methode wenn Componente entfernt wird
+     */
+    ngOnDestroy() {
+        if (this.hasSetBodyTag && document.body.classList.contains('modal-open')) {
+            document.body.classList.remove('modal-open');
+            this.hasSetBodyTag = false;
+        }
+    }
+    // #region Methods
+    /**
+     * Die Methode setz den Wert des _show property auf true
+     */
+    show() {
+        this._show = true;
+        if (!this.hasSetBodyTag &&
+            !document.body.classList.contains('modal-open')) {
+            document.body.classList.add('modal-open');
+            this.hasSetBodyTag = true;
+        }
+        this.isvisibleChange.emit(this._show);
+    }
+    /**
+     * Die Methode setz den Wert des _show property auf false
+     */
+    hide() {
+        if (this.hasSetBodyTag && document.body.classList.contains('modal-open')) {
+            document.body.classList.remove('modal-open');
+            this.hasSetBodyTag = false;
+        }
+        this._show = false;
+        this.isvisibleChange.emit(this._show);
+    }
+    /**
+     * Getter for ChangeDetector.
+     */
+    get ChangeDetector() {
+        return this.cdRef;
+    }
+    // #endregion
+    // #region Host Actions
+    /**
+     * Allow Close by Click outside Dialog
+     */
+    onClick(event) {
+        if (this.allowesc === false ||
+            (this.dialogElement !== null &&
+                this.dialogElement !== undefined &&
+                event.target !== this.dialogElement.nativeElement)) {
+            return;
+        }
+        this.hide();
+    }
+    /**
+     * Allow Close by ESC
+     */
+    onKeydownHandler(event) {
+        const ESCAPE_KEYCODE = 'Escape';
+        if (this.allowesc === true && event.key === ESCAPE_KEYCODE) {
+            this.hide();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacDialogCommon, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacDialogCommon, inputs: { title: "title", allowesc: "allowesc", backdrop: "backdrop", name: "name", closebutton: "closebutton", width: "width", height: "height", size: "size", isvisible: "isvisible" }, outputs: { isvisibleChange: "isvisibleChange" }, host: { listeners: { "click": "onClick($event)", "document:keydown": "onKeydownHandler($event)" } }, viewQueries: [{ propertyName: "dialogElementSetter", first: true, predicate: ["dialog"], descendants: true }], ngImport: i0 }); }
+}
+export { SacDialogCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacDialogCommon, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { dialogElementSetter: [{
+                type: ViewChild,
+                args: ['dialog', { static: false }]
+            }], title: [{
+                type: Input
+            }], allowesc: [{
+                type: Input
+            }], backdrop: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], closebutton: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], isvisibleChange: [{
+                type: Output
+            }], isvisible: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onKeydownHandler: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/dialog/dialog.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  ElementRef,\r\n  EventEmitter,\r\n  HostListener,\r\n  Input,\r\n  Output,\r\n  ViewChild,\r\n  Directive,\r\n  OnDestroy,\r\n} from '@angular/core';\r\n\r\n/**\r\n * Base Komponente für Dialog\r\n */\r\n@Directive()\r\nexport class SacDialogCommon implements OnDestroy {\r\n  /**\r\n   * Name des Containers für den Dialog\r\n   */\r\n  dialogElement: ElementRef;\r\n\r\n  private hasSetBodyTag = false;\r\n\r\n  /**\r\n   * Implementation als Setter, da mit ngIf das Element bei Unsichtbarkeit UNDEFINED ist.\r\n   */\r\n  @ViewChild('dialog', { static: false })\r\n  set dialogElementSetter(content: ElementRef) {\r\n    this.dialogElement = content;\r\n  }\r\n\r\n  /**\r\n   * Boolean Property definiert ob das Dialog angezeigt wird\r\n   */\r\n  _show: boolean = false;\r\n\r\n  /**\r\n   * Das property enthielt (wenn überhaupt gesetzt) entweder keywords für sizing oder custom css Klassen.\r\n   * Die akzeptabel keywordssind: 'small', 'large', 'extralarge', 'medium', ''.\r\n   */\r\n  _size: string = '';\r\n\r\n  // #region Properties\r\n\r\n  /**\r\n   * Input Property. Erhält den Title des Dialog. Default Value: 'Dialog'.\r\n   */\r\n  @Input()\r\n  public title: string = 'Dialog';\r\n\r\n  /**\r\n   * Das input property akzeptiert boolen Wert. Definiert ob das Dialog darf durch ESC geschlossen werden. Default ist true.\r\n   */\r\n  @Input()\r\n  public allowesc: boolean = true;\r\n\r\n  /**\r\n   * Das input property akzeptiert boolen Wert. Definiert ob das Dialog darf durch click außerhalb des Dialog-Fenster geschlossen werden. Default ist true.\r\n   */\r\n  @Input()\r\n  public backdrop: boolean = true;\r\n\r\n  /**\r\n   * Input Property. Erhält den Namen des Dialog - benutzt für das ID. Default Value: ''\r\n   */\r\n  @Input()\r\n  public name: string = '';\r\n\r\n  /**\r\n   * Steuert ob im Header des Dialogs ein Button angezeigt wird.\r\n   */\r\n  @Input()\r\n  public closebutton: boolean = true;\r\n\r\n  /**\r\n   * Input Property. Erhält die Breite des Dialog\r\n   */\r\n  @Input()\r\n  public width: string = null;\r\n\r\n  /**\r\n   * Definiert eine feste Höhe beim Dialog.\r\n   */\r\n  @Input()\r\n  public height: string = null;\r\n\r\n  /**\r\n   * Das Input akzeptiert sowohl default size-css-Klassen als auch custom Klassen.\r\n   * case insensitive.\r\n   * Die akzeptabel default-size-Klassen sind: 'small', 'large', 'extralarge', 'medium', ''.\r\n   * Wenn size ist NICHT gesetzt (oder 'medium' oder ''), default ist in medium size: max-width 500px.\r\n   */\r\n  @Input()\r\n  set size(v: string) {\r\n    v = v.toLowerCase();\r\n    this._size = v;\r\n  }\r\n\r\n  /**\r\n   * Output Emitter. Wird aufgerufen, wenn das Wert des _show property geändert ist - damait das Dialog geöfnet/geschlossen wird.\r\n   */\r\n  @Output()\r\n  isvisibleChange: EventEmitter<boolean> = new EventEmitter<boolean>();\r\n\r\n  /**\r\n   * Setter. Erhält das boolen Wert des _show property\r\n   */\r\n  @Input()\r\n  set isvisible(v: boolean) {\r\n    if (\r\n      v &&\r\n      !this.hasSetBodyTag &&\r\n      !document.body.classList.contains('modal-open')\r\n    ) {\r\n      document.body.classList.add('modal-open');\r\n      this.hasSetBodyTag = true;\r\n    }\r\n\r\n    if (\r\n      !v &&\r\n      this.hasSetBodyTag &&\r\n      document.body.classList.contains('modal-open')\r\n    ) {\r\n      document.body.classList.remove('modal-open');\r\n      this.hasSetBodyTag = false;\r\n    }\r\n\r\n    this._show = v;\r\n  }\r\n\r\n  /**\r\n   * Getter. Ergibt das boolen Wert des _show property\r\n   */\r\n  get isvisible(): boolean {\r\n    return this._show;\r\n  }\r\n\r\n  /**\r\n   * Die Funktion prüft ob es ein default css classe für Size des Dialog durch den size Input gesetzt wurde.\r\n   */\r\n  issetdefaultsize(): boolean {\r\n    let result: boolean = false;\r\n\r\n    switch (this._size) {\r\n      case 'small':\r\n        result = true;\r\n        break;\r\n      case 'medium':\r\n        result = true;\r\n        break;\r\n      case 'large':\r\n        result = true;\r\n        break;\r\n      case 'extralarge':\r\n        result = true;\r\n        break;\r\n      case '':\r\n        result = true;\r\n        break;\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  // #endregion\r\n\r\n  // #region Constructor\r\n\r\n  /**\r\n   * Konstruktor\r\n   * Inject des Formulars\r\n   */\r\n  constructor(private cdRef: ChangeDetectorRef) {}\r\n\r\n  // #endregion\r\n\r\n  /**\r\n   * Methode wenn Componente entfernt wird\r\n   */\r\n  ngOnDestroy(): void {\r\n    if (this.hasSetBodyTag && document.body.classList.contains('modal-open')) {\r\n      document.body.classList.remove('modal-open');\r\n      this.hasSetBodyTag = false;\r\n    }\r\n  }\r\n\r\n  // #region Methods\r\n\r\n  /**\r\n   * Die Methode setz den Wert des _show property auf true\r\n   */\r\n  public show(): void {\r\n    this._show = true;\r\n\r\n    if (\r\n      !this.hasSetBodyTag &&\r\n      !document.body.classList.contains('modal-open')\r\n    ) {\r\n      document.body.classList.add('modal-open');\r\n      this.hasSetBodyTag = true;\r\n    }\r\n\r\n    this.isvisibleChange.emit(this._show);\r\n  }\r\n\r\n  /**\r\n   * Die Methode setz den Wert des _show property auf false\r\n   */\r\n  public hide(): void {\r\n    if (this.hasSetBodyTag && document.body.classList.contains('modal-open')) {\r\n      document.body.classList.remove('modal-open');\r\n      this.hasSetBodyTag = false;\r\n    }\r\n\r\n    this._show = false;\r\n    this.isvisibleChange.emit(this._show);\r\n  }\r\n\r\n  /**\r\n   * Getter for ChangeDetector.\r\n   */\r\n  protected get ChangeDetector(): ChangeDetectorRef {\r\n    return this.cdRef;\r\n  }\r\n\r\n  // #endregion\r\n\r\n  // #region Host Actions\r\n\r\n  /**\r\n   * Allow Close by Click outside Dialog\r\n   */\r\n  @HostListener('click', ['$event'])\r\n  onClick(event: any): void {\r\n    if (\r\n      this.allowesc === false ||\r\n      (this.dialogElement !== null &&\r\n        this.dialogElement !== undefined &&\r\n        event.target !== this.dialogElement.nativeElement)\r\n    ) {\r\n      return;\r\n    }\r\n    this.hide();\r\n  }\r\n\r\n  /**\r\n   * Allow Close by ESC\r\n   */\r\n  @HostListener('document:keydown', ['$event'])\r\n  onKeydownHandler(event: KeyboardEvent) {\r\n    const ESCAPE_KEYCODE = 'Escape';\r\n\r\n    if (this.allowesc === true && event.key === ESCAPE_KEYCODE) {\r\n      this.hide();\r\n    }\r\n  }\r\n\r\n  // #endregion\r\n}\r\n"]}

package/esm2022/controls/form/form.mjs

@@ -0,0 +1,164 @@
+import { Directive, Input } from '@angular/core';
+import { UntypedFormGroup } from '@angular/forms';
+import { convertToBoolean } from '../../utilities/convertion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+/**
+ * Base Komponente für SacFormular
+ */
+class SacFormCommon {
+    /**
+     * Definiert, wenn das Model geupdatet wird
+     */
+    set updateon(v) {
+        this._updateon = v;
+        this.form.options.updateOn = v;
+    }
+    get updateon() {
+        return this._updateon;
+    }
+    /**
+     * Aktiviert oder Deaktiviert die Inline Errors für das Control
+     */
+    set inlineerrorenabled(value) {
+        if (value === null || value === undefined) {
+            this._inlineerrorenabled = null;
+        }
+        else {
+            this._inlineerrorenabled = convertToBoolean(value);
+        }
+    }
+    /**
+     * Aktiviert oder Deaktiviert die Inline Errors für das Control
+     */
+    get inlineerrorenabled() {
+        return this._inlineerrorenabled;
+    }
+    /**
+     * Vertikale oder horizontale Orientierung des Formulars zurück
+     */
+    getOrientation() {
+        switch (this.orientation.toLowerCase()) {
+            case 'horizontal':
+                return 'horizontal';
+            case 'vertical':
+                return 'vertical';
+            case 'none':
+                return 'none';
+            default:
+                throw new Error('Invalid formtype at SacFormCommon. Valid values are horizontal, vertical, none');
+        }
+    }
+    /**
+     * Gibt die NgForm Instanz zurück
+     */
+    getForm() {
+        return this.form;
+    }
+    /**
+     * Konstruktor
+     * @param form Instanz von NgForm
+     */
+    constructor(form) {
+        this.form = form;
+        /**
+         * Inline Errors für das Formular
+         */
+        this._inlineerrorenabled = null;
+        /**
+         * Default Label Size for Form
+         */
+        this.labelsize = 3;
+        /**
+         * Kontroliert, ob das Label adaptive ist
+         */
+        this.isadaptivelabel = false;
+        /**
+         * Type des Forms
+         */
+        this.orientation = 'horizontal';
+        /**
+         * Standardwert wann die Werte via NgModel aktualisiert werden
+         */
+        this._updateon = 'change';
+        this.form.options = { updateOn: this._updateon };
+    }
+    /**
+     * Markiert alle Controls innerhalb des Formulares als Touched
+     */
+    markAsTouched() {
+        if (this.form && this.form.invalid) {
+            this.markAsTouchedInternal(this.form.controls);
+        }
+    }
+    /**
+     * Aktualisiert die Werte und den Gültigkeitsstatus des Formulars
+     */
+    updateValueAndValidity(markAsTouched = true) {
+        // Update all Controls
+        this.updateValueAndValidityInternal(this.form.controls);
+        // Update Main Form
+        this.getForm().form.updateValueAndValidity();
+        // Mark all Controls as Touched
+        if (markAsTouched) {
+            this.markAsTouched();
+        }
+    }
+    /**
+     * Markiert alle Controls inkl. dem Tree als Touched
+     * @param controls Controls Collection
+     */
+    markAsTouchedInternal(controls) {
+        const keyList = Object.keys(controls);
+        for (const field of keyList) {
+            const control = controls[field];
+            if (control instanceof UntypedFormGroup) {
+                this.markAsTouchedInternal(control.controls);
+            }
+            else {
+                control.markAsTouched({ onlySelf: true });
+            }
+        }
+    }
+    /**
+     * Aktualisiert die Werte und die gültigkeit des Formulars
+     * @param controls Controls Collection
+     */
+    updateValueAndValidityInternal(controls) {
+        const keyList = Object.keys(controls);
+        for (const field of keyList) {
+            const control = controls[field];
+            if (control instanceof UntypedFormGroup) {
+                this.updateValueAndValidityInternal(control.controls);
+            }
+            else {
+                control.updateValueAndValidity({ onlySelf: true });
+            }
+        }
+    }
+    /**
+     * Gibt zurück, ob die Inline Error Meldungen für das Formular aktiv sind.
+     */
+    get IsInlineErrorEnabled() {
+        return this._inlineerrorenabled !== false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacFormCommon, deps: [{ token: i1.NgForm }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacFormCommon, inputs: { SacFormular: "SacFormular", labelsize: "labelsize", isadaptivelabel: "isadaptivelabel", orientation: "orientation", updateon: "updateon", inlineerrorenabled: "inlineerrorenabled" }, ngImport: i0 }); }
+}
+export { SacFormCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacFormCommon, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.NgForm }]; }, propDecorators: { SacFormular: [{
+                type: Input
+            }], labelsize: [{
+                type: Input
+            }], isadaptivelabel: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], updateon: [{
+                type: Input
+            }], inlineerrorenabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/form/form.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input } from '@angular/core';\r\nimport { AbstractControl, UntypedFormGroup, NgForm } from '@angular/forms';\r\nimport { convertToBoolean } from '../../utilities/convertion';\r\n\r\n/**\r\n * Typ für Form Actions\r\n */\r\nexport type FormHooks = 'change' | 'blur' | 'submit';\r\n\r\n/**\r\n * Base Komponente für SacFormular\r\n */\r\n@Directive()\r\nexport class SacFormCommon {\r\n  /**\r\n   * Inline Errors für das Formular\r\n   */\r\n  private _inlineerrorenabled: boolean | null = null;\r\n\r\n  /**\r\n   * Form Control\r\n   */\r\n  @Input()\r\n  SacFormular: string;\r\n\r\n  /**\r\n   * Default Label Size for Form\r\n   */\r\n  @Input() labelsize: number = 3;\r\n  /**\r\n   * Kontroliert, ob das Label adaptive ist\r\n   */\r\n  @Input() isadaptivelabel: boolean = false;\r\n  /**\r\n   * Type des Forms\r\n   */\r\n  @Input() orientation: string = 'horizontal';\r\n\r\n  /**\r\n   * Standardwert wann die Werte via NgModel aktualisiert werden\r\n   */\r\n  private _updateon: FormHooks = 'change';\r\n\r\n  /**\r\n   * Definiert, wenn das Model geupdatet wird\r\n   */\r\n  @Input()\r\n  set updateon(v: FormHooks) {\r\n    this._updateon = v;\r\n    this.form.options.updateOn = v;\r\n  }\r\n  get updateon(): FormHooks {\r\n    return this._updateon;\r\n  }\r\n\r\n  /**\r\n   * Aktiviert oder Deaktiviert die Inline Errors für das Control\r\n   */\r\n  @Input()\r\n  set inlineerrorenabled(value: boolean) {\r\n    if (value === null || value === undefined) {\r\n      this._inlineerrorenabled = null;\r\n    } else {\r\n      this._inlineerrorenabled = convertToBoolean(value);\r\n    }\r\n  }\r\n  /**\r\n   * Aktiviert oder Deaktiviert die Inline Errors für das Control\r\n   */\r\n  get inlineerrorenabled(): boolean {\r\n    return this._inlineerrorenabled;\r\n  }\r\n\r\n  /**\r\n   * Vertikale oder horizontale Orientierung des Formulars zurück\r\n   */\r\n  public getOrientation(): string {\r\n    switch (this.orientation.toLowerCase()) {\r\n      case 'horizontal':\r\n        return 'horizontal';\r\n      case 'vertical':\r\n        return 'vertical';\r\n      case 'none':\r\n        return 'none';\r\n      default:\r\n        throw new Error(\r\n          'Invalid formtype at SacFormCommon. Valid values are horizontal, vertical, none'\r\n        );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gibt die NgForm Instanz zurück\r\n   */\r\n  public getForm(): NgForm {\r\n    return this.form;\r\n  }\r\n\r\n  /**\r\n   * Konstruktor\r\n   * @param form Instanz von NgForm\r\n   */\r\n  constructor(private form: NgForm) {\r\n    this.form.options = { updateOn: this._updateon };\r\n  }\r\n\r\n  /**\r\n   * Markiert alle Controls innerhalb des Formulares als Touched\r\n   */\r\n  public markAsTouched(): void {\r\n    if (this.form && this.form.invalid) {\r\n      this.markAsTouchedInternal(this.form.controls);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Aktualisiert die Werte und den Gültigkeitsstatus des Formulars\r\n   */\r\n  public updateValueAndValidity(markAsTouched: boolean = true): void {\r\n    // Update all Controls\r\n    this.updateValueAndValidityInternal(this.form.controls);\r\n    // Update Main Form\r\n    this.getForm().form.updateValueAndValidity();\r\n\r\n    // Mark all Controls as Touched\r\n    if (markAsTouched) {\r\n      this.markAsTouched();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Markiert alle Controls inkl. dem Tree als Touched\r\n   * @param controls Controls Collection\r\n   */\r\n  private markAsTouchedInternal(controls: { [key: string]: AbstractControl }) {\r\n    const keyList: string[] = Object.keys(controls);\r\n\r\n    for (const field of keyList) {\r\n      const control = controls[field];\r\n      if (control instanceof UntypedFormGroup) {\r\n        this.markAsTouchedInternal(control.controls);\r\n      } else {\r\n        control.markAsTouched({ onlySelf: true });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Aktualisiert die Werte und die gültigkeit des Formulars\r\n   * @param controls Controls Collection\r\n   */\r\n  private updateValueAndValidityInternal(controls: {\r\n    [key: string]: AbstractControl;\r\n  }) {\r\n    const keyList: string[] = Object.keys(controls);\r\n\r\n    for (const field of keyList) {\r\n      const control = controls[field];\r\n      if (control instanceof UntypedFormGroup) {\r\n        this.updateValueAndValidityInternal(control.controls);\r\n      } else {\r\n        control.updateValueAndValidity({ onlySelf: true });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gibt zurück, ob die Inline Error Meldungen für das Formular aktiv sind.\r\n   */\r\n  public get IsInlineErrorEnabled(): boolean {\r\n    return this._inlineerrorenabled !== false;\r\n  }\r\n}\r\n"]}

package/esm2022/controls/grid/grid.mjs

@@ -0,0 +1,157 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { SortDescriptor, SortOrder } from './model';
+import * as i0 from "@angular/core";
+/**
+ * Basis Komponente für SacGrid
+ */
+class SacGridCommon {
+    /**
+     * Konstruktor
+     * @param cd Change Detection Service
+     */
+    constructor(cd) {
+        this.cd = cd;
+        /**
+         * Private Property. Enthielt die Column Menge. Type: number. Default ist 0
+         */
+        this.ColumnCount = 0;
+        /**
+         * Protected Property. Enthielt Array of Pages. Default value: empty array []
+         */
+        this.paginators = [];
+        /**
+         * Protected Property. Enthielt die Nummer der aktiven Seite. Type: number. Default ist 1
+         */
+        this.activePage = 1;
+        /**
+         * Protected Property. Enthielt die Nummer der ersten angezeigtenen Seite in Pager. Type: number. Default ist 1
+         */
+        this.firstPageNumber = 1;
+        /**
+         * Text in Pager für 'Seite x von y'.
+         * Folgende Interpolation Texte sind vorhanden:
+         * {{CURRENTPAGE}}: Aktuelle Seite
+         * {{TOTALPAGES}}: Anzahl Seiten
+         */
+        this.pagingtext = 'PAGING_PAGEOFTEXT';
+        /**
+         * Text in Page für Anzahl Seitenelemente pro Seite
+         * Folgende Interpolation Texte sind vorhanden:
+         * {{PAGESIZE}}: Anzahl Elemente pro Seite
+         */
+        this.pagesizetext = 'PAGING_PAGEENTRIESTEXT';
+        /**
+         * Definiert die Anzahl der Elemente pro Seite die ausgewählt werden können
+         */
+        this.pagesizes = '20|50|100';
+        /**
+         * Deaktiviert die Auswahl der PageSize im Pager
+         */
+        this.pagesizedisabled = false;
+        /**
+         * Output EventEmitter. Wird aufgerufen wenn das Pager geklickt ist.
+         */
+        this.paging = new EventEmitter();
+        /**
+         * Output EventEmitter. Wird aufgerufen wenn ein Header geklickt ist, damit das Column soritert wird.
+         */
+        this.sorting = new EventEmitter();
+        //#endregion
+        /**
+         * Aktuelle Sortierung
+         */
+        this.sortDirection = SortOrder.None;
+        /**
+         * Aktuell Sortierte Spalte
+         */
+        this.sortColumn = '';
+    }
+    /**
+     * Setzt die neue Seite
+     * @param newStartIndex Neuer Seiten Index (Zero-Based)
+     */
+    pageChange(newStartIndex) {
+        this.paging.emit(newStartIndex);
+    }
+    /**
+     * Die Methode erhöht die Column-Stücke um eins
+     */
+    RegisterColumn() {
+        this.ColumnCount++;
+        // Detect Changes ausführen, da ColumnChange nach OnInit ausgeführt wird.
+        this.cd.detectChanges();
+    }
+    /**
+     * Die Methode verringert die Column-Stücke um eins
+     */
+    UnregisterColumn() {
+        this.ColumnCount--;
+    }
+    /**
+     * Die Methode deffiniert das Sortierung Flow
+     */
+    SortBy(command) {
+        let direction;
+        if (command === this.sortColumn) {
+            switch (this.sortDirection) {
+                case SortOrder.None:
+                case SortOrder.Descending:
+                    direction = SortOrder.Ascending;
+                    break;
+                case SortOrder.Ascending:
+                    direction = SortOrder.Descending;
+                    break;
+            }
+        }
+        else {
+            direction = SortOrder.Ascending;
+        }
+        const result = new SortDescriptor();
+        result.SortColumn = command;
+        result.SortOrder = direction;
+        this.sorting.emit(result);
+    }
+    /**
+     * Model für Sortierung
+     * @param sortDescription Settings für aktuelle sortierung
+     */
+    set sortdata(sortDescription) {
+        this.sortColumn = sortDescription.SortColumn;
+        this.sortDirection = sortDescription.SortOrder;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacGridCommon, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacGridCommon, inputs: { value: "value", pagerdata: "pagerdata", name: "name", emptytext: "emptytext", pagingtext: "pagingtext", pagesizetext: "pagesizetext", pagesizes: "pagesizes", pagesizedisabled: "pagesizedisabled", maxvisiblepagenumbers: "maxvisiblepagenumbers", headers: "headers", body: "body", sortdata: "sortdata" }, outputs: { paging: "paging", sorting: "sorting" }, ngImport: i0 }); }
+}
+export { SacGridCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacGridCommon, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { value: [{
+                type: Input
+            }], pagerdata: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], emptytext: [{
+                type: Input
+            }], pagingtext: [{
+                type: Input
+            }], pagesizetext: [{
+                type: Input
+            }], pagesizes: [{
+                type: Input
+            }], pagesizedisabled: [{
+                type: Input
+            }], maxvisiblepagenumbers: [{
+                type: Input
+            }], headers: [{
+                type: Input
+            }], body: [{
+                type: Input
+            }], paging: [{
+                type: Output
+            }], sorting: [{
+                type: Output
+            }], sortdata: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/grid/grid.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Directive, EventEmitter, Input, Output, TemplateRef } from '@angular/core';\r\nimport { PagerData, PagerRequest, SortDescriptor, SortOrder } from './model';\r\n\r\n/**\r\n * Basis Komponente für SacGrid\r\n */\r\n@Directive()\r\nexport abstract class SacGridCommon {\r\n\r\n  /**\r\n   * Konstruktor\r\n   * @param cd Change Detection Service\r\n   */\r\n  constructor(private cd: ChangeDetectorRef) { }\r\n\r\n  /**\r\n   * Private Property. Enthielt die Column Menge. Type: number. Default ist 0\r\n   */\r\n  public ColumnCount: number = 0;\r\n\r\n  /**\r\n   * Protected Property. Enthielt Array of Pages. Default value: empty array []\r\n   */\r\n  protected paginators: Array<any> = [];\r\n\r\n  /**\r\n   * Protected Property. Enthielt die Nummer der aktiven Seite. Type: number. Default ist 1\r\n   */\r\n  protected activePage: number = 1;\r\n\r\n  /**\r\n   * Protected Property. Enthielt die Nummer der ersten angezeigtenen Seite in Pager. Type: number. Default ist 1\r\n   */\r\n  protected firstPageNumber: number = 1;\r\n\r\n  // protected firstVisibleIndex: number = 1;\r\n  // protected lastVisibleIndex;\r\n\r\n  /**\r\n   * Protected Property. Enthielt die Nummer der letzen Seite in Pager. Type: number. Default ist undefined/null\r\n   */\r\n  protected lastPageNumber: number;\r\n\r\n  //#region Input and Outputs\r\n\r\n  /**\r\n   * Grid Daten\r\n   */\r\n  @Input()\r\n  public value: any;\r\n\r\n  /**\r\n   * Pager Settings\r\n   *\r\n   * Pager kann ausgeschaltet werden, in dem PagerData auf NULL gesetzt wird.\r\n   */\r\n  @Input()\r\n  public pagerdata: PagerData;\r\n\r\n  /**\r\n   * Input property für Name.\r\n   */\r\n  @Input()\r\n  public name: string;\r\n\r\n  /**\r\n   * Text welcher angezeigt wird, wenn keine Rows verfügbar sind.\r\n   */\r\n  @Input()\r\n  public emptytext: string;\r\n\r\n  /**\r\n   * Text in Pager für 'Seite x von y'.\r\n   * Folgende Interpolation Texte sind vorhanden:\r\n   * {{CURRENTPAGE}}: Aktuelle Seite\r\n   * {{TOTALPAGES}}: Anzahl Seiten\r\n   */\r\n  @Input()\r\n  public pagingtext: string = 'PAGING_PAGEOFTEXT';\r\n\r\n  /**\r\n   * Text in Page für Anzahl Seitenelemente pro Seite\r\n   * Folgende Interpolation Texte sind vorhanden:\r\n   * {{PAGESIZE}}: Anzahl Elemente pro Seite\r\n   */\r\n  @Input()\r\n  public pagesizetext: string = 'PAGING_PAGEENTRIESTEXT';\r\n\r\n  /**\r\n   * Definiert die Anzahl der Elemente pro Seite die ausgewählt werden können\r\n   */\r\n  @Input()\r\n  public pagesizes: string = '20|50|100';\r\n\r\n  /**\r\n   * Deaktiviert die Auswahl der PageSize im Pager\r\n   */\r\n  @Input()\r\n  public pagesizedisabled: boolean = false;\r\n\r\n  /**\r\n   * Input property für die maximalle Seiten die sichtbar sind. Type: number.\r\n   */\r\n  @Input() maxvisiblepagenumbers: number;\r\n\r\n  /**\r\n   * Input property für headers. Type: TemplateRef<any>.\r\n   */\r\n  @Input() headers: TemplateRef<any>;\r\n\r\n  /**\r\n   * Input property für body. Type: TemplateRef<any>.\r\n   */\r\n  @Input() body: TemplateRef<any>;\r\n\r\n  /**\r\n   * Output EventEmitter. Wird aufgerufen wenn das Pager geklickt ist.\r\n   */\r\n  @Output() paging: EventEmitter<PagerRequest> = new EventEmitter<PagerRequest>();\r\n\r\n  /**\r\n   * Output EventEmitter. Wird aufgerufen wenn ein Header geklickt ist, damit das Column soritert wird.\r\n   */\r\n  @Output() sorting: EventEmitter<SortDescriptor> = new EventEmitter<SortDescriptor>();\r\n\r\n  //#endregion\r\n\r\n  /**\r\n   * Aktuelle Sortierung\r\n   */\r\n  public sortDirection: SortOrder = SortOrder.None;\r\n\r\n  /**\r\n   * Aktuell Sortierte Spalte\r\n   */\r\n  public sortColumn: string = '';\r\n\r\n  /**\r\n   * Setzt die neue Seite\r\n   * @param newStartIndex Neuer Seiten Index (Zero-Based)\r\n   */\r\n  pageChange(newStartIndex) {\r\n    this.paging.emit(newStartIndex);\r\n  }\r\n\r\n  /**\r\n   * Die Methode erhöht die Column-Stücke um eins\r\n   */\r\n  public RegisterColumn() {\r\n    this.ColumnCount++;\r\n    // Detect Changes ausführen, da ColumnChange nach OnInit ausgeführt wird.\r\n    this.cd.detectChanges();\r\n  }\r\n\r\n  /**\r\n   * Die Methode verringert die Column-Stücke um eins\r\n   */\r\n  public UnregisterColumn() {\r\n    this.ColumnCount--;\r\n  }\r\n\r\n  /**\r\n   * Die Methode deffiniert das Sortierung Flow\r\n   */\r\n  public SortBy(command) {\r\n    let direction: SortOrder;\r\n\r\n    if (command === this.sortColumn) {\r\n\r\n      switch (this.sortDirection) {\r\n        case SortOrder.None:\r\n        case SortOrder.Descending:\r\n          direction = SortOrder.Ascending;\r\n          break;\r\n        case SortOrder.Ascending:\r\n          direction = SortOrder.Descending;\r\n          break;\r\n      }\r\n\r\n    } else {\r\n      direction = SortOrder.Ascending;\r\n    }\r\n\r\n    const result: SortDescriptor = new SortDescriptor();\r\n    result.SortColumn = command;\r\n    result.SortOrder = direction;\r\n\r\n    this.sorting.emit(result);\r\n  }\r\n\r\n  /**\r\n   * Model für Sortierung\r\n   * @param sortDescription Settings für aktuelle sortierung\r\n   */\r\n  @Input()\r\n  public set sortdata(sortDescription: SortDescriptor) {\r\n    this.sortColumn = sortDescription.SortColumn;\r\n    this.sortDirection = sortDescription.SortOrder;\r\n  }\r\n}\r\n"]}

package/esm2022/controls/grid/gridbutton.mjs

@@ -0,0 +1,60 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Base Grid Action Button
+ */
+class SacGridButtonCommon {
+    constructor() {
+        /**
+         * Input Property für Styling des Buttons. Deffiniert die Css Klassen des Buttons
+         */
+        this.iconstyle = '';
+        /**
+         * Button ist deaktiviert
+         */
+        this._isdisabledvalue = false;
+        /**
+         * Event wenn auf den Button geklickt wird
+         */
+        this.clicked = new EventEmitter();
+    }
+    /**
+     * Deaktivieren von Buttons
+     * @param v Deaktiviert den Button
+     * @return Definiert ob der Button deaktiviert ist
+     */
+    set isdisabled(v) {
+        if (v === null || v === undefined || typeof v === 'boolean') {
+            this._isdisabledvalue = v;
+        }
+        else {
+            this._isdisabledvalue = v === 'true';
+        }
+    }
+    get isdisabled() {
+        return this._isdisabledvalue;
+    }
+    /**
+     * Die Methode wird das cklickaction Emitter aktivieren
+     */
+    callaction() {
+        if (!this._isdisabledvalue) {
+            this.clicked.emit(this.iconstyle);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacGridButtonCommon, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacGridButtonCommon, inputs: { iconstyle: "iconstyle", icon: "icon", isdisabled: "isdisabled" }, outputs: { clicked: "clicked" }, ngImport: i0 }); }
+}
+export { SacGridButtonCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacGridButtonCommon, decorators: [{
+            type: Directive
+        }], propDecorators: { iconstyle: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], isdisabled: [{
+                type: Input
+            }], clicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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