@igo2/geo 18.0.0-next.9 → 18.0.1-next.1

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;
+}

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

@@ -0,0 +1,14 @@
+import { AnyLayer } from './layers/any-layer';
+export declare class LayerSelectionModel {
+    private selection;
+    private descendantSelection;
+    get selected(): AnyLayer[];
+    get hasSelection(): boolean;
+    get isSelectionEmpty(): boolean;
+    clearSelection(): void;
+    select(...layers: AnyLayer[]): void;
+    deselect(...layers: AnyLayer[]): void;
+    isSelected: (layer: AnyLayer) => boolean;
+    isDescendantSelection: (layer: AnyLayer) => boolean;
+    private getDescendants;
+}

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

@@ -7,7 +7,8 @@ import { AnyDataSourceOptions, AnyDataSourceOptionsWithParams, ArcGISRestDataSou
 import { LayerDBService } from '../../offline/layerDB/layerDB.service';
 import { GeoNetworkService } from '../../offline/shared/geo-network.service';
 import { StyleService } from '../../style/style-service/style.service';
-import { AnyLayerOptions, Layer } from './layers';
+import { AnyLayer, AnyLayerItemOptions, AnyLayerOptions, Layer, LayerGroupOptions } from './layers';
+import { LayerGroup } from './layers/layer-group';
 import * as i0 from "@angular/core";
 export declare class LayerService {
     private http;
@@ -17,10 +18,13 @@ export declare class LayerService {
     private geoNetworkService?;
     private layerDBService?;
     private authInterceptor?;
-    unavailableLayers: AnyLayerOptions[];
+    unavailableLayers: AnyLayerItemOptions[];
     constructor(http: HttpClient, styleService: StyleService, dataSourceService: DataSourceService, messageService: MessageService, geoNetworkService?: GeoNetworkService, layerDBService?: LayerDBService, authInterceptor?: AuthInterceptor);
-    createLayer(layerOptions: AnyLayerOptions): Layer;
-    createAsyncLayer(_layerOptions: AnyLayerOptions, detailedContextUri?: string): Observable<Layer>;
+    createLayers(layersOption: AnyLayerOptions[], contextUri?: string): Observable<(AnyLayer | undefined)[]>;
+    createLayer(layerOptions: AnyLayerItemOptions): Layer;
+    createAsyncLayer(options: AnyLayerItemOptions, detailedContextUri?: string): Observable<Layer | undefined>;
+    createAsyncGroup(options: LayerGroupOptions, detailedContextUri?: string): Observable<LayerGroup>;
+    private createGroup;
     private createImageLayer;
     private createTileLayer;
     private createVectorLayer;
@@ -30,7 +34,7 @@ export declare class LayerService {
     private getStuff;
     private getAbsoluteUrl;
     createAsyncIdbLayers(contextUri?: string): Observable<Layer[]>;
-    deleteUnavailableLayers(anyLayerOptions: AnyLayerOptions): void;
+    deleteUnavailableLayers(anyLayerOptions: AnyLayerItemOptions): void;
     sourceOptionsWithParams(sourceOptions: AnyDataSourceOptions): sourceOptions is AnyDataSourceOptionsWithParams;
     sourceOptionsWithLayer(sourceOptions: AnyDataSourceOptions): sourceOptions is ArcGISRestDataSourceOptions | WMTSDataSourceOptions;
     static ɵfac: i0.ɵɵFactoryDeclaration<LayerService, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;

package/lib/layer/shared/layers/any-layer.d.ts

@@ -1,6 +1,3 @@
-import { ImageLayer } from './image-layer';
-import { Layer } from './layer';
-import { TileLayer } from './tile-layer';
-import { VectorLayer } from './vector-layer';
-import { VectorTileLayer } from './vectortile-layer';
-export type AnyLayer = Layer | ImageLayer | TileLayer | VectorLayer | VectorTileLayer;
+import { type Layer } from './layer';
+import { type LayerGroup } from './layer-group';
+export type AnyLayer = Layer | LayerGroup;

package/lib/layer/shared/layers/any-layer.interface.d.ts

@@ -1,6 +1,8 @@
-import { ImageLayerOptions } from './image-layer.interface';
-import { LayerOptions } from './layer.interface';
-import { TileLayerOptions } from './tile-layer.interface';
-import { VectorLayerOptions } from './vector-layer.interface';
-import { VectorTileLayerOptions } from './vectortile-layer.interface';
-export type AnyLayerOptions = LayerOptions | ImageLayerOptions | TileLayerOptions | VectorLayerOptions | VectorTileLayerOptions;
+import { type ImageLayerOptions } from './image-layer.interface';
+import { type LayerGroupOptions } from './layer-group.interface';
+import { type LayerOptions } from './layer.interface';
+import { type TileLayerOptions } from './tile-layer.interface';
+import { type VectorLayerOptions } from './vector-layer.interface';
+import { type VectorTileLayerOptions } from './vectortile-layer.interface';
+export type AnyLayerOptions = AnyLayerItemOptions | LayerGroupOptions;
+export type AnyLayerItemOptions = LayerOptions | ImageLayerOptions | TileLayerOptions | VectorLayerOptions | VectorTileLayerOptions;

package/lib/layer/shared/layers/image-layer.d.ts

@@ -4,18 +4,21 @@ import olLayerImage from 'ol/layer/Image';
 import olSourceImage from 'ol/source/Image';
 import { ImageArcGISRestDataSource } from '../../../datasource/shared/datasources/imagearcgisrest-datasource';
 import { WMSDataSource } from '../../../datasource/shared/datasources/wms-datasource';
-import type { IgoMap } from '../../../map/shared/map';
+import { type MapBase } from '../../../map/shared/map.abstract';
 import { ImageLayerOptions } from './image-layer.interface';
 import { Layer } from './layer';
+import { LayerType } from './layer.interface';
 export declare class ImageLayer extends Layer {
     messageService: MessageService;
     authInterceptor?: AuthInterceptor;
+    type: LayerType;
     dataSource: WMSDataSource | ImageArcGISRestDataSource;
     options: ImageLayerOptions;
     ol: olLayerImage<olSourceImage>;
     private watcher;
     constructor(options: ImageLayerOptions, messageService: MessageService, authInterceptor?: AuthInterceptor);
     protected createOlLayer(): olLayerImage<olSourceImage>;
-    setMap(map: IgoMap | undefined): void;
+    init(map: MapBase | undefined): void;
+    remove(): void;
     private customLoader;
 }

package/lib/layer/shared/layers/image-layer.interface.d.ts

@@ -1,9 +1,6 @@
 import olLayerImage from 'ol/layer/Image';
 import olSourceImage from 'ol/source/Image';
-import { ImageArcGISRestDataSource } from '../../../datasource/shared/datasources/imagearcgisrest-datasource';
-import { ArcGISRestImageDataSourceOptions } from '../../../datasource/shared/datasources/imagearcgisrest-datasource.interface';
-import { WMSDataSource } from '../../../datasource/shared/datasources/wms-datasource';
-import { WMSDataSourceOptions } from '../../../datasource/shared/datasources/wms-datasource.interface';
+import { ArcGISRestImageDataSourceOptions, ImageArcGISRestDataSource, WMSDataSource, WMSDataSourceOptions } from '../../../datasource/shared/datasources';
 import { LayerOptions } from './layer.interface';
 export interface ImageLayerOptions extends LayerOptions {
     source?: WMSDataSource | ImageArcGISRestDataSource;

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

@@ -1,5 +1,8 @@
+export * from './linked';
 export * from './layer';
+export * from './layer-base';
 export * from './layer.interface';
+export * from './legend.interface';
 export * from './image-layer';
 export * from './image-layer.interface';
 export * from './tile-layer';
@@ -10,3 +13,5 @@ export * from './vectortile-layer';
 export * from './vectortile-layer.interface';
 export * from './any-layer';
 export * from './any-layer.interface';
+export * from './layer-group.interface';
+export * from './layer-group';

package/lib/layer/shared/layers/layer-base.d.ts

@@ -0,0 +1,75 @@
+import { SubjectStatus } from '@igo2/utils';
+import BaseLayer from 'ol/layer/Base';
+import { BehaviorSubject, Subject } from 'rxjs';
+import type { DataSource } from '../../../datasource/shared/datasources/datasource';
+import type { MapBase } from '../../../map/shared/map.abstract';
+import type { LayerOptions, LayerType } from './layer.interface';
+export type AnyLayerBase = LayerBase | LayerGroupBase;
+export declare abstract class LayerBase {
+    options: LayerOptions;
+    abstract type: LayerType;
+    abstract ol: BaseLayer;
+    abstract parent: LayerGroupBase;
+    protected abstract createOlLayer(): BaseLayer;
+    collapsed: boolean;
+    firstLoadComponent: boolean;
+    map: MapBase;
+    olLoadingProblem: boolean;
+    status$: Subject<SubjectStatus>;
+    dataSource: DataSource | undefined;
+    /**
+     * Define if a layer is generated by code OR defined by layer/context user layer.
+     * Useful for filtering layers list in mapOffline.directive or in the sharemap...
+     * return false by default.
+     */
+    get isIgoInternalLayer(): boolean;
+    get id(): string;
+    get parentId(): string;
+    get alias(): string;
+    get title(): string;
+    set title(title: string);
+    get zIndex(): number;
+    set zIndex(zIndex: number);
+    get baseLayer(): boolean;
+    set baseLayer(baseLayer: boolean);
+    get opacity(): number;
+    set opacity(opacity: number);
+    set isInResolutionsRange(value: boolean);
+    get isInResolutionsRange(): boolean;
+    readonly isInResolutionsRange$: BehaviorSubject<boolean>;
+    set maxResolution(value: number);
+    get maxResolution(): number;
+    set minResolution(value: number);
+    get minResolution(): number;
+    set visible(value: boolean);
+    get visible(): boolean;
+    private _visible$;
+    readonly visible$: import("rxjs").Observable<boolean>;
+    get displayed(): boolean;
+    set displayed(value: boolean);
+    private _displayed$;
+    displayed$: import("rxjs").Observable<boolean>;
+    private displayed$$;
+    get showInLayerList(): boolean;
+    get saveableOptions(): Partial<LayerOptions>;
+    constructor(options: LayerOptions);
+    afterCreated(): void;
+    init(map: MapBase): void;
+    add(parent?: LayerGroupBase): void;
+    private _add;
+    addParent(parent?: LayerGroupBase): void;
+    remove(): void;
+    private _remove;
+    reset(parent?: LayerGroupBase): void;
+    moveTo(parent?: LayerGroupBase): void;
+    clone(): LayerBase;
+    private initDisplayed$$;
+}
+export declare abstract class LayerGroupBase extends LayerBase {
+    type: LayerType;
+    children: LayerBase[];
+    abstract get descendants(): LayerBase[];
+    abstract addChild(layer: LayerBase): void;
+    abstract removeChild(layer: LayerBase): void;
+    abstract isDescendant(layer: LayerBase): boolean;
+}

package/lib/layer/shared/layers/layer-group.d.ts

@@ -0,0 +1,32 @@
+import { Group } from 'ol/layer.js';
+import { BehaviorSubject } from 'rxjs';
+import type { MapBase } from '../../../map/shared/map.abstract';
+import { type AnyLayer } from './any-layer';
+import { LayerGroupBase } from './layer-base';
+import { type LayerGroupOptions } from './layer-group.interface';
+export declare class LayerGroup extends LayerGroupBase {
+    children: AnyLayer[] | null;
+    options: LayerGroupOptions;
+    parent: LayerGroup;
+    ol: Group;
+    expanded: boolean;
+    private isInResolutionsRange$$;
+    readonly isInResolutionsRange$: BehaviorSubject<boolean>;
+    get saveableOptions(): Partial<LayerGroupOptions>;
+    get descendants(): AnyLayer[];
+    get descendantsLevel(): number;
+    constructor(children: AnyLayer[] | null, options: LayerGroupOptions);
+    init(map: MapBase): void;
+    add(parent?: LayerGroupBase): void;
+    addChild(...layers: AnyLayer[]): void;
+    remove(): void;
+    removeChild(layer: AnyLayer): void;
+    isDescendant(layer: AnyLayer): boolean;
+    private setChildrenObserver;
+    protected createOlLayer(): Group;
+    private hasChildren;
+    /** recursive */
+    private _getDescendants;
+    /** recursive */
+    private _getDescendantsLevel;
+}

package/lib/layer/shared/layers/layer-group.interface.d.ts

@@ -0,0 +1,8 @@
+import { AnyLayerOptions } from './any-layer.interface';
+import type { LayerOptionsBase } from './layer.interface';
+export interface LayerGroupOptions extends Omit<LayerOptionsBase, 'title'> {
+    type: 'group';
+    title: string;
+    expanded?: boolean;
+    children?: AnyLayerOptions[];
+}