@igo2/geo 18.0.1-next.2 → 18.0.1

package/esm2022/lib/layer/layer-legend/layer-legend.component.mjs

@@ -0,0 +1,287 @@
+import { AsyncPipe, NgClass, NgFor, NgIf, NgStyle } from '@angular/common';
+import { HttpClient } from '@angular/common/http';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, ViewChildren } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatOptionModule } from '@angular/material/core';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatListModule } from '@angular/material/list';
+import { MatSelectModule } from '@angular/material/select';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { CollapseDirective } from '@igo2/common/collapsible';
+import { SanitizeHtmlPipe } from '@igo2/common/custom-html';
+import { ImageErrorDirective, SecureImagePipe } from '@igo2/common/image';
+import { ConfigService } from '@igo2/core/config';
+import { LanguageService } from '@igo2/core/language';
+import { IgoLanguageModule } from '@igo2/core/language';
+import { BehaviorSubject, of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { CapabilitiesService } from '../../datasource/shared/capabilities.service';
+import { WMSDataSource } from '../../datasource/shared/datasources';
+import { Layer } from '../shared/layers';
+import * as i0 from "@angular/core";
+import * as i1 from "../../datasource/shared/capabilities.service";
+import * as i2 from "@igo2/core/language";
+import * as i3 from "@igo2/core/config";
+import * as i4 from "@angular/common/http";
+import * as i5 from "@angular/material/list";
+import * as i6 from "@angular/material/icon";
+import * as i7 from "@angular/material/form-field";
+import * as i8 from "@angular/material/select";
+import * as i9 from "@angular/material/core";
+import * as i10 from "@angular/material/tooltip";
+import * as i11 from "@angular/forms";
+import * as i12 from "@ngx-translate/core";
+export class LayerLegendComponent {
+    capabilitiesService;
+    languageService;
+    configService;
+    http;
+    cdRef;
+    updateLegendOnResolutionChange = false;
+    /**
+     * Observable of the legend items
+     */
+    legendItems$ = new BehaviorSubject([]);
+    /**
+     * Subscription to the map's resolution
+     */
+    state$$;
+    /**
+     * The available styles
+     */
+    styles;
+    /**
+     * The style used to make the legend
+     */
+    currentStyle;
+    /**
+     * The scale used to make the legend
+     */
+    scale = undefined;
+    /**
+     * The extent used to make the legend
+     */
+    view = undefined;
+    /**
+     * Get list of images display
+     */
+    renderedLegends;
+    /**
+     * List of size of images displayed
+     */
+    imagesHeight = {};
+    layer;
+    /**
+     * if getLegendGraphic is authorized
+     */
+    getLegend = true;
+    /**
+     * activeLegend
+     */
+    constructor(capabilitiesService, languageService, configService, http, cdRef) {
+        this.capabilitiesService = capabilitiesService;
+        this.languageService = languageService;
+        this.configService = configService;
+        this.http = http;
+        this.cdRef = cdRef;
+    }
+    /**
+     * On init, subscribe to the map's resolution and update the legend accordingly
+     */
+    ngOnInit() {
+        let lastlLegend = this.layer.legend;
+        this.styles = this.listStyles();
+        const sourceOptions = this.layer.options.source.options;
+        if (sourceOptions && sourceOptions.params && sourceOptions.params.STYLES) {
+            // if a styles is provided into the layers wms params
+            this.currentStyle = this.styles.find((style) => style.name === sourceOptions.params.STYLES).name;
+        }
+        else if (!lastlLegend) {
+            // if no legend is manually provided
+            if (this.styles && this.styles.length > 1) {
+                this.currentStyle = this.styles[0].name;
+            }
+        }
+        else if (this.styles && this.styles.length > 1) {
+            this.currentStyle = lastlLegend[0].currentStyle;
+        }
+        if (typeof this.layer.options.legendOptions !== 'undefined' &&
+            this.layer.options.legendOptions.display === false) {
+            lastlLegend = [];
+        }
+        else {
+            lastlLegend = this.layer.dataSource.getLegend();
+        }
+        if (this.updateLegendOnResolutionChange ||
+            sourceOptions.contentDependentLegend) {
+            const state$ = this.layer.map.viewController.state$;
+            this.state$$ = state$.subscribe(() => this.onViewControllerStateChange());
+        }
+        else if (lastlLegend && lastlLegend.length !== 0) {
+            this.legendItems$.next(lastlLegend);
+            for (const legend of lastlLegend) {
+                this.getLegendGraphic(legend);
+            }
+        }
+    }
+    /**
+     * On destroy, unsubscribe to the map's view state
+     */
+    ngOnDestroy() {
+        if (this.state$$ !== undefined) {
+            this.state$$.unsubscribe();
+        }
+    }
+    getLegendGraphic(item) {
+        if (item.url) {
+            const secureIMG = new SecureImagePipe(this.http, this.configService);
+            secureIMG
+                .transform(item.url)
+                .pipe(catchError((err) => {
+                if (err.error) {
+                    err.error.caught = true;
+                    this.getLegend = false;
+                    this.cdRef.detectChanges();
+                    return err;
+                }
+            }))
+                .subscribe((obsLegGraph) => {
+                const idx = this.legendItems$.value.findIndex((leg) => leg.title === item.title);
+                const legendGraph = obsLegGraph;
+                this.legendItems$.value[idx].imgGraphValue = legendGraph;
+                this.cdRef.detectChanges();
+            });
+        }
+    }
+    toggleLegendItem(collapsed, item) {
+        item.collapsed = collapsed;
+    }
+    transfertToggleLegendItem(newLegends) {
+        const outLegends = newLegends;
+        const lastLegends = this.layer.legend;
+        for (let i = 0; i < lastLegends.length; i++) {
+            outLegends[i].collapsed = lastLegends[i].collapsed;
+        }
+        return outLegends;
+    }
+    computeItemTitle(layerLegend) {
+        const layerOptions = this.layer.dataSource.options;
+        if (layerOptions.type !== 'wms') {
+            return of(layerLegend.title);
+        }
+        const layers = layerOptions.params.LAYERS.split(',');
+        const localLayerOptions = JSON.parse(JSON.stringify(layerOptions)); // to avoid to alter the original options.
+        localLayerOptions.params.LAYERS = layers.find((layer) => layer === layerLegend.title);
+        return this.capabilitiesService.getWMSOptions(localLayerOptions).pipe(map((wmsDataSourceOptions) => {
+            return wmsDataSourceOptions._layerOptionsFromSource.title;
+        }));
+    }
+    /**
+     * On resolution change, compute the effective scale level and update the
+     * legend accordingly.
+     * @param resolution Map resolution
+     */
+    onViewControllerStateChange() {
+        this.view = {
+            resolution: this.layer.map.viewController.getResolution(),
+            extent: this.layer.map.viewController.getExtent(),
+            projection: this.layer.map.viewController.getOlProjection().getCode(),
+            scale: this.layer.map.viewController.getScale(),
+            size: this.layer.map.ol.getSize()
+        };
+        this.updateLegend();
+    }
+    /**
+     * Update the legend with scale level and style define
+     */
+    updateLegend() {
+        let legendItems = this.layer.dataSource.getLegend();
+        if (this.layer.legend && this.layer.legend.length > 1) {
+            legendItems = this.transfertToggleLegendItem(legendItems);
+        }
+        this.layer.legend = legendItems;
+        if (legendItems.length === 0 && this.legendItems$.value.length === 0) {
+            return;
+        }
+        this.legendItems$.next(legendItems);
+        for (const legend of this.legendItems$.value) {
+            this.getLegendGraphic(legend);
+        }
+    }
+    listStyles() {
+        const layerOptions = this.layer.options;
+        if (layerOptions && layerOptions.legendOptions) {
+            const translate = this.languageService.translate;
+            const title = translate.instant('igo.geo.layer.legend.default');
+            let stylesAvailable = [{ name: '', title }];
+            if (layerOptions.legendOptions.stylesAvailable) {
+                stylesAvailable = stylesAvailable.concat(layerOptions.legendOptions.stylesAvailable.filter((sA) => sA.name.normalize('NFD').replace(/[\u0300-\u036f]/gi, '') !==
+                    'default' &&
+                    sA.name.normalize('NFD').replace(/[\u0300-\u036f]/gi, '') !==
+                        'defaut'));
+            }
+            stylesAvailable
+                .filter((sa) => !sa.title)
+                .map((sa) => (sa.title = sa.name));
+            stylesAvailable.map((s) => (s.title =
+                s.title.charAt(0).toUpperCase() +
+                    s.title.slice(1).replace(/_/g, ' ')));
+            return stylesAvailable;
+        }
+        return;
+    }
+    onChangeStyle() {
+        this.updateLegend();
+        let STYLES = '';
+        if (this.layer.dataSource instanceof WMSDataSource) {
+            this.layer.dataSource.ol
+                .getParams()
+                .LAYERS.split(',')
+                .map(() => (STYLES += this.currentStyle + ','));
+            STYLES = STYLES.slice(0, -1);
+            this.layer.dataSource.ol.updateParams({ STYLES });
+        }
+    }
+    onLoadImage(id) {
+        let elemRef;
+        if (this.renderedLegends.length === 1) {
+            elemRef = this.renderedLegends.first.nativeElement;
+        }
+        else {
+            elemRef = this.renderedLegends.find((renderedLegend) => renderedLegend.nativeElement.id === id).nativeElement;
+        }
+        this.imagesHeight[id] = elemRef.height;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerLegendComponent, deps: [{ token: i1.CapabilitiesService }, { token: i2.LanguageService }, { token: i3.ConfigService }, { token: i4.HttpClient }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LayerLegendComponent, isStandalone: true, selector: "igo-layer-legend", inputs: { updateLegendOnResolutionChange: "updateLegendOnResolutionChange", layer: "layer" }, viewQueries: [{ propertyName: "renderedLegends", predicate: ["renderedLegend"], descendants: true }], ngImport: i0, template: "<ng-container *ngIf=\"legendItems$ | async as items\">\n  <ng-container *ngIf=\"items.length; else noItems\">\n    <ng-container *ngFor=\"let item of items.slice().reverse()\" #renderedLegends>\n      <div *ngIf=\"getLegend; else noItems\">\n        <mat-list-item *ngIf=\"item.title\">\n          <mat-icon\n            id=\"legend-toggle\"\n            class=\"igo-chevron\"\n            matListItemIcon\n            igoCollapse\n            [target]=\"legend\"\n            [collapsed]=\"item.collapsed\"\n            (toggle)=\"toggleLegendItem($event, item)\"\n            >expand_less\n          </mat-icon>\n          <span matListItemTitle>{{ computeItemTitle(item) | async }} </span>\n        </mat-list-item>\n        <div\n          #legend\n          class=\"igo-layer-legend\"\n          [ngClass]=\"{ 'with-title': item.title }\"\n        >\n          <mat-form-field\n            *ngIf=\"currentStyle !== undefined\"\n            subscriptSizing=\"dynamic\"\n          >\n            <mat-select\n              tooltip-position=\"below\"\n              matTooltipShowDelay=\"500\"\n              [matTooltip]=\"'igo.geo.layer.legend.selectStyle' | translate\"\n              [(ngModel)]=\"currentStyle\"\n              (selectionChange)=\"onChangeStyle()\"\n            >\n              <mat-option *ngFor=\"let style of styles\" [value]=\"style.name\">{{\n                style.title\n              }}</mat-option>\n            </mat-select>\n          </mat-form-field>\n          <div *ngIf=\"!item.collapsed\">\n            <div *ngIf=\"item.url\">\n              <img\n                igoImageError\n                *ngIf=\"item.imgGraphValue\"\n                [hideError]=\"true\"\n                #renderedLegend\n                id=\"{{ item.title }}\"\n                (load)=\"onLoadImage(item.title)\"\n                [src]=\"item.imgGraphValue\"\n                alt=\"{{ 'igo.geo.layer.legend.loadingLegendText' | translate }}\"\n              />\n              <small *ngIf=\"imagesHeight[item.title] < 16\">\n                {{ 'igo.geo.layer.legend.noLegendScale' | translate }}\n              </small>\n            </div>\n            <div\n              [ngStyle]=\"item.style\"\n              [innerHTML]=\"item.html | sanitizeHtml\"\n              *ngIf=\"item.html\"\n            ></div>\n          </div>\n        </div>\n      </div>\n    </ng-container>\n  </ng-container>\n\n  <ng-template #noItems>\n    <small>\n      {{ 'igo.geo.layer.legend.noLegendText' | translate }}\n    </small>\n  </ng-template>\n</ng-container>\n", styles: [":host .igo-layer-legend.with-title{padding-left:18px}:host img{max-width:100%}:host img:after{content:\" \";position:relative;height:17px;float:left;width:17px;top:-3px;right:19px;background-color:#fff;border:3px solid #f3f3f3;border-radius:50%;animation:2s linear infinite spin}@-moz-document url-prefix(){:host img:after{margin-left:19px}}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}mat-form-field{margin-bottom:4px}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "ngmodule", type: MatListModule }, { kind: "component", type: i5.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "directive", type: i5.MatListItemIcon, selector: "[matListItemIcon]" }, { kind: "directive", type: i5.MatListItemTitle, selector: "[matListItemTitle]" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i6.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: CollapseDirective, selector: "[igoCollapse]", inputs: ["target", "collapsed"], outputs: ["toggle"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i7.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i8.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i9.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i10.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i11.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i11.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatOptionModule }, { kind: "directive", type: ImageErrorDirective, selector: "[igoImageError]", inputs: ["errorImageUrl", "hideError"] }, { kind: "directive", type: NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "ngmodule", type: IgoLanguageModule }, { kind: "pipe", type: i12.TranslatePipe, name: "translate" }, { kind: "pipe", type: SanitizeHtmlPipe, name: "sanitizeHtml" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerLegendComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-layer-legend', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        NgIf,
+                        NgFor,
+                        MatListModule,
+                        MatIconModule,
+                        CollapseDirective,
+                        NgClass,
+                        MatFormFieldModule,
+                        MatSelectModule,
+                        MatTooltipModule,
+                        FormsModule,
+                        MatOptionModule,
+                        ImageErrorDirective,
+                        NgStyle,
+                        AsyncPipe,
+                        IgoLanguageModule,
+                        SanitizeHtmlPipe
+                    ], template: "<ng-container *ngIf=\"legendItems$ | async as items\">\n  <ng-container *ngIf=\"items.length; else noItems\">\n    <ng-container *ngFor=\"let item of items.slice().reverse()\" #renderedLegends>\n      <div *ngIf=\"getLegend; else noItems\">\n        <mat-list-item *ngIf=\"item.title\">\n          <mat-icon\n            id=\"legend-toggle\"\n            class=\"igo-chevron\"\n            matListItemIcon\n            igoCollapse\n            [target]=\"legend\"\n            [collapsed]=\"item.collapsed\"\n            (toggle)=\"toggleLegendItem($event, item)\"\n            >expand_less\n          </mat-icon>\n          <span matListItemTitle>{{ computeItemTitle(item) | async }} </span>\n        </mat-list-item>\n        <div\n          #legend\n          class=\"igo-layer-legend\"\n          [ngClass]=\"{ 'with-title': item.title }\"\n        >\n          <mat-form-field\n            *ngIf=\"currentStyle !== undefined\"\n            subscriptSizing=\"dynamic\"\n          >\n            <mat-select\n              tooltip-position=\"below\"\n              matTooltipShowDelay=\"500\"\n              [matTooltip]=\"'igo.geo.layer.legend.selectStyle' | translate\"\n              [(ngModel)]=\"currentStyle\"\n              (selectionChange)=\"onChangeStyle()\"\n            >\n              <mat-option *ngFor=\"let style of styles\" [value]=\"style.name\">{{\n                style.title\n              }}</mat-option>\n            </mat-select>\n          </mat-form-field>\n          <div *ngIf=\"!item.collapsed\">\n            <div *ngIf=\"item.url\">\n              <img\n                igoImageError\n                *ngIf=\"item.imgGraphValue\"\n                [hideError]=\"true\"\n                #renderedLegend\n                id=\"{{ item.title }}\"\n                (load)=\"onLoadImage(item.title)\"\n                [src]=\"item.imgGraphValue\"\n                alt=\"{{ 'igo.geo.layer.legend.loadingLegendText' | translate }}\"\n              />\n              <small *ngIf=\"imagesHeight[item.title] < 16\">\n                {{ 'igo.geo.layer.legend.noLegendScale' | translate }}\n              </small>\n            </div>\n            <div\n              [ngStyle]=\"item.style\"\n              [innerHTML]=\"item.html | sanitizeHtml\"\n              *ngIf=\"item.html\"\n            ></div>\n          </div>\n        </div>\n      </div>\n    </ng-container>\n  </ng-container>\n\n  <ng-template #noItems>\n    <small>\n      {{ 'igo.geo.layer.legend.noLegendText' | translate }}\n    </small>\n  </ng-template>\n</ng-container>\n", styles: [":host .igo-layer-legend.with-title{padding-left:18px}:host img{max-width:100%}:host img:after{content:\" \";position:relative;height:17px;float:left;width:17px;top:-3px;right:19px;background-color:#fff;border:3px solid #f3f3f3;border-radius:50%;animation:2s linear infinite spin}@-moz-document url-prefix(){:host img:after{margin-left:19px}}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}mat-form-field{margin-bottom:4px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.CapabilitiesService }, { type: i2.LanguageService }, { type: i3.ConfigService }, { type: i4.HttpClient }, { type: i0.ChangeDetectorRef }], propDecorators: { updateLegendOnResolutionChange: [{
+                type: Input
+            }], renderedLegends: [{
+                type: ViewChildren,
+                args: ['renderedLegend']
+            }], layer: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layer-legend.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/layer/layer-legend/layer-legend.component.ts","../../../../../../packages/geo/src/lib/layer/layer-legend/layer-legend.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AsyncPipe, NgClass, NgFor, NgIf, NgStyle } from '@angular/common';\nimport { HttpClient } from '@angular/common/http';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  Input,\n  OnDestroy,\n  OnInit,\n  ViewChildren\n} from '@angular/core';\nimport type { QueryList } from '@angular/core';\nimport { FormsModule } from '@angular/forms';\nimport { MatOptionModule } from '@angular/material/core';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatListModule } from '@angular/material/list';\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatTooltipModule } from '@angular/material/tooltip';\n\nimport { CollapseDirective } from '@igo2/common/collapsible';\nimport { SanitizeHtmlPipe } from '@igo2/common/custom-html';\nimport { ImageErrorDirective, SecureImagePipe } from '@igo2/common/image';\nimport { ConfigService } from '@igo2/core/config';\nimport { LanguageService } from '@igo2/core/language';\nimport { IgoLanguageModule } from '@igo2/core/language';\n\nimport { BehaviorSubject, Observable, Subscription, of } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\n\nimport { CapabilitiesService } from '../../datasource/shared/capabilities.service';\nimport {\n  Legend,\n  WMSDataSource,\n  WMSDataSourceOptions\n} from '../../datasource/shared/datasources';\nimport {\n  ItemStyleOptions,\n  Layer,\n  LegendMapViewOptions\n} from '../shared/layers';\n\n@Component({\n  selector: 'igo-layer-legend',\n  templateUrl: './layer-legend.component.html',\n  styleUrls: ['./layer-legend.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    NgIf,\n    NgFor,\n    MatListModule,\n    MatIconModule,\n    CollapseDirective,\n    NgClass,\n    MatFormFieldModule,\n    MatSelectModule,\n    MatTooltipModule,\n    FormsModule,\n    MatOptionModule,\n    ImageErrorDirective,\n    NgStyle,\n    AsyncPipe,\n    IgoLanguageModule,\n    SanitizeHtmlPipe\n  ]\n})\nexport class LayerLegendComponent implements OnInit, OnDestroy {\n  @Input() updateLegendOnResolutionChange = false;\n\n  /**\n   * Observable of the legend items\n   */\n  legendItems$ = new BehaviorSubject<Legend[]>([]);\n\n  /**\n   * Subscription to the map's resolution\n   */\n  private state$$: Subscription;\n\n  /**\n   * The available styles\n   */\n  public styles;\n\n  /**\n   * The style used to make the legend\n   */\n  public currentStyle;\n\n  /**\n   * The scale used to make the legend\n   */\n  private scale: number = undefined;\n\n  /**\n   * The extent used to make the legend\n   */\n  private view: LegendMapViewOptions = undefined;\n  /**\n   * Get list of images display\n   */\n  @ViewChildren('renderedLegend') renderedLegends: QueryList<ElementRef>;\n\n  /**\n   * List of size of images displayed\n   */\n  public imagesHeight: Record<string, number> = {};\n\n  @Input() layer: Layer;\n\n  /**\n   * if getLegendGraphic is authorized\n   */\n  public getLegend = true;\n\n  /**\n   * activeLegend\n   */\n\n  constructor(\n    private capabilitiesService: CapabilitiesService,\n    private languageService: LanguageService,\n    private configService: ConfigService,\n    private http: HttpClient,\n    private cdRef: ChangeDetectorRef\n  ) {}\n\n  /**\n   * On init, subscribe to the map's resolution and update the legend accordingly\n   */\n  ngOnInit() {\n    let lastlLegend = this.layer.legend;\n    this.styles = this.listStyles();\n    const sourceOptions = this.layer.options.source.options as any;\n    if (sourceOptions && sourceOptions.params && sourceOptions.params.STYLES) {\n      // if a styles is provided into the layers wms params\n      this.currentStyle = this.styles.find(\n        (style) => style.name === sourceOptions.params.STYLES\n      ).name;\n    } else if (!lastlLegend) {\n      // if no legend is manually provided\n      if (this.styles && this.styles.length > 1) {\n        this.currentStyle = this.styles[0].name;\n      }\n    } else if (this.styles && this.styles.length > 1) {\n      this.currentStyle = lastlLegend[0].currentStyle;\n    }\n    if (\n      typeof this.layer.options.legendOptions !== 'undefined' &&\n      this.layer.options.legendOptions.display === false\n    ) {\n      lastlLegend = [];\n    } else {\n      lastlLegend = this.layer.dataSource.getLegend();\n    }\n\n    if (\n      this.updateLegendOnResolutionChange ||\n      (sourceOptions as WMSDataSourceOptions).contentDependentLegend\n    ) {\n      const state$ = this.layer.map.viewController.state$;\n      this.state$$ = state$.subscribe(() => this.onViewControllerStateChange());\n    } else if (lastlLegend && lastlLegend.length !== 0) {\n      this.legendItems$.next(lastlLegend);\n      for (const legend of lastlLegend) {\n        this.getLegendGraphic(legend);\n      }\n    }\n  }\n\n  /**\n   * On destroy, unsubscribe to the map's view state\n   */\n  ngOnDestroy() {\n    if (this.state$$ !== undefined) {\n      this.state$$.unsubscribe();\n    }\n  }\n\n  getLegendGraphic(item: Legend) {\n    if (item.url) {\n      const secureIMG = new SecureImagePipe(this.http, this.configService);\n      secureIMG\n        .transform(item.url)\n        .pipe(\n          catchError((err) => {\n            if (err.error) {\n              err.error.caught = true;\n              this.getLegend = false;\n              this.cdRef.detectChanges();\n              return err;\n            }\n          })\n        )\n        .subscribe((obsLegGraph) => {\n          const idx = this.legendItems$.value.findIndex(\n            (leg) => leg.title === item.title\n          );\n          const legendGraph = obsLegGraph as string;\n          this.legendItems$.value[idx].imgGraphValue = legendGraph;\n          this.cdRef.detectChanges();\n        });\n    }\n  }\n\n  toggleLegendItem(collapsed: boolean, item: Legend) {\n    item.collapsed = collapsed;\n  }\n\n  private transfertToggleLegendItem(newLegends: Legend[]): Legend[] {\n    const outLegends: Legend[] = newLegends;\n    const lastLegends = this.layer.legend;\n    for (let i = 0; i < lastLegends.length; i++) {\n      outLegends[i].collapsed = lastLegends[i].collapsed;\n    }\n    return outLegends;\n  }\n\n  computeItemTitle(layerLegend): Observable<string> {\n    const layerOptions = this.layer.dataSource.options as any;\n    if (layerOptions.type !== 'wms') {\n      return of(layerLegend.title);\n    }\n\n    const layers = layerOptions.params.LAYERS.split(',');\n    const localLayerOptions = JSON.parse(JSON.stringify(layerOptions)); // to avoid to alter the original options.\n    localLayerOptions.params.LAYERS = layers.find(\n      (layer) => layer === layerLegend.title\n    );\n    return this.capabilitiesService.getWMSOptions(localLayerOptions).pipe(\n      map((wmsDataSourceOptions) => {\n        return wmsDataSourceOptions._layerOptionsFromSource.title;\n      })\n    );\n  }\n\n  /**\n   * On resolution change, compute the effective scale level and update the\n   * legend accordingly.\n   * @param resolution Map resolution\n   */\n  private onViewControllerStateChange() {\n    this.view = {\n      resolution: this.layer.map.viewController.getResolution(),\n      extent: this.layer.map.viewController.getExtent(),\n      projection: this.layer.map.viewController.getOlProjection().getCode(),\n      scale: this.layer.map.viewController.getScale(),\n      size: this.layer.map.ol.getSize()\n    } as LegendMapViewOptions;\n    this.updateLegend();\n  }\n\n  /**\n   * Update the legend with scale level and style define\n   */\n  private updateLegend() {\n    let legendItems = this.layer.dataSource.getLegend();\n    if (this.layer.legend && this.layer.legend.length > 1) {\n      legendItems = this.transfertToggleLegendItem(legendItems);\n    }\n    this.layer.legend = legendItems;\n\n    if (legendItems.length === 0 && this.legendItems$.value.length === 0) {\n      return;\n    }\n    this.legendItems$.next(legendItems);\n    for (const legend of this.legendItems$.value) {\n      this.getLegendGraphic(legend);\n    }\n  }\n\n  private listStyles() {\n    const layerOptions = this.layer.options;\n    if (layerOptions && layerOptions.legendOptions) {\n      const translate = this.languageService.translate;\n      const title = translate.instant('igo.geo.layer.legend.default');\n      let stylesAvailable = [{ name: '', title } as ItemStyleOptions];\n      if (layerOptions.legendOptions.stylesAvailable) {\n        stylesAvailable = stylesAvailable.concat(\n          layerOptions.legendOptions.stylesAvailable.filter(\n            (sA) =>\n              sA.name.normalize('NFD').replace(/[\\u0300-\\u036f]/gi, '') !==\n                'default' &&\n              sA.name.normalize('NFD').replace(/[\\u0300-\\u036f]/gi, '') !==\n                'defaut'\n          )\n        );\n      }\n      stylesAvailable\n        .filter((sa) => !sa.title)\n        .map((sa) => (sa.title = sa.name));\n      stylesAvailable.map(\n        (s) =>\n          (s.title =\n            s.title.charAt(0).toUpperCase() +\n            s.title.slice(1).replace(/_/g, ' '))\n      );\n      return stylesAvailable;\n    }\n    return;\n  }\n\n  onChangeStyle() {\n    this.updateLegend();\n    let STYLES = '';\n    if (this.layer.dataSource instanceof WMSDataSource) {\n      this.layer.dataSource.ol\n        .getParams()\n        .LAYERS.split(',')\n        .map(() => (STYLES += this.currentStyle + ','));\n      STYLES = STYLES.slice(0, -1);\n      this.layer.dataSource.ol.updateParams({ STYLES });\n    }\n  }\n\n  onLoadImage(id: string) {\n    let elemRef: HTMLImageElement;\n    if (this.renderedLegends.length === 1) {\n      elemRef = this.renderedLegends.first.nativeElement as HTMLImageElement;\n    } else {\n      elemRef = this.renderedLegends.find(\n        (renderedLegend) => renderedLegend.nativeElement.id === id\n      ).nativeElement as HTMLImageElement;\n    }\n    this.imagesHeight[id] = elemRef.height;\n  }\n}\n","<ng-container *ngIf=\"legendItems$ | async as items\">\n  <ng-container *ngIf=\"items.length; else noItems\">\n    <ng-container *ngFor=\"let item of items.slice().reverse()\" #renderedLegends>\n      <div *ngIf=\"getLegend; else noItems\">\n        <mat-list-item *ngIf=\"item.title\">\n          <mat-icon\n            id=\"legend-toggle\"\n            class=\"igo-chevron\"\n            matListItemIcon\n            igoCollapse\n            [target]=\"legend\"\n            [collapsed]=\"item.collapsed\"\n            (toggle)=\"toggleLegendItem($event, item)\"\n            >expand_less\n          </mat-icon>\n          <span matListItemTitle>{{ computeItemTitle(item) | async }} </span>\n        </mat-list-item>\n        <div\n          #legend\n          class=\"igo-layer-legend\"\n          [ngClass]=\"{ 'with-title': item.title }\"\n        >\n          <mat-form-field\n            *ngIf=\"currentStyle !== undefined\"\n            subscriptSizing=\"dynamic\"\n          >\n            <mat-select\n              tooltip-position=\"below\"\n              matTooltipShowDelay=\"500\"\n              [matTooltip]=\"'igo.geo.layer.legend.selectStyle' | translate\"\n              [(ngModel)]=\"currentStyle\"\n              (selectionChange)=\"onChangeStyle()\"\n            >\n              <mat-option *ngFor=\"let style of styles\" [value]=\"style.name\">{{\n                style.title\n              }}</mat-option>\n            </mat-select>\n          </mat-form-field>\n          <div *ngIf=\"!item.collapsed\">\n            <div *ngIf=\"item.url\">\n              <img\n                igoImageError\n                *ngIf=\"item.imgGraphValue\"\n                [hideError]=\"true\"\n                #renderedLegend\n                id=\"{{ item.title }}\"\n                (load)=\"onLoadImage(item.title)\"\n                [src]=\"item.imgGraphValue\"\n                alt=\"{{ 'igo.geo.layer.legend.loadingLegendText' | translate }}\"\n              />\n              <small *ngIf=\"imagesHeight[item.title] < 16\">\n                {{ 'igo.geo.layer.legend.noLegendScale' | translate }}\n              </small>\n            </div>\n            <div\n              [ngStyle]=\"item.style\"\n              [innerHTML]=\"item.html | sanitizeHtml\"\n              *ngIf=\"item.html\"\n            ></div>\n          </div>\n        </div>\n      </div>\n    </ng-container>\n  </ng-container>\n\n  <ng-template #noItems>\n    <small>\n      {{ 'igo.geo.layer.legend.noLegendText' | translate }}\n    </small>\n  </ng-template>\n</ng-container>\n"]}

package/esm2022/lib/layer/layer-legend-item/index.mjs

@@ -0,0 +1,2 @@
+export * from './layer-legend-item.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9sYXllci9sYXllci1sZWdlbmQtaXRlbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9sYXllci1sZWdlbmQtaXRlbS5jb21wb25lbnQnO1xuIl19

package/esm2022/lib/layer/layer-legend-item/layer-legend-item.component.mjs

@@ -0,0 +1,85 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { MatListModule } from '@angular/material/list';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { NetworkService } from '@igo2/core/network';
+import { BehaviorSubject } from 'rxjs';
+import { LayerLegendComponent } from '../layer-legend/layer-legend.component';
+import { Layer } from '../shared/layers/layer';
+import { TooltipType } from '../shared/layers/layer.interface';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core/network";
+import * as i2 from "@angular/material/list";
+import * as i3 from "@angular/material/tooltip";
+export class LayerLegendItemComponent {
+    networkService;
+    inResolutionRange$ = new BehaviorSubject(true);
+    tooltipText;
+    state;
+    resolution$$;
+    network$$;
+    layer;
+    updateLegendOnResolutionChange = false;
+    constructor(networkService) {
+        this.networkService = networkService;
+    }
+    ngOnInit() {
+        const resolution$ = this.layer.map.viewController.resolution$;
+        this.resolution$$ = resolution$.subscribe(() => {
+            this.onResolutionChange();
+        });
+        this.tooltipText = this.computeTooltip();
+        this.network$$ = this.networkService
+            .currentState()
+            .subscribe((state) => {
+            this.state = state;
+            this.onResolutionChange();
+        });
+    }
+    ngOnDestroy() {
+        this.resolution$$.unsubscribe();
+        this.network$$.unsubscribe();
+    }
+    computeTooltip() {
+        const layerOptions = this.layer.options;
+        if (!layerOptions.tooltip) {
+            return this.layer.title;
+        }
+        const layerTooltip = layerOptions.tooltip;
+        const layerMetadata = layerOptions.metadata;
+        switch (layerOptions.tooltip.type) {
+            case TooltipType.TITLE:
+                return this.layer.title;
+            case TooltipType.ABSTRACT:
+                if (layerMetadata && layerMetadata.abstract) {
+                    return layerMetadata.abstract;
+                }
+                else {
+                    return this.layer.title;
+                }
+            case TooltipType.CUSTOM:
+                if (layerTooltip && layerTooltip.text) {
+                    return layerTooltip.text;
+                }
+                else {
+                    return this.layer.title;
+                }
+            default:
+                return this.layer.title;
+        }
+    }
+    onResolutionChange() {
+        const inResolutionRange = this.layer.isInResolutionsRange;
+        this.inResolutionRange$.next(inResolutionRange);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerLegendItemComponent, deps: [{ token: i1.NetworkService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LayerLegendItemComponent, isStandalone: true, selector: "igo-layer-legend-item", inputs: { layer: "layer", updateLegendOnResolutionChange: "updateLegendOnResolutionChange" }, ngImport: i0, template: "<mat-list-item class=\"igo-layer-list-item\">\n  <span\n    matListItemTitle\n    class=\"igo-layer-title\"\n    [matTooltip]=\"tooltipText\"\n    matTooltipShowDelay=\"500\"\n    >{{ layer.title }}</span\n  >\n</mat-list-item>\n\n<div #legend class=\"igo-layer-legend-container\">\n  <igo-layer-legend\n    [layer]=\"layer\"\n    [updateLegendOnResolutionChange]=\"updateLegendOnResolutionChange\"\n  >\n  </igo-layer-legend>\n</div>\n", styles: [":host{overflow:hidden}:host .igo-layer-list-item{height:48px;clear:both}:host .igo-layer-legend-container{padding-left:18px;width:calc(100% - 18px)}\n"], dependencies: [{ kind: "ngmodule", type: MatListModule }, { kind: "component", type: i2.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "directive", type: i2.MatListItemTitle, selector: "[matListItemTitle]" }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i3.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "component", type: LayerLegendComponent, selector: "igo-layer-legend", inputs: ["updateLegendOnResolutionChange", "layer"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerLegendItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-layer-legend-item', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [MatListModule, MatTooltipModule, LayerLegendComponent], template: "<mat-list-item class=\"igo-layer-list-item\">\n  <span\n    matListItemTitle\n    class=\"igo-layer-title\"\n    [matTooltip]=\"tooltipText\"\n    matTooltipShowDelay=\"500\"\n    >{{ layer.title }}</span\n  >\n</mat-list-item>\n\n<div #legend class=\"igo-layer-legend-container\">\n  <igo-layer-legend\n    [layer]=\"layer\"\n    [updateLegendOnResolutionChange]=\"updateLegendOnResolutionChange\"\n  >\n  </igo-layer-legend>\n</div>\n", styles: [":host{overflow:hidden}:host .igo-layer-list-item{height:48px;clear:both}:host .igo-layer-legend-container{padding-left:18px;width:calc(100% - 18px)}\n"] }]
+        }], ctorParameters: () => [{ type: i1.NetworkService }], propDecorators: { layer: [{
+                type: Input
+            }], updateLegendOnResolutionChange: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/layer/layer-legend-list/index.mjs

@@ -0,0 +1,3 @@
+export * from './layer-legend-list.component';
+export * from './layer-legend-list-binding.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9sYXllci9sYXllci1sZWdlbmQtbGlzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsdUNBQXVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xheWVyLWxlZ2VuZC1saXN0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xheWVyLWxlZ2VuZC1saXN0LWJpbmRpbmcuZGlyZWN0aXZlJztcbiJdfQ==

package/esm2022/lib/layer/layer-legend-list/layer-legend-list-binding.directive.mjs

@@ -0,0 +1,54 @@
+import { Directive, Self } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { MapService } from '../../map/shared/map.service';
+import { isLayerItem } from '../utils';
+import { LayerLegendListComponent } from './layer-legend-list.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./layer-legend-list.component";
+import * as i2 from "../../map/shared/map.service";
+export class LayerLegendListBindingDirective {
+    mapService;
+    component;
+    layersOrResolutionChange$$;
+    layersVisibility$$;
+    constructor(component, mapService) {
+        this.mapService = mapService;
+        this.component = component;
+    }
+    ngOnInit() {
+        // Override input layers
+        this.component.layers = [];
+        this.layersOrResolutionChange$$ = combineLatest([
+            this.mapService.getMap().layerController.all$,
+            this.mapService.getMap().viewController.resolution$
+        ])
+            .pipe(debounceTime(10))
+            .subscribe((bunch) => {
+            const shownLayers = bunch[0].filter((layer) => {
+                return isLayerItem(layer) && layer.showInLayerList === true;
+            });
+            this.component.layers = shownLayers;
+            this.layersVisibility$$ = combineLatest(shownLayers.map((layer) => layer.visible$)).subscribe(() => this.component.change$.next());
+        });
+    }
+    ngOnDestroy() {
+        this.layersOrResolutionChange$$.unsubscribe();
+        if (this.layersVisibility$$ !== undefined) {
+            this.layersVisibility$$.unsubscribe();
+            this.layersVisibility$$ = undefined;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerLegendListBindingDirective, deps: [{ token: i1.LayerLegendListComponent, self: true }, { token: i2.MapService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LayerLegendListBindingDirective, isStandalone: true, selector: "[igoLayerLegendListBinding]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerLegendListBindingDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igoLayerLegendListBinding]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.LayerLegendListComponent, decorators: [{
+                    type: Self
+                }] }, { type: i2.MapService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF5ZXItbGVnZW5kLWxpc3QtYmluZGluZy5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9sYXllci9sYXllci1sZWdlbmQtbGlzdC9sYXllci1sZWdlbmQtbGlzdC1iaW5kaW5nLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFxQixJQUFJLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFbkUsT0FBTyxFQUFnQixhQUFhLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDbkQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRTlDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUcxRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLCtCQUErQixDQUFDOzs7O0FBTXpFLE1BQU0sT0FBTywrQkFBK0I7SUFPaEM7SUFORixTQUFTLENBQTJCO0lBQ3BDLDBCQUEwQixDQUFlO0lBQ2pELGtCQUFrQixDQUFlO0lBRWpDLFlBQ1UsU0FBbUMsRUFDbkMsVUFBc0I7UUFBdEIsZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUU5QixJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztJQUM3QixDQUFDO0lBRUQsUUFBUTtRQUNOLHdCQUF3QjtRQUN4QixJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxFQUFFLENBQUM7UUFDM0IsSUFBSSxDQUFDLDBCQUEwQixHQUFHLGFBQWEsQ0FBQztZQUM5QyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxDQUFDLGVBQWUsQ0FBQyxJQUFJO1lBQzdDLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLENBQUMsY0FBYyxDQUFDLFdBQVc7U0FDcEQsQ0FBQzthQUNDLElBQUksQ0FBQyxZQUFZLENBQUMsRUFBRSxDQUFDLENBQUM7YUFDdEIsU0FBUyxDQUFDLENBQUMsS0FBMkIsRUFBRSxFQUFFO1lBQ3pDLE1BQU0sV0FBVyxHQUFHLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRTtnQkFDNUMsT0FBTyxXQUFXLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxDQUFDLGVBQWUsS0FBSyxJQUFJLENBQUM7WUFDOUQsQ0FBQyxDQUFZLENBQUM7WUFDZCxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxXQUFXLENBQUM7WUFFcEMsSUFBSSxDQUFDLGtCQUFrQixHQUFHLGFBQWEsQ0FDckMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUMzQyxDQUFDLFNBQVMsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQ25ELENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVELFdBQVc7UUFDVCxJQUFJLENBQUMsMEJBQTBCLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDOUMsSUFBSSxJQUFJLENBQUMsa0JBQWtCLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDMUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ3RDLElBQUksQ0FBQyxrQkFBa0IsR0FBRyxTQUFTLENBQUM7UUFDdEMsQ0FBQztJQUNILENBQUM7d0dBdENVLCtCQUErQjs0RkFBL0IsK0JBQStCOzs0RkFBL0IsK0JBQStCO2tCQUozQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSw2QkFBNkI7b0JBQ3ZDLFVBQVUsRUFBRSxJQUFJO2lCQUNqQjs7MEJBT0ksSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgT25EZXN0cm95LCBPbkluaXQsIFNlbGYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgU3Vic2NyaXB0aW9uLCBjb21iaW5lTGF0ZXN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBkZWJvdW5jZVRpbWUgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbmltcG9ydCB7IE1hcFNlcnZpY2UgfSBmcm9tICcuLi8uLi9tYXAvc2hhcmVkL21hcC5zZXJ2aWNlJztcbmltcG9ydCB7IEFueUxheWVyIH0gZnJvbSAnLi4vc2hhcmVkL2xheWVycy9hbnktbGF5ZXInO1xuaW1wb3J0IHsgTGF5ZXIgfSBmcm9tICcuLi9zaGFyZWQvbGF5ZXJzL2xheWVyJztcbmltcG9ydCB7IGlzTGF5ZXJJdGVtIH0gZnJvbSAnLi4vdXRpbHMnO1xuaW1wb3J0IHsgTGF5ZXJMZWdlbmRMaXN0Q29tcG9uZW50IH0gZnJvbSAnLi9sYXllci1sZWdlbmQtbGlzdC5jb21wb25lbnQnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbaWdvTGF5ZXJMZWdlbmRMaXN0QmluZGluZ10nLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIExheWVyTGVnZW5kTGlzdEJpbmRpbmdEaXJlY3RpdmUgaW1wbGVtZW50cyBPbkluaXQsIE9uRGVzdHJveSB7XG4gIHByaXZhdGUgY29tcG9uZW50OiBMYXllckxlZ2VuZExpc3RDb21wb25lbnQ7XG4gIHByaXZhdGUgbGF5ZXJzT3JSZXNvbHV0aW9uQ2hhbmdlJCQ6IFN1YnNjcmlwdGlvbjtcbiAgbGF5ZXJzVmlzaWJpbGl0eSQkOiBTdWJzY3JpcHRpb247XG5cbiAgY29uc3RydWN0b3IoXG4gICAgQFNlbGYoKSBjb21wb25lbnQ6IExheWVyTGVnZW5kTGlzdENvbXBvbmVudCxcbiAgICBwcml2YXRlIG1hcFNlcnZpY2U6IE1hcFNlcnZpY2VcbiAgKSB7XG4gICAgdGhpcy5jb21wb25lbnQgPSBjb21wb25lbnQ7XG4gIH1cblxuICBuZ09uSW5pdCgpIHtcbiAgICAvLyBPdmVycmlkZSBpbnB1dCBsYXllcnNcbiAgICB0aGlzLmNvbXBvbmVudC5sYXllcnMgPSBbXTtcbiAgICB0aGlzLmxheWVyc09yUmVzb2x1dGlvbkNoYW5nZSQkID0gY29tYmluZUxhdGVzdChbXG4gICAgICB0aGlzLm1hcFNlcnZpY2UuZ2V0TWFwKCkubGF5ZXJDb250cm9sbGVyLmFsbCQsXG4gICAgICB0aGlzLm1hcFNlcnZpY2UuZ2V0TWFwKCkudmlld0NvbnRyb2xsZXIucmVzb2x1dGlvbiRcbiAgICBdKVxuICAgICAgLnBpcGUoZGVib3VuY2VUaW1lKDEwKSlcbiAgICAgIC5zdWJzY3JpYmUoKGJ1bmNoOiBbQW55TGF5ZXJbXSwgbnVtYmVyXSkgPT4ge1xuICAgICAgICBjb25zdCBzaG93bkxheWVycyA9IGJ1bmNoWzBdLmZpbHRlcigobGF5ZXIpID0+IHtcbiAgICAgICAgICByZXR1cm4gaXNMYXllckl0ZW0obGF5ZXIpICYmIGxheWVyLnNob3dJbkxheWVyTGlzdCA9PT0gdHJ1ZTtcbiAgICAgICAgfSkgYXMgTGF5ZXJbXTtcbiAgICAgICAgdGhpcy5jb21wb25lbnQubGF5ZXJzID0gc2hvd25MYXllcnM7XG5cbiAgICAgICAgdGhpcy5sYXllcnNWaXNpYmlsaXR5JCQgPSBjb21iaW5lTGF0ZXN0KFxuICAgICAgICAgIHNob3duTGF5ZXJzLm1hcCgobGF5ZXIpID0+IGxheWVyLnZpc2libGUkKVxuICAgICAgICApLnN1YnNjcmliZSgoKSA9PiB0aGlzLmNvbXBvbmVudC5jaGFuZ2UkLm5leHQoKSk7XG4gICAgICB9KTtcbiAgfVxuXG4gIG5nT25EZXN0cm95KCkge1xuICAgIHRoaXMubGF5ZXJzT3JSZXNvbHV0aW9uQ2hhbmdlJCQudW5zdWJzY3JpYmUoKTtcbiAgICBpZiAodGhpcy5sYXllcnNWaXNpYmlsaXR5JCQgIT09IHVuZGVmaW5lZCkge1xuICAgICAgdGhpcy5sYXllcnNWaXNpYmlsaXR5JCQudW5zdWJzY3JpYmUoKTtcbiAgICAgIHRoaXMubGF5ZXJzVmlzaWJpbGl0eSQkID0gdW5kZWZpbmVkO1xuICAgIH1cbiAgfVxufVxuIl19