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

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

@@ -3,22 +3,28 @@ import { AuthInterceptor } from '@igo2/auth';
 import { MessageService } from '@igo2/core/message';
 import { Observable } from 'rxjs';
 import { DataSourceService } from '../../datasource/shared/datasource.service';
+import { AnyDataSourceOptions, AnyDataSourceOptionsWithParams, ArcGISRestDataSourceOptions, WMTSDataSourceOptions } from '../../datasource/shared/datasources';
 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;
     private styleService;
     private dataSourceService;
-    private geoNetworkService;
     private messageService;
-    private layerDBService;
-    private authInterceptor;
-    constructor(http: HttpClient, styleService: StyleService, dataSourceService: DataSourceService, geoNetworkService: GeoNetworkService, messageService: MessageService, layerDBService: LayerDBService, authInterceptor: AuthInterceptor);
-    createLayer(layerOptions: AnyLayerOptions): Layer;
-    createAsyncLayer(_layerOptions: AnyLayerOptions, detailedContextUri?: string): Observable<Layer>;
+    private geoNetworkService?;
+    private layerDBService?;
+    private authInterceptor?;
+    unavailableLayers: AnyLayerItemOptions[];
+    constructor(http: HttpClient, styleService: StyleService, dataSourceService: DataSourceService, messageService: MessageService, geoNetworkService?: GeoNetworkService, layerDBService?: LayerDBService, authInterceptor?: AuthInterceptor);
+    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;
@@ -28,6 +34,9 @@ export declare class LayerService {
     private getStuff;
     private getAbsoluteUrl;
     createAsyncIdbLayers(contextUri?: string): Observable<Layer[]>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LayerService, [null, null, null, null, null, null, { optional: true; }]>;
+    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; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LayerService>;
 }

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 { 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[];
+}

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

@@ -1,65 +1,44 @@
 import { AuthInterceptor } from '@igo2/auth';
 import { MessageService } from '@igo2/core/message';
-import { SubjectStatus } from '@igo2/utils';
-import olLayer from 'ol/layer/Layer';
-import olSource from 'ol/source/Source';
-import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { DataSource } from '../../../datasource/shared/datasources/datasource';
-import { Legend } from '../../../datasource/shared/datasources/datasource.interface';
+import OlLayer from 'ol/layer/Layer';
+import { Source } from 'ol/source';
+import { BehaviorSubject } from 'rxjs';
+import { DataSource, Legend } from '../../../datasource/shared/datasources';
 import type { MapBase } from '../../../map/shared/map.abstract';
