@ks89/angular-modal-gallery 8.0.0-rc.1 → 9.0.1

package/esm2020/lib/components/modal-gallery/modal-gallery.component.mjs

@@ -0,0 +1,523 @@
+import { ChangeDetectionStrategy, Component, HostListener, Inject, PLATFORM_ID, SecurityContext, ViewChild } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { DIALOG_DATA } from './modal-gallery.tokens';
+import { ImageModalEvent } from '../../model/image.class';
+import { ButtonType } from '../../model/buttons-config.interface';
+import { Action } from '../../model/action.enum';
+import { CurrentImageComponent } from '../current-image/current-image.component';
+import { KS_DEFAULT_ACCESSIBILITY_CONFIG } from '../accessibility-default';
+import * as i0 from "@angular/core";
+import * as i1 from "./modal-gallery.service";
+import * as i2 from "../../services/keyboard.service";
+import * as i3 from "../../services/id-validator.service";
+import * as i4 from "../../services/config.service";
+import * as i5 from "@angular/platform-browser";
+import * as i6 from "../upper-buttons/upper-buttons.component";
+import * as i7 from "../current-image/current-image.component";
+import * as i8 from "../dots/dots.component";
+import * as i9 from "../previews/previews.component";
+import * as i10 from "../../directives/click-outside.directive";
+export class ModalGalleryComponent {
+    constructor(dialogContent, modalGalleryService, keyboardService, 
+    // tslint:disable-next-line:ban-types
+    platformId, changeDetectorRef, idValidatorService, configService, sanitizer) {
+        this.dialogContent = dialogContent;
+        this.modalGalleryService = modalGalleryService;
+        this.keyboardService = keyboardService;
+        this.platformId = platformId;
+        this.changeDetectorRef = changeDetectorRef;
+        this.idValidatorService = idValidatorService;
+        this.configService = configService;
+        this.sanitizer = sanitizer;
+        /**
+         * Boolean to enable modal-gallery close behaviour when clicking
+         * on the semi-transparent background. Enabled by default.
+         */
+        this.enableCloseOutside = true;
+        /**
+         * Object of type `AccessibilityConfig` to init custom accessibility features.
+         * For instance, it contains titles, alt texts, aria-labels and so on.
+         */
+        this.accessibilityConfig = KS_DEFAULT_ACCESSIBILITY_CONFIG;
+        /**
+         * Boolean to open the modal gallery. False by default.
+         */
+        this.showGallery = false;
+        this.id = this.dialogContent.id;
+        this.images = this.dialogContent.images;
+        this.currentImage = this.dialogContent.currentImage;
+        this.libConfig = this.dialogContent.libConfig;
+        this.configService.setConfig(this.id, this.libConfig);
+        this.updateImagesSubscription = this.modalGalleryService.updateImages$.subscribe((images) => {
+            this.images = images.map((image) => {
+                const newImage = Object.assign({}, image, { previouslyLoaded: false });
+                return newImage;
+            });
+            this.initImages();
+            this.images.forEach((image) => {
+                if (image.id === this.currentImage.id) {
+                    this.currentImage = image;
+                }
+            });
+            this.changeDetectorRef.markForCheck();
+        });
+    }
+    /**
+     * HostListener to catch browser's back button and destroy the gallery.
+     * This prevents weired behaviour about scrolling.
+     * Added to fix this issue: https://github.com/Ks89/angular-modal-gallery/issues/159
+     */
+    onPopState(e) {
+        this.closeGallery();
+    }
+    /**
+     * Method ´ngOnInit´ to init images calling `initImages()`.
+     * This is an Angular's lifecycle hook, so its called automatically by Angular itself.
+     * In particular, it's called only one time!!!
+     */
+    ngOnInit() {
+        this.idValidatorService.checkAndAdd(this.id);
+        // id is a mandatory input and must a number > 0
+        if ((!this.id && this.id !== 0) || this.id < 0) {
+            throw new Error(`'[id]="a number >= 0"' is a mandatory input in angular-modal-gallery.` +
+                `If you are using multiple instances of this library, please be sure to use different ids`);
+        }
+        const libConfig = this.configService.getConfig(this.id);
+        if (!libConfig || !libConfig.dotsConfig) {
+            throw new Error('Internal library error - libConfig and dotsConfig must be defined');
+        }
+        this.dotsConfig = libConfig.dotsConfig;
+        this.registerKeyboardService();
+        setTimeout(() => {
+            this.initImages();
+        }, 0);
+    }
+    /**
+     * Method called by custom upper buttons.
+     * @param event ButtonEvent event payload
+     */
+    onCustomEmit(event) {
+        const eventToEmit = this.getButtonEventToEmit(event);
+        this.modalGalleryService.emitButtonBeforeHook(eventToEmit);
+        this.modalGalleryService.emitButtonAfterHook(eventToEmit);
+    }
+    /**
+     * Method called by the full-screen upper button.
+     * @param event ButtonEvent event payload
+     */
+    onFullScreen(event) {
+        const eventToEmit = this.getButtonEventToEmit(event);
+        this.modalGalleryService.emitButtonBeforeHook(eventToEmit);
+        // tslint:disable-next-line:no-any
+        const doc = document;
+        // tslint:disable-next-line:no-any
+        const docEl = document.documentElement;
+        const fullscreenDisabled = !doc.fullscreenElement && !doc.webkitFullscreenElement;
+        // In Safari `requestFullscreen` and `exitFullscreen` are undefined. Safari requires the prefixed version `webkit-`
+        // and it doesn't return promises.
+        // I cannot call `emitButtonAfterHook` only if requestFullScreen is successful, because there are no guarantees across browsers and
+        // I should also handle the case with keyboard "esc" button.
+        if (fullscreenDisabled) {
+            if (docEl.requestFullscreen) {
+                docEl.requestFullscreen()
+                    .then(() => {
+                })
+                    .catch(() => {
+                    console.error('Cannot request full screen');
+                });
+            }
+            else if (docEl.webkitRequestFullscreen) {
+                // For Safari and it doesn't return a promise
+                docEl.webkitRequestFullscreen();
+            }
+        }
+        else {
+            if (doc.exitFullscreen) {
+                doc.exitFullscreen()
+                    .then(() => {
+                })
+                    .catch(() => {
+                    console.error('Cannot request exit full screen');
+                });
+            }
+            else if (doc.webkitExitFullscreen) {
+                // For Safari and it doesn't return a promise
+                doc.webkitExitFullscreen();
+            }
+        }
+        this.modalGalleryService.emitButtonAfterHook(eventToEmit);
+    }
+    /**
+     * Method called by the delete upper button.
+     * @param event ButtonEvent event payload
+     */
+    onDelete(event) {
+        const eventToEmit = this.getButtonEventToEmit(event);
+        this.modalGalleryService.emitButtonBeforeHook(eventToEmit);
+        if (this.images.length === 1) {
+            this.closeGallery();
+        }
+        if (!this.currentImageComponent) {
+            throw new Error('currentImageComponent must be defined');
+        }
+        const imageIndexToDelete = this.currentImageComponent.getIndexToDelete(event.image);
+        if (imageIndexToDelete === this.images.length - 1) {
+            // last image
+            this.currentImageComponent.prevImage();
+        }
+        else {
+            this.currentImageComponent.nextImage();
+        }
+        this.modalGalleryService.emitButtonAfterHook(eventToEmit);
+    }
+    /**
+     * Method called by the navigate upper button.
+     * @param event ButtonEvent event payload
+     */
+    onNavigate(event) {
+        const eventToEmit = this.getButtonEventToEmit(event);
+        this.modalGalleryService.emitButtonBeforeHook(eventToEmit);
+        // To support SSR
+        if (isPlatformBrowser(this.platformId)) {
+            if (eventToEmit.image && eventToEmit.image.modal.extUrl) {
+                // where I should open this link? The current tab or another one?
+                if (eventToEmit.button && eventToEmit.button.extUrlInNewTab) {
+                    // in this case I should use target _blank to open the url in a new tab, however these is a security issue.
+                    // Prevent Reverse Tabnabbing's attacks (https://www.owasp.org/index.php/Reverse_Tabnabbing)
+                    // Some resources:
+                    // - https://www.owasp.org/index.php/HTML5_Security_Cheat_Sheet#Tabnabbing
+                    // - https://medium.com/@jitbit/target-blank-the-most-underestimated-vulnerability-ever-96e328301f4c
+                    // - https://developer.mozilla.org/en-US/docs/Web/API/Window/open
+                    const newWindow = window.open(eventToEmit.image.modal.extUrl, 'noopener,noreferrer,');
+                    // it returns null if the call failed, so I have to do this check
+                    if (newWindow) {
+                        newWindow.opener = null; // required to prevent security issues
+                        // emit only in case of success
+                        this.modalGalleryService.emitButtonAfterHook(eventToEmit);
+                    }
+                }
+                else {
+                    this.updateLocationHref(eventToEmit.image.modal.extUrl);
+                    // emit only in case of success
+                    this.modalGalleryService.emitButtonAfterHook(eventToEmit);
+                }
+            }
+        }
+    }
+    /**
+     * This method is defined to be spied and replaced in unit testing with a fake method call.
+     * It must be public to be able to use jasmine spyOn method.
+     * @param newHref string new url
+     */
+    updateLocationHref(newHref) {
+        window.location.href = newHref;
+    }
+    /**
+     * Method called by the download upper button.
+     * @param event ButtonEvent event payload
+     */
+    onDownload(event) {
+        const eventToEmit = this.getButtonEventToEmit(event);
+        this.modalGalleryService.emitButtonBeforeHook(eventToEmit);
+        this.downloadImage();
+        this.modalGalleryService.emitButtonAfterHook(eventToEmit);
+    }
+    /**
+     * Method called by the close upper button.
+     * @param event ButtonEvent event payload
+     * @param action Action that triggered the close method. `Action.NORMAL` by default
+     */
+    onCloseGalleryButton(event, action = Action.NORMAL) {
+        const eventToEmit = this.getButtonEventToEmit(event);
+        this.modalGalleryService.emitButtonBeforeHook(eventToEmit);
+        this.closeGallery(action, false);
+    }
+    /**
+     * Method called by CurrentImageComponent and triggered via KeyboardService.
+     * @param event ImageModalEvent event payload
+     * @param action Action that triggered the close method. `Action.NORMAL` by default
+     */
+    onCloseGallery(event, action = Action.NORMAL) {
+        // remap ImageModalEvent to ButtonEvent
+        const buttonEvent = {
+            button: {
+                type: ButtonType.CLOSE
+            },
+            image: null,
+            action: event.action,
+            galleryId: event.galleryId
+        };
+        this.modalGalleryService.emitButtonBeforeHook(buttonEvent);
+        this.closeGallery(action, false);
+    }
+    /**
+     * Method to close the modal gallery specifying the action.
+     * It also reset the `keyboardService` to prevent multiple listeners.
+     * @param action Action action type. `Action.NORMAL` by default
+     * @param clickOutside boolean that is true if called clicking on the modal background. False by default.
+     */
+    closeGallery(action = Action.NORMAL, clickOutside = false) {
+        const libConfig = this.configService.getConfig(this.id);
+        if (!libConfig) {
+            throw new Error('Internal library error - libConfig must be defined');
+        }
+        this.modalGalleryService.emitClose(new ImageModalEvent(this.id, action, true));
+        this.keyboardService.reset(libConfig);
+        this.modalGalleryService.close(this.id, clickOutside);
+    }
+    /**
+     * Method called when the image changes and used to update the `currentImage` object.
+     * @param event ImageModalEvent event payload
+     */
+    onChangeCurrentImage(event) {
+        const newIndex = event.result;
+        if (newIndex < 0 || newIndex >= this.images.length) {
+            return;
+        }
+        this.currentImage = this.images[newIndex];
+        // emit current visible image index
+        this.modalGalleryService.emitShow(new ImageModalEvent(this.id, event.action, newIndex + 1));
+        // emit first/last event based on newIndex value
+        this.emitBoundaryEvent(event.action, newIndex);
+    }
+    /**
+     * Method called when you click 'outside' (i.e. on the semi-transparent background)
+     * to close the modal gallery if `enableCloseOutside` is true.
+     * @param event boolean that is true to close the modal gallery, false otherwise
+     */
+    onClickOutside(event) {
+        if (event && this.enableCloseOutside) {
+            this.closeGallery(Action.CLICK, true);
+        }
+    }
+    /**
+     * Method called when an image is loaded and the loading spinner has gone.
+     * It sets the previouslyLoaded flag inside the Image to hide loading spinner when displayed again.
+     * @param event ImageLoadEvent event payload
+     */
+    onImageLoad(event) {
+        // sets as previously loaded the image with index specified by `event.status`
+        this.images = this.images.map((img) => {
+            if (img && img.id === event.id) {
+                return Object.assign({}, img, { previouslyLoaded: event.status });
+            }
+            return img;
+        });
+    }
+    /**
+     * Method called when a dot is clicked and used to update the current image.
+     * @param index number index of the clicked dot
+     */
+    onClickDot(index) {
+        this.currentImage = this.images[index];
+    }
+    /**
+     * Method called when an image preview is clicked and used to update the current image.
+     * @param event ImageModalEvent preview image
+     */
+    onClickPreview(event) {
+        this.onChangeCurrentImage(event);
+    }
+    /**
+     * Method to cleanup resources. In fact, this will reset keyboard's service.
+     * This is an Angular's lifecycle hook that is called when this component is destroyed.
+     */
+    ngOnDestroy() {
+        if (this.keyboardService) {
+            const libConfig = this.configService.getConfig(this.id);
+            if (this.id && libConfig) {
+                this.keyboardService.reset(libConfig);
+            }
+        }
+        if (this.updateImagesSubscription) {
+            this.updateImagesSubscription.unsubscribe();
+        }
+        this.idValidatorService.remove(this.id);
+    }
+    /**
+     * Method to show the modal gallery displaying the currentImage.
+     * It will also register a new `keyboardService` to catch keyboard's events to download the current
+     * image with keyboard's shortcuts. This service, will be removed either when modal gallery component
+     * will be destroyed or when the gallery is closed invoking the `closeGallery` method.
+     * @private
+     */
+    registerKeyboardService() {
+        if (this.id === null || this.id === undefined) {
+            throw new Error('Internal library error - id must be defined');
+        }
+        const libConfig = this.configService.getConfig(this.id);
+        if (!libConfig) {
+            throw new Error('Internal library error - libConfig must be defined');
+        }
+        this.keyboardService.init(libConfig).then(() => {
+            this.keyboardService.add((event, combo) => {
+                if (event.preventDefault) {
+                    event.preventDefault();
+                }
+                else {
+                    // internet explorer
+                    event.returnValue = false;
+                }
+                this.downloadImage();
+            }, libConfig);
+        });
+    }
+    /**
+     * Method to download the current image, only if `downloadable` is true.
+     * @private
+     */
+    downloadImage() {
+        if (this.id === null || this.id === undefined) {
+            throw new Error('Internal library error - id must be defined');
+        }
+        const libConfig = this.configService.getConfig(this.id);
+        if (!libConfig) {
+            throw new Error('Internal library error - libConfig must be defined');
+        }
+        const currentImageConfig = libConfig.currentImageConfig;
+        if (currentImageConfig && !currentImageConfig.downloadable) {
+            return;
+        }
+        this.downloadImageAllBrowsers();
+    }
+    /**
+     * Method to convert a base64 to a Blob
+     * @param base64Data string with base64 data
+     * @param contentType string with the MIME type
+     * @return Blob converted from the input base64Data
+     * @private
+     */
+    base64toBlob(base64Data, contentType = '') {
+        const sliceSize = 1024;
+        const byteCharacters = atob(base64Data);
+        const bytesLength = byteCharacters.length;
+        const slicesCount = Math.ceil(bytesLength / sliceSize);
+        const byteArrays = new Array(slicesCount);
+        for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+            const begin = sliceIndex * sliceSize;
+            const end = Math.min(begin + sliceSize, bytesLength);
+            const bytes = new Array(end - begin);
+            for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+                bytes[i] = byteCharacters[offset].charCodeAt(0);
+            }
+            byteArrays[sliceIndex] = new Uint8Array(bytes);
+        }
+        return new Blob(byteArrays, { type: contentType });
+    }
+    /**
+     * Private method to download the current image for all browsers.
+     * @private
+     */
+    downloadImageAllBrowsers() {
+        const link = document.createElement('a');
+        let isBase64 = false;
+        let img;
+        // convert a SafeResourceUrl to a string
+        if (typeof this.currentImage.modal.img === 'string') {
+            img = this.currentImage.modal.img;
+        }
+        else {
+            // if it's a SafeResourceUrl
+            img = this.sanitizer.sanitize(SecurityContext.RESOURCE_URL, this.currentImage.modal.img);
+        }
+        if (img.includes('data:image/') || img.includes(';base64,')) {
+            const extension = img.replace('data:image/', '').split(';base64,')[0];
+            const pureBase64 = img.split(';base64,')[1];
+            const blob = this.base64toBlob(pureBase64, 'image/' + extension);
+            link.href = URL.createObjectURL(blob);
+            isBase64 = true;
+            link.setAttribute('download', this.getFileName(this.currentImage, isBase64, extension));
+        }
+        else {
+            link.href = img;
+            link.setAttribute('download', this.getFileName(this.currentImage, isBase64));
+        }
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }
+    /**
+     * Private method to get the `ButtonEvent` to emit, merging the input `ButtonEvent`
+     * with the current image.
+     * @param event ButtonEvent event payload to return
+     * @returns ButtonEvent event payload with the current image included
+     * @private
+     */
+    getButtonEventToEmit(event) {
+        return Object.assign(event, { image: this.currentImage });
+    }
+    /**
+     * Private method to get the file name from an input path.
+     * This is used either to get the image's name from its path or from the Image itself,
+     * if specified as 'downloadFileName' by the user.
+     * @param image Image image to extract its file name
+     * @param isBase64 boolean to set if the image is a base64 file or not. False by default.
+     * @param base64Extension string to force the extension of the base64 image. Empty string by default.
+     * @returns string string file name of the input image.
+     * @private
+     */
+    getFileName(image, isBase64 = false, base64Extension = '') {
+        if (!image.modal.downloadFileName || image.modal.downloadFileName.length === 0) {
+            if (isBase64) {
+                return `Image-${image.id}.${base64Extension !== '' ? base64Extension : 'png'}`;
+            }
+            else {
+                return image.modal.img.replace(/^.*[\\\/]/, '');
+            }
+        }
+        else {
+            return image.modal.downloadFileName;
+        }
+    }
+    /**
+     * Private method to initialize `images` as array of `Image`s.
+     * Also, it will emit ImageModalEvent to say that images are loaded.
+     * @private
+     */
+    initImages() {
+        this.modalGalleryService.emitHasData(new ImageModalEvent(this.id, Action.LOAD, true));
+        const currentIndex = this.images.indexOf(this.currentImage);
+        // emit a new ImageModalEvent with the index of the current image
+        this.modalGalleryService.emitShow(new ImageModalEvent(this.id, Action.LOAD, currentIndex + 1));
+        // emit first/last event based on newIndex value
+        this.emitBoundaryEvent(Action.NORMAL, currentIndex);
+        this.showGallery = this.images.length > 0;
+    }
+    /**
+     * Private method to emit events when either the last or the first image are visible.
+     * @param action Action Enum of type Action that represents the source of the event that changed the
+     *  current image to the first one or the last one.
+     * @param indexToCheck number is the index number of the image (the first or the last one).
+     * @private
+     */
+    emitBoundaryEvent(action, indexToCheck) {
+        // to emit first/last event
+        switch (indexToCheck) {
+            case 0:
+                this.modalGalleryService.emitFirstImage(new ImageModalEvent(this.id, action, true));
+                break;
+            case this.images.length - 1:
+                this.modalGalleryService.emitLastImage(new ImageModalEvent(this.id, action, true));
+                break;
+        }
+    }
+}
+ModalGalleryComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ModalGalleryComponent, deps: [{ token: DIALOG_DATA }, { token: i1.ModalGalleryService }, { token: i2.KeyboardService }, { token: PLATFORM_ID }, { token: i0.ChangeDetectorRef }, { token: i3.IdValidatorService }, { token: i4.ConfigService }, { token: i5.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component });
+ModalGalleryComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ModalGalleryComponent, selector: "ks-modal-gallery", host: { listeners: { "window:popstate": "onPopState($event)" } }, viewQueries: [{ propertyName: "currentImageComponent", first: true, predicate: CurrentImageComponent, descendants: true, static: true }], ngImport: i0, template: "<div id=\"modal-gallery-wrapper\"\n     [attr.aria-label]=\"accessibilityConfig.modalGalleryContentAriaLabel\"\n     [title]=\"accessibilityConfig.modalGalleryContentTitle\"\n     ksClickOutside [clickOutsideEnable]=\"enableCloseOutside\"\n     (clickOutside)=\"onClickOutside($event)\">\n\n  <div id=\"flex-min-height-ie-fix\">\n    <div id=\"modal-gallery-container\">\n\n      <ks-upper-buttons [id]=\"id\"\n                        [currentImage]=\"currentImage\"\n                        (delete)=\"onDelete($event)\"\n                        (navigate)=\"onNavigate($event)\"\n                        (download)=\"onDownload($event)\"\n                        (closeButton)=\"onCloseGalleryButton($event)\"\n                        (fullscreen)=\"onFullScreen($event)\"\n                        (customEmit)=\"onCustomEmit($event)\"></ks-upper-buttons>\n\n      <ks-current-image [id]=\"id\"\n                        [images]=\"images\"\n                        [currentImage]=\"currentImage\"\n                        [isOpen]=\"true\"\n                        (loadImage)=\"onImageLoad($event)\"\n                        (changeImage)=\"onChangeCurrentImage($event)\"\n                        (closeGallery)=\"onCloseGallery($event)\"></ks-current-image>\n\n      <div>\n        <ks-dots [id]=\"id\"\n                 [images]=\"images\"\n                 [currentImage]=\"currentImage\"\n                 [dotsConfig]=\"dotsConfig\"\n                 (clickDot)=\"onClickDot($event)\"></ks-dots>\n\n        <ks-previews [id]=\"id\"\n                     [images]=\"images\"\n                     [currentImage]=\"currentImage\"\n                     (clickPreview)=\"onClickPreview($event)\"></ks-previews>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: ["#flex-min-height-ie-fix{display:flex;flex-direction:column;justify-content:center}#modal-gallery-container{display:flex;flex-direction:column;justify-content:space-between;min-width:100vw;min-height:100vh}\n"], components: [{ type: i6.UpperButtonsComponent, selector: "ks-upper-buttons", inputs: ["id", "currentImage"], outputs: ["refresh", "delete", "navigate", "download", "closeButton", "fullscreen", "customEmit"] }, { type: i7.CurrentImageComponent, selector: "ks-current-image", inputs: ["id", "currentImage", "images", "isOpen"], outputs: ["loadImage", "changeImage", "closeGallery"] }, { type: i8.DotsComponent, selector: "ks-dots", inputs: ["id", "currentImage", "images", "dotsConfig"], outputs: ["clickDot"] }, { type: i9.PreviewsComponent, selector: "ks-previews", inputs: ["id", "currentImage", "images"], outputs: ["clickPreview"] }], directives: [{ type: i10.ClickOutsideDirective, selector: "[ksClickOutside]", inputs: ["clickOutsideEnable"], outputs: ["clickOutside"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ModalGalleryComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ks-modal-gallery', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div id=\"modal-gallery-wrapper\"\n     [attr.aria-label]=\"accessibilityConfig.modalGalleryContentAriaLabel\"\n     [title]=\"accessibilityConfig.modalGalleryContentTitle\"\n     ksClickOutside [clickOutsideEnable]=\"enableCloseOutside\"\n     (clickOutside)=\"onClickOutside($event)\">\n\n  <div id=\"flex-min-height-ie-fix\">\n    <div id=\"modal-gallery-container\">\n\n      <ks-upper-buttons [id]=\"id\"\n                        [currentImage]=\"currentImage\"\n                        (delete)=\"onDelete($event)\"\n                        (navigate)=\"onNavigate($event)\"\n                        (download)=\"onDownload($event)\"\n                        (closeButton)=\"onCloseGalleryButton($event)\"\n                        (fullscreen)=\"onFullScreen($event)\"\n                        (customEmit)=\"onCustomEmit($event)\"></ks-upper-buttons>\n\n      <ks-current-image [id]=\"id\"\n                        [images]=\"images\"\n                        [currentImage]=\"currentImage\"\n                        [isOpen]=\"true\"\n                        (loadImage)=\"onImageLoad($event)\"\n                        (changeImage)=\"onChangeCurrentImage($event)\"\n                        (closeGallery)=\"onCloseGallery($event)\"></ks-current-image>\n\n      <div>\n        <ks-dots [id]=\"id\"\n                 [images]=\"images\"\n                 [currentImage]=\"currentImage\"\n                 [dotsConfig]=\"dotsConfig\"\n                 (clickDot)=\"onClickDot($event)\"></ks-dots>\n\n        <ks-previews [id]=\"id\"\n                     [images]=\"images\"\n                     [currentImage]=\"currentImage\"\n                     (clickPreview)=\"onClickPreview($event)\"></ks-previews>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: ["#flex-min-height-ie-fix{display:flex;flex-direction:column;justify-content:center}#modal-gallery-container{display:flex;flex-direction:column;justify-content:space-between;min-width:100vw;min-height:100vh}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DIALOG_DATA]
+                }] }, { type: i1.ModalGalleryService }, { type: i2.KeyboardService }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i0.ChangeDetectorRef }, { type: i3.IdValidatorService }, { type: i4.ConfigService }, { type: i5.DomSanitizer }]; }, propDecorators: { currentImageComponent: [{
+                type: ViewChild,
+                args: [CurrentImageComponent, { static: true }]
+            }], onPopState: [{
+                type: HostListener,
+                args: ['window:popstate', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-gallery.component.js","sourceRoot":"","sources":["../../../../../../../projects/ks89/angular-modal-gallery/src/lib/components/modal-gallery/modal-gallery.component.ts","../../../../../../../projects/ks89/angular-modal-gallery/src/lib/components/modal-gallery/modal-gallery.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAqB,SAAS,EAC5D,YAAY,EAAE,MAAM,EAAqB,WAAW,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1G,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAKpD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAS,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAGjE,OAAO,EAA4C,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAE5G,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,qBAAqB,EAAkB,MAAM,0CAA0C,CAAC;AAQjG,OAAO,EAAE,+BAA+B,EAAE,MAAM,0BAA0B,CAAC;;;;;;;;;;;;AAY3E,MAAM,OAAO,qBAAqB;IA4EhC,YAC+B,aAAiC,EACtD,mBAAwC,EACxC,eAAgC;IACxC,qCAAqC;IACR,UAAkB,EACvC,iBAAoC,EACpC,kBAAsC,EACtC,aAA4B,EAC5B,SAAuB;QARF,kBAAa,GAAb,aAAa,CAAoB;QACtD,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,oBAAe,GAAf,eAAe,CAAiB;QAEX,eAAU,GAAV,UAAU,CAAQ;QACvC,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,kBAAa,GAAb,aAAa,CAAe;QAC5B,cAAS,GAAT,SAAS,CAAc;QAtEjC;;;WAGG;QACH,uBAAkB,GAAG,IAAI,CAAC;QAe1B;;;WAGG;QACH,wBAAmB,GAAwB,+BAA+B,CAAC;QAiB3E;;WAEG;QACH,gBAAW,GAAG,KAAK,CAAC;QA6BlB,IAAI,CAAC,EAAE,GAAI,IAAI,CAAC,aAAoC,CAAC,EAAE,CAAC;QACxD,IAAI,CAAC,MAAM,GAAI,IAAI,CAAC,aAAoC,CAAC,MAA4B,CAAC;QACtF,IAAI,CAAC,YAAY,GAAI,IAAI,CAAC,aAAoC,CAAC,YAAgC,CAAC;QAChG,IAAI,CAAC,SAAS,GAAI,IAAI,CAAC,aAAoC,CAAC,SAAS,CAAC;QACtE,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAEtD,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,MAAe,EAAE,EAAE;YACnG,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAY,EAAE,EAAE;gBACxC,MAAM,QAAQ,GAAqB,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,CAAC;gBACzF,OAAO,QAAQ,CAAC;YAClB,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAuB,EAAE,EAAE;gBAC9C,IAAI,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE;oBACrC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;iBAC3B;YACH,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;QACxC,CAAC,CAAC,CAAC;IACL,CAAC;IAxCD;;;;OAIG;IAEH,UAAU,CAAC,CAAQ;QACjB,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAkCD;;;;OAIG;IACH,QAAQ;QACN,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAE7C,gDAAgD;QAChD,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE;YAC9C,MAAM,IAAI,KAAK,CACb,uEAAuE;gBACvE,0FAA0F,CAC3F,CAAC;SACH;QAED,MAAM,SAAS,GAA0B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC/E,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE;YACvC,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;SACtF;QAED,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC;QAEvC,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAE/B,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,KAAkB;QAC7B,MAAM,WAAW,GAAgB,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAClE,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAC3D,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC5D,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,KAAkB;QAC7B,MAAM,WAAW,GAAgB,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAClE,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAE3D,kCAAkC;QAClC,MAAM,GAAG,GAAQ,QAAe,CAAC;QACjC,kCAAkC;QAClC,MAAM,KAAK,GAAQ,QAAQ,CAAC,eAAsB,CAAC;QAEnD,MAAM,kBAAkB,GAAY,CAAC,GAAG,CAAC,iBAAiB,IAAI,CAAC,GAAG,CAAC,uBAAuB,CAAC;QAE3F,mHAAmH;QACnH,kCAAkC;QAElC,mIAAmI;QACnI,4DAA4D;QAE5D,IAAI,kBAAkB,EAAE;YACtB,IAAI,KAAK,CAAC,iBAAiB,EAAE;gBAC3B,KAAK,CAAC,iBAAiB,EAAE;qBACtB,IAAI,CAAC,GAAG,EAAE;gBACX,CAAC,CAAC;qBACD,KAAK,CAAC,GAAG,EAAE;oBACV,OAAO,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;gBAC9C,CAAC,CAAC,CAAC;aACN;iBAAM,IAAI,KAAK,CAAC,uBAAuB,EAAE;gBACxC,6CAA6C;gBAC7C,KAAK,CAAC,uBAAuB,EAAE,CAAC;aACjC;SACF;aAAM;YACL,IAAI,GAAG,CAAC,cAAc,EAAE;gBACtB,GAAG,CAAC,cAAc,EAAE;qBACjB,IAAI,CAAC,GAAG,EAAE;gBACX,CAAC,CAAC;qBACD,KAAK,CAAC,GAAG,EAAE;oBACV,OAAO,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC;gBACnD,CAAC,CAAC,CAAC;aACN;iBAAM,IAAI,GAAG,CAAC,oBAAoB,EAAE;gBACnC,6CAA6C;gBAC7C,GAAG,CAAC,oBAAoB,EAAE,CAAC;aAC5B;SACF;QAED,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC5D,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAkB;QACzB,MAAM,WAAW,GAAgB,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAClE,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAE3D,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5B,IAAI,CAAC,YAAY,EAAE,CAAC;SACrB;QAED,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC/B,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;SAC1D;QAED,MAAM,kBAAkB,GAAW,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,CAAC,KAAK,CAAC,KAAyB,CAAC,CAAC;QAChH,IAAI,kBAAkB,KAAK,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACjD,aAAa;YACb,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAAE,CAAC;SACxC;aAAM;YACL,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAAE,CAAC;SACxC;QAED,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC5D,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAAkB;QAC3B,MAAM,WAAW,GAAgB,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAClE,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAC3D,iBAAiB;QACjB,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;YACtC,IAAI,WAAW,CAAC,KAAK,IAAI,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE;gBACvD,iEAAiE;gBACjE,IAAI,WAAW,CAAC,MAAM,IAAI,WAAW,CAAC,MAAM,CAAC,cAAc,EAAE;oBAC3D,2GAA2G;oBAC3G,4FAA4F;oBAC5F,kBAAkB;oBAClB,0EAA0E;oBAC1E,oGAAoG;oBACpG,iEAAiE;oBACjE,MAAM,SAAS,GAAkB,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;oBACrG,iEAAiE;oBACjE,IAAI,SAAS,EAAE;wBACb,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,sCAAsC;wBAC/D,+BAA+B;wBAC/B,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;qBAC3D;iBACF;qBAAM;oBACL,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;oBACxD,+BAA+B;oBAC/B,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;iBAC3D;aACF;SACF;IACH,CAAC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,OAAe;QAChC,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,OAAO,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAAkB;QAC3B,MAAM,WAAW,GAAgB,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAClE,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAC3D,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC5D,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,KAAkB,EAAE,SAAiB,MAAM,CAAC,MAAM;QACrE,MAAM,WAAW,GAAgB,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAClE,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAC3D,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,KAAsB,EAAE,SAAiB,MAAM,CAAC,MAAM;QACnE,uCAAuC;QACvC,MAAM,WAAW,GAAgB;YAC/B,MAAM,EAAE;gBACN,IAAI,EAAE,UAAU,CAAC,KAAK;aACP;YACjB,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,SAAS,EAAE,KAAK,CAAC,SAAS;SAC3B,CAAC;QACF,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAC3D,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,SAAiB,MAAM,CAAC,MAAM,EAAE,eAAwB,KAAK;QACxE,MAAM,SAAS,GAA0B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC/E,IAAI,CAAC,SAAS,EAAE;YACd,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;SACvE;QAED,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACtC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,oBAAoB,CAAC,KAAsB;QACzC,MAAM,QAAQ,GAAW,KAAK,CAAC,MAAgB,CAAC;QAChD,IAAI,QAAQ,GAAG,CAAC,IAAI,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YAClD,OAAO;SACR;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE1C,mCAAmC;QACnC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC;QAE5F,gDAAgD;QAChD,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,KAAc;QAC3B,IAAI,KAAK,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACpC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;SACvC;IACH,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,KAAqB;QAC/B,6EAA6E;QAC7E,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAqB,EAAE,EAAE;YACtD,IAAI,GAAG,IAAI,GAAG,CAAC,EAAE,KAAK,KAAK,CAAC,EAAE,EAAE;gBAC9B,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,gBAAgB,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;aACnE;YACD,OAAO,GAAG,CAAC;QACb,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAAa;QACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,KAAsB;QACnC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,MAAM,SAAS,GAA0B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC/E,IAAI,IAAI,CAAC,EAAE,IAAI,SAAS,EAAE;gBACxB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;aACvC;SACF;QACD,IAAI,IAAI,CAAC,wBAAwB,EAAE;YACjC,IAAI,CAAC,wBAAwB,CAAC,WAAW,EAAE,CAAC;SAC7C;QACD,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;OAMG;IACK,uBAAuB;QAC7B,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC,EAAE,KAAK,SAAS,EAAE;YAC7C,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;SAChE;QACD,MAAM,SAAS,GAA0B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC/E,IAAI,CAAC,SAAS,EAAE;YACd,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;SACvE;QAED,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAC7C,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,KAAoB,EAAE,KAAa,EAAE,EAAE;gBAC/D,IAAI,KAAK,CAAC,cAAc,EAAE;oBACxB,KAAK,CAAC,cAAc,EAAE,CAAC;iBACxB;qBAAM;oBACL,oBAAoB;oBACpB,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC;iBAC3B;gBACD,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,CAAC,EAAE,SAAS,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,aAAa;QACnB,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC,EAAE,KAAK,SAAS,EAAE;YAC7C,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;SAChE;QACD,MAAM,SAAS,GAA0B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC/E,IAAI,CAAC,SAAS,EAAE;YACd,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;SACvE;QAED,MAAM,kBAAkB,GAAmC,SAAS,CAAC,kBAAkB,CAAC;QACxF,IAAI,kBAAkB,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE;YAC1D,OAAO;SACR;QACD,IAAI,CAAC,wBAAwB,EAAE,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACK,YAAY,CAAC,UAAkB,EAAE,cAAsB,EAAE;QAC/D,MAAM,SAAS,GAAG,IAAI,CAAC;QACvB,MAAM,cAAc,GAAW,IAAI,CAAC,UAAU,CAAC,CAAC;QAChD,MAAM,WAAW,GAAW,cAAc,CAAC,MAAM,CAAC;QAClD,MAAM,WAAW,GAAW,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;QAC/D,MAAM,UAAU,GAAsB,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC;QAC7D,KAAK,IAAI,UAAU,GAAG,CAAC,EAAE,UAAU,GAAG,WAAW,EAAE,EAAE,UAAU,EAAE;YAC/D,MAAM,KAAK,GAAW,UAAU,GAAG,SAAS,CAAC;YAC7C,MAAM,GAAG,GAAW,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,SAAS,EAAE,WAAW,CAAC,CAAC;YAC7D,MAAM,KAAK,GAAkB,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC;YACpD,KAAK,IAAI,MAAM,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE;gBAC3D,KAAK,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;aACjD;YACD,UAAU,CAAC,UAAU,CAAC,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;SAChD;QACD,OAAO,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACK,wBAAwB;QAC9B,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,GAAW,CAAC;QAChB,wCAAwC;QACxC,IAAI,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,KAAK,QAAQ,EAAE;YACnD,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAa,CAAC;SAC7C;aAAM;YACL,4BAA4B;YAC5B,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,eAAe,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAW,CAAC;SACpG;QACD,IAAI,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;YAC3D,MAAM,SAAS,GAAW,GAAG,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9E,MAAM,UAAU,GAAW,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YACpD,MAAM,IAAI,GAAS,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC;YACvE,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YACtC,QAAQ,GAAG,IAAI,CAAC;YAChB,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;SACzF;aAAM;YACL,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;YAChB,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC;SAC9E;QACD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACK,oBAAoB,CAAC,KAAkB;QAC7C,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;;OASG;IACK,WAAW,CAAC,KAAY,EAAE,WAAoB,KAAK,EAAE,kBAA0B,EAAE;QACvF,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,gBAAgB,IAAI,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE;YAC9E,IAAI,QAAQ,EAAE;gBACZ,OAAO,SAAS,KAAK,CAAC,EAAE,IAAI,eAAe,KAAK,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;aAChF;iBAAM;gBACL,OAAQ,KAAK,CAAC,KAAK,CAAC,GAAc,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;aAC7D;SACF;aAAM;YACL,OAAO,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC;SACrC;IACH,CAAC;IAED;;;;OAIG;IACK,UAAU;QAChB,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;QAEtF,MAAM,YAAY,GAAW,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACpE,iEAAiE;QACjE,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;QAE/F,gDAAgD;QAChD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QAEpD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;OAMG;IACK,iBAAiB,CAAC,MAAc,EAAE,YAAoB;QAC5D,2BAA2B;QAC3B,QAAQ,YAAY,EAAE;YACpB,KAAK,CAAC;gBACJ,IAAI,CAAC,mBAAmB,CAAC,cAAc,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;gBACpF,MAAM;YACR,KAAK,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;gBACzB,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;gBACnF,MAAM;SACT;IACH,CAAC;;kHAjkBU,qBAAqB,kBA6EtB,WAAW,+EAIX,WAAW;sGAjFV,qBAAqB,iLAIrB,qBAAqB,8DCtClC,kuDAyCA;2FDPa,qBAAqB;kBANjC,SAAS;+BACE,kBAAkB,mBAGX,uBAAuB,CAAC,MAAM;;0BA+E5C,MAAM;2BAAC,WAAW;8FAIsB,MAAM;0BAA9C,MAAM;2BAAC,WAAW;oKA7E+B,qBAAqB;sBAAxE,SAAS;uBAAC,qBAAqB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAoElD,UAAU;sBADT,YAAY;uBAAC,iBAAiB,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component,\n  HostListener, Inject, OnDestroy, OnInit, PLATFORM_ID, SecurityContext, ViewChild } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { DomSanitizer } from '@angular/platform-browser';\n\nimport { Subscription } from 'rxjs';\n\nimport { DIALOG_DATA } from './modal-gallery.tokens';\nimport { Image, ImageModalEvent } from '../../model/image.class';\nimport { ConfigService } from '../../services/config.service';\nimport { DotsConfig } from '../../model/dots-config.interface';\nimport { ButtonConfig, ButtonEvent, ButtonsConfig, ButtonType } from '../../model/buttons-config.interface';\nimport { InternalLibImage } from '../../model/image-internal.class';\nimport { Action } from '../../model/action.enum';\nimport { CurrentImageComponent, ImageLoadEvent } from '../current-image/current-image.component';\nimport { KeyboardService } from '../../services/keyboard.service';\nimport { IdValidatorService } from '../../services/id-validator.service';\nimport { KeyboardConfig } from '../../model/keyboard-config.interface';\nimport { PreviewConfig } from '../../model/preview-config.interface';\nimport { SlideConfig } from '../../model/slide-config.interface';\nimport { AccessibilityConfig } from '../../model/accessibility.interface';\nimport { PlainGalleryConfig } from '../../model/plain-gallery-config.interface';\nimport { KS_DEFAULT_ACCESSIBILITY_CONFIG } from '../accessibility-default';\nimport { CurrentImageConfig } from '../../model/current-image-config.interface';\nimport { ModalGalleryService } from './modal-gallery.service';\nimport { LibConfig } from '../../model/lib-config.interface';\nimport { ModalGalleryConfig } from '../../model/modal-gallery-config.interface';\n\n@Component({\n  selector: 'ks-modal-gallery',\n  templateUrl: './modal-gallery.component.html',\n  styleUrls: ['./modal-gallery.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ModalGalleryComponent implements OnInit, OnDestroy {\n  /**\n   * Reference to the CurrentImageComponent to invoke methods on it.\n   */\n  @ViewChild(CurrentImageComponent, { static: true }) currentImageComponent: CurrentImageComponent | undefined;\n\n  /**\n   * Unique id (>=0) of the current instance of this library. This is useful when you are using\n   * the service to call modal gallery without open it manually.\n   */\n  id: number;\n  /**\n   * Object of type `ButtonsConfig` to show/hide buttons.\n   */\n  buttonsConfig: ButtonsConfig | undefined;\n  /**\n   * Boolean to enable modal-gallery close behaviour when clicking\n   * on the semi-transparent background. Enabled by default.\n   */\n  enableCloseOutside = true;\n  /**\n   * Object of type `DotsConfig` to init DotsComponent's features.\n   * For instance, it contains a param to show/hide dots.\n   */\n  dotsConfig: DotsConfig | undefined;\n  /**\n   * Object of type `PreviewConfig` to init PreviewsComponent's features.\n   * For instance, it contains a param to show/hide previews.\n   */\n  previewConfig: PreviewConfig | undefined;\n  /**\n   * Object of type `SlideConfig` to init side previews and `infinite sliding`.\n   */\n  slideConfig: SlideConfig | undefined;\n  /**\n   * Object of type `AccessibilityConfig` to init custom accessibility features.\n   * For instance, it contains titles, alt texts, aria-labels and so on.\n   */\n  accessibilityConfig: AccessibilityConfig = KS_DEFAULT_ACCESSIBILITY_CONFIG;\n  /**\n   * Object of type `KeyboardConfig` to assign custom keys to ESC, RIGHT and LEFT keyboard's actions.\n   */\n  keyboardConfig: KeyboardConfig | undefined;\n  /**\n   * Object of type `PlainGalleryConfig` to configure the plain gallery.\n   */\n  plainGalleryConfig: PlainGalleryConfig | undefined;\n  /**\n   * Array of `InternalLibImage` representing the model of this library with all images, thumbs and so on.\n   */\n  images: InternalLibImage[];\n  /**\n   * `Image` that is visible right now.\n   */\n  currentImage: InternalLibImage;\n  /**\n   * Boolean to open the modal gallery. False by default.\n   */\n  showGallery = false;\n  /**\n   * Object to configure this component.\n   */\n  libConfig: LibConfig | undefined;\n\n  private updateImagesSubscription: Subscription | undefined;\n\n  /**\n   * HostListener to catch browser's back button and destroy the gallery.\n   * This prevents weired behaviour about scrolling.\n   * Added to fix this issue: https://github.com/Ks89/angular-modal-gallery/issues/159\n   */\n  @HostListener('window:popstate', ['$event'])\n  onPopState(e: Event): void {\n    this.closeGallery();\n  }\n\n  constructor(\n    @Inject(DIALOG_DATA) private dialogContent: ModalGalleryConfig,\n    private modalGalleryService: ModalGalleryService,\n    private keyboardService: KeyboardService,\n    // tslint:disable-next-line:ban-types\n    @Inject(PLATFORM_ID) private platformId: Object,\n    private changeDetectorRef: ChangeDetectorRef,\n    private idValidatorService: IdValidatorService,\n    private configService: ConfigService,\n    private sanitizer: DomSanitizer\n  ) {\n    this.id = (this.dialogContent as ModalGalleryConfig).id;\n    this.images = (this.dialogContent as ModalGalleryConfig).images as InternalLibImage[];\n    this.currentImage = (this.dialogContent as ModalGalleryConfig).currentImage as InternalLibImage;\n    this.libConfig = (this.dialogContent as ModalGalleryConfig).libConfig;\n    this.configService.setConfig(this.id, this.libConfig);\n\n    this.updateImagesSubscription = this.modalGalleryService.updateImages$.subscribe((images: Image[]) => {\n      this.images = images.map((image: Image) => {\n        const newImage: InternalLibImage = Object.assign({}, image, { previouslyLoaded: false });\n        return newImage;\n      });\n      this.initImages();\n      this.images.forEach((image: InternalLibImage) => {\n        if (image.id === this.currentImage.id) {\n          this.currentImage = image;\n        }\n      });\n      this.changeDetectorRef.markForCheck();\n    });\n  }\n\n  /**\n   * Method ´ngOnInit´ to init images calling `initImages()`.\n   * This is an Angular's lifecycle hook, so its called automatically by Angular itself.\n   * In particular, it's called only one time!!!\n   */\n  ngOnInit(): void {\n    this.idValidatorService.checkAndAdd(this.id);\n\n    // id is a mandatory input and must a number > 0\n    if ((!this.id && this.id !== 0) || this.id < 0) {\n      throw new Error(\n        `'[id]=\"a number >= 0\"' is a mandatory input in angular-modal-gallery.` +\n        `If you are using multiple instances of this library, please be sure to use different ids`\n      );\n    }\n\n    const libConfig: LibConfig | undefined = this.configService.getConfig(this.id);\n    if (!libConfig || !libConfig.dotsConfig) {\n      throw new Error('Internal library error - libConfig and dotsConfig must be defined');\n    }\n\n    this.dotsConfig = libConfig.dotsConfig;\n\n    this.registerKeyboardService();\n\n    setTimeout(() => {\n      this.initImages();\n    }, 0);\n  }\n\n  /**\n   * Method called by custom upper buttons.\n   * @param event ButtonEvent event payload\n   */\n  onCustomEmit(event: ButtonEvent): void {\n    const eventToEmit: ButtonEvent = this.getButtonEventToEmit(event);\n    this.modalGalleryService.emitButtonBeforeHook(eventToEmit);\n    this.modalGalleryService.emitButtonAfterHook(eventToEmit);\n  }\n\n  /**\n   * Method called by the full-screen upper button.\n   * @param event ButtonEvent event payload\n   */\n  onFullScreen(event: ButtonEvent): void {\n    const eventToEmit: ButtonEvent = this.getButtonEventToEmit(event);\n    this.modalGalleryService.emitButtonBeforeHook(eventToEmit);\n\n    // tslint:disable-next-line:no-any\n    const doc: any = document as any;\n    // tslint:disable-next-line:no-any\n    const docEl: any = document.documentElement as any;\n\n    const fullscreenDisabled: boolean = !doc.fullscreenElement && !doc.webkitFullscreenElement;\n\n    // In Safari `requestFullscreen` and `exitFullscreen` are undefined. Safari requires the prefixed version `webkit-`\n    // and it doesn't return promises.\n\n    // I cannot call `emitButtonAfterHook` only if requestFullScreen is successful, because there are no guarantees across browsers and\n    // I should also handle the case with keyboard \"esc\" button.\n\n    if (fullscreenDisabled) {\n      if (docEl.requestFullscreen) {\n        docEl.requestFullscreen()\n          .then(() => {\n          })\n          .catch(() => {\n            console.error('Cannot request full screen');\n          });\n      } else if (docEl.webkitRequestFullscreen) {\n        // For Safari and it doesn't return a promise\n        docEl.webkitRequestFullscreen();\n      }\n    } else {\n      if (doc.exitFullscreen) {\n        doc.exitFullscreen()\n          .then(() => {\n          })\n          .catch(() => {\n            console.error('Cannot request exit full screen');\n          });\n      } else if (doc.webkitExitFullscreen) {\n        // For Safari and it doesn't return a promise\n        doc.webkitExitFullscreen();\n      }\n    }\n\n    this.modalGalleryService.emitButtonAfterHook(eventToEmit);\n  }\n\n  /**\n   * Method called by the delete upper button.\n   * @param event ButtonEvent event payload\n   */\n  onDelete(event: ButtonEvent): void {\n    const eventToEmit: ButtonEvent = this.getButtonEventToEmit(event);\n    this.modalGalleryService.emitButtonBeforeHook(eventToEmit);\n\n    if (this.images.length === 1) {\n      this.closeGallery();\n    }\n\n    if (!this.currentImageComponent) {\n      throw new Error('currentImageComponent must be defined');\n    }\n\n    const imageIndexToDelete: number = this.currentImageComponent.getIndexToDelete(event.image as InternalLibImage);\n    if (imageIndexToDelete === this.images.length - 1) {\n      // last image\n      this.currentImageComponent.prevImage();\n    } else {\n      this.currentImageComponent.nextImage();\n    }\n\n    this.modalGalleryService.emitButtonAfterHook(eventToEmit);\n  }\n\n  /**\n   * Method called by the navigate upper button.\n   * @param event ButtonEvent event payload\n   */\n  onNavigate(event: ButtonEvent): void {\n    const eventToEmit: ButtonEvent = this.getButtonEventToEmit(event);\n    this.modalGalleryService.emitButtonBeforeHook(eventToEmit);\n    // To support SSR\n    if (isPlatformBrowser(this.platformId)) {\n      if (eventToEmit.image && eventToEmit.image.modal.extUrl) {\n        // where I should open this link? The current tab or another one?\n        if (eventToEmit.button && eventToEmit.button.extUrlInNewTab) {\n          // in this case I should use target _blank to open the url in a new tab, however these is a security issue.\n          // Prevent Reverse Tabnabbing's attacks (https://www.owasp.org/index.php/Reverse_Tabnabbing)\n          // Some resources:\n          // - https://www.owasp.org/index.php/HTML5_Security_Cheat_Sheet#Tabnabbing\n          // - https://medium.com/@jitbit/target-blank-the-most-underestimated-vulnerability-ever-96e328301f4c\n          // - https://developer.mozilla.org/en-US/docs/Web/API/Window/open\n          const newWindow: Window | null = window.open(eventToEmit.image.modal.extUrl, 'noopener,noreferrer,');\n          // it returns null if the call failed, so I have to do this check\n          if (newWindow) {\n            newWindow.opener = null; // required to prevent security issues\n            // emit only in case of success\n            this.modalGalleryService.emitButtonAfterHook(eventToEmit);\n          }\n        } else {\n          this.updateLocationHref(eventToEmit.image.modal.extUrl);\n          // emit only in case of success\n          this.modalGalleryService.emitButtonAfterHook(eventToEmit);\n        }\n      }\n    }\n  }\n\n  /**\n   * This method is defined to be spied and replaced in unit testing with a fake method call.\n   * It must be public to be able to use jasmine spyOn method.\n   * @param newHref string new url\n   */\n  updateLocationHref(newHref: string) {\n    window.location.href = newHref;\n  }\n\n  /**\n   * Method called by the download upper button.\n   * @param event ButtonEvent event payload\n   */\n  onDownload(event: ButtonEvent): void {\n    const eventToEmit: ButtonEvent = this.getButtonEventToEmit(event);\n    this.modalGalleryService.emitButtonBeforeHook(eventToEmit);\n    this.downloadImage();\n    this.modalGalleryService.emitButtonAfterHook(eventToEmit);\n  }\n\n  /**\n   * Method called by the close upper button.\n   * @param event ButtonEvent event payload\n   * @param action Action that triggered the close method. `Action.NORMAL` by default\n   */\n  onCloseGalleryButton(event: ButtonEvent, action: Action = Action.NORMAL): void {\n    const eventToEmit: ButtonEvent = this.getButtonEventToEmit(event);\n    this.modalGalleryService.emitButtonBeforeHook(eventToEmit);\n    this.closeGallery(action, false);\n  }\n\n  /**\n   * Method called by CurrentImageComponent and triggered via KeyboardService.\n   * @param event ImageModalEvent event payload\n   * @param action Action that triggered the close method. `Action.NORMAL` by default\n   */\n  onCloseGallery(event: ImageModalEvent, action: Action = Action.NORMAL): void {\n    // remap ImageModalEvent to ButtonEvent\n    const buttonEvent: ButtonEvent = {\n      button: {\n        type: ButtonType.CLOSE\n      } as ButtonConfig,\n      image: null,\n      action: event.action,\n      galleryId: event.galleryId\n    };\n    this.modalGalleryService.emitButtonBeforeHook(buttonEvent);\n    this.closeGallery(action, false);\n  }\n\n  /**\n   * Method to close the modal gallery specifying the action.\n   * It also reset the `keyboardService` to prevent multiple listeners.\n   * @param action Action action type. `Action.NORMAL` by default\n   * @param clickOutside boolean that is true if called clicking on the modal background. False by default.\n   */\n  closeGallery(action: Action = Action.NORMAL, clickOutside: boolean = false): void {\n    const libConfig: LibConfig | undefined = this.configService.getConfig(this.id);\n    if (!libConfig) {\n      throw new Error('Internal library error - libConfig must be defined');\n    }\n\n    this.modalGalleryService.emitClose(new ImageModalEvent(this.id, action, true));\n    this.keyboardService.reset(libConfig);\n    this.modalGalleryService.close(this.id, clickOutside);\n  }\n\n  /**\n   * Method called when the image changes and used to update the `currentImage` object.\n   * @param event ImageModalEvent event payload\n   */\n  onChangeCurrentImage(event: ImageModalEvent): void {\n    const newIndex: number = event.result as number;\n    if (newIndex < 0 || newIndex >= this.images.length) {\n      return;\n    }\n\n    this.currentImage = this.images[newIndex];\n\n    // emit current visible image index\n    this.modalGalleryService.emitShow(new ImageModalEvent(this.id, event.action, newIndex + 1));\n\n    // emit first/last event based on newIndex value\n    this.emitBoundaryEvent(event.action, newIndex);\n  }\n\n  /**\n   * Method called when you click 'outside' (i.e. on the semi-transparent background)\n   * to close the modal gallery if `enableCloseOutside` is true.\n   * @param event boolean that is true to close the modal gallery, false otherwise\n   */\n  onClickOutside(event: boolean): void {\n    if (event && this.enableCloseOutside) {\n      this.closeGallery(Action.CLICK, true);\n    }\n  }\n\n  /**\n   * Method called when an image is loaded and the loading spinner has gone.\n   * It sets the previouslyLoaded flag inside the Image to hide loading spinner when displayed again.\n   * @param event ImageLoadEvent event payload\n   */\n  onImageLoad(event: ImageLoadEvent): void {\n    // sets as previously loaded the image with index specified by `event.status`\n    this.images = this.images.map((img: InternalLibImage) => {\n      if (img && img.id === event.id) {\n        return Object.assign({}, img, { previouslyLoaded: event.status });\n      }\n      return img;\n    });\n  }\n\n  /**\n   * Method called when a dot is clicked and used to update the current image.\n   * @param index number index of the clicked dot\n   */\n  onClickDot(index: number): void {\n    this.currentImage = this.images[index];\n  }\n\n  /**\n   * Method called when an image preview is clicked and used to update the current image.\n   * @param event ImageModalEvent preview image\n   */\n  onClickPreview(event: ImageModalEvent): void {\n    this.onChangeCurrentImage(event);\n  }\n\n  /**\n   * Method to cleanup resources. In fact, this will reset keyboard's service.\n   * This is an Angular's lifecycle hook that is called when this component is destroyed.\n   */\n  ngOnDestroy(): void {\n    if (this.keyboardService) {\n      const libConfig: LibConfig | undefined = this.configService.getConfig(this.id);\n      if (this.id && libConfig) {\n        this.keyboardService.reset(libConfig);\n      }\n    }\n    if (this.updateImagesSubscription) {\n      this.updateImagesSubscription.unsubscribe();\n    }\n    this.idValidatorService.remove(this.id);\n  }\n\n  /**\n   * Method to show the modal gallery displaying the currentImage.\n   * It will also register a new `keyboardService` to catch keyboard's events to download the current\n   * image with keyboard's shortcuts. This service, will be removed either when modal gallery component\n   * will be destroyed or when the gallery is closed invoking the `closeGallery` method.\n   * @private\n   */\n  private registerKeyboardService(): void {\n    if (this.id === null || this.id === undefined) {\n      throw new Error('Internal library error - id must be defined');\n    }\n    const libConfig: LibConfig | undefined = this.configService.getConfig(this.id);\n    if (!libConfig) {\n      throw new Error('Internal library error - libConfig must be defined');\n    }\n\n    this.keyboardService.init(libConfig).then(() => {\n      this.keyboardService.add((event: KeyboardEvent, combo: string) => {\n        if (event.preventDefault) {\n          event.preventDefault();\n        } else {\n          // internet explorer\n          event.returnValue = false;\n        }\n        this.downloadImage();\n      }, libConfig);\n    });\n  }\n\n  /**\n   * Method to download the current image, only if `downloadable` is true.\n   * @private\n   */\n  private downloadImage(): void {\n    if (this.id === null || this.id === undefined) {\n      throw new Error('Internal library error - id must be defined');\n    }\n    const libConfig: LibConfig | undefined = this.configService.getConfig(this.id);\n    if (!libConfig) {\n      throw new Error('Internal library error - libConfig must be defined');\n    }\n\n    const currentImageConfig: CurrentImageConfig | undefined = libConfig.currentImageConfig;\n    if (currentImageConfig && !currentImageConfig.downloadable) {\n      return;\n    }\n    this.downloadImageAllBrowsers();\n  }\n\n  /**\n   * Method to convert a base64 to a Blob\n   * @param base64Data string with base64 data\n   * @param contentType string with the MIME type\n   * @return Blob converted from the input base64Data\n   * @private\n   */\n  private base64toBlob(base64Data: string, contentType: string = ''): Blob {\n    const sliceSize = 1024;\n    const byteCharacters: string = atob(base64Data);\n    const bytesLength: number = byteCharacters.length;\n    const slicesCount: number = Math.ceil(bytesLength / sliceSize);\n    const byteArrays: Array<Uint8Array> = new Array(slicesCount);\n    for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {\n      const begin: number = sliceIndex * sliceSize;\n      const end: number = Math.min(begin + sliceSize, bytesLength);\n      const bytes: Array<number> = new Array(end - begin);\n      for (let offset = begin, i = 0; offset < end; ++i, ++offset) {\n        bytes[i] = byteCharacters[offset].charCodeAt(0);\n      }\n      byteArrays[sliceIndex] = new Uint8Array(bytes);\n    }\n    return new Blob(byteArrays, { type: contentType });\n  }\n\n  /**\n   * Private method to download the current image for all browsers.\n   * @private\n   */\n  private downloadImageAllBrowsers(): void {\n    const link = document.createElement('a');\n    let isBase64 = false;\n    let img: string;\n    // convert a SafeResourceUrl to a string\n    if (typeof this.currentImage.modal.img === 'string') {\n      img = this.currentImage.modal.img as string;\n    } else {\n      // if it's a SafeResourceUrl\n      img = this.sanitizer.sanitize(SecurityContext.RESOURCE_URL, this.currentImage.modal.img) as string;\n    }\n    if (img.includes('data:image/') || img.includes(';base64,')) {\n      const extension: string = img.replace('data:image/', '').split(';base64,')[0];\n      const pureBase64: string = img.split(';base64,')[1];\n      const blob: Blob = this.base64toBlob(pureBase64, 'image/' + extension);\n      link.href = URL.createObjectURL(blob);\n      isBase64 = true;\n      link.setAttribute('download', this.getFileName(this.currentImage, isBase64, extension));\n    } else {\n      link.href = img;\n      link.setAttribute('download', this.getFileName(this.currentImage, isBase64));\n    }\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n  }\n\n  /**\n   * Private method to get the `ButtonEvent` to emit, merging the input `ButtonEvent`\n   * with the current image.\n   * @param event ButtonEvent event payload to return\n   * @returns ButtonEvent event payload with the current image included\n   * @private\n   */\n  private getButtonEventToEmit(event: ButtonEvent): ButtonEvent {\n    return Object.assign(event, { image: this.currentImage });\n  }\n\n  /**\n   * Private method to get the file name from an input path.\n   * This is used either to get the image's name from its path or from the Image itself,\n   * if specified as 'downloadFileName' by the user.\n   * @param image Image image to extract its file name\n   * @param isBase64 boolean to set if the image is a base64 file or not. False by default.\n   * @param base64Extension string to force the extension of the base64 image. Empty string by default.\n   * @returns string string file name of the input image.\n   * @private\n   */\n  private getFileName(image: Image, isBase64: boolean = false, base64Extension: string = ''): string {\n    if (!image.modal.downloadFileName || image.modal.downloadFileName.length === 0) {\n      if (isBase64) {\n        return `Image-${image.id}.${base64Extension !== '' ? base64Extension : 'png'}`;\n      } else {\n        return (image.modal.img as string).replace(/^.*[\\\\\\/]/, '');\n      }\n    } else {\n      return image.modal.downloadFileName;\n    }\n  }\n\n  /**\n   * Private method to initialize `images` as array of `Image`s.\n   * Also, it will emit ImageModalEvent to say that images are loaded.\n   * @private\n   */\n  private initImages(): void {\n    this.modalGalleryService.emitHasData(new ImageModalEvent(this.id, Action.LOAD, true));\n\n    const currentIndex: number = this.images.indexOf(this.currentImage);\n    // emit a new ImageModalEvent with the index of the current image\n    this.modalGalleryService.emitShow(new ImageModalEvent(this.id, Action.LOAD, currentIndex + 1));\n\n    // emit first/last event based on newIndex value\n    this.emitBoundaryEvent(Action.NORMAL, currentIndex);\n\n    this.showGallery = this.images.length > 0;\n  }\n\n  /**\n   * Private method to emit events when either the last or the first image are visible.\n   * @param action Action Enum of type Action that represents the source of the event that changed the\n   *  current image to the first one or the last one.\n   * @param indexToCheck number is the index number of the image (the first or the last one).\n   * @private\n   */\n  private emitBoundaryEvent(action: Action, indexToCheck: number): void {\n    // to emit first/last event\n    switch (indexToCheck) {\n      case 0:\n        this.modalGalleryService.emitFirstImage(new ImageModalEvent(this.id, action, true));\n        break;\n      case this.images.length - 1:\n        this.modalGalleryService.emitLastImage(new ImageModalEvent(this.id, action, true));\n        break;\n    }\n  }\n}\n","<div id=\"modal-gallery-wrapper\"\n     [attr.aria-label]=\"accessibilityConfig.modalGalleryContentAriaLabel\"\n     [title]=\"accessibilityConfig.modalGalleryContentTitle\"\n     ksClickOutside [clickOutsideEnable]=\"enableCloseOutside\"\n     (clickOutside)=\"onClickOutside($event)\">\n\n  <div id=\"flex-min-height-ie-fix\">\n    <div id=\"modal-gallery-container\">\n\n      <ks-upper-buttons [id]=\"id\"\n                        [currentImage]=\"currentImage\"\n                        (delete)=\"onDelete($event)\"\n                        (navigate)=\"onNavigate($event)\"\n                        (download)=\"onDownload($event)\"\n                        (closeButton)=\"onCloseGalleryButton($event)\"\n                        (fullscreen)=\"onFullScreen($event)\"\n                        (customEmit)=\"onCustomEmit($event)\"></ks-upper-buttons>\n\n      <ks-current-image [id]=\"id\"\n                        [images]=\"images\"\n                        [currentImage]=\"currentImage\"\n                        [isOpen]=\"true\"\n                        (loadImage)=\"onImageLoad($event)\"\n                        (changeImage)=\"onChangeCurrentImage($event)\"\n                        (closeGallery)=\"onCloseGallery($event)\"></ks-current-image>\n\n      <div>\n        <ks-dots [id]=\"id\"\n                 [images]=\"images\"\n                 [currentImage]=\"currentImage\"\n                 [dotsConfig]=\"dotsConfig\"\n                 (clickDot)=\"onClickDot($event)\"></ks-dots>\n\n        <ks-previews [id]=\"id\"\n                     [images]=\"images\"\n                     [currentImage]=\"currentImage\"\n                     (clickPreview)=\"onClickPreview($event)\"></ks-previews>\n      </div>\n    </div>\n  </div>\n</div>\n"]}