design-angular-kit 1.0.0-2 → 1.0.0-21

package/esm2022/lib/services/notification/notification.service.mjs

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import { filter, Subject } from 'rxjs';
+import { NotificationType } from '../../interfaces/core';
+import * as i0 from "@angular/core";
+export class ItNotificationService {
+    constructor() {
+        this.subject = new Subject();
+    }
+    /**
+     * Listen on notification arrived
+     * @param filterType filter type of notification
+     */
+    onNotification(filterType) {
+        return this.subject.asObservable().pipe(filter(n => n && (!filterType || (n.type === filterType))));
+    }
+    /**
+     * Show new notification
+     * @param notification notification
+     */
+    addNotification(notification) {
+        this.subject.next(notification);
+    }
+    /**
+     * Create new Standard notification
+     * @param title notification title
+     * @param message notification message
+     * @param dismissible notification dismissible
+     * @param duration notification duration (milliseconds)
+     * @param position notification position
+     */
+    standard(title, message, dismissible, duration, position) {
+        this.addNotification({
+            type: NotificationType.Standard,
+            message,
+            title,
+            duration,
+            dismissible,
+            position
+        });
+    }
+    /**
+     * Create new Success notification
+     * @param title notification title
+     * @param message notification message
+     * @param dismissible notification dismissible
+     * @param duration notification duration (milliseconds)
+     * @param position notification position
+     */
+    success(title, message, dismissible, duration, position) {
+        this.addNotification({
+            type: NotificationType.Success,
+            message,
+            title,
+            duration,
+            dismissible,
+            position
+        });
+    }
+    /**
+     * Create new Error notification
+     * @param title notification title
+     * @param message notification message
+     * @param dismissible notification dismissible
+     * @param duration notification duration (milliseconds)
+     * @param position notification position
+     */
+    error(title, message, dismissible, duration, position) {
+        this.addNotification({
+            type: NotificationType.Error,
+            message,
+            title,
+            duration,
+            dismissible,
+            position
+        });
+    }
+    /**
+     * Create new Warning notification
+     * @param title notification title
+     * @param message notification message
+     * @param dismissible notification dismissible
+     * @param duration notification duration (milliseconds)
+     * @param position notification position
+     */
+    warning(title, message, dismissible, duration, position) {
+        this.addNotification({
+            type: NotificationType.Warning,
+            message,
+            title,
+            duration,
+            dismissible,
+            position
+        });
+    }
+    /**
+     * Create new Info notification
+     * @param title notification title
+     * @param message notification message
+     * @param dismissible notification dismissible
+     * @param duration notification duration (milliseconds)
+     * @param position notification position
+     */
+    info(title, message, dismissible, duration, position) {
+        this.addNotification({
+            type: NotificationType.Info,
+            message,
+            title,
+            duration,
+            dismissible,
+            position
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.7", ngImport: i0, type: ItNotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.7", ngImport: i0, type: ItNotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.7", ngImport: i0, type: ItNotificationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/file-utils.mjs

@@ -0,0 +1,73 @@
+import { Observable } from 'rxjs';
+export class FileUtils {
+    /**
+     * Return the file size string
+     * @param file the file
+     * @param decimals decimal to show
+     */
+    static getFileSizeString(file, decimals = 2) {
+        const bytes = file.size;
+        if (!+bytes) {
+            return '0 Bytes';
+        }
+        const k = 1024;
+        const dm = decimals < 0 ? 0 : decimals;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+    }
+    /**
+     * Convert a file to base64 string
+     * @param file the base64 string
+     */
+    static fileToBase64(file) {
+        const reader = new FileReader();
+        reader.readAsDataURL(file);
+        return new Observable(observer => {
+            reader.onload = (e) => {
+                const target = e.target;
+                if (!target?.result || target.result instanceof ArrayBuffer) {
+                    return observer.error('Error on parse');
+                }
+                observer.next(target.result);
+                observer.complete();
+            };
+            reader.onerror = error => {
+                observer.error(error);
+            };
+        });
+    }
+    /**
+     * Convert base64 to Blob
+     * @param base64 the base64 string
+     * @param mimeType the <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types">MIME type</a> (example 'application/pdf')
+     */
+    static base64ToBlob(base64, mimeType) {
+        const byteString = window.atob(base64);
+        const arrayBuffer = new ArrayBuffer(byteString.length);
+        const int8Array = new Uint8Array(arrayBuffer);
+        for (let i = 0; i < byteString.length; i++) {
+            int8Array[i] = byteString.charCodeAt(i);
+        }
+        return new Blob([int8Array], { type: mimeType });
+    }
+    /**
+     * Convert base64 to File
+     * @param base64 the base64 string
+     * @param mimeType the <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types">MIME type</a> (example 'application/pdf')
+     * @param filename the file name
+     */
+    static base64ToFile(base64, mimeType, filename) {
+        const fileBlob = FileUtils.base64ToBlob(base64, mimeType);
+        return new File([fileBlob], filename, { type: mimeType });
+    }
+    /**
+     * Extract the MIME type from base64 string
+     * @param base64 the base64 string
+     */
+    static getMimeTypeFromBase64(base64) {
+        const mime = base64.match(/data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,.*/);
+        return mime?.length ? mime[1] : undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/regex.mjs

@@ -0,0 +1,31 @@
+/**
+ * General Email Regex (RFC 5322 Official Standard)
+ * http://emailregex.com/
+ */
+export const EMAIL_REGEX = /(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/;
+/**
+ * Phone number Regex
+ */
+export const PHONE_NUMBER_REGEX = /^\s*(?:\+?(\d{1,3}))?[-. (]*(\d{3})[-. )]*(\d{3})[-. ]*(\d{3})(?: *x(\d+))?\s*$/;
+/**
+ * URL Regex
+ */
+export const URL_REGEX = /(https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[^\s]{2,}|www\.[a-zA-Z0-9][a-zA-Z0-9-]+[a-zA-Z0-9]\.[^\s]{2,}|https?:\/\/(?:www\.|(?!www))[a-zA-Z0-9]+\.[^\s]{2,}|www\.[a-zA-Z0-9]+\.[^\s]{2,})/;
+/**
+ * The italian tax code Regex (Codice Fiscale)
+ */
+export const ITALIAN_TAX_CODE_REGEX = /^[A-Za-z]{6}[0-9]{2}[A-Za-z]{1}[0-9]{2}[A-Za-z]{1}[0-9]{3}[A-Za-z]{1}$/i;
+/**
+ * The VAT number Regex (Partita iva)
+ */
+export const VAT_NUMBER_REGEX = /^[0-9]{11}$/;
+/**
+ * Italian CAP Regex
+ */
+export const CAP_REGEX = /^[0-9]{5}$/;
+/**
+ * IBAN Regex
+ * https://blog.marketto.it/en/2018/06/validate-any-country-iban/
+ */
+export const IBAN_REGEX = /^(?:(?:IT|SM)\d{2}[A-Z]\d{22}|CY\d{2}[A-Z]\d{23}|NL\d{2}[A-Z]{4}\d{10}|LV\d{2}[A-Z]{4}\d{13}|(?:BG|BH|GB|IE)\d{2}[A-Z]{4}\d{14}|GI\d{2}[A-Z]{4}\d{15}|RO\d{2}[A-Z]{4}\d{16}|KW\d{2}[A-Z]{4}\d{22}|MT\d{2}[A-Z]{4}\d{23}|NO\d{13}|(?:DK|FI|GL|FO)\d{16}|MK\d{17}|(?:AT|EE|KZ|LU|XK)\d{18}|(?:BA|HR|LI|CH|CR)\d{19}|(?:GE|DE|LT|ME|RS)\d{20}|IL\d{21}|(?:AD|CZ|ES|MD|SA)\d{22}|PT\d{23}|(?:BE|IS)\d{24}|(?:FR|MR|MC)\d{25}|(?:AL|DO|LB|PL)\d{26}|(?:AZ|HU)\d{27}|(?:GR|MU)\d{28})$/i;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/validators/it-validators.mjs

@@ -0,0 +1,153 @@
+import { Validators } from '@angular/forms';
+import { CAP_REGEX, EMAIL_REGEX, IBAN_REGEX, ITALIAN_TAX_CODE_REGEX, PHONE_NUMBER_REGEX, URL_REGEX, VAT_NUMBER_REGEX } from '../utils/regex';
+export class ItValidators {
+    static { this.SpecialCharacterPattern = '!@#$%&*_+=;:|,.'; }
+    /**
+     * Static pattern validator with custom error
+     * @param regex
+     * @param error
+     */
+    static customPattern(regex, error) {
+        return (control) => {
+            if (!control.value) {
+                // if control is empty return no error
+                return null;
+            }
+            // test the value of the control against the regexp supplied
+            const valid = regex.test(control.value);
+            // if true, return no error (no error), else return error passed in the second parameter
+            return valid ? null : error;
+        };
+    }
+    /**
+     * Set Validator if the condition is satisfied
+     * @param validator the validator to apply if the condition is true
+     * @param condition the condition
+     */
+    static conditional(validator, condition) {
+        return formControl => {
+            if (!formControl.parent) {
+                return null;
+            }
+            if (condition(formControl)) {
+                return validator(formControl);
+            }
+            return null;
+        };
+    }
+    /**
+     * Check whether our password and confirm password are a match
+     * @param control
+     * @param passwordControlName the password formControlName
+     * @param confirmControlName the confirmPassword formControlName
+     */
+    static passwordMatch(control, passwordControlName = 'password', confirmControlName = 'confirmPassword') {
+        const confirmControl = control.get(confirmControlName); // confirmPassword form control
+        if (!confirmControl) {
+            return null;
+        }
+        const passwordControl = control.get(passwordControlName); // password form control
+        const password = passwordControl?.value; // get password from our password form control
+        // compare is the password match
+        if ((password && !confirmControl.value) || (confirmControl.value && password !== confirmControl.value)) {
+            // if they don't match, set an error in our confirmPassword form control
+            confirmControl?.setErrors({ noPasswordMatch: true });
+            confirmControl?.markAsTouched();
+            return control;
+        }
+        if (password && passwordControl?.touched) {
+            confirmControl?.markAsTouched();
+        }
+        return null;
+    }
+    /**
+     * Password validator
+     * @param minLength minimum password length - default 10
+     * @param hasNumber check whether the entered password has a number - default true
+     * @param hasCapitalCase check whether the entered password has upper case letter - default true
+     * @param hasSmallCase check whether the entered password has a lower-case letter - default true
+     * @param hasSpecialCharacters check whether the entered password has a special character - default true
+     * @param required the field is required - default true
+     */
+    static password(minLength = 10, hasNumber = true, hasCapitalCase = true, hasSmallCase = true, hasSpecialCharacters = true, required = true) {
+        const validators = [Validators.minLength(minLength)];
+        if (hasNumber) {
+            validators.push(ItValidators.customPattern(/\d/, { hasNumber }));
+        }
+        if (hasCapitalCase) {
+            validators.push(ItValidators.customPattern(/[A-Z]/, { hasCapitalCase }));
+        }
+        if (hasSmallCase) {
+            validators.push(ItValidators.customPattern(/[a-z]/, { hasSmallCase }));
+        }
+        if (hasSpecialCharacters) {
+            validators.push(ItValidators.customPattern(new RegExp(`[${ItValidators.SpecialCharacterPattern}]`), { hasSpecialCharacters }));
+        }
+        if (required) {
+            validators.push(Validators.required);
+        }
+        return Validators.compose(validators);
+    }
+    /**
+     * Email validator
+     */
+    static get email() {
+        return Validators.compose([
+            Validators.email,
+            ItValidators.customPattern(EMAIL_REGEX, { invalidEmail: true })
+        ]);
+    }
+    /**
+     * Phone number validator
+     */
+    static get tel() {
+        return ItValidators.customPattern(PHONE_NUMBER_REGEX, { invalidTel: true });
+    }
+    /**
+     * URL validator
+     */
+    static get url() {
+        return ItValidators.customPattern(URL_REGEX, { invalidUrl: true });
+    }
+    /**
+     * Italian Tax Code validator
+     */
+    static get taxCode() {
+        return ItValidators.customPattern(ITALIAN_TAX_CODE_REGEX, { invalidTaxCode: true });
+    }
+    /**
+     * VAT Number validator
+     */
+    static get vatNumber() {
+        return ItValidators.customPattern(VAT_NUMBER_REGEX, { invalidVatNumber: true });
+    }
+    /**
+     * Italian Postal Code validator (CAP)
+     */
+    static get cap() {
+        return ItValidators.customPattern(CAP_REGEX, { invalidCap: true });
+    }
+    /**
+     * IBAN validator
+     */
+    static get iban() {
+        return ItValidators.customPattern(IBAN_REGEX, { invalidIban: true });
+    }
+    /**
+     * Check if value is a valid RegExp
+     */
+    static get regExp() {
+        return (control) => {
+            try {
+                if (control?.value) {
+                    new RegExp(control.value);
+                }
+            }
+            catch (e) {
+                return { invalidRegex: true };
+            }
+            return null;
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"it-validators.js","sourceRoot":"","sources":["../../../../../projects/design-angular-kit/src/lib/validators/it-validators.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';\nimport {\n  CAP_REGEX,\n  EMAIL_REGEX,\n  IBAN_REGEX,\n  ITALIAN_TAX_CODE_REGEX,\n  PHONE_NUMBER_REGEX,\n  URL_REGEX,\n  VAT_NUMBER_REGEX\n} from '../utils/regex';\n\nexport class ItValidators {\n  public static SpecialCharacterPattern = '!@#$%&*_+=;:|,.';\n\n  /**\n   * Static pattern validator with custom error\n   * @param regex\n   * @param error\n   */\n  public static customPattern(regex: RegExp, error: ValidationErrors): ValidatorFn {\n    return (control: AbstractControl): ValidationErrors | null => {\n      if (!control.value) {\n        // if control is empty return no error\n        return null;\n      }\n\n      // test the value of the control against the regexp supplied\n      const valid = regex.test(control.value);\n\n      // if true, return no error (no error), else return error passed in the second parameter\n      return valid ? null : error;\n    };\n  }\n\n  /**\n   * Set Validator if the condition is satisfied\n   * @param validator the validator to apply if the condition is true\n   * @param condition the condition\n   */\n  public static conditional(validator: ValidatorFn, condition: (control: AbstractControl) => boolean): ValidatorFn {\n    return formControl => {\n      if (!formControl.parent) {\n        return null;\n      }\n      if (condition(formControl)) {\n        return validator(formControl);\n      }\n      return null;\n    };\n  }\n\n  /**\n   * Check whether our password and confirm password are a match\n   * @param control\n   * @param passwordControlName the password formControlName\n   * @param confirmControlName the confirmPassword formControlName\n   */\n  public static passwordMatch(control: AbstractControl, passwordControlName = 'password', confirmControlName = 'confirmPassword'): AbstractControl | null {\n    const confirmControl = control.get(confirmControlName); // confirmPassword form control\n    if (!confirmControl) {\n      return null;\n    }\n\n    const passwordControl = control.get(passwordControlName); // password form control\n    const password = passwordControl?.value; // get password from our password form control\n\n    // compare is the password match\n    if ((password && !confirmControl.value) || (confirmControl.value && password !== confirmControl.value)) {\n      // if they don't match, set an error in our confirmPassword form control\n      confirmControl?.setErrors({ noPasswordMatch: true });\n      confirmControl?.markAsTouched();\n      return control;\n    }\n\n    if (password && passwordControl?.touched) {\n      confirmControl?.markAsTouched();\n    }\n    return null;\n  }\n\n  /**\n   * Password validator\n   * @param minLength minimum password length - default 10\n   * @param hasNumber check whether the entered password has a number - default true\n   * @param hasCapitalCase check whether the entered password has upper case letter - default true\n   * @param hasSmallCase check whether the entered password has a lower-case letter - default true\n   * @param hasSpecialCharacters check whether the entered password has a special character - default true\n   * @param required the field is required - default true\n   */\n  public static password(minLength = 10, hasNumber = true, hasCapitalCase = true, hasSmallCase = true, hasSpecialCharacters = true, required = true): ValidatorFn {\n    const validators: Array<ValidatorFn> = [Validators.minLength(minLength)];\n    if (hasNumber) {\n      validators.push(ItValidators.customPattern(/\\d/, { hasNumber }));\n    }\n    if (hasCapitalCase) {\n      validators.push(ItValidators.customPattern(/[A-Z]/, { hasCapitalCase }));\n    }\n    if (hasSmallCase) {\n      validators.push(ItValidators.customPattern(/[a-z]/, { hasSmallCase }));\n    }\n    if (hasSpecialCharacters) {\n      validators.push(ItValidators.customPattern(new RegExp(`[${ItValidators.SpecialCharacterPattern}]`), { hasSpecialCharacters }));\n    }\n    if (required) {\n      validators.push(Validators.required);\n    }\n    return <ValidatorFn>Validators.compose(validators);\n  }\n\n  /**\n   * Email validator\n   */\n  public static get email(): ValidatorFn {\n    return <ValidatorFn>Validators.compose([\n      Validators.email,\n      ItValidators.customPattern(EMAIL_REGEX, { invalidEmail: true })\n    ]);\n  }\n\n  /**\n   * Phone number validator\n   */\n  public static get tel(): ValidatorFn {\n    return ItValidators.customPattern(PHONE_NUMBER_REGEX, { invalidTel: true });\n  }\n\n  /**\n   * URL validator\n   */\n  public static get url(): ValidatorFn {\n    return ItValidators.customPattern(URL_REGEX, { invalidUrl: true });\n  }\n\n  /**\n   * Italian Tax Code validator\n   */\n  public static get taxCode(): ValidatorFn {\n    return ItValidators.customPattern(ITALIAN_TAX_CODE_REGEX, { invalidTaxCode: true });\n  }\n\n  /**\n   * VAT Number validator\n   */\n  public static get vatNumber(): ValidatorFn {\n    return ItValidators.customPattern(VAT_NUMBER_REGEX, { invalidVatNumber: true });\n  }\n\n  /**\n   * Italian Postal Code validator (CAP)\n   */\n  public static get cap(): ValidatorFn {\n    return ItValidators.customPattern(CAP_REGEX, { invalidCap: true });\n  }\n\n  /**\n   * IBAN validator\n   */\n  public static get iban(): ValidatorFn {\n    return ItValidators.customPattern(IBAN_REGEX, { invalidIban: true });\n  }\n\n  /**\n   * Check if value is a valid RegExp\n   */\n  public static get regExp(): ValidatorFn {\n    return (control: AbstractControl): ValidationErrors | null => {\n      try {\n        if (control?.value) {\n          new RegExp(control.value);\n        }\n      } catch (e) {\n        return { invalidRegex: true };\n      }\n      return null;\n    };\n  }\n}\n"]}

package/esm2022/public_api.mjs

@@ -0,0 +1,85 @@
+/*
+ * Public API Surface of design-angular-kit
+ */
+export * from './lib/design-angular-kit.module';
+export * from './lib/components/components.module';
+// Config
+export * from './lib/design-angular-kit-config';
+// Core components
+export * from './lib/components/core/accordion/accordion.component';
+export * from './lib/components/core/alert/alert.component';
+export * from './lib/components/core/badge/badge.directive';
+export * from './lib/components/core/button/button.directive';
+export * from './lib/components/core/callout/callout.component';
+export * from './lib/components/core/card/card.component';
+export * from './lib/components/core/carousel/carousel.module';
+export * from './lib/components/core/carousel/carousel/carousel.component';
+export * from './lib/components/core/carousel/carousel-item/carousel-item.component';
+export * from './lib/components/core/chip/chip.component';
+export * from './lib/components/core/collapse/collapse.component';
+export * from './lib/components/core/dimmer/dimmer.module';
+export * from './lib/components/core/dimmer/dimmer.component';
+export * from './lib/components/core/dimmer/dimmer-buttons/dimmer-buttons.component';
+export * from './lib/components/core/dimmer/dimmer-icon/dimmer-icon.component';
+export * from './lib/components/core/dropdown/dropdown.module';
+export * from './lib/components/core/dropdown/dropdown/dropdown.component';
+export * from './lib/components/core/dropdown/dropdown-item/dropdown-item.component';
+export * from './lib/components/core/forward/forward.directive';
+export * from './lib/components/core/link/link.component';
+export * from './lib/components/core/list/list.module';
+export * from './lib/components/core/list/list/list.component';
+export * from './lib/components/core/list/list-item/list-item.component';
+export * from './lib/components/core/modal/modal.component';
+export * from './lib/components/core/notifications/notifications.component';
+export * from './lib/components/core/pagination/pagination.component';
+export * from './lib/components/core/popover/popover.directive';
+export * from './lib/components/core/progress-bar/progress-bar.component';
+export * from './lib/components/core/progress-button/progress-button.component';
+export * from './lib/components/core/spinner/spinner.component';
+export * from './lib/components/core/steppers/steppers.module';
+export * from './lib/components/core/steppers/steppers-container/steppers-container.component';
+export * from './lib/components/core/steppers/steppers-item/steppers-item.component';
+export * from './lib/components/core/tab/tab.module';
+export * from './lib/components/core/tab/tab-container/tab-container.component';
+export * from './lib/components/core/tab/tab-item/tab-item.component';
+export * from './lib/components/core/table/table.component';
+export * from './lib/components/core/tooltip/tooltip.directive';
+// Forms components
+export * from './lib/components/form/form.module';
+export * from './lib/components/form/checkbox/checkbox.component';
+export * from './lib/components/form/input/input.component';
+export * from './lib/components/form/password-input/password-input.component';
+export * from './lib/components/form/radio-button/radio-button.component';
+export * from './lib/components/form/range/range.component';
+export * from './lib/components/form/rating/rating.component';
+export * from './lib/components/form/select/select.component';
+export * from './lib/components/form/textarea/textarea.component';
+export * from './lib/components/form/upload-drag-drop/upload-drag-drop.component';
+export * from './lib/components/form/upload-file-list/upload-file-list.component';
+// Navigation components
+export * from './lib/components/navigation/back-button/back-button.component';
+export * from './lib/components/navigation/back-to-top/back-to-top.component';
+export * from './lib/components/navigation/breadcrumbs/breadcrumbs.module';
+export * from './lib/components/navigation/breadcrumbs/breadcrumb/breadcrumb.component';
+export * from './lib/components/navigation/breadcrumbs/breadcrumb-item/breadcrumb-item.component';
+export * from './lib/components/navigation/header/header.component';
+// Utils components
+export * from './lib/components/utils/error-page/error-page.component';
+export * from './lib/components/utils/icon/icon.component';
+export * from './lib/components/utils/language-switcher/language-switcher.component';
+// Services
+export * from './lib/services/notification/notification.service';
+// Pipes
+export * from './lib/pipes/mark-matching-text.pipe';
+// Interfaces
+export * from './lib/interfaces/design-angular-kit-init';
+export * from './lib/interfaces/core';
+export * from './lib/interfaces/form';
+export * from './lib/interfaces/icon';
+export * from './lib/interfaces/utils';
+// Utils
+export * from './lib/utils/regex';
+export * from './lib/utils/file-utils';
+// Validators
+export * from './lib/validators/it-validators';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_api.js","sourceRoot":"","sources":["../../../projects/design-angular-kit/src/public_api.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AAEnD,SAAS;AACT,cAAc,iCAAiC,CAAC;AAEhD,kBAAkB;AAClB,cAAc,qDAAqD,CAAC;AACpE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,iDAAiD,CAAC;AAChE,cAAc,2CAA2C,CAAC;AAE1D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4DAA4D,CAAC;AAC3E,cAAc,sEAAsE,CAAC;AAErF,cAAc,2CAA2C,CAAC;AAC1D,cAAc,mDAAmD,CAAC;AAElE,cAAc,4CAA4C,CAAC;AAC3D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,sEAAsE,CAAC;AACrF,cAAc,gEAAgE,CAAC;AAE/E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4DAA4D,CAAC;AAC3E,cAAc,sEAAsE,CAAC;AAErF,cAAc,iDAAiD,CAAC;AAChE,cAAc,2CAA2C,CAAC;AAE1D,cAAc,wCAAwC,CAAC;AACvD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0DAA0D,CAAC;AAEzE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6DAA6D,CAAC;AAC5E,cAAc,uDAAuD,CAAC;AACtE,cAAc,iDAAiD,CAAC;AAChE,cAAc,2DAA2D,CAAC;AAC1E,cAAc,iEAAiE,CAAC;AAChF,cAAc,iDAAiD,CAAC;AAEhE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,gFAAgF,CAAC;AAC/F,cAAc,sEAAsE,CAAC;AAErF,cAAc,sCAAsC,CAAC;AACrD,cAAc,iEAAiE,CAAC;AAChF,cAAc,uDAAuD,CAAC;AAEtE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,iDAAiD,CAAC;AAEhE,mBAAmB;AACnB,cAAc,mCAAmC,CAAC;AAClD,cAAc,mDAAmD,CAAC;AAClE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,+DAA+D,CAAC;AAC9E,cAAc,2DAA2D,CAAC;AAC1E,cAAc,6CAA6C,CAAC;AAC5D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,mEAAmE,CAAC;AAClF,cAAc,mEAAmE,CAAC;AAElF,wBAAwB;AACxB,cAAc,+DAA+D,CAAC;AAC9E,cAAc,+DAA+D,CAAC;AAE9E,cAAc,4DAA4D,CAAC;AAC3E,cAAc,yEAAyE,CAAC;AACxF,cAAc,mFAAmF,CAAC;AAElG,cAAc,qDAAqD,CAAC;AAEpE,mBAAmB;AACnB,cAAc,wDAAwD,CAAC;AACvE,cAAc,4CAA4C,CAAC;AAC3D,cAAc,sEAAsE,CAAC;AAErF,WAAW;AACX,cAAc,kDAAkD,CAAC;AAEjE,QAAQ;AACR,cAAc,qCAAqC,CAAC;AAEpD,aAAa;AACb,cAAc,0CAA0C,CAAC;AAEzD,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AAEvC,QAAQ;AACR,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AAEvC,aAAa;AACb,cAAc,gCAAgC,CAAC","sourcesContent":["/*\n * Public API Surface of design-angular-kit\n */\n\nexport * from './lib/design-angular-kit.module';\nexport * from './lib/components/components.module';\n\n// Config\nexport * from './lib/design-angular-kit-config';\n\n// Core components\nexport * from './lib/components/core/accordion/accordion.component';\nexport * from './lib/components/core/alert/alert.component';\nexport * from './lib/components/core/badge/badge.directive';\nexport * from './lib/components/core/button/button.directive';\nexport * from './lib/components/core/callout/callout.component';\nexport * from './lib/components/core/card/card.component';\n\nexport * from './lib/components/core/carousel/carousel.module';\nexport * from './lib/components/core/carousel/carousel/carousel.component';\nexport * from './lib/components/core/carousel/carousel-item/carousel-item.component';\n\nexport * from './lib/components/core/chip/chip.component';\nexport * from './lib/components/core/collapse/collapse.component';\n\nexport * from './lib/components/core/dimmer/dimmer.module';\nexport * from './lib/components/core/dimmer/dimmer.component';\nexport * from './lib/components/core/dimmer/dimmer-buttons/dimmer-buttons.component';\nexport * from './lib/components/core/dimmer/dimmer-icon/dimmer-icon.component';\n\nexport * from './lib/components/core/dropdown/dropdown.module';\nexport * from './lib/components/core/dropdown/dropdown/dropdown.component';\nexport * from './lib/components/core/dropdown/dropdown-item/dropdown-item.component';\n\nexport * from './lib/components/core/forward/forward.directive';\nexport * from './lib/components/core/link/link.component';\n\nexport * from './lib/components/core/list/list.module';\nexport * from './lib/components/core/list/list/list.component';\nexport * from './lib/components/core/list/list-item/list-item.component';\n\nexport * from './lib/components/core/modal/modal.component';\nexport * from './lib/components/core/notifications/notifications.component';\nexport * from './lib/components/core/pagination/pagination.component';\nexport * from './lib/components/core/popover/popover.directive';\nexport * from './lib/components/core/progress-bar/progress-bar.component';\nexport * from './lib/components/core/progress-button/progress-button.component';\nexport * from './lib/components/core/spinner/spinner.component';\n\nexport * from './lib/components/core/steppers/steppers.module';\nexport * from './lib/components/core/steppers/steppers-container/steppers-container.component';\nexport * from './lib/components/core/steppers/steppers-item/steppers-item.component';\n\nexport * from './lib/components/core/tab/tab.module';\nexport * from './lib/components/core/tab/tab-container/tab-container.component';\nexport * from './lib/components/core/tab/tab-item/tab-item.component';\n\nexport * from './lib/components/core/table/table.component';\nexport * from './lib/components/core/tooltip/tooltip.directive';\n\n// Forms components\nexport * from './lib/components/form/form.module';\nexport * from './lib/components/form/checkbox/checkbox.component';\nexport * from './lib/components/form/input/input.component';\nexport * from './lib/components/form/password-input/password-input.component';\nexport * from './lib/components/form/radio-button/radio-button.component';\nexport * from './lib/components/form/range/range.component';\nexport * from './lib/components/form/rating/rating.component';\nexport * from './lib/components/form/select/select.component';\nexport * from './lib/components/form/textarea/textarea.component';\nexport * from './lib/components/form/upload-drag-drop/upload-drag-drop.component';\nexport * from './lib/components/form/upload-file-list/upload-file-list.component';\n\n// Navigation components\nexport * from './lib/components/navigation/back-button/back-button.component';\nexport * from './lib/components/navigation/back-to-top/back-to-top.component';\n\nexport * from './lib/components/navigation/breadcrumbs/breadcrumbs.module';\nexport * from './lib/components/navigation/breadcrumbs/breadcrumb/breadcrumb.component';\nexport * from './lib/components/navigation/breadcrumbs/breadcrumb-item/breadcrumb-item.component';\n\nexport * from './lib/components/navigation/header/header.component';\n\n// Utils components\nexport * from './lib/components/utils/error-page/error-page.component';\nexport * from './lib/components/utils/icon/icon.component';\nexport * from './lib/components/utils/language-switcher/language-switcher.component';\n\n// Services\nexport * from './lib/services/notification/notification.service';\n\n// Pipes\nexport * from './lib/pipes/mark-matching-text.pipe';\n\n// Interfaces\nexport * from './lib/interfaces/design-angular-kit-init';\n\nexport * from './lib/interfaces/core';\nexport * from './lib/interfaces/form';\nexport * from './lib/interfaces/icon';\nexport * from './lib/interfaces/utils';\n\n// Utils\nexport * from './lib/utils/regex';\nexport * from './lib/utils/file-utils';\n\n// Validators\nexport * from './lib/validators/it-validators';\n"]}