mmhglobal-dynamicform 2.42.0 → 2.43.0

package/esm2020/lib/zupload/zupload.component.mjs

@@ -3,11 +3,11 @@ import { Component, ViewChild } from "@angular/core";
 /********** Ionic **********/
 /********** Plugin **********/
 // import { environment } from "src/environments/environment";
-import { take } from 'rxjs/operators';
-import { HttpEventType } from '@angular/common/http';
+import { HttpEventType } from "@angular/common/http";
+import { take } from "rxjs/operators";
 /********** Component & Service **********/
 import { InputFieldBase } from "../components/inputfieldbase.component";
-import { ZComponentHelper, UploadMetaData, AttachmentConfig } from "mmhglobal-zcore";
+import { AttachmentConfig, UploadMetaData, ZComponentHelper, } from "mmhglobal-zcore";
 import * as i0 from "@angular/core";
 import * as i1 from "../services/zcomponent.service";
 import * as i2 from "mmhglobal-zcore";
@@ -17,24 +17,6 @@ import * as i5 from "@angular/common";
 export class MyFileInfo {
 }
 export class ZuploadComponent extends InputFieldBase {
-    // zModelValue = [{
-    //   name: "RXJS 01.png",
-    //   size: 128753,
-    //   uid: "c96e234d-af61-4587-adcc-3b400ddef884"
-    // }];
-    // fieldElement = [{
-    //   Name: 'FileUploadList',
-    //   Type: 'zupload',
-    //   Value: 'FileUploadList',
-    //   SelectionOptions: ['jpg', 'jpeg', 'png', 'bmp', 'pdf'],
-    //   UploadMetaData: 'group.UploadMetaData',
-    //   AutoUpload: false,
-    //   AllowRemove: true,
-    //   Multiple: false,
-    //   OnSuccess: 'group.onSuccess()',
-    //   DivClass: "col-md-12 col-md-6",
-    //   Visible: true
-    // }];
     constructor(componentService, authService, compressImage, zcoreService, ngZone, sharePointService, alertService) {
         super(componentService);
         this.componentService = componentService;
@@ -44,6 +26,7 @@ export class ZuploadComponent extends InputFieldBase {
         this.ngZone = ngZone;
         this.sharePointService = sharePointService;
         this.alertService = alertService;
+        // NOTE: Naming: `uid` array actually stores preview UIDs. Consider renaming to `previewUids` in future (not changed to preserve API).
         this.uploadAttachmentUrl = null;
         this.uploadSaveUrl = "/Attachment/Chunk_Upload_Save"; // should represent an actual API endpoint
         this.uploadRemoveUrl = "/Attachment/Chunk_Upload_Remove"; // should represent an actual API endpoint
@@ -51,9 +34,9 @@ export class ZuploadComponent extends InputFieldBase {
         this.getImageUrl = "/Attachment/getImage"; // GET method
         this.isAutoUpload = false;
         this.isMultiple = false;
+        this.showFileList = true;
         this.imagePreviews = [];
         this.uid = [];
-        this.showFileList = true;
         this.fileList = [];
         this.restrictions = {
             minFileSize: 1,
@@ -78,74 +61,132 @@ export class ZuploadComponent extends InputFieldBase {
             size: 102400,
             maxAutoRetries: 3,
         };
-        this.uploadAttachmentUrl = this.zcoreService.normalizeUrl(this.zcoreService.getEnvironment().uploadAttachmentUrl);
-        this.uploadSaveUrl = this.uploadAttachmentUrl + this.uploadSaveUrl;
-        this.uploadRemoveUrl = this.uploadAttachmentUrl + this.uploadRemoveUrl;
+        const env = this.zcoreService.getEnvironment();
+        const normalized = this.zcoreService.normalizeUrl(env?.uploadAttachmentUrl);
+        this.uploadAttachmentUrl = normalized ?? null;
+        if (this.uploadAttachmentUrl) {
+            this.uploadSaveUrl = this.uploadAttachmentUrl + this.uploadSaveUrl;
+            this.uploadRemoveUrl = this.uploadAttachmentUrl + this.uploadRemoveUrl;
+        }
+        else {
+            // Safer logging: avoid silent null URLs that break uploads
+            // NOTE: This indicates a configuration issue.
+            console.warn(`[ZuploadComponent] uploadAttachmentUrl is empty. Upload endpoints may be invalid.`, { uploadAttachmentUrl: env?.uploadAttachmentUrl });
+        }
+        this.defaultUploadSaveUrl = this.uploadSaveUrl;
+        this.defaultUploadRemoveUrl = this.uploadRemoveUrl;
     }
+    /**
+     * Angular lifecycle hook - initializes restrictions and upload behavior from field config.
+     */
     ngOnInit() {
         super.setupInnerField();
-        // this.group['UploadMetaData'] = new UploadMetaData(null, '15', 'SO-No-1234', 'SaleOrder');
-        // this.uploadSaveUrl = uploadAttachmentUrl + this.uploadSaveUrl;
-        // this.uploadRemoveUrl = uploadAttachmentUrl + this.uploadRemoveUrl;
-        if (this.data.SelectOptions && !this.data.AllowedFileExtension) {
+        // Allowed extensions:
+        // - If SelectOptions present and AllowedFileExtension not present, override
+        // - Else if AllowedFileExtension present and SelectOptions absent, append
+        // NOTE: Keep original behavior; it may allow duplicates, but prevents unexpected restriction loss.
+        if (this.data?.SelectOptions && !this.data?.AllowedFileExtension) {
             this.restrictions.allowedExtensions = this.data.SelectOptions;
         }
-        else if (!this.data.SelectOptions && this.data.AllowedFileExtension) {
+        else if (!this.data?.SelectOptions && this.data?.AllowedFileExtension) {
             this.restrictions.allowedExtensions = this.restrictions.allowedExtensions.concat(this.data.AllowedFileExtension);
         }
-        if (this.data.MinFileSize) {
+        if (typeof this.data?.MinFileSize === "number" && this.data.MinFileSize >= 0) {
             this.restrictions.minFileSize = this.data.MinFileSize;
         }
-        if (this.data.MaxFileSize) {
+        if (typeof this.data?.MaxFileSize === "number" && this.data.MaxFileSize >= 0) {
             this.restrictions.maxFileSize = this.data.MaxFileSize;
         }
-        this.isAutoUpload = this.data.AutoUpload || false;
-        if (!this.data.AllowRemove) {
+        this.isAutoUpload = Boolean(this.data?.AutoUpload);
+        // If remove is not allowed, Kendo upload expects empty URL to hide remove request.
+        if (this.data && this.data.AllowRemove === false) {
             this.uploadRemoveUrl = "";
         }
-        if (this.data.Multiple) {
-            this.isMultiple = this.data.Multiple;
-        }
-        this.componentProperties.style.style6 = this.componentProperties.style.style6 || "margin: 5px; border: 1px solid gray;";
+        this.isMultiple = Boolean(this.data?.Multiple);
+        // Ensure style6 exists (legacy styling hook).
+        this.componentProperties.style.style6 =
+            this.componentProperties.style.style6 || "margin: 5px; border: 1px solid gray;";
     }
+    /**
+     * Kendo Upload success callback for both upload and remove.
+     * Keeps zModel in sync and emits ZComponent output events.
+     */
     onSuccess(e) {
-        // angular kendo upload didn't filter away Sent event for remove, so we have to handle it here
-        // upload progress not required for removal, thus it's also removed
-        // @ts-ignore
-        if (e.operation === "remove" && (e.response.type === HttpEventType.Sent || e.response.type === HttpEventType.UploadProgress)) {
+        // Angular Kendo Upload emits "Sent" and "UploadProgress" for remove; ignore them to avoid double-handling.
+        // @ts-ignore - Kendo types for response differ by runtime usage
+        const responseType = e?.response?.type;
+        if (e?.operation === "remove" &&
+            (responseType === HttpEventType.Sent || responseType === HttpEventType.UploadProgress)) {
+            return;
+        }
+        const modelKey = this.data?.Value;
+        if (!modelKey) {
+            console.warn(`[ZuploadComponent] onSuccess skipped: missing data.Value.`, { event: e });
             return;
         }
-        if (!Array.isArray(this.group.zModel[this.data.Value])) {
-            this.group.zModel[this.data.Value] = [];
+        if (!this.group?.zModel) {
+            console.warn(`[ZuploadComponent] onSuccess skipped: missing group.zModel.`, { event: e });
+            return;
         }
-        const file = e.files[0];
-        const existingFileIndex = this.group.zModel[this.data.Value].findIndex(f => f.name === file.name && f.uid === file.uid);
+        if (!Array.isArray(this.group.zModel[modelKey])) {
+            this.group.zModel[modelKey] = [];
+        }
+        const file = e?.files?.[0] ?? undefined;
+        if (!file) {
+            console.warn(`[ZuploadComponent] onSuccess: no file found in event.`, { event: e });
+            return;
+        }
+        const existingFileIndex = this.group.zModel[modelKey].findIndex((f) => f?.name === file.name && f?.uid === file.uid);
         if (e.operation === "upload") {
-            // console.log('upload Success: ', e);
-            //sharepoint required to read data from fileUid and attachment able to get data from fileUid too.
-            file.myUid = e.response?.body?.fileUid ?? file.uid;
-            delete file['httpSubscription'];
+            // SharePoint and Attachment use fileUid (server) for later operations.
+            // Prefer fileUid if provided; fallback to file.uid
+            // @ts-ignore - body shape is runtime-dependent
+            file.myUid = e?.response?.body?.fileUid ?? file.uid;
+            // Clean up internal subscription data to avoid circular structures
+            // NOTE: This relies on Kendo attaching internal fields; safe delete.
+            delete file["httpSubscription"];
             if (existingFileIndex !== -1) {
-                this.group.zModel[this.data.Value][existingFileIndex] = file;
+                this.group.zModel[modelKey][existingFileIndex] = file;
             }
             else {
-                this.group.zModel[this.data.Value].push(file);
+                this.group.zModel[modelKey].push(file);
             }
+            console.info(`[ZuploadComponent] Upload succeeded.`, {
+                name: file.name,
+                uid: file.uid,
+                myUid: file.myUid,
+            });
         }
         else if (e.operation === "remove") {
             if (existingFileIndex !== -1) {
-                this.group.zModel[this.data.Value].splice(existingFileIndex, 1);
+                this.group.zModel[modelKey].splice(existingFileIndex, 1);
             }
+            console.info(`[ZuploadComponent] Remove succeeded.`, {
+                name: file.name,
+                uid: file.uid,
+                myUid: file.myUid,
+            });
+        }
+        else {
+            // Unknown operation, preserve behavior but log for diagnostics.
+            console.debug(`[ZuploadComponent] onSuccess received unsupported operation.`, { operation: e.operation, event: e });
         }
-        ZComponentHelper.setComponentModelValue(this.data, this.group.zModel[this.data.Value], this.group);
-        this.group.subject.next({
+        ZComponentHelper.setComponentModelValue(this.data, this.group.zModel[modelKey], this.group);
+        this.group.subject?.next({
             type: "zupload-onSuccess",
-            target: this.data.OnSuccess,
+            target: this.data?.OnSuccess,
             event: e,
-            data: { value: e.files[0], field: this.data },
+            data: { value: file, field: this.data },
         });
     }
+    /**
+     * Normalize and enrich image compression config with byte-based thresholds.
+     */
     compressionConfigHandler(imgConfig) {
+        if (!imgConfig) {
+            // NOTE: keep function safe for unexpected null; returns as-is
+            return imgConfig;
+        }
         if (imgConfig.FileSizeMaxSize) {
             imgConfig.FileSizeMaxSizeByte = this.convertSizeToByte(imgConfig.FileSizeMaxSize);
         }
@@ -157,79 +198,114 @@ export class ZuploadComponent extends InputFieldBase {
         }
         return imgConfig;
     }
+    /**
+     * Convert string size values like "10KB", "2 MB", "1gb", "1024" into bytes.
+     * If unit is omitted, bytes are assumed.
+     *
+     * @param sizeString Human readable size string.
+     * @returns Size in bytes. Returns 0 if parsing fails.
+     */
     convertSizeToByte(sizeString) {
-        let _tempFileSizeMaxSize = 0;
+        if (!sizeString || typeof sizeString !== "string") {
+            return 0;
+        }
+        // Remove all spaces
+        const raw = sizeString.replace(/ /g, "").trim();
+        if (!raw) {
+            return 0;
+        }
+        let parsedValue = 0;
         let sizeByByte = 0;
-        let sizeType = 'b';
-        // remove all space
-        const _tempFileSize = sizeString.replace(/ /g, '');
-        // check last char is alphabetic
-        const lastChar = _tempFileSize.substr(_tempFileSize.length - 1);
-        if (isNaN(parseFloat(lastChar))) {
-            const secLastChar = _tempFileSize.substr(_tempFileSize.length - 2).slice(0, -1);
-            if (isNaN(parseFloat(secLastChar))) {
-                // check last 2nd char is alphabetic
-                sizeType = secLastChar + sizeType;
-                _tempFileSizeMaxSize = parseFloat(_tempFileSize.slice(0, -2));
+        let sizeType = "b";
+        // Check last char is alphabetic
+        const lastChar = raw.substring(raw.length - 1);
+        const lastCharIsNumber = !Number.isNaN(Number.parseFloat(lastChar));
+        if (!lastCharIsNumber) {
+            const secondLastChar = raw.substring(raw.length - 2).slice(0, -1);
+            const secondLastIsNumber = !Number.isNaN(Number.parseFloat(secondLastChar));
+            if (!secondLastIsNumber) {
+                // Last 2nd char is also alphabetic (e.g. "MB", "GB")
+                sizeType = `${secondLastChar}${sizeType}`;
+                parsedValue = Number.parseFloat(raw.slice(0, -2));
             }
             else {
-                _tempFileSizeMaxSize = parseFloat(_tempFileSize.slice(0, -1));
+                parsedValue = Number.parseFloat(raw.slice(0, -1));
+            }
+            // If parsing failed, return 0 (SonarQube safe behavior)
+            if (Number.isNaN(parsedValue) || parsedValue < 0) {
+                console.warn(`[ZuploadComponent] convertSizeToByte: invalid size value.`, { sizeString });
+                return 0;
             }
             switch (sizeType.toLowerCase()) {
                 case "b":
-                    sizeByByte = _tempFileSizeMaxSize;
+                    sizeByByte = parsedValue;
                     break;
                 case "kb":
-                    sizeByByte = _tempFileSizeMaxSize * 1024;
+                    sizeByByte = parsedValue * 1024;
                     break;
                 case "mb":
-                    sizeByByte = _tempFileSizeMaxSize * 1048576;
+                    sizeByByte = parsedValue * 1048576;
                     break;
                 case "gb":
-                    sizeByByte = _tempFileSizeMaxSize * 1073741824;
+                    sizeByByte = parsedValue * 1073741824;
+                    break;
+                default:
+                    // Unknown unit => treat as bytes for backward compatibility
+                    console.warn(`[ZuploadComponent] convertSizeToByte: unknown unit, defaulting to bytes.`, {
+                        sizeString,
+                        unit: sizeType,
+                    });
+                    sizeByByte = parsedValue;
                     break;
             }
         }
         else {
-            // default using bytes if no size type
-            sizeByByte = parseFloat(_tempFileSize);
+            // Default using bytes if no size type
+            const n = Number.parseFloat(raw);
+            if (Number.isNaN(n) || n < 0) {
+                console.warn(`[ZuploadComponent] convertSizeToByte: invalid numeric bytes value.`, { sizeString });
+                return 0;
+            }
+            sizeByByte = n;
         }
         return sizeByByte;
     }
+    /**
+     * Kendo Upload upload event: validates files, builds image previews, injects metadata and auth header.
+     */
     uploadEventHandler(e) {
+        if (!e?.files?.length) {
+            console.warn(`[ZuploadComponent] uploadEventHandler: no files in UploadEvent.`);
+            return;
+        }
         // Image Preview
-        const me = this;
         e.files.forEach((file) => {
-            if (!me.isValidUploadedFile(me, file)) {
+            if (!this.isValidUploadedFile(file)) {
                 e.preventDefault();
                 return;
             }
-            else {
-                if (file.rawFile && file.rawFile.type.includes("image")) {
-                    if (!file.validationErrors) {
-                        const reader = new FileReader();
-                        reader.onload = function (ev) {
-                            if (me.data.EnableImagePreview) {
-                                if (!me.uid.includes(file.uid)) {
-                                    me.uid.push(file.uid);
-                                    me.imagePreviews.push({ ...file, src: reader.result });
-                                }
-                            }
-                        };
-                        reader.readAsDataURL(file.rawFile);
+            if (file?.rawFile?.type?.includes("image") && !file.validationErrors) {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    if (this.data?.EnableImagePreview) {
+                        if (!this.uid.includes(file.uid)) {
+                            this.uid.push(file.uid);
+                            this.imagePreviews.push({ ...file, src: reader.result });
+                        }
                     }
-                }
+                };
+                reader.readAsDataURL(file.rawFile);
             }
         });
         // Add metadata to the upload event
-        let additional = ZComponentHelper.getGroupEvalValue.call(this, this.data.UploadMetaData);
+        let additional = ZComponentHelper.getGroupEvalValue.call(this, this.data?.UploadMetaData);
         if (!(additional instanceof UploadMetaData)) {
-            console.error("UploadMetaData defined at " + this.data.UploadMetaData + " is invalid: ", additional);
+            console.warn(`[ZuploadComponent] Invalid UploadMetaData at "${this.data?.UploadMetaData}". Fallback to default metadata.`, additional);
             additional = new UploadMetaData(null, "0");
         }
         //#region sharepoint
-        let attachmentInfo = this.sharePointService.getAttachmentInfo(this.data["DownloadFileConfig"]);
-        //add tagging into metadata
+        const attachmentInfo = this.sharePointService.getAttachmentInfo(this.data?.["DownloadFileConfig"]);
+        // Add tagging into metadata
         if (attachmentInfo) {
             if (attachmentInfo.tag) {
                 const tag = this.sharePointService.generateTagging(this.group, attachmentInfo.tag);
@@ -240,155 +316,270 @@ export class ZuploadComponent extends InputFieldBase {
             additional[AttachmentConfig.isSaveToSharePoint] = attachmentInfo.isSaveToSharePoint;
         }
         //#endregion
-        const str = JSON.stringify(additional);
-        e.data = { additional: str, };
-        e.headers = e.headers.append("Authorization", "Bearer " + this.authService.e1AccessToken);
+        additional[AttachmentConfig.projectCode] = this.data?.ProjectCode;
+        additional[AttachmentConfig.moduleCode] = this.data?.ModuleCode;
+        const payload = JSON.stringify(additional);
+        e.data = { additional: payload };
+        // NOTE: Potentially unsafe: assumes token is always present. Keep behavior but add clearer logging.
+        const token = this.authService?.e1AccessToken;
+        if (!token) {
+            console.warn(`[ZuploadComponent] Missing e1AccessToken. Upload may fail due to authorization.`);
+        }
+        e.headers = e.headers.append("Authorization", `Bearer ${token ?? ""}`);
     }
+    /**
+     * Kendo Upload remove event: updates component memory, fires project event if defined,
+     * otherwise attaches required payload and authorization headers.
+     */
     onRemove(e) {
-        // remove file from component memory
-        const index = this.fileList.findIndex((item) => item.uid === e.files[0].uid);
+        const file = e?.files?.[0];
+        if (!file) {
+            console.warn(`[ZuploadComponent] onRemove: no file found in RemoveEvent.`, { event: e });
+            return;
+        }
+        // Remove file from component memory (for SelectFileOnly flow)
+        const index = this.fileList.findIndex((item) => item.uid === file.uid);
         if (index >= 0) {
             this.fileList.splice(index, 1);
-            this.group['zupload_' + this.data.Value] = this.fileList;
+            this.group[`zupload_${this.data?.Value}`] = this.fileList;
         }
-        if (this.data['FileRemovedEvent']) {
-            this.group.subject.next({
+        const removedEvent = this.data?.["FileRemovedEvent"];
+        if (removedEvent) {
+            this.group.subject?.next({
                 type: "zupload-fileRemovedEvent",
-                target: this.data['FileRemovedEvent'],
-                data: e
+                target: removedEvent,
+                data: e,
             });
+            return;
         }
-        else {
-            const myFile = e.files[0];
-            // console.log('remove done: ', e);
-            e.data = {
-                id: myFile.myUid,
-            };
-            e.headers = e.headers.append("Authorization", "Bearer " + this.authService.e1AccessToken);
-            if (this.data.EnableImagePreview) {
-                e.files.forEach((file) => {
-                    this.imagePreviews = this.imagePreviews.filter(f => f.uid !== file.uid);
-                });
-            }
+        const myFile = file;
+        // Attach remove payload
+        e.data = { id: myFile.myUid };
+        const token = this.authService?.e1AccessToken;
+        if (!token) {
+            console.warn(`[ZuploadComponent] Missing e1AccessToken. Remove may fail due to authorization.`);
         }
-    }
-    onChange(file) {
-        if (this.data['FileChangedEvent']) {
-            this.group.subject.next({
-                type: "zupload-fileChangedEvent",
-                target: this.data['FileChangedEvent'],
-                data: file
+        e.headers = e.headers.append("Authorization", `Bearer ${token ?? ""}`);
+        // Remove preview if enabled
+        if (this.data?.EnableImagePreview) {
+            e.files.forEach((f) => {
+                this.imagePreviews = this.imagePreviews.filter((p) => p?.["uid"] !== f.uid);
             });
         }
+        console.info(`[ZuploadComponent] Remove requested.`, { name: myFile.name, uid: myFile.uid, myUid: myFile.myUid });
+    }
+    /**
+     * Kendo Upload change event handler. Emits project event if configured.
+     */
+    onChange(files) {
+        const changedEvent = this.data?.["FileChangedEvent"];
+        if (!changedEvent) {
+            return;
+        }
+        this.group.subject?.next({
+            type: "zupload-fileChangedEvent",
+            target: changedEvent,
+            data: files,
+        });
     }
-    isValidUploadedFile(me, file) {
-        const fileSize = file.rawFile.size;
-        const fileExtension = file.rawFile.name.split('.').pop().toLowerCase();
-        // Check if file size and extension are valid
-        if (fileSize > me.restrictions.maxFileSize || !me.restrictions.allowedExtensions.includes(fileExtension)) {
-            let errorMessage = 'Error: ';
-            if (!me.restrictions.allowedExtensions.includes(fileExtension)) {
-                errorMessage = `Invalid file type. Allowed types are: ${me.restrictions.allowedExtensions.join(', ')}.`;
+    /**
+     * Validate a selected/uploaded file against configured restrictions (size + extension).
+     *
+     * @param file Kendo FileInfo
+     * @returns true if file passes restrictions, otherwise false (and shows alert).
+     */
+    isValidUploadedFile(file) {
+        const rawFile = file?.rawFile;
+        if (!rawFile) {
+            // NOTE: Kendo can provide FileInfo without rawFile in some events. Preserve behavior: treat as invalid.
+            console.warn(`[ZuploadComponent] File validation failed: rawFile is missing.`, { file });
+            this.alertService.showOkay("Failed to upload", "File is not available for upload.", ["col-4"]);
+            return false;
+        }
+        const fileSize = rawFile.size ?? 0;
+        // Keep original behavior: uses last segment after dot.
+        // NOTE: Potentially unsafe for files without extension; will result in empty extension.
+        const fileExtension = (rawFile.name?.split(".").pop() ?? "").toLowerCase();
+        const max = this.restrictions?.maxFileSize ?? 0;
+        const allowed = this.restrictions?.allowedExtensions ?? [];
+        const isExtensionAllowed = allowed.includes(fileExtension);
+        const isSizeAllowed = fileSize <= max;
+        if (!isExtensionAllowed || !isSizeAllowed) {
+            let errorMessage = "Error:";
+            if (!isExtensionAllowed) {
+                errorMessage = `Invalid file type "${fileExtension || "unknown"}". Allowed types: ${allowed.join(", ")}.`;
             }
-            else if (fileSize > me.restrictions.maxFileSize) {
-                errorMessage = `File size cannot exceeds ${me.formatFileSize(me.restrictions.maxFileSize)}.`;
+            else if (!isSizeAllowed) {
+                errorMessage = `File size cannot exceed ${this.formatFileSize(max)}.`;
             }
-            me.alertService.showOkay('Failed to upload', errorMessage, ['col-4']);
+            console.warn(`[ZuploadComponent] File rejected by restrictions.`, {
+                name: rawFile.name,
+                size: fileSize,
+                extension: fileExtension,
+                maxAllowedBytes: max,
+                allowedExtensions: allowed,
+            });
+            this.alertService.showOkay("Failed to upload", errorMessage, ["col-4"]);
             return false;
         }
         return true;
     }
+    /**
+     * Kendo Upload select event handler:
+     * - Handles SharePoint endpoint switching
+     * - Supports SelectFileOnly mode (read file content into memory and emit event)
+     * - Supports image compression when AutoUpload is false
+     */
     selectEventHandler(e) {
-        const me = this;
+        if (!e?.files?.length) {
+            console.warn(`[ZuploadComponent] selectEventHandler: no files in SelectEvent.`);
+            return;
+        }
+        // Reset to default every selection to avoid SharePoint URL "sticking" permanently.
+        this.uploadSaveUrl = this.defaultUploadSaveUrl;
+        this.uploadRemoveUrl = this.defaultUploadRemoveUrl;
         //#region sharepoint
-        const attachmentInfo = this.sharePointService.getAttachmentInfo(this.data["DownloadFileConfig"]);
+        const attachmentInfo = this.sharePointService.getAttachmentInfo(this.data?.["DownloadFileConfig"]);
         // Change uploadSaveUrl if saving to SharePoint
-        if (attachmentInfo && attachmentInfo.isSaveToSharePoint && attachmentInfo.siteName) {
-            const attachmentSourceUrl = this.zcoreService.getEnvironment().attachmentSourceUrl;
-            this.uploadSaveUrl = attachmentSourceUrl + '/Chunk_Upload_Save';
+        if (attachmentInfo?.isSaveToSharePoint && attachmentInfo.siteName) {
+            const attachmentSourceUrl = this.zcoreService.getEnvironment()?.attachmentSourceUrl;
+            if (attachmentSourceUrl) {
+                this.uploadSaveUrl = `${attachmentSourceUrl}/Chunk_Upload_Save`;
+                console.info(`[ZuploadComponent] Upload endpoint switched to SharePoint mode.`, { uploadSaveUrl: this.uploadSaveUrl });
+            }
+            else {
+                console.warn(`[ZuploadComponent] attachmentSourceUrl is missing. Cannot switch to SharePoint upload endpoint.`);
+            }
         }
         //#endregion
-        if (this.data['SelectFileOnly']) {
+        if (this.data?.["SelectFileOnly"]) {
             // Append all files to component memory
-            e.files.forEach(async (file) => {
-                if (me.isValidUploadedFile(me, file)) {
-                    if (file.rawFile) {
-                        const reader = new FileReader();
-                        reader.onload = function (ev) {
-                            // Clone the data and also add the read file to the object
-                            const fileData = Object.assign({}, file);
-                            fileData['file'] = ev.target["result"];
-                            // Push to component fileList
-                            me.fileList.push(fileData);
-                            me.group['zupload_' + me.data.Value] = me.fileList;
-                            if (me.data['FileSelectedEvent']) {
-                                // Call the project event
-                                me.group.subject.next({
-                                    type: "zupload-fileSelectedEvent",
-                                    target: me.data['FileSelectedEvent'],
-                                    data: me.fileList
-                                });
-                            }
-                        };
-                        await reader.readAsDataURL(file.rawFile);
-                    }
+            e.files.forEach((file) => {
+                if (!this.isValidUploadedFile(file)) {
+                    e.preventDefault();
+                    return;
                 }
-                else {
+                if (!file.rawFile) {
                     e.preventDefault();
+                    return;
                 }
+                const reader = new FileReader();
+                reader.onload = (ev) => {
+                    // Clone the data and also add the read file to the object
+                    const fileData = {
+                        ...file,
+                        file: ev?.target?.result ?? null,
+                    };
+                    fileData["file"] = ev?.target?.result;
+                    // Push to component fileList
+                    this.fileList.push(fileData);
+                    this.group[`zupload_${this.data?.Value}`] = this.fileList;
+                    const selectedEvent = this.data?.["FileSelectedEvent"];
+                    if (selectedEvent) {
+                        this.group.subject?.next({
+                            type: "zupload-fileSelectedEvent",
+                            target: selectedEvent,
+                            data: this.fileList,
+                        });
+                    }
+                };
+                reader.onerror = () => {
+                    console.warn(`[ZuploadComponent] Failed to read file as base64.`, {
+                        name: file.rawFile?.name,
+                        uid: file.uid,
+                        error: reader.error,
+                    });
+                };
+                reader.readAsDataURL(file.rawFile);
             });
+            return;
         }
-        else {
-            // Only workable for Auto Upload = false
-            if (!this.data.AutoUpload) {
-                // Compression for image file
-                const imageCompressionEnabled = this.data.Compression ? true : false;
-                //Check if Image Compression is enabled.
-                if (imageCompressionEnabled === true) {
-                    e.files.forEach((file) => {
-                        if (me.isValidUploadedFile(me, file)) {
-                            // Compress only if it is an image file
-                            if (file.rawFile && file.rawFile.type.includes("image")) {
-                                if (!file.validationErrors) {
-                                    const imgConfig = this.compressionConfigHandler(this.data.Compression);
-                                    if (file.size > imgConfig.FileSizeMinSizeByte) {
-                                        me.compressImage.compress(file.rawFile, imgConfig) //Pass in parameter to set the Compression Options
-                                            .pipe(take(1))
-                                            .subscribe(compressFile => {
-                                            this.ngZone.run(() => {
-                                                file.rawFile = compressFile;
-                                                file.size = compressFile.size;
-                                                // Push to component fileList
-                                                me.fileList.push(Object.assign({}, file));
-                                                const reader = new FileReader();
-                                                reader.readAsDataURL(file.rawFile);
-                                            });
-                                            console.log(`Compressed file size: ${(file.rawFile.size / 1024).toFixed(2)}KB`);
-                                        });
-                                    } // file size check
-                                } // validationErrors check
-                            } // file type check
-                        }
-                        else {
-                            e.preventDefault();
-                        }
-                    }); // loop each file
-                } // imagecompression check
-                // add to group scope
-                me.group['zupload_' + me.data.Value] = e.files;
-            }
+        // Only workable for Auto Upload = false
+        if (this.data?.AutoUpload) {
+            return;
+        }
+        // Compression for image file
+        const imageCompressionEnabled = Boolean(this.data?.Compression);
+        // Check if Image Compression is enabled.
+        if (imageCompressionEnabled) {
+            e.files.forEach((file) => {
+                if (!this.isValidUploadedFile(file)) {
+                    e.preventDefault();
+                    return;
+                }
+                // Compress only if it is an image file
+                if (!file?.rawFile?.type?.includes("image") || file.validationErrors) {
+                    return;
+                }
+                const imgConfig = this.compressionConfigHandler(this.data.Compression);
+                const minBytes = imgConfig?.FileSizeMinSizeByte ?? 0;
+                // Original behavior: only compress if file size > minBytes
+                if (file.size <= minBytes) {
+                    return;
+                }
+                this.compressImage
+                    .compress(file.rawFile, imgConfig) // Pass in parameter to set the Compression Options
+                    .pipe(take(1))
+                    .subscribe({
+                    next: (compressFile) => {
+                        this.ngZone.run(() => {
+                            file.rawFile = compressFile;
+                            file.size = compressFile.size;
+                            // Push to component fileList (kept as original intent)
+                            const fileData = { ...file };
+                            this.fileList.push(fileData);
+                            // Keep original: read to data URL (side effect)
+                            const reader = new FileReader();
+                            reader.readAsDataURL(file.rawFile);
+                        });
+                        console.info(`[ZuploadComponent] Image compressed successfully.`, {
+                            name: file?.rawFile?.name,
+                            newSizeKB: Number((file.rawFile.size / 1024).toFixed(2)),
+                        });
+                    },
+                    error: (err) => {
+                        // Preserve flow (do not block selection), but provide clearer diagnostic
+                        console.error(`[ZuploadComponent] Image compression failed. Upload will continue with original file.`, {
+                            name: file?.rawFile?.name,
+                            error: err,
+                        });
+                    },
+                });
+            });
         }
+        // Add to group scope (original behavior: store selected files)
+        this.group[`zupload_${this.data?.Value}`] = e.files;
     }
+    /**
+     * Clears UI-selected files and syncs group state.
+     * NOTE: Original behavior sets group value to fileList (not empty); preserved.
+     */
     clearFiles() {
+        if (!this.uploadComponent) {
+            console.warn(`[ZuploadComponent] clearFiles: uploadComponent is not ready.`);
+            return;
+        }
         this.uploadComponent.clearFiles();
-        this.group['zupload_' + this.data.Value] = this.fileList;
+        this.group[`zupload_${this.data?.Value}`] = this.fileList;
+        console.info(`[ZuploadComponent] Files cleared from UI.`, {
+            storedFileListCount: this.fileList.length,
+        });
     }
+    /**
+     * Format bytes into human-readable string.
+     *
+     * @param bytes Raw byte size
+     * @returns Formatted file size string (e.g. "12.5MB")
+     */
     formatFileSize(bytes) {
-        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
-        if (bytes === 0)
-            return '0 Byte';
+        const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+        if (!Number.isFinite(bytes) || bytes <= 0) {
+            return "0 Byte";
+        }
         const i = Math.floor(Math.log(bytes) / Math.log(1024));
-        return parseFloat((bytes / Math.pow(1024, i)).toFixed(2)) + sizes[i];
+        const value = bytes / Math.pow(1024, i);
+        // NOTE: Original output had no space between number and unit; preserved.
+        return `${Number.parseFloat(value.toFixed(2))}${sizes[i]}`;
     }
 }
 ZuploadComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ZuploadComponent, deps: [{ token: i1.ZComponentService }, { token: i2.AuthService }, { token: i2.CompressImageService }, { token: i2.ZCoreService }, { token: i0.NgZone }, { token: i2.SharePointService }, { token: i2.AlertService }], target: i0.ɵɵFactoryTarget.Component });
@@ -398,6 +589,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImpor
             args: [{ selector: "app-zupload", template: "<div [formGroup]=\"form\" class=\"zupload-container e1tag-style\" [style]=\"componentProperties.style.style\">\r\n  <kendo-upload\r\n    *ngIf=\"!data.SelectFileOnly\"\r\n    #uploadComponent\r\n    [id]=\"data.Value\"\r\n    [autoUpload]=\"isAutoUpload\"\r\n    [saveUrl]=\"uploadSaveUrl\"\r\n    [removeUrl]=\"uploadRemoveUrl\"\r\n    [restrictions]=\"restrictions\"\r\n    [multiple]=\"isMultiple\"\r\n    [chunkable]=\"chunkSettings\"\r\n    [showFileList]=\"showFileList\"\r\n    (select)=\"selectEventHandler($event)\"\r\n    (remove)=\"onRemove($event)\"\r\n    (success)=\"onSuccess($event)\"\r\n    (upload)=\"uploadEventHandler($event)\"\r\n    [style]=\"componentProperties.style.style1\"\r\n    class=\"e1tag-style1\">\r\n  </kendo-upload>\r\n\r\n  <kendo-fileselect\r\n    *ngIf=\"data.SelectFileOnly\"\r\n    #uploadComponent\r\n    [id]=\"data.Value\"\r\n    (select)=\"selectEventHandler($event)\"\r\n    (remove)=\"onRemove($event)\"\r\n    [formControlName]=\"data.Value\"\r\n    (valueChange)=\"onChange($event)\" \r\n    [restrictions]=\"restrictions\"\r\n    [style]=\"componentProperties.style.style1\"\r\n    class=\"e1tag-style1\">\r\n  </kendo-fileselect>\r\n\r\n  <div\r\n    *ngIf=\"imagePreviews.length\"\r\n    class=\"image-preview-container e1tag-style2\"\r\n    [style]=\"componentProperties.style.style2\">\r\n    <div\r\n      class=\"label-container e1tag-style3\"\r\n      [style]=\"componentProperties.style.style3\">\r\n      Image Preview:\r\n    </div>\r\n    <div\r\n      class=\"image-container e1tag-style4\"\r\n      [style]=\"componentProperties.style.style4\">\r\n      <img\r\n        *ngFor=\"let image of imagePreviews\"\r\n        [src]=\"image.src\"\r\n        alt=\"image preview\"\r\n        height=\"100\"\r\n        class=\"e1tag-style5\"\r\n        [style]=\"componentProperties.style.style5\" />\r\n    </div>\r\n  </div>\r\n</div>\r\n", styles: [".image-preview-container{border:1px solid rgba(0,0,0,.08)}.image-preview-container>.label-container{margin:5px}\n"] }]
         }], ctorParameters: function () { return [{ type: i1.ZComponentService }, { type: i2.AuthService }, { type: i2.CompressImageService }, { type: i2.ZCoreService }, { type: i0.NgZone }, { type: i2.SharePointService }, { type: i2.AlertService }]; }, propDecorators: { uploadComponent: [{
                 type: ViewChild,
-                args: ["uploadComponent"]
+                args: ["uploadComponent", { static: false }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zupload.component.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/zupload/zupload.component.ts","../../../../../projects/mmhglobal-dynamicform/src/lib/zupload/zupload.component.html"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,OAAO,EAAE,SAAS,EAAkB,SAAS,EAAE,MAAM,eAAe,CAAC;AAErE,6BAA6B;AAE7B,8BAA8B;AAC9B,8DAA8D;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGrD,2CAA2C;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAExE,OAAO,EAEO,gBAAgB,EAAyB,cAAc,EAA6C,gBAAgB,EACjI,MAAM,iBAAiB,CAAC;;;;;;;AAEzB,MAAM,OAAO,UAAU;CAItB;AASD,MAAM,OAAO,gBAAiB,SAAQ,cAAc;IAwClD,mBAAmB;IACnB,yBAAyB;IACzB,kBAAkB;IAClB,gDAAgD;IAChD,MAAM;IAEN,oBAAoB;IACpB,4BAA4B;IAC5B,qBAAqB;IACrB,6BAA6B;IAC7B,4DAA4D;IAC5D,4CAA4C;IAC5C,uBAAuB;IACvB,uBAAuB;IACvB,qBAAqB;IACrB,oCAAoC;IACpC,oCAAoC;IACpC,kBAAkB;IAClB,MAAM;IAEN,YACS,gBAAmC,EAClC,WAAwB,EACxB,aAAmC,EACnC,YAA0B,EAC1B,MAAc,EACd,iBAAoC,EACpC,YAA0B;QAElC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QARjB,qBAAgB,GAAhB,gBAAgB,CAAmB;QAClC,gBAAW,GAAX,WAAW,CAAa;QACxB,kBAAa,GAAb,aAAa,CAAsB;QACnC,iBAAY,GAAZ,YAAY,CAAc;QAC1B,WAAM,GAAN,MAAM,CAAQ;QACd,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,iBAAY,GAAZ,YAAY,CAAc;QAhEpC,wBAAmB,GAAW,IAAI,CAAC;QACnC,kBAAa,GAAG,+BAA+B,CAAC,CAAC,0CAA0C;QAC3F,oBAAe,GAAG,iCAAiC,CAAC,CAAC,0CAA0C;QAC/F,oBAAe,GAAG,0BAA0B,CAAC;QAC7C,gBAAW,GAAG,sBAAsB,CAAC,CAAC,aAAa;QACnD,iBAAY,GAAG,KAAK,CAAC;QACrB,eAAU,GAAG,KAAK,CAAC;QACnB,kBAAa,GAAU,EAAE,CAAC;QAC1B,QAAG,GAAa,EAAE,CAAC;QACnB,iBAAY,GAAG,IAAI,CAAC;QACpB,aAAQ,GAAU,EAAE,CAAC;QAEd,iBAAY,GAAqB;YACtC,WAAW,EAAE,CAAC;YACd,WAAW,EAAE,OAAO;YACpB,iBAAiB,EAAE;gBACjB,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,KAAK;gBACL,KAAK;gBACL,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,KAAK;gBACL,MAAM;gBACN,KAAK;aACN;SACF,CAAC;QAEK,kBAAa,GAAkB;YACpC,IAAI,EAAE,MAAM;YACZ,cAAc,EAAE,CAAC;SAClB,CAAC;QAgCA,IAAI,CAAC,mBAAmB,GAAI,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,mBAAmB,CAAC,CAAC;QACnH,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,aAAa,CAAC;QACnE,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,eAAe,CAAC;IACzE,CAAC;IAED,QAAQ;QACN,KAAK,CAAC,eAAe,EAAE,CAAC;QACxB,4FAA4F;QAG5F,iEAAiE;QACjE,qEAAqE;QAErE,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE;YAC9D,IAAI,CAAC,YAAY,CAAC,iBAAiB,GAAI,IAAI,CAAC,IAAI,CAAC,aAAqC,CAAC;SACxF;aACI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE;YACnE,IAAI,CAAC,YAAY,CAAC,iBAAiB,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;SAClH;QAED,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACzB,IAAI,CAAC,YAAY,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;SACvD;QAED,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACzB,IAAI,CAAC,YAAY,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;SACvD;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,KAAK,CAAC;QAElD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YAC1B,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;SAC3B;QAED,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YACtB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;SACtC;QAED,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,IAAI,sCAAsC,CAAC;IAC1H,CAAC;IAED,SAAS,CAAC,CAAe;QACvB,8FAA8F;QAC9F,mEAAmE;QACnE,aAAa;QACb,IAAI,CAAC,CAAC,SAAS,KAAK,QAAQ,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,cAAc,CAAC,EAAE;YAC5H,OAAO;SACR;QAED,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE;YACtD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;SACzC;QAED,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAe,CAAC;QACtC,MAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC;QACxH,IAAI,CAAC,CAAC,SAAS,KAAK,QAAQ,EAAE;YAC5B,sCAAsC;YACtC,iGAAiG;YACjG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC;YACnD,OAAO,IAAI,CAAC,kBAAkB,CAAC,CAAC;YAEhC,IAAI,iBAAiB,KAAK,CAAC,CAAC,EAAE;gBAC5B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC;aAC9D;iBAAM;gBACL,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC/C;SAEF;aAAM,IAAI,CAAC,CAAC,SAAS,KAAK,QAAQ,EAAE;YACnC,IAAI,iBAAiB,KAAK,CAAC,CAAC,EAAE;gBAC5B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;aACjE;SACF;QAED,gBAAgB,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACnG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;YACtB,IAAI,EAAE,mBAAmB;YACzB,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS;YAC3B,KAAK,EAAE,CAAC;YACR,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE;SACrB,CAAC,CAAC;IAC9B,CAAC;IAEO,wBAAwB,CAAC,SAAiC;QAChE,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,SAAS,CAAC,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;SACnF;QAED,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,SAAS,CAAC,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;SACnF;aACI;YACH,SAAS,CAAC,mBAAmB,GAAG,CAAC,CAAC;SACnC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,iBAAiB,CAAC,UAAkB;QAC1C,IAAI,oBAAoB,GAAW,CAAC,CAAC;QACrC,IAAI,UAAU,GAAW,CAAC,CAAC;QAC3B,IAAI,QAAQ,GAAG,GAAG,CAAC;QAEnB,mBAAmB;QACnB,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAEnD,gCAAgC;QAChC,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAChE,IAAI,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE;YAC/B,MAAM,WAAW,GAAG,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAEhF,IAAI,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,EAAE;gBAClC,oCAAoC;gBACpC,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;gBAClC,oBAAoB,GAAG,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAC/D;iBACI;gBACH,oBAAoB,GAAG,UAAU,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAC/D;YAED,QAAQ,QAAQ,CAAC,WAAW,EAAE,EAAE;gBAC9B,KAAK,GAAG;oBACN,UAAU,GAAG,oBAAoB,CAAA;oBACjC,MAAM;gBACR,KAAK,IAAI;oBACP,UAAU,GAAG,oBAAoB,GAAG,IAAI,CAAA;oBACxC,MAAM;gBACR,KAAK,IAAI;oBACP,UAAU,GAAG,oBAAoB,GAAG,OAAO,CAAA;oBAC3C,MAAM;gBACR,KAAK,IAAI;oBACP,UAAU,GAAG,oBAAoB,GAAG,UAAU,CAAA;oBAC9C,MAAM;aACT;SACF;aACI;YACH,sCAAsC;YACtC,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC,CAAC;SACxC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,kBAAkB,CAAC,CAAc;QAC/B,gBAAgB;QAChB,MAAM,EAAE,GAAG,IAAI,CAAC;QAEhB,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAc,EAAE,EAAE;YACjC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;gBACrC,CAAC,CAAC,cAAc,EAAE,CAAC;gBACnB,OAAO;aACR;iBACI;gBACH,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;oBACvD,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;wBAC1B,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;wBAChC,MAAM,CAAC,MAAM,GAAG,UAAU,EAAE;4BAC1B,IAAI,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE;gCAC9B,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;oCAC9B,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oCACtB,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAU,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;iCAChE;6BACF;wBACH,CAAC,CAAA;wBACD,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;qBACpC;iBACF;aACF;QACH,CAAC,CAAC,CAAC;QAEH,mCAAmC;QACnC,IAAI,UAAU,GAAmB,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAEzG,IAAI,CAAC,CAAC,UAAU,YAAY,cAAc,CAAC,EAAE;YAC3C,OAAO,CAAC,KAAK,CAAC,4BAA4B,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,eAAe,EAAE,UAAU,CAAC,CAAC;YACrG,UAAU,GAAG,IAAI,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;SAC5C;QAGD,oBAAoB;QACpB,IAAI,cAAc,GAAe,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC;QAE3G,2BAA2B;QAC3B,IAAI,cAAc,EAAE;YAClB,IAAI,cAAc,CAAC,GAAG,EAAE;gBACtB,MAAM,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC;gBACnF,UAAU,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;aACxC;YACD,UAAU,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,cAAc,CAAC,QAAQ,CAAC;YAChE,UAAU,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,GAAG,cAAc,CAAC,mBAAmB,CAAC;YACtF,UAAU,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,GAAG,cAAc,CAAC,kBAAkB,CAAC;SACrF;QACD,YAAY;QAEZ,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAEvC,CAAC,CAAC,IAAI,GAAG,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC;QAC9B,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IAC5F,CAAC;IAED,QAAQ,CAAC,CAAc;QACrB,oCAAoC;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CACnC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CACtC,CAAC;QAEF,IAAI,KAAK,IAAI,CAAC,EAAE;YACd,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC/B,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC;SAC1D;QAED,IAAI,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE;YACjC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;gBACtB,IAAI,EAAE,0BAA0B;gBAChC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC;gBACrC,IAAI,EAAE,CAAC;aACiB,CAAC,CAAC;SAC7B;aACI;YACH,MAAM,MAAM,GAAe,CAAC,CAAC,KAAK,CAAC,CAAC,CAAe,CAAC;YAEpD,mCAAmC;YACnC,CAAC,CAAC,IAAI,GAAG;gBACP,EAAE,EAAE,MAAM,CAAC,KAAK;aACjB,CAAC;YACF,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,CAC1B,eAAe,EACf,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAC3C,CAAC;YAEF,IAAI,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;gBAChC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAc,EAAE,EAAE;oBACjC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC1E,CAAC,CAAC,CAAC;aACJ;SACF;IACH,CAAC;IAED,QAAQ,CAAC,IAAgB;QACvB,IAAI,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE;YACjC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;gBACtB,IAAI,EAAE,0BAA0B;gBAChC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC;gBACrC,IAAI,EAAE,IAAI;aACc,CAAC,CAAC;SAC7B;IACH,CAAC;IAEO,mBAAmB,CAAC,EAAO,EAAE,IAAc;QACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;QACnC,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC;QAEvE,6CAA6C;QAC7C,IAAI,QAAQ,GAAG,EAAE,CAAC,YAAY,CAAC,WAAW,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,iBAAiB,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YACxG,IAAI,YAAY,GAAG,SAAS,CAAC;YAC7B,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,iBAAiB,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;gBAC9D,YAAY,GAAG,yCAAyC,EAAE,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;aACzG;iBACI,IAAI,QAAQ,GAAG,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE;gBAC/C,YAAY,GAAG,4BAA4B,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC;aAC9F;YAED,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,kBAAkB,EAAE,YAAY,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;YAEtE,OAAO,KAAK,CAAC;SACd;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB,CAAC,CAAc;QAC/B,MAAM,EAAE,GAAG,IAAI,CAAC;QAEhB,oBAAoB;QACpB,MAAM,cAAc,GAAe,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC;QAC7G,+CAA+C;QAC/C,IAAI,cAAc,IAAI,cAAc,CAAC,kBAAkB,IAAI,cAAc,CAAC,QAAQ,EAAE;YAClF,MAAM,mBAAmB,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,mBAAmB,CAAC;YACnF,IAAI,CAAC,aAAa,GAAG,mBAAmB,GAAG,oBAAoB,CAAC;SACjE;QACD,YAAY;QAEZ,IAAI,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE;YAC/B,uCAAuC;YACvC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,IAAc,EAAE,EAAE;gBACvC,IAAI,EAAE,CAAC,mBAAmB,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;oBACpC,IAAI,IAAI,CAAC,OAAO,EAAE;wBAChB,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;wBAChC,MAAM,CAAC,MAAM,GAAG,UAAU,EAAE;4BAC1B,0DAA0D;4BAC1D,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;4BACzC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;4BAEvC,6BAA6B;4BAC7B,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;4BAC3B,EAAE,CAAC,KAAK,CAAC,UAAU,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC;4BAEnD,IAAI,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE;gCAChC,yBAAyB;gCACzB,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;oCACpB,IAAI,EAAE,2BAA2B;oCACjC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC;oCACpC,IAAI,EAAE,EAAE,CAAC,QAAQ;iCACO,CAAC,CAAC;6BAC7B;wBACH,CAAC,CAAC;wBACF,MAAM,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;qBAC1C;iBACF;qBACI;oBACH,CAAC,CAAC,cAAc,EAAE,CAAC;iBACpB;YACH,CAAC,CAAC,CAAC;SACJ;aACI;YACH,wCAAwC;YACxC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;gBACzB,6BAA6B;gBAC7B,MAAM,uBAAuB,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;gBAErE,wCAAwC;gBACxC,IAAI,uBAAuB,KAAK,IAAI,EAAE;oBACpC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAc,EAAE,EAAE;wBACjC,IAAI,EAAE,CAAC,mBAAmB,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;4BACpC,uCAAuC;4BACvC,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;gCACvD,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;oCAC1B,MAAM,SAAS,GAAG,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;oCACvE,IAAI,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC,mBAAmB,EAAE;wCAC7C,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAE,kDAAkD;6CACnG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;6CACb,SAAS,CAAC,YAAY,CAAC,EAAE;4CACxB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE;gDACnB,IAAI,CAAC,OAAO,GAAG,YAAY,CAAC;gDAC5B,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC;gDAE9B,6BAA6B;gDAC7B,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;gDAE1C,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gDAChC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;4CACrC,CAAC,CAAC,CAAC;4CACH,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;wCAClF,CAAC,CAAC,CAAC;qCACN,CAAC,kBAAkB;iCACrB,CAAC,yBAAyB;6BAC5B,CAAC,kBAAkB;yBACrB;6BACI;4BACH,CAAC,CAAC,cAAc,EAAE,CAAC;yBACpB;oBACH,CAAC,CAAC,CAAA,CAAC,iBAAiB;iBACrB,CAAC,yBAAyB;gBAE3B,qBAAqB;gBACrB,EAAE,CAAC,KAAK,CAAC,UAAU,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;aAChD;SACF;IACH,CAAC;IAED,UAAU;QACR,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,CAAC;QAClC,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC;IAC3D,CAAC;IAEO,cAAc,CAAC,KAAa;QAClC,MAAM,KAAK,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAChD,IAAI,KAAK,KAAK,CAAC;YAAE,OAAO,QAAQ,CAAC;QACjC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;QACvD,OAAO,UAAU,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACvE,CAAC;;6GAvbU,gBAAgB;iGAAhB,gBAAgB,8LChC7B,u2DAuDA;2FDvBa,gBAAgB;kBAN5B,SAAS;+BACE,aAAa;gRAMO,eAAe;sBAA5C,SAAS;uBAAC,iBAAiB","sourcesContent":["/********** Angular **********/\r\nimport { Component, OnInit, NgZone, ViewChild } from \"@angular/core\";\r\n\r\n/********** Ionic **********/\r\n\r\n/********** Plugin **********/\r\n// import { environment } from \"src/environments/environment\";\r\nimport { take } from 'rxjs/operators';\r\nimport { HttpEventType } from '@angular/common/http';\r\nimport { FileInfo, SuccessEvent, RemoveEvent, UploadEvent, FileRestrictions, ChunkSettings, SelectEvent, UploadComponent } from \"@progress/kendo-angular-upload\";\r\n\r\n/********** Component & Service **********/\r\nimport { InputFieldBase } from \"../components/inputfieldbase.component\";\r\nimport { ZComponentService } from \"../services/zcomponent.service\";\r\nimport {\r\n  AuthService, ZCoreService, CompressImageService, AlertService,\r\n  ZComponent, ZComponentHelper, ZComponentOutputEvent, UploadMetaData, ImageCompressionConfig, SharePointService, AttachmentConfig, Attachment\r\n} from \"mmhglobal-zcore\";\r\n\r\nexport class MyFileInfo implements FileInfo {\r\n  name: string;\r\n  uid?: string;\r\n  myUid?: string;\r\n}\r\n\r\n\r\n@Component({\r\n  selector: \"app-zupload\",\r\n  templateUrl: \"./zupload.component.html\",\r\n  styleUrls: [\"./zupload.component.scss\"],\r\n})\r\n\r\nexport class ZuploadComponent extends InputFieldBase implements ZComponent, OnInit {\r\n  @ViewChild(\"uploadComponent\") uploadComponent: UploadComponent;\r\n\r\n  uploadAttachmentUrl: string = null;\r\n  uploadSaveUrl = \"/Attachment/Chunk_Upload_Save\"; // should represent an actual API endpoint\r\n  uploadRemoveUrl = \"/Attachment/Chunk_Upload_Remove\"; // should represent an actual API endpoint\r\n  downloadFileUrl = \"/Attachment/downloadFile\";\r\n  getImageUrl = \"/Attachment/getImage\"; // GET method\r\n  isAutoUpload = false;\r\n  isMultiple = false;\r\n  imagePreviews: any[] = [];\r\n  uid: string[] = [];\r\n  showFileList = true;\r\n  fileList: any[] = [];\r\n\r\n  public restrictions: FileRestrictions = {\r\n    minFileSize: 1,\r\n    maxFileSize: 4194304,\r\n    allowedExtensions: [\r\n      \"jpg\",\r\n      \"jpeg\",\r\n      \"png\",\r\n      \"bmp\",\r\n      \"pdf\",\r\n      \"txt\",\r\n      \"docx\",\r\n      \"doc\",\r\n      \"xlsx\",\r\n      \"xls\",\r\n      \"ppt\",\r\n      \"pptx\",\r\n      \"csv\",\r\n    ],\r\n  };\r\n\r\n  public chunkSettings: ChunkSettings = {\r\n    size: 102400,\r\n    maxAutoRetries: 3,\r\n  };\r\n\r\n  // zModelValue = [{\r\n  //   name: \"RXJS 01.png\",\r\n  //   size: 128753,\r\n  //   uid: \"c96e234d-af61-4587-adcc-3b400ddef884\"\r\n  // }];\r\n\r\n  // fieldElement = [{\r\n  //   Name: 'FileUploadList',\r\n  //   Type: 'zupload',\r\n  //   Value: 'FileUploadList',\r\n  //   SelectionOptions: ['jpg', 'jpeg', 'png', 'bmp', 'pdf'],\r\n  //   UploadMetaData: 'group.UploadMetaData',\r\n  //   AutoUpload: false,\r\n  //   AllowRemove: true,\r\n  //   Multiple: false,\r\n  //   OnSuccess: 'group.onSuccess()',\r\n  //   DivClass: \"col-md-12 col-md-6\",\r\n  //   Visible: true\r\n  // }];\r\n\r\n  constructor(\r\n    public componentService: ZComponentService,\r\n    private authService: AuthService,\r\n    private compressImage: CompressImageService,\r\n    private zcoreService: ZCoreService,\r\n    private ngZone: NgZone,\r\n    private sharePointService: SharePointService,\r\n    private alertService: AlertService\r\n  ) {\r\n    super(componentService);\r\n    this.uploadAttachmentUrl =  this.zcoreService.normalizeUrl(this.zcoreService.getEnvironment().uploadAttachmentUrl);\r\n    this.uploadSaveUrl = this.uploadAttachmentUrl + this.uploadSaveUrl;\r\n    this.uploadRemoveUrl = this.uploadAttachmentUrl + this.uploadRemoveUrl;\r\n  }\r\n\r\n  ngOnInit() {\r\n    super.setupInnerField();\r\n    // this.group['UploadMetaData'] = new UploadMetaData(null, '15', 'SO-No-1234', 'SaleOrder');\r\n\r\n\r\n    // this.uploadSaveUrl = uploadAttachmentUrl + this.uploadSaveUrl;\r\n    // this.uploadRemoveUrl = uploadAttachmentUrl + this.uploadRemoveUrl;\r\n\r\n    if (this.data.SelectOptions && !this.data.AllowedFileExtension) {\r\n      this.restrictions.allowedExtensions = (this.data.SelectOptions as unknown) as string[];\r\n    }\r\n    else if (!this.data.SelectOptions && this.data.AllowedFileExtension) {\r\n      this.restrictions.allowedExtensions = this.restrictions.allowedExtensions.concat(this.data.AllowedFileExtension);\r\n    }\r\n\r\n    if (this.data.MinFileSize) {\r\n      this.restrictions.minFileSize = this.data.MinFileSize;\r\n    }\r\n\r\n    if (this.data.MaxFileSize) {\r\n      this.restrictions.maxFileSize = this.data.MaxFileSize;\r\n    }\r\n\r\n    this.isAutoUpload = this.data.AutoUpload || false;\r\n\r\n    if (!this.data.AllowRemove) {\r\n      this.uploadRemoveUrl = \"\";\r\n    }\r\n\r\n    if (this.data.Multiple) {\r\n      this.isMultiple = this.data.Multiple;\r\n    }\r\n     \r\n    this.componentProperties.style.style6 = this.componentProperties.style.style6 || \"margin: 5px; border: 1px solid gray;\";\r\n  }\r\n\r\n  onSuccess(e: SuccessEvent): void {\r\n    // angular kendo upload didn't filter away Sent event for remove, so we have to handle it here\r\n    // upload progress not required for removal, thus it's also removed\r\n    // @ts-ignore\r\n    if (e.operation === \"remove\" && (e.response.type === HttpEventType.Sent || e.response.type === HttpEventType.UploadProgress)) {\r\n      return;\r\n    }\r\n\r\n    if (!Array.isArray(this.group.zModel[this.data.Value])) {\r\n      this.group.zModel[this.data.Value] = [];\r\n    }\r\n\r\n    const file = e.files[0] as MyFileInfo;\r\n    const existingFileIndex = this.group.zModel[this.data.Value].findIndex(f => f.name === file.name && f.uid === file.uid);\r\n    if (e.operation === \"upload\") {\r\n      // console.log('upload Success: ', e);\r\n      //sharepoint required to read data from fileUid and attachment able to get data from fileUid too.\r\n      file.myUid = e.response?.body?.fileUid ?? file.uid;\r\n      delete file['httpSubscription'];\r\n\r\n      if (existingFileIndex !== -1) {\r\n        this.group.zModel[this.data.Value][existingFileIndex] = file;\r\n      } else {\r\n        this.group.zModel[this.data.Value].push(file);\r\n      }\r\n\r\n    } else if (e.operation === \"remove\") {\r\n      if (existingFileIndex !== -1) {\r\n        this.group.zModel[this.data.Value].splice(existingFileIndex, 1);\r\n      }\r\n    }\r\n\r\n    ZComponentHelper.setComponentModelValue(this.data, this.group.zModel[this.data.Value], this.group);\r\n    this.group.subject.next({\r\n      type: \"zupload-onSuccess\",\r\n      target: this.data.OnSuccess,\r\n      event: e,\r\n      data: { value: e.files[0], field: this.data },\r\n    } as ZComponentOutputEvent);\r\n  }\r\n\r\n  private compressionConfigHandler(imgConfig: ImageCompressionConfig): ImageCompressionConfig {\r\n    if (imgConfig.FileSizeMaxSize) {\r\n      imgConfig.FileSizeMaxSizeByte = this.convertSizeToByte(imgConfig.FileSizeMaxSize);\r\n    }\r\n\r\n    if (imgConfig.FileSizeMinSize) {\r\n      imgConfig.FileSizeMinSizeByte = this.convertSizeToByte(imgConfig.FileSizeMinSize);\r\n    }\r\n    else {\r\n      imgConfig.FileSizeMinSizeByte = 0;\r\n    }\r\n\r\n    return imgConfig;\r\n  }\r\n\r\n  private convertSizeToByte(sizeString: string): number {\r\n    let _tempFileSizeMaxSize: number = 0;\r\n    let sizeByByte: number = 0;\r\n    let sizeType = 'b';\r\n\r\n    // remove all space\r\n    const _tempFileSize = sizeString.replace(/ /g, '');\r\n\r\n    // check last char is alphabetic\r\n    const lastChar = _tempFileSize.substr(_tempFileSize.length - 1);\r\n    if (isNaN(parseFloat(lastChar))) {\r\n      const secLastChar = _tempFileSize.substr(_tempFileSize.length - 2).slice(0, -1);\r\n\r\n      if (isNaN(parseFloat(secLastChar))) {\r\n        // check last 2nd char is alphabetic\r\n        sizeType = secLastChar + sizeType;\r\n        _tempFileSizeMaxSize = parseFloat(_tempFileSize.slice(0, -2));\r\n      }\r\n      else {\r\n        _tempFileSizeMaxSize = parseFloat(_tempFileSize.slice(0, -1));\r\n      }\r\n\r\n      switch (sizeType.toLowerCase()) {\r\n        case \"b\":\r\n          sizeByByte = _tempFileSizeMaxSize\r\n          break;\r\n        case \"kb\":\r\n          sizeByByte = _tempFileSizeMaxSize * 1024\r\n          break;\r\n        case \"mb\":\r\n          sizeByByte = _tempFileSizeMaxSize * 1048576\r\n          break;\r\n        case \"gb\":\r\n          sizeByByte = _tempFileSizeMaxSize * 1073741824\r\n          break;\r\n      }\r\n    }\r\n    else {\r\n      // default using bytes if no size type\r\n      sizeByByte = parseFloat(_tempFileSize);\r\n    }\r\n\r\n    return sizeByByte;\r\n  }\r\n\r\n  uploadEventHandler(e: UploadEvent) {\r\n    // Image Preview\r\n    const me = this;\r\n\r\n    e.files.forEach((file: FileInfo) => {\r\n      if (!me.isValidUploadedFile(me, file)) {\r\n        e.preventDefault();\r\n        return;\r\n      }\r\n      else {\r\n        if (file.rawFile && file.rawFile.type.includes(\"image\")) {\r\n          if (!file.validationErrors) {\r\n            const reader = new FileReader();\r\n            reader.onload = function (ev) {\r\n              if (me.data.EnableImagePreview) {\r\n                if (!me.uid.includes(file.uid)) {\r\n                  me.uid.push(file.uid);\r\n                  me.imagePreviews.push({ ...file, src: <string>reader.result });\r\n                }\r\n              }\r\n            }\r\n            reader.readAsDataURL(file.rawFile);\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    // Add metadata to the upload event\r\n    let additional: UploadMetaData = ZComponentHelper.getGroupEvalValue.call(this, this.data.UploadMetaData);\r\n\r\n    if (!(additional instanceof UploadMetaData)) {\r\n      console.error(\"UploadMetaData defined at \" + this.data.UploadMetaData + \" is invalid: \", additional);\r\n      additional = new UploadMetaData(null, \"0\");\r\n    }\r\n\r\n\r\n    //#region sharepoint\r\n    let attachmentInfo: Attachment = this.sharePointService.getAttachmentInfo(this.data[\"DownloadFileConfig\"]);\r\n\r\n    //add tagging into metadata\r\n    if (attachmentInfo) {\r\n      if (attachmentInfo.tag) {\r\n        const tag = this.sharePointService.generateTagging(this.group, attachmentInfo.tag);\r\n        additional[AttachmentConfig.tag] = tag;\r\n      }\r\n      additional[AttachmentConfig.siteName] = attachmentInfo.siteName;\r\n      additional[AttachmentConfig.documentLibraryName] = attachmentInfo.documentLibraryName;\r\n      additional[AttachmentConfig.isSaveToSharePoint] = attachmentInfo.isSaveToSharePoint;\r\n    }\r\n    //#endregion\r\n\r\n    const str = JSON.stringify(additional);\r\n\r\n    e.data = { additional: str, };\r\n    e.headers = e.headers.append(\"Authorization\", \"Bearer \" + this.authService.e1AccessToken);\r\n  }\r\n\r\n  onRemove(e: RemoveEvent): void {\r\n    // remove file from component memory\r\n    const index = this.fileList.findIndex(\r\n      (item) => item.uid === e.files[0].uid\r\n    );\r\n\r\n    if (index >= 0) {\r\n      this.fileList.splice(index, 1);\r\n      this.group['zupload_' + this.data.Value] = this.fileList;\r\n    }\r\n\r\n    if (this.data['FileRemovedEvent']) {\r\n      this.group.subject.next({\r\n        type: \"zupload-fileRemovedEvent\",\r\n        target: this.data['FileRemovedEvent'],\r\n        data: e\r\n      } as ZComponentOutputEvent);\r\n    }\r\n    else {\r\n      const myFile: MyFileInfo = e.files[0] as MyFileInfo;\r\n\r\n      // console.log('remove done: ', e);\r\n      e.data = {\r\n        id: myFile.myUid,\r\n      };\r\n      e.headers = e.headers.append(\r\n        \"Authorization\",\r\n        \"Bearer \" + this.authService.e1AccessToken\r\n      );\r\n\r\n      if (this.data.EnableImagePreview) {\r\n        e.files.forEach((file: FileInfo) => {\r\n          this.imagePreviews = this.imagePreviews.filter(f => f.uid !== file.uid);\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  onChange(file: FileInfo[]): void {\r\n    if (this.data['FileChangedEvent']) {\r\n      this.group.subject.next({\r\n        type: \"zupload-fileChangedEvent\",\r\n        target: this.data['FileChangedEvent'],\r\n        data: file\r\n      } as ZComponentOutputEvent);\r\n    }\r\n  }\r\n\r\n  private isValidUploadedFile(me: any, file: FileInfo): boolean {\r\n    const fileSize = file.rawFile.size;\r\n    const fileExtension = file.rawFile.name.split('.').pop().toLowerCase();\r\n\r\n    // Check if file size and extension are valid\r\n    if (fileSize > me.restrictions.maxFileSize || !me.restrictions.allowedExtensions.includes(fileExtension)) {\r\n      let errorMessage = 'Error: ';\r\n      if (!me.restrictions.allowedExtensions.includes(fileExtension)) {\r\n        errorMessage = `Invalid file type. Allowed types are: ${me.restrictions.allowedExtensions.join(', ')}.`;\r\n      }\r\n      else if (fileSize > me.restrictions.maxFileSize) {\r\n        errorMessage = `File size cannot exceeds ${me.formatFileSize(me.restrictions.maxFileSize)}.`;\r\n      }\r\n\r\n      me.alertService.showOkay('Failed to upload', errorMessage, ['col-4']);\r\n\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  selectEventHandler(e: SelectEvent) {\r\n    const me = this;\r\n\r\n    //#region sharepoint\r\n    const attachmentInfo: Attachment = this.sharePointService.getAttachmentInfo(this.data[\"DownloadFileConfig\"]);\r\n    // Change uploadSaveUrl if saving to SharePoint\r\n    if (attachmentInfo && attachmentInfo.isSaveToSharePoint && attachmentInfo.siteName) {\r\n      const attachmentSourceUrl = this.zcoreService.getEnvironment().attachmentSourceUrl;\r\n      this.uploadSaveUrl = attachmentSourceUrl + '/Chunk_Upload_Save';\r\n    }\r\n    //#endregion\r\n\r\n    if (this.data['SelectFileOnly']) {\r\n      // Append all files to component memory\r\n      e.files.forEach(async (file: FileInfo) => {\r\n        if (me.isValidUploadedFile(me, file)) {\r\n          if (file.rawFile) {\r\n            const reader = new FileReader();\r\n            reader.onload = function (ev) {\r\n              // Clone the data and also add the read file to the object\r\n              const fileData = Object.assign({}, file);\r\n              fileData['file'] = ev.target[\"result\"];\r\n\r\n              // Push to component fileList\r\n              me.fileList.push(fileData);\r\n              me.group['zupload_' + me.data.Value] = me.fileList;\r\n\r\n              if (me.data['FileSelectedEvent']) {\r\n                // Call the project event\r\n                me.group.subject.next({\r\n                  type: \"zupload-fileSelectedEvent\",\r\n                  target: me.data['FileSelectedEvent'],\r\n                  data: me.fileList\r\n                } as ZComponentOutputEvent);\r\n              }\r\n            };\r\n            await reader.readAsDataURL(file.rawFile);\r\n          }\r\n        }\r\n        else {\r\n          e.preventDefault();\r\n        }\r\n      });\r\n    }\r\n    else {\r\n      // Only workable for Auto Upload = false\r\n      if (!this.data.AutoUpload) {\r\n        // Compression for image file\r\n        const imageCompressionEnabled = this.data.Compression ? true : false;\r\n\r\n        //Check if Image Compression is enabled.\r\n        if (imageCompressionEnabled === true) {\r\n          e.files.forEach((file: FileInfo) => {\r\n            if (me.isValidUploadedFile(me, file)) {\r\n              // Compress only if it is an image file\r\n              if (file.rawFile && file.rawFile.type.includes(\"image\")) {\r\n                if (!file.validationErrors) {\r\n                  const imgConfig = this.compressionConfigHandler(this.data.Compression);\r\n                  if (file.size > imgConfig.FileSizeMinSizeByte) {\r\n                    me.compressImage.compress(file.rawFile, imgConfig)  //Pass in parameter to set the Compression Options\r\n                      .pipe(take(1))\r\n                      .subscribe(compressFile => {\r\n                        this.ngZone.run(() => {\r\n                          file.rawFile = compressFile;\r\n                          file.size = compressFile.size;\r\n\r\n                          // Push to component fileList\r\n                          me.fileList.push(Object.assign({}, file));\r\n\r\n                          const reader = new FileReader();\r\n                          reader.readAsDataURL(file.rawFile);\r\n                        });\r\n                        console.log(`Compressed file size: ${(file.rawFile.size / 1024).toFixed(2)}KB`);\r\n                      });\r\n                  } // file size check\r\n                } // validationErrors check\r\n              } // file type check\r\n            }\r\n            else {\r\n              e.preventDefault();\r\n            }\r\n          }) // loop each file\r\n        } // imagecompression check\r\n\r\n        // add to group scope\r\n        me.group['zupload_' + me.data.Value] = e.files;\r\n      }\r\n    }\r\n  }\r\n\r\n  clearFiles() {\r\n    this.uploadComponent.clearFiles();\r\n    this.group['zupload_' + this.data.Value] = this.fileList;\r\n  }\r\n\r\n  private formatFileSize(bytes: number): string {\r\n    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];\r\n    if (bytes === 0) return '0 Byte';\r\n    const i = Math.floor(Math.log(bytes) / Math.log(1024));\r\n    return parseFloat((bytes / Math.pow(1024, i)).toFixed(2)) + sizes[i];\r\n  }\r\n}\r\n","<div [formGroup]=\"form\" class=\"zupload-container e1tag-style\" [style]=\"componentProperties.style.style\">\r\n  <kendo-upload\r\n    *ngIf=\"!data.SelectFileOnly\"\r\n    #uploadComponent\r\n    [id]=\"data.Value\"\r\n    [autoUpload]=\"isAutoUpload\"\r\n    [saveUrl]=\"uploadSaveUrl\"\r\n    [removeUrl]=\"uploadRemoveUrl\"\r\n    [restrictions]=\"restrictions\"\r\n    [multiple]=\"isMultiple\"\r\n    [chunkable]=\"chunkSettings\"\r\n    [showFileList]=\"showFileList\"\r\n    (select)=\"selectEventHandler($event)\"\r\n    (remove)=\"onRemove($event)\"\r\n    (success)=\"onSuccess($event)\"\r\n    (upload)=\"uploadEventHandler($event)\"\r\n    [style]=\"componentProperties.style.style1\"\r\n    class=\"e1tag-style1\">\r\n  </kendo-upload>\r\n\r\n  <kendo-fileselect\r\n    *ngIf=\"data.SelectFileOnly\"\r\n    #uploadComponent\r\n    [id]=\"data.Value\"\r\n    (select)=\"selectEventHandler($event)\"\r\n    (remove)=\"onRemove($event)\"\r\n    [formControlName]=\"data.Value\"\r\n    (valueChange)=\"onChange($event)\" \r\n    [restrictions]=\"restrictions\"\r\n    [style]=\"componentProperties.style.style1\"\r\n    class=\"e1tag-style1\">\r\n  </kendo-fileselect>\r\n\r\n  <div\r\n    *ngIf=\"imagePreviews.length\"\r\n    class=\"image-preview-container e1tag-style2\"\r\n    [style]=\"componentProperties.style.style2\">\r\n    <div\r\n      class=\"label-container e1tag-style3\"\r\n      [style]=\"componentProperties.style.style3\">\r\n      Image Preview:\r\n    </div>\r\n    <div\r\n      class=\"image-container e1tag-style4\"\r\n      [style]=\"componentProperties.style.style4\">\r\n      <img\r\n        *ngFor=\"let image of imagePreviews\"\r\n        [src]=\"image.src\"\r\n        alt=\"image preview\"\r\n        height=\"100\"\r\n        class=\"e1tag-style5\"\r\n        [style]=\"componentProperties.style.style5\" />\r\n    </div>\r\n  </div>\r\n</div>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zupload.component.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/zupload/zupload.component.ts","../../../../../projects/mmhglobal-dynamicform/src/lib/zupload/zupload.component.html"],"names":[],"mappings":"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","sourcesContent":["/********** Angular **********/\r\nimport { Component, NgZone, OnInit, ViewChild } from \"@angular/core\";\r\n\r\n/********** Ionic **********/\r\n\r\n/********** Plugin **********/\r\n// import { environment } from \"src/environments/environment\";\r\nimport { HttpEventType } from \"@angular/common/http\";\r\nimport { take } from \"rxjs/operators\";\r\nimport {\r\n  ChunkSettings,\r\n  FileInfo,\r\n  FileRestrictions,\r\n  RemoveEvent,\r\n  SelectEvent,\r\n  SuccessEvent,\r\n  UploadComponent,\r\n  UploadEvent,\r\n} from \"@progress/kendo-angular-upload\";\r\n\r\n/********** Component & Service **********/\r\nimport { InputFieldBase } from \"../components/inputfieldbase.component\";\r\nimport { ZComponentService } from \"../services/zcomponent.service\";\r\nimport {\r\n  AlertService,\r\n  Attachment,\r\n  AttachmentConfig,\r\n  AuthService,\r\n  CompressImageService,\r\n  ImageCompressionConfig,\r\n  SharePointService,\r\n  UploadMetaData,\r\n  ZComponent,\r\n  ZComponentHelper,\r\n  ZComponentOutputEvent,\r\n  ZCoreService,\r\n} from \"mmhglobal-zcore\";\r\n \r\n/**\r\n * Kendo FileInfo + optional base64 payload (used by SelectFileOnly mode).\r\n * NOTE: Keeps runtime behavior the same; only improves type safety.\r\n */\r\ntype SelectedFileData = FileInfo & {\r\n  /**\r\n   * Base64 Data URL or ArrayBuffer from FileReader.\r\n   * Present only when SelectFileOnly reads file content into memory.\r\n   */\r\n  file?: string | ArrayBuffer | null;\r\n};\r\n\r\nexport class MyFileInfo implements FileInfo {\r\n  public name!: string;\r\n  public uid?: string;\r\n\r\n  /**\r\n   * Server or application-defined UID used for remove/download operations.\r\n   * (Set from API response fileUid when upload succeeds)\r\n   */\r\n  public myUid?: string;\r\n}\r\n\r\n@Component({\r\n  selector: \"app-zupload\",\r\n  templateUrl: \"./zupload.component.html\",\r\n  styleUrls: [\"./zupload.component.scss\"],\r\n})\r\nexport class ZuploadComponent extends InputFieldBase implements ZComponent, OnInit {\r\n  @ViewChild(\"uploadComponent\", { static: false })\r\n  public uploadComponent!: UploadComponent;\r\n  \r\n  private readonly defaultUploadSaveUrl: string;\r\n  private readonly defaultUploadRemoveUrl: string;\r\n\r\n  // NOTE: Naming: `uid` array actually stores preview UIDs. Consider renaming to `previewUids` in future (not changed to preserve API).\r\n  public uploadAttachmentUrl: string | null = null;\r\n  public uploadSaveUrl = \"/Attachment/Chunk_Upload_Save\"; // should represent an actual API endpoint\r\n  public uploadRemoveUrl = \"/Attachment/Chunk_Upload_Remove\"; // should represent an actual API endpoint\r\n  public readonly downloadFileUrl = \"/Attachment/downloadFile\";\r\n  public readonly getImageUrl = \"/Attachment/getImage\"; // GET method\r\n\r\n  public isAutoUpload = false;\r\n  public isMultiple = false;\r\n  public showFileList = true;\r\n\r\n  public imagePreviews: Array<Record<string, unknown>> = [];\r\n  public uid: string[] = [];\r\n  public fileList: SelectedFileData[] = [];\r\n\r\n  public restrictions: FileRestrictions = {\r\n    minFileSize: 1,\r\n    maxFileSize: 4194304,\r\n    allowedExtensions: [\r\n      \"jpg\",\r\n      \"jpeg\",\r\n      \"png\",\r\n      \"bmp\",\r\n      \"pdf\",\r\n      \"txt\",\r\n      \"docx\",\r\n      \"doc\",\r\n      \"xlsx\",\r\n      \"xls\",\r\n      \"ppt\",\r\n      \"pptx\",\r\n      \"csv\",\r\n    ],\r\n  };\r\n\r\n  public readonly chunkSettings: ChunkSettings = {\r\n    size: 102400,\r\n    maxAutoRetries: 3,\r\n  };\r\n\r\n  public constructor(\r\n    public readonly componentService: ZComponentService,\r\n    private readonly authService: AuthService,\r\n    private readonly compressImage: CompressImageService,\r\n    private readonly zcoreService: ZCoreService,\r\n    private readonly ngZone: NgZone,\r\n    private readonly sharePointService: SharePointService,\r\n    private readonly alertService: AlertService\r\n  ) {\r\n    super(componentService);\r\n\r\n    const env = this.zcoreService.getEnvironment();\r\n    const normalized = this.zcoreService.normalizeUrl(env?.uploadAttachmentUrl);\r\n\r\n    this.uploadAttachmentUrl = normalized ?? null;\r\n    if (this.uploadAttachmentUrl) {\r\n      this.uploadSaveUrl = this.uploadAttachmentUrl + this.uploadSaveUrl;\r\n      this.uploadRemoveUrl = this.uploadAttachmentUrl + this.uploadRemoveUrl;\r\n    } else {\r\n      // Safer logging: avoid silent null URLs that break uploads\r\n      // NOTE: This indicates a configuration issue.\r\n      console.warn(\r\n        `[ZuploadComponent] uploadAttachmentUrl is empty. Upload endpoints may be invalid.`,\r\n        { uploadAttachmentUrl: env?.uploadAttachmentUrl }\r\n      );\r\n    }\r\n\r\n    this.defaultUploadSaveUrl = this.uploadSaveUrl;\r\n    this.defaultUploadRemoveUrl = this.uploadRemoveUrl;\r\n  }\r\n\r\n  /**\r\n   * Angular lifecycle hook - initializes restrictions and upload behavior from field config.\r\n   */\r\n  public ngOnInit(): void {\r\n    super.setupInnerField();\r\n\r\n    // Allowed extensions:\r\n    // - If SelectOptions present and AllowedFileExtension not present, override\r\n    // - Else if AllowedFileExtension present and SelectOptions absent, append\r\n    // NOTE: Keep original behavior; it may allow duplicates, but prevents unexpected restriction loss.\r\n    if (this.data?.SelectOptions && !this.data?.AllowedFileExtension) {\r\n      this.restrictions.allowedExtensions = (this.data.SelectOptions as unknown) as string[];\r\n    } else if (!this.data?.SelectOptions && this.data?.AllowedFileExtension) {\r\n      this.restrictions.allowedExtensions = this.restrictions.allowedExtensions.concat(this.data.AllowedFileExtension);\r\n    }\r\n\r\n    if (typeof this.data?.MinFileSize === \"number\" && this.data.MinFileSize >= 0) {\r\n      this.restrictions.minFileSize = this.data.MinFileSize;\r\n    }\r\n\r\n    if (typeof this.data?.MaxFileSize === \"number\" && this.data.MaxFileSize >= 0) {\r\n      this.restrictions.maxFileSize = this.data.MaxFileSize;\r\n    }\r\n\r\n    this.isAutoUpload = Boolean(this.data?.AutoUpload);\r\n\r\n    // If remove is not allowed, Kendo upload expects empty URL to hide remove request.\r\n    if (this.data && this.data.AllowRemove === false) {\r\n      this.uploadRemoveUrl = \"\";\r\n    }\r\n\r\n    this.isMultiple = Boolean(this.data?.Multiple);\r\n\r\n    // Ensure style6 exists (legacy styling hook).\r\n    this.componentProperties.style.style6 =\r\n      this.componentProperties.style.style6 || \"margin: 5px; border: 1px solid gray;\";\r\n  }\r\n\r\n  /**\r\n   * Kendo Upload success callback for both upload and remove.\r\n   * Keeps zModel in sync and emits ZComponent output events.\r\n   */\r\n  public onSuccess(e: SuccessEvent): void {\r\n    // Angular Kendo Upload emits \"Sent\" and \"UploadProgress\" for remove; ignore them to avoid double-handling.\r\n    // @ts-ignore - Kendo types for response differ by runtime usage\r\n    const responseType: number | undefined = e?.response?.type;\r\n    if (\r\n      e?.operation === \"remove\" &&\r\n      (responseType === HttpEventType.Sent || responseType === HttpEventType.UploadProgress)\r\n    ) {\r\n      return;\r\n    }\r\n\r\n    const modelKey = this.data?.Value;\r\n    if (!modelKey) {\r\n      console.warn(`[ZuploadComponent] onSuccess skipped: missing data.Value.`, { event: e });\r\n      return;\r\n    }\r\n\r\n    if (!this.group?.zModel) {\r\n      console.warn(`[ZuploadComponent] onSuccess skipped: missing group.zModel.`, { event: e });\r\n      return;\r\n    }\r\n\r\n    if (!Array.isArray(this.group.zModel[modelKey])) {\r\n      this.group.zModel[modelKey] = [];\r\n    }\r\n\r\n    const file = (e?.files?.[0] as MyFileInfo | undefined) ?? undefined;\r\n    if (!file) {\r\n      console.warn(`[ZuploadComponent] onSuccess: no file found in event.`, { event: e });\r\n      return;\r\n    }\r\n\r\n    const existingFileIndex = this.group.zModel[modelKey].findIndex(\r\n      (f: MyFileInfo) => f?.name === file.name && f?.uid === file.uid\r\n    );\r\n\r\n    if (e.operation === \"upload\") {\r\n      // SharePoint and Attachment use fileUid (server) for later operations.\r\n      // Prefer fileUid if provided; fallback to file.uid\r\n      // @ts-ignore - body shape is runtime-dependent\r\n      file.myUid = e?.response?.body?.fileUid ?? file.uid;\r\n\r\n      // Clean up internal subscription data to avoid circular structures\r\n      // NOTE: This relies on Kendo attaching internal fields; safe delete.\r\n      delete (file as unknown as Record<string, unknown>)[\"httpSubscription\"];\r\n\r\n      if (existingFileIndex !== -1) {\r\n        this.group.zModel[modelKey][existingFileIndex] = file;\r\n      } else {\r\n        this.group.zModel[modelKey].push(file);\r\n      }\r\n\r\n      console.info(`[ZuploadComponent] Upload succeeded.`, {\r\n        name: file.name,\r\n        uid: file.uid,\r\n        myUid: file.myUid,\r\n      });\r\n    } else if (e.operation === \"remove\") {\r\n      if (existingFileIndex !== -1) {\r\n        this.group.zModel[modelKey].splice(existingFileIndex, 1);\r\n      }\r\n\r\n      console.info(`[ZuploadComponent] Remove succeeded.`, {\r\n        name: file.name,\r\n        uid: file.uid,\r\n        myUid: file.myUid,\r\n      });\r\n    } else {\r\n      // Unknown operation, preserve behavior but log for diagnostics.\r\n      console.debug(`[ZuploadComponent] onSuccess received unsupported operation.`, { operation: e.operation, event: e });\r\n    }\r\n\r\n    ZComponentHelper.setComponentModelValue(this.data, this.group.zModel[modelKey], this.group);\r\n\r\n    this.group.subject?.next({\r\n      type: \"zupload-onSuccess\",\r\n      target: this.data?.OnSuccess,\r\n      event: e,\r\n      data: { value: file, field: this.data },\r\n    } as ZComponentOutputEvent);\r\n  }\r\n\r\n  /**\r\n   * Normalize and enrich image compression config with byte-based thresholds.\r\n   */\r\n  private compressionConfigHandler(imgConfig: ImageCompressionConfig): ImageCompressionConfig {\r\n    if (!imgConfig) {\r\n      // NOTE: keep function safe for unexpected null; returns as-is\r\n      return imgConfig;\r\n    }\r\n\r\n    if (imgConfig.FileSizeMaxSize) {\r\n      imgConfig.FileSizeMaxSizeByte = this.convertSizeToByte(imgConfig.FileSizeMaxSize);\r\n    }\r\n\r\n    if (imgConfig.FileSizeMinSize) {\r\n      imgConfig.FileSizeMinSizeByte = this.convertSizeToByte(imgConfig.FileSizeMinSize);\r\n    } else {\r\n      imgConfig.FileSizeMinSizeByte = 0;\r\n    }\r\n\r\n    return imgConfig;\r\n  }\r\n\r\n  /**\r\n   * Convert string size values like \"10KB\", \"2 MB\", \"1gb\", \"1024\" into bytes.\r\n   * If unit is omitted, bytes are assumed.\r\n   *\r\n   * @param sizeString Human readable size string.\r\n   * @returns Size in bytes. Returns 0 if parsing fails.\r\n   */\r\n  private convertSizeToByte(sizeString: string): number {\r\n    if (!sizeString || typeof sizeString !== \"string\") {\r\n      return 0;\r\n    }\r\n\r\n    // Remove all spaces\r\n    const raw = sizeString.replace(/ /g, \"\").trim();\r\n    if (!raw) {\r\n      return 0;\r\n    }\r\n\r\n    let parsedValue = 0;\r\n    let sizeByByte = 0;\r\n    let sizeType = \"b\";\r\n\r\n    // Check last char is alphabetic\r\n    const lastChar = raw.substring(raw.length - 1);\r\n    const lastCharIsNumber = !Number.isNaN(Number.parseFloat(lastChar));\r\n\r\n    if (!lastCharIsNumber) {\r\n      const secondLastChar = raw.substring(raw.length - 2).slice(0, -1);\r\n      const secondLastIsNumber = !Number.isNaN(Number.parseFloat(secondLastChar));\r\n\r\n      if (!secondLastIsNumber) {\r\n        // Last 2nd char is also alphabetic (e.g. \"MB\", \"GB\")\r\n        sizeType = `${secondLastChar}${sizeType}`;\r\n        parsedValue = Number.parseFloat(raw.slice(0, -2));\r\n      } else {\r\n        parsedValue = Number.parseFloat(raw.slice(0, -1));\r\n      }\r\n\r\n      // If parsing failed, return 0 (SonarQube safe behavior)\r\n      if (Number.isNaN(parsedValue) || parsedValue < 0) {\r\n        console.warn(`[ZuploadComponent] convertSizeToByte: invalid size value.`, { sizeString });\r\n        return 0;\r\n      }\r\n\r\n      switch (sizeType.toLowerCase()) {\r\n        case \"b\":\r\n          sizeByByte = parsedValue;\r\n          break;\r\n        case \"kb\":\r\n          sizeByByte = parsedValue * 1024;\r\n          break;\r\n        case \"mb\":\r\n          sizeByByte = parsedValue * 1_048_576;\r\n          break;\r\n        case \"gb\":\r\n          sizeByByte = parsedValue * 1_073_741_824;\r\n          break;\r\n        default:\r\n          // Unknown unit => treat as bytes for backward compatibility\r\n          console.warn(`[ZuploadComponent] convertSizeToByte: unknown unit, defaulting to bytes.`, {\r\n            sizeString,\r\n            unit: sizeType,\r\n          });\r\n          sizeByByte = parsedValue;\r\n          break;\r\n      }\r\n    } else {\r\n      // Default using bytes if no size type\r\n      const n = Number.parseFloat(raw);\r\n      if (Number.isNaN(n) || n < 0) {\r\n        console.warn(`[ZuploadComponent] convertSizeToByte: invalid numeric bytes value.`, { sizeString });\r\n        return 0;\r\n      }\r\n      sizeByByte = n;\r\n    }\r\n\r\n    return sizeByByte;\r\n  }\r\n\r\n  /**\r\n   * Kendo Upload upload event: validates files, builds image previews, injects metadata and auth header.\r\n   */\r\n  public uploadEventHandler(e: UploadEvent): void {\r\n    if (!e?.files?.length) {\r\n      console.warn(`[ZuploadComponent] uploadEventHandler: no files in UploadEvent.`);\r\n      return;\r\n    }\r\n\r\n    // Image Preview\r\n    e.files.forEach((file: FileInfo) => {\r\n      if (!this.isValidUploadedFile(file)) {\r\n        e.preventDefault();\r\n        return;\r\n      }\r\n\r\n      if (file?.rawFile?.type?.includes(\"image\") && !file.validationErrors) {\r\n        const reader = new FileReader();\r\n        reader.onload = () => {\r\n          if (this.data?.EnableImagePreview) {\r\n            if (!this.uid.includes(file.uid)) {\r\n              this.uid.push(file.uid);\r\n              this.imagePreviews.push({ ...file, src: reader.result as string });\r\n            }\r\n          }\r\n        };\r\n        reader.readAsDataURL(file.rawFile);\r\n      }\r\n    });\r\n\r\n    // Add metadata to the upload event\r\n    let additional: UploadMetaData = ZComponentHelper.getGroupEvalValue.call(this, this.data?.UploadMetaData);\r\n\r\n    if (!(additional instanceof UploadMetaData)) {\r\n      console.warn(\r\n        `[ZuploadComponent] Invalid UploadMetaData at \"${this.data?.UploadMetaData}\". Fallback to default metadata.`,\r\n        additional\r\n      );\r\n      additional = new UploadMetaData(null, \"0\");\r\n    }\r\n\r\n    //#region sharepoint\r\n    const attachmentInfo: Attachment | null = this.sharePointService.getAttachmentInfo(this.data?.[\"DownloadFileConfig\"]);\r\n\r\n    // Add tagging into metadata\r\n    if (attachmentInfo) {\r\n      if (attachmentInfo.tag) {\r\n        const tag = this.sharePointService.generateTagging(this.group, attachmentInfo.tag);\r\n        (additional as unknown as Record<string, unknown>)[AttachmentConfig.tag] = tag;\r\n      }\r\n\r\n      (additional as unknown as Record<string, unknown>)[AttachmentConfig.siteName] = attachmentInfo.siteName;\r\n      (additional as unknown as Record<string, unknown>)[AttachmentConfig.documentLibraryName] = attachmentInfo.documentLibraryName;\r\n      (additional as unknown as Record<string, unknown>)[AttachmentConfig.isSaveToSharePoint] = attachmentInfo.isSaveToSharePoint;\r\n    }\r\n    //#endregion\r\n  \r\n    (additional as unknown as Record<string, unknown>)[AttachmentConfig.projectCode] = this.data?.ProjectCode;\r\n    (additional as unknown as Record<string, unknown>)[AttachmentConfig.moduleCode] = this.data?.ModuleCode;\r\n    \r\n    const payload = JSON.stringify(additional);\r\n    e.data = { additional: payload };\r\n\r\n    // NOTE: Potentially unsafe: assumes token is always present. Keep behavior but add clearer logging.\r\n    const token = this.authService?.e1AccessToken;\r\n    if (!token) {\r\n      console.warn(`[ZuploadComponent] Missing e1AccessToken. Upload may fail due to authorization.`);\r\n    }\r\n    e.headers = e.headers.append(\"Authorization\", `Bearer ${token ?? \"\"}`);\r\n  }\r\n\r\n  /**\r\n   * Kendo Upload remove event: updates component memory, fires project event if defined,\r\n   * otherwise attaches required payload and authorization headers.\r\n   */\r\n  public onRemove(e: RemoveEvent): void {\r\n    const file = e?.files?.[0];\r\n    if (!file) {\r\n      console.warn(`[ZuploadComponent] onRemove: no file found in RemoveEvent.`, { event: e });\r\n      return;\r\n    }\r\n\r\n    // Remove file from component memory (for SelectFileOnly flow)\r\n    const index = this.fileList.findIndex((item) => item.uid === file.uid);\r\n    if (index >= 0) {\r\n      this.fileList.splice(index, 1);\r\n      this.group[`zupload_${this.data?.Value}`] = this.fileList;\r\n    }\r\n\r\n    const removedEvent = this.data?.[\"FileRemovedEvent\"];\r\n    if (removedEvent) {\r\n      this.group.subject?.next({\r\n        type: \"zupload-fileRemovedEvent\",\r\n        target: removedEvent,\r\n        data: e,\r\n      } as ZComponentOutputEvent);\r\n      return;\r\n    }\r\n\r\n    const myFile = file as MyFileInfo;\r\n\r\n    // Attach remove payload\r\n    e.data = { id: myFile.myUid };\r\n\r\n    const token = this.authService?.e1AccessToken;\r\n    if (!token) {\r\n      console.warn(`[ZuploadComponent] Missing e1AccessToken. Remove may fail due to authorization.`);\r\n    }\r\n\r\n    e.headers = e.headers.append(\"Authorization\", `Bearer ${token ?? \"\"}`);\r\n\r\n    // Remove preview if enabled\r\n    if (this.data?.EnableImagePreview) {\r\n      e.files.forEach((f: FileInfo) => {\r\n        this.imagePreviews = this.imagePreviews.filter((p) => p?.[\"uid\"] !== f.uid);\r\n      });\r\n    }\r\n\r\n    console.info(`[ZuploadComponent] Remove requested.`, { name: myFile.name, uid: myFile.uid, myUid: myFile.myUid });\r\n  }\r\n\r\n  /**\r\n   * Kendo Upload change event handler. Emits project event if configured.\r\n   */\r\n  public onChange(files: FileInfo[]): void {\r\n    const changedEvent = this.data?.[\"FileChangedEvent\"];\r\n    if (!changedEvent) {\r\n      return;\r\n    }\r\n\r\n    this.group.subject?.next({\r\n      type: \"zupload-fileChangedEvent\",\r\n      target: changedEvent,\r\n      data: files,\r\n    } as ZComponentOutputEvent);\r\n  }\r\n\r\n  /**\r\n   * Validate a selected/uploaded file against configured restrictions (size + extension).\r\n   *\r\n   * @param file Kendo FileInfo\r\n   * @returns true if file passes restrictions, otherwise false (and shows alert).\r\n   */\r\n  private isValidUploadedFile(file: FileInfo): boolean {\r\n    const rawFile = file?.rawFile;\r\n    if (!rawFile) {\r\n      // NOTE: Kendo can provide FileInfo without rawFile in some events. Preserve behavior: treat as invalid.\r\n      console.warn(`[ZuploadComponent] File validation failed: rawFile is missing.`, { file });\r\n      this.alertService.showOkay(\"Failed to upload\", \"File is not available for upload.\", [\"col-4\"]);\r\n      return false;\r\n    }\r\n\r\n    const fileSize = rawFile.size ?? 0;\r\n\r\n    // Keep original behavior: uses last segment after dot.\r\n    // NOTE: Potentially unsafe for files without extension; will result in empty extension.\r\n    const fileExtension = (rawFile.name?.split(\".\").pop() ?? \"\").toLowerCase();\r\n\r\n    const max = this.restrictions?.maxFileSize ?? 0;\r\n    const allowed = this.restrictions?.allowedExtensions ?? [];\r\n\r\n    const isExtensionAllowed = allowed.includes(fileExtension);\r\n    const isSizeAllowed = fileSize <= max;\r\n\r\n    if (!isExtensionAllowed || !isSizeAllowed) {\r\n      let errorMessage = \"Error:\";\r\n      if (!isExtensionAllowed) {\r\n        errorMessage = `Invalid file type \"${fileExtension || \"unknown\"}\". Allowed types: ${allowed.join(\", \")}.`;\r\n      } else if (!isSizeAllowed) {\r\n        errorMessage = `File size cannot exceed ${this.formatFileSize(max)}.`;\r\n      }\r\n\r\n      console.warn(`[ZuploadComponent] File rejected by restrictions.`, {\r\n        name: rawFile.name,\r\n        size: fileSize,\r\n        extension: fileExtension,\r\n        maxAllowedBytes: max,\r\n        allowedExtensions: allowed,\r\n      });\r\n\r\n      this.alertService.showOkay(\"Failed to upload\", errorMessage, [\"col-4\"]);\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Kendo Upload select event handler:\r\n   * - Handles SharePoint endpoint switching\r\n   * - Supports SelectFileOnly mode (read file content into memory and emit event)\r\n   * - Supports image compression when AutoUpload is false\r\n   */\r\n  public selectEventHandler(e: SelectEvent): void {\r\n    if (!e?.files?.length) {\r\n      console.warn(`[ZuploadComponent] selectEventHandler: no files in SelectEvent.`);\r\n      return;\r\n    }\r\n    // Reset to default every selection to avoid SharePoint URL \"sticking\" permanently.\r\n    this.uploadSaveUrl = this.defaultUploadSaveUrl;\r\n    this.uploadRemoveUrl = this.defaultUploadRemoveUrl;\r\n\r\n    //#region sharepoint\r\n    const attachmentInfo: Attachment | null = this.sharePointService.getAttachmentInfo(this.data?.[\"DownloadFileConfig\"]);\r\n    // Change uploadSaveUrl if saving to SharePoint\r\n    if (attachmentInfo?.isSaveToSharePoint && attachmentInfo.siteName) {\r\n      const attachmentSourceUrl = this.zcoreService.getEnvironment()?.attachmentSourceUrl;\r\n      if (attachmentSourceUrl) {\r\n        this.uploadSaveUrl = `${attachmentSourceUrl}/Chunk_Upload_Save`;\r\n        console.info(`[ZuploadComponent] Upload endpoint switched to SharePoint mode.`, { uploadSaveUrl: this.uploadSaveUrl });\r\n      } else {\r\n        console.warn(`[ZuploadComponent] attachmentSourceUrl is missing. Cannot switch to SharePoint upload endpoint.`);\r\n      }\r\n    }\r\n    //#endregion\r\n\r\n    if (this.data?.[\"SelectFileOnly\"]) {\r\n      // Append all files to component memory\r\n      e.files.forEach((file: FileInfo) => {\r\n        if (!this.isValidUploadedFile(file)) {\r\n          e.preventDefault();\r\n          return;\r\n        }\r\n\r\n        if (!file.rawFile) {\r\n          e.preventDefault();\r\n          return;\r\n        }\r\n\r\n        const reader = new FileReader();\r\n        reader.onload = (ev: ProgressEvent<FileReader>) => {\r\n          // Clone the data and also add the read file to the object\r\n          const fileData: SelectedFileData = {\r\n            ...file,\r\n            file: ev?.target?.result ?? null,\r\n          };\r\n          fileData[\"file\"] = ev?.target?.result;\r\n\r\n          // Push to component fileList\r\n          this.fileList.push(fileData);\r\n          this.group[`zupload_${this.data?.Value}`] = this.fileList;\r\n\r\n          const selectedEvent = this.data?.[\"FileSelectedEvent\"];\r\n          if (selectedEvent) {\r\n            this.group.subject?.next({\r\n              type: \"zupload-fileSelectedEvent\",\r\n              target: selectedEvent,\r\n              data: this.fileList,\r\n            } as ZComponentOutputEvent);\r\n          }\r\n        };\r\n\r\n        reader.onerror = () => {\r\n          console.warn(`[ZuploadComponent] Failed to read file as base64.`, {\r\n            name: file.rawFile?.name,\r\n            uid: file.uid,\r\n            error: reader.error,\r\n          });\r\n        };\r\n\r\n        reader.readAsDataURL(file.rawFile);\r\n      });\r\n\r\n      return;\r\n    }\r\n\r\n    // Only workable for Auto Upload = false\r\n    if (this.data?.AutoUpload) {\r\n      return;\r\n    }\r\n\r\n    // Compression for image file\r\n    const imageCompressionEnabled = Boolean(this.data?.Compression);\r\n\r\n    // Check if Image Compression is enabled.\r\n    if (imageCompressionEnabled) {\r\n      e.files.forEach((file: FileInfo) => {\r\n        if (!this.isValidUploadedFile(file)) {\r\n          e.preventDefault();\r\n          return;\r\n        }\r\n\r\n        // Compress only if it is an image file\r\n        if (!file?.rawFile?.type?.includes(\"image\") || file.validationErrors) {\r\n          return;\r\n        }\r\n\r\n        const imgConfig = this.compressionConfigHandler(this.data.Compression);\r\n        const minBytes = imgConfig?.FileSizeMinSizeByte ?? 0;\r\n\r\n        // Original behavior: only compress if file size > minBytes\r\n        if (file.size <= minBytes) {\r\n          return;\r\n        }\r\n\r\n        this.compressImage\r\n          .compress(file.rawFile, imgConfig) // Pass in parameter to set the Compression Options\r\n          .pipe(take(1))\r\n          .subscribe({\r\n            next: (compressFile) => {\r\n              this.ngZone.run(() => {\r\n                file.rawFile = compressFile;\r\n                file.size = compressFile.size;\r\n\r\n                // Push to component fileList (kept as original intent)\r\n                const fileData: SelectedFileData = { ...file };\r\n                this.fileList.push(fileData);\r\n\r\n                // Keep original: read to data URL (side effect)\r\n                const reader = new FileReader();\r\n                reader.readAsDataURL(file.rawFile);\r\n              });\r\n\r\n              console.info(`[ZuploadComponent] Image compressed successfully.`, {\r\n                name: file?.rawFile?.name,\r\n                newSizeKB: Number((file.rawFile.size / 1024).toFixed(2)),\r\n              });\r\n            },\r\n            error: (err) => {\r\n              // Preserve flow (do not block selection), but provide clearer diagnostic\r\n              console.error(`[ZuploadComponent] Image compression failed. Upload will continue with original file.`, {\r\n                name: file?.rawFile?.name,\r\n                error: err,\r\n              });\r\n            },\r\n          });\r\n      });\r\n    }\r\n\r\n    // Add to group scope (original behavior: store selected files)\r\n    this.group[`zupload_${this.data?.Value}`] = e.files;\r\n  }\r\n\r\n  /**\r\n   * Clears UI-selected files and syncs group state.\r\n   * NOTE: Original behavior sets group value to fileList (not empty); preserved.\r\n   */\r\n  public clearFiles(): void {\r\n    if (!this.uploadComponent) {\r\n      console.warn(`[ZuploadComponent] clearFiles: uploadComponent is not ready.`);\r\n      return;\r\n    }\r\n\r\n    this.uploadComponent.clearFiles();\r\n    this.group[`zupload_${this.data?.Value}`] = this.fileList;\r\n\r\n    console.info(`[ZuploadComponent] Files cleared from UI.`, {\r\n      storedFileListCount: this.fileList.length,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Format bytes into human-readable string.\r\n   *\r\n   * @param bytes Raw byte size\r\n   * @returns Formatted file size string (e.g. \"12.5MB\")\r\n   */\r\n  private formatFileSize(bytes: number): string {\r\n    const sizes = [\"Bytes\", \"KB\", \"MB\", \"GB\", \"TB\"];\r\n    if (!Number.isFinite(bytes) || bytes <= 0) {\r\n      return \"0 Byte\";\r\n    }\r\n\r\n    const i = Math.floor(Math.log(bytes) / Math.log(1024));\r\n    const value = bytes / Math.pow(1024, i);\r\n\r\n    // NOTE: Original output had no space between number and unit; preserved.\r\n    return `${Number.parseFloat(value.toFixed(2))}${sizes[i]}`;\r\n  }\r\n}\r\n","<div [formGroup]=\"form\" class=\"zupload-container e1tag-style\" [style]=\"componentProperties.style.style\">\r\n  <kendo-upload\r\n    *ngIf=\"!data.SelectFileOnly\"\r\n    #uploadComponent\r\n    [id]=\"data.Value\"\r\n    [autoUpload]=\"isAutoUpload\"\r\n    [saveUrl]=\"uploadSaveUrl\"\r\n    [removeUrl]=\"uploadRemoveUrl\"\r\n    [restrictions]=\"restrictions\"\r\n    [multiple]=\"isMultiple\"\r\n    [chunkable]=\"chunkSettings\"\r\n    [showFileList]=\"showFileList\"\r\n    (select)=\"selectEventHandler($event)\"\r\n    (remove)=\"onRemove($event)\"\r\n    (success)=\"onSuccess($event)\"\r\n    (upload)=\"uploadEventHandler($event)\"\r\n    [style]=\"componentProperties.style.style1\"\r\n    class=\"e1tag-style1\">\r\n  </kendo-upload>\r\n\r\n  <kendo-fileselect\r\n    *ngIf=\"data.SelectFileOnly\"\r\n    #uploadComponent\r\n    [id]=\"data.Value\"\r\n    (select)=\"selectEventHandler($event)\"\r\n    (remove)=\"onRemove($event)\"\r\n    [formControlName]=\"data.Value\"\r\n    (valueChange)=\"onChange($event)\" \r\n    [restrictions]=\"restrictions\"\r\n    [style]=\"componentProperties.style.style1\"\r\n    class=\"e1tag-style1\">\r\n  </kendo-fileselect>\r\n\r\n  <div\r\n    *ngIf=\"imagePreviews.length\"\r\n    class=\"image-preview-container e1tag-style2\"\r\n    [style]=\"componentProperties.style.style2\">\r\n    <div\r\n      class=\"label-container e1tag-style3\"\r\n      [style]=\"componentProperties.style.style3\">\r\n      Image Preview:\r\n    </div>\r\n    <div\r\n      class=\"image-container e1tag-style4\"\r\n      [style]=\"componentProperties.style.style4\">\r\n      <img\r\n        *ngFor=\"let image of imagePreviews\"\r\n        [src]=\"image.src\"\r\n        alt=\"image preview\"\r\n        height=\"100\"\r\n        class=\"e1tag-style5\"\r\n        [style]=\"componentProperties.style.style5\" />\r\n    </div>\r\n  </div>\r\n</div>\r\n"]}