-import { GeoDBService } from '../../../offline/geoDB/geoDB.service';
-import { LayerDBService } from '../../../offline/layerDB/layerDB.service';
-import { LayerOptions } from './layer.interface';
-export declare abstract class Layer {
+import { LayerBase, LayerGroupBase } from './layer-base';
+import { type LayerGroup } from './layer-group';
+import { type LayerOptions } from './layer.interface';
+import { Linked } from './linked/linked-layer';
+export declare abstract class Layer extends LayerBase {
     options: LayerOptions;
     protected messageService?: MessageService;
     protected authInterceptor?: AuthInterceptor;
-    protected geoDBService?: GeoDBService;
-    layerDBService?: LayerDBService;
-    collapsed: boolean;
     dataSource: DataSource;
+    parent: LayerGroup;
+    ol: OlLayer<Source>;
+    hasBeenVisible$: BehaviorSubject<boolean>;
     legend: Legend[];
     legendCollapsed: boolean;
-    firstLoadComponent: boolean;
-    map: MapBase;
-    ol: olLayer<olSource>;
-    olLoadingProblem: boolean;
-    status$: Subject<SubjectStatus>;
-    hasBeenVisible$: BehaviorSubject<boolean>;
-    private hasBeenVisible$$;
+    link?: Linked;
+    linkMaster?: Linked;
     private resolution$$;
-    /**
-     * 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 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 visible(): boolean;
+    set visible(value: boolean);
     get maxResolution(): number;
-    set minResolution(value: number);
+    set maxResolution(value: number);
     get minResolution(): number;
-    set visible(value: boolean);
-    get visible(): boolean;
-    readonly visible$: BehaviorSubject<boolean>;
-    get displayed(): boolean;
-    readonly displayed$: Observable<boolean>;
-    get showInLayerList(): boolean;
-    constructor(options: LayerOptions, messageService?: MessageService, authInterceptor?: AuthInterceptor, geoDBService?: GeoDBService, layerDBService?: LayerDBService);
-    protected abstract createOlLayer(): olLayer<olSource>;
-    setMap(map: MapBase | undefined): void;
+    set minResolution(value: number);
+    get saveableOptions(): Partial<LayerOptions> | undefined;
+    constructor(options: LayerOptions, messageService?: MessageService, authInterceptor?: AuthInterceptor);
+    protected abstract createOlLayer(): OlLayer<Source>;
+    init(map: MapBase): void;
+    createLink(): void;
+    remove(): void;
+    add(parent?: LayerGroupBase): void;
+    moveTo(parent?: LayerGroup): void;
+    private createLinkWithParent;
+    private findParentByLinkId;
     private showMessage;
     private observeResolution;
     private unobserveResolution;

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

@@ -1,40 +1,46 @@
 import { Message } from '@igo2/core/message';
 import olLayer from 'ol/layer/Layer';
 import olSource from 'ol/source/Source';
-import { AnyDataSourceOptions } from '../../../datasource/shared/datasources/any-datasource.interface';
-import { DataSource } from '../../../datasource/shared/datasources/datasource';
-import { MapExtent } from '../../../map/shared/map.interface';
-import { LegendOptions } from './legend.interface';
-export interface LayerOptions {
+import type { AnyDataSourceOptions, DataSource } from '../../../datasource/shared/datasources';
+import type { MapExtent } from '../../../map/shared/map.interface';
+import type { LegendOptions } from './legend.interface';
+import type { LayersLink } from './linked/linked-layer.interface';
+export interface LayerOptions extends LayerOptionsBase {
     isIgoInternalLayer?: boolean;
     source?: DataSource;
     sourceOptions?: AnyDataSourceOptions;
-    title?: string;
-    id?: string;
     alias?: string;
     security?: LayerSecurityOptions;
     baseLayer?: boolean;
-    opacity?: number;
-    visible?: boolean;
-    extent?: MapExtent;
-    zIndex?: number;
     messages?: Message[];
-    minResolution?: number;
-    maxResolution?: number;
     minScaleDenom?: number;
     maxScaleDenom?: number;
-    showInLayerList?: boolean;
     removable?: boolean;
     workspace?: GeoWorkspaceOptions;
     legendOptions?: LegendOptions;
     ol?: olLayer<olSource>;
     tooltip?: TooltipContent;
     _internal?: Record<string, string>;
-    active?: boolean;
-    check?: boolean;
     linkedLayers?: LayersLink;
     showButtonZoomToExtent?: boolean;
 }
+export interface LayerOptionsBase {
+    id?: string | number;
+    /**
+     * An unique identifier calculated client side
+     * The name prop provide a way to have a unique identifier between all layers
+     **/
+    name?: string;
+    title?: string;
+    opacity?: number;
+    visible?: boolean;
+    extent?: MapExtent;
+    zIndex?: number;
+    minResolution?: number;
+    maxResolution?: number;
+    showInLayerList?: boolean;
+    parentId?: string;
+}
 export interface LayerSecurityOptions {
     profils?: string[];
 }
@@ -54,31 +60,6 @@ export interface GeoWorkspaceQueryOptions {
     mapQueryOnOpenTab?: boolean;
     tabQuery?: boolean;
 }
-export interface LayersLink {
-    linkId: string;
-    /** Default value is true */
-    showInMiniBaseMap?: boolean;
-    links?: LayersLinkProperties[];
-}
-export interface LayersLinkProperties {
-    linkedIds: string[];
-    syncedDelete: boolean;
-    properties: LinkedProperties[];
-}
-export declare enum LinkedProperties {
-    OPACITY = "opacity",
-    VISIBLE = "visible",
-    OGCFILTERS = "ogcFilters",
-    MINRESOLUTION = "minResolution",
-    MAXRESOLUTION = "maxResolution",
-    ZINDEX = "zIndex",
-    TIMEFILTER = "timeFilter"
-}
-export interface GroupLayers {
-    title: string;
-    layers?: LayerOptions;
-    collapsed?: boolean;
-}
 export interface TooltipContent {
     type?: TooltipType;
     text?: string;
@@ -88,3 +69,4 @@ export declare enum TooltipType {
     ABSTRACT = "abstract",
     CUSTOM = "custom"
 }
+export type LayerType = 'vector' | 'raster' | 'group';

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

@@ -0,0 +1,3 @@
+export * from './linked-layer';
+export * from './linked-layer.interface';
+export * from './linked-layer.utils';

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

@@ -0,0 +1,35 @@
+import type { LayerController } from '../../layer-controller';
+import type { Layer } from '../layer';
+import type { LayerGroup } from '../layer-group';
+import { LayersLinkProperties } from './linked-layer.interface';
+export declare class Linked {
+    layer: Layer;
+    private children;
+    private watcher;
+    private bidirectionnalChildren;
+    private childrenByProperty;
+    private disabledProperties;
+    constructor(layer: Layer);
+    get options(): import("@igo2/geo").LayerOptions;
+    get links(): LayersLinkProperties[];
+    get map(): import("@igo2/geo").MapBase;
+    init(): void;
+    private initZIndexLinkOptions;
+    destroy(): void;
+    add(layer: Layer): void;
+    hasSyncDeletion(layer: Layer): boolean;
+    remove(layer: Layer): void;
+    deleteChildren(controller: LayerController): void;
+    move(layer: Layer, parent?: LayerGroup): void;
+    private disable;
+    private enable;
+    private getByProperty;
+    private propertyIsDisabled;
+    private getLayerLinks;
+    private removeArrayItem;
+    private getLinkedLayersOnZindex;
+    private unwatch;
+    private handleChange;
+    private handleDisplayChange;
+    private findChildren;
+}

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

@@ -0,0 +1,32 @@
+import type { AnyLayer } from '../any-layer';
+import type { Layer } from '../layer';
+export type AnyPropertyOptions = ZindexPropertyOptions | BasePropertyOptions;
+export interface ZindexPropertyOptions extends BasePropertyOptions {
+    initialOrder: AnyLayer[];
+}
+interface BasePropertyOptions {
+    layers: Layer[];
+}
+export interface LayersLink {
+    linkId: string;
+    /** Default value is true */
+    showInMiniBaseMap?: boolean;
+    links?: LayersLinkProperties[];
+}
+export interface LayersLinkProperties {
+    bidirectionnal?: boolean;
+    linkedIds: string[];
+    syncedDelete: boolean;
+    properties: LinkedProperties[];
+}
+export declare enum LinkedProperties {
+    OPACITY = "opacity",
+    VISIBLE = "visible",
+    DISPLAYED = "displayed",
+    OGCFILTERS = "ogcFilters",
+    MINRESOLUTION = "minResolution",
+    MAXRESOLUTION = "maxResolution",
+    ZINDEX = "zIndex",
+    TIMEFILTER = "timeFilter"
+}
+export {};

package/lib/layer/shared/layers/linked/linked-layer.utils.d.ts

@@ -0,0 +1,9 @@
+import type { AnyLayer } from '../any-layer';
+import type { AnyLayerItemOptions, AnyLayerOptions } from '../any-layer.interface';
+import type { Layer } from '../layer';
+import type { LinkedProperties } from './linked-layer.interface';
+export declare function isLayerLinked(layer: AnyLayer): layer is Layer;
+export declare function isLinkMaster(layer: Layer): boolean;
+export declare function isLayerLinkedTogether(layerA: AnyLayer, layerB: AnyLayer, layers: AnyLayer[], property?: LinkedProperties): boolean;
+export declare function isLayerLinkedOptions(options: AnyLayerOptions): options is AnyLayerItemOptions;
+export declare function isBaseLayerLinked(layer: AnyLayer, allLayers: AnyLayer[]): layer is Layer;

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

@@ -8,12 +8,14 @@ import { TileArcGISRestDataSource } from '../../../datasource/shared/datasources
 import { TileDebugDataSource } from '../../../datasource/shared/datasources/tiledebug-datasource';
 import { WMTSDataSource } from '../../../datasource/shared/datasources/wmts-datasource';
 import { XYZDataSource } from '../../../datasource/shared/datasources/xyz-datasource';
-import { IgoMap } from '../../../map/shared/map';
+import type { MapBase } from '../../../map/shared/map.abstract';
 import { Layer } from './layer';
+import { LayerType } from './layer.interface';
 import { TileLayerOptions } from './tile-layer.interface';
 export declare class TileLayer extends Layer {
     messageService?: MessageService;
     authInterceptor?: AuthInterceptor;
+    type: LayerType;
     dataSource: OSMDataSource | WMTSDataSource | XYZDataSource | TileDebugDataSource | CartoDataSource | TileArcGISRestDataSource;
     options: TileLayerOptions;
     ol: olLayerTile<olSourceTile>;
@@ -27,5 +29,6 @@ export declare class TileLayer extends Layer {
      * @param url the url string or function to retrieve the data
      */
     customLoader(tile: any, url: string, interceptor: AuthInterceptor): void;
-    setMap(map: IgoMap | undefined): void;
+    init(map: MapBase | undefined): void;
+    remove(): void;
 }

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

@@ -11,18 +11,21 @@ import { FeatureDataSource } from '../../../datasource/shared/datasources/featur
 import { WebSocketDataSource } from '../../../datasource/shared/datasources/websocket-datasource';
 import { WFSDataSource } from '../../../datasource/shared/datasources/wfs-datasource';
 import { WFSDataSourceOptions } from '../../../datasource/shared/datasources/wfs-datasource.interface';
-import { IgoMap, MapExtent } from '../../../map/shared';
+import type { MapBase } from '../../../map/shared/map.abstract';
+import { MapExtent } from '../../../map/shared/map.interface';
 import { GeoDBService } from '../../../offline/geoDB/geoDB.service';
 import { LayerDBService } from '../../../offline/layerDB/layerDB.service';
 import { GeoNetworkService } from '../../../offline/shared/geo-network.service';
 import { Layer } from './layer';
-import { VectorLayerOptions } from './vector-layer.interface';
+import { LayerType } from './layer.interface';
+import type { VectorLayerOptions } from './vector-layer.interface';
 export declare class VectorLayer extends Layer {
     messageService?: MessageService;
     authInterceptor?: AuthInterceptor;
     private geoNetworkService?;
     geoDBService?: GeoDBService;
     layerDBService?: LayerDBService;
+    type: LayerType;
     private previousLoadExtent;
     private previousLoadResolution;
     private previousOgcFilters;
@@ -36,11 +39,12 @@ export declare class VectorLayer extends Layer {
     get exportable(): boolean;
     constructor(options: VectorLayerOptions, messageService?: MessageService, authInterceptor?: AuthInterceptor, geoNetworkService?: GeoNetworkService, geoDBService?: GeoDBService, layerDBService?: LayerDBService);
     protected createOlLayer(): olLayerVector<olSourceVector>;
-    removeLayerFromIDB(): void;
+    remove(): void;
+    private removeLayerFromIDB;
     private maintainOptionsInIdb;
     private maintainFeaturesInIdb;
     protected flash(feature: any): void;
-    setMap(map: IgoMap | undefined): void;
+    init(map: MapBase | undefined): void;
     setExtent(extent: MapExtent): void;
     onUnwatch(): void;
     stopAnimation(): void;
@@ -66,7 +70,6 @@ export declare class VectorLayer extends Layer {
      * Custom loader to get feature from a WFS datasource
      * @internal
      * @param vectorSource the vector source to be created
-     * @param interceptor the interceptor of the data
      * @param extent the extent of the requested data
      * @param dataProjection the projection of the retrieved data
      * @param featureProjection the projection of the created features
@@ -80,7 +83,6 @@ export declare class VectorLayer extends Layer {
      * @internal
      * @param vectorSource the vector source to be created
      * @param url the url string or function to retrieve the data
-     * @param interceptor the interceptor of the data
      * @param extent the extent of the requested data
      * @param resolution the current resolution
      * @param projection the projection to retrieve the data
@@ -91,7 +93,6 @@ export declare class VectorLayer extends Layer {
      * @internal
      * @param vectorSource the vector source to be created
      * @param layerID the url string or function to retrieve the data
-     * @param interceptor the interceptor of the data
      * @param extent the extent of the requested data
      * @param resolution the current resolution
      * @param projection the projection to retrieve the data

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

@@ -2,12 +2,14 @@ import { AuthInterceptor } from '@igo2/auth';
 import { MessageService } from '@igo2/core/message';
 import olLayerVectorTile from 'ol/layer/VectorTile';
 import { MVTDataSource } from '../../../datasource/shared/datasources/mvt-datasource';
-import { IgoMap } from '../../../map/shared/map';
+import type { MapBase } from '../../../map/shared/map.abstract';
 import { Layer } from './layer';
+import { LayerType } from './layer.interface';
 import { VectorTileLayerOptions } from './vectortile-layer.interface';
 export declare class VectorTileLayer extends Layer {
     messageService?: MessageService;
     authInterceptor?: AuthInterceptor;
+    type: LayerType;
     dataSource: MVTDataSource;
     options: VectorTileLayerOptions;
     ol: olLayerVectorTile;
@@ -24,5 +26,6 @@ export declare class VectorTileLayer extends Layer {
      * @param failure On failure event action to trigger TODO
      */
     customLoader(url: any, format: any, interceptor: any, success: any, failure?: any): (extent: any, resolution: any, projection: any) => void;
-    setMap(map: IgoMap | undefined): void;
+    init(map: MapBase | undefined): void;
+    remove(): void;
 }