@porscheinformatik/clr-addons 15.0.1 → 15.2.0

package/esm2020/daterangepicker/validators/daterange-min.validator.mjs

@@ -0,0 +1,85 @@
+import { Directive, forwardRef, Input, Optional } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import { DaterangeService } from '../providers/daterange.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../providers/daterange.service";
+/**
+ * Validator for daterangepicker to validate that 'from' date is not before 'min' value.
+ * Otherwise will throw corresponding `min` validation error.
+ *
+ * Validator is applied to the ClrDaterangepickerDirective with `min` attribute.
+ * Or when set manually with `clrDaterangeMin` attribute.
+ *
+ * Validator is active by default when applied. It can be disabled with: `[clrDaterangeMin]="false"`
+ */
+export class ClrDaterangeMinValidator {
+    constructor(daterangeService) {
+        this.daterangeService = daterangeService;
+        this._active = true;
+    }
+    /**
+     * Disable validator by setting value to `false`.
+     */
+    set active(active) {
+        this._active = active == null || (active !== false && `${active}` !== 'false');
+    }
+    /**
+     * Validator method. Method that performs synchronous validation against the provided control.
+     * @param control - The control to validate against.
+     * @returns A map of validation errors if validation fails, otherwise null.
+     */
+    validate(control) {
+        if (!this._active) {
+            return null;
+        }
+        if (control.value == null) {
+            return null;
+        }
+        const min = this.daterangeService.minDate;
+        if (min == null) {
+            return null;
+        }
+        const { from } = control.value;
+        if (from == null) {
+            return null;
+        }
+        if (from.isBefore(min)) {
+            return {
+                [ClrDaterangeMinValidator.validationErrorName]: {
+                    min,
+                    actual: from,
+                },
+            };
+        }
+        return null;
+    }
+}
+/** Validation error name. */
+ClrDaterangeMinValidator.validationErrorName = 'min';
+ClrDaterangeMinValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangeMinValidator, deps: [{ token: i1.DaterangeService, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ClrDaterangeMinValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.1", type: ClrDaterangeMinValidator, selector: "[clrDaterangepicker][min], [clrDaterangeMin]", inputs: { active: ["clrDaterangeMin", "active"] }, providers: [
+        {
+            provide: NG_VALIDATORS,
+            useExisting: forwardRef(() => ClrDaterangeMinValidator),
+            multi: true,
+        },
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangeMinValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrDaterangepicker][min], [clrDaterangeMin]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => ClrDaterangeMinValidator),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DaterangeService, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { active: [{
+                type: Input,
+                args: ['clrDaterangeMin']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/daterangepicker/validators/daterange-order.validator.mjs

@@ -0,0 +1,75 @@
+import { Directive, forwardRef, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Validator for daterangepicker to validate that 'from' date is before 'to' date.
+ * Otherwise will throw `fromIsAfterTo` validation error.
+ *
+ * This validator is applied automatically on ClrDaterangepickerDirective.
+ * Or when set manually with `clrDaterangeOrder` attribute.
+ *
+ * Validator is active by default when applied. It can be disabled with: `[clrDaterangeOrder]="false"`
+ */
+export class ClrDaterangeOrderValidator {
+    constructor() {
+        this._active = true;
+    }
+    /**
+     * Disable validator by setting value to `false`.
+     */
+    set active(active) {
+        this._active = active == null || (active !== false && `${active}` !== 'false');
+    }
+    /**
+     * Validator method. Method that performs synchronous validation against the provided control.
+     * @param control - The control to validate against.
+     * @returns A map of validation errors if validation fails, otherwise null.
+     */
+    validate(control) {
+        if (!this._active) {
+            return null;
+        }
+        // Validation with `null` value is done with the regular required validator.
+        if (control.value == null) {
+            return null;
+        }
+        const { from, to } = control.value;
+        // Validation with `null` values from 'from' & 'to' is done with the ClrDaterangeRequiredValidator.
+        if (from == null || to == null) {
+            return null;
+        }
+        if (from.isAfter(to)) {
+            return {
+                [ClrDaterangeOrderValidator.validationErrorName]: control.value,
+            };
+        }
+        return null;
+    }
+}
+/** Validation error name. */
+ClrDaterangeOrderValidator.validationErrorName = 'fromIsAfterTo';
+ClrDaterangeOrderValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangeOrderValidator, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ClrDaterangeOrderValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.1", type: ClrDaterangeOrderValidator, selector: "[clrDaterangepicker], [clrDaterangeOrder]", inputs: { active: ["clrDaterangeOrder", "active"] }, providers: [
+        {
+            provide: NG_VALIDATORS,
+            useExisting: forwardRef(() => ClrDaterangeOrderValidator),
+            multi: true,
+        },
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangeOrderValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrDaterangepicker], [clrDaterangeOrder]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => ClrDaterangeOrderValidator),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { active: [{
+                type: Input,
+                args: ['clrDaterangeOrder']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/daterangepicker/validators/daterange-required.validator.mjs

@@ -0,0 +1,71 @@
+import { Directive, forwardRef, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Validator for daterangepicker to validate that 'from' *AND* 'to' date are not `null`.
+ * Will throw `required` validation error.
+ *
+ * Validator is applied to the ClrDaterangepickerDirective with `required` attribute.
+ * Or when set manually with `clrDaterangeRequired` attribute.
+ *
+ * Validator is active by default when applied. It can be disabled with: `[clrDaterangeRequired]="false"`
+ */
+export class ClrDaterangeRequiredValidator {
+    constructor() {
+        this._active = true;
+    }
+    /**
+     * Disable validator by setting value to `false`.
+     */
+    set active(active) {
+        this._active = active == null || (active !== false && `${active}` !== 'false');
+    }
+    /**
+     * Validator method. Method that performs synchronous validation against the provided control.
+     * @param control - The control to validate against.
+     * @returns A map of validation errors if validation fails, otherwise null.
+     */
+    validate(control) {
+        if (!this._active) {
+            return null;
+        }
+        // Validation with `null` value is done with the regular required validator.
+        if (control.value == null) {
+            return null;
+        }
+        const { from, to } = control.value;
+        if (from == null || to == null) {
+            return {
+                [ClrDaterangeRequiredValidator.validationErrorName]: control.value,
+            };
+        }
+        return null;
+    }
+}
+/** Validation error name. */
+ClrDaterangeRequiredValidator.validationErrorName = 'required';
+ClrDaterangeRequiredValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangeRequiredValidator, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ClrDaterangeRequiredValidator.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.1", type: ClrDaterangeRequiredValidator, selector: "[clrDaterangepicker][required], [clrDaterangeRequired]", inputs: { active: ["clrDaterangeRequired", "active"] }, providers: [
+        {
+            provide: NG_VALIDATORS,
+            useExisting: forwardRef(() => ClrDaterangeRequiredValidator),
+            multi: true,
+        },
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangeRequiredValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrDaterangepicker][required], [clrDaterangeRequired]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => ClrDaterangeRequiredValidator),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { active: [{
+                type: Input,
+                args: ['clrDaterangeRequired']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/index.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2022 Porsche Informatik. All Rights Reserved.
+ * Copyright (c) 2018-2023 Porsche Informatik. All Rights Reserved.
  * This software is released under MIT license.
  * The full license information can be found in LICENSE in the root directory of this project.
  */
@@ -34,4 +34,5 @@ export * from './autocomplete-off/index';
 export * from './abstract-form-component/index';
 export * from './dropdown/index';
 export * from './datagrid/index';
-//# sourceMappingURL=data:application/json;base64,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
+export * from './daterangepicker/index';
+//# sourceMappingURL=data:application/json;base64,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