@ieeesa-npm/presentation 0.13.4 → 0.13.6

package/esm2022/lib/services/file-upload.service.mjs

@@ -0,0 +1,263 @@
+import { HttpClient, HttpEventType, } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { AlertType, } from '@ieeesa-npm/utility';
+import { catchError, last, map, Subject, takeUntil, tap, } from 'rxjs';
+import * as constants from '../assets/constants.json';
+import * as i0 from "@angular/core";
+import * as i1 from "@ieeesa-npm/utility";
+import * as i2 from "@angular/common/http";
+/**
+ * This service interacts with the server to obtain pre-signed URLs for file upload and uploads files to Amazon S3.
+ * @class FileUploadService
+ */
+export class FileUploadService {
+    constructor(
+    // eslint-disable-next-line no-unused-vars
+    httpService, handler, 
+    // eslint-disable-next-line no-unused-vars
+    alertService, 
+    // eslint-disable-next-line no-unused-vars
+    loaderNotificationService) {
+        this.httpService = httpService;
+        this.alertService = alertService;
+        this.loaderNotificationService = loaderNotificationService;
+        this.destroy$ = new Subject();
+        this.constants = constants;
+        this.isFileUploading = false;
+        this.httpClient = new HttpClient(handler);
+    }
+    /**
+     * Sets the base URL for API requests.
+     * @param {string} apiBaseUrl -API base URL.
+     * @memberof FileUploadService
+     */
+    setApiBaseUrl(apiBaseUrl) {
+        this.apiBaseUrl = apiBaseUrl;
+    }
+    /**
+     * Retrieves presigned URL for uploading files to Amazon S3 bucket.
+     * @param {(File | FileList)} file
+     * @return {Observable<FileUploadPresignedUrl>}
+     * @memberof FileUploadService
+     */
+    getFileUploadPresignedUrl(file) {
+        let fileName = '';
+        if (Object.values(file).length)
+            fileName = Object.values(file)[0].name;
+        else
+            fileName = file.name;
+        return this.httpService
+            .getData(`${this.apiBaseUrl}/configurations/s3/uploadFileUrl/${fileName}`)
+            .pipe(map((response) => {
+            return response;
+        }), catchError((errorRes) => {
+            throw errorRes;
+        }));
+    }
+    /**
+     * Uploads file to AWS S3 using a presigned URL.
+     * @param {string} presignedUrl
+     * @param {(File | FileList)} file
+     * @return {Observable<any>} -Returns an observable that emits the response after uploading the file to S3.
+     * @memberof FileUploadService
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    uploadFileToS3(presignedUrl, file) {
+        this.loaderNotificationService.show();
+        return this.httpClient
+            .put(presignedUrl, this.fileByteArray, {
+            reportProgress: true,
+            observe: 'events',
+        })
+            .pipe(takeUntil(this.destroy$), map((event) => this.getEventMessage(event, file)), tap((message) => this.showProgress(message)), last(), catchError((errorRes) => {
+            this.loaderNotificationService.hide();
+            throw errorRes;
+        }));
+    }
+    /**
+     * Gets file upload progress.
+     * @param {*} message
+     * @memberof FileUploadService
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars, no-unused-vars, no-empty-function, @typescript-eslint/no-empty-function
+    showProgress(message) { }
+    /**
+     * Return distinct message for sent, upload progress, & response events.
+     * @param {HttpEvent<any>} event
+     * @param {(File | FileList)} file
+     * @return {*}
+     * @memberof FileUploadService
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getEventMessage(event, file) {
+        let fileName = '';
+        let fileSize = 0;
+        if (Object.values(file).length) {
+            fileName = Object.values(file)[0].name;
+            fileSize = Object.values(file)[0].size;
+        }
+        else {
+            fileName = file.name;
+            fileSize = file.size;
+        }
+        switch (event.type) {
+            case HttpEventType.Sent:
+                return `Uploading file "${fileName}" of size ${fileSize}.`;
+            case HttpEventType.UploadProgress:
+                // eslint-disable-next-line no-case-declarations
+                const percentDone = event?.total
+                    ? Math.round((100 * event.loaded) / event.total)
+                    : 0;
+                return `File "${fileName}" is ${percentDone}% uploaded.`;
+            case HttpEventType.Response:
+                this.loaderNotificationService.hide();
+                return true;
+            default:
+                return `File "${fileName}" surprising upload event: ${event.type}.`;
+        }
+    }
+    /**
+     * Converts file to byte array.
+     * @param {File} file
+     * @memberof FileUploadService
+     */
+    convertFileToByteArray(file) {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            const arrayBuffer = reader?.result;
+            this.fileByteArray = new Uint8Array(arrayBuffer);
+        };
+        reader.onerror = () => {
+            this.alertService?.showMessage({
+                status: 'custom',
+                message: this.constants?.fileUpload?.message?.error?.errorReadingFile,
+                alertType: AlertType?.ERROR,
+                isCloseNeeded: true,
+            });
+        };
+        reader.readAsArrayBuffer(file);
+    }
+    /**
+     * Resets file byte array format to undefined.
+     * @memberof FileUploadService
+     */
+    clearFileByteArray() {
+        this.fileByteArray = undefined;
+    }
+    /**
+     * Sets file upload status.
+     * @param {boolean} status
+     * @memberof FileUploadService
+     */
+    setFileUploadStatus(status) {
+        this.isFileUploading = status;
+    }
+    /**
+     * Returns file upload status.
+     * @return {boolean}
+     * @memberof FileUploadService
+     */
+    getFileUploadStatus() {
+        return this.isFileUploading;
+    }
+    /**
+     * Retrieves presigned URL for downloading files to Amazon S3 bucket.
+     * @param {(File | FileList)} file
+     * @return {Observable<string>}
+     * @memberof FileUploadService
+     */
+    getFileDownloadPresignedUrls(file) {
+        let fileName = '';
+        if (Object.values(file).length)
+            fileName = Object.values(file)[0].name;
+        else
+            fileName = file.name;
+        return this.httpService
+            .getData(`${this.apiBaseUrl}/configurations/s3/downloadFileUrl/${fileName}`)
+            .pipe(map((response) => {
+            return response;
+        }), catchError((errorRes) => {
+            throw errorRes;
+        }));
+    }
+    /**
+     * Downloads file to AWS S3 using a presigned URL.
+     * @return {Observable<any>}
+     * @memberof FileUploadService
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    downloadFile(fileDownloadPresignedUrl) {
+        return this.httpClient.get(fileDownloadPresignedUrl);
+    }
+    /**
+     * Validates the total size of the files uploaded.
+     * @param {(File | FileList)} files -The files to be validated.
+     * @param {number} maxFileSize
+     * @param {boolean} isMultiFileUpload
+     * @return {boolean} -Returns true if the total size of files is within the specified limit, otherwise false.
+     * @memberof FileUploadService
+     */
+    validateFileSize(files, maxFileSize, isMultiFileUpload) {
+        if (isMultiFileUpload) {
+            let totalSize = 0;
+            Object.values(files).forEach((file) => {
+                totalSize += file.size;
+            });
+            return totalSize / (1024 * 1024) <= maxFileSize;
+        }
+        return files.size / (1024 * 1024) <= maxFileSize;
+    }
+    /**
+     * Validates the file types of the uploaded files.
+     * @param {(File | FileList)} files
+     * @param {string[]} allowedFileTypes
+     * @param {boolean} isMultiFileUpload
+     * @return {boolean} -Returns true if all files have valid extensions, otherwise false.
+     * @memberof FileUploadService
+     */
+    validateFileTypes(files, allowedFileTypes, isMultiFileUpload) {
+        const validateSingleFile = (file) => {
+            const fileExtension = this.getFileExtension(file.name);
+            return allowedFileTypes?.includes(fileExtension);
+        };
+        if (isMultiFileUpload) {
+            let allFilesValid = true;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            Object.values(files)?.forEach((fileItem) => {
+                if (!validateSingleFile(fileItem)) {
+                    allFilesValid = false;
+                }
+            });
+            return allFilesValid;
+        }
+        return validateSingleFile(files);
+    }
+    /**
+     * Extracts and returns the extension of a file from its name.
+     * @private
+     * @param {string} fileName
+     * @return {string} -The file extension in lowercase.
+     * @memberof FileUploadService
+     */
+    getFileExtension(fileName) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return fileName?.split('.').pop().toLowerCase();
+    }
+    /**
+     * Implementation of ngOnDestroy lifecycle hook method to unsubscribe the open observable subscriptions.
+     * @memberof FileUploadService
+     */
+    ngOnDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FileUploadService, deps: [{ token: i1.HttpService }, { token: i2.HttpBackend }, { token: i1.AlertsService }, { token: i1.LoaderNotificationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FileUploadService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FileUploadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpService }, { type: i2.HttpBackend }, { type: i1.AlertsService }, { type: i1.LoaderNotificationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-upload.service.js","sourceRoot":"","sources":["../../../../../projects/presentation/src/lib/services/file-upload.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  HttpBackend,\r\n  HttpClient,\r\n  HttpEvent,\r\n  HttpEventType,\r\n} from '@angular/common/http';\r\nimport { Injectable, OnDestroy } from '@angular/core';\r\nimport {\r\n  AlertsService,\r\n  AlertType,\r\n  HttpService,\r\n  LoaderNotificationService,\r\n} from '@ieeesa-npm/utility';\r\nimport { FileUploadPresignedUrl } from '../models/file-upload-presigned-url-res.model';\r\nimport {\r\n  catchError,\r\n  last,\r\n  map,\r\n  Observable,\r\n  Subject,\r\n  takeUntil,\r\n  tap,\r\n} from 'rxjs';\r\nimport * as constants from '../assets/constants.json';\r\n\r\n/**\r\n * This service interacts with the server to obtain pre-signed URLs for file upload and uploads files to Amazon S3.\r\n * @class FileUploadService\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class FileUploadService implements OnDestroy {\r\n  destroy$: Subject<boolean> = new Subject<boolean>();\r\n  constants = constants;\r\n  apiBaseUrl!: string;\r\n  fileByteArray: Uint8Array | undefined;\r\n  httpClient: HttpClient;\r\n  isFileUploading = false;\r\n  constructor(\r\n    // eslint-disable-next-line no-unused-vars\r\n    public httpService: HttpService,\r\n    handler: HttpBackend,\r\n    // eslint-disable-next-line no-unused-vars\r\n    public alertService: AlertsService,\r\n    // eslint-disable-next-line no-unused-vars\r\n    public loaderNotificationService: LoaderNotificationService\r\n  ) {\r\n    this.httpClient = new HttpClient(handler);\r\n  }\r\n\r\n  /**\r\n   * Sets the base URL for API requests.\r\n   * @param {string} apiBaseUrl -API base URL.\r\n   * @memberof FileUploadService\r\n   */\r\n  setApiBaseUrl(apiBaseUrl: string) {\r\n    this.apiBaseUrl = apiBaseUrl;\r\n  }\r\n\r\n  /**\r\n   * Retrieves presigned URL for uploading files to Amazon S3 bucket.\r\n   * @param {(File | FileList)} file\r\n   * @return {Observable<FileUploadPresignedUrl>}\r\n   * @memberof FileUploadService\r\n   */\r\n  getFileUploadPresignedUrl(\r\n    file: File | FileList\r\n  ): Observable<FileUploadPresignedUrl> {\r\n    let fileName = '';\r\n    if (Object.values(file).length) fileName = Object.values(file)[0].name;\r\n    else fileName = (file as File).name;\r\n    return this.httpService\r\n      .getData(`${this.apiBaseUrl}/configurations/s3/uploadFileUrl/${fileName}`)\r\n      .pipe(\r\n        map((response) => {\r\n          return response;\r\n        }),\r\n        catchError((errorRes) => {\r\n          throw errorRes;\r\n        })\r\n      );\r\n  }\r\n  /**\r\n   * Uploads file to AWS S3 using a presigned URL.\r\n   * @param {string} presignedUrl\r\n   * @param {(File | FileList)} file\r\n   * @return {Observable<any>} -Returns an observable that emits the response after uploading the file to S3.\r\n   * @memberof FileUploadService\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  uploadFileToS3(presignedUrl: string, file: File | FileList): Observable<any> {\r\n    this.loaderNotificationService.show();\r\n    return this.httpClient\r\n      .put(presignedUrl, this.fileByteArray, {\r\n        reportProgress: true,\r\n        observe: 'events',\r\n      })\r\n      .pipe(\r\n        takeUntil(this.destroy$),\r\n        map((event) => this.getEventMessage(event, file)),\r\n        tap((message) => this.showProgress(message)),\r\n        last(),\r\n        catchError((errorRes) => {\r\n          this.loaderNotificationService.hide();\r\n          throw errorRes;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Gets file upload progress.\r\n   * @param {*} message\r\n   * @memberof FileUploadService\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars, no-unused-vars, no-empty-function, @typescript-eslint/no-empty-function\r\n  showProgress(message: any) {}\r\n\r\n  /**\r\n   * Return distinct message for sent, upload progress, & response events.\r\n   * @param {HttpEvent<any>} event\r\n   * @param {(File | FileList)} file\r\n   * @return {*}\r\n   * @memberof FileUploadService\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  getEventMessage(event: HttpEvent<any>, file: File | FileList) {\r\n    let fileName = '';\r\n    let fileSize: number | string = 0;\r\n    if (Object.values(file).length) {\r\n      fileName = Object.values(file)[0].name;\r\n      fileSize = Object.values(file)[0].size;\r\n    } else {\r\n      fileName = (file as File).name;\r\n      fileSize = (file as File).size;\r\n    }\r\n    switch (event.type) {\r\n      case HttpEventType.Sent:\r\n        return `Uploading file \"${fileName}\" of size ${fileSize}.`;\r\n      case HttpEventType.UploadProgress:\r\n        // eslint-disable-next-line no-case-declarations\r\n        const percentDone = event?.total\r\n          ? Math.round((100 * event.loaded) / event.total)\r\n          : 0;\r\n        return `File \"${fileName}\" is ${percentDone}% uploaded.`;\r\n      case HttpEventType.Response:\r\n        this.loaderNotificationService.hide();\r\n        return true;\r\n      default:\r\n        return `File \"${fileName}\" surprising upload event: ${event.type}.`;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Converts file to byte array.\r\n   * @param {File} file\r\n   * @memberof FileUploadService\r\n   */\r\n  convertFileToByteArray(file: File): void {\r\n    const reader = new FileReader();\r\n    reader.onloadend = () => {\r\n      const arrayBuffer = reader?.result as ArrayBuffer;\r\n      this.fileByteArray = new Uint8Array(arrayBuffer);\r\n    };\r\n    reader.onerror = () => {\r\n      this.alertService?.showMessage({\r\n        status: 'custom',\r\n        message: this.constants?.fileUpload?.message?.error?.errorReadingFile,\r\n        alertType: AlertType?.ERROR,\r\n        isCloseNeeded: true,\r\n      });\r\n    };\r\n    reader.readAsArrayBuffer(file);\r\n  }\r\n\r\n  /**\r\n   * Resets file byte array format to undefined.\r\n   * @memberof FileUploadService\r\n   */\r\n  clearFileByteArray(): void {\r\n    this.fileByteArray = undefined;\r\n  }\r\n\r\n  /**\r\n   * Sets file upload status.\r\n   * @param {boolean} status\r\n   * @memberof FileUploadService\r\n   */\r\n  setFileUploadStatus(status: boolean): void {\r\n    this.isFileUploading = status;\r\n  }\r\n\r\n  /**\r\n   * Returns file upload status.\r\n   * @return {boolean}\r\n   * @memberof FileUploadService\r\n   */\r\n  getFileUploadStatus(): boolean {\r\n    return this.isFileUploading;\r\n  }\r\n\r\n  /**\r\n   * Retrieves presigned URL for downloading files to Amazon S3 bucket.\r\n   * @param {(File | FileList)} file\r\n   * @return {Observable<string>}\r\n   * @memberof FileUploadService\r\n   */\r\n  getFileDownloadPresignedUrls(file: File | FileList): Observable<string> {\r\n    let fileName = '';\r\n    if (Object.values(file).length) fileName = Object.values(file)[0].name;\r\n    else fileName = (file as File).name;\r\n    return this.httpService\r\n      .getData(\r\n        `${this.apiBaseUrl}/configurations/s3/downloadFileUrl/${fileName}`\r\n      )\r\n      .pipe(\r\n        map((response) => {\r\n          return response;\r\n        }),\r\n        catchError((errorRes) => {\r\n          throw errorRes;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Downloads file to AWS S3 using a presigned URL.\r\n   * @return {Observable<any>}\r\n   * @memberof FileUploadService\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  downloadFile(fileDownloadPresignedUrl: string): Observable<any> {\r\n    return this.httpClient.get(fileDownloadPresignedUrl);\r\n  }\r\n\r\n  /**\r\n   * Validates the total size of the files uploaded.\r\n   * @param {(File | FileList)} files -The files to be validated.\r\n   * @param {number} maxFileSize\r\n   * @param {boolean} isMultiFileUpload\r\n   * @return {boolean} -Returns true if the total size of files is within the specified limit, otherwise false.\r\n   * @memberof FileUploadService\r\n   */\r\n  validateFileSize(\r\n    files: File | FileList,\r\n    maxFileSize: number,\r\n    isMultiFileUpload: boolean\r\n  ): boolean {\r\n    if (isMultiFileUpload) {\r\n      let totalSize = 0;\r\n      Object.values(files).forEach((file: File) => {\r\n        totalSize += file.size;\r\n      });\r\n      return totalSize / (1024 * 1024) <= maxFileSize;\r\n    }\r\n    return (files as File).size / (1024 * 1024) <= maxFileSize;\r\n  }\r\n\r\n  /**\r\n   * Validates the file types of the uploaded files.\r\n   * @param {(File | FileList)} files\r\n   * @param {string[]} allowedFileTypes\r\n   * @param {boolean} isMultiFileUpload\r\n   * @return {boolean} -Returns true if all files have valid extensions, otherwise false.\r\n   * @memberof FileUploadService\r\n   */\r\n  validateFileTypes(\r\n    files: File | FileList,\r\n    allowedFileTypes: string[],\r\n    isMultiFileUpload: boolean\r\n  ): boolean {\r\n    const validateSingleFile = (file: File): boolean => {\r\n      const fileExtension = this.getFileExtension(file.name);\r\n      return allowedFileTypes?.includes(fileExtension);\r\n    };\r\n    if (isMultiFileUpload) {\r\n      let allFilesValid = true;\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      Object.values(files)?.forEach((fileItem: any) => {\r\n        if (!validateSingleFile(fileItem)) {\r\n          allFilesValid = false;\r\n        }\r\n      });\r\n      return allFilesValid;\r\n    }\r\n    return validateSingleFile(files as File);\r\n  }\r\n\r\n  /**\r\n   * Extracts and returns the extension of a file from its name.\r\n   * @private\r\n   * @param {string} fileName\r\n   * @return {string} -The file extension in lowercase.\r\n   * @memberof FileUploadService\r\n   */\r\n  private getFileExtension(fileName: string): string {\r\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\r\n    return fileName?.split('.').pop()!.toLowerCase();\r\n  }\r\n\r\n  /**\r\n   * Implementation of ngOnDestroy lifecycle hook method to unsubscribe the open observable subscriptions.\r\n   * @memberof FileUploadService\r\n   */\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next(true);\r\n    this.destroy$.unsubscribe();\r\n  }\r\n}\r\n"]}

package/esm2022/public-api.mjs

@@ -34,10 +34,13 @@ export * from './lib/components/time-picker/time-picker.component';
 export * from './lib/components/tabs/tabs.component';
 export * from './lib/components/slide-toggle/slide-toggle.component';
 export * from './lib/components/card/card.component';
+export * from './lib/components/color-picker/color-picker.component';
+export * from './lib/components/file-upload/file-upload.component';
 export * from './lib/directives/dynamic-form-field/dynamic-form-field.directive';
 export * from './lib/directives/focus-invalid-form-field/focus-invalid-form-field.directive';
 export * from './lib/directives/set-background/set-background.directive';
 export * from './lib/directives/text-truncated/text-truncated.directive';
+export * from './lib/directives/file-upload/file-upload.directive';
 export * from './lib/models/align-type.model';
 export * from './lib/models/app-config-info.model';
 export * from './lib/models/autocomplete-option.model';
@@ -78,7 +81,11 @@ export * from './lib/models/slide-toggle-options.model';
 export * from './lib/models/button-type.model';
 export * from './lib/models/card-button.model';
 export * from './lib/models/card-info.model';
+export * from './lib/models/color-format.model';
+export * from './lib/models/allowed-file-types.model';
+export * from './lib/models/file-upload-presigned-url-res.model';
 export * from './lib/services/datepicker.service';
 export * from './lib/services/form-utility.service';
+export * from './lib/services/file-upload.service';
 export * from './lib/presentation.module';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../projects/presentation/src/public-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,sDAAsD,CAAC;AACrE,cAAc,8CAA8C,CAAC;AAC7D,cAAc,oDAAoD,CAAC;AACnE,cAAc,kEAAkE,CAAC;AACjF,cAAc,sDAAsD,CAAC;AACrE,cAAc,0CAA0C,CAAC;AACzD,cAAc,kDAAkD,CAAC;AACjE,cAAc,gEAAgE,CAAC;AAC/E,cAAc,0CAA0C,CAAC;AACzD,cAAc,oDAAoD,CAAC;AACnE,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC;AACvD,cAAc,kEAAkE,CAAC;AACjF,cAAc,4DAA4D,CAAC;AAC3E,cAAc,sDAAsD,CAAC;AACrE,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,wDAAwD,CAAC;AACvE,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,kDAAkD,CAAC;AACjE,cAAc,kDAAkD,CAAC;AACjE,cAAc,sCAAsC,CAAC;AACrD,cAAc,oDAAoD,CAAC;AACnE,cAAc,sCAAsC,CAAC;AACrD,cAAc,sDAAsD,CAAC;AACrE,cAAc,sCAAsC,CAAC;AAErD,cAAc,kEAAkE,CAAC;AACjF,cAAc,8EAA8E,CAAC;AAC7F,cAAc,0DAA0D,CAAC;AACzE,cAAc,0DAA0D,CAAC;AAEzE,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,cAAc,wCAAwC,CAAC;AACvD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wCAAwC,CAAC;AACvD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,iCAAiC,CAAC;AAChD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAE7C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AAEpD,cAAc,2BAA2B,CAAC","sourcesContent":["/*\r\n * Public API Surface of presentation\r\n */\r\nexport * from './lib/components/autocomplete/autocomplete.component';\r\nexport * from './lib/components/checkbox/checkbox.component';\r\nexport * from './lib/components/date-picker/date-picker.component';\r\nexport * from './lib/components/date-picker-header/date-picker-header.component';\r\nexport * from './lib/components/dynamic-form/dynamic-form.component';\r\nexport * from './lib/components/footer/footer.component';\r\nexport * from './lib/components/form-error/form-error.component';\r\nexport * from './lib/components/form-support-text/form-support-text.component';\r\nexport * from './lib/components/header/header.component';\r\nexport * from './lib/components/icon-button/icon-button.component';\r\nexport * from './lib/components/input/input.component';\r\nexport * from './lib/components/legend/legend.component';\r\nexport * from './lib/components/menu/menu.component';\r\nexport * from './lib/components/modal/modal.component';\r\nexport * from './lib/components/modal-confirmation/modal-confirmation.component';\r\nexport * from './lib/components/navigation-menu/navigation-menu.component';\r\nexport * from './lib/components/notification/notification.component';\r\nexport * from './lib/components/radio/radio.component';\r\nexport * from './lib/components/search/search.component';\r\nexport * from './lib/components/select/select.component';\r\nexport * from './lib/components/text-area/text-area.component';\r\nexport * from './lib/components/toggle-button/toggle-button.component';\r\nexport * from './lib/components/welcome/welcome.component';\r\nexport * from './lib/components/chips/chips.component';\r\nexport * from './lib/components/filter/filter.component';\r\nexport * from './lib/components/loader/loader.component';\r\nexport * from './lib/components/data-table/data-table.component';\r\nexport * from './lib/components/breadcrumb/breadcrumb.component';\r\nexport * from './lib/components/tile/tile.component';\r\nexport * from './lib/components/time-picker/time-picker.component';\r\nexport * from './lib/components/tabs/tabs.component';\r\nexport * from './lib/components/slide-toggle/slide-toggle.component';\r\nexport * from './lib/components/card/card.component';\r\n\r\nexport * from './lib/directives/dynamic-form-field/dynamic-form-field.directive';\r\nexport * from './lib/directives/focus-invalid-form-field/focus-invalid-form-field.directive';\r\nexport * from './lib/directives/set-background/set-background.directive';\r\nexport * from './lib/directives/text-truncated/text-truncated.directive';\r\n\r\nexport * from './lib/models/align-type.model';\r\nexport * from './lib/models/app-config-info.model';\r\nexport * from './lib/models/autocomplete-option.model';\r\nexport * from './lib/models/calendar.model';\r\nexport * from './lib/models/checkbox-option.model';\r\nexport * from './lib/models/confirmation-modal-data.model';\r\nexport * from './lib/models/date-picker.model';\r\nexport * from './lib/models/event-emit-type.model';\r\nexport * from './lib/models/field-config.model';\r\nexport * from './lib/models/footer-config.model';\r\nexport * from './lib/models/form-control-types.model';\r\nexport * from './lib/models/form-field.model';\r\nexport * from './lib/models/form-grid.model';\r\nexport * from './lib/models/form.model';\r\nexport * from './lib/models/header-config.model';\r\nexport * from './lib/models/icon-button.model';\r\nexport * from './lib/models/legend.model';\r\nexport * from './lib/models/link-type.model';\r\nexport * from './lib/models/menu.model';\r\nexport * from './lib/models/navigation-menu.model';\r\nexport * from './lib/models/radio-option.model';\r\nexport * from './lib/models/search.model';\r\nexport * from './lib/models/select-opened-state.model';\r\nexport * from './lib/models/select-option.model';\r\nexport * from './lib/models/selected-date.model';\r\nexport * from './lib/models/selected-time.model';\r\nexport * from './lib/models/tab.model';\r\nexport * from './lib/models/toggle-button.model';\r\nexport * from './lib/models/chip-option.model';\r\nexport * from './lib/models/paginator-config.model';\r\nexport * from './lib/models/table-actions.model';\r\nexport * from './lib/models/table-schema.model';\r\nexport * from './lib/models/breadcrumb.model';\r\nexport * from './lib/models/tile.model';\r\nexport * from './lib/models/filters-options.model';\r\nexport * from './lib/models/profile-menu.model';\r\nexport * from './lib/models/slide-toggle-options.model';\r\nexport * from './lib/models/button-type.model';\r\nexport * from './lib/models/card-button.model';\r\nexport * from './lib/models/card-info.model';\r\n\r\nexport * from './lib/services/datepicker.service';\r\nexport * from './lib/services/form-utility.service';\r\n\r\nexport * from './lib/presentation.module';\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../projects/presentation/src/public-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * Public API Surface of presentation\r\n */\r\nexport * from './lib/components/autocomplete/autocomplete.component';\r\nexport * from './lib/components/checkbox/checkbox.component';\r\nexport * from './lib/components/date-picker/date-picker.component';\r\nexport * from './lib/components/date-picker-header/date-picker-header.component';\r\nexport * from './lib/components/dynamic-form/dynamic-form.component';\r\nexport * from './lib/components/footer/footer.component';\r\nexport * from './lib/components/form-error/form-error.component';\r\nexport * from './lib/components/form-support-text/form-support-text.component';\r\nexport * from './lib/components/header/header.component';\r\nexport * from './lib/components/icon-button/icon-button.component';\r\nexport * from './lib/components/input/input.component';\r\nexport * from './lib/components/legend/legend.component';\r\nexport * from './lib/components/menu/menu.component';\r\nexport * from './lib/components/modal/modal.component';\r\nexport * from './lib/components/modal-confirmation/modal-confirmation.component';\r\nexport * from './lib/components/navigation-menu/navigation-menu.component';\r\nexport * from './lib/components/notification/notification.component';\r\nexport * from './lib/components/radio/radio.component';\r\nexport * from './lib/components/search/search.component';\r\nexport * from './lib/components/select/select.component';\r\nexport * from './lib/components/text-area/text-area.component';\r\nexport * from './lib/components/toggle-button/toggle-button.component';\r\nexport * from './lib/components/welcome/welcome.component';\r\nexport * from './lib/components/chips/chips.component';\r\nexport * from './lib/components/filter/filter.component';\r\nexport * from './lib/components/loader/loader.component';\r\nexport * from './lib/components/data-table/data-table.component';\r\nexport * from './lib/components/breadcrumb/breadcrumb.component';\r\nexport * from './lib/components/tile/tile.component';\r\nexport * from './lib/components/time-picker/time-picker.component';\r\nexport * from './lib/components/tabs/tabs.component';\r\nexport * from './lib/components/slide-toggle/slide-toggle.component';\r\nexport * from './lib/components/card/card.component';\r\nexport * from './lib/components/color-picker/color-picker.component';\r\nexport * from './lib/components/file-upload/file-upload.component';\r\n\r\nexport * from './lib/directives/dynamic-form-field/dynamic-form-field.directive';\r\nexport * from './lib/directives/focus-invalid-form-field/focus-invalid-form-field.directive';\r\nexport * from './lib/directives/set-background/set-background.directive';\r\nexport * from './lib/directives/text-truncated/text-truncated.directive';\r\nexport * from './lib/directives/file-upload/file-upload.directive';\r\n\r\nexport * from './lib/models/align-type.model';\r\nexport * from './lib/models/app-config-info.model';\r\nexport * from './lib/models/autocomplete-option.model';\r\nexport * from './lib/models/calendar.model';\r\nexport * from './lib/models/checkbox-option.model';\r\nexport * from './lib/models/confirmation-modal-data.model';\r\nexport * from './lib/models/date-picker.model';\r\nexport * from './lib/models/event-emit-type.model';\r\nexport * from './lib/models/field-config.model';\r\nexport * from './lib/models/footer-config.model';\r\nexport * from './lib/models/form-control-types.model';\r\nexport * from './lib/models/form-field.model';\r\nexport * from './lib/models/form-grid.model';\r\nexport * from './lib/models/form.model';\r\nexport * from './lib/models/header-config.model';\r\nexport * from './lib/models/icon-button.model';\r\nexport * from './lib/models/legend.model';\r\nexport * from './lib/models/link-type.model';\r\nexport * from './lib/models/menu.model';\r\nexport * from './lib/models/navigation-menu.model';\r\nexport * from './lib/models/radio-option.model';\r\nexport * from './lib/models/search.model';\r\nexport * from './lib/models/select-opened-state.model';\r\nexport * from './lib/models/select-option.model';\r\nexport * from './lib/models/selected-date.model';\r\nexport * from './lib/models/selected-time.model';\r\nexport * from './lib/models/tab.model';\r\nexport * from './lib/models/toggle-button.model';\r\nexport * from './lib/models/chip-option.model';\r\nexport * from './lib/models/paginator-config.model';\r\nexport * from './lib/models/table-actions.model';\r\nexport * from './lib/models/table-schema.model';\r\nexport * from './lib/models/breadcrumb.model';\r\nexport * from './lib/models/tile.model';\r\nexport * from './lib/models/filters-options.model';\r\nexport * from './lib/models/profile-menu.model';\r\nexport * from './lib/models/slide-toggle-options.model';\r\nexport * from './lib/models/button-type.model';\r\nexport * from './lib/models/card-button.model';\r\nexport * from './lib/models/card-info.model';\r\nexport * from './lib/models/color-format.model';\r\nexport * from './lib/models/allowed-file-types.model';\r\nexport * from './lib/models/file-upload-presigned-url-res.model';\r\n\r\nexport * from './lib/services/datepicker.service';\r\nexport * from './lib/services/form-utility.service';\r\nexport * from './lib/services/file-upload.service';\r\n\r\nexport * from './lib/presentation.module';\r\n"]}