@quadrel-enterprise-ui/framework 1.0.0 → 18.19.2

package/esm2022/lib/forms/shared/validators/validators.mjs

@@ -0,0 +1,247 @@
+import { FormControl, Validators } from '@angular/forms';
+import moment from 'moment';
+import { TimePickerService } from '../../datepicker/service/timepicker.service';
+function hasUnit(control) {
+    return control.value?.value != null && control.value?.unit != null;
+}
+export class QdValidators {
+    /**
+     * Validates that the value of the form field is at least the specified minimum.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.min(3));
+     * new QdFormControl('', QdValidators.min(3, 'custom-error'));
+     * ```
+     */
+    static min(min, errorKey = 'i18n.qd.form.error.min') {
+        const validFn = (control) => {
+            if (hasUnit(control))
+                return Validators.min(min)(new FormControl(control.value.value)) ? { min: errorKey } : null;
+            return Validators.min(min)(control) ? { min: errorKey } : null;
+        };
+        return validFn;
+    }
+    /**
+     * Validates that the value of the form field does not exceed the specified maximum.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.max(10));
+     * new QdFormControl('', QdValidators.max(10, 'custom-error'));
+     * ```
+     */
+    static max(max, errorKey = 'i18n.qd.form.error.max') {
+        const validFn = (control) => {
+            if (hasUnit(control))
+                return Validators.max(max)(new FormControl(control.value.value)) ? { max: errorKey } : null;
+            return Validators.max(max)(control) ? { max: errorKey } : null;
+        };
+        return validFn;
+    }
+    /**
+     * Ensures that the form field is not empty.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.required());
+     * new QdFormControl('', QdValidators.required('custom-error'));
+     * ```
+     */
+    static required(errorKey = 'i18n.qd.form.error.required') {
+        const validFn = (control) => {
+            if (Array.isArray(control.value))
+                return Validators.required(control) ? { required: errorKey } : null;
+            return this.isEmptyInputValue(control.value) ? { required: errorKey } : null;
+        };
+        return validFn;
+    }
+    static isEmptyInputValue(value) {
+        if (value !== null && typeof value === 'object') {
+            return Object.keys(value).some(key => this.isEmptyInputValue(value[key]));
+        }
+        return value == null || (typeof value === 'string' && value.length === 0);
+    }
+    /**
+     * Validates that the form field contains a valid email address.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.email());
+     * new QdFormControl('', QdValidators.email('custom-error'));
+     * ```
+     */
+    static email(errorKey = 'i18n.qd.form.error.email') {
+        // regex from https://regexr.com/ community patterns "RFC2822 Email Validation"
+        const emailValidatorRegex = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
+        const validFn = (control) => Validators.pattern(emailValidatorRegex)(control) ? { email: errorKey } : null;
+        return validFn;
+    }
+    /**
+     * Ensures that the form field contains at least the specified number of characters.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.minLength(3));
+     * new QdFormControl('', QdValidators.minLength(3, 'custom-error'));
+     * ```
+     */
+    static minLength(minLength, errorKey = 'i18n.qd.form.error.minLength') {
+        const validFn = (control) => {
+            if (hasUnit(control))
+                return Validators.minLength(minLength)(new FormControl(control.value.value)) ? { minLength: errorKey } : null;
+            return Validators.minLength(minLength)(control) ? { minLength: errorKey } : null;
+        };
+        return validFn;
+    }
+    /**
+     * Ensures that the form field contains no more than the specified number of characters.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.maxLength(10));
+     * new QdFormControl('', QdValidators.maxLength(10, 'custom-error'));
+     * ```
+     */
+    static maxLength(maxLength, errorKey = 'i18n.qd.form.error.maxLength') {
+        const validFn = (control) => {
+            if (hasUnit(control))
+                return Validators.maxLength(maxLength)(new FormControl(control.value.value)) ? { maxLength: errorKey } : null;
+            return Validators.maxLength(maxLength)(control) ? { maxLength: errorKey } : null;
+        };
+        validFn.maxLength = maxLength;
+        return validFn;
+    }
+    /**
+     * Ensures that the form field matches a given regular expression pattern.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.pattern(/\d/));
+     * new QdFormControl('', QdValidators.pattern('[A-Za-z]+'));
+     * new QdFormControl('', QdValidators.pattern(/\d/, 'custom-error'));
+     * ```
+     */
+    static pattern(pattern, errorKey = 'i18n.qd.form.error.pattern') {
+        const validFn = (control) => {
+            if (hasUnit(control))
+                return Validators.pattern(pattern)(new FormControl(control.value.value)) ? { pattern: errorKey } : null;
+            return Validators.pattern(pattern)(control) ? { pattern: errorKey } : null;
+        };
+        return validFn;
+    }
+    /**
+     * Ensures that the form field contains a valid date.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.date());
+     * new QdFormControl(new Date(), QdValidators.date());
+     * new QdFormControl(new Date(), QdValidators.date('date-error'));
+     * ```
+     */
+    static date(errorKey = 'i18n.qd.form.error.date') {
+        return ({ value }) => {
+            if (!value)
+                return null;
+            const localizedFormat = moment().locale('de').format('L');
+            const formattedErrorKey = { date: { key: errorKey, params: { format: localizedFormat } } };
+            if (value === 'Invalid Date')
+                return formattedErrorKey;
+            if (!(value instanceof Date) || isNaN(value.getTime()))
+                return formattedErrorKey;
+            return null;
+        };
+    }
+    /**
+     * Ensures that the selected date is not within a range of disabled dates.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.disabledDates([{ from: new Date('2025-01-01') }]));
+     * ```
+     */
+    static disabledDates(disabledDates, errorKey = 'i18n.qd.form.error.disabledDates') {
+        const validFn = (control) => {
+            if (!control.value || isNaN(control.value?.getTime?.()))
+                return null;
+            const date = moment(control.value.getTime());
+            return this.isDateDisabled(disabledDates, date) ? { disabledDates: errorKey } : null;
+        };
+        return validFn;
+    }
+    static isDateDisabled(disabledDates, date) {
+        return disabledDates.some(disabledDate => {
+            let fromDate = moment(disabledDate.from);
+            let toDate = moment(disabledDate.to);
+            if (!disabledDate.from)
+                fromDate = moment('1900-01-01T00:00:00.000Z');
+            if (!disabledDate.to)
+                toDate = moment('2100-01-01T00:00:00.000Z');
+            return date.isAfter(fromDate, 'day') && date.isBefore(toDate, 'day');
+        });
+    }
+    /**
+     * Ensures that the selected time is not within a range of disabled times.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl('', QdValidators.disabledTimes([{ from: '15:00' }]));
+     * ```
+     */
+    static disabledTimes(disabledTimes, errorKey = 'i18n.qd.form.error.disabledTimes') {
+        const validFn = (control) => {
+            if (!control.value || isNaN(control.value?.getTime?.()))
+                return null;
+            const time = moment(control.value).format('HH:mm');
+            return TimePickerService.isTimeDisabled(time, disabledTimes) ? { disabledTimes: errorKey } : null;
+        };
+        return validFn;
+    }
+    /**
+     * Ensures that the selected file does not exceed the given maximum size in megabytes.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl(null, QdValidators.fileSize(5));
+     * new QdFormControl(null, QdValidators.fileSize(10, 'custom-error'));
+     * ```
+     */
+    static fileSize(maxMb, errorKey = 'i18n.qd.form.error.fileSize') {
+        return (control) => {
+            const file = control.value;
+            if (!file || !(file instanceof File))
+                return null;
+            const maxBytes = maxMb * 1024 * 1024;
+            return file.size > maxBytes ? { fileSize: { key: errorKey, params: { maxMb } } } : null;
+        };
+    }
+    /**
+     * Validates that the file type or file extension matches one of the accepted types.
+     *
+     * #### **Usage**
+     * ```ts
+     * new QdFormControl(null, QdValidators.fileType(['image/*', '.pdf']));
+     * new QdFormControl(null, QdValidators.fileType(['application/msword'], 'custom-error'));
+     * ```
+     */
+    static fileType(accepted, errorKey = 'i18n.qd.form.error.fileType') {
+        return (control) => {
+            const file = control.value;
+            if (!file || !(file instanceof File))
+                return null;
+            const fileName = file.name.toLowerCase();
+            const mimeType = file.type.toLowerCase();
+            const isAccepted = accepted.some(type => {
+                const t = type.toLowerCase().trim();
+                if (t.endsWith('/*')) {
+                    const baseType = t.slice(0, t.indexOf('/'));
+                    return mimeType.startsWith(`${baseType}/`);
+                }
+                return mimeType === t || fileName.endsWith(t);
+            });
+            return !isAccepted ? { fileType: { key: errorKey, params: { accepted } } } : null;
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../../../../../../libs/qd-ui/src/lib/forms/shared/validators/validators.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl, FormControl, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';\nimport moment, { Moment } from 'moment';\n\nimport { QdDisabledDates, QdDisabledTimes } from '../../model/datepicker';\nimport { TimePickerService } from '../../datepicker/service/timepicker.service';\n\nfunction hasUnit(control: AbstractControl): boolean {\n  return control.value?.value != null && control.value?.unit != null;\n}\n\nexport class QdValidators {\n  /**\n   * Validates that the value of the form field is at least the specified minimum.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.min(3));\n   * new QdFormControl('', QdValidators.min(3, 'custom-error'));\n   * ```\n   */\n  static min(min: number, errorKey = 'i18n.qd.form.error.min'): ValidatorFn {\n    const validFn = (control: AbstractControl): ValidationErrors | null => {\n      if (hasUnit(control)) return Validators.min(min)(new FormControl(control.value.value)) ? { min: errorKey } : null;\n\n      return Validators.min(min)(control) ? { min: errorKey } : null;\n    };\n\n    return validFn;\n  }\n\n  /**\n   * Validates that the value of the form field does not exceed the specified maximum.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.max(10));\n   * new QdFormControl('', QdValidators.max(10, 'custom-error'));\n   * ```\n   */\n  static max(max: number, errorKey = 'i18n.qd.form.error.max'): ValidatorFn {\n    const validFn = (control: AbstractControl): ValidationErrors | null => {\n      if (hasUnit(control)) return Validators.max(max)(new FormControl(control.value.value)) ? { max: errorKey } : null;\n\n      return Validators.max(max)(control) ? { max: errorKey } : null;\n    };\n\n    return validFn;\n  }\n\n  /**\n   * Ensures that the form field is not empty.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.required());\n   * new QdFormControl('', QdValidators.required('custom-error'));\n   * ```\n   */\n  static required(errorKey = 'i18n.qd.form.error.required'): ValidatorFn {\n    const validFn = (control: AbstractControl): ValidationErrors | null => {\n      if (Array.isArray(control.value)) return Validators.required(control) ? { required: errorKey } : null;\n\n      return this.isEmptyInputValue(control.value) ? { required: errorKey } : null;\n    };\n\n    return validFn;\n  }\n\n  private static isEmptyInputValue(value: unknown): boolean {\n    if (value !== null && typeof value === 'object') {\n      return Object.keys(value).some(key => this.isEmptyInputValue((value as Record<string, unknown>)[key]));\n    }\n\n    return value == null || (typeof value === 'string' && value.length === 0);\n  }\n\n  /**\n   * Validates that the form field contains a valid email address.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.email());\n   * new QdFormControl('', QdValidators.email('custom-error'));\n   * ```\n   */\n  static email(errorKey = 'i18n.qd.form.error.email'): ValidatorFn {\n    // regex from https://regexr.com/ community patterns \"RFC2822 Email Validation\"\n    const emailValidatorRegex =\n      /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;\n\n    const validFn = (control: AbstractControl): ValidationErrors | null =>\n      Validators.pattern(emailValidatorRegex)(control) ? { email: errorKey } : null;\n\n    return validFn;\n  }\n\n  /**\n   * Ensures that the form field contains at least the specified number of characters.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.minLength(3));\n   * new QdFormControl('', QdValidators.minLength(3, 'custom-error'));\n   * ```\n   */\n  static minLength(minLength: number, errorKey = 'i18n.qd.form.error.minLength'): ValidatorFn {\n    const validFn = (control: AbstractControl): ValidationErrors | null => {\n      if (hasUnit(control))\n        return Validators.minLength(minLength)(new FormControl(control.value.value)) ? { minLength: errorKey } : null;\n\n      return Validators.minLength(minLength)(control) ? { minLength: errorKey } : null;\n    };\n\n    return validFn;\n  }\n\n  /**\n   * Ensures that the form field contains no more than the specified number of characters.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.maxLength(10));\n   * new QdFormControl('', QdValidators.maxLength(10, 'custom-error'));\n   * ```\n   */\n  static maxLength(maxLength: number, errorKey = 'i18n.qd.form.error.maxLength'): ValidatorFn {\n    const validFn = (control: AbstractControl): ValidationErrors | null => {\n      if (hasUnit(control))\n        return Validators.maxLength(maxLength)(new FormControl(control.value.value)) ? { maxLength: errorKey } : null;\n\n      return Validators.maxLength(maxLength)(control) ? { maxLength: errorKey } : null;\n    };\n\n    validFn.maxLength = maxLength;\n    return validFn;\n  }\n\n  /**\n   * Ensures that the form field matches a given regular expression pattern.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.pattern(/\\d/));\n   * new QdFormControl('', QdValidators.pattern('[A-Za-z]+'));\n   * new QdFormControl('', QdValidators.pattern(/\\d/, 'custom-error'));\n   * ```\n   */\n  static pattern(pattern: string | RegExp, errorKey = 'i18n.qd.form.error.pattern'): ValidatorFn {\n    const validFn = (control: AbstractControl): ValidationErrors | null => {\n      if (hasUnit(control))\n        return Validators.pattern(pattern)(new FormControl(control.value.value)) ? { pattern: errorKey } : null;\n\n      return Validators.pattern(pattern)(control) ? { pattern: errorKey } : null;\n    };\n\n    return validFn;\n  }\n\n  /**\n   * Ensures that the form field contains a valid date.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.date());\n   * new QdFormControl(new Date(), QdValidators.date());\n   * new QdFormControl(new Date(), QdValidators.date('date-error'));\n   * ```\n   */\n  static date(errorKey = 'i18n.qd.form.error.date'): ValidatorFn {\n    return ({ value }: AbstractControl): ValidationErrors | null => {\n      if (!value) return null;\n\n      const localizedFormat = moment().locale('de').format('L');\n      const formattedErrorKey = { date: { key: errorKey, params: { format: localizedFormat } } };\n\n      if (value === 'Invalid Date') return formattedErrorKey;\n\n      if (!(value instanceof Date) || isNaN(value.getTime())) return formattedErrorKey;\n\n      return null;\n    };\n  }\n\n  /**\n   * Ensures that the selected date is not within a range of disabled dates.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.disabledDates([{ from: new Date('2025-01-01') }]));\n   * ```\n   */\n  static disabledDates(disabledDates: QdDisabledDates[], errorKey = 'i18n.qd.form.error.disabledDates'): ValidatorFn {\n    const validFn = (control: AbstractControl): ValidationErrors | null => {\n      if (!control.value || isNaN(control.value?.getTime?.())) return null;\n\n      const date = moment(control.value.getTime());\n\n      return this.isDateDisabled(disabledDates, date) ? { disabledDates: errorKey } : null;\n    };\n\n    return validFn;\n  }\n\n  private static isDateDisabled(disabledDates: QdDisabledDates[], date: Moment): boolean {\n    return disabledDates.some(disabledDate => {\n      let fromDate = moment(disabledDate.from);\n      let toDate = moment(disabledDate.to);\n      if (!disabledDate.from) fromDate = moment('1900-01-01T00:00:00.000Z');\n      if (!disabledDate.to) toDate = moment('2100-01-01T00:00:00.000Z');\n\n      return date.isAfter(fromDate, 'day') && date.isBefore(toDate, 'day');\n    });\n  }\n\n  /**\n   * Ensures that the selected time is not within a range of disabled times.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl('', QdValidators.disabledTimes([{ from: '15:00' }]));\n   * ```\n   */\n  static disabledTimes(disabledTimes: QdDisabledTimes[], errorKey = 'i18n.qd.form.error.disabledTimes'): ValidatorFn {\n    const validFn = (control: AbstractControl): ValidationErrors | null => {\n      if (!control.value || isNaN(control.value?.getTime?.())) return null;\n\n      const time = moment(control.value).format('HH:mm');\n\n      return TimePickerService.isTimeDisabled(time, disabledTimes) ? { disabledTimes: errorKey } : null;\n    };\n\n    return validFn;\n  }\n\n  /**\n   * Ensures that the selected file does not exceed the given maximum size in megabytes.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl(null, QdValidators.fileSize(5));\n   * new QdFormControl(null, QdValidators.fileSize(10, 'custom-error'));\n   * ```\n   */\n  static fileSize(maxMb: number, errorKey = 'i18n.qd.form.error.fileSize'): ValidatorFn {\n    return (control: AbstractControl): ValidationErrors | null => {\n      const file = control.value as File | null;\n\n      if (!file || !(file instanceof File)) return null;\n\n      const maxBytes = maxMb * 1024 * 1024;\n\n      return file.size > maxBytes ? { fileSize: { key: errorKey, params: { maxMb } } } : null;\n    };\n  }\n\n  /**\n   * Validates that the file type or file extension matches one of the accepted types.\n   *\n   * #### **Usage**\n   * ```ts\n   * new QdFormControl(null, QdValidators.fileType(['image/*', '.pdf']));\n   * new QdFormControl(null, QdValidators.fileType(['application/msword'], 'custom-error'));\n   * ```\n   */\n  static fileType(accepted: string[], errorKey = 'i18n.qd.form.error.fileType'): ValidatorFn {\n    return (control: AbstractControl): ValidationErrors | null => {\n      const file = control.value as File | null;\n\n      if (!file || !(file instanceof File)) return null;\n\n      const fileName = file.name.toLowerCase();\n      const mimeType = file.type.toLowerCase();\n\n      const isAccepted = accepted.some(type => {\n        const t = type.toLowerCase().trim();\n        if (t.endsWith('/*')) {\n          const baseType = t.slice(0, t.indexOf('/'));\n\n          return mimeType.startsWith(`${baseType}/`);\n        }\n\n        return mimeType === t || fileName.endsWith(t);\n      });\n\n      return !isAccepted ? { fileType: { key: errorKey, params: { accepted } } } : null;\n    };\n  }\n}\n"]}

package/esm2022/lib/forms/switches/switch/switch.component.mjs

@@ -0,0 +1,102 @@
+// @ts-strict-ignore
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { v4 as uuid } from 'uuid';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+export class QdSwitchComponent {
+    // TODO: Refactor FormInput for better internal interface
+    inputData;
+    value;
+    id;
+    disabled = false;
+    testId = 'switch';
+    valueChange = new EventEmitter();
+    get active() {
+        return this.inputData.active;
+    }
+    get isDisabled() {
+        return this.inputData.disabled || this.disabled;
+    }
+    get toggleId() {
+        const uid = this.inputData ? this.inputData.value + this.id : this.id;
+        return `switch-toggle-${uid}`;
+    }
+    get label() {
+        return this.inputData.i18n;
+    }
+    get labelPosition() {
+        return this.inputData.labelPosition || 'right';
+    }
+    _onChange = () => { };
+    _onTouch = () => { };
+    ngOnInit() {
+        if (!this.id) {
+            this.id = uuid();
+        }
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+        this._onChange(this.value);
+    }
+    registerOnTouched(fn) {
+        this._onTouch = fn;
+    }
+    setDisabledState(state) {
+        this.disabled = state;
+    }
+    writeValue(value) {
+        this.value = value;
+        this.valueChange.emit(this.value);
+    }
+    handleClick(value, event) {
+        event.stopPropagation();
+        if (this.disabled) {
+            return;
+        }
+        const _value = value !== this.value ? value : null;
+        this._onChange(_value);
+        this._onTouch(_value);
+        this.value = _value;
+        this.valueChange.emit(this.value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdSwitchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdSwitchComponent, selector: "qd-switch", inputs: { inputData: "inputData", value: "value", id: "id", disabled: "disabled", testId: ["data-test-id", "testId"] }, outputs: { valueChange: "valueChange" }, host: { properties: { "class.qd-switch-active": "this.active", "class.qd-switch-disabled": "this.isDisabled" }, classAttribute: "qd-switch" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: QdSwitchComponent,
+                multi: true
+            }
+        ], ngImport: i0, template: "<label [for]=\"toggleId\">\n  <div class=\"switch-content\" *ngIf=\"labelPosition === 'left'\" [attr.data-test-id]=\"testId + '-label'\">\n    {{ label | translate }}\n  </div>\n  <div class=\"switch-toggle-bar\">\n    <input\n      class=\"switch-toggle-input\"\n      name=\"switch-toggle\"\n      type=\"checkbox\"\n      [id]=\"toggleId\"\n      (click)=\"handleClick(value, $event)\"\n      [value]=\"value\"\n      [disabled]=\"isDisabled\"\n      [attr.data-test-id]=\"testId + '-input'\"\n    />\n    <div class=\"switch-toggle-button\"></div>\n  </div>\n  <div class=\"switch-content\" *ngIf=\"labelPosition === 'right'\" [attr.data-test-id]=\"testId + '-content'\">\n    {{ label | translate }}\n  </div>\n</label>\n", styles: [".qd-switch label{display:flex;width:max-content;align-items:center}.qd-switch label:hover{cursor:pointer}.qd-switch .switch-toggle-bar{position:relative;width:2.5rem;height:1.25rem;border-radius:1.25rem;background-color:#e5e5e5}.qd-switch .switch-toggle-bar input{appearance:none}.qd-switch .switch-toggle-bar .switch-toggle-button{position:absolute;top:0;width:1.25rem;height:1.25rem;border-radius:1.25rem;background-color:#b4b4b4;transition:all 80ms linear;transition-property:transform}.qd-switch .switch-content{margin-right:.75rem;margin-left:.75rem;color:#171717;font-size:.875rem;font-weight:400;line-height:.875rem}.qd-switch:hover .switch-toggle-bar{background-color:#d5d5d5}.qd-switch:hover .switch-toggle-bar .switch-toggle-button{background-color:#979797}.qd-switch.qd-switch-active .switch-toggle-bar{background-color:#c3e8cd}.qd-switch.qd-switch-active .switch-toggle-bar .switch-toggle-button{background-color:#00813a;transform:translate(1.25rem)}.qd-switch.qd-switch-active:hover .switch-toggle-bar .switch-toggle-button{background-color:#006226}.qd-switch.qd-switch-disabled label:hover{cursor:initial}.qd-switch.qd-switch-disabled .switch-toggle-bar{background-color:#efefef}.qd-switch.qd-switch-disabled .switch-toggle-bar .switch-toggle-button{background-color:#d5d5d5}.qd-switch.qd-switch-disabled .switch-content{color:#757575}.qd-switch.qd-switch-disabled:hover .switch-toggle-bar{background-color:#efefef}.qd-switch.qd-switch-disabled:hover .switch-toggle-bar .switch-toggle-button{background-color:#d5d5d5}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdSwitchComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-switch', encapsulation: ViewEncapsulation.None, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: QdSwitchComponent,
+                            multi: true
+                        }
+                    ], host: { class: 'qd-switch' }, template: "<label [for]=\"toggleId\">\n  <div class=\"switch-content\" *ngIf=\"labelPosition === 'left'\" [attr.data-test-id]=\"testId + '-label'\">\n    {{ label | translate }}\n  </div>\n  <div class=\"switch-toggle-bar\">\n    <input\n      class=\"switch-toggle-input\"\n      name=\"switch-toggle\"\n      type=\"checkbox\"\n      [id]=\"toggleId\"\n      (click)=\"handleClick(value, $event)\"\n      [value]=\"value\"\n      [disabled]=\"isDisabled\"\n      [attr.data-test-id]=\"testId + '-input'\"\n    />\n    <div class=\"switch-toggle-button\"></div>\n  </div>\n  <div class=\"switch-content\" *ngIf=\"labelPosition === 'right'\" [attr.data-test-id]=\"testId + '-content'\">\n    {{ label | translate }}\n  </div>\n</label>\n", styles: [".qd-switch label{display:flex;width:max-content;align-items:center}.qd-switch label:hover{cursor:pointer}.qd-switch .switch-toggle-bar{position:relative;width:2.5rem;height:1.25rem;border-radius:1.25rem;background-color:#e5e5e5}.qd-switch .switch-toggle-bar input{appearance:none}.qd-switch .switch-toggle-bar .switch-toggle-button{position:absolute;top:0;width:1.25rem;height:1.25rem;border-radius:1.25rem;background-color:#b4b4b4;transition:all 80ms linear;transition-property:transform}.qd-switch .switch-content{margin-right:.75rem;margin-left:.75rem;color:#171717;font-size:.875rem;font-weight:400;line-height:.875rem}.qd-switch:hover .switch-toggle-bar{background-color:#d5d5d5}.qd-switch:hover .switch-toggle-bar .switch-toggle-button{background-color:#979797}.qd-switch.qd-switch-active .switch-toggle-bar{background-color:#c3e8cd}.qd-switch.qd-switch-active .switch-toggle-bar .switch-toggle-button{background-color:#00813a;transform:translate(1.25rem)}.qd-switch.qd-switch-active:hover .switch-toggle-bar .switch-toggle-button{background-color:#006226}.qd-switch.qd-switch-disabled label:hover{cursor:initial}.qd-switch.qd-switch-disabled .switch-toggle-bar{background-color:#efefef}.qd-switch.qd-switch-disabled .switch-toggle-bar .switch-toggle-button{background-color:#d5d5d5}.qd-switch.qd-switch-disabled .switch-content{color:#757575}.qd-switch.qd-switch-disabled:hover .switch-toggle-bar{background-color:#efefef}.qd-switch.qd-switch-disabled:hover .switch-toggle-bar .switch-toggle-button{background-color:#d5d5d5}\n"] }]
+        }], propDecorators: { inputData: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], testId: [{
+                type: Input,
+                args: ['data-test-id']
+            }], valueChange: [{
+                type: Output
+            }], active: [{
+                type: HostBinding,
+                args: ['class.qd-switch-active']
+            }], isDisabled: [{
+                type: HostBinding,
+                args: ['class.qd-switch-disabled']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dpdGNoLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi9mb3Jtcy9zd2l0Y2hlcy9zd2l0Y2gvc3dpdGNoLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi9mb3Jtcy9zd2l0Y2hlcy9zd2l0Y2gvc3dpdGNoLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9CQUFvQjtBQUNwQixPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFVLE1BQU0sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMvRyxPQUFPLEVBQXdCLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDekUsT0FBTyxFQUFFLEVBQUUsSUFBSSxJQUFJLEVBQUUsTUFBTSxNQUFNLENBQUM7Ozs7QUFrQmxDLE1BQU0sT0FBTyxpQkFBaUI7SUFDNUIseURBQXlEO0lBQ2hELFNBQVMsQ0FBZ0I7SUFDekIsS0FBSyxDQUFDO0lBQ04sRUFBRSxDQUFDO0lBQ0gsUUFBUSxHQUFHLEtBQUssQ0FBQztJQUNILE1BQU0sR0FBRyxRQUFRLENBQUM7SUFFL0IsV0FBVyxHQUFHLElBQUksWUFBWSxFQUFVLENBQUM7SUFFbkQsSUFDSSxNQUFNO1FBQ1IsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQztJQUMvQixDQUFDO0lBRUQsSUFDSSxVQUFVO1FBQ1osT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDO0lBQ2xELENBQUM7SUFFRCxJQUFJLFFBQVE7UUFDVixNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO1FBQ3RFLE9BQU8saUJBQWlCLEdBQUcsRUFBRSxDQUFDO0lBQ2hDLENBQUM7SUFFRCxJQUFJLEtBQUs7UUFDUCxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDO0lBQzdCLENBQUM7SUFFRCxJQUFJLGFBQWE7UUFDZixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsYUFBYSxJQUFJLE9BQU8sQ0FBQztJQUNqRCxDQUFDO0lBRU8sU0FBUyxHQUFRLEdBQUcsRUFBRSxHQUFFLENBQUMsQ0FBQztJQUMxQixRQUFRLEdBQVEsR0FBRyxFQUFFLEdBQUUsQ0FBQyxDQUFDO0lBRWpDLFFBQVE7UUFDTixJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDO1lBQ2IsSUFBSSxDQUFDLEVBQUUsR0FBRyxJQUFJLEVBQUUsQ0FBQztRQUNuQixDQUFDO0lBQ0gsQ0FBQztJQUVELGdCQUFnQixDQUFDLEVBQW9CO1FBQ25DLElBQUksQ0FBQyxTQUFTLEdBQUcsRUFBRSxDQUFDO1FBQ3BCLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzdCLENBQUM7SUFFRCxpQkFBaUIsQ0FBQyxFQUFPO1FBQ3ZCLElBQUksQ0FBQyxRQUFRLEdBQUcsRUFBRSxDQUFDO0lBQ3JCLENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxLQUFjO1FBQzdCLElBQUksQ0FBQyxRQUFRLEdBQUcsS0FBSyxDQUFDO0lBQ3hCLENBQUM7SUFFRCxVQUFVLENBQUMsS0FBSztRQUNkLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQsV0FBVyxDQUFDLEtBQWEsRUFBRSxLQUFpQjtRQUMxQyxLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7UUFFeEIsSUFBSSxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDbEIsT0FBTztRQUNULENBQUM7UUFFRCxNQUFNLE1BQU0sR0FBRyxLQUFLLEtBQUssSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7UUFFbkQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN2QixJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3RCLElBQUksQ0FBQyxLQUFLLEdBQUcsTUFBTSxDQUFDO1FBQ3BCLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNwQyxDQUFDO3VHQXpFVSxpQkFBaUI7MkZBQWpCLGlCQUFpQixvVkFUakI7WUFDVDtnQkFDRSxPQUFPLEVBQUUsaUJBQWlCO2dCQUMxQixXQUFXLEVBQUUsaUJBQWlCO2dCQUM5QixLQUFLLEVBQUUsSUFBSTthQUNaO1NBQ0YsMEJDbEJILHd0QkFxQkE7OzJGREFhLGlCQUFpQjtrQkFkN0IsU0FBUzsrQkFDRSxXQUFXLGlCQUdOLGlCQUFpQixDQUFDLElBQUksYUFDMUI7d0JBQ1Q7NEJBQ0UsT0FBTyxFQUFFLGlCQUFpQjs0QkFDMUIsV0FBVyxtQkFBbUI7NEJBQzlCLEtBQUssRUFBRSxJQUFJO3lCQUNaO3FCQUNGLFFBQ0ssRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFOzhCQUluQixTQUFTO3NCQUFqQixLQUFLO2dCQUNHLEtBQUs7c0JBQWIsS0FBSztnQkFDRyxFQUFFO3NCQUFWLEtBQUs7Z0JBQ0csUUFBUTtzQkFBaEIsS0FBSztnQkFDaUIsTUFBTTtzQkFBNUIsS0FBSzt1QkFBQyxjQUFjO2dCQUVYLFdBQVc7c0JBQXBCLE1BQU07Z0JBR0gsTUFBTTtzQkFEVCxXQUFXO3VCQUFDLHdCQUF3QjtnQkFNakMsVUFBVTtzQkFEYixXQUFXO3VCQUFDLDBCQUEwQiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1zdHJpY3QtaWdub3JlXG5pbXBvcnQgeyBDb21wb25lbnQsIEV2ZW50RW1pdHRlciwgSG9zdEJpbmRpbmcsIElucHV0LCBPbkluaXQsIE91dHB1dCwgVmlld0VuY2Fwc3VsYXRpb24gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbnRyb2xWYWx1ZUFjY2Vzc29yLCBOR19WQUxVRV9BQ0NFU1NPUiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcbmltcG9ydCB7IHY0IGFzIHV1aWQgfSBmcm9tICd1dWlkJztcblxuaW1wb3J0IHsgUWRTd2l0Y2hJbnB1dCB9IGZyb20gJy4uLy4uL21vZGVsL29wdGlvbnMuaW50ZXJmYWNlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAncWQtc3dpdGNoJyxcbiAgdGVtcGxhdGVVcmw6ICcuL3N3aXRjaC5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL3N3aXRjaC5jb21wb25lbnQuc2NzcyddLFxuICBlbmNhcHN1bGF0aW9uOiBWaWV3RW5jYXBzdWxhdGlvbi5Ob25lLFxuICBwcm92aWRlcnM6IFtcbiAgICB7XG4gICAgICBwcm92aWRlOiBOR19WQUxVRV9BQ0NFU1NPUixcbiAgICAgIHVzZUV4aXN0aW5nOiBRZFN3aXRjaENvbXBvbmVudCxcbiAgICAgIG11bHRpOiB0cnVlXG4gICAgfVxuICBdLFxuICBob3N0OiB7IGNsYXNzOiAncWQtc3dpdGNoJyB9XG59KVxuZXhwb3J0IGNsYXNzIFFkU3dpdGNoQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0LCBDb250cm9sVmFsdWVBY2Nlc3NvciB7XG4gIC8vIFRPRE86IFJlZmFjdG9yIEZvcm1JbnB1dCBmb3IgYmV0dGVyIGludGVybmFsIGludGVyZmFjZVxuICBASW5wdXQoKSBpbnB1dERhdGE6IFFkU3dpdGNoSW5wdXQ7XG4gIEBJbnB1dCgpIHZhbHVlO1xuICBASW5wdXQoKSBpZDtcbiAgQElucHV0KCkgZGlzYWJsZWQgPSBmYWxzZTtcbiAgQElucHV0KCdkYXRhLXRlc3QtaWQnKSB0ZXN0SWQgPSAnc3dpdGNoJztcblxuICBAT3V0cHV0KCkgdmFsdWVDaGFuZ2UgPSBuZXcgRXZlbnRFbWl0dGVyPHN0cmluZz4oKTtcblxuICBASG9zdEJpbmRpbmcoJ2NsYXNzLnFkLXN3aXRjaC1hY3RpdmUnKVxuICBnZXQgYWN0aXZlKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmlucHV0RGF0YS5hY3RpdmU7XG4gIH1cblxuICBASG9zdEJpbmRpbmcoJ2NsYXNzLnFkLXN3aXRjaC1kaXNhYmxlZCcpXG4gIGdldCBpc0Rpc2FibGVkKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmlucHV0RGF0YS5kaXNhYmxlZCB8fCB0aGlzLmRpc2FibGVkO1xuICB9XG5cbiAgZ2V0IHRvZ2dsZUlkKCk6IHN0cmluZyB7XG4gICAgY29uc3QgdWlkID0gdGhpcy5pbnB1dERhdGEgPyB0aGlzLmlucHV0RGF0YS52YWx1ZSArIHRoaXMuaWQgOiB0aGlzLmlkO1xuICAgIHJldHVybiBgc3dpdGNoLXRvZ2dsZS0ke3VpZH1gO1xuICB9XG5cbiAgZ2V0IGxhYmVsKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuaW5wdXREYXRhLmkxOG47XG4gIH1cblxuICBnZXQgbGFiZWxQb3NpdGlvbigpOiBzdHJpbmcge1xuICAgIHJldHVybiB0aGlzLmlucHV0RGF0YS5sYWJlbFBvc2l0aW9uIHx8ICdyaWdodCc7XG4gIH1cblxuICBwcml2YXRlIF9vbkNoYW5nZTogYW55ID0gKCkgPT4ge307XG4gIHByaXZhdGUgX29uVG91Y2g6IGFueSA9ICgpID0+IHt9O1xuXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIGlmICghdGhpcy5pZCkge1xuICAgICAgdGhpcy5pZCA9IHV1aWQoKTtcbiAgICB9XG4gIH1cblxuICByZWdpc3Rlck9uQ2hhbmdlKGZuOiAoXzogYW55KSA9PiB2b2lkKTogdm9pZCB7XG4gICAgdGhpcy5fb25DaGFuZ2UgPSBmbjtcbiAgICB0aGlzLl9vbkNoYW5nZSh0aGlzLnZhbHVlKTtcbiAgfVxuXG4gIHJlZ2lzdGVyT25Ub3VjaGVkKGZuOiBhbnkpOiB2b2lkIHtcbiAgICB0aGlzLl9vblRvdWNoID0gZm47XG4gIH1cblxuICBzZXREaXNhYmxlZFN0YXRlKHN0YXRlOiBib29sZWFuKTogdm9pZCB7XG4gICAgdGhpcy5kaXNhYmxlZCA9IHN0YXRlO1xuICB9XG5cbiAgd3JpdGVWYWx1ZSh2YWx1ZSk6IHZvaWQge1xuICAgIHRoaXMudmFsdWUgPSB2YWx1ZTtcbiAgICB0aGlzLnZhbHVlQ2hhbmdlLmVtaXQodGhpcy52YWx1ZSk7XG4gIH1cblxuICBoYW5kbGVDbGljayh2YWx1ZTogc3RyaW5nLCBldmVudDogTW91c2VFdmVudCk6IHZvaWQge1xuICAgIGV2ZW50LnN0b3BQcm9wYWdhdGlvbigpO1xuXG4gICAgaWYgKHRoaXMuZGlzYWJsZWQpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBjb25zdCBfdmFsdWUgPSB2YWx1ZSAhPT0gdGhpcy52YWx1ZSA/IHZhbHVlIDogbnVsbDtcblxuICAgIHRoaXMuX29uQ2hhbmdlKF92YWx1ZSk7XG4gICAgdGhpcy5fb25Ub3VjaChfdmFsdWUpO1xuICAgIHRoaXMudmFsdWUgPSBfdmFsdWU7XG4gICAgdGhpcy52YWx1ZUNoYW5nZS5lbWl0KHRoaXMudmFsdWUpO1xuICB9XG59XG4iLCI8bGFiZWwgW2Zvcl09XCJ0b2dnbGVJZFwiPlxuICA8ZGl2IGNsYXNzPVwic3dpdGNoLWNvbnRlbnRcIiAqbmdJZj1cImxhYmVsUG9zaXRpb24gPT09ICdsZWZ0J1wiIFthdHRyLmRhdGEtdGVzdC1pZF09XCJ0ZXN0SWQgKyAnLWxhYmVsJ1wiPlxuICAgIHt7IGxhYmVsIHwgdHJhbnNsYXRlIH19XG4gIDwvZGl2PlxuICA8ZGl2IGNsYXNzPVwic3dpdGNoLXRvZ2dsZS1iYXJcIj5cbiAgICA8aW5wdXRcbiAgICAgIGNsYXNzPVwic3dpdGNoLXRvZ2dsZS1pbnB1dFwiXG4gICAgICBuYW1lPVwic3dpdGNoLXRvZ2dsZVwiXG4gICAgICB0eXBlPVwiY2hlY2tib3hcIlxuICAgICAgW2lkXT1cInRvZ2dsZUlkXCJcbiAgICAgIChjbGljayk9XCJoYW5kbGVDbGljayh2YWx1ZSwgJGV2ZW50KVwiXG4gICAgICBbdmFsdWVdPVwidmFsdWVcIlxuICAgICAgW2Rpc2FibGVkXT1cImlzRGlzYWJsZWRcIlxuICAgICAgW2F0dHIuZGF0YS10ZXN0LWlkXT1cInRlc3RJZCArICctaW5wdXQnXCJcbiAgICAvPlxuICAgIDxkaXYgY2xhc3M9XCJzd2l0Y2gtdG9nZ2xlLWJ1dHRvblwiPjwvZGl2PlxuICA8L2Rpdj5cbiAgPGRpdiBjbGFzcz1cInN3aXRjaC1jb250ZW50XCIgKm5nSWY9XCJsYWJlbFBvc2l0aW9uID09PSAncmlnaHQnXCIgW2F0dHIuZGF0YS10ZXN0LWlkXT1cInRlc3RJZCArICctY29udGVudCdcIj5cbiAgICB7eyBsYWJlbCB8IHRyYW5zbGF0ZSB9fVxuICA8L2Rpdj5cbjwvbGFiZWw+XG4iXX0=

package/esm2022/lib/forms/switches/switches-service/switches.service.mjs

@@ -0,0 +1,67 @@
+// @ts-strict-ignore
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class QdSwitchesService {
+    switchesList;
+    formatFormControlValues(formControlValues) {
+        const values = formControlValues || [];
+        return values.map(formControlValue => {
+            if (formControlValue.hasOwnProperty('value')) {
+                return formControlValue;
+            }
+            else {
+                return { value: formControlValue };
+            }
+        });
+    }
+    isAtLeastOneSelected(list) {
+        return list.reduce((hasValue, item) => hasValue || item.active, false);
+    }
+    setList(list) {
+        this.switchesList = list.map(item => ({ ...item, disabled: item.disabled || false }));
+    }
+    getList() {
+        return this.switchesList;
+    }
+    fillListWithDefaults(formControlValues) {
+        const _formControlValue = this.formatFormControlValues(formControlValues);
+        this.switchesList = this.switchesList.map((item, index) => {
+            let values;
+            _formControlValue.forEach(formControlValue => {
+                if (formControlValue.value === item.value) {
+                    values = { active: true, disabled: formControlValue.disabled || item.disabled || false };
+                }
+            });
+            return {
+                ...item,
+                ...{ active: item.active || false },
+                ...{ index },
+                ...values
+            };
+        });
+    }
+    getValues() {
+        if (this.isAtLeastOneSelected(this.switchesList)) {
+            return this.switchesList.map(checkbox => (checkbox.active ? checkbox.value : null));
+        }
+        else {
+            return [];
+        }
+    }
+    updateList(value) {
+        this.switchesList = this.switchesList.map(item => {
+            if (item.value === value) {
+                return { ...item, ...{ active: !item.active } };
+            }
+            else {
+                return item;
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdSwitchesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdSwitchesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdSwitchesService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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