@igo2/geo 17.0.1-next.2 → 18.0.0-next.10

package/lib/layer/layer-list/layer-list.component.d.ts

@@ -1,127 +1,55 @@
-import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
-import type { TemplateRef } from '@angular/core';
-import { FloatLabelType } from '@angular/material/form-field';
-import { MatSliderChange } from '@angular/material/slider';
-import { BehaviorSubject, ReplaySubject } from 'rxjs';
-import { IgoMap } from '../../map/shared/map';
-import { LayerListControlsOptions } from '../layer-list-tool/layer-list-tool.interface';
-import { Layer } from '../shared/layers/layer';
-import { LayerListDisplacement } from './layer-list.enum';
-import { LayerListSelectVisibleEnum } from './layer-list.enum';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { EventEmitter } from '@angular/core';
+import { MatTreeFlatDataSource, MatTreeFlattener } from '@angular/material/tree';
+import { DropPermission, TreeDropEvent, TreeFlatNode } from '@igo2/common/drag-drop';
+import { IconSvg } from '@igo2/common/icon';
+import { MessageService } from '@igo2/core/message';
+import type { LayerViewerOptions } from '../layer-viewer/layer-viewer.interface';
+import { LayerType } from '../shared';
+import type { LayerController } from '../shared/layer-controller';
+import type { AnyLayer } from '../shared/layers/any-layer';
+import type { Layer } from '../shared/layers/layer';
+import type { LayerGroup } from '../shared/layers/layer-group';
+import { isLayerGroup, isLayerItem } from '../utils/layer.utils';
 import * as i0 from "@angular/core";
