@tft/crispr-forms 13.0.2 → 13.0.5

package/esm2020/lib/material/image-upload-field/image-upload-field.component.mjs

@@ -29,7 +29,6 @@ import * as i10 from "@angular/common";
 import * as i11 from "../file-upload/file-dropzone.directive";
 const ImageUploadFieldMixin = crisprControlMixin(CrisprFieldComponent);
 export class ImageUploadFieldComponent extends ImageUploadFieldMixin {
-    // ngControl: NgControl = null;
     constructor(ngControl, domSanitizer, cdr) {
         super();
         this.ngControl = ngControl;
@@ -50,24 +49,28 @@ export class ImageUploadFieldComponent extends ImageUploadFieldMixin {
             minCompressionThresholdMb: .6,
             useWebWorker: true,
         };
+        /**
+         * The url mapped from initial input value, consumers can us mapInputValueToUrl in config to transform their input value into a src url for the image element
+         */
+        // inputValueUrl: string | undefined;
         this.inputImageFileSubject = new Subject();
         this.inputImageFile$ = this.inputImageFileSubject.asObservable().pipe(shareReplay(1));
         this.compressedFile$ = this.inputImageFile$.pipe(switchMap(async (file) => {
-            if (!file)
+            if (!file || !(file instanceof File))
                 return null;
-            if (typeof file === 'string')
-                return file;
             const { compressImage, targetCompressedImageFileSizeMb, minCompressionThresholdMb, maxWidthOrHeight, useWebWorker } = this.config;
             const fileSizeMb = convertBytesToMb(file.size);
-            const shouldCompress = compressImage && targetCompressedImageFileSizeMb < fileSizeMb && minCompressionThresholdMb < fileSizeMb;
+            const shouldCompress = compressImage
+                && targetCompressedImageFileSizeMb < fileSizeMb
+                && minCompressionThresholdMb < fileSizeMb;
             if (shouldCompress) {
                 const options = {
                     // Use maxWidthOrHeight if it was provided, else use target compressed size
                     ...(maxWidthOrHeight ? { maxWidthOrHeight } : { maxSizeMB: targetCompressedImageFileSizeMb }),
                     useWebWorker,
                     maxIterations: 30,
-                    onProgress: (p) => {
-                        this.progress = p;
+                    onProgress: (progress) => {
+                        this.progress = progress;
                         this.cdr.detectChanges();
                     }
                 };
@@ -75,23 +78,27 @@ export class ImageUploadFieldComponent extends ImageUploadFieldMixin {
             }
             else
                 return file;
-        }), map((compressedFileOrString) => {
-            if (!compressedFileOrString || typeof compressedFileOrString === 'string')
-                return compressedFileOrString;
-            const { type, name, lastModified } = compressedFileOrString;
-            return new File([compressedFileOrString], this.config.fileName || name, {
+        }), map((compressedFile) => {
+            if (!compressedFile)
+                return compressedFile;
+            const { type, name, lastModified } = compressedFile;
+            return new File([compressedFile], this.config.fileName || name, {
                 type,
                 lastModified
             });
         }), tap(file => {
-            this.control.setValue(file);
+            // only set the value if there is a file because resetToInitialValue sets the control value
+            // to initial value and clears the compressed image, so setting it to null here would undo that
+            if (file) {
+                this.control.setValue(file);
+            }
             if (file || this.value) {
                 this.control.markAsTouched();
                 setTimeout(() => {
                     this.cdr.detectChanges();
                 }, 100);
             }
-        }), map(file => typeof file === 'string' ? null : file), shareReplay(1));
+        }), shareReplay(1));
         this.compressedImageUrlString$ = this.compressedFile$.pipe(switchMap(async (file) => {
             if (!file)
                 return null;
@@ -107,11 +114,18 @@ export class ImageUploadFieldComponent extends ImageUploadFieldMixin {
     }
     ngOnInit() {
         super.ngOnInit();
+        // this.inputValueUrl = this.value && this.config.mapInputValueToUrl?.(this.value) || this.value;
         this.imageSrcUrl$ = combineLatest([
             this.compressedImageUrlString$.pipe(startWith(null)),
-            this.control.valueChanges.pipe(startWith(this.value))
+            this.control.valueChanges.pipe(startWith(this.value), map((controlValue) => {
+                if (!controlValue)
+                    return null;
+                if (controlValue instanceof File)
+                    return null;
+                return this.config.mapInputValueToUrl?.(controlValue) || controlValue;
+            }))
         ]).pipe(map(([compressedImageUrlString, controlUrl]) => {
-            return compressedImageUrlString || typeof controlUrl === 'string' && controlUrl || null;
+            return compressedImageUrlString || controlUrl || null;
         }));
         this.disabled$ = this.config.disabledCallback
             ? this.config.disabledCallback(this.group, this.config)
@@ -120,6 +134,10 @@ export class ImageUploadFieldComponent extends ImageUploadFieldMixin {
     filesChanged(files) {
         if (files && files.length > 0) {
             const imageFile = files[0];
+            // We clear the control here so that it is invalid while compressing
+            // the input pipeline will take care of resetting it
+            this.control.patchValue(null);
+            // this.control.setErrors({compressing: {loadingMessage: 'Please wait while file compresses'}});
             this.control.markAsTouched();
             this.inputImageFileSubject.next(imageFile);
         }
@@ -132,8 +150,8 @@ export class ImageUploadFieldComponent extends ImageUploadFieldMixin {
         this.isUploaded = false;
     }
     resetToInitialValue(initialValue) {
-        this.inputImageFileSubject.next(initialValue);
-        // this.fileInputRef.nativeElement.value = initialValue
+        this.inputImageFileSubject.next(null);
+        this.control.patchValue(initialValue);
         this.isUploaded = false;
     }
     writeValue(value) { }
@@ -212,7 +230,6 @@ export function maxFileSizeValidator(maxFileSize) {
         const actualFileSize = +convertBytesToMb(controlValue.size).toPrecision(3);
         if (maxFileSize > actualFileSize)
             return null;
-        // control.setErrors({maxFileSize: { maxFileSize, actualFileSize }} )
         return { maxFileSize: { maxFileSize, actualFileSize } };
     };
 }
@@ -222,7 +239,7 @@ export function allowedFileExtValidator(allowedFileExtensions, onlyAllowFiles =
         const isFile = controlValue instanceof File;
         if (!onlyAllowFiles && !isFile)
             return null;
-        const actualExtension = isFile ? controlValue.name.split('.').pop() : 'Not a file';
+        const actualExtension = isFile ? controlValue.name.split('.').pop().toLocaleLowerCase() : 'Not a file';
         const isAllowedExtension = allowedFileExtensions.includes(actualExtension);
         if (isAllowedExtension) {
             return null;
@@ -230,4 +247,4 @@ export function allowedFileExtValidator(allowedFileExtensions, onlyAllowFiles =
         return { allowedExtension: { allowedFileExtensions, actualExtension } };
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-upload-field.component.js","sourceRoot":"","sources":["../../../../../../../libs/crispr-forms/src/lib/material/image-upload-field/image-upload-field.component.ts","../../../../../../../libs/crispr-forms/src/lib/material/image-upload-field/image-upload-field.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  Component,\n  ElementRef,\n  ViewChild,\n  OnInit,\n  ChangeDetectionStrategy,\n  Optional,\n  Self,\n  ChangeDetectorRef,\n  NgModule\n} from '@angular/core';\nimport { ControlValueAccessor, FormControl, NgControl, ReactiveFormsModule, ValidationErrors, ValidatorFn } from '@angular/forms';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatInputModule } from '@angular/material/input';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport imageCompression from 'browser-image-compression';\nimport { combineLatest, Observable, of, Subject } from 'rxjs';\nimport { map, shareReplay, startWith, switchMap, tap } from 'rxjs/operators';\nimport { FileUploadFieldModule } from '../file-upload';\nimport { crisprControlMixin, CrisprFieldComponent } from '../../abstracts';\nimport { FieldContainerModule } from '../../field-container/field-container.component';\nimport type { ImageUploadFieldConfig } from '../../models/image-upload-field.config';\nimport { convertBytesToMb } from './image-compression.helpers';\nimport { SelectedFileModule } from '../selected-file/selected-file.component';\nimport { FormValidationHandlerModule } from '@tft/form-validation-handler';\n\nconst ImageUploadFieldMixin = crisprControlMixin<ImageUploadFieldConfig>(CrisprFieldComponent);\n\n@Component({\n  selector: 'crispr-image-upload-field',\n  templateUrl: './image-upload-field.component.html',\n  styleUrls: ['./image-upload-field.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ImageUploadFieldComponent extends ImageUploadFieldMixin implements OnInit, ControlValueAccessor {\n\n  onChange: () => void;\n\n  defaultConfig: Partial<ImageUploadFieldConfig> = {\n    // allowMultipleFiles: false,\n    acceptedTypes: 'image/*',\n    dropZoneText: 'DROP FILE HERE',\n    selectFilesButtonType: 'button',\n    selectButtonText: 'SELECT',\n    showClearFilesButton: true,\n    clearFilesButtonText: 'CLEAR',\n    resetFilesButtonText: 'RESET',\n    imagePreviewHeight: '250px',\n    compressImage: false,\n    targetCompressedImageFileSizeMb: .4,\n    minCompressionThresholdMb: .6,\n    useWebWorker: true,\n  }\n\n  progress: number | undefined;\n  private inputImageFileSubject = new Subject<File | string | null>();\n\n  inputImageFile$ = this.inputImageFileSubject.asObservable().pipe(\n    shareReplay(1),\n  );\n\n  compressedFile$: Observable<File> = this.inputImageFile$.pipe(\n    switchMap(async (file) => {\n      if (!file) return null;\n      if (typeof file === 'string') return file\n      const { compressImage, targetCompressedImageFileSizeMb, minCompressionThresholdMb, maxWidthOrHeight, useWebWorker } = this.config;\n      const fileSizeMb = convertBytesToMb(file.size);\n      const shouldCompress = compressImage && targetCompressedImageFileSizeMb < fileSizeMb && minCompressionThresholdMb < fileSizeMb\n      if (shouldCompress) {\n        const options = {\n          // Use maxWidthOrHeight if it was provided, else use target compressed size\n          ...(maxWidthOrHeight ? {maxWidthOrHeight} : { maxSizeMB: targetCompressedImageFileSizeMb}),\n          useWebWorker,\n          maxIterations: 30,\n          onProgress: (p: number) => {\n            this.progress = p;\n            this.cdr.detectChanges();\n          }\n        }\n        return await imageCompression(file, options);\n      } else return  file;\n    }),\n    map((compressedFileOrString: File | string) => {\n      if(!compressedFileOrString || typeof compressedFileOrString === 'string') return compressedFileOrString;\n      const { type, name, lastModified } = compressedFileOrString\n      return new File([compressedFileOrString], this.config.fileName || name, {\n        type,\n        lastModified\n      });\n    }),\n    tap(file => {\n      this.control.setValue(file);\n      if (file || this.value) {\n        this.control.markAsTouched();\n        setTimeout(() => {\n          this.cdr.detectChanges();\n        }, 100)\n      }\n    }),\n    map(file => typeof file === 'string' ? null : file),\n    shareReplay(1)\n  )\n\n  compressedImageUrlString$: Observable<string | null> = this.compressedFile$.pipe(\n    switchMap(async (file) => {\n      if(!file) return null;\n      const compressedStringImage = await imageCompression.getDataUrlFromFile(file);\n      return this.domSanitizer.bypassSecurityTrustResourceUrl(compressedStringImage) as string\n    }),\n    shareReplay(1),\n  )\n\n  // This is what is displayed by the image preview\n  imageSrcUrl$: Observable<string | null>;\n\n  @ViewChild('fileInput') fileInputRef: ElementRef\n\n  selectedFiles: FileList;\n\n  isUploaded = false;\n\n  disabled$: Observable<boolean>;\n\n  // ngControl: NgControl = null;\n  constructor(\n    @Optional() @Self() public ngControl: NgControl,\n    private domSanitizer: DomSanitizer,\n    private cdr: ChangeDetectorRef,\n  ) {\n    super();\n    if (this.ngControl != null) {\n      // Setting the value accessor directly (instead of using\n      // the providers) to avoid running into a circular import.\n      ngControl.valueAccessor = this;\n    }\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n    this.imageSrcUrl$ = combineLatest([\n      this.compressedImageUrlString$.pipe(startWith(null)),\n      this.control.valueChanges.pipe(startWith(this.value))\n    ]).pipe(\n      map(([compressedImageUrlString, controlUrl]) => {\n        return compressedImageUrlString || typeof controlUrl === 'string' && controlUrl || null;\n      })\n    )\n    this.disabled$ = this.config.disabledCallback\n    ? this.config.disabledCallback(this.group, this.config)\n    : of(false);\n  }\n\n  filesChanged(files: FileList): void {\n    if (files && files.length > 0 ) {\n      const imageFile = files[0];\n      this.control.markAsTouched();\n      this.inputImageFileSubject.next(imageFile);\n    }\n  }\n\n  clearFileInput(): void {\n    this.inputImageFileSubject.next(null);\n    this.fileInputRef.nativeElement.value = ''\n    this.control.patchValue(null);\n    this.control.markAsTouched();\n    this.isUploaded = false;\n  }\n\n  resetToInitialValue(initialValue: string): void {\n    this.inputImageFileSubject.next(initialValue);\n    // this.fileInputRef.nativeElement.value = initialValue\n    this.isUploaded = false;\n  }\n\n  writeValue( value: null ) { }\n\n  registerOnChange( fn: () => void ) {\n    this.onChange = fn;\n  }\n\n  registerOnTouched( fn: () => void ) { }\n}\n@NgModule({\n  imports: [\n    CommonModule,\n    FieldContainerModule,\n    ReactiveFormsModule,\n    MatIconModule,\n    MatButtonModule,\n    MatFormFieldModule,\n    MatInputModule,\n    SelectedFileModule,\n    FileUploadFieldModule,\n    FormValidationHandlerModule\n  ],\n  exports: [\n      ImageUploadFieldComponent\n  ],\n  declarations: [\n      ImageUploadFieldComponent\n  ]\n})\nexport class ImageUploadFieldModule { }\n\nexport function maxFileSizeValidator(maxFileSize: number): ValidatorFn {\n  return (control: FormControl): ValidationErrors | null => {\n    const controlValue = control.value;\n    if (!(controlValue instanceof File)) {\n      return null;\n    }\n    const actualFileSize = +convertBytesToMb(controlValue.size).toPrecision(3);\n    if (maxFileSize > actualFileSize) return null;\n    // control.setErrors({maxFileSize: { maxFileSize, actualFileSize }} )\n    return {maxFileSize: { maxFileSize, actualFileSize }};\n  }\n}\n\nexport function allowedFileExtValidator(allowedFileExtensions: string[], onlyAllowFiles = true): ValidatorFn {\n  return (control: FormControl): ValidationErrors | null => {\n    const controlValue = control.value;\n    const isFile = controlValue instanceof File;\n    if (!onlyAllowFiles && !isFile) return null;\n    const actualExtension = isFile ? controlValue.name.split('.').pop() : 'Not a file';\n    const isAllowedExtension = allowedFileExtensions.includes(actualExtension);\n    if(isAllowedExtension) {\n      return null;\n    }\n    return {allowedExtension: { allowedFileExtensions, actualExtension }};\n  }\n}\n","<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field floatLabel=\"always\"\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\"\n    [formGroup]=\"group\">\n    <mat-label>{{config.label}}</mat-label>\n    <input [formControlName]=\"config.controlName\" matInput type=\"text\"/>\n    <input\n      #fileInput\n      type=\"file\"\n      [accept]=\"config.acceptedTypes\"\n      (change)=\"filesChanged($event.target.files)\"/>\n    <div class=\"ui-container\">\n\n      <div class=\"image-preview\" [style.height]=\"config.imagePreviewHeight\">\n        <crispr-selected-file\n          *ngIf=\"(progress < 100) && inputImageFile$ | async as file; else dropzoneOrPreview\"\n          [color]=\"config.color === 'primary' ? 'accent' : 'primary'\"\n          [fileName]=\"'Compressing: ' + file.name\"\n          [showProgress]=\"true\"\n          [progress]=\"progress\">\n        </crispr-selected-file>\n\n        <ng-template #dropzoneOrPreview>\n          <!-- <img *ngIf=\"(initialUrlString$ | async) as initialUrlString;\" [src]=\"initialUrlString\" alt=\"\"> -->\n          <img *ngIf=\"imageSrcUrl$ | async as srcUrl; else noImage\" [src]=\"srcUrl\" alt=\"\">\n          <ng-template #noImage>\n            <div class=\"drop-container\"\n              [crisprFileDropzone]=\"!(disabled$ | async)\"\n              (fileDrop)=\"filesChanged($event)\">\n              <mat-icon class=\"drop-icon\" inline=\"true\">cloud_upload</mat-icon>\n              <h2 class=\"mat-h2\">{{config.dropZoneText}}</h2>\n            </div>\n          </ng-template>\n\n        </ng-template>\n      </div>\n\n\n\n      <!-- </ng-template> -->\n      <div class=\"button-container\" *ngIf=\"true\">\n\n        <button\n          mat-button\n          (click)=\"clearFileInput()\"\n          type=\"button\"\n          [disabled]=\"(disabled$ | async)\"\n          aria-label=\"Remove Selected File(s)\">\n          <mat-icon>delete</mat-icon>\n          {{config.clearFilesButtonText}}\n        </button>\n\n        <button\n          *ngIf=\"value\"\n          mat-button\n          (click)=\"resetToInitialValue(value)\"\n          type=\"button\"\n          [disabled]=\"(disabled$ | async)\"\n          aria-label=\"Remove Selected File(s)\">\n          <mat-icon>replay</mat-icon>\n          {{config.resetFilesButtonText}}\n        </button>\n\n        <button\n          mat-button\n          type=\"button\"\n          color=\"primary\"\n          [disabled]=\"(disabled$ | async)\"\n          (click)=\"fileInput.click()\"\n          [attr.aria-label]=\"config.controlName\">\n          <mat-icon>\n            camera\n          </mat-icon>\n          SELECT\n        </button>\n      </div>\n    </div>\n\n  </mat-form-field>\n\n</crispr-field-container>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-upload-field.component.js","sourceRoot":"","sources":["../../../../../../../libs/crispr-forms/src/lib/material/image-upload-field/image-upload-field.component.ts","../../../../../../../libs/crispr-forms/src/lib/material/image-upload-field/image-upload-field.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  Component,\n  ElementRef,\n  ViewChild,\n  OnInit,\n  ChangeDetectionStrategy,\n  Optional,\n  Self,\n  ChangeDetectorRef,\n  NgModule\n} from '@angular/core';\nimport { ControlValueAccessor, FormControl, NgControl, ReactiveFormsModule, ValidationErrors, ValidatorFn } from '@angular/forms';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatInputModule } from '@angular/material/input';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport imageCompression from 'browser-image-compression';\nimport { combineLatest, Observable, of, Subject } from 'rxjs';\nimport { map, shareReplay, startWith, switchMap, tap } from 'rxjs/operators';\nimport { FileUploadFieldModule } from '../file-upload';\nimport { crisprControlMixin, CrisprFieldComponent } from '../../abstracts';\nimport { FieldContainerModule } from '../../field-container/field-container.component';\nimport type { ImageUploadFieldConfig } from '../../models/image-upload-field.config';\nimport { convertBytesToMb } from './image-compression.helpers';\nimport { SelectedFileModule } from '../selected-file/selected-file.component';\nimport { FormValidationHandlerModule } from '@tft/form-validation-handler';\n\nconst ImageUploadFieldMixin = crisprControlMixin<ImageUploadFieldConfig>(CrisprFieldComponent);\n\n@Component({\n  selector: 'crispr-image-upload-field',\n  templateUrl: './image-upload-field.component.html',\n  styleUrls: ['./image-upload-field.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ImageUploadFieldComponent extends ImageUploadFieldMixin implements OnInit, ControlValueAccessor {\n\n  onChange: () => void;\n\n  defaultConfig: Partial<ImageUploadFieldConfig> = {\n    // allowMultipleFiles: false,\n    acceptedTypes: 'image/*',\n    dropZoneText: 'DROP FILE HERE',\n    selectFilesButtonType: 'button',\n    selectButtonText: 'SELECT',\n    showClearFilesButton: true,\n    clearFilesButtonText: 'CLEAR',\n    resetFilesButtonText: 'RESET',\n    imagePreviewHeight: '250px',\n    compressImage: false,\n    targetCompressedImageFileSizeMb: .4,\n    minCompressionThresholdMb: .6,\n    useWebWorker: true,\n  }\n\n  /**\n   * The url mapped from initial input value, consumers can us mapInputValueToUrl in config to transform their input value into a src url for the image element\n   */\n  // inputValueUrl: string | undefined;\n\n  private inputImageFileSubject = new Subject<File | null>();\n  inputImageFile$ = this.inputImageFileSubject.asObservable().pipe(\n    shareReplay(1),\n  );\n  /**\n   * the compression progress\n   */\n  progress: number | undefined;\n\n  compressedFile$: Observable<File> = this.inputImageFile$.pipe(\n    switchMap(async (file) => {\n      if (!file || !(file instanceof File)) return null;\n      const { compressImage, targetCompressedImageFileSizeMb, minCompressionThresholdMb, maxWidthOrHeight, useWebWorker } = this.config;\n      const fileSizeMb = convertBytesToMb(file.size);\n      const shouldCompress = compressImage\n        && targetCompressedImageFileSizeMb < fileSizeMb\n        && minCompressionThresholdMb < fileSizeMb\n      if (shouldCompress) {\n        const options = {\n          // Use maxWidthOrHeight if it was provided, else use target compressed size\n          ...(maxWidthOrHeight ? {maxWidthOrHeight} : { maxSizeMB: targetCompressedImageFileSizeMb}),\n          useWebWorker,\n          maxIterations: 30,\n          onProgress: (progress: number) => {\n            this.progress = progress;\n            this.cdr.detectChanges();\n          }\n        }\n        return await imageCompression(file, options);\n      } else return  file;\n    }),\n    map((compressedFile: File) => {\n      if(!compressedFile) return compressedFile;\n      const { type, name, lastModified } = compressedFile\n      return new File([compressedFile], this.config.fileName || name, {\n        type,\n        lastModified\n      });\n    }),\n    tap(file => {\n      // only set the value if there is a file because resetToInitialValue sets the control value\n      // to initial value and clears the compressed image, so setting it to null here would undo that\n      if (file) {\n        this.control.setValue(file);\n      }\n      if (file || this.value) {\n        this.control.markAsTouched();\n        setTimeout(() => {\n          this.cdr.detectChanges();\n        }, 100)\n      }\n    }),\n    shareReplay(1)\n  )\n\n  compressedImageUrlString$: Observable<string | null> = this.compressedFile$.pipe(\n    switchMap(async (file) => {\n      if(!file) return null;\n      const compressedStringImage = await imageCompression.getDataUrlFromFile(file);\n      return this.domSanitizer.bypassSecurityTrustResourceUrl(compressedStringImage) as string\n    }),\n    shareReplay(1),\n  )\n\n  // This is what is displayed by the image preview\n  imageSrcUrl$: Observable<string | null>;\n\n  @ViewChild('fileInput') fileInputRef: ElementRef\n\n  selectedFiles: FileList;\n\n  isUploaded = false;\n\n  disabled$: Observable<boolean>;\n\n  constructor(\n    @Optional() @Self() public ngControl: NgControl,\n    private domSanitizer: DomSanitizer,\n    private cdr: ChangeDetectorRef,\n  ) {\n    super();\n    if (this.ngControl != null) {\n      // Setting the value accessor directly (instead of using\n      // the providers) to avoid running into a circular import.\n      ngControl.valueAccessor = this;\n    }\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n    // this.inputValueUrl = this.value && this.config.mapInputValueToUrl?.(this.value) || this.value;\n    this.imageSrcUrl$ = combineLatest([\n      this.compressedImageUrlString$.pipe(startWith(null)),\n      this.control.valueChanges.pipe(\n        startWith(this.value),\n        map((controlValue): string => {\n          if(!controlValue) return null;\n          if(controlValue instanceof File) return null;\n          return this.config.mapInputValueToUrl?.(controlValue) || controlValue as string\n        })\n      )\n    ]).pipe(\n      map(([compressedImageUrlString, controlUrl]) => {\n        return compressedImageUrlString || controlUrl || null;\n      })\n    )\n    this.disabled$ = this.config.disabledCallback\n    ? this.config.disabledCallback(this.group, this.config)\n    : of(false);\n  }\n\n  filesChanged(files: FileList): void {\n    if (files && files.length > 0 ) {\n      const imageFile = files[0];\n      // We clear the control here so that it is invalid while compressing\n      // the input pipeline will take care of resetting it\n      this.control.patchValue(null);\n      // this.control.setErrors({compressing: {loadingMessage: 'Please wait while file compresses'}});\n      this.control.markAsTouched();\n      this.inputImageFileSubject.next(imageFile);\n    }\n  }\n\n  clearFileInput(): void {\n    this.inputImageFileSubject.next(null);\n    this.fileInputRef.nativeElement.value = ''\n    this.control.patchValue(null);\n    this.control.markAsTouched();\n    this.isUploaded = false;\n  }\n\n  resetToInitialValue(initialValue: string): void {\n    this.inputImageFileSubject.next(null);\n    this.control.patchValue(initialValue)\n    this.isUploaded = false;\n  }\n\n  writeValue( value: null ) { }\n\n  registerOnChange( fn: () => void ) {\n    this.onChange = fn;\n  }\n\n  registerOnTouched( fn: () => void ) { }\n}\n@NgModule({\n  imports: [\n    CommonModule,\n    FieldContainerModule,\n    ReactiveFormsModule,\n    MatIconModule,\n    MatButtonModule,\n    MatFormFieldModule,\n    MatInputModule,\n    SelectedFileModule,\n    FileUploadFieldModule,\n    FormValidationHandlerModule\n  ],\n  exports: [\n      ImageUploadFieldComponent\n  ],\n  declarations: [\n      ImageUploadFieldComponent\n  ]\n})\nexport class ImageUploadFieldModule { }\n\nexport function maxFileSizeValidator(maxFileSize: number): ValidatorFn {\n  return (control: FormControl): ValidationErrors | null => {\n    const controlValue = control.value;\n    if (!(controlValue instanceof File)) {\n      return null;\n    }\n    const actualFileSize = +convertBytesToMb(controlValue.size).toPrecision(3);\n    if (maxFileSize > actualFileSize) return null;\n    return {maxFileSize: { maxFileSize, actualFileSize }};\n  }\n}\n\nexport function allowedFileExtValidator(allowedFileExtensions: string[], onlyAllowFiles = true): ValidatorFn {\n  return (control: FormControl): ValidationErrors | null => {\n    const controlValue = control.value;\n    const isFile = controlValue instanceof File;\n    if (!onlyAllowFiles && !isFile) return null;\n    const actualExtension = isFile ? controlValue.name.split('.').pop().toLocaleLowerCase() : 'Not a file';\n    const isAllowedExtension = allowedFileExtensions.includes(actualExtension);\n    if(isAllowedExtension) {\n      return null;\n    }\n    return {allowedExtension: { allowedFileExtensions, actualExtension }};\n  }\n}\n","<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field floatLabel=\"always\"\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\"\n    [formGroup]=\"group\">\n    <mat-label>{{config.label}}</mat-label>\n    <input [formControlName]=\"config.controlName\" matInput type=\"text\"/>\n    <input\n      #fileInput\n      type=\"file\"\n      [accept]=\"config.acceptedTypes\"\n      (change)=\"filesChanged($event.target.files)\"/>\n    <div class=\"ui-container\">\n\n      <div class=\"image-preview\" [style.height]=\"config.imagePreviewHeight\">\n        <crispr-selected-file\n          *ngIf=\"(progress < 100) && inputImageFile$ | async as file; else dropzoneOrPreview\"\n          [color]=\"config.color === 'primary' ? 'accent' : 'primary'\"\n          [fileName]=\"'Compressing: ' + file.name\"\n          [showProgress]=\"true\"\n          [progress]=\"progress\">\n        </crispr-selected-file>\n\n        <ng-template #dropzoneOrPreview>\n          <!-- <img *ngIf=\"(initialUrlString$ | async) as initialUrlString;\" [src]=\"initialUrlString\" alt=\"\"> -->\n          <img *ngIf=\"imageSrcUrl$ | async as srcUrl; else noImage\" [src]=\"srcUrl\" alt=\"\">\n          <ng-template #noImage>\n            <div class=\"drop-container\"\n              [crisprFileDropzone]=\"!(disabled$ | async)\"\n              (fileDrop)=\"filesChanged($event)\">\n              <mat-icon class=\"drop-icon\" inline=\"true\">cloud_upload</mat-icon>\n              <h2 class=\"mat-h2\">{{config.dropZoneText}}</h2>\n            </div>\n          </ng-template>\n\n        </ng-template>\n      </div>\n\n\n\n      <!-- </ng-template> -->\n      <div class=\"button-container\" *ngIf=\"true\">\n\n        <button\n          mat-button\n          (click)=\"clearFileInput()\"\n          type=\"button\"\n          [disabled]=\"(disabled$ | async)\"\n          aria-label=\"Remove Selected File(s)\">\n          <mat-icon>delete</mat-icon>\n          {{config.clearFilesButtonText}}\n        </button>\n\n        <button\n          *ngIf=\"value\"\n          mat-button\n          (click)=\"resetToInitialValue(value)\"\n          type=\"button\"\n          [disabled]=\"(disabled$ | async)\"\n          aria-label=\"Remove Selected File(s)\">\n          <mat-icon>replay</mat-icon>\n          {{config.resetFilesButtonText}}\n        </button>\n\n        <button\n          mat-button\n          type=\"button\"\n          color=\"primary\"\n          [disabled]=\"(disabled$ | async)\"\n          (click)=\"fileInput.click()\"\n          [attr.aria-label]=\"config.controlName\">\n          <mat-icon>\n            camera\n          </mat-icon>\n          SELECT\n        </button>\n      </div>\n    </div>\n\n  </mat-form-field>\n\n</crispr-field-container>\n"]}

package/esm2020/lib/models/image-upload-field.config.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2015/tft-crispr-forms.mjs

@@ -1,7 +1,7 @@
 import { of, combineLatest, from, isObservable, BehaviorSubject, Subject } from 'rxjs';
 import * as i4$1 from '@angular/forms';
 import { FormGroup, FormArray, FormControl, ReactiveFormsModule } from '@angular/forms';
-import { map, startWith, debounceTime, distinctUntilChanged, switchMap, tap, shareReplay } from 'rxjs/operators';
+import { map, startWith, shareReplay, debounceTime, distinctUntilChanged, switchMap, tap } from 'rxjs/operators';
 import * as i0 from '@angular/core';
 import { Directive, Component, ChangeDetectionStrategy, Input, NgModule, ViewChild, EventEmitter, Output, HostListener, Optional, Self, Pipe } from '@angular/core';
 import * as i2 from '@angular/common';
@@ -211,7 +211,7 @@ function callOptionsIfFunction(options, parentGroup, searchString) {
 function observablifyOptions(options, parentGroup, searchString) {
     const calledOptions = callOptionsIfFunction(options, parentGroup, searchString);
     // if options are a promise
-    return calledOptions instanceof Promise
+    const observableOptions = calledOptions instanceof Promise
         // convert to observable
         ? from(calledOptions)
         // if array that isn't empty
@@ -224,6 +224,7 @@ function observablifyOptions(options, parentGroup, searchString) {
                 ? calledOptions
                 // else an empty array
                 : of([]);
+    return observableOptions.pipe(shareReplay(1));
 }
 /**
  * Determines if the field config is for a form control (not a divider, heading or other non-control field)
@@ -333,7 +334,7 @@ class AbstractAutocompleteComponent extends AbstractAutocompleteFieldMixin {
         // filter options by the search string using either the default filter function or one passed in through config
         this.options$ = this.autocompleteInputControl.valueChanges.pipe(
         // this is needed to have the options panel to open on focus
-        startWith(''), debounceTime(this.config.typeDebounceTime), distinctUntilChanged(), map(searchText => searchText || ''), switchMap((searchText) => observablifyOptions(this.config.options, this.group, searchText)));
+        startWith(''), debounceTime(this.config.typeDebounceTime), map(searchText => searchText || ''), distinctUntilChanged(), switchMap((searchText) => observablifyOptions(this.config.options, this.group, searchText)), shareReplay(1));
     }
 }
 AbstractAutocompleteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AbstractAutocompleteComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive });
@@ -616,10 +617,10 @@ class AutocompleteFieldComponent extends AbstractAutocompleteComponent {
     }
 }
 AutocompleteFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AutocompleteFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-AutocompleteFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: AutocompleteFieldComponent, selector: "crispr-autocomplete-field", viewQueries: [{ propertyName: "autoInput", first: true, predicate: ["autoInput"], descendants: true, read: MatAutocompleteTrigger }, { propertyName: "autoInputRef", first: true, predicate: ["autoInput"], descendants: true }], usesInheritance: true, ngImport: i0, template: "\n<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\">\n    <mat-label *ngIf=\"config.label\">\n      {{config.label}}\n    </mat-label>\n    <input\n      matInput\n      [formControl]=\"autocompleteInputControl\"\n      [placeholder]=\"config.placeholder\"\n      [matAutocomplete]=\"auto\"\n      role=\"textbox\"\n      type=\"textbox\"\n      autocapitalize=\"off\"\n      autocorrect=\"off\"\n      spellcheck=\"false\"\n      #autoInput>\n\n    <span *ngIf=\"config.fieldSuffix\" matSuffix>{{config.fieldSuffix}}</span>\n    <crispr-info\n      *ngIf=\"config.info\"\n      matSuffix\n      [info]=\"config.info \">\n    </crispr-info>\n\n    <mat-autocomplete\n      #auto=\"matAutocomplete\"\n      [autoActiveFirstOption]=\"config.autoActiveFirstOption\"\n      (optionSelected)=\"handleSelect($event)\"\n      [displayWith]=\"displayLabel(options$ | async)\">\n\n      <ng-container *ngIf=\"options$ | async as options; else emptyOption\">\n        <ng-container *ngIf=\"options.length > 0; else emptyOption\">\n          <mat-option\n            *ngFor=\"let option of options$ | async\"\n            [value]=\"option.value\">\n            <crispr-option [option]=\"option\"></crispr-option>\n          </mat-option>\n        </ng-container>\n\n      </ng-container>\n      <ng-template #emptyOption>\n        <mat-option disabled=\"true\">\n          {{config.emptyOptionsMessage}}\n        </mat-option>\n      </ng-template>\n\n    </mat-autocomplete>\n  </mat-form-field>\n</crispr-field-container>\n", styles: [""], components: [{ type: FieldContainerComponent, selector: "crispr-field-container", inputs: ["config", "group", "inlineField"] }, { type: i2$1.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: InfoComponent, selector: "crispr-info", inputs: ["info"] }, { type: i4$3.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i5$1.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: OptionComponent, selector: "crispr-option", inputs: ["option"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2$1.MatLabel, selector: "mat-label" }, { type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i4$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i4$3.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i4$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4$1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i5.ControlErrorsDirective, selector: "[formControl], [formControlName]" }, { type: i2$1.MatSuffix, selector: "[matSuffix]" }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, preserveWhitespaces: true });
+AutocompleteFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: AutocompleteFieldComponent, selector: "crispr-autocomplete-field", viewQueries: [{ propertyName: "autoInput", first: true, predicate: ["autoInput"], descendants: true, read: MatAutocompleteTrigger }, { propertyName: "autoInputRef", first: true, predicate: ["autoInput"], descendants: true }], usesInheritance: true, ngImport: i0, template: "\n<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\"\n    [formGroup]=\"group\">\n    <mat-label *ngIf=\"config.label\">\n      {{config.label}}\n    </mat-label>\n\n    <input class=\"hidden-error-directive-anchor\" [formControlName]=\"config.controlName\" type=\"text\"/>\n\n    <input\n      matInput\n      [formControl]=\"autocompleteInputControl\"\n      [placeholder]=\"config.placeholder\"\n      [matAutocomplete]=\"auto\"\n      role=\"textbox\"\n      type=\"textbox\"\n      autocapitalize=\"off\"\n      autocorrect=\"off\"\n      spellcheck=\"false\"\n      #autoInput>\n\n    <span *ngIf=\"config.fieldSuffix\" matSuffix>{{config.fieldSuffix}}</span>\n    <crispr-info\n      *ngIf=\"config.info\"\n      matSuffix\n      [info]=\"config.info \">\n    </crispr-info>\n\n    <mat-autocomplete\n      #auto=\"matAutocomplete\"\n      [autoActiveFirstOption]=\"config.autoActiveFirstOption\"\n      (optionSelected)=\"handleSelect($event)\"\n      [displayWith]=\"displayLabel(options$ | async)\">\n\n      <ng-container *ngIf=\"options$ | async as options; else emptyOption\">\n        <ng-container *ngIf=\"options.length > 0; else emptyOption\">\n          <mat-option\n            *ngFor=\"let option of options$ | async\"\n            [value]=\"option.value\">\n            <crispr-option [option]=\"option\"></crispr-option>\n          </mat-option>\n        </ng-container>\n\n      </ng-container>\n      <ng-template #emptyOption>\n        <mat-option disabled=\"true\">\n          {{config.emptyOptionsMessage}}\n        </mat-option>\n      </ng-template>\n\n    </mat-autocomplete>\n  </mat-form-field>\n</crispr-field-container>\n", styles: [".hidden-error-directive-anchor{display:none}\n"], components: [{ type: FieldContainerComponent, selector: "crispr-field-container", inputs: ["config", "group", "inlineField"] }, { type: i2$1.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: InfoComponent, selector: "crispr-info", inputs: ["info"] }, { type: i4$3.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i5$1.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: OptionComponent, selector: "crispr-option", inputs: ["option"] }], directives: [{ type: i4$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i4$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i5.ControlErrorContainerDirective, selector: "[controlErrorContainer], [formGroup]" }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2$1.MatLabel, selector: "mat-label" }, { type: i4$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i4$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4$1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { type: i5.ControlErrorsDirective, selector: "[formControl], [formControlName]" }, { type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i4$3.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i4$1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i2$1.MatSuffix, selector: "[matSuffix]" }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, preserveWhitespaces: true });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AutocompleteFieldComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'crispr-autocomplete-field', changeDetection: ChangeDetectionStrategy.OnPush, template: "\n<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\">\n    <mat-label *ngIf=\"config.label\">\n      {{config.label}}\n    </mat-label>\n    <input\n      matInput\n      [formControl]=\"autocompleteInputControl\"\n      [placeholder]=\"config.placeholder\"\n      [matAutocomplete]=\"auto\"\n      role=\"textbox\"\n      type=\"textbox\"\n      autocapitalize=\"off\"\n      autocorrect=\"off\"\n      spellcheck=\"false\"\n      #autoInput>\n\n    <span *ngIf=\"config.fieldSuffix\" matSuffix>{{config.fieldSuffix}}</span>\n    <crispr-info\n      *ngIf=\"config.info\"\n      matSuffix\n      [info]=\"config.info \">\n    </crispr-info>\n\n    <mat-autocomplete\n      #auto=\"matAutocomplete\"\n      [autoActiveFirstOption]=\"config.autoActiveFirstOption\"\n      (optionSelected)=\"handleSelect($event)\"\n      [displayWith]=\"displayLabel(options$ | async)\">\n\n      <ng-container *ngIf=\"options$ | async as options; else emptyOption\">\n        <ng-container *ngIf=\"options.length > 0; else emptyOption\">\n          <mat-option\n            *ngFor=\"let option of options$ | async\"\n            [value]=\"option.value\">\n            <crispr-option [option]=\"option\"></crispr-option>\n          </mat-option>\n        </ng-container>\n\n      </ng-container>\n      <ng-template #emptyOption>\n        <mat-option disabled=\"true\">\n          {{config.emptyOptionsMessage}}\n        </mat-option>\n      </ng-template>\n\n    </mat-autocomplete>\n  </mat-form-field>\n</crispr-field-container>\n", styles: [""] }]
+            args: [{ selector: 'crispr-autocomplete-field', changeDetection: ChangeDetectionStrategy.OnPush, template: "\n<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\"\n    [formGroup]=\"group\">\n    <mat-label *ngIf=\"config.label\">\n      {{config.label}}\n    </mat-label>\n\n    <input class=\"hidden-error-directive-anchor\" [formControlName]=\"config.controlName\" type=\"text\"/>\n\n    <input\n      matInput\n      [formControl]=\"autocompleteInputControl\"\n      [placeholder]=\"config.placeholder\"\n      [matAutocomplete]=\"auto\"\n      role=\"textbox\"\n      type=\"textbox\"\n      autocapitalize=\"off\"\n      autocorrect=\"off\"\n      spellcheck=\"false\"\n      #autoInput>\n\n    <span *ngIf=\"config.fieldSuffix\" matSuffix>{{config.fieldSuffix}}</span>\n    <crispr-info\n      *ngIf=\"config.info\"\n      matSuffix\n      [info]=\"config.info \">\n    </crispr-info>\n\n    <mat-autocomplete\n      #auto=\"matAutocomplete\"\n      [autoActiveFirstOption]=\"config.autoActiveFirstOption\"\n      (optionSelected)=\"handleSelect($event)\"\n      [displayWith]=\"displayLabel(options$ | async)\">\n\n      <ng-container *ngIf=\"options$ | async as options; else emptyOption\">\n        <ng-container *ngIf=\"options.length > 0; else emptyOption\">\n          <mat-option\n            *ngFor=\"let option of options$ | async\"\n            [value]=\"option.value\">\n            <crispr-option [option]=\"option\"></crispr-option>\n          </mat-option>\n        </ng-container>\n\n      </ng-container>\n      <ng-template #emptyOption>\n        <mat-option disabled=\"true\">\n          {{config.emptyOptionsMessage}}\n        </mat-option>\n      </ng-template>\n\n    </mat-autocomplete>\n  </mat-form-field>\n</crispr-field-container>\n", styles: [".hidden-error-directive-anchor{display:none}\n"] }]
         }], propDecorators: { autoInput: [{
                 type: ViewChild,
                 args: ['autoInput', { read: MatAutocompleteTrigger }]
@@ -708,10 +709,10 @@ class AutocompleteChiplistFieldComponent extends AbstractAutocompleteComponent {
     }
 }
 AutocompleteChiplistFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AutocompleteChiplistFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-AutocompleteChiplistFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: AutocompleteChiplistFieldComponent, selector: "crispr-autocomplete-chiplist-field", viewQueries: [{ propertyName: "chipInput", first: true, predicate: ["autoInput"], descendants: true, read: MatAutocompleteTrigger }, { propertyName: "chipInputRef", first: true, predicate: ["autoInput"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\">\n    <mat-label *ngIf=\"config.label\">\n      {{config.label}}\n    </mat-label>\n\n    <mat-chip-list\n      #chipList>\n      <mat-chip\n        class=\"refinement-chip\"\n        *ngFor=\"let chip of controlValue$ | async\"\n        [selectable]=\"config.chipsSelectable\"\n        [removable]=\"config.areChipsRemovable\"\n        (removed)=\"removeChip(chip)\">\n        <span *ngIf=\"chip.imageUrl as imageUrl\" class=\"image-container\">\n          <img [src]=\"imageUrl\" alt=\"image of {{chip.label}}\">\n        </span>\n        {{chip.label}}\n        <mat-icon\n          matChipRemove\n          *ngIf=\"config.areChipsRemovable\">\n          cancel\n        </mat-icon>\n      </mat-chip>\n\n      <input\n        matInput\n        [formControl]=\"autocompleteInputControl\"\n        [placeholder]=\"config.placeholder\"\n        [matChipInputFor]=\"chipList\"\n        [matAutocomplete]=\"auto\"\n        (keydown.tab)=\"handleTab($event)\"\n        [matChipInputSeparatorKeyCodes]=\"config.separatorKeyCodes\"\n        (matChipInputTokenEnd)=\"handleTokenEnd($event)\"\n        role=\"searchbox\"\n        type=\"text\"\n        autocapitalize=\"off\"\n        autocorrect=\"off\"\n        spellcheck=\"false\"\n        #autoInput/>\n      <span *ngIf=\"config.fieldSuffix\" matSuffix>{{config.fieldSuffix}}</span>\n      <crispr-info\n        *ngIf=\"config.info\"\n        matSuffix\n        [info]=\"config.info \">\n      </crispr-info>\n\n    </mat-chip-list>\n    <mat-autocomplete\n      #auto=\"matAutocomplete\"\n      [autoActiveFirstOption]=\"this.config.autoActiveFirstOption\"\n      (optionSelected)=\"handleSelect($event)\"\n      [displayWith]=\"mapToLabel\">\n      <ng-container *ngIf=\"remainingOptions$ | async as remainingOptions; else emptyOption\">\n        <ng-container *ngIf=\"remainingOptions.length > 0; else emptyOption\">\n           <mat-option\n            *ngFor=\"let option of remainingOptions$ | async\"\n            [value]=\"option\">\n            <crispr-option [option]=\"option\"></crispr-option>\n          </mat-option>\n        </ng-container>\n\n      </ng-container>\n      <ng-template #emptyOption>\n        <mat-option disabled=\"true\">\n          {{config.emptyOptionsMessage}}\n        </mat-option>\n      </ng-template>\n    </mat-autocomplete>\n\n\n  </mat-form-field>\n</crispr-field-container>\n", styles: [".refinement-chip .image-container{width:26px;height:26px;border-radius:50%;overflow:hidden;margin:-2px 4px -2px -8px}.refinement-chip .image-container img{width:100%;height:100%;object-fit:cover}\n"], components: [{ type: FieldContainerComponent, selector: "crispr-field-container", inputs: ["config", "group", "inlineField"] }, { type: i2$1.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: i3$2.MatChipList, selector: "mat-chip-list", inputs: ["errorStateMatcher", "multiple", "compareWith", "value", "required", "placeholder", "disabled", "aria-orientation", "selectable", "tabIndex"], outputs: ["change", "valueChange"], exportAs: ["matChipList"] }, { type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: InfoComponent, selector: "crispr-info", inputs: ["info"] }, { type: i4$3.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i5$1.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: OptionComponent, selector: "crispr-option", inputs: ["option"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2$1.MatLabel, selector: "mat-label" }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3$2.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["color", "disableRipple", "tabIndex", "selected", "value", "selectable", "disabled", "removable"], outputs: ["selectionChange", "destroyed", "removed"], exportAs: ["matChip"] }, { type: i3$2.MatChipRemove, selector: "[matChipRemove]" }, { type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i4$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i3$2.MatChipInput, selector: "input[matChipInputFor]", inputs: ["matChipInputFor", "matChipInputAddOnBlur", "matChipInputSeparatorKeyCodes", "placeholder", "id", "disabled"], outputs: ["matChipInputTokenEnd"], exportAs: ["matChipInput", "matChipInputFor"] }, { type: i4$3.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i4$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4$1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i5.ControlErrorsDirective, selector: "[formControl], [formControlName]" }, { type: i2$1.MatSuffix, selector: "[matSuffix]" }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, preserveWhitespaces: true });
+AutocompleteChiplistFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: AutocompleteChiplistFieldComponent, selector: "crispr-autocomplete-chiplist-field", viewQueries: [{ propertyName: "chipInput", first: true, predicate: ["autoInput"], descendants: true, read: MatAutocompleteTrigger }, { propertyName: "chipInputRef", first: true, predicate: ["autoInput"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\"\n    [formGroup]=\"group\">\n    <mat-label *ngIf=\"config.label\">\n      {{config.label}}\n    </mat-label>\n\n    <mat-chip-list\n      #chipList>\n      <mat-chip\n        class=\"refinement-chip\"\n        *ngFor=\"let chip of controlValue$ | async\"\n        [selectable]=\"config.chipsSelectable\"\n        [removable]=\"config.areChipsRemovable\"\n        (removed)=\"removeChip(chip)\">\n        <span *ngIf=\"chip.imageUrl as imageUrl\" class=\"image-container\">\n          <img [src]=\"imageUrl\" alt=\"image of {{chip.label}}\">\n        </span>\n        {{chip.label}}\n        <mat-icon\n          matChipRemove\n          *ngIf=\"config.areChipsRemovable\">\n          cancel\n        </mat-icon>\n      </mat-chip>\n      <input class=\"hidden-error-directive-anchor\" [formControlName]=\"config.controlName\" type=\"text\"/>\n\n      <input\n        matInput\n        [formControl]=\"autocompleteInputControl\"\n        [placeholder]=\"config.placeholder\"\n        [matChipInputFor]=\"chipList\"\n        [matAutocomplete]=\"auto\"\n        (keydown.tab)=\"handleTab($event)\"\n        [matChipInputSeparatorKeyCodes]=\"config.separatorKeyCodes\"\n        (matChipInputTokenEnd)=\"handleTokenEnd($event)\"\n        role=\"searchbox\"\n        type=\"text\"\n        autocapitalize=\"off\"\n        autocorrect=\"off\"\n        spellcheck=\"false\"\n        #autoInput/>\n      <span *ngIf=\"config.fieldSuffix\" matSuffix>{{config.fieldSuffix}}</span>\n      <crispr-info\n        *ngIf=\"config.info\"\n        matSuffix\n        [info]=\"config.info \">\n      </crispr-info>\n\n    </mat-chip-list>\n    <mat-autocomplete\n      #auto=\"matAutocomplete\"\n      [autoActiveFirstOption]=\"this.config.autoActiveFirstOption\"\n      (optionSelected)=\"handleSelect($event)\"\n      [displayWith]=\"mapToLabel\">\n      <ng-container *ngIf=\"remainingOptions$ | async as remainingOptions; else emptyOption\">\n        <ng-container *ngIf=\"remainingOptions.length > 0; else emptyOption\">\n           <mat-option\n            *ngFor=\"let option of remainingOptions$ | async\"\n            [value]=\"option\">\n            <crispr-option [option]=\"option\"></crispr-option>\n          </mat-option>\n        </ng-container>\n\n      </ng-container>\n      <ng-template #emptyOption>\n        <mat-option disabled=\"true\">\n          {{config.emptyOptionsMessage}}\n        </mat-option>\n      </ng-template>\n    </mat-autocomplete>\n\n\n  </mat-form-field>\n</crispr-field-container>\n", styles: [".refinement-chip .image-container{width:26px;height:26px;border-radius:50%;overflow:hidden;margin:-2px 4px -2px -8px}.refinement-chip .image-container img{width:100%;height:100%;object-fit:cover}.hidden-error-directive-anchor{display:none}\n"], components: [{ type: FieldContainerComponent, selector: "crispr-field-container", inputs: ["config", "group", "inlineField"] }, { type: i2$1.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: i3$2.MatChipList, selector: "mat-chip-list", inputs: ["errorStateMatcher", "multiple", "compareWith", "value", "required", "placeholder", "disabled", "aria-orientation", "selectable", "tabIndex"], outputs: ["change", "valueChange"], exportAs: ["matChipList"] }, { type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: InfoComponent, selector: "crispr-info", inputs: ["info"] }, { type: i4$3.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i5$1.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: OptionComponent, selector: "crispr-option", inputs: ["option"] }], directives: [{ type: i4$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i4$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i5.ControlErrorContainerDirective, selector: "[controlErrorContainer], [formGroup]" }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2$1.MatLabel, selector: "mat-label" }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3$2.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["color", "disableRipple", "tabIndex", "selected", "value", "selectable", "disabled", "removable"], outputs: ["selectionChange", "destroyed", "removed"], exportAs: ["matChip"] }, { type: i3$2.MatChipRemove, selector: "[matChipRemove]" }, { type: i4$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i4$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4$1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { type: i5.ControlErrorsDirective, selector: "[formControl], [formControlName]" }, { type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i3$2.MatChipInput, selector: "input[matChipInputFor]", inputs: ["matChipInputFor", "matChipInputAddOnBlur", "matChipInputSeparatorKeyCodes", "placeholder", "id", "disabled"], outputs: ["matChipInputTokenEnd"], exportAs: ["matChipInput", "matChipInputFor"] }, { type: i4$3.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i4$1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i2$1.MatSuffix, selector: "[matSuffix]" }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush, preserveWhitespaces: true });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AutocompleteChiplistFieldComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'crispr-autocomplete-chiplist-field', changeDetection: ChangeDetectionStrategy.OnPush, template: "<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\">\n    <mat-label *ngIf=\"config.label\">\n      {{config.label}}\n    </mat-label>\n\n    <mat-chip-list\n      #chipList>\n      <mat-chip\n        class=\"refinement-chip\"\n        *ngFor=\"let chip of controlValue$ | async\"\n        [selectable]=\"config.chipsSelectable\"\n        [removable]=\"config.areChipsRemovable\"\n        (removed)=\"removeChip(chip)\">\n        <span *ngIf=\"chip.imageUrl as imageUrl\" class=\"image-container\">\n          <img [src]=\"imageUrl\" alt=\"image of {{chip.label}}\">\n        </span>\n        {{chip.label}}\n        <mat-icon\n          matChipRemove\n          *ngIf=\"config.areChipsRemovable\">\n          cancel\n        </mat-icon>\n      </mat-chip>\n\n      <input\n        matInput\n        [formControl]=\"autocompleteInputControl\"\n        [placeholder]=\"config.placeholder\"\n        [matChipInputFor]=\"chipList\"\n        [matAutocomplete]=\"auto\"\n        (keydown.tab)=\"handleTab($event)\"\n        [matChipInputSeparatorKeyCodes]=\"config.separatorKeyCodes\"\n        (matChipInputTokenEnd)=\"handleTokenEnd($event)\"\n        role=\"searchbox\"\n        type=\"text\"\n        autocapitalize=\"off\"\n        autocorrect=\"off\"\n        spellcheck=\"false\"\n        #autoInput/>\n      <span *ngIf=\"config.fieldSuffix\" matSuffix>{{config.fieldSuffix}}</span>\n      <crispr-info\n        *ngIf=\"config.info\"\n        matSuffix\n        [info]=\"config.info \">\n      </crispr-info>\n\n    </mat-chip-list>\n    <mat-autocomplete\n      #auto=\"matAutocomplete\"\n      [autoActiveFirstOption]=\"this.config.autoActiveFirstOption\"\n      (optionSelected)=\"handleSelect($event)\"\n      [displayWith]=\"mapToLabel\">\n      <ng-container *ngIf=\"remainingOptions$ | async as remainingOptions; else emptyOption\">\n        <ng-container *ngIf=\"remainingOptions.length > 0; else emptyOption\">\n           <mat-option\n            *ngFor=\"let option of remainingOptions$ | async\"\n            [value]=\"option\">\n            <crispr-option [option]=\"option\"></crispr-option>\n          </mat-option>\n        </ng-container>\n\n      </ng-container>\n      <ng-template #emptyOption>\n        <mat-option disabled=\"true\">\n          {{config.emptyOptionsMessage}}\n        </mat-option>\n      </ng-template>\n    </mat-autocomplete>\n\n\n  </mat-form-field>\n</crispr-field-container>\n", styles: [".refinement-chip .image-container{width:26px;height:26px;border-radius:50%;overflow:hidden;margin:-2px 4px -2px -8px}.refinement-chip .image-container img{width:100%;height:100%;object-fit:cover}\n"] }]
+            args: [{ selector: 'crispr-autocomplete-chiplist-field', changeDetection: ChangeDetectionStrategy.OnPush, template: "<crispr-field-container\n  [config]=\"config\"\n  [group]=\"group\">\n\n  <mat-form-field\n    [color]=\"config.color\"\n    [appearance]=\"config.appearance\"\n    [formGroup]=\"group\">\n    <mat-label *ngIf=\"config.label\">\n      {{config.label}}\n    </mat-label>\n\n    <mat-chip-list\n      #chipList>\n      <mat-chip\n        class=\"refinement-chip\"\n        *ngFor=\"let chip of controlValue$ | async\"\n        [selectable]=\"config.chipsSelectable\"\n        [removable]=\"config.areChipsRemovable\"\n        (removed)=\"removeChip(chip)\">\n        <span *ngIf=\"chip.imageUrl as imageUrl\" class=\"image-container\">\n          <img [src]=\"imageUrl\" alt=\"image of {{chip.label}}\">\n        </span>\n        {{chip.label}}\n        <mat-icon\n          matChipRemove\n          *ngIf=\"config.areChipsRemovable\">\n          cancel\n        </mat-icon>\n      </mat-chip>\n      <input class=\"hidden-error-directive-anchor\" [formControlName]=\"config.controlName\" type=\"text\"/>\n\n      <input\n        matInput\n        [formControl]=\"autocompleteInputControl\"\n        [placeholder]=\"config.placeholder\"\n        [matChipInputFor]=\"chipList\"\n        [matAutocomplete]=\"auto\"\n        (keydown.tab)=\"handleTab($event)\"\n        [matChipInputSeparatorKeyCodes]=\"config.separatorKeyCodes\"\n        (matChipInputTokenEnd)=\"handleTokenEnd($event)\"\n        role=\"searchbox\"\n        type=\"text\"\n        autocapitalize=\"off\"\n        autocorrect=\"off\"\n        spellcheck=\"false\"\n        #autoInput/>\n      <span *ngIf=\"config.fieldSuffix\" matSuffix>{{config.fieldSuffix}}</span>\n      <crispr-info\n        *ngIf=\"config.info\"\n        matSuffix\n        [info]=\"config.info \">\n      </crispr-info>\n\n    </mat-chip-list>\n    <mat-autocomplete\n      #auto=\"matAutocomplete\"\n      [autoActiveFirstOption]=\"this.config.autoActiveFirstOption\"\n      (optionSelected)=\"handleSelect($event)\"\n      [displayWith]=\"mapToLabel\">\n      <ng-container *ngIf=\"remainingOptions$ | async as remainingOptions; else emptyOption\">\n        <ng-container *ngIf=\"remainingOptions.length > 0; else emptyOption\">\n           <mat-option\n            *ngFor=\"let option of remainingOptions$ | async\"\n            [value]=\"option\">\n            <crispr-option [option]=\"option\"></crispr-option>\n          </mat-option>\n        </ng-container>\n\n      </ng-container>\n      <ng-template #emptyOption>\n        <mat-option disabled=\"true\">\n          {{config.emptyOptionsMessage}}\n        </mat-option>\n      </ng-template>\n    </mat-autocomplete>\n\n\n  </mat-form-field>\n</crispr-field-container>\n", styles: [".refinement-chip .image-container{width:26px;height:26px;border-radius:50%;overflow:hidden;margin:-2px 4px -2px -8px}.refinement-chip .image-container img{width:100%;height:100%;object-fit:cover}.hidden-error-directive-anchor{display:none}\n"] }]
         }], propDecorators: { chipInput: [{
                 type: ViewChild,
                 args: ['autoInput', { read: MatAutocompleteTrigger }]
@@ -1137,7 +1138,6 @@ function convertBytesToMb(bytes) {
 
 const ImageUploadFieldMixin = crisprControlMixin(CrisprFieldComponent);
 class ImageUploadFieldComponent extends ImageUploadFieldMixin {
-    // ngControl: NgControl = null;
     constructor(ngControl, domSanitizer, cdr) {
         super();
         this.ngControl = ngControl;
@@ -1158,42 +1158,50 @@ class ImageUploadFieldComponent extends ImageUploadFieldMixin {
             minCompressionThresholdMb: .6,
             useWebWorker: true,
         };
+        /**
+         * The url mapped from initial input value, consumers can us mapInputValueToUrl in config to transform their input value into a src url for the image element
+         */
+        // inputValueUrl: string | undefined;
         this.inputImageFileSubject = new Subject();
         this.inputImageFile$ = this.inputImageFileSubject.asObservable().pipe(shareReplay(1));
         this.compressedFile$ = this.inputImageFile$.pipe(switchMap((file) => __awaiter(this, void 0, void 0, function* () {
-            if (!file)
+            if (!file || !(file instanceof File))
                 return null;
-            if (typeof file === 'string')
-                return file;
             const { compressImage, targetCompressedImageFileSizeMb, minCompressionThresholdMb, maxWidthOrHeight, useWebWorker } = this.config;
             const fileSizeMb = convertBytesToMb(file.size);
-            const shouldCompress = compressImage && targetCompressedImageFileSizeMb < fileSizeMb && minCompressionThresholdMb < fileSizeMb;
+            const shouldCompress = compressImage
+                && targetCompressedImageFileSizeMb < fileSizeMb
+                && minCompressionThresholdMb < fileSizeMb;
             if (shouldCompress) {
-                const options = Object.assign(Object.assign({}, (maxWidthOrHeight ? { maxWidthOrHeight } : { maxSizeMB: targetCompressedImageFileSizeMb })), { useWebWorker, maxIterations: 30, onProgress: (p) => {
-                        this.progress = p;
+                const options = Object.assign(Object.assign({}, (maxWidthOrHeight ? { maxWidthOrHeight } : { maxSizeMB: targetCompressedImageFileSizeMb })), { useWebWorker, maxIterations: 30, onProgress: (progress) => {
+                        this.progress = progress;
                         this.cdr.detectChanges();
                     } });
                 return yield imageCompression(file, options);
             }
             else
                 return file;
-        })), map((compressedFileOrString) => {
-            if (!compressedFileOrString || typeof compressedFileOrString === 'string')
-                return compressedFileOrString;
-            const { type, name, lastModified } = compressedFileOrString;
-            return new File([compressedFileOrString], this.config.fileName || name, {
+        })), map((compressedFile) => {
+            if (!compressedFile)
+                return compressedFile;
+            const { type, name, lastModified } = compressedFile;
+            return new File([compressedFile], this.config.fileName || name, {
                 type,
                 lastModified
             });
         }), tap(file => {
-            this.control.setValue(file);
+            // only set the value if there is a file because resetToInitialValue sets the control value
+            // to initial value and clears the compressed image, so setting it to null here would undo that
+            if (file) {
+                this.control.setValue(file);
+            }
             if (file || this.value) {
                 this.control.markAsTouched();
                 setTimeout(() => {
                     this.cdr.detectChanges();
                 }, 100);
             }
-        }), map(file => typeof file === 'string' ? null : file), shareReplay(1));
+        }), shareReplay(1));
         this.compressedImageUrlString$ = this.compressedFile$.pipe(switchMap((file) => __awaiter(this, void 0, void 0, function* () {
             if (!file)
                 return null;
@@ -1209,11 +1217,19 @@ class ImageUploadFieldComponent extends ImageUploadFieldMixin {
     }
     ngOnInit() {
         super.ngOnInit();
+        // this.inputValueUrl = this.value && this.config.mapInputValueToUrl?.(this.value) || this.value;
         this.imageSrcUrl$ = combineLatest([
             this.compressedImageUrlString$.pipe(startWith(null)),
-            this.control.valueChanges.pipe(startWith(this.value))
+            this.control.valueChanges.pipe(startWith(this.value), map((controlValue) => {
+                var _a, _b;
+                if (!controlValue)
+                    return null;
+                if (controlValue instanceof File)
+                    return null;
+                return ((_b = (_a = this.config).mapInputValueToUrl) === null || _b === void 0 ? void 0 : _b.call(_a, controlValue)) || controlValue;
+            }))
         ]).pipe(map(([compressedImageUrlString, controlUrl]) => {
-            return compressedImageUrlString || typeof controlUrl === 'string' && controlUrl || null;
+            return compressedImageUrlString || controlUrl || null;
         }));
         this.disabled$ = this.config.disabledCallback
             ? this.config.disabledCallback(this.group, this.config)
@@ -1222,6 +1238,10 @@ class ImageUploadFieldComponent extends ImageUploadFieldMixin {
     filesChanged(files) {
         if (files && files.length > 0) {
             const imageFile = files[0];
+            // We clear the control here so that it is invalid while compressing
+            // the input pipeline will take care of resetting it
+            this.control.patchValue(null);
+            // this.control.setErrors({compressing: {loadingMessage: 'Please wait while file compresses'}});
             this.control.markAsTouched();
             this.inputImageFileSubject.next(imageFile);
         }
@@ -1234,8 +1254,8 @@ class ImageUploadFieldComponent extends ImageUploadFieldMixin {
         this.isUploaded = false;
     }
     resetToInitialValue(initialValue) {
-        this.inputImageFileSubject.next(initialValue);
-        // this.fileInputRef.nativeElement.value = initialValue
+        this.inputImageFileSubject.next(null);
+        this.control.patchValue(initialValue);
         this.isUploaded = false;
     }
     writeValue(value) { }
@@ -1316,7 +1336,6 @@ function maxFileSizeValidator(maxFileSize) {
         const actualFileSize = +convertBytesToMb(controlValue.size).toPrecision(3);
         if (maxFileSize > actualFileSize)
             return null;
-        // control.setErrors({maxFileSize: { maxFileSize, actualFileSize }} )
         return { maxFileSize: { maxFileSize, actualFileSize } };
     };
 }
@@ -1326,7 +1345,7 @@ function allowedFileExtValidator(allowedFileExtensions, onlyAllowFiles = true) {
         const isFile = controlValue instanceof File;
         if (!onlyAllowFiles && !isFile)
             return null;
-        const actualExtension = isFile ? controlValue.name.split('.').pop() : 'Not a file';
+        const actualExtension = isFile ? controlValue.name.split('.').pop().toLocaleLowerCase() : 'Not a file';
         const isAllowedExtension = allowedFileExtensions.includes(actualExtension);
         if (isAllowedExtension) {
             return null;