@ks89/angular-modal-gallery 8.0.1 → 9.1.0-beta.1

package/esm2020/lib/components/carousel/carousel-previews/carousel-previews.component.mjs

@@ -0,0 +1,462 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (C) 2017-2021 Stefano Cappa (Ks89)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, Input, Output } from '@angular/core';
+import { Breakpoints } from '@angular/cdk/layout';
+import { AccessibleComponent } from '../../accessible.component';
+import { NEXT, PREV } from '../../../utils/user-input.util';
+import { getIndex } from '../../../utils/image.util';
+import { Action } from '../../../model/action.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/layout";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "../../../services/config.service";
+import * as i4 from "@angular/common";
+import * as i5 from "../../../directives/fallback-image.directive";
+import * as i6 from "../../../directives/size.directive";
+/**
+ * Default max height of previews.
+ */
+const DEFAULT_MAX_HEIGHT = '200px';
+/**
+ * Component with image previews for carousel
+ */
+export class CarouselPreviewsComponent extends AccessibleComponent {
+    constructor(ref, breakpointObserver, 
+    // sanitizer is used only to sanitize style before add it to background property when legacyIE11Mode is enabled
+    sanitizer, configService) {
+        super();
+        this.ref = ref;
+        this.breakpointObserver = breakpointObserver;
+        this.sanitizer = sanitizer;
+        this.configService = configService;
+        /**
+         * Variable to change the max-width of the host component
+         */
+        this.hostMaxWidth = '100%';
+        /**
+         * Variable to set aria-label of the host component
+         */
+        this.ariaLabel = `Carousel previews`;
+        /**
+         * Output to emit the clicked preview. The payload contains the `InternalLibImage` associated to the clicked preview.
+         */
+        this.clickPreview = new EventEmitter();
+        /**
+         * Enum of type `Action` that represents a mouse click on a button.
+         * Declared here to be used inside the template.
+         */
+        this.clickAction = Action.CLICK;
+        /**
+         * Enum of type `Action` that represents a keyboard action.
+         * Declared here to be used inside the template.
+         */
+        this.keyboardAction = Action.KEYBOARD;
+        /**
+         * Array of `InternalLibImage` exposed to the template. This field is initialized
+         * applying transformations, default values and so on to the input of the same type.
+         */
+        this.previews = [];
+        /**
+         * Variable with the preview's maxHeight
+         */
+        this.previewMaxHeight = DEFAULT_MAX_HEIGHT;
+        // listen for width changes and update preview heights accordingly
+        this.breakpointSubscription = breakpointObserver
+            .observe([Breakpoints.XSmall, Breakpoints.Small, Breakpoints.Medium, Breakpoints.Large, Breakpoints.XLarge])
+            .subscribe((result) => {
+            if (!this.previewConfig || !this.previewConfig.breakpoints) {
+                return;
+            }
+            if (result.breakpoints[Breakpoints.XSmall]) {
+                this.updateHeight(this.previewConfig.breakpoints.xSmall);
+            }
+            else if (result.breakpoints[Breakpoints.Small]) {
+                this.updateHeight(this.previewConfig.breakpoints.small);
+            }
+            else if (result.breakpoints[Breakpoints.Medium]) {
+                this.updateHeight(this.previewConfig.breakpoints.medium);
+            }
+            else if (result.breakpoints[Breakpoints.Large]) {
+                this.updateHeight(this.previewConfig.breakpoints.large);
+            }
+            else if (result.breakpoints[Breakpoints.XLarge]) {
+                this.updateHeight(this.previewConfig.breakpoints.xLarge);
+            }
+        });
+    }
+    /**
+     * Method to update the height of previews, passing the desired height as input.
+     * @param configBreakpointHeight is a number that represent the desired height to set.
+     */
+    updateHeight(configBreakpointHeight) {
+        if (this.previewConfig && this.previewConfig.maxHeight) {
+            const heightNum = +this.previewConfig.maxHeight.replace('/px/g', '').replace('/%/g', '');
+            this.previewMaxHeight = Math.min(configBreakpointHeight, heightNum) + 'px';
+        }
+        else {
+            const heightNum = +DEFAULT_MAX_HEIGHT.replace('/px/g', '').replace('/%/g', '');
+            this.previewMaxHeight = Math.min(configBreakpointHeight, heightNum) + 'px';
+        }
+        this.ref.markForCheck();
+    }
+    /**
+     * Method ´ngOnInit´ to build `configPreview` applying a default value and also to
+     * init the `previews` array.
+     * This is an Angular's lifecycle hook, so its called automatically by Angular itself.
+     * In particular, it's called only one time!!!
+     */
+    ngOnInit() {
+        const libConfig = this.configService.getConfig(this.id);
+        if (!libConfig) {
+            throw new Error('Internal library error - libConfig must be defined');
+        }
+        this.carouselConfig = libConfig.carouselConfig;
+        this.previewConfig = libConfig.carouselPreviewsConfig;
+        this.accessibilityConfig = libConfig.accessibilityConfig;
+        if (!this.previewConfig || !this.previewConfig.maxHeight || !this.previewConfig.breakpoints) {
+            throw new Error('Internal library error - previewConfig must be defined');
+        }
+        // change the max-width of this component if there is a specified width !== 100% in carouselConfig
+        if (this.carouselConfig && this.carouselConfig.maxWidth !== '100%') {
+            this.hostMaxWidth = this.carouselConfig.maxWidth;
+        }
+        this.previewMaxHeight = this.previewConfig.maxHeight;
+        // init previews based on currentImage and the full array of images
+        this.initPreviews(this.currentImage, this.images);
+        // apply custom height based on responsive breakpoints
+        // This is required, because the breakpointSubscription is not triggered at creation,
+        // but only when the width changes
+        const isXsmallScreen = this.breakpointObserver.isMatched(Breakpoints.XSmall);
+        const isSmallScreen = this.breakpointObserver.isMatched(Breakpoints.Small);
+        const isMediumScreen = this.breakpointObserver.isMatched(Breakpoints.Medium);
+        const isLargeScreen = this.breakpointObserver.isMatched(Breakpoints.Large);
+        const isxLargeScreen = this.breakpointObserver.isMatched(Breakpoints.XLarge);
+        if (isXsmallScreen) {
+            this.updateHeight(this.previewConfig.breakpoints.xSmall);
+        }
+        else if (isSmallScreen) {
+            this.updateHeight(this.previewConfig.breakpoints.small);
+        }
+        else if (isMediumScreen) {
+            this.updateHeight(this.previewConfig.breakpoints.medium);
+        }
+        else if (isLargeScreen) {
+            this.updateHeight(this.previewConfig.breakpoints.large);
+        }
+        else if (isxLargeScreen) {
+            this.updateHeight(this.previewConfig.breakpoints.xLarge);
+        }
+    }
+    /**
+     * Method to check if an image is active (i.e. a preview image).
+     * @param InternalLibImage preview is an image to check if it's active or not
+     * @returns boolean true if is active, false otherwise
+     */
+    isActive(preview) {
+        if (!preview || !this.currentImage) {
+            return false;
+        }
+        return preview.id === this.currentImage.id;
+    }
+    /**
+     * Method ´ngOnChanges´ to update `previews` array.
+     * Also, both `start` and `end` local variables will be updated accordingly.
+     * This is an Angular's lifecycle hook, so its called automatically by Angular itself.
+     * In particular, it's called when any data-bound property of a directive changes!!!
+     */
+    ngOnChanges(changes) {
+        const simpleChange = changes.currentImage;
+        if (!simpleChange) {
+            return;
+        }
+        const prev = simpleChange.previousValue;
+        const current = simpleChange.currentValue;
+        if (current && changes.images && changes.images.previousValue && changes.images.currentValue) {
+            // I'm in this if statement, if input images are changed (for instance, because I removed one of them with the 'delete button',
+            // or because users changed the images array while modal gallery is still open).
+            // In this case, I have to re-init previews, because the input array of images is changed.
+            this.initPreviews(current, changes.images.currentValue);
+        }
+        if (prev && current && prev.id !== current.id) {
+            // to manage infinite sliding I have to reset both `start` and `end` at the beginning
+            // to show again previews from the first image.
+            // This happens when you navigate over the last image to return to the first one
+            let prevIndex;
+            let currentIndex;
+            try {
+                prevIndex = getIndex(prev, this.images);
+                currentIndex = getIndex(current, this.images);
+            }
+            catch (err) {
+                console.error('Cannot get previous and current image indexes in previews');
+                throw err;
+            }
+            // apply a formula to get a values to be used to decide if go next, return back or stay without doing anything
+            const calc = Math.floor((this.end - this.start) / 2) + this.start;
+            if (prevIndex === this.images.length - 1 && currentIndex === 0) {
+                // first image
+                this.setBeginningIndexesPreviews();
+                this.previews = this.images.filter((img, i) => i >= this.start && i < this.end);
+                return;
+            }
+            // the same for the opposite case, when you navigate back from the fist image to go to the last one.
+            if (prevIndex === 0 && currentIndex === this.images.length - 1) {
+                // last image
+                this.setEndIndexesPreviews();
+                this.previews = this.images.filter((img, i) => i >= this.start && i < this.end);
+                return;
+            }
+            if (this.previewConfig && this.previewConfig.number % 2 === 0) {
+                if (calc > currentIndex) {
+                    this.previous();
+                }
+                else {
+                    this.next();
+                }
+            }
+            else {
+                if (calc > currentIndex) {
+                    this.previous();
+                }
+                if (calc < currentIndex) {
+                    this.next();
+                }
+            }
+        }
+    }
+    /**
+     * Method called by events from both keyboard and mouse on a preview.
+     * This will trigger the `clickpreview` output with the input preview as its payload.
+     * @param InternalLibImage preview that triggered this method
+     * @param KeyboardEvent | MouseEvent event payload
+     * @param Action that triggered this event (Action.NORMAL by default)
+     */
+    onImageEvent(preview, event, action = Action.NORMAL) {
+        if (!this.previewConfig || !this.previewConfig.clickable) {
+            return;
+        }
+        const clickedImageIndex = this.images.indexOf(preview);
+        const result = super.handleImageEvent(event);
+        if (result === NEXT) {
+            this.clickPreview.emit({ action, result: clickedImageIndex });
+        }
+        else if (result === PREV) {
+            this.clickPreview.emit({ action, result: clickedImageIndex });
+        }
+    }
+    /**
+     * Method called by events from both keyboard and mouse on a navigation arrow.
+     * @param string direction of the navigation that can be either 'next' or 'prev'
+     * @param KeyboardEvent | MouseEvent event payload
+     */
+    onNavigationEvent(direction, event) {
+        const result = super.handleNavigationEvent(direction, event);
+        if (result === NEXT) {
+            this.next();
+        }
+        else if (result === PREV) {
+            this.previous();
+        }
+    }
+    /**
+     * Method to get aria-label text for a preview image.
+     * @param Image is the preview
+     */
+    getAriaLabel(preview) {
+        if (!preview.plain) {
+            return preview.modal.ariaLabel || '';
+        }
+        return preview.plain.ariaLabel || preview.modal.ariaLabel || '';
+    }
+    /**
+     * Method to get title text for a preview image.
+     * @param Image is the preview
+     */
+    getTitle(preview) {
+        if (!preview.plain) {
+            return preview.modal.title || '';
+        }
+        return preview.plain.title || preview.modal.title || '';
+    }
+    /**
+     * Method to get alt text for a preview image.
+     * @param Image is the preview
+     */
+    getAlt(preview) {
+        if (!preview.plain) {
+            return preview.modal.alt || '';
+        }
+        return preview.plain.alt || preview.modal.alt || '';
+    }
+    /**
+     * Method used in the template to track ids in ngFor.
+     * @param number index of the array
+     * @param Image item of the array
+     * @returns number the id of the item
+     */
+    trackById(index, item) {
+        return item.id;
+    }
+    /**
+     * Method used in template to sanitize an url when you need legacyIE11Mode.
+     * In this way you can set an url as background of a div.
+     * @param unsafeStyle is a string or a SafeResourceUrl that represents the url to sanitize.
+     * @param unsafeStyleFallback is a string or a SafeResourceUrl that represents the fallback url to sanitize.
+     * @returns a SafeStyle object that can be used in template without problems.
+     */
+    sanitizeUrlBgStyle(unsafeStyle, unsafeStyleFallback) {
+        // Method used only to sanitize background-image style before add it to background property when legacyIE11Mode is enabled
+        let bg = 'url(' + unsafeStyle + ')';
+        if (!!unsafeStyleFallback) {
+            // if a fallback image is defined, append it. In this way, it will be used by the browser as fallback.
+            bg += ', ' + 'url(' + unsafeStyleFallback + ')';
+        }
+        return this.sanitizer.bypassSecurityTrustStyle(bg);
+    }
+    /**
+     * Method to cleanup resources. In fact, it cleans breakpointSubscription.
+     * This is an Angular's lifecycle hook that is called when this component is destroyed.
+     */
+    ngOnDestroy() {
+        if (this.breakpointSubscription) {
+            this.breakpointSubscription.unsubscribe();
+        }
+    }
+    /**
+     * Private method to init previews based on the currentImage and the full array of images.
+     * The current image in mandatory to show always the current preview (as highlighted).
+     * @param InternalLibImage currentImage to decide how to show previews, because I always want to see the current image as highlighted
+     * @param InternalLibImage[] images is the array of all images.
+     */
+    initPreviews(currentImage, images) {
+        let index;
+        try {
+            index = getIndex(currentImage, images);
+        }
+        catch (err) {
+            throw err;
+        }
+        switch (index) {
+            case 0:
+                // first image
+                this.setBeginningIndexesPreviews();
+                break;
+            case images.length - 1:
+                // last image
+                this.setEndIndexesPreviews();
+                break;
+            // default:
+            //   // other images
+            //   // TODO unused because it starts always at image 0
+            //   this.setIndexesPreviews();
+            //   break;
+        }
+        this.previews = images.filter((img, i) => i >= this.start && i < this.end);
+    }
+    /**
+     * Private method to init both `start` and `end` to the beginning.
+     */
+    setBeginningIndexesPreviews() {
+        if (!this.previewConfig || this.previewConfig.number === undefined) {
+            throw new Error('Internal library error - previewConfig and number must be defined');
+        }
+        this.start = 0;
+        this.end = Math.min(this.previewConfig.number, this.images.length);
+    }
+    /**
+     * Private method to init both `start` and `end` to the end.
+     */
+    setEndIndexesPreviews() {
+        if (!this.previewConfig || this.previewConfig.number === undefined) {
+            throw new Error('Internal library error - previewConfig and number must be defined');
+        }
+        this.start = this.images.length - 1 - (this.previewConfig.number - 1);
+        this.end = this.images.length;
+    }
+    /**
+     * Private method to update the visible previews navigating to the right (next).
+     */
+    next() {
+        // check if nextImage should be blocked
+        if (this.isPreventSliding(this.images.length - 1)) {
+            return;
+        }
+        if (this.end === this.images.length) {
+            return;
+        }
+        this.start++;
+        this.end = Math.min(this.end + 1, this.images.length);
+        this.previews = this.images.filter((img, i) => i >= this.start && i < this.end);
+    }
+    /**
+     * Private method to update the visible previews navigating to the left (previous).
+     */
+    previous() {
+        // check if prevImage should be blocked
+        if (this.isPreventSliding(0)) {
+            return;
+        }
+        if (this.start === 0) {
+            return;
+        }
+        this.start = Math.max(this.start - 1, 0);
+        this.end = Math.min(this.end - 1, this.images.length);
+        this.previews = this.images.filter((img, i) => i >= this.start && i < this.end);
+    }
+    /**
+     * Private method to block/permit sliding between previews.
+     * @param number boundaryIndex is the first or the last index of `images` input array
+     * @returns boolean if true block sliding, otherwise not
+     */
+    isPreventSliding(boundaryIndex) {
+        return getIndex(this.currentImage, this.images) === boundaryIndex;
+    }
+}
+CarouselPreviewsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CarouselPreviewsComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.BreakpointObserver }, { token: i2.DomSanitizer }, { token: i3.ConfigService }], target: i0.ɵɵFactoryTarget.Component });
+CarouselPreviewsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: CarouselPreviewsComponent, selector: "ks-carousel-previews", inputs: { id: "id", currentImage: "currentImage", images: "images" }, outputs: { clickPreview: "clickPreview" }, host: { properties: { "style.max-width": "this.hostMaxWidth", "attr.aria-label": "this.ariaLabel" } }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<nav *ngIf=\"previewConfig?.visible\"\n     class=\"previews-container\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewsContainerAriaLabel\"\n     [title]=\"accessibilityConfig?.carouselPreviewsContainerTitle\">\n\n  <a class=\"nav-left\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewScrollPrevAriaLabel\"\n     [tabIndex]=\"previewConfig?.arrows && start > 0 ? 0 : -1\" role=\"button\"\n     (click)=\"onNavigationEvent('left', $event)\" (keyup)=\"onNavigationEvent('left', $event)\">\n    <div class=\"inside {{previewConfig?.arrows && start > 0 ? 'left-arrow-preview-image' : 'empty-arrow-preview-image'}}\"\n         aria-hidden=\"true\"\n         [title]=\"accessibilityConfig?.carouselPreviewScrollPrevTitle\"></div>\n  </a>\n\n  <div class=\"preview-inner-container\">\n    <ng-container *ngFor=\"let preview of previews; trackBy: trackById; let index = index\">\n      <img *ngIf=\"preview?.modal?.img\"\n           class=\"inside preview-image{{isActive(preview) ? ' active' : ''}}{{!previewConfig?.clickable ? ' unclickable' : ''}}\"\n           [src]=\"preview.plain?.img ? preview.plain?.img : preview.modal.img\"\n           ksFallbackImage [fallbackImg]=\"preview.plain?.fallbackImg ? preview.plain?.fallbackImg : preview.modal.fallbackImg\"\n           ksSize [sizeConfig]=\"{width: previewConfig?.width!,\n                                 height: previewMaxHeight}\"\n           [attr.aria-label]=\"getAriaLabel(preview)\"\n           [title]=\"getTitle(preview)\"\n           alt=\"{{getAlt(preview)}}\"\n           [tabIndex]=\"0\" role=\"img\"\n           (click)=\"onImageEvent(preview, $event, clickAction)\" (keyup)=\"onImageEvent(preview, $event, keyboardAction)\"/>\n    </ng-container>\n  </div>\n\n  <a class=\"nav-right\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewScrollNextAriaLabel\"\n     [tabIndex]=\"previewConfig?.arrows && end < images.length ? 0 : -1\" role=\"button\"\n     (click)=\"onNavigationEvent('right', $event)\" (keyup)=\"onNavigationEvent('right', $event)\">\n    <div class=\"inside {{previewConfig?.arrows && end < images.length ? 'right-arrow-preview-image' : 'empty-arrow-preview-image'}}\"\n         aria-hidden=\"true\"\n         [title]=\"accessibilityConfig?.carouselPreviewScrollNextTitle\"></div>\n  </a>\n\n</nav>\n", styles: [":host{position:relative;margin-top:3px;margin-bottom:3px;width:100%}.previews-container{align-items:center;animation:fadein-semi-visible08 .8s;display:flex;flex-direction:row;justify-content:center;margin-bottom:0}.previews-container>.preview-inner-container{display:flex;flex-direction:row;justify-content:center;align-items:center;flex-wrap:nowrap;width:100%}.previews-container>.preview-inner-container>.preview-image{cursor:pointer;object-fit:cover}.previews-container>.preview-inner-container>.preview-image.unclickable{cursor:not-allowed}.previews-container .nav,.previews-container>.nav-right,.previews-container>.nav-left{position:absolute;top:calc(50% - 7px);color:#919191;z-index:1000;cursor:pointer;transition:all .5s}.previews-container .nav:hover,.previews-container>.nav-right:hover,.previews-container>.nav-left:hover{transform:scale(1.1)}.previews-container>.nav-left{margin-right:10px;left:10px}.previews-container>.nav-left>.left-arrow-preview-image{opacity:1}.previews-container>.nav-right{margin-left:10px;right:10px}.previews-container>.nav-right>.right-arrow-preview-image{opacity:1}\n", ".arrow-preview-image,.right-arrow-preview-image,.left-arrow-preview-image,.empty-arrow-preview-image{width:15px;height:15px;opacity:.5}.empty-arrow-preview-image{background:black;opacity:0}.left-arrow-preview-image{background-image:url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iaXNvLTg4NTktMSI/PjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgdmVyc2lvbj0iMS4xIiBpZD0iQ2FwYV8xIiB4PSIwcHgiIHk9IjBweCIgdmlld0JveD0iMCAwIDQ3Ny4xNzUgNDc3LjE3NSIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgNDc3LjE3NSA0NzcuMTc1OyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgd2lkdGg9IjUxMnB4IiBoZWlnaHQ9IjUxMnB4Ij48Zz48cGF0aCBkPSJNMTQ1LjE4OCwyMzguNTc1bDIxNS41LTIxNS41YzUuMy01LjMsNS4zLTEzLjgsMC0xOS4xcy0xMy44LTUuMy0xOS4xLDBsLTIyNS4xLDIyNS4xYy01LjMsNS4zLTUuMywxMy44LDAsMTkuMWwyMjUuMSwyMjUgICBjMi42LDIuNiw2LjEsNCw5LjUsNHM2LjktMS4zLDkuNS00YzUuMy01LjMsNS4zLTEzLjgsMC0xOS4xTDE0NS4xODgsMjM4LjU3NXoiIGZpbGw9IiNGRkZGRkYiLz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PC9zdmc+);background-size:15px;transition:all .5s}.left-arrow-preview-image:hover{transform:scale(1.2)}.right-arrow-preview-image{background-image:url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iaXNvLTg4NTktMSI/PjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgdmVyc2lvbj0iMS4xIiBpZD0iQ2FwYV8xIiB4PSIwcHgiIHk9IjBweCIgdmlld0JveD0iMCAwIDQ3Ny4xNzUgNDc3LjE3NSIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgNDc3LjE3NSA0NzcuMTc1OyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgd2lkdGg9IjUxMnB4IiBoZWlnaHQ9IjUxMnB4Ij48Zz48cGF0aCBkPSJNMzYwLjczMSwyMjkuMDc1bC0yMjUuMS0yMjUuMWMtNS4zLTUuMy0xMy44LTUuMy0xOS4xLDBzLTUuMywxMy44LDAsMTkuMWwyMTUuNSwyMTUuNWwtMjE1LjUsMjE1LjUgICBjLTUuMyw1LjMtNS4zLDEzLjgsMCwxOS4xYzIuNiwyLjYsNi4xLDQsOS41LDRjMy40LDAsNi45LTEuMyw5LjUtNGwyMjUuMS0yMjUuMUMzNjUuOTMxLDI0Mi44NzUsMzY1LjkzMSwyMzQuMjc1LDM2MC43MzEsMjI5LjA3NXogICAiIGZpbGw9IiNGRkZGRkYiLz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PC9zdmc+);background-size:15px;transition:all .5s}.right-arrow-preview-image:hover{transform:scale(1.2)}\n"], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.FallbackImageDirective, selector: "[ksFallbackImage]", inputs: ["fallbackImg"], outputs: ["fallbackApplied"] }, { type: i6.SizeDirective, selector: "[ksSize]", inputs: ["sizeConfig"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CarouselPreviewsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ks-carousel-previews', changeDetection: ChangeDetectionStrategy.OnPush, template: "<nav *ngIf=\"previewConfig?.visible\"\n     class=\"previews-container\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewsContainerAriaLabel\"\n     [title]=\"accessibilityConfig?.carouselPreviewsContainerTitle\">\n\n  <a class=\"nav-left\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewScrollPrevAriaLabel\"\n     [tabIndex]=\"previewConfig?.arrows && start > 0 ? 0 : -1\" role=\"button\"\n     (click)=\"onNavigationEvent('left', $event)\" (keyup)=\"onNavigationEvent('left', $event)\">\n    <div class=\"inside {{previewConfig?.arrows && start > 0 ? 'left-arrow-preview-image' : 'empty-arrow-preview-image'}}\"\n         aria-hidden=\"true\"\n         [title]=\"accessibilityConfig?.carouselPreviewScrollPrevTitle\"></div>\n  </a>\n\n  <div class=\"preview-inner-container\">\n    <ng-container *ngFor=\"let preview of previews; trackBy: trackById; let index = index\">\n      <img *ngIf=\"preview?.modal?.img\"\n           class=\"inside preview-image{{isActive(preview) ? ' active' : ''}}{{!previewConfig?.clickable ? ' unclickable' : ''}}\"\n           [src]=\"preview.plain?.img ? preview.plain?.img : preview.modal.img\"\n           ksFallbackImage [fallbackImg]=\"preview.plain?.fallbackImg ? preview.plain?.fallbackImg : preview.modal.fallbackImg\"\n           ksSize [sizeConfig]=\"{width: previewConfig?.width!,\n                                 height: previewMaxHeight}\"\n           [attr.aria-label]=\"getAriaLabel(preview)\"\n           [title]=\"getTitle(preview)\"\n           alt=\"{{getAlt(preview)}}\"\n           [tabIndex]=\"0\" role=\"img\"\n           (click)=\"onImageEvent(preview, $event, clickAction)\" (keyup)=\"onImageEvent(preview, $event, keyboardAction)\"/>\n    </ng-container>\n  </div>\n\n  <a class=\"nav-right\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewScrollNextAriaLabel\"\n     [tabIndex]=\"previewConfig?.arrows && end < images.length ? 0 : -1\" role=\"button\"\n     (click)=\"onNavigationEvent('right', $event)\" (keyup)=\"onNavigationEvent('right', $event)\">\n    <div class=\"inside {{previewConfig?.arrows && end < images.length ? 'right-arrow-preview-image' : 'empty-arrow-preview-image'}}\"\n         aria-hidden=\"true\"\n         [title]=\"accessibilityConfig?.carouselPreviewScrollNextTitle\"></div>\n  </a>\n\n</nav>\n", styles: [":host{position:relative;margin-top:3px;margin-bottom:3px;width:100%}.previews-container{align-items:center;animation:fadein-semi-visible08 .8s;display:flex;flex-direction:row;justify-content:center;margin-bottom:0}.previews-container>.preview-inner-container{display:flex;flex-direction:row;justify-content:center;align-items:center;flex-wrap:nowrap;width:100%}.previews-container>.preview-inner-container>.preview-image{cursor:pointer;object-fit:cover}.previews-container>.preview-inner-container>.preview-image.unclickable{cursor:not-allowed}.previews-container .nav,.previews-container>.nav-right,.previews-container>.nav-left{position:absolute;top:calc(50% - 7px);color:#919191;z-index:1000;cursor:pointer;transition:all .5s}.previews-container .nav:hover,.previews-container>.nav-right:hover,.previews-container>.nav-left:hover{transform:scale(1.1)}.previews-container>.nav-left{margin-right:10px;left:10px}.previews-container>.nav-left>.left-arrow-preview-image{opacity:1}.previews-container>.nav-right{margin-left:10px;right:10px}.previews-container>.nav-right>.right-arrow-preview-image{opacity:1}\n", ".arrow-preview-image,.right-arrow-preview-image,.left-arrow-preview-image,.empty-arrow-preview-image{width:15px;height:15px;opacity:.5}.empty-arrow-preview-image{background:black;opacity:0}.left-arrow-preview-image{background-image:url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iaXNvLTg4NTktMSI/PjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgdmVyc2lvbj0iMS4xIiBpZD0iQ2FwYV8xIiB4PSIwcHgiIHk9IjBweCIgdmlld0JveD0iMCAwIDQ3Ny4xNzUgNDc3LjE3NSIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgNDc3LjE3NSA0NzcuMTc1OyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgd2lkdGg9IjUxMnB4IiBoZWlnaHQ9IjUxMnB4Ij48Zz48cGF0aCBkPSJNMTQ1LjE4OCwyMzguNTc1bDIxNS41LTIxNS41YzUuMy01LjMsNS4zLTEzLjgsMC0xOS4xcy0xMy44LTUuMy0xOS4xLDBsLTIyNS4xLDIyNS4xYy01LjMsNS4zLTUuMywxMy44LDAsMTkuMWwyMjUuMSwyMjUgICBjMi42LDIuNiw2LjEsNCw5LjUsNHM2LjktMS4zLDkuNS00YzUuMy01LjMsNS4zLTEzLjgsMC0xOS4xTDE0NS4xODgsMjM4LjU3NXoiIGZpbGw9IiNGRkZGRkYiLz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PC9zdmc+);background-size:15px;transition:all .5s}.left-arrow-preview-image:hover{transform:scale(1.2)}.right-arrow-preview-image{background-image:url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iaXNvLTg4NTktMSI/PjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgdmVyc2lvbj0iMS4xIiBpZD0iQ2FwYV8xIiB4PSIwcHgiIHk9IjBweCIgdmlld0JveD0iMCAwIDQ3Ny4xNzUgNDc3LjE3NSIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgNDc3LjE3NSA0NzcuMTc1OyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgd2lkdGg9IjUxMnB4IiBoZWlnaHQ9IjUxMnB4Ij48Zz48cGF0aCBkPSJNMzYwLjczMSwyMjkuMDc1bC0yMjUuMS0yMjUuMWMtNS4zLTUuMy0xMy44LTUuMy0xOS4xLDBzLTUuMywxMy44LDAsMTkuMWwyMTUuNSwyMTUuNWwtMjE1LjUsMjE1LjUgICBjLTUuMyw1LjMtNS4zLDEzLjgsMCwxOS4xYzIuNiwyLjYsNi4xLDQsOS41LDRjMy40LDAsNi45LTEuMyw5LjUtNGwyMjUuMS0yMjUuMUMzNjUuOTMxLDI0Mi44NzUsMzY1LjkzMSwyMzQuMjc1LDM2MC43MzEsMjI5LjA3NXogICAiIGZpbGw9IiNGRkZGRkYiLz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PGc+PC9nPjxnPjwvZz48Zz48L2c+PC9zdmc+);background-size:15px;transition:all .5s}.right-arrow-preview-image:hover{transform:scale(1.2)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.BreakpointObserver }, { type: i2.DomSanitizer }, { type: i3.ConfigService }]; }, propDecorators: { hostMaxWidth: [{
+                type: HostBinding,
+                args: ['style.max-width']
+            }], ariaLabel: [{
+                type: HostBinding,
+                args: ['attr.aria-label']
+            }], 
+        // @ts-ignore
+        id: [{
+                type: Input
+            }], 
+        // @ts-ignore
+        currentImage: [{
+                type: Input
+            }], 
+        // @ts-ignore
+        images: [{
+                type: Input
+            }], clickPreview: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel-previews.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ks89/angular-modal-gallery/src/lib/components/carousel/carousel-previews/carousel-previews.component.ts","../../../../../../../../projects/ks89/angular-modal-gallery/src/lib/components/carousel/carousel-previews/carousel-previews.html"],"names":[],"mappings":"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","sourcesContent":["/*\n The MIT License (MIT)\n\n Copyright (C) 2017-2021 Stefano Cappa (Ks89)\n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in all\n copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n SOFTWARE.\n */\n\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  HostBinding,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChange,\n  SimpleChanges\n} from '@angular/core';\nimport { DomSanitizer, SafeResourceUrl, SafeStyle } from '@angular/platform-browser';\nimport { BreakpointObserver, Breakpoints, BreakpointState } from '@angular/cdk/layout';\n\nimport { Subscription } from 'rxjs';\n\nimport { AccessibleComponent } from '../../accessible.component';\n\nimport { AccessibilityConfig } from '../../../model/accessibility.interface';\nimport { Image, ImageEvent } from '../../../model/image.class';\nimport { InternalLibImage } from '../../../model/image-internal.class';\nimport { CarouselPreviewConfig } from '../../../model/carousel-preview-config.interface';\nimport { CarouselConfig } from '../../../model/carousel-config.interface';\n\nimport { NEXT, PREV } from '../../../utils/user-input.util';\nimport { getIndex } from '../../../utils/image.util';\nimport { Action } from '../../../model/action.enum';\nimport { ConfigService } from '../../../services/config.service';\nimport { LibConfig } from '../../../model/lib-config.interface';\n\n/**\n * Default max height of previews.\n */\nconst DEFAULT_MAX_HEIGHT = '200px';\n\n/**\n * Component with image previews for carousel\n */\n@Component({\n  selector: 'ks-carousel-previews',\n  styleUrls: ['carousel-previews.scss', '../../previews-arrows.scss'],\n  templateUrl: 'carousel-previews.html',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class CarouselPreviewsComponent extends AccessibleComponent implements OnInit, OnChanges, OnDestroy {\n  /**\n   * Variable to change the max-width of the host component\n   */\n  @HostBinding('style.max-width')\n  hostMaxWidth = '100%';\n\n  /**\n   * Variable to set aria-label of the host component\n   */\n  @HostBinding('attr.aria-label')\n  ariaLabel = `Carousel previews`;\n\n  /**\n   * TODO write doc\n   */\n  @Input()\n  // @ts-ignore\n  id: number;\n  /**\n   * Object of type `InternalLibImage` that represent the visible image.\n   */\n  @Input()\n  // @ts-ignore\n  currentImage: InternalLibImage;\n  /**\n   * Array of `InternalLibImage` that represent the model of this library with all images,\n   * thumbs and so on.\n   */\n  @Input()\n  // @ts-ignore\n  images: InternalLibImage[];\n\n  /**\n   * Output to emit the clicked preview. The payload contains the `InternalLibImage` associated to the clicked preview.\n   */\n  @Output()\n  clickPreview: EventEmitter<ImageEvent> = new EventEmitter<ImageEvent>();\n\n  /**\n   * Object of type `CarouselConfig` to init CarouselComponent's features.\n   * For instance, it contains parameters to change the style, how it navigates and so on.\n   */\n  carouselConfig: CarouselConfig | undefined;\n  /**\n   * Object of type `CarouselPreviewConfig` to init PreviewsComponent's features.\n   * For instance, it contains a param to show/hide this component, sizes.\n   */\n  previewConfig: CarouselPreviewConfig | 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 | undefined;\n  /**\n   * Enum of type `Action` that represents a mouse click on a button.\n   * Declared here to be used inside the template.\n   */\n  clickAction: Action = Action.CLICK;\n  /**\n   * Enum of type `Action` that represents a keyboard action.\n   * Declared here to be used inside the template.\n   */\n  keyboardAction: Action = Action.KEYBOARD;\n  /**\n   * Array of `InternalLibImage` exposed to the template. This field is initialized\n   * applying transformations, default values and so on to the input of the same type.\n   */\n  previews: InternalLibImage[] = [];\n  /**\n   * Variable with the preview's maxHeight\n   */\n  previewMaxHeight: string = DEFAULT_MAX_HEIGHT;\n  /**\n   * Start index (inclusive) of the input images used to display previews.\n   */\n  // @ts-ignore\n  start: number;\n  /**\n   * End index (non inclusive) of the input images used to display previews.\n   */\n  // @ts-ignore\n  end: number;\n\n  private readonly breakpointSubscription: Subscription;\n\n  constructor(\n    private ref: ChangeDetectorRef,\n    private breakpointObserver: BreakpointObserver,\n    // sanitizer is used only to sanitize style before add it to background property when legacyIE11Mode is enabled\n    private sanitizer: DomSanitizer,\n    private configService: ConfigService\n  ) {\n    super();\n\n    // listen for width changes and update preview heights accordingly\n    this.breakpointSubscription = breakpointObserver\n      .observe([Breakpoints.XSmall, Breakpoints.Small, Breakpoints.Medium, Breakpoints.Large, Breakpoints.XLarge])\n      .subscribe((result: BreakpointState) => {\n        if (!this.previewConfig || !this.previewConfig.breakpoints) {\n          return;\n        }\n        if (result.breakpoints[Breakpoints.XSmall]) {\n          this.updateHeight(this.previewConfig.breakpoints.xSmall);\n        } else if (result.breakpoints[Breakpoints.Small]) {\n          this.updateHeight(this.previewConfig.breakpoints.small);\n        } else if (result.breakpoints[Breakpoints.Medium]) {\n          this.updateHeight(this.previewConfig.breakpoints.medium);\n        } else if (result.breakpoints[Breakpoints.Large]) {\n          this.updateHeight(this.previewConfig.breakpoints.large);\n        } else if (result.breakpoints[Breakpoints.XLarge]) {\n          this.updateHeight(this.previewConfig.breakpoints.xLarge);\n        }\n      });\n  }\n\n  /**\n   * Method to update the height of previews, passing the desired height as input.\n   * @param configBreakpointHeight is a number that represent the desired height to set.\n   */\n  private updateHeight(configBreakpointHeight: number): void {\n    if (this.previewConfig && this.previewConfig.maxHeight) {\n      const heightNum: number = +this.previewConfig.maxHeight.replace('/px/g', '').replace('/%/g', '');\n      this.previewMaxHeight = Math.min(configBreakpointHeight, heightNum) + 'px';\n    } else {\n      const heightNum: number = +DEFAULT_MAX_HEIGHT.replace('/px/g', '').replace('/%/g', '');\n      this.previewMaxHeight = Math.min(configBreakpointHeight, heightNum) + 'px';\n    }\n    this.ref.markForCheck();\n  }\n\n  /**\n   * Method ´ngOnInit´ to build `configPreview` applying a default value and also to\n   * init the `previews` array.\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    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    this.carouselConfig = libConfig.carouselConfig;\n    this.previewConfig = libConfig.carouselPreviewsConfig;\n    this.accessibilityConfig = libConfig.accessibilityConfig;\n\n    if (!this.previewConfig || !this.previewConfig.maxHeight || !this.previewConfig.breakpoints) {\n      throw new Error('Internal library error - previewConfig must be defined');\n    }\n    // change the max-width of this component if there is a specified width !== 100% in carouselConfig\n    if (this.carouselConfig && this.carouselConfig.maxWidth !== '100%') {\n      this.hostMaxWidth = this.carouselConfig.maxWidth;\n    }\n\n    this.previewMaxHeight = this.previewConfig.maxHeight;\n    // init previews based on currentImage and the full array of images\n    this.initPreviews(this.currentImage, this.images);\n\n    // apply custom height based on responsive breakpoints\n    // This is required, because the breakpointSubscription is not triggered at creation,\n    // but only when the width changes\n    const isXsmallScreen = this.breakpointObserver.isMatched(Breakpoints.XSmall);\n    const isSmallScreen = this.breakpointObserver.isMatched(Breakpoints.Small);\n    const isMediumScreen = this.breakpointObserver.isMatched(Breakpoints.Medium);\n    const isLargeScreen = this.breakpointObserver.isMatched(Breakpoints.Large);\n    const isxLargeScreen = this.breakpointObserver.isMatched(Breakpoints.XLarge);\n    if (isXsmallScreen) {\n      this.updateHeight(this.previewConfig.breakpoints.xSmall);\n    } else if (isSmallScreen) {\n      this.updateHeight(this.previewConfig.breakpoints.small);\n    } else if (isMediumScreen) {\n      this.updateHeight(this.previewConfig.breakpoints.medium);\n    } else if (isLargeScreen) {\n      this.updateHeight(this.previewConfig.breakpoints.large);\n    } else if (isxLargeScreen) {\n      this.updateHeight(this.previewConfig.breakpoints.xLarge);\n    }\n  }\n\n  /**\n   * Method to check if an image is active (i.e. a preview image).\n   * @param InternalLibImage preview is an image to check if it's active or not\n   * @returns boolean true if is active, false otherwise\n   */\n  isActive(preview: InternalLibImage): boolean {\n    if (!preview || !this.currentImage) {\n      return false;\n    }\n    return preview.id === this.currentImage.id;\n  }\n\n  /**\n   * Method ´ngOnChanges´ to update `previews` array.\n   * Also, both `start` and `end` local variables will be updated accordingly.\n   * This is an Angular's lifecycle hook, so its called automatically by Angular itself.\n   * In particular, it's called when any data-bound property of a directive changes!!!\n   */\n  ngOnChanges(changes: SimpleChanges): void {\n    const simpleChange: SimpleChange = changes.currentImage;\n    if (!simpleChange) {\n      return;\n    }\n\n    const prev: InternalLibImage = simpleChange.previousValue;\n    const current: InternalLibImage = simpleChange.currentValue;\n\n    if (current && changes.images && changes.images.previousValue && changes.images.currentValue) {\n      // I'm in this if statement, if input images are changed (for instance, because I removed one of them with the 'delete button',\n      // or because users changed the images array while modal gallery is still open).\n      // In this case, I have to re-init previews, because the input array of images is changed.\n      this.initPreviews(current, changes.images.currentValue);\n    }\n\n    if (prev && current && prev.id !== current.id) {\n      // to manage infinite sliding I have to reset both `start` and `end` at the beginning\n      // to show again previews from the first image.\n      // This happens when you navigate over the last image to return to the first one\n      let prevIndex: number;\n      let currentIndex: number;\n      try {\n        prevIndex = getIndex(prev, this.images);\n        currentIndex = getIndex(current, this.images);\n      } catch (err) {\n        console.error('Cannot get previous and current image indexes in previews');\n        throw err;\n      }\n\n      // apply a formula to get a values to be used to decide if go next, return back or stay without doing anything\n      const calc = Math.floor((this.end - this.start) / 2) + this.start;\n\n      if (prevIndex === this.images.length - 1 && currentIndex === 0) {\n        // first image\n        this.setBeginningIndexesPreviews();\n        this.previews = this.images.filter((img: InternalLibImage, i: number) => i >= this.start && i < this.end);\n        return;\n      }\n      // the same for the opposite case, when you navigate back from the fist image to go to the last one.\n      if (prevIndex === 0 && currentIndex === this.images.length - 1) {\n        // last image\n        this.setEndIndexesPreviews();\n        this.previews = this.images.filter((img: InternalLibImage, i: number) => i >= this.start && i < this.end);\n        return;\n      }\n\n      if (this.previewConfig && (this.previewConfig.number as number) % 2 === 0) {\n        if (calc > currentIndex) {\n          this.previous();\n        } else {\n          this.next();\n        }\n      } else {\n        if (calc > currentIndex) {\n          this.previous();\n        }\n        if (calc < currentIndex) {\n          this.next();\n        }\n      }\n    }\n  }\n\n  /**\n   * Method called by events from both keyboard and mouse on a preview.\n   * This will trigger the `clickpreview` output with the input preview as its payload.\n   * @param InternalLibImage preview that triggered this method\n   * @param KeyboardEvent | MouseEvent event payload\n   * @param Action that triggered this event (Action.NORMAL by default)\n   */\n  onImageEvent(preview: InternalLibImage, event: KeyboardEvent | MouseEvent, action: Action = Action.NORMAL): void {\n    if (!this.previewConfig || !this.previewConfig.clickable) {\n      return;\n    }\n    const clickedImageIndex: number = this.images.indexOf(preview);\n    const result: number = super.handleImageEvent(event);\n    if (result === NEXT) {\n      this.clickPreview.emit({ action, result: clickedImageIndex } as ImageEvent);\n    } else if (result === PREV) {\n      this.clickPreview.emit({ action, result: clickedImageIndex } as ImageEvent);\n    }\n  }\n\n  /**\n   * Method called by events from both keyboard and mouse on a navigation arrow.\n   * @param string direction of the navigation that can be either 'next' or 'prev'\n   * @param KeyboardEvent | MouseEvent event payload\n   */\n  onNavigationEvent(direction: string, event: KeyboardEvent | MouseEvent): void {\n    const result: number = super.handleNavigationEvent(direction, event);\n    if (result === NEXT) {\n      this.next();\n    } else if (result === PREV) {\n      this.previous();\n    }\n  }\n\n  /**\n   * Method to get aria-label text for a preview image.\n   * @param Image is the preview\n   */\n  getAriaLabel(preview: Image): string {\n    if (!preview.plain) {\n      return preview.modal.ariaLabel || '';\n    }\n    return preview.plain.ariaLabel || preview.modal.ariaLabel || '';\n  }\n\n  /**\n   * Method to get title text for a preview image.\n   * @param Image is the preview\n   */\n  getTitle(preview: Image): string {\n    if (!preview.plain) {\n      return preview.modal.title || '';\n    }\n    return preview.plain.title || preview.modal.title || '';\n  }\n\n  /**\n   * Method to get alt text for a preview image.\n   * @param Image is the preview\n   */\n  getAlt(preview: Image): string {\n    if (!preview.plain) {\n      return preview.modal.alt || '';\n    }\n    return preview.plain.alt || preview.modal.alt || '';\n  }\n\n  /**\n   * Method used in the template to track ids in ngFor.\n   * @param number index of the array\n   * @param Image item of the array\n   * @returns number the id of the item\n   */\n  trackById(index: number, item: Image): number {\n    return item.id;\n  }\n\n  /**\n   * Method used in template to sanitize an url when you need legacyIE11Mode.\n   * In this way you can set an url as background of a div.\n   * @param unsafeStyle is a string or a SafeResourceUrl that represents the url to sanitize.\n   * @param unsafeStyleFallback is a string or a SafeResourceUrl that represents the fallback url to sanitize.\n   * @returns a SafeStyle object that can be used in template without problems.\n   */\n  sanitizeUrlBgStyle(unsafeStyle: string | SafeResourceUrl, unsafeStyleFallback: string | SafeResourceUrl): SafeStyle {\n    // Method used only to sanitize background-image style before add it to background property when legacyIE11Mode is enabled\n    let bg: string = 'url(' + unsafeStyle + ')';\n    if (!!unsafeStyleFallback) {\n      // if a fallback image is defined, append it. In this way, it will be used by the browser as fallback.\n      bg += ', ' + 'url(' + unsafeStyleFallback + ')';\n    }\n    return this.sanitizer.bypassSecurityTrustStyle(bg);\n  }\n\n  /**\n   * Method to cleanup resources. In fact, it cleans breakpointSubscription.\n   * This is an Angular's lifecycle hook that is called when this component is destroyed.\n   */\n  ngOnDestroy(): void {\n    if (this.breakpointSubscription) {\n      this.breakpointSubscription.unsubscribe();\n    }\n  }\n\n  /**\n   * Private method to init previews based on the currentImage and the full array of images.\n   * The current image in mandatory to show always the current preview (as highlighted).\n   * @param InternalLibImage currentImage to decide how to show previews, because I always want to see the current image as highlighted\n   * @param InternalLibImage[] images is the array of all images.\n   */\n  private initPreviews(currentImage: InternalLibImage, images: InternalLibImage[]): void {\n    let index: number;\n    try {\n      index = getIndex(currentImage, images);\n    } catch (err) {\n      throw err;\n    }\n    switch (index) {\n      case 0:\n        // first image\n        this.setBeginningIndexesPreviews();\n        break;\n      case images.length - 1:\n        // last image\n        this.setEndIndexesPreviews();\n        break;\n      // default:\n      //   // other images\n      //   // TODO unused because it starts always at image 0\n      //   this.setIndexesPreviews();\n      //   break;\n    }\n    this.previews = images.filter((img: InternalLibImage, i: number) => i >= this.start && i < this.end);\n  }\n\n  /**\n   * Private method to init both `start` and `end` to the beginning.\n   */\n  private setBeginningIndexesPreviews(): void {\n    if (!this.previewConfig || this.previewConfig.number === undefined) {\n      throw new Error('Internal library error - previewConfig and number must be defined');\n    }\n\n    this.start = 0;\n    this.end = Math.min(this.previewConfig.number as number, this.images.length);\n  }\n\n  /**\n   * Private method to init both `start` and `end` to the end.\n   */\n  private setEndIndexesPreviews(): void {\n    if (!this.previewConfig || this.previewConfig.number === undefined) {\n      throw new Error('Internal library error - previewConfig and number must be defined');\n    }\n\n    this.start = this.images.length - 1 - ((this.previewConfig.number as number) - 1);\n    this.end = this.images.length;\n  }\n\n  /**\n   * Private method to update the visible previews navigating to the right (next).\n   */\n  private next(): void {\n    // check if nextImage should be blocked\n    if (this.isPreventSliding(this.images.length - 1)) {\n      return;\n    }\n\n    if (this.end === this.images.length) {\n      return;\n    }\n\n    this.start++;\n    this.end = Math.min(this.end + 1, this.images.length);\n\n    this.previews = this.images.filter((img: InternalLibImage, i: number) => i >= this.start && i < this.end);\n  }\n\n  /**\n   * Private method to update the visible previews navigating to the left (previous).\n   */\n  private previous(): void {\n    // check if prevImage should be blocked\n    if (this.isPreventSliding(0)) {\n      return;\n    }\n\n    if (this.start === 0) {\n      return;\n    }\n\n    this.start = Math.max(this.start - 1, 0);\n    this.end = Math.min(this.end - 1, this.images.length);\n\n    this.previews = this.images.filter((img: InternalLibImage, i: number) => i >= this.start && i < this.end);\n  }\n\n  /**\n   * Private method to block/permit sliding between previews.\n   * @param number boundaryIndex is the first or the last index of `images` input array\n   * @returns boolean if true block sliding, otherwise not\n   */\n  private isPreventSliding(boundaryIndex: number): boolean {\n    return getIndex(this.currentImage, this.images) === boundaryIndex;\n  }\n}\n","<nav *ngIf=\"previewConfig?.visible\"\n     class=\"previews-container\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewsContainerAriaLabel\"\n     [title]=\"accessibilityConfig?.carouselPreviewsContainerTitle\">\n\n  <a class=\"nav-left\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewScrollPrevAriaLabel\"\n     [tabIndex]=\"previewConfig?.arrows && start > 0 ? 0 : -1\" role=\"button\"\n     (click)=\"onNavigationEvent('left', $event)\" (keyup)=\"onNavigationEvent('left', $event)\">\n    <div class=\"inside {{previewConfig?.arrows && start > 0 ? 'left-arrow-preview-image' : 'empty-arrow-preview-image'}}\"\n         aria-hidden=\"true\"\n         [title]=\"accessibilityConfig?.carouselPreviewScrollPrevTitle\"></div>\n  </a>\n\n  <div class=\"preview-inner-container\">\n    <ng-container *ngFor=\"let preview of previews; trackBy: trackById; let index = index\">\n      <img *ngIf=\"preview?.modal?.img\"\n           class=\"inside preview-image{{isActive(preview) ? ' active' : ''}}{{!previewConfig?.clickable ? ' unclickable' : ''}}\"\n           [src]=\"preview.plain?.img ? preview.plain?.img : preview.modal.img\"\n           ksFallbackImage [fallbackImg]=\"preview.plain?.fallbackImg ? preview.plain?.fallbackImg : preview.modal.fallbackImg\"\n           ksSize [sizeConfig]=\"{width: previewConfig?.width!,\n                                 height: previewMaxHeight}\"\n           [attr.aria-label]=\"getAriaLabel(preview)\"\n           [title]=\"getTitle(preview)\"\n           alt=\"{{getAlt(preview)}}\"\n           [tabIndex]=\"0\" role=\"img\"\n           (click)=\"onImageEvent(preview, $event, clickAction)\" (keyup)=\"onImageEvent(preview, $event, keyboardAction)\"/>\n    </ng-container>\n  </div>\n\n  <a class=\"nav-right\"\n     [attr.aria-label]=\"accessibilityConfig?.carouselPreviewScrollNextAriaLabel\"\n     [tabIndex]=\"previewConfig?.arrows && end < images.length ? 0 : -1\" role=\"button\"\n     (click)=\"onNavigationEvent('right', $event)\" (keyup)=\"onNavigationEvent('right', $event)\">\n    <div class=\"inside {{previewConfig?.arrows && end < images.length ? 'right-arrow-preview-image' : 'empty-arrow-preview-image'}}\"\n         aria-hidden=\"true\"\n         [title]=\"accessibilityConfig?.carouselPreviewScrollNextTitle\"></div>\n  </a>\n\n</nav>\n"]}