-export declare class LayerListComponent implements OnInit, OnDestroy {
-    private elRef;
-    orderable: boolean;
-    thresholdToFilterAndSort: number;
-    layers$: BehaviorSubject<Layer[]>;
-    change$: ReplaySubject<void>;
-    showToolbar$: BehaviorSubject<boolean>;
-    layerTool: boolean;
-    hideSelectedLayers: boolean;
-    activeLayer$: BehaviorSubject<Layer>;
-    layersChecked: Layer[];
-    selection: boolean;
-    private change$$;
-    private layers$$;
-    layerItemChangeDetection$: BehaviorSubject<any>;
-    templateLayerToolbar: TemplateRef<any>;
-    layersAreAllVisible: boolean;
-    ogcButton: boolean;
-    timeButton: boolean;
-    get map(): IgoMap;
-    set map(value: IgoMap);
-    private _map;
-    set layers(value: Layer[]);
-    get layers(): Layer[];
-    private _layers;
-    set activeLayer(value: Layer);
-    get activeLayer(): Layer;
-    private _activeLayer;
-    floatLabel: FloatLabelType;
-    layerFilterAndSortOptions: LayerListControlsOptions;
-    excludeBaseLayers: boolean;
-    toggleLegendOnVisibilityChange: boolean;
-    expandLegendOfVisibleLayers: boolean;
-    updateLegendOnResolutionChange: boolean;
-    queryBadge: boolean;
-    appliedFilterAndSort: EventEmitter<LayerListControlsOptions>;
-    get keyword(): string;
-    set keyword(value: string);
-    private _keyword;
-    get onlyVisible(): boolean;
-    set onlyVisible(value: boolean);
-    private _onlyVisible;
-    get sortAlpha(): boolean;
-    set sortAlpha(value: boolean);
-    private _sortedAlpha;
-    get opacity(): number;
-    set opacity(opacity: number);
-    get badgeOpacity(): number;
-    get raiseDisabled(): boolean;
-    get lowerDisabled(): boolean;
-    get raiseDisabledSelection(): boolean;
-    get lowerDisabledSelection(): boolean;
-    get checkOpacity(): number;
-    set checkOpacity(opacity: number);
-    get layerListDisplacement(): typeof LayerListDisplacement;
+type LayerFlatNode<T = AnyLayer> = TreeFlatNode<T>;
+export declare class LayerListComponent {
+    private messageService;
     toggleOpacity: boolean;
-    selectAllCheck: boolean;
-    selectAllCheck$: BehaviorSubject<boolean>;
-    private selectAllCheck$$;
-    constructor(elRef: ElementRef);
-    /**
-     * Subscribe to the search term stream and trigger researches
-     * @internal
-     */
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    activeLayerExtentIsValid(layer: Layer): boolean;
-    activeLayersExtentAreValid(layers: Layer[]): boolean;
-    zoomLayerExtents(layer: Layer): void;
-    zoomLayersExtents(layers: Layer[]): void;
-    changeOpacity(event: MatSliderChange): void;
-    clearKeyword(): void;
-    getLowerLayer(): {
-        zIndex: any;
-        id: any;
-    };
-    isLowerBaselayer(layer: any): boolean;
-    getUpperLayer(): {
-        zIndex: any;
-        id: any;
-    };
-    isUpperBaselayer(layer: any): boolean;
-    moveActiveLayer(activeLayer: Layer, actiontype: LayerListDisplacement, fromUi?: boolean): void;
-    raisableLayers(layers: Layer[]): boolean;
-    raisableLayer(index: number): any;
-    raiseLayers(layers: Layer[], fromUi?: boolean): void;
-    lowerableLayers(layers: Layer[]): boolean;
-    lowerableLayer(index: number): any;
-    lowerLayers(layers: Layer[], fromUi?: boolean): void;
-    private next;
-    private computeLayers;
-    onKeywordChange(term: any): void;
-    onAppliedFilterAndSortChange(appliedFilter: LayerListControlsOptions): void;
-    private filterLayers;
-    private sortLayersByZindex;
-    private sortLayersByTitle;
-    private normalize;
-    private computeShowToolbar;
-    toggleLayerTool(layer: any): void;
-    removeLayers(layers?: Layer[]): void;
-    toggleVisibility(layers?: Layer[]): void;
-    isLayerRemovable(layer: Layer): boolean;
-    isAllLayersRemovable(layers: Layer[]): boolean;
-    get statusSelectedLayersCheck(): LayerListSelectVisibleEnum;
-    layersCheck(event: {
-        layer: Layer;
-        check: boolean;
-    }): void;
-    toggleSelectionMode(value: boolean): void;
-    layersCheckedOpacity(): any;
-    selectAll(): void;
-    isScrolledIntoView(elemSource: any, elem: any): boolean;
-    removeProblemLayerInList(layersList: Layer[]): Layer[];
+    isInit: boolean;
+    controller: LayerController;
+    set layers(layers: AnyLayer[]);
+    get layers(): AnyLayer[];
+    private _layers;
+    isDesktop: boolean;
+    isDragDropDisabled: boolean;
+    selectAll: boolean;
+    viewerOptions: LayerViewerOptions;
+    activeChange: EventEmitter<AnyLayer>;
+    private _transformer;
+    treeControl: FlatTreeControl<LayerFlatNode<AnyLayer>, LayerFlatNode<AnyLayer>>;
+    treeFlattener: MatTreeFlattener<AnyLayer, LayerFlatNode<AnyLayer>, LayerFlatNode<AnyLayer>>;
+    dataSource: MatTreeFlatDataSource<AnyLayer, LayerFlatNode>;
+    constructor(messageService: MessageService);
+    isGroup: (_: number, node: LayerFlatNode) => boolean;
+    isLayerGroup: typeof isLayerGroup;
+    isLayerItem: typeof isLayerItem;
+    isSelected: (layer: AnyLayer) => boolean;
+    isDescendantSelection: (layer: AnyLayer) => boolean;
+    toggleActive(layer: AnyLayer): void;
+    handleSelect(checked: boolean, layer: AnyLayer): void;
+    getLayerType(layer: Layer): LayerType | 'measure' | 'draw';
+    getLayerIcon(layer: Layer): string | IconSvg;
+    dropNode({ node, ref, position }: TreeDropEvent<AnyLayer>): void;
+    dropNodeError(details: DropPermission): void;
+    dragStart(): void;
+    handleNodeToggle(node: LayerFlatNode<LayerGroup>): void;
+    private findNodeByLayerId;
+    private updateDatasource;
+    /** Recursive */
+    private expandGroup;
+    private restoreModel;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerListComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LayerListComponent, "igo-layer-list", never, { "layersAreAllVisible": { "alias": "layersAreAllVisible"; "required": false; }; "ogcButton": { "alias": "ogcButton"; "required": false; }; "timeButton": { "alias": "timeButton"; "required": false; }; "map": { "alias": "map"; "required": false; }; "layers": { "alias": "layers"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "layerFilterAndSortOptions": { "alias": "layerFilterAndSortOptions"; "required": false; }; "excludeBaseLayers": { "alias": "excludeBaseLayers"; "required": false; }; "toggleLegendOnVisibilityChange": { "alias": "toggleLegendOnVisibilityChange"; "required": false; }; "expandLegendOfVisibleLayers": { "alias": "expandLegendOfVisibleLayers"; "required": false; }; "updateLegendOnResolutionChange": { "alias": "updateLegendOnResolutionChange"; "required": false; }; "queryBadge": { "alias": "queryBadge"; "required": false; }; }, { "appliedFilterAndSort": "appliedFilterAndSort"; }, ["templateLayerToolbar"], ["[igoLayerItemToolbar]"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerListComponent, "igo-layer-list", never, { "controller": { "alias": "controller"; "required": true; }; "layers": { "alias": "layers"; "required": true; }; "isDesktop": { "alias": "isDesktop"; "required": false; }; "isDragDropDisabled": { "alias": "isDragDropDisabled"; "required": false; }; "selectAll": { "alias": "selectAll"; "required": false; }; "viewerOptions": { "alias": "viewerOptions"; "required": false; }; }, { "activeChange": "activeChange"; }, never, never, true, never>;
 }
+export {};

package/lib/layer/layer-list-tool/index.d.ts

@@ -1,4 +1,3 @@
 export * from './layer-list-tool.component';
-export * from './layer-list-tool.enum';
 export * from './layer-list-tool.interface';
 export * from './layer-list-tool.service';

package/lib/layer/layer-list-tool/layer-list-tool.component.d.ts

@@ -1,32 +1,25 @@
-import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { EventEmitter } from '@angular/core';
 import { FloatLabelType } from '@angular/material/form-field';
-import { BehaviorSubject, Subscription } from 'rxjs';
-import { LayerListControlsOptions } from './layer-list-tool.interface';
+import { LayerToolMode, LayerViewerOptions } from '../layer-viewer/layer-viewer.interface';
+import { LayerGroup } from '../shared/layers/layer-group';
+import { LayerListToolService } from './layer-list-tool.service';
 import * as i0 from "@angular/core";
-export declare class LayerListToolComponent implements OnInit, OnDestroy {
-    onlyVisible$: BehaviorSubject<boolean>;
-    sortAlpha$: BehaviorSubject<boolean>;
-    term$: BehaviorSubject<string>;
-    onlyVisible$$: Subscription;
-    sortAlpha$$: Subscription;
-    term$$: Subscription;
-    layersAreAllVisible: boolean;
+export declare class LayerListToolComponent {
+    private layerListToolService;
+    mode: LayerToolMode;
+    viewerOptions: LayerViewerOptions;
     floatLabel: FloatLabelType;
-    set onlyVisible(value: boolean);
-    get onlyVisible(): boolean;
-    set sortAlpha(value: boolean);
-    get sortAlpha(): boolean;
-    set term(value: string);
-    get term(): string;
-    selectionMode: boolean;
-    appliedFilterAndSort: EventEmitter<LayerListControlsOptions>;
-    selection: EventEmitter<boolean>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    clearTerm(): void;
-    toggleSortAlpha(): void;
-    toggleOnlyVisible(): void;
+    onlyVisible: boolean;
+    term: string;
+    searchChange: EventEmitter<string>;
+    visibilityOnlyChange: EventEmitter<boolean>;
+    modeChange: EventEmitter<boolean>;
+    addedLayer: EventEmitter<LayerGroup>;
+    get selectionActive(): boolean;
+    constructor(layerListToolService: LayerListToolService);
+    handleTermChange(value: string | undefined): void;
     toggleSelectionMode(): void;
+    createGroup(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerListToolComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LayerListToolComponent, "igo-layer-list-tool", never, { "layersAreAllVisible": { "alias": "layersAreAllVisible"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "onlyVisible": { "alias": "onlyVisible"; "required": false; }; "sortAlpha": { "alias": "sortAlpha"; "required": false; }; "term": { "alias": "term"; "required": false; }; }, { "appliedFilterAndSort": "appliedFilterAndSort"; "selection": "selection"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerListToolComponent, "igo-layer-list-tool", never, { "mode": { "alias": "mode"; "required": true; }; "viewerOptions": { "alias": "viewerOptions"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "onlyVisible": { "alias": "onlyVisible"; "required": false; }; "term": { "alias": "term"; "required": false; }; }, { "searchChange": "searchChange"; "visibilityOnlyChange": "visibilityOnlyChange"; "modeChange": "modeChange"; "addedLayer": "addedLayer"; }, never, never, true, never>;
 }

package/lib/layer/layer-list-tool/layer-list-tool.interface.d.ts

@@ -1,4 +1,3 @@
-import { LayerListControlsEnum } from '../layer-list/layer-list.enum';
 export interface LayerListControlsOptions {
     excludeBaseLayers?: boolean;
     showToolbar?: LayerListControlsEnum;
@@ -6,3 +5,8 @@ export interface LayerListControlsOptions {
     sortAlpha?: boolean;
     onlyVisible?: boolean;
 }
+export declare enum LayerListControlsEnum {
+    always = "always",
+    never = "never",
+    default = "default"
+}

package/lib/layer/layer-list-tool/layer-list-tool.service.d.ts

@@ -1,13 +1,14 @@
+import { FormDialogService } from '@igo2/common/form';
+import { Observable } from 'rxjs';
+import { LayerService } from '../shared/layer.service';
+import { LayerGroup } from '../shared/layers/layer-group';
 import * as i0 from "@angular/core";
 export declare class LayerListToolService {
-    keyword: string;
-    sortAlpha: boolean;
-    onlyVisible: boolean;
-    onlyInRange: boolean;
-    keywordInitialized: boolean;
-    sortedAlphaInitialized: boolean;
-    onlyVisibleInitialized: boolean;
-    onlyInRangeInitialized: boolean;
+    private layerService;
+    private formDialogService;
+    constructor(layerService: LayerService, formDialogService: FormDialogService);
+    createGroup(): Observable<LayerGroup | undefined>;
+    renameGroup(group: LayerGroup): Observable<string | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerListToolService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LayerListToolService>;
 }

package/lib/layer/layer-search/index.d.ts

@@ -0,0 +1 @@
+export * from './layer-search.component';

package/lib/layer/layer-search/layer-search.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { FloatLabelType } from '@angular/material/form-field';
+import * as i0 from "@angular/core";
+export declare class LayerSearchComponent implements OnInit {
+    control: FormControl<any>;
+    initialValue: string;
+    floatLabel: FloatLabelType;
+    placeholder: string;
+    tooltip: string;
+    searchChange: EventEmitter<string>;
+    ngOnInit(): void;
+    clearTerm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerSearchComponent, "igo-layer-search", never, { "initialValue": { "alias": "initialValue"; "required": false; }; "floatLabel": { "alias": "floatLabel"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, { "searchChange": "searchChange"; }, never, never, true, never>;
+}

package/lib/layer/layer-unavailable/index.d.ts

@@ -0,0 +1,2 @@
+export * from './layer-unavailable.component';
+export * from './layer-unavailable-list/layer-unavailable-list.component';

package/lib/layer/layer-unavailable/layer-unavailable-list/layer-unavailable-list.component.d.ts

@@ -0,0 +1,10 @@
+import { AnyLayerOptions, LayerService } from '../../shared';
+import * as i0 from "@angular/core";
+export declare class LayerUnavailableListComponent {
+    private layerService;
+    layersOptions: AnyLayerOptions[];
+    constructor(layerService: LayerService);
+    deleteUnavailableLayer(options: AnyLayerOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerUnavailableListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerUnavailableListComponent, "igo-layer-unavailable-list", never, { "layersOptions": { "alias": "layersOptions"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/layer/layer-unavailable/layer-unavailable.component.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from '@angular/core';
+import { AnyLayerItemOptions, AnyLayerOptions } from '../shared';
+import * as i0 from "@angular/core";
+export declare class LayerUnavailableComponent {
+    layerOptions: AnyLayerItemOptions;
+    remove: EventEmitter<AnyLayerOptions>;
+    get title(): string | undefined;
+    handleRemove(layerOptions: AnyLayerOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerUnavailableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerUnavailableComponent, "igo-layer-unavailable", never, { "layerOptions": { "alias": "layerOptions"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
+}

package/lib/layer/layer-viewer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './layer-viewer.component';
+export * from './layer-viewer.interface';

package/lib/layer/layer-viewer/layer-viewer.component.d.ts

@@ -0,0 +1,52 @@
+import { ChangeDetectorRef, EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import type { MapBase } from '../../map/shared/map.abstract';
+import { LayerListControlsOptions } from '../layer-list-tool/layer-list-tool.interface';
+import { LayerController } from '../shared';
+import { LayerService } from '../shared/layer.service';
+import { AnyLayer, LayerGroup, LayerOptionsBase } from '../shared/layers';
+import { isLayerItem } from '../utils/layer.utils';
+import { LayerToolMode, LayerViewerOptions } from './layer-viewer.interface';
+import * as i0 from "@angular/core";
+export declare class LayerViewerComponent implements OnInit {
+    private cdr;
+    private layerService;
+    layers: AnyLayer[];
+    baselayers: AnyLayer[];
+    keyword$: BehaviorSubject<string>;
+    mode: LayerToolMode;
+    isDragDropDisabled: boolean;
+    map: MapBase;
+    options: LayerViewerOptions;
+    isDesktop: boolean;
+    excludeBaseLayers: boolean;
+    appliedFilterAndSort: EventEmitter<LayerListControlsOptions>;
+    customBottomActions: TemplateRef<unknown> | undefined;
+    get layerViewerOptions(): LayerViewerOptions;
+    get layerController(): LayerController;
+    get unavailableLayers(): LayerOptionsBase[];
+    constructor(cdr: ChangeDetectorRef, layerService: LayerService);
+    isLayerItem: typeof isLayerItem;
+    /**
+     * Subscribe to the search term stream and trigger researches
+     * @internal
+     */
+    ngOnInit(): void;
+    clearKeyword(): void;
+    onVisibilityOnlyChange(): void;
+    onLayerChange(): void;
+    onSearchChange(value: string | undefined): void;
+    toggleSelectionMode(active: boolean): void;
+    toggleAllRows(): void;
+    isAllSelected(): boolean;
+    isScrolledIntoView(elemSource: any, elem: any): boolean;
+    createGroup(group: LayerGroup): void;
+    private computeLayers;
+    private filterLayers;
+    /** Recursive */
+    private filterSearch;
+    private layerHasTerm;
+    private normalizeString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerViewerComponent, "igo-layer-viewer", never, { "map": { "alias": "map"; "required": true; }; "options": { "alias": "options"; "required": false; }; "isDesktop": { "alias": "isDesktop"; "required": false; }; "excludeBaseLayers": { "alias": "excludeBaseLayers"; "required": false; }; }, { "appliedFilterAndSort": "appliedFilterAndSort"; }, ["customBottomActions"], ["[emptyList]", "*"], true, never>;
+}

package/lib/layer/layer-viewer/layer-viewer.interface.d.ts

@@ -0,0 +1,22 @@
+import { LayerListControlsOptions } from '../layer-list-tool/layer-list-tool.interface';
+export interface LayerConfig {
+    group?: {
+        enable: boolean;
+        maxHierarchyLevel?: number;
+        canCreate?: boolean;
+        canRename?: boolean;
+    };
+}
+export interface LayerViewerOptions extends LayerConfig {
+    mode?: LayerToolMode;
+    queryBadge?: boolean;
+    legend?: Partial<ViewerLegendOptions>;
+    filterAndSortOptions?: LayerListControlsOptions;
+}
+interface ViewerLegendOptions {
+    showOnVisibilityChange: boolean;
+    updateOnResolutionChange: boolean;
+    showForVisibleLayers: boolean;
+}
+export type LayerToolMode = 'selection';
+export {};

package/lib/layer/layer-viewer-bottom-actions/index.d.ts

@@ -0,0 +1 @@
+export * from './layer-viewer-bottom-actions.component';

package/lib/layer/layer-viewer-bottom-actions/layer-viewer-bottom-actions.component.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from '@angular/core';
+import { MatSliderChange } from '@angular/material/slider';
+import type { MapBase } from '../../map/shared/map.abstract';
+import { LayerListToolService } from '../layer-list-tool';
+import { LayerViewerOptions } from '../layer-viewer/layer-viewer.interface';
+import { LayerController } from '../shared/layer-controller';
+import type { AnyLayer } from '../shared/layers';
+import { isLayerItem } from '../utils/layer.utils';
+import * as i0 from "@angular/core";
+export declare class LayerViewerBottomActionsComponent {
+    private layerListToolService;
+    orderable: boolean;
+    map: MapBase;
+    controller: LayerController;
+    searchTerm: string;
+    viewerOptions: LayerViewerOptions;
+    layerChange: EventEmitter<any>;
+    get layersFlattened(): AnyLayer[];
+    get hasMultipleSelection(): boolean;
+    get selected(): AnyLayer[];
+    get opacity(): number;
+    set opacity(opacity: number);
+    get allSelectionVisibilityHidden(): boolean;
+    get isSelectionRaisable(): boolean;
+    get isSelectionLowerable(): boolean;
+    get canRename(): boolean;
+    constructor(layerListToolService: LayerListToolService);
+    isLayerItem: typeof isLayerItem;
+    handleRename(): void;
+    isLayersRemovable(layers: AnyLayer[]): boolean;
+    removeLayers(): void;
+    isExtentsValid(): boolean;
+    zoomLayersExtents(): void;
+    raiseSelection(): void;
+    lowerSelection(): void;
+    changeOpacity(event: MatSliderChange): void;
+    toggleSelectionVisibility(): void;
+    private isLowerable;
+    private isRaisable;
+    private getRecipientOfVisibleLayer;
+    private isLayerRemovable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerViewerBottomActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerViewerBottomActionsComponent, "igo-layer-viewer-bottom-actions", never, { "map": { "alias": "map"; "required": true; }; "controller": { "alias": "controller"; "required": true; }; "searchTerm": { "alias": "searchTerm"; "required": true; }; "viewerOptions": { "alias": "viewerOptions"; "required": false; }; }, { "layerChange": "layerChange"; }, never, ["*"], true, never>;
+}

package/lib/layer/layer-visibility-button/index.d.ts

@@ -0,0 +1 @@
+export * from './layer-visibility-button.component';

package/lib/layer/layer-visibility-button/layer-visibility-button.component.d.ts

@@ -0,0 +1,22 @@
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { IconSvg } from '@igo2/common/icon';
+import { AnyLayer } from '../shared/layers/any-layer';
+import * as i0 from "@angular/core";
+export declare class LayerVisibilityButtonComponent implements OnInit {
+    private cdr;
+    eyeClosedSvg: IconSvg;
+    hiddenByParent?: boolean;
+    visible: boolean;
+    layer: AnyLayer;
+    tooltip: string;
+    disabled: boolean;
+    showQueryBadge: boolean;
+    inResolutionsRange: boolean;
+    get defaultTooltip(): string;
+    visibilityChange: EventEmitter<Event>;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    toggle(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerVisibilityButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerVisibilityButtonComponent, "igo-layer-visibility-button", never, { "layer": { "alias": "layer"; "required": true; }; "tooltip": { "alias": "tooltip"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showQueryBadge": { "alias": "showQueryBadge"; "required": false; }; "inResolutionsRange": { "alias": "inResolutionsRange"; "required": false; }; }, { "visibilityChange": "visibilityChange"; }, never, never, true, never>;
+}

package/lib/layer/layer.module.d.ts

@@ -1,12 +1,18 @@
 import { ModuleWithProviders } from '@angular/core';
+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';
 import { LayerLegendListComponent } from './layer-legend-list/layer-legend-list.component';
 import { LayerLegendComponent } from './layer-legend/layer-legend.component';
 import { LayerListToolComponent } from './layer-list-tool/layer-list-tool.component';
-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 { TrackFeatureButtonComponent } from './track-feature-button/track-feature-button.component';
 import * as i0 from "@angular/core";
 import * as i1 from "./layer-item/layer-item.component";
@@ -15,16 +21,22 @@ import * as i3 from "./layer-legend/layer-legend.component";
 import * as i4 from "./layer-list/layer-list.component";
 import * as i5 from "./layer-list-tool/layer-list-tool.component";
 import * as i6 from "./layer-legend-list/layer-legend-list.component";
-import * as i7 from "./layer-list/layer-list-binding.directive";
-import * as i8 from "./layer-legend-list/layer-legend-list-binding.directive";
-import * as i9 from "./track-feature-button/track-feature-button.component";
-export declare const LAYER_DIRECTIVES: readonly [typeof LayerItemComponent, typeof LayerLegendItemComponent, typeof LayerLegendComponent, typeof LayerListComponent, typeof LayerListToolComponent, typeof LayerLegendListComponent, typeof LayerListBindingDirective, typeof LayerLegendListBindingDirective, typeof TrackFeatureButtonComponent];
+import * as i7 from "./layer-legend-list/layer-legend-list-binding.directive";
+import * as i8 from "./track-feature-button/track-feature-button.component";
+import * as i9 from "./layer-group/layer-group.component";
+import * as i10 from "./layer-viewer/layer-viewer.component";
+import * as i11 from "./layer-unavailable/layer-unavailable.component";
+import * as i12 from "./layer-visibility-button/layer-visibility-button.component";
+import * as i13 from "./layer-search/layer-search.component";
+import * as i14 from "./layer-viewer-bottom-actions/layer-viewer-bottom-actions.component";
+import * as i15 from "./layer-unavailable/layer-unavailable-list/layer-unavailable-list.component";
+export declare const LAYER_DIRECTIVES: readonly [typeof LayerItemComponent, typeof LayerLegendItemComponent, typeof LayerLegendComponent, typeof LayerListComponent, typeof LayerListToolComponent, typeof LayerLegendListComponent, typeof LayerLegendListBindingDirective, typeof TrackFeatureButtonComponent, typeof LayerGroupComponent, typeof LayerViewerComponent, typeof LayerUnavailableComponent, typeof LayerVisibilityButtonComponent, typeof LayerSearchComponent, typeof LayerViewerBottomActionsComponent, typeof LayerUnavailableListComponent];
 /**
  * @deprecated import the components/directives directly or LAYER_DIRECTIVES for the set
  */
 export declare class IgoLayerModule {
     static forRoot(): ModuleWithProviders<IgoLayerModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<IgoLayerModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoLayerModule, never, [typeof i1.LayerItemComponent, typeof i2.LayerLegendItemComponent, typeof i3.LayerLegendComponent, typeof i4.LayerListComponent, typeof i5.LayerListToolComponent, typeof i6.LayerLegendListComponent, typeof i7.LayerListBindingDirective, typeof i8.LayerLegendListBindingDirective, typeof i9.TrackFeatureButtonComponent], [typeof i1.LayerItemComponent, typeof i2.LayerLegendItemComponent, typeof i3.LayerLegendComponent, typeof i4.LayerListComponent, typeof i5.LayerListToolComponent, typeof i6.LayerLegendListComponent, typeof i7.LayerListBindingDirective, typeof i8.LayerLegendListBindingDirective, typeof i9.TrackFeatureButtonComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoLayerModule, never, [typeof i1.LayerItemComponent, typeof i2.LayerLegendItemComponent, typeof i3.LayerLegendComponent, typeof i4.LayerListComponent, typeof i5.LayerListToolComponent, typeof i6.LayerLegendListComponent, typeof i7.LayerLegendListBindingDirective, typeof i8.TrackFeatureButtonComponent, typeof i9.LayerGroupComponent, typeof i10.LayerViewerComponent, typeof i11.LayerUnavailableComponent, typeof i12.LayerVisibilityButtonComponent, typeof i13.LayerSearchComponent, typeof i14.LayerViewerBottomActionsComponent, typeof i15.LayerUnavailableListComponent], [typeof i1.LayerItemComponent, typeof i2.LayerLegendItemComponent, typeof i3.LayerLegendComponent, typeof i4.LayerListComponent, typeof i5.LayerListToolComponent, typeof i6.LayerLegendListComponent, typeof i7.LayerLegendListBindingDirective, typeof i8.TrackFeatureButtonComponent, typeof i9.LayerGroupComponent, typeof i10.LayerViewerComponent, typeof i11.LayerUnavailableComponent, typeof i12.LayerVisibilityButtonComponent, typeof i13.LayerSearchComponent, typeof i14.LayerViewerBottomActionsComponent, typeof i15.LayerUnavailableListComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<IgoLayerModule>;
 }

package/lib/layer/shared/index.d.ts

@@ -1,4 +1,5 @@
 export * from './layer.service';
 export * from './layer.enums';
 export * from './layers';
+export * from './layer-controller';
 export * from './clusterParam';

package/lib/layer/shared/layer-controller.d.ts

@@ -0,0 +1,81 @@
+import { Observable } from 'rxjs';
+import { type MapBase } from '../../map/shared/map.abstract';
+import { LayerSelectionModel } from './layer-selection';
+import type { AnyLayer } from './layers/any-layer';
+import type { Layer } from './layers/layer';
+import type { LayerGroup } from './layers/layer-group';
+/**
+ * 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 declare class LayerController extends LayerSelectionModel {
+    private _map;
+    private tree;
+    /** Selection, Hovering, every internalLayer not in the tree is here */
+    private _systemLayers;
+    /** LinkedLayer and other layer that are not in the previous category and not visible in tree */
+    private _otherLayers;
+    layersFlattened: AnyLayer[];
+    private _layers$;
+    layers$: Observable<AnyLayer[]>;
+    layersFlattened$: Observable<AnyLayer[]>;
+    private _baseLayers;
+    private _baseLayers$;
+    baseLayers$: Observable<Layer[]>;
+    baseLayerSelection: Layer;
+    /** All layers with the tree flattened */
+    all$: Observable<AnyLayer[]>;
+    constructor(_map: MapBase, layers: AnyLayer[]);
+    get all(): AnyLayer[];
+    get baseLayers(): readonly Layer[];
+    get baseLayer(): Layer;
+    get treeLayers(): readonly AnyLayer[];
+    add(...layers: AnyLayer[]): void;
+    selectBaseLayer(layer: Layer): void;
+    remove(...layers: AnyLayer[]): void;
+    /**
+     * Move a layer into the tree
+     * @param layer Layer to move
+     * @param beforeTo The index position to move inside a tree
+     */
+    moveTo(beforeTo: number[], ...layers: AnyLayer[]): AnyLayer[];
+    moveBelow(layerRef: AnyLayer | undefined, ...layers: AnyLayer[]): void;
+    moveAbove(layerRef: AnyLayer | undefined, ...layers: AnyLayer[]): void;
+    moveInside(layerRef: LayerGroup, ...layers: AnyLayer[]): void;
+    raise(...layers: AnyLayer[]): void;
+    lower(...layers: AnyLayer[]): void;
+    /** Reset all except SystemLayer */
+    reset(): void;
+    getById(id: string): AnyLayer;
+    getBySourceId(id: string): AnyLayer;
+    getPosition(layer: AnyLayer, type?: 'below' | 'above'): number[];
+    getLayerRecipient(layer: AnyLayer): AnyLayer[];
+    /**
+     * We got non visible layer in the tree like LinkedLayer. We want the next visible layer in tree
+     */
+    private findLowestVisiblePostion;
+    private handleMove;
+    private _internalMove;
+    private getBefore;
+    /** Recursive */
+    private recalculateZindex;
+    private handleAdd;
+    private _remove;
+    private removeBaselayer;
+    private removeSystemLayer;
+    private removeOtherLayer;
+    private removeIn;
+    private isSystemLayer;
+    private isOtherLayer;
+    private clearBaselayers;
+    private clearTree;
+    private clearSystems;
+    private clearOther;
+    private getZindexOffset;
+    private setZindex;
+    private handleBaselayerZIndex;
+    private notify;
+}