@ks89/angular-modal-gallery 8.0.1 → 9.0.0

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

@@ -0,0 +1,187 @@
+import { Injectable, Injector } from '@angular/core';
+import { OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Subject } from 'rxjs';
+import { DIALOG_DATA } from './modal-gallery.tokens';
+import { ModalGalleryComponent } from './modal-gallery.component';
+import { ModalGalleryRef } from './modal-gallery-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "../../services/config.service";
+const DEFAULT_DIALOG_CONFIG = {
+    hasBackdrop: true,
+    backdropClass: 'ks-modal-gallery-backdrop',
+    panelClass: 'ks-modal-gallery-panel'
+};
+export class ModalGalleryService {
+    constructor(injector, overlay, configService) {
+        this.injector = injector;
+        this.overlay = overlay;
+        this.configService = configService;
+        this.updateImages = new Subject();
+        this.updateImages$ = this.updateImages.asObservable();
+    }
+    /**
+     * Method to open modal gallery passing the configuration
+     * @param config ModalGalleryConfig that contains: id, array of images, current image and optionally the configuration object
+     * @return ModalGalleryRef | undefined is the object used to listen for events.
+     */
+    open(config) {
+        // Returns an OverlayRef which is a PortalHost
+        const overlayRef = this.createOverlay();
+        // Instantiate a reference to the dialog
+        this.dialogRef = new ModalGalleryRef(overlayRef);
+        // Attach dialog container
+        const overlayComponent = this.attachDialogContainer(overlayRef, config, this.dialogRef);
+        overlayRef.backdropClick().subscribe(() => {
+            if (this.dialogRef) {
+                this.dialogRef.closeModal();
+            }
+        });
+        return this.dialogRef;
+    }
+    /**
+     * Method to close a modal gallery previously opened.
+     * @param id Unique identifier of the modal gallery
+     * @param clickOutside boolean is true if closed clicking on the modal backdrop, false otherwise.
+     */
+    close(id, clickOutside) {
+        const libConfig = this.configService.getConfig(id);
+        if (clickOutside) {
+            if (this.dialogRef && libConfig && libConfig.enableCloseOutside) {
+                this.dialogRef.closeModal();
+            }
+        }
+        else {
+            if (this.dialogRef) {
+                this.dialogRef.closeModal();
+            }
+        }
+    }
+    /**
+     * Method to update images array.
+     * @param images Image[] updated array of images
+     */
+    updateModalImages(images) {
+        this.updateImages.next(images);
+    }
+    /**
+     * Method to emit close event.
+     * @param event ImageModalEvent is the event payload
+     */
+    emitClose(event) {
+        if (!this.dialogRef) {
+            return;
+        }
+        this.dialogRef.emitClose(event);
+    }
+    /**
+     * Method to emit show event.
+     * @param event ImageModalEvent is the event payload
+     */
+    emitShow(event) {
+        if (!this.dialogRef) {
+            return;
+        }
+        this.dialogRef.emitShow(event);
+    }
+    /**
+     * Method to emit firstImage event.
+     * @param event ImageModalEvent is the event payload
+     */
+    emitFirstImage(event) {
+        if (!this.dialogRef) {
+            return;
+        }
+        this.dialogRef.emitFirstImage(event);
+    }
+    /**
+     * Method to emit lastImage event.
+     * @param event ImageModalEvent is the event payload
+     */
+    emitLastImage(event) {
+        if (!this.dialogRef) {
+            return;
+        }
+        this.dialogRef.emitLastImage(event);
+    }
+    /**
+     * Method to emit hasData event.
+     * @param event ImageModalEvent is the event payload
+     */
+    emitHasData(event) {
+        if (!this.dialogRef) {
+            return;
+        }
+        this.dialogRef.emitHasData(event);
+    }
+    /**
+     * Method to emit buttonBeforeHook event.
+     * @param event ButtonEvent is the event payload
+     */
+    emitButtonBeforeHook(event) {
+        if (!this.dialogRef) {
+            return;
+        }
+        this.dialogRef.emitButtonBeforeHook(event);
+    }
+    /**
+     * Method to emit buttonAfterHook event.
+     * @param event ButtonEvent is the event payload
+     */
+    emitButtonAfterHook(event) {
+        if (!this.dialogRef) {
+            return;
+        }
+        this.dialogRef.emitButtonAfterHook(event);
+    }
+    /**
+     * Private method to create an Overlay using Angular CDK APIs
+     * @private
+     */
+    createOverlay() {
+        const overlayConfig = this.getOverlayConfig();
+        return this.overlay.create(overlayConfig);
+    }
+    /**
+     * Private method to attach ModalGalleryComponent to the overlay.
+     * @param overlayRef OverlayRef is the Overlay object created using Angular CDK APIs
+     * @param config ModalGalleryConfig that contains: id, array of images, current image and optionally the configuration object
+     * @param dialogRef ModalGalleryRef is the object to control the dialog instance
+     * @private
+     */
+    attachDialogContainer(overlayRef, config, dialogRef) {
+        const injector = Injector.create({
+            parent: this.injector,
+            providers: [
+                { provide: ModalGalleryRef, useValue: dialogRef },
+                { provide: DIALOG_DATA, useValue: config }
+            ]
+        });
+        const containerPortal = new ComponentPortal(ModalGalleryComponent, null, injector);
+        const containerRef = overlayRef.attach(containerPortal);
+        return containerRef.instance;
+    }
+    /**
+     * Private method to create an OverlayConfig instance
+     * @private
+     */
+    getOverlayConfig() {
+        const positionStrategy = this.overlay.position().global().centerHorizontally().centerVertically();
+        const overlayConfig = new OverlayConfig({
+            hasBackdrop: DEFAULT_DIALOG_CONFIG.hasBackdrop,
+            backdropClass: DEFAULT_DIALOG_CONFIG.backdropClass,
+            panelClass: DEFAULT_DIALOG_CONFIG.panelClass,
+            scrollStrategy: this.overlay.scrollStrategies.block(),
+            positionStrategy
+        });
+        return overlayConfig;
+    }
+}
+ModalGalleryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ModalGalleryService, deps: [{ token: i0.Injector }, { token: i1.Overlay }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+ModalGalleryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ModalGalleryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ModalGalleryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.Overlay }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-gallery.service.js","sourceRoot":"","sources":["../../../../../../../projects/ks89/angular-modal-gallery/src/lib/components/modal-gallery/modal-gallery.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, ComponentRef } from '@angular/core';\n\nimport { GlobalPositionStrategy, Overlay, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\n\nimport { Subject } from 'rxjs';\n\nimport { DIALOG_DATA } from './modal-gallery.tokens';\nimport { ModalGalleryComponent } from './modal-gallery.component';\nimport { ModalGalleryRef } from './modal-gallery-ref';\nimport { Image, ImageModalEvent } from '../../model/image.class';\nimport { ConfigService } from '../../services/config.service';\nimport { ButtonEvent } from '../../model/buttons-config.interface';\nimport { ModalGalleryConfig } from '../../model/modal-gallery-config.interface';\nimport { LibConfig } from '../../model/lib-config.interface';\n\n// private interface used only in this file\ninterface ModalDialogConfig {\n  panelClass: string;\n  hasBackdrop: boolean;\n  backdropClass: string;\n}\n\nconst DEFAULT_DIALOG_CONFIG: ModalDialogConfig = {\n  hasBackdrop: true,\n  backdropClass: 'ks-modal-gallery-backdrop',\n  panelClass: 'ks-modal-gallery-panel'\n};\n\n@Injectable({ providedIn: 'root' })\nexport class ModalGalleryService {\n  private updateImages = new Subject<Image[]>();\n  updateImages$ = this.updateImages.asObservable();\n\n  private dialogRef: ModalGalleryRef | undefined;\n\n  constructor(private injector: Injector, private overlay: Overlay, private configService: ConfigService) {}\n\n  /**\n   * Method to open modal gallery passing the configuration\n   * @param config ModalGalleryConfig that contains: id, array of images, current image and optionally the configuration object\n   * @return ModalGalleryRef | undefined is the object used to listen for events.\n   */\n  open(config: ModalGalleryConfig): ModalGalleryRef | undefined {\n    // Returns an OverlayRef which is a PortalHost\n    const overlayRef: OverlayRef = this.createOverlay();\n    // Instantiate a reference to the dialog\n    this.dialogRef = new ModalGalleryRef(overlayRef);\n    // Attach dialog container\n    const overlayComponent: ModalGalleryComponent = this.attachDialogContainer(overlayRef, config, this.dialogRef);\n    overlayRef.backdropClick().subscribe(() => {\n      if (this.dialogRef) {\n        this.dialogRef.closeModal();\n      }\n    });\n    return this.dialogRef;\n  }\n\n  /**\n   * Method to close a modal gallery previously opened.\n   * @param id Unique identifier of the modal gallery\n   * @param clickOutside boolean is true if closed clicking on the modal backdrop, false otherwise.\n   */\n  close(id: number, clickOutside: boolean): void {\n    const libConfig: LibConfig | undefined = this.configService.getConfig(id);\n    if (clickOutside) {\n      if (this.dialogRef && libConfig && libConfig.enableCloseOutside) {\n        this.dialogRef.closeModal();\n      }\n    } else {\n      if (this.dialogRef) {\n        this.dialogRef.closeModal();\n      }\n    }\n  }\n\n  /**\n   * Method to update images array.\n   * @param images Image[] updated array of images\n   */\n  updateModalImages(images: Image[]): void {\n    this.updateImages.next(images);\n  }\n\n  /**\n   * Method to emit close event.\n   * @param event ImageModalEvent is the event payload\n   */\n  emitClose(event: ImageModalEvent): void {\n    if (!this.dialogRef) {\n      return;\n    }\n    this.dialogRef.emitClose(event);\n  }\n\n  /**\n   * Method to emit show event.\n   * @param event ImageModalEvent is the event payload\n   */\n  emitShow(event: ImageModalEvent): void {\n    if (!this.dialogRef) {\n      return;\n    }\n    this.dialogRef.emitShow(event);\n  }\n\n  /**\n   * Method to emit firstImage event.\n   * @param event ImageModalEvent is the event payload\n   */\n  emitFirstImage(event: ImageModalEvent): void {\n    if (!this.dialogRef) {\n      return;\n    }\n    this.dialogRef.emitFirstImage(event);\n  }\n\n  /**\n   * Method to emit lastImage event.\n   * @param event ImageModalEvent is the event payload\n   */\n  emitLastImage(event: ImageModalEvent): void {\n    if (!this.dialogRef) {\n      return;\n    }\n    this.dialogRef.emitLastImage(event);\n  }\n\n  /**\n   * Method to emit hasData event.\n   * @param event ImageModalEvent is the event payload\n   */\n  emitHasData(event: ImageModalEvent): void {\n    if (!this.dialogRef) {\n      return;\n    }\n    this.dialogRef.emitHasData(event);\n  }\n\n  /**\n   * Method to emit buttonBeforeHook event.\n   * @param event ButtonEvent is the event payload\n   */\n  emitButtonBeforeHook(event: ButtonEvent): void {\n    if (!this.dialogRef) {\n      return;\n    }\n    this.dialogRef.emitButtonBeforeHook(event);\n  }\n\n  /**\n   * Method to emit buttonAfterHook event.\n   * @param event ButtonEvent is the event payload\n   */\n  emitButtonAfterHook(event: ButtonEvent): void {\n    if (!this.dialogRef) {\n      return;\n    }\n    this.dialogRef.emitButtonAfterHook(event);\n  }\n\n  /**\n   * Private method to create an Overlay using Angular CDK APIs\n   * @private\n   */\n  private createOverlay(): OverlayRef {\n    const overlayConfig = this.getOverlayConfig();\n    return this.overlay.create(overlayConfig);\n  }\n\n  /**\n   * Private method to attach ModalGalleryComponent to the overlay.\n   * @param overlayRef OverlayRef is the Overlay object created using Angular CDK APIs\n   * @param config ModalGalleryConfig that contains: id, array of images, current image and optionally the configuration object\n   * @param dialogRef ModalGalleryRef is the object to control the dialog instance\n   * @private\n   */\n  private attachDialogContainer(overlayRef: OverlayRef, config: ModalGalleryConfig, dialogRef: ModalGalleryRef): ModalGalleryComponent {\n    const injector: Injector = Injector.create({\n      parent: this.injector,\n      providers: [\n        { provide: ModalGalleryRef, useValue: dialogRef },\n        { provide: DIALOG_DATA, useValue: config }\n      ]\n    });\n\n    const containerPortal = new ComponentPortal(ModalGalleryComponent, null, injector);\n    const containerRef: ComponentRef<ModalGalleryComponent> = overlayRef.attach(containerPortal);\n\n    return containerRef.instance;\n  }\n\n  /**\n   * Private method to create an OverlayConfig instance\n   * @private\n   */\n  private getOverlayConfig(): OverlayConfig {\n    const positionStrategy: GlobalPositionStrategy = this.overlay.position().global().centerHorizontally().centerVertically();\n\n    const overlayConfig: OverlayConfig = new OverlayConfig({\n      hasBackdrop: DEFAULT_DIALOG_CONFIG.hasBackdrop,\n      backdropClass: DEFAULT_DIALOG_CONFIG.backdropClass,\n      panelClass: DEFAULT_DIALOG_CONFIG.panelClass,\n      scrollStrategy: this.overlay.scrollStrategies.block(),\n      positionStrategy\n    });\n\n    return overlayConfig;\n  }\n}\n"]}

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

@@ -0,0 +1,249 @@
+/*
+ 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, Input, Output } from '@angular/core';
+import { GridLayout, LineLayout, PlainGalleryStrategy } from '../../model/plain-gallery-config.interface';
+import { getIndex } from '../../utils/image.util';
+import { NEXT } from '../../utils/user-input.util';
+import { AccessibleComponent } from '../accessible.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/config.service";
+import * as i2 from "../../directives/wrap.directive";
+import * as i3 from "../../directives/direction.directive";
+import * as i4 from "@angular/common";
+import * as i5 from "../../directives/fallback-image.directive";
+import * as i6 from "../../directives/size.directive";
+import * as i7 from "../../directives/a-tag-bg-image.directive";
+/**
+ * Component with the gallery of thumbs.
+ * In receives an array of Images, a boolean to show/hide
+ * the gallery (feature used by imagePointer) and a config
+ * object to customize the behaviour of this component.
+ * Also, it emits click events as outputs.
+ */
+export class PlainGalleryComponent extends AccessibleComponent {
+    constructor(configService) {
+        super();
+        this.configService = configService;
+        /**
+         * Array of `Image` that represent the model of this library with all images, thumbs and so on.
+         */
+        this.images = [];
+        /**
+         * Output to emit an event when an image is clicked.
+         */
+        this.clickImage = new EventEmitter();
+        /**
+         * Bi-dimensional array of `Image` object to store images to display as plain gallery.
+         * [] by default.
+         */
+        this.imageGrid = [];
+        /**
+         * Boolean passed as input to `ks-wrap` directive to configure flex-wrap css property.
+         * However it's not enough, because you need to limit the width using `widthStyle` public variable.
+         * For more info check https://developer.mozilla.org/it/docs/Web/CSS/flex-wrap
+         */
+        this.wrapStyle = false;
+        /**
+         * String passed as input to `ks-wrap` directive to set width to be able to force overflow.
+         * In this way, `wrapStyle` (flex-wrap css property) will be used as requested.
+         */
+        this.widthStyle = '';
+    }
+    /**
+     * Method ´ngOnInit´ to init both `configPlainGallery` calling `initPlainGalleryConfig()`
+     * and `imageGrid invoking `initImageGrid()`.
+     * This is an Angular's lifecycle hook, so its called automatically by Angular itself.
+     * In particular, it's called only one time!!!
+     */
+    ngOnInit() {
+        if (this.id === null || this.id === undefined) {
+            throw new Error('Internal library error - id must be defined');
+        }
+        this.configService.setConfig(this.id, this.config);
+        const libConfig = this.configService.getConfig(this.id);
+        if (!libConfig) {
+            throw new Error('Internal library error - libConfig must be defined');
+        }
+        this.accessibilityConfig = libConfig.accessibilityConfig;
+        this.plainGalleryConfig = libConfig.plainGalleryConfig;
+        this.initImageGrid();
+    }
+    /**
+     * Method ´ngOnChanges´ to update both `imageGrid` and`plainGalleryConfig`.
+     * 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) {
+        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 imagesChange = changes.images;
+        const configChange = changes.plainGalleryConfig;
+        // I'm using !change.firstChange because the first time will be called both onInit and onChange and I don't
+        // want to execute initialization two times.
+        if (configChange &&
+            !configChange.firstChange &&
+            (configChange.previousValue !== configChange.currentValue || (!configChange.previousValue && !configChange.currentValue))) {
+            this.plainGalleryConfig = libConfig.plainGalleryConfig;
+            // this.configPlainGallery = this.initPlainGalleryConfig();
+        }
+        if (imagesChange && !imagesChange.firstChange && imagesChange.previousValue !== imagesChange.currentValue) {
+            this.initImageGrid();
+        }
+    }
+    /**
+     * Method called when you click on an image of the plain (or inline) gallery.
+     * This will emit the show event with the image as payload.
+     * @param Image img is the Image to show
+     */
+    showModalGalleryByImage(img) {
+        const index = this.images.findIndex((val) => val && img && val.id === img.id);
+        this.showModalGallery(index);
+    }
+    /**
+     * Method called when you navigate between images.
+     * This will emit the show event with the image as payload.
+     * @param KeyboardEvent event that triggered the navigation
+     * @param Image img is the Image to show
+     */
+    onNavigationEvent(event, img) {
+        const result = super.handleImageEvent(event);
+        if (result === NEXT) {
+            this.showModalGalleryByImage(img);
+        }
+    }
+    /**
+     * Method to get `alt attribute`.
+     * `alt` specifies an alternate text for an image, if the image cannot be displayed.
+     * @param Image image to get its alt description.
+     * @returns string alt description of the image
+     */
+    getAltPlainDescriptionByImage(image) {
+        if (!image) {
+            return '';
+        }
+        return image.plain && image.plain.description ? image.plain.description : `Image ${getIndex(image, this.images) + 1}`;
+    }
+    /**
+     * Method to get the title for an image.
+     * @param Image image to get its title
+     * @returns string the title of the input image
+     */
+    getTitleDisplay(image) {
+        let description = '';
+        if (image.plain && image.plain.description) {
+            description = image.plain.description;
+        }
+        else if (image.modal && image.modal.description) {
+            description = image.modal.description;
+        }
+        const currentIndex = getIndex(image, this.images);
+        const prevDescription = 'Image ' + (currentIndex + 1) + '/' + this.images.length;
+        let currImgDescription = description ? description : '';
+        if (currImgDescription !== '') {
+            currImgDescription = ' - ' + currImgDescription;
+        }
+        return prevDescription + currImgDescription;
+    }
+    /**
+     * 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 called when you click on an image of the plain (or inline) gallery.
+     * This will emit the show event with the index number as payload.
+     * @param number index of the clicked image
+     */
+    showModalGallery(index) {
+        this.clickImage.emit(index);
+    }
+    /**
+     * Private method to init both `imageGrid` and other style variables,
+     * based on the layout type.
+     */
+    initImageGrid() {
+        if (!this.plainGalleryConfig) {
+            throw new Error('Internal library error - plainGalleryConfig must be defined');
+        }
+        // reset the array to prevent issues in case of GridLayout
+        this.imageGrid = [];
+        if (this.plainGalleryConfig.layout instanceof LineLayout) {
+            const layout = this.plainGalleryConfig.layout;
+            const row = this.images.filter((val, i) => i < layout.breakConfig.length || layout.breakConfig.length === -1);
+            this.imageGrid = [row];
+            this.size = this.plainGalleryConfig.layout.size;
+            switch (this.plainGalleryConfig.strategy) {
+                case PlainGalleryStrategy.ROW:
+                    this.directionStyle = 'row';
+                    break;
+                case PlainGalleryStrategy.COLUMN:
+                    this.directionStyle = 'column';
+                    this.wrapStyle = layout.breakConfig.wrap;
+                    break;
+            }
+            this.justifyStyle = layout.justify;
+        }
+        if (this.plainGalleryConfig.layout instanceof GridLayout) {
+            const layout = this.plainGalleryConfig.layout;
+            const count = Math.ceil(this.images.length / layout.breakConfig.length);
+            let start = 0;
+            let end = layout.breakConfig.length - 1;
+            for (let j = 0; j < count; j++) {
+                const row = this.images.filter((val, i) => i >= start && i <= end);
+                this.imageGrid.push(row);
+                start = end + 1;
+                end = start + layout.breakConfig.length - 1;
+            }
+            this.size = this.plainGalleryConfig.layout.size;
+            const pixels = +layout.size.width.replace('px', '');
+            this.widthStyle = pixels * layout.breakConfig.length + pixels / 2 + 'px';
+            this.wrapStyle = layout.breakConfig.wrap;
+            this.directionStyle = 'row';
+        }
+    }
+}
+PlainGalleryComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: PlainGalleryComponent, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Component });
+PlainGalleryComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: PlainGalleryComponent, selector: "ks-plain-gallery", inputs: { id: "id", images: "images", config: "config" }, outputs: { clickImage: "clickImage" }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div class=\"plain-container\"\n     ksWrap [wrap]=\"wrapStyle\" [width]=\"widthStyle\"\n     ksDirection [direction]=\"directionStyle\" [justify]=\"justifyStyle\"\n     [attr.aria-label]=\"accessibilityConfig?.plainGalleryContentAriaLabel\"\n     [title]=\"accessibilityConfig?.plainGalleryContentTitle\">\n\n  <ng-container *ngFor=\"let imgRow of imageGrid; let i = index\">\n    <ng-container *ngFor=\"let imgCol of imgRow; let j = index\">\n\n      <ng-container *ngIf=\"!plainGalleryConfig?.advanced?.aTags; else aTags\">\n        <img *ngIf=\"imgCol?.modal?.img\"\n             [src]=\"imgCol.plain?.img! ? imgCol.plain?.img! : imgCol.modal.img\"\n             ksFallbackImage [fallbackImg]=\"imgCol.plain?.fallbackImg ? imgCol.plain?.fallbackImg : imgCol.modal.fallbackImg\"\n             class=\"image\"\n             ksSize [sizeConfig]=\"{width: size?.width!, height: size?.height!}\"\n             [attr.aria-label]=\"imgCol.plain?.ariaLabel\"\n             [title]=\"(imgCol.plain?.title || imgCol.plain?.title === '') ? imgCol.plain?.title : getTitleDisplay(imgCol)\"\n             alt=\"{{imgCol.plain?.alt! ? imgCol.plain?.alt! : getAltPlainDescriptionByImage(imgCol)}}\"\n             [tabIndex]=\"0\" role=\"img\"\n             (click)=\"showModalGalleryByImage(imgCol)\" (keyup)=\"onNavigationEvent($event, imgCol)\"/>\n      </ng-container>\n\n      <!-- Add directive to set background with the image url as param to pass thumb or img-->\n      <!-- to do something like this <a style=\"background: url('path to image') 50% 50%/cover\">.-->\n      <ng-template #aTags>\n        <a *ngIf=\"imgCol?.modal?.img\"\n           class=\"a-tag-image\"\n           ksATagBgImage [image]=\"imgCol\" [style]=\"plainGalleryConfig?.advanced?.additionalBackground\"\n           ksSize [sizeConfig]=\"{width: size?.width!, height: size?.height!}\"\n           [attr.aria-label]=\"imgCol.plain?.ariaLabel\"\n           [title]=\"(imgCol.plain?.title || imgCol.plain?.title === '') ? imgCol.plain?.title : getTitleDisplay(imgCol)\"\n           [tabIndex]=\"0\"\n           (click)=\"showModalGalleryByImage(imgCol)\" (keyup)=\"onNavigationEvent($event, imgCol)\"></a>\n      </ng-template>\n\n    </ng-container>\n  </ng-container>\n\n</div>\n\n", styles: [".plain-container{align-items:center;display:flex}.plain-container .image{cursor:pointer;height:auto;margin:2px;width:50px}.plain-container .a-tag-image{cursor:pointer;margin:2px}\n"], directives: [{ type: i2.WrapDirective, selector: "[ksWrap]", inputs: ["wrap", "width"] }, { type: i3.DirectionDirective, selector: "[ksDirection]", inputs: ["direction", "justify"] }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.FallbackImageDirective, selector: "[ksFallbackImage]", inputs: ["fallbackImg"], outputs: ["fallbackApplied"] }, { type: i6.SizeDirective, selector: "[ksSize]", inputs: ["sizeConfig"] }, { type: i7.ATagBgImageDirective, selector: "[ksATagBgImage]", inputs: ["image", "style"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: PlainGalleryComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ks-plain-gallery', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"plain-container\"\n     ksWrap [wrap]=\"wrapStyle\" [width]=\"widthStyle\"\n     ksDirection [direction]=\"directionStyle\" [justify]=\"justifyStyle\"\n     [attr.aria-label]=\"accessibilityConfig?.plainGalleryContentAriaLabel\"\n     [title]=\"accessibilityConfig?.plainGalleryContentTitle\">\n\n  <ng-container *ngFor=\"let imgRow of imageGrid; let i = index\">\n    <ng-container *ngFor=\"let imgCol of imgRow; let j = index\">\n\n      <ng-container *ngIf=\"!plainGalleryConfig?.advanced?.aTags; else aTags\">\n        <img *ngIf=\"imgCol?.modal?.img\"\n             [src]=\"imgCol.plain?.img! ? imgCol.plain?.img! : imgCol.modal.img\"\n             ksFallbackImage [fallbackImg]=\"imgCol.plain?.fallbackImg ? imgCol.plain?.fallbackImg : imgCol.modal.fallbackImg\"\n             class=\"image\"\n             ksSize [sizeConfig]=\"{width: size?.width!, height: size?.height!}\"\n             [attr.aria-label]=\"imgCol.plain?.ariaLabel\"\n             [title]=\"(imgCol.plain?.title || imgCol.plain?.title === '') ? imgCol.plain?.title : getTitleDisplay(imgCol)\"\n             alt=\"{{imgCol.plain?.alt! ? imgCol.plain?.alt! : getAltPlainDescriptionByImage(imgCol)}}\"\n             [tabIndex]=\"0\" role=\"img\"\n             (click)=\"showModalGalleryByImage(imgCol)\" (keyup)=\"onNavigationEvent($event, imgCol)\"/>\n      </ng-container>\n\n      <!-- Add directive to set background with the image url as param to pass thumb or img-->\n      <!-- to do something like this <a style=\"background: url('path to image') 50% 50%/cover\">.-->\n      <ng-template #aTags>\n        <a *ngIf=\"imgCol?.modal?.img\"\n           class=\"a-tag-image\"\n           ksATagBgImage [image]=\"imgCol\" [style]=\"plainGalleryConfig?.advanced?.additionalBackground\"\n           ksSize [sizeConfig]=\"{width: size?.width!, height: size?.height!}\"\n           [attr.aria-label]=\"imgCol.plain?.ariaLabel\"\n           [title]=\"(imgCol.plain?.title || imgCol.plain?.title === '') ? imgCol.plain?.title : getTitleDisplay(imgCol)\"\n           [tabIndex]=\"0\"\n           (click)=\"showModalGalleryByImage(imgCol)\" (keyup)=\"onNavigationEvent($event, imgCol)\"></a>\n      </ng-template>\n\n    </ng-container>\n  </ng-container>\n\n</div>\n\n", styles: [".plain-container{align-items:center;display:flex}.plain-container .image{cursor:pointer;height:auto;margin:2px;width:50px}.plain-container .a-tag-image{cursor:pointer;margin:2px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }]; }, propDecorators: { id: [{
+                type: Input
+            }], images: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], clickImage: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plain-gallery.component.js","sourceRoot":"","sources":["../../../../../../../projects/ks89/angular-modal-gallery/src/lib/components/plain-gallery/plain-gallery.component.ts","../../../../../../../projects/ks89/angular-modal-gallery/src/lib/components/plain-gallery/plain-gallery.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 { ChangeDetectionStrategy, Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChange, SimpleChanges } from '@angular/core';\n\nimport { AccessibilityConfig } from '../../model/accessibility.interface';\nimport { Image } from '../../model/image.class';\nimport { Size } from '../../model/size.interface';\nimport { GridLayout, LineLayout, PlainGalleryConfig, PlainGalleryStrategy } from '../../model/plain-gallery-config.interface';\n\nimport { getIndex } from '../../utils/image.util';\nimport { ConfigService } from '../../services/config.service';\nimport { NEXT } from '../../utils/user-input.util';\nimport { AccessibleComponent } from '../accessible.component';\nimport { PlainLibConfig, LibConfig } from '../../model/lib-config.interface';\n\n/**\n * Component with the gallery of thumbs.\n * In receives an array of Images, a boolean to show/hide\n * the gallery (feature used by imagePointer) and a config\n * object to customize the behaviour of this component.\n * Also, it emits click events as outputs.\n */\n@Component({\n  selector: 'ks-plain-gallery',\n  styleUrls: ['plain-gallery.scss'],\n  templateUrl: 'plain-gallery.html',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PlainGalleryComponent extends AccessibleComponent implements OnInit, OnChanges {\n  /**\n   * Unique id (>=0) of the current instance of this library. This is required when you are using\n   * the service to call modal gallery.\n   */\n  @Input()\n  id: number | undefined;\n\n  /**\n   * Array of `Image` that represent the model of this library with all images, thumbs and so on.\n   */\n  @Input()\n  images: Image[] = [];\n  /**\n   * PlainLibConfig object to configure plain-gallery.\n   */\n  @Input()\n  config: PlainLibConfig | undefined;\n\n  /**\n   * Output to emit an event when an image is clicked.\n   */\n  @Output()\n  clickImage: EventEmitter<number> = new EventEmitter<number>();\n\n  /**\n   * Object of type `PlainGalleryConfig` to configure the plain gallery.\n   */\n  plainGalleryConfig: PlainGalleryConfig | undefined;\n\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  /**\n   * Bi-dimensional array of `Image` object to store images to display as plain gallery.\n   * [] by default.\n   */\n  imageGrid: Image[][] = [];\n  /**\n   * Size object used in the template to resize images.\n   */\n  size: Size | undefined;\n  /**\n   * Boolean passed as input to `ks-wrap` directive to configure flex-wrap css property.\n   * However it's not enough, because you need to limit the width using `widthStyle` public variable.\n   * For more info check https://developer.mozilla.org/it/docs/Web/CSS/flex-wrap\n   */\n  wrapStyle = false;\n  /**\n   * String passed as input to `ks-wrap` directive to set width to be able to force overflow.\n   * In this way, `wrapStyle` (flex-wrap css property) will be used as requested.\n   */\n  widthStyle = '';\n  /**\n   * String passed as input to `ks-direction` directive to set the flex-direction css property.\n   * For more info check https://developer.mozilla.org/it/docs/Web/CSS/flex-direction\n   */\n  directionStyle: string | undefined;\n  /**\n   * String passed as input to `ks-direction` directive to set the justify-content css property.\n   * For more info check https://developer.mozilla.org/it/docs/Web/CSS/justify-content\n   */\n  justifyStyle: string | undefined;\n\n  constructor(private configService: ConfigService) {\n    super();\n  }\n\n  /**\n   * Method ´ngOnInit´ to init both `configPlainGallery` calling `initPlainGalleryConfig()`\n   * and `imageGrid invoking `initImageGrid()`.\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    if (this.id === null || this.id === undefined) {\n      throw new Error('Internal library error - id must be defined');\n    }\n    this.configService.setConfig(this.id, this.config);\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    this.accessibilityConfig = libConfig.accessibilityConfig;\n    this.plainGalleryConfig = libConfig.plainGalleryConfig;\n    this.initImageGrid();\n  }\n\n  /**\n   * Method ´ngOnChanges´ to update both `imageGrid` and`plainGalleryConfig`.\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    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 imagesChange: SimpleChange = changes.images;\n    const configChange: SimpleChange = changes.plainGalleryConfig;\n\n    // I'm using !change.firstChange because the first time will be called both onInit and onChange and I don't\n    // want to execute initialization two times.\n    if (\n      configChange &&\n      !configChange.firstChange &&\n      (configChange.previousValue !== configChange.currentValue || (!configChange.previousValue && !configChange.currentValue))\n    ) {\n      this.plainGalleryConfig = libConfig.plainGalleryConfig;\n      // this.configPlainGallery = this.initPlainGalleryConfig();\n    }\n    if (imagesChange && !imagesChange.firstChange && imagesChange.previousValue !== imagesChange.currentValue) {\n      this.initImageGrid();\n    }\n  }\n\n  /**\n   * Method called when you click on an image of the plain (or inline) gallery.\n   * This will emit the show event with the image as payload.\n   * @param Image img is the Image to show\n   */\n  showModalGalleryByImage(img: Image): void {\n    const index: number = this.images.findIndex((val: Image) => val && img && val.id === img.id);\n    this.showModalGallery(index);\n  }\n\n  /**\n   * Method called when you navigate between images.\n   * This will emit the show event with the image as payload.\n   * @param KeyboardEvent event that triggered the navigation\n   * @param Image img is the Image to show\n   */\n  onNavigationEvent(event: KeyboardEvent, img: Image): void {\n    const result: number = super.handleImageEvent(event);\n    if (result === NEXT) {\n      this.showModalGalleryByImage(img);\n    }\n  }\n\n  /**\n   * Method to get `alt attribute`.\n   * `alt` specifies an alternate text for an image, if the image cannot be displayed.\n   * @param Image image to get its alt description.\n   * @returns string alt description of the image\n   */\n  getAltPlainDescriptionByImage(image: Image): string {\n    if (!image) {\n      return '';\n    }\n    return image.plain && image.plain.description ? image.plain.description : `Image ${getIndex(image, this.images) + 1}`;\n  }\n\n  /**\n   * Method to get the title for an image.\n   * @param Image image to get its title\n   * @returns string the title of the input image\n   */\n  getTitleDisplay(image: Image): string {\n    let description = '';\n\n    if (image.plain && image.plain.description) {\n      description = image.plain.description;\n    } else if (image.modal && image.modal.description) {\n      description = image.modal.description;\n    }\n\n    const currentIndex: number = getIndex(image, this.images);\n    const prevDescription: string = 'Image ' + (currentIndex + 1) + '/' + this.images.length;\n    let currImgDescription: string = description ? description : '';\n\n    if (currImgDescription !== '') {\n      currImgDescription = ' - ' + currImgDescription;\n    }\n    return prevDescription + currImgDescription;\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 called when you click on an image of the plain (or inline) gallery.\n   * This will emit the show event with the index number as payload.\n   * @param number index of the clicked image\n   */\n  private showModalGallery(index: number): void {\n    this.clickImage.emit(index);\n  }\n\n  /**\n   * Private method to init both `imageGrid` and other style variables,\n   * based on the layout type.\n   */\n  private initImageGrid(): void {\n    if (!this.plainGalleryConfig) {\n      throw new Error('Internal library error - plainGalleryConfig must be defined');\n    }\n\n    // reset the array to prevent issues in case of GridLayout\n    this.imageGrid = [];\n\n    if (this.plainGalleryConfig.layout instanceof LineLayout) {\n      const layout: LineLayout = this.plainGalleryConfig.layout;\n      const row: Image[] = this.images.filter((val: Image, i: number) => i < layout.breakConfig.length || layout.breakConfig.length === -1);\n      this.imageGrid = [row];\n\n      this.size = this.plainGalleryConfig.layout.size;\n\n      switch (this.plainGalleryConfig.strategy) {\n        case PlainGalleryStrategy.ROW:\n          this.directionStyle = 'row';\n          break;\n        case PlainGalleryStrategy.COLUMN:\n          this.directionStyle = 'column';\n          this.wrapStyle = layout.breakConfig.wrap;\n          break;\n      }\n      this.justifyStyle = layout.justify;\n    }\n\n    if (this.plainGalleryConfig.layout instanceof GridLayout) {\n      const layout: GridLayout = this.plainGalleryConfig.layout;\n      const count: number = Math.ceil(this.images.length / layout.breakConfig.length);\n      let start = 0;\n      let end: number = layout.breakConfig.length - 1;\n\n      for (let j = 0; j < count; j++) {\n        const row: Image[] = this.images.filter((val: Image, i: number) => i >= start && i <= end);\n        this.imageGrid.push(row);\n        start = end + 1;\n        end = start + layout.breakConfig.length - 1;\n      }\n\n      this.size = this.plainGalleryConfig.layout.size;\n\n      const pixels: number = +layout.size.width.replace('px', '');\n\n      this.widthStyle = pixels * layout.breakConfig.length + pixels / 2 + 'px';\n      this.wrapStyle = layout.breakConfig.wrap;\n\n      this.directionStyle = 'row';\n    }\n  }\n}\n","<div class=\"plain-container\"\n     ksWrap [wrap]=\"wrapStyle\" [width]=\"widthStyle\"\n     ksDirection [direction]=\"directionStyle\" [justify]=\"justifyStyle\"\n     [attr.aria-label]=\"accessibilityConfig?.plainGalleryContentAriaLabel\"\n     [title]=\"accessibilityConfig?.plainGalleryContentTitle\">\n\n  <ng-container *ngFor=\"let imgRow of imageGrid; let i = index\">\n    <ng-container *ngFor=\"let imgCol of imgRow; let j = index\">\n\n      <ng-container *ngIf=\"!plainGalleryConfig?.advanced?.aTags; else aTags\">\n        <img *ngIf=\"imgCol?.modal?.img\"\n             [src]=\"imgCol.plain?.img! ? imgCol.plain?.img! : imgCol.modal.img\"\n             ksFallbackImage [fallbackImg]=\"imgCol.plain?.fallbackImg ? imgCol.plain?.fallbackImg : imgCol.modal.fallbackImg\"\n             class=\"image\"\n             ksSize [sizeConfig]=\"{width: size?.width!, height: size?.height!}\"\n             [attr.aria-label]=\"imgCol.plain?.ariaLabel\"\n             [title]=\"(imgCol.plain?.title || imgCol.plain?.title === '') ? imgCol.plain?.title : getTitleDisplay(imgCol)\"\n             alt=\"{{imgCol.plain?.alt! ? imgCol.plain?.alt! : getAltPlainDescriptionByImage(imgCol)}}\"\n             [tabIndex]=\"0\" role=\"img\"\n             (click)=\"showModalGalleryByImage(imgCol)\" (keyup)=\"onNavigationEvent($event, imgCol)\"/>\n      </ng-container>\n\n      <!-- Add directive to set background with the image url as param to pass thumb or img-->\n      <!-- to do something like this <a style=\"background: url('path to image') 50% 50%/cover\">.-->\n      <ng-template #aTags>\n        <a *ngIf=\"imgCol?.modal?.img\"\n           class=\"a-tag-image\"\n           ksATagBgImage [image]=\"imgCol\" [style]=\"plainGalleryConfig?.advanced?.additionalBackground\"\n           ksSize [sizeConfig]=\"{width: size?.width!, height: size?.height!}\"\n           [attr.aria-label]=\"imgCol.plain?.ariaLabel\"\n           [title]=\"(imgCol.plain?.title || imgCol.plain?.title === '') ? imgCol.plain?.title : getTitleDisplay(imgCol)\"\n           [tabIndex]=\"0\"\n           (click)=\"showModalGalleryByImage(imgCol)\" (keyup)=\"onNavigationEvent($event, imgCol)\"></a>\n      </ng-template>\n\n    </ng-container>\n  </ng-container>\n\n</div>\n\n"]}