@igo2/geo 18.0.0-next.9 → 18.0.0

package/esm2022/lib/layer/layer-visibility-button/layer-visibility-button.component.mjs

@@ -0,0 +1,83 @@
+import { NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, Output } from '@angular/core';
+import { MatBadgeModule } from '@angular/material/badge';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { IgoIconComponent } from '@igo2/common/icon';
+import { IgoLanguageModule } from '@igo2/core/language';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/badge";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/material/tooltip";
+import * as i4 from "@ngx-translate/core";
+const EYE_CLOSE_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><title>eye-closed</title><path d="M12 17.5C8.2 17.5 4.8 15.4 3.2 12H1C2.7 16.4 7 19.5 12 19.5S21.3 16.4 23 12H20.8C19.2 15.4 15.8 17.5 12 17.5Z" /></svg>`;
+export class LayerVisibilityButtonComponent {
+    cdr;
+    eyeClosedSvg = {
+        name: 'eye-closed',
+        svg: EYE_CLOSE_SVG
+    };
+    hiddenByParent;
+    visible;
+    layer;
+    tooltip;
+    disabled;
+    showQueryBadge;
+    inResolutionsRange;
+    get defaultTooltip() {
+        return !this.layer.isInResolutionsRange
+            ? 'igo.geo.layer.notInResolution'
+            : this.layer.visible && this.disabled
+                ? 'igo.geo.layer.group.hideChildren'
+                : this.layer.visible
+                    ? 'igo.geo.layer.hideLayer'
+                    : 'igo.geo.layer.showLayer';
+    }
+    visibilityChange = new EventEmitter();
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    ngOnInit() {
+        this.layer.parent?.displayed$.subscribe((displayed) => {
+            this.hiddenByParent = !displayed;
+            this.cdr.markForCheck();
+        });
+        this.layer.visible$.subscribe((visible) => {
+            this.visible = visible;
+            this.cdr.markForCheck();
+        });
+    }
+    toggle(event) {
+        this.layer.visible = !this.layer.visible;
+        this.visibilityChange.emit(event);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerVisibilityButtonComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: LayerVisibilityButtonComponent, isStandalone: true, selector: "igo-layer-visibility-button", inputs: { layer: "layer", tooltip: "tooltip", disabled: "disabled", showQueryBadge: "showQueryBadge", inResolutionsRange: "inResolutionsRange" }, outputs: { visibilityChange: "visibilityChange" }, ngImport: i0, template: "<button\n  mat-icon-button\n  [ngClass]=\"{\n    disabled: disabled,\n    'out-of-range': !inResolutionsRange,\n    'visibility-hidden': !visible\n  }\"\n  [color]=\"visible ? 'primary' : 'default'\"\n  tooltip-position=\"below\"\n  matTooltipShowDelay=\"500\"\n  [matTooltip]=\"tooltip ?? defaultTooltip | translate\"\n  (click)=\"toggle($event)\"\n>\n  <igo-icon\n    matBadge=\"?\"\n    matBadgeColor=\"accent\"\n    matBadgeSize=\"small\"\n    matBadgePosition=\"after\"\n    [matBadgeHidden]=\"!showQueryBadge\"\n    [icon]=\"\n      visible\n        ? hiddenByParent\n          ? eyeClosedSvg\n          : 'visibility'\n        : 'visibility_off'\n    \"\n    iconPositionEnd\n  />\n</button>\n", styles: [":host .disabled.out-of-range,:host .visibility-hidden.out-of-range{opacity:.54}mat-icon[matBadge] ::ng-deep .mat-badge-content{font-size:12px}\n"], dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: MatBadgeModule }, { kind: "directive", type: i1.MatBadge, selector: "[matBadge]", inputs: ["matBadgeColor", "matBadgeOverlap", "matBadgeDisabled", "matBadgePosition", "matBadge", "matBadgeDescription", "matBadgeSize", "matBadgeHidden"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i3.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: IgoLanguageModule }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }, { kind: "component", type: IgoIconComponent, selector: "igo-icon", inputs: ["icon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerVisibilityButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-layer-visibility-button', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        NgClass,
+                        MatBadgeModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        MatTooltipModule,
+                        IgoLanguageModule,
+                        IgoIconComponent
+                    ], template: "<button\n  mat-icon-button\n  [ngClass]=\"{\n    disabled: disabled,\n    'out-of-range': !inResolutionsRange,\n    'visibility-hidden': !visible\n  }\"\n  [color]=\"visible ? 'primary' : 'default'\"\n  tooltip-position=\"below\"\n  matTooltipShowDelay=\"500\"\n  [matTooltip]=\"tooltip ?? defaultTooltip | translate\"\n  (click)=\"toggle($event)\"\n>\n  <igo-icon\n    matBadge=\"?\"\n    matBadgeColor=\"accent\"\n    matBadgeSize=\"small\"\n    matBadgePosition=\"after\"\n    [matBadgeHidden]=\"!showQueryBadge\"\n    [icon]=\"\n      visible\n        ? hiddenByParent\n          ? eyeClosedSvg\n          : 'visibility'\n        : 'visibility_off'\n    \"\n    iconPositionEnd\n  />\n</button>\n", styles: [":host .disabled.out-of-range,:host .visibility-hidden.out-of-range{opacity:.54}mat-icon[matBadge] ::ng-deep .mat-badge-content{font-size:12px}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { layer: [{
+                type: Input,
+                args: [{ required: true }]
+            }], tooltip: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], showQueryBadge: [{
+                type: Input
+            }], inResolutionsRange: [{
+                type: Input
+            }], visibilityChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/layer/layer.module.mjs

@@ -1,5 +1,7 @@
 import { NgModule } from '@angular/core';
+import { FormDialogService } from '@igo2/common/form';
 import { StyleService } from '../style/style-service/style.service';
+import { LayerGroupComponent } from './layer-group/layer-group.component';
 import { LayerItemComponent } from './layer-item/layer-item.component';
 import { LayerLegendItemComponent } from './layer-legend-item/layer-legend-item.component';
 import { LayerLegendListBindingDirective } from './layer-legend-list/layer-legend-list-binding.directive';
@@ -7,8 +9,13 @@ import { LayerLegendListComponent } from './layer-legend-list/layer-legend-list.
 import { LayerLegendComponent } from './layer-legend/layer-legend.component';
 import { LayerListToolComponent } from './layer-list-tool/layer-list-tool.component';
 import { LayerListToolService } from './layer-list-tool/layer-list-tool.service';
-import { LayerListBindingDirective } from './layer-list/layer-list-binding.directive';
 import { LayerListComponent } from './layer-list/layer-list.component';
+import { LayerSearchComponent } from './layer-search/layer-search.component';
+import { LayerUnavailableListComponent } from './layer-unavailable/layer-unavailable-list/layer-unavailable-list.component';
+import { LayerUnavailableComponent } from './layer-unavailable/layer-unavailable.component';
+import { LayerViewerBottomActionsComponent } from './layer-viewer-bottom-actions/layer-viewer-bottom-actions.component';
+import { LayerViewerComponent } from './layer-viewer/layer-viewer.component';
+import { LayerVisibilityButtonComponent } from './layer-visibility-button/layer-visibility-button.component';
 import { LayerService } from './shared/layer.service';
 import { TrackFeatureButtonComponent } from './track-feature-button/track-feature-button.component';
 import * as i0 from "@angular/core";
@@ -19,9 +26,15 @@ export const LAYER_DIRECTIVES = [
     LayerListComponent,
     LayerListToolComponent,
     LayerLegendListComponent,
-    LayerListBindingDirective,
     LayerLegendListBindingDirective,
-    TrackFeatureButtonComponent
+    TrackFeatureButtonComponent,
+    LayerGroupComponent,
+    LayerViewerComponent,
+    LayerUnavailableComponent,
+    LayerVisibilityButtonComponent,
+    LayerSearchComponent,
+    LayerViewerBottomActionsComponent,
+    LayerUnavailableListComponent
 ];
 /**
  * @deprecated import the components/directives directly or LAYER_DIRECTIVES for the set
@@ -30,7 +43,12 @@ export class IgoLayerModule {
     static forRoot() {
         return {
             ngModule: IgoLayerModule,
-            providers: [LayerService, StyleService, LayerListToolService]
+            providers: [
+                LayerService,
+                StyleService,
+                FormDialogService,
+                LayerListToolService
+            ]
         };
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoLayerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
@@ -40,50 +58,50 @@ export class IgoLayerModule {
             LayerListComponent,
             LayerListToolComponent,
             LayerLegendListComponent,
-            LayerListBindingDirective,
             LayerLegendListBindingDirective,
-            TrackFeatureButtonComponent], exports: [LayerItemComponent,
+            TrackFeatureButtonComponent,
+            LayerGroupComponent,
+            LayerViewerComponent,
+            LayerUnavailableComponent,
+            LayerVisibilityButtonComponent,
+            LayerSearchComponent,
+            LayerViewerBottomActionsComponent,
+            LayerUnavailableListComponent], exports: [LayerItemComponent,
             LayerLegendItemComponent,
             LayerLegendComponent,
             LayerListComponent,
             LayerListToolComponent,
             LayerLegendListComponent,
-            LayerListBindingDirective,
             LayerLegendListBindingDirective,
-            TrackFeatureButtonComponent] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoLayerModule, imports: [LayerItemComponent,
+            TrackFeatureButtonComponent,
+            LayerGroupComponent,
+            LayerViewerComponent,
+            LayerUnavailableComponent,
+            LayerVisibilityButtonComponent,
+            LayerSearchComponent,
+            LayerViewerBottomActionsComponent,
+            LayerUnavailableListComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoLayerModule, providers: [FormDialogService], imports: [LayerItemComponent,
             LayerLegendItemComponent,
             LayerLegendComponent,
             LayerListComponent,
             LayerListToolComponent,
             LayerLegendListComponent,
-            TrackFeatureButtonComponent] });
+            TrackFeatureButtonComponent,
+            LayerGroupComponent,
+            LayerViewerComponent,
+            LayerUnavailableComponent,
+            LayerVisibilityButtonComponent,
+            LayerSearchComponent,
+            LayerViewerBottomActionsComponent,
+            LayerUnavailableListComponent] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoLayerModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [
-                        LayerItemComponent,
-                        LayerLegendItemComponent,
-                        LayerLegendComponent,
-                        LayerListComponent,
-                        LayerListToolComponent,
-                        LayerLegendListComponent,
-                        LayerListBindingDirective,
-                        LayerLegendListBindingDirective,
-                        TrackFeatureButtonComponent
-                    ],
-                    exports: [
-                        LayerItemComponent,
-                        LayerLegendItemComponent,
-                        LayerLegendComponent,
-                        LayerListComponent,
-                        LayerListToolComponent,
-                        LayerLegendListComponent,
-                        LayerListBindingDirective,
-                        LayerLegendListBindingDirective,
-                        TrackFeatureButtonComponent
-                    ]
+                    imports: [...LAYER_DIRECTIVES],
+                    exports: [...LAYER_DIRECTIVES],
+                    providers: [FormDialogService]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/layer/shared/index.mjs

@@ -1,5 +1,6 @@
 export * from './layer.service';
 export * from './layer.enums';
 export * from './layers';
+export * from './layer-controller';
 export * from './clusterParam';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9sYXllci9zaGFyZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9sYXllci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGF5ZXIuZW51bXMnO1xuZXhwb3J0ICogZnJvbSAnLi9sYXllcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9jbHVzdGVyUGFyYW0nO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9sYXllci9zaGFyZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xheWVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9sYXllci5lbnVtcyc7XG5leHBvcnQgKiBmcm9tICcuL2xheWVycyc7XG5leHBvcnQgKiBmcm9tICcuL2xheWVyLWNvbnRyb2xsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9jbHVzdGVyUGFyYW0nO1xuIl19

package/esm2022/lib/layer/shared/layer-controller.mjs

@@ -0,0 +1,316 @@
+import { TREE_SEPERATOR, Tree } from '@igo2/utils';
+import { BehaviorSubject, combineLatest, debounceTime, map } from 'rxjs';
+import { isBaseLayer, isLayerGroup, isLayerItem } from '../utils/layer.utils';
+import { LayerSelectionModel } from './layer-selection';
+import { isLayerLinked } from './layers/linked/linked-layer.utils';
+// Below 10 is reserved for BaseLayer
+const ZINDEX_MIN = 10;
+/**
+ * We got four kind of layers
+ * TreeLayer: all layers to show in the layer manager
+ * Baselayer: Layer dedicated for the basemap
+ * SystemLayer: Every layer dedicated to good function of the map (Selection, hovering)
+ * OtherLayer: all remaining layer that is linked to another layer or simply not a systemLayer that need to be cleaned on map reset
+ */
+export class LayerController extends LayerSelectionModel {
+    _map;
+    tree;
+    /** Selection, Hovering, every internalLayer not in the tree is here */
+    _systemLayers = [];
+    /** LinkedLayer and other layer that are not in the previous category and not visible in tree */
+    _otherLayers = [];
+    layersFlattened = [];
+    _layers$ = new BehaviorSubject(undefined);
+    layers$ = this._layers$.asObservable();
+    layersFlattened$ = this._layers$
+        .asObservable()
+        .pipe(map(() => this.layersFlattened));
+    _baseLayers = [];
+    _baseLayers$ = new BehaviorSubject(undefined);
+    baseLayers$ = this._baseLayers$.asObservable();
+    baseLayerSelection;
+    /** All layers with the tree flattened */
+    all$;
+    constructor(_map, layers) {
+        super();
+        this._map = _map;
+        this.all$ = combineLatest([this.layersFlattened$, this.baseLayers$]).pipe(debounceTime(10), map(() => this.all));
+        this.tree = new Tree(layers, {
+            getChildren: (node) => isLayerGroup(node) && node.children,
+            getId: (node) => node.id,
+            getLevel: (node) => node.zIndex,
+            reverse: true
+        });
+    }
+    get all() {
+        return [
+            ...this.baseLayers,
+            ...this.layersFlattened,
+            ...this._systemLayers,
+            ...this._otherLayers
+        ];
+    }
+    get baseLayers() {
+        return this._baseLayers;
+    }
+    get baseLayer() {
+        return this.baseLayers.find((layer) => layer.visible);
+    }
+    get treeLayers() {
+        return this.tree.data;
+    }
+    add(...layers) {
+        const offset = 0;
+        const addedLayers = layers
+            .map((layer) => this.handleAdd(layer, offset))
+            .filter(Boolean);
+        if (!addedLayers.length) {
+            this.notify();
+            return;
+        }
+        this.tree.add(...addedLayers);
+        // Notify the layers change before the iteration on the addedLayer
+        // Because the Layer may have have LinkedLayer who need to find the parent.
+        this.layersFlattened = [...this.tree.flattened];
+        addedLayers.forEach((layer) => layer.add());
+        this.recalculateZindex();
+        this.notify();
+    }
+    selectBaseLayer(layer) {
+        if (!isBaseLayer(layer)) {
+            return;
+        }
+        if (this.baseLayerSelection) {
+            this.baseLayerSelection.visible = false;
+        }
+        layer.visible = true;
+        this.baseLayerSelection = layer;
+        this._map.viewController.olView.setMinZoom(layer.dataSource.options.minZoom || (this._map.options.view || {}).minZoom);
+        this._map.viewController.olView.setMaxZoom(layer.dataSource.options.maxZoom || (this._map.options.view || {}).maxZoom);
+    }
+    remove(...layers) {
+        const list = layers.reduce((list, layer) => {
+            if (this.isSelected(layer)) {
+                this.deselect(layer);
+            }
+            const result = this._remove(layer);
+            Array.isArray(result) ? list.push(...result) : list.push(result);
+            return list;
+        }, []);
+        this.tree.remove(...list);
+        this.notify();
+    }
+    /**
+     * Move a layer into the tree
+     * @param layer Layer to move
+     * @param beforeTo The index position to move inside a tree
+     */
+    moveTo(beforeTo, ...layers) {
+        const movedLayers = this.tree.moveTo(beforeTo, ...layers);
+        if (!movedLayers?.length) {
+            return;
+        }
+        return movedLayers;
+    }
+    moveBelow(layerRef, ...layers) {
+        const position = this.getPosition(layerRef, 'below');
+        const movedLayers = this.moveTo(position, ...layers);
+        this.handleMove(movedLayers, layerRef.parent);
+    }
+    moveAbove(layerRef, ...layers) {
+        const position = this.getPosition(layerRef);
+        const movedLayers = this.moveTo(position, ...layers);
+        this.handleMove(movedLayers, layerRef.parent);
+    }
+    moveInside(layerRef, ...layers) {
+        const position = this.getPosition(layerRef);
+        const movedLayers = this.moveTo(position.concat(0), ...layers);
+        this.handleMove(movedLayers, layerRef);
+    }
+    raise(...layers) {
+        const position = this.getPosition(layers[0]);
+        const nextPosition = this.findLowestVisiblePostion(position, -1);
+        this.moveTo(nextPosition, ...layers);
+        this.handleMove(layers, null, true);
+    }
+    lower(...layers) {
+        const position = this.getPosition(layers[layers.length - 1]);
+        const nextPosition = this.findLowestVisiblePostion(position, 2); // +2 because we use moveBefore
+        this.moveTo(nextPosition, ...layers);
+        this.handleMove(layers, null, true);
+    }
+    /** Reset all except SystemLayer */
+    reset() {
+        this.clearBaselayers();
+        this.clearTree();
+        this.clearOther();
+        this.clearSelection();
+        this.notify();
+    }
+    getById(id) {
+        return this.all.find((layer) => layer.id && layer.id === id);
+    }
+    getBySourceId(id) {
+        return this.all.find((layer) => layer.dataSource?.id && layer.dataSource.id === id);
+    }
+    getPosition(layer, type = 'above') {
+        const position = this.tree.getPosition(layer);
+        if (type === 'below') {
+            let index = position.pop();
+            return position.concat(++index);
+        }
+        return position;
+    }
+    getLayerRecipient(layer) {
+        return layer.parent
+            ? this.tree.getChildren(layer.parent)
+            : [...this.treeLayers];
+    }
+    /**
+     * We got non visible layer in the tree like LinkedLayer. We want the next visible layer in tree
+     */
+    findLowestVisiblePostion(position, increment) {
+        const index = position.pop();
+        const nextPosition = position.concat(index + increment);
+        const layer = this.tree.getNodeByPosition(nextPosition);
+        if (layer && !layer.showInLayerList) {
+            const nextIndex = increment > 1 ? 1 : increment;
+            return this.findLowestVisiblePostion(nextPosition, nextIndex);
+        }
+        return nextPosition;
+    }
+    handleMove(layers, parent, keepCurrentParent) {
+        if (!layers?.length) {
+            return;
+        }
+        layers.forEach((layer) => {
+            layer.moveTo(keepCurrentParent ? layer.parent : parent);
+        });
+        this._internalMove();
+    }
+    _internalMove() {
+        this.recalculateZindex();
+        this.notify();
+    }
+    getBefore(layer) {
+        return this.treeLayers.find((layerTree) => layerTree.zIndex <= layer.zIndex);
+    }
+    /** Recursive */
+    recalculateZindex(minIndex = this.baseLayers.length, layers = this.treeLayers) {
+        return [...layers].reverse().reduce((previousZindex, layer) => {
+            let zIndex = ++previousZindex;
+            layer.zIndex = zIndex;
+            if (isLayerGroup(layer)) {
+                zIndex = this.recalculateZindex(zIndex, layer.children);
+            }
+            return zIndex;
+        }, minIndex);
+    }
+    handleAdd(layer, offset) {
+        const existingLayer = this.getById(layer.id);
+        if (existingLayer !== undefined) {
+            existingLayer.visible = true;
+            return;
+        }
+        const zIndex = this.getZindexOffset(layer, offset);
+        this.setZindex(layer, zIndex);
+        layer.init(this._map);
+        if (isBaseLayer(layer)) {
+            if (layer.visible) {
+                this.selectBaseLayer(layer);
+            }
+            this._baseLayers.push(layer);
+        }
+        else if (this.isOtherLayer(layer)) {
+            this._otherLayers.push(layer);
+        }
+        else if (this.isSystemLayer(layer) && !layer.showInLayerList) {
+            this._systemLayers.push(layer);
+        }
+        else if (layer.showInLayerList) {
+            return layer;
+        }
+        else {
+            this._otherLayers.push(layer);
+        }
+        const parent = layer.parentId
+            ? this.getById(layer.parentId.split(TREE_SEPERATOR).pop())
+            : undefined;
+        layer.add(parent);
+        return;
+    }
+    _remove(layer) {
+        if (isBaseLayer(layer)) {
+            this.removeBaselayer(layer);
+        }
+        else if (this.isOtherLayer(layer)) {
+            this.removeOtherLayer(layer);
+        }
+        else if (this.isSystemLayer(layer)) {
+            this.removeSystemLayer(layer);
+        }
+        layer.remove();
+        return layer;
+    }
+    removeBaselayer(layer) {
+        this.removeIn(layer, this._baseLayers);
+    }
+    removeSystemLayer(layer) {
+        this.removeIn(layer, this._systemLayers);
+    }
+    removeOtherLayer(layer) {
+        this.removeIn(layer, this._otherLayers);
+    }
+    removeIn(layer, store) {
+        const index = store.findIndex((sysLayer) => sysLayer.id === layer.id);
+        if (index === -1) {
+            return;
+        }
+        store.splice(index, 1);
+    }
+    isSystemLayer(layer) {
+        return isLayerItem(layer) && layer.isIgoInternalLayer;
+    }
+    isOtherLayer(layer) {
+        return isLayerLinked(layer) && !layer.showInLayerList;
+    }
+    clearBaselayers() {
+        this.baseLayers.forEach((layer) => this._remove(layer));
+        this._baseLayers = [];
+    }
+    clearTree() {
+        this.treeLayers.forEach((layer) => this._remove(layer));
+        this.tree.clear();
+    }
+    clearSystems() {
+        this._systemLayers.forEach((layer) => this._remove(layer));
+        this._systemLayers = [];
+    }
+    clearOther() {
+        this._otherLayers.forEach((layer) => this._remove(layer));
+        this._otherLayers = [];
+    }
+    getZindexOffset(layer, previousOffset = 0) {
+        return layer.zIndex ? 0 : previousOffset++;
+    }
+    setZindex(layer, offset) {
+        if (isBaseLayer(layer)) {
+            return this.handleBaselayerZIndex(layer, offset);
+        }
+        if (layer.zIndex === undefined || layer.zIndex === 0) {
+            const maxZIndex = Math.max(ZINDEX_MIN, ...this.treeLayers.map((l) => l.zIndex));
+            layer.zIndex = maxZIndex + 1 + (offset ?? 0);
+        }
+    }
+    handleBaselayerZIndex(layer, offset) {
+        const maxZIndex = Math.max(0, ...this.baseLayers.map((l) => l.zIndex));
+        const zIndex = maxZIndex + 1 + (offset ?? 0);
+        layer.zIndex = zIndex > ZINDEX_MIN ? ZINDEX_MIN : zIndex;
+    }
+    notify() {
+        this.layersFlattened = [...this.tree.flattened];
+        this._layers$.next([...this.treeLayers]);
+        this._baseLayers$.next([...this.baseLayers]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layer-controller.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/layer/shared/layer-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { TREE_SEPERATOR, Tree } from '@igo2/utils';\n\nimport {\n  BehaviorSubject,\n  Observable,\n  combineLatest,\n  debounceTime,\n  map\n} from 'rxjs';\n\nimport { type MapBase } from '../../map/shared/map.abstract';\nimport { isBaseLayer, isLayerGroup, isLayerItem } from '../utils/layer.utils';\nimport { LayerSelectionModel } from './layer-selection';\nimport type { AnyLayer } from './layers/any-layer';\nimport type { Layer } from './layers/layer';\nimport type { LayerGroup } from './layers/layer-group';\nimport { isLayerLinked } from './layers/linked/linked-layer.utils';\n\n// Below 10 is reserved for BaseLayer\nconst ZINDEX_MIN = 10;\n\n/**\n * We got four kind of layers\n * TreeLayer: all layers to show in the layer manager\n * Baselayer: Layer dedicated for the basemap\n * SystemLayer: Every layer dedicated to good function of the map (Selection, hovering)\n * OtherLayer: all remaining layer that is linked to another layer or simply not a systemLayer that need to be cleaned on map reset\n */\nexport class LayerController extends LayerSelectionModel {\n  private tree: Tree<AnyLayer>;\n\n  /** Selection, Hovering, every internalLayer not in the tree is here */\n  private _systemLayers: AnyLayer[] = [];\n\n  /** LinkedLayer and other layer that are not in the previous category and not visible in tree */\n  private _otherLayers: AnyLayer[] = [];\n\n  layersFlattened: AnyLayer[] = [];\n\n  private _layers$ = new BehaviorSubject<AnyLayer[] | undefined>(undefined);\n  layers$ = this._layers$.asObservable();\n\n  layersFlattened$ = this._layers$\n    .asObservable()\n    .pipe(map(() => this.layersFlattened));\n\n  private _baseLayers: Layer[] = [];\n  private _baseLayers$ = new BehaviorSubject<Layer[] | undefined>(undefined);\n  baseLayers$ = this._baseLayers$.asObservable();\n\n  baseLayerSelection: Layer;\n\n  /** All layers with the tree flattened */\n  all$: Observable<AnyLayer[]>;\n\n  constructor(\n    private _map: MapBase,\n    layers: AnyLayer[]\n  ) {\n    super();\n\n    this.all$ = combineLatest([this.layersFlattened$, this.baseLayers$]).pipe(\n      debounceTime(10),\n      map(() => this.all)\n    );\n\n    this.tree = new Tree(layers, {\n      getChildren: (node) => isLayerGroup(node) && node.children,\n      getId: (node) => node.id,\n      getLevel: (node) => node.zIndex,\n      reverse: true\n    });\n  }\n\n  get all(): AnyLayer[] {\n    return [\n      ...this.baseLayers,\n      ...this.layersFlattened,\n      ...this._systemLayers,\n      ...this._otherLayers\n    ];\n  }\n\n  get baseLayers(): readonly Layer[] {\n    return this._baseLayers;\n  }\n\n  get baseLayer(): Layer {\n    return this.baseLayers.find((layer) => layer.visible);\n  }\n\n  get treeLayers(): readonly AnyLayer[] {\n    return this.tree.data;\n  }\n\n  add(...layers: AnyLayer[]): void {\n    const offset = 0;\n\n    const addedLayers = layers\n      .map((layer) => this.handleAdd(layer, offset))\n      .filter(Boolean);\n\n    if (!addedLayers.length) {\n      this.notify();\n      return;\n    }\n\n    this.tree.add(...addedLayers);\n\n    // Notify the layers change before the iteration on the addedLayer\n    // Because the Layer may have have LinkedLayer who need to find the parent.\n    this.layersFlattened = [...this.tree.flattened];\n    addedLayers.forEach((layer) => layer.add());\n\n    this.recalculateZindex();\n    this.notify();\n  }\n\n  selectBaseLayer(layer: Layer): void {\n    if (!isBaseLayer(layer)) {\n      return;\n    }\n\n    if (this.baseLayerSelection) {\n      this.baseLayerSelection.visible = false;\n    }\n\n    layer.visible = true;\n    this.baseLayerSelection = layer;\n\n    this._map.viewController.olView.setMinZoom(\n      layer.dataSource.options.minZoom || (this._map.options.view || {}).minZoom\n    );\n    this._map.viewController.olView.setMaxZoom(\n      layer.dataSource.options.maxZoom || (this._map.options.view || {}).maxZoom\n    );\n  }\n\n  remove(...layers: AnyLayer[]): void {\n    const list = layers.reduce((list, layer) => {\n      if (this.isSelected(layer)) {\n        this.deselect(layer);\n      }\n      const result = this._remove(layer);\n      Array.isArray(result) ? list.push(...result) : list.push(result);\n      return list;\n    }, []);\n    this.tree.remove(...list);\n\n    this.notify();\n  }\n\n  /**\n   * Move a layer into the tree\n   * @param layer Layer to move\n   * @param beforeTo The index position to move inside a tree\n   */\n  moveTo(beforeTo: number[], ...layers: AnyLayer[]): AnyLayer[] {\n    const movedLayers = this.tree.moveTo(beforeTo, ...layers);\n    if (!movedLayers?.length) {\n      return;\n    }\n\n    return movedLayers;\n  }\n\n  moveBelow(layerRef: AnyLayer | undefined, ...layers: AnyLayer[]): void {\n    const position = this.getPosition(layerRef, 'below');\n\n    const movedLayers = this.moveTo(position, ...layers);\n    this.handleMove(movedLayers, layerRef.parent);\n  }\n\n  moveAbove(layerRef: AnyLayer | undefined, ...layers: AnyLayer[]): void {\n    const position = this.getPosition(layerRef);\n\n    const movedLayers = this.moveTo(position, ...layers);\n    this.handleMove(movedLayers, layerRef.parent);\n  }\n\n  moveInside(layerRef: LayerGroup, ...layers: AnyLayer[]): void {\n    const position = this.getPosition(layerRef);\n\n    const movedLayers = this.moveTo(position.concat(0), ...layers);\n    this.handleMove(movedLayers, layerRef);\n  }\n\n  raise(...layers: AnyLayer[]): void {\n    const position = this.getPosition(layers[0]);\n    const nextPosition = this.findLowestVisiblePostion(position, -1);\n    this.moveTo(nextPosition, ...layers);\n    this.handleMove(layers, null, true);\n  }\n\n  lower(...layers: AnyLayer[]): void {\n    const position = this.getPosition(layers[layers.length - 1]);\n    const nextPosition = this.findLowestVisiblePostion(position, 2); // +2 because we use moveBefore\n    this.moveTo(nextPosition, ...layers);\n    this.handleMove(layers, null, true);\n  }\n\n  /** Reset all except SystemLayer */\n  reset(): void {\n    this.clearBaselayers();\n    this.clearTree();\n    this.clearOther();\n    this.clearSelection();\n\n    this.notify();\n  }\n\n  getById(id: string): AnyLayer {\n    return this.all.find((layer) => layer.id && layer.id === id);\n  }\n\n  getBySourceId(id: string): AnyLayer {\n    return this.all.find(\n      (layer) => layer.dataSource?.id && layer.dataSource.id === id\n    );\n  }\n\n  getPosition(layer: AnyLayer, type: 'below' | 'above' = 'above'): number[] {\n    const position = this.tree.getPosition(layer);\n\n    if (type === 'below') {\n      let index = position.pop();\n      return position.concat(++index);\n    }\n\n    return position;\n  }\n\n  getLayerRecipient(layer: AnyLayer): AnyLayer[] {\n    return layer.parent\n      ? this.tree.getChildren(layer.parent)\n      : [...this.treeLayers];\n  }\n\n  /**\n   * We got non visible layer in the tree like LinkedLayer. We want the next visible layer in tree\n   */\n  private findLowestVisiblePostion(\n    position: number[],\n    increment: number\n  ): number[] {\n    const index = position.pop();\n    const nextPosition = position.concat(index + increment);\n    const layer = this.tree.getNodeByPosition(nextPosition);\n    if (layer && !layer.showInLayerList) {\n      const nextIndex = increment > 1 ? 1 : increment;\n      return this.findLowestVisiblePostion(nextPosition, nextIndex);\n    }\n    return nextPosition;\n  }\n\n  private handleMove(\n    layers: AnyLayer[],\n    parent?: LayerGroup,\n    keepCurrentParent?: boolean\n  ): void {\n    if (!layers?.length) {\n      return;\n    }\n\n    layers.forEach((layer) => {\n      layer.moveTo(keepCurrentParent ? layer.parent : parent);\n    });\n    this._internalMove();\n  }\n\n  private _internalMove() {\n    this.recalculateZindex();\n    this.notify();\n  }\n\n  private getBefore(layer: AnyLayer): AnyLayer {\n    return this.treeLayers.find(\n      (layerTree) => layerTree.zIndex <= layer.zIndex\n    );\n  }\n\n  /** Recursive */\n  private recalculateZindex(\n    minIndex = this.baseLayers.length,\n    layers = this.treeLayers\n  ) {\n    return [...layers].reverse().reduce((previousZindex, layer) => {\n      let zIndex = ++previousZindex;\n      layer.zIndex = zIndex;\n      if (isLayerGroup(layer)) {\n        zIndex = this.recalculateZindex(zIndex, layer.children);\n      }\n\n      return zIndex;\n    }, minIndex);\n  }\n\n  private handleAdd(layer: AnyLayer, offset?: number): AnyLayer {\n    const existingLayer = this.getById(layer.id);\n    if (existingLayer !== undefined) {\n      existingLayer.visible = true;\n      return;\n    }\n\n    const zIndex = this.getZindexOffset(layer, offset);\n    this.setZindex(layer, zIndex);\n\n    layer.init(this._map);\n\n    if (isBaseLayer(layer)) {\n      if (layer.visible) {\n        this.selectBaseLayer(layer);\n      }\n      this._baseLayers.push(layer);\n    } else if (this.isOtherLayer(layer)) {\n      this._otherLayers.push(layer);\n    } else if (this.isSystemLayer(layer) && !layer.showInLayerList) {\n      this._systemLayers.push(layer);\n    } else if (layer.showInLayerList) {\n      return layer;\n    } else {\n      this._otherLayers.push(layer);\n    }\n\n    const parent: LayerGroup | undefined = layer.parentId\n      ? (this.getById(layer.parentId.split(TREE_SEPERATOR).pop()) as LayerGroup)\n      : undefined;\n    layer.add(parent);\n\n    return;\n  }\n\n  private _remove(layer: AnyLayer): AnyLayer | AnyLayer[] {\n    if (isBaseLayer(layer)) {\n      this.removeBaselayer(layer);\n    } else if (this.isOtherLayer(layer)) {\n      this.removeOtherLayer(layer);\n    } else if (this.isSystemLayer(layer)) {\n      this.removeSystemLayer(layer);\n    }\n\n    layer.remove();\n    return layer;\n  }\n\n  private removeBaselayer(layer: AnyLayer) {\n    this.removeIn(layer, this._baseLayers);\n  }\n\n  private removeSystemLayer(layer: AnyLayer) {\n    this.removeIn(layer, this._systemLayers);\n  }\n\n  private removeOtherLayer(layer: AnyLayer) {\n    this.removeIn(layer, this._otherLayers);\n  }\n\n  private removeIn(layer: AnyLayer, store: AnyLayer[]) {\n    const index = store.findIndex((sysLayer) => sysLayer.id === layer.id);\n    if (index === -1) {\n      return;\n    }\n    store.splice(index, 1);\n  }\n\n  private isSystemLayer(layer: AnyLayer): boolean {\n    return isLayerItem(layer) && layer.isIgoInternalLayer;\n  }\n\n  private isOtherLayer(layer: AnyLayer): boolean {\n    return isLayerLinked(layer) && !layer.showInLayerList;\n  }\n\n  private clearBaselayers(): void {\n    this.baseLayers.forEach((layer) => this._remove(layer));\n    this._baseLayers = [];\n  }\n\n  private clearTree(): void {\n    this.treeLayers.forEach((layer) => this._remove(layer));\n    this.tree.clear();\n  }\n\n  private clearSystems(): void {\n    this._systemLayers.forEach((layer) => this._remove(layer));\n    this._systemLayers = [];\n  }\n\n  private clearOther(): void {\n    this._otherLayers.forEach((layer) => this._remove(layer));\n    this._otherLayers = [];\n  }\n\n  private getZindexOffset(layer: AnyLayer, previousOffset = 0): number {\n    return layer.zIndex ? 0 : previousOffset++;\n  }\n\n  private setZindex(layer: AnyLayer, offset?: number): void {\n    if (isBaseLayer(layer)) {\n      return this.handleBaselayerZIndex(layer, offset);\n    }\n    if (layer.zIndex === undefined || layer.zIndex === 0) {\n      const maxZIndex = Math.max(\n        ZINDEX_MIN,\n        ...this.treeLayers.map((l) => l.zIndex)\n      );\n      layer.zIndex = maxZIndex + 1 + (offset ?? 0);\n    }\n  }\n\n  private handleBaselayerZIndex(layer: Layer, offset?: number) {\n    const maxZIndex = Math.max(0, ...this.baseLayers.map((l) => l.zIndex));\n\n    const zIndex = maxZIndex + 1 + (offset ?? 0);\n    layer.zIndex = zIndex > ZINDEX_MIN ? ZINDEX_MIN : zIndex;\n  }\n\n  private notify(): void {\n    this.layersFlattened = [...this.tree.flattened];\n    this._layers$.next([...this.treeLayers]);\n    this._baseLayers$.next([...this.baseLayers]);\n  }\n}\n"]}