diff --git a/demo/src/environments/environment.ts b/demo/src/environments/environment.ts
index a29fed3559..34173fd920 100644
--- a/demo/src/environments/environment.ts
+++ b/demo/src/environments/environment.ts
@@ -68,6 +68,75 @@ export const environment: Environment = {
           title: 'Controling tooltip format',
           url: 'https://geoegl.msp.gouv.qc.ca/apis/ws/igo_gouvouvert.fcgi',
           tooltipType: 'abstract' // or title
+        },
+        {
+          id: 'fusion_catalog',
+          title: '(composite catalog) fusion catalog',
+          composite: [
+            {
+              id: 'tq_swtq',
+              url: 'https://geoegl.msp.gouv.qc.ca/apis/ws/swtq'
+            },
+            {
+              id: 'rn_wmts',
+              url: 'https://servicesmatriciels.mern.gouv.qc.ca/erdas-iws/ogc/wmts/Cartes_Images',
+              type: 'wmts',
+              crossOrigin: true,
+              matrixSet: 'EPSG_3857',
+              version: '1.0.0'
+            }
+          ]
+        },
+        {
+          id: 'group_impose',
+          title: '(composite catalog) group imposed and unique layer title for same source',
+          composite: [
+            {
+              id: 'tq_swtq',
+              url: 'https://geoegl.msp.gouv.qc.ca/apis/ws/swtq',
+              regFilters: ['zpegt'],
+              groupImpose: {id: 'zpegt', title: 'zpegt'}
+            },
+            {
+              id: 'Gououvert',
+              url: 'https://geoegl.msp.gouv.qc.ca/apis/ws/igo_gouvouvert.fcgi',
+              regFilters: ['zpegt'],
+              groupImpose: {id: 'zpegt', title: 'zpegt'}
+            },
+            {
+              id: 'Gououvert',
+              url: 'https://geoegl.msp.gouv.qc.ca/apis/ws/igo_gouvouvert.fcgi',
+              regFilters: ['zpegt'],
+              groupImpose: {id: 'zpegt', title: 'zpegt'}
+            },
+            {
+              id: 'rn_wmts',
+              url: 'https://servicesmatriciels.mern.gouv.qc.ca/erdas-iws/ogc/wmts/Cartes_Images',
+              type: 'wmts',
+              crossOrigin: true,
+              matrixSet: 'EPSG_3857',
+              version: '1.0.0',
+              groupImpose: {id: 'cartetopo', title: 'Carte topo échelle 1/20 000'}
+            }
+          ]
+        },
+        {
+          id: 'tag_layernametitle',
+          title: '(composite catalog) tag source on same layer title',
+          composite: [
+            {
+              id: 'tq_swtq',
+              url: 'https://geoegl.msp.gouv.qc.ca/apis/ws/swtq',
+              regFilters: ['limtn_charg'],
+              groupImpose: {id: 'mix_swtq_gouv', title: 'mix same name layer'}
+            },
+            {
+              id: 'Gououvert',
+              url: 'https://geoegl.msp.gouv.qc.ca/apis/ws/igo_gouvouvert.fcgi',
+              regFilters: ['limtn_charg'],
+              groupImpose: {id: 'mix_swtq_gouv', title: 'mix same name layer'}
+            }
+          ]
         }
       ]
     },
diff --git a/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-group.component.html b/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-group.component.html
index a590e5c881..f45e44a6f9 100644
--- a/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-group.component.html
+++ b/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-group.component.html
@@ -38,7 +38,9 @@ <h4 class="igo-catalog-group-title" id="catalog-group-title" mat-line matTooltip
 
 <div #items>
   <ng-template ngFor let-item [ngForOf]="store.view.all$() | async">
-    <ng-container *ngIf="isGroup(item)"></ng-container>
+    <ng-container *ngIf="isGroup(item)">
+      <!-- todo: add display ans manage CatalogItemGroup -->
+    </ng-container>
     <ng-container *ngIf="isLayer(item)">
       <igo-catalog-browser-layer
         igoListItem
diff --git a/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-layer.component.html b/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-layer.component.html
index d40e846a9a..f19692120d 100644
--- a/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-layer.component.html
+++ b/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-layer.component.html
@@ -1,6 +1,7 @@
 <mat-list-item>
-  <mat-icon mat-list-avatar svgIcon="blank"></mat-icon>
+  <mat-icon *ngIf="haveGroup()" mat-list-avatar svgIcon="blank"></mat-icon>
   <h4 mat-line matTooltipShowDelay="500" [ngClass]="(catalogAllowLegend)?'igo-cataloglayer-title':''" (click)="askForLegend($event)" [matTooltip]="title">{{title}}</h4>
+
   <igo-metadata-button [layer]="layer"></igo-metadata-button>
 
   <button
diff --git a/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-layer.component.ts b/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-layer.component.ts
index 507ef50cc7..1f35ca3e8f 100644
--- a/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-layer.component.ts
+++ b/packages/geo/src/lib/catalog/catalog-browser/catalog-browser-layer.component.ts
@@ -151,6 +151,10 @@ export class CatalogBrowserLayerComponent implements OnInit {
     }
   }
 
+  haveGroup(): boolean {
+    return !(!this.layer.address || this.layer.address.split('.').length === 1);
+  }
+
   isInResolutionsRange(): boolean {
     const minResolution = this.layer.options.minResolution;
     const maxResolution = this.layer.options.maxResolution;
diff --git a/packages/geo/src/lib/catalog/catalog-library/catalog-library-item.component.ts b/packages/geo/src/lib/catalog/catalog-library/catalog-library-item.component.ts
index 19bb0d5183..50bd537aef 100644
--- a/packages/geo/src/lib/catalog/catalog-library/catalog-library-item.component.ts
+++ b/packages/geo/src/lib/catalog/catalog-library/catalog-library-item.component.ts
@@ -2,8 +2,7 @@ import { Component, Input, ChangeDetectionStrategy } from '@angular/core';
 
 import { getEntityTitle } from '@igo2/common';
 import { IgoMap } from '../../map';
-
-import { Catalog } from '../shared/catalog.interface';
+import { Catalog } from '../shared/catalog.abstract';
 
 /**
  * Catalog library item
diff --git a/packages/geo/src/lib/catalog/catalog-library/catalog-library.component.ts b/packages/geo/src/lib/catalog/catalog-library/catalog-library.component.ts
index 0a7d0cee3d..1a5bbf8854 100644
--- a/packages/geo/src/lib/catalog/catalog-library/catalog-library.component.ts
+++ b/packages/geo/src/lib/catalog/catalog-library/catalog-library.component.ts
@@ -9,7 +9,7 @@ import {
 
 import { EntityStore } from '@igo2/common';
 import { IgoMap } from '../../map';
-import { Catalog } from '../shared/catalog.interface';
+import { Catalog } from '../shared/catalog.abstract';
 
 /**
  * Component to browse a list of available catalogs
diff --git a/packages/geo/src/lib/catalog/shared/catalog.abstract.ts b/packages/geo/src/lib/catalog/shared/catalog.abstract.ts
new file mode 100644
index 0000000000..eff26dd1fa
--- /dev/null
+++ b/packages/geo/src/lib/catalog/shared/catalog.abstract.ts
@@ -0,0 +1,114 @@
+import { Observable } from 'rxjs';
+
+import { TooltipType } from '../../layer';
+import { TimeFilterOptions } from '../../filter';
+import { QueryFormat, QueryHtmlTarget  } from '../../query';
+
+import { ICatalog, ICompositeCatalog , CatalogItem, CatalogItemGroup } from './catalog.interface';
+import { CatalogService } from './catalog.service';
+import { TypeCatalog, TypeCatalogStrings } from './catalog.enum';
+
+export abstract class Catalog implements ICatalog {
+
+    // ICatalog -----------------------------
+    id: string;
+    title: string;
+    url: string;
+    items?: CatalogItem[];
+    type?: TypeCatalogStrings;
+    version?: string;
+    matrixSet?: string;
+    requestEncoding?: string;
+    regFilters?: string[];
+    groupImpose?: CatalogItemGroup;
+    timeFilter?: TimeFilterOptions;
+    queryFormat?: QueryFormat;
+    queryHtmlTarget?: QueryHtmlTarget;
+    queryParams?: { [key: string]: string; };
+    sourceOptions?: { [key: string]: any; };
+    count?: number;
+    tooltipType?: TooltipType.ABSTRACT | TooltipType.TITLE;
+    sortDirection?: 'asc' | 'desc';
+    setCrossOriginAnonymous?: boolean;
+    showLegend?: boolean;
+    // ICatalog -----------------------------
+
+    protected catalogService: CatalogService;
+
+    constructor(options: Catalog, service: CatalogService) {
+        Object.assign(this, options);
+        this.catalogService = service;
+    }
+
+    public abstract collectCatalogItems(): Observable<CatalogItem[]>;
+}
+
+class WMSCatalog extends Catalog {
+    constructor(options: Catalog, service: CatalogService) {
+        super(options, service);
+        const sType: string = TypeCatalog[TypeCatalog.wms];
+        this.type =  TypeCatalog[sType];
+    }
+
+    public collectCatalogItems(): Observable<CatalogItem[]> {
+        return this.catalogService.loadCatalogWMSLayerItems(this);
+    }
+}
+
+class WMTSCatalog extends Catalog {
+    constructor(options: Catalog, service: CatalogService) {
+        super(options, service);
+        const sType: string = TypeCatalog[TypeCatalog.wmts];
+        this.type =  TypeCatalog[sType];
+    }
+
+    public collectCatalogItems(): Observable<CatalogItem[]> {
+        return this.catalogService.loadCatalogWMTSLayerItems(this);
+    }
+}
+
+class BaselayersCatalog extends Catalog {
+    constructor(options: Catalog, service: CatalogService) {
+        super(options, service);
+        const sType: string = TypeCatalog[TypeCatalog.baselayers];
+        this.type =  TypeCatalog[sType];
+    }
+
+    public collectCatalogItems(): Observable<CatalogItemGroup[]> {
+        return this.catalogService.loadCatalogBaseLayerItems(this);
+    }
+}
+
+export class CompositeCatalog extends Catalog implements ICompositeCatalog {
+    composite: ICatalog[];
+
+    constructor(options: Catalog, service: CatalogService) {
+        super(options, service);
+        const sType: string = TypeCatalog[TypeCatalog.composite];
+        this.type =  TypeCatalog[sType];
+        this.url = null;
+    }
+
+    public collectCatalogItems(): Observable<CatalogItem[]> {
+        return this.catalogService.loadCatalogCompositeLayerItems(this);
+    }
+}
+
+export class CatalogFactory {
+
+    public static createInstanceCatalog(options: Catalog, service: CatalogService): Catalog {
+
+        let catalog: Catalog;
+        if (options.hasOwnProperty('composite')) {
+            catalog = new CompositeCatalog(options, service);
+        } else if (options.type === TypeCatalog[TypeCatalog.baselayers]) {
+            catalog = new BaselayersCatalog(options, service);
+        } else if (options.type === TypeCatalog[TypeCatalog.wmts]) {
+            catalog = new WMTSCatalog(options, service);
+        } else {
+            catalog = new WMSCatalog(options, service);
+        }
+
+        return catalog;
+    }
+}
diff --git a/packages/geo/src/lib/catalog/shared/catalog.enum.ts b/packages/geo/src/lib/catalog/shared/catalog.enum.ts
index 40c1e1656e..c31517feb6 100644
--- a/packages/geo/src/lib/catalog/shared/catalog.enum.ts
+++ b/packages/geo/src/lib/catalog/shared/catalog.enum.ts
@@ -2,3 +2,9 @@ export enum CatalogItemType {
   Layer = 'layer',
   Group = 'group'
 }
+
+export enum TypeCatalog {
+  wms, wmts, baselayers, composite
+}
+
+export type TypeCatalogStrings = keyof typeof TypeCatalog;
diff --git a/packages/geo/src/lib/catalog/shared/catalog.interface.ts b/packages/geo/src/lib/catalog/shared/catalog.interface.ts
index 7ea32542c6..d685940ee3 100644
--- a/packages/geo/src/lib/catalog/shared/catalog.interface.ts
+++ b/packages/geo/src/lib/catalog/shared/catalog.interface.ts
@@ -5,18 +5,19 @@ import { TooltipType } from '../../layer';
 import { TimeFilterOptions } from '../../filter';
 import { QueryFormat, QueryHtmlTarget } from '../../query';
 
-import { CatalogItemType } from './catalog.enum';
+import { CatalogItemType, TypeCatalogStrings } from './catalog.enum';
 
-export interface Catalog {
+export interface ICatalog {
   id: string;
   title: string;
   url: string;
   items?: CatalogItem[];
-  type?: string;
+  type?: TypeCatalogStrings;
   version?: string;
   matrixSet?: string;
   requestEncoding?: string;
   regFilters?: string[];
+  groupImpose?: CatalogItemGroup; // only use by ICompositeCatalog object (id and title)
   timeFilter?: TimeFilterOptions;
   queryFormat?: QueryFormat;
   queryHtmlTarget?: QueryHtmlTarget;
@@ -29,10 +30,15 @@ export interface Catalog {
   showLegend?: boolean;
 }
 
+export interface ICompositeCatalog extends ICatalog {
+  composite: ICatalog[];
+}
+
 export interface CatalogItem {
   id: string;
   title: string;
   type: CatalogItemType;
+  address?: string;
 }
 
 export interface CatalogItemLayer<L = MetadataLayerOptions>
@@ -50,6 +56,6 @@ export interface CatalogItemState extends EntityState {
 
 export interface CatalogServiceOptions {
   baseLayers?: boolean;
-  sources?: Catalog[];
+  sources?: (ICatalog|ICompositeCatalog)[];
   sourcesUrl?: string;
 }
diff --git a/packages/geo/src/lib/catalog/shared/catalog.service.ts b/packages/geo/src/lib/catalog/shared/catalog.service.ts
index 449f9a1896..7e8e314c8a 100644
--- a/packages/geo/src/lib/catalog/shared/catalog.service.ts
+++ b/packages/geo/src/lib/catalog/shared/catalog.service.ts
@@ -7,6 +7,7 @@ import { uuid } from '@igo2/utils';
 import { LanguageService, ConfigService } from '@igo2/core';
 import {
   CapabilitiesService,
+  TypeCapabilities,
   WMSDataSourceOptions,
   WMTSDataSourceOptions,
   WMSDataSourceOptionsParams
@@ -20,12 +21,16 @@ import {
 import { getResolutionFromScale } from '../../map';
 
 import {
-  Catalog,
   CatalogItem,
   CatalogItemLayer,
   CatalogItemGroup
 } from './catalog.interface';
-import { CatalogItemType } from './catalog.enum';
+import {
+  Catalog,
+  CatalogFactory,
+  CompositeCatalog
+} from './catalog.abstract';
+import { CatalogItemType, TypeCatalog } from './catalog.enum';
 import { QueryHtmlTarget, QueryFormat } from '../../query';
 import { generateIdFromSourceOptions } from '../../utils';
 
@@ -96,15 +101,12 @@ export class CatalogService {
   }
 
   loadCatalogItems(catalog: Catalog): Observable<CatalogItem[]> {
-    if (catalog.type === 'baselayers') {
-      return this.loadCatalogBaseLayerItems(catalog);
-    } else if (catalog.type === 'wmts') {
-      return this.loadCatalogWMTSLayerItems(catalog);
-    }
-    return this.loadCatalogWMSLayerItems(catalog);
+    let newCatalog: Catalog;
+    newCatalog = CatalogFactory.createInstanceCatalog(catalog, this);
+    return newCatalog.collectCatalogItems();
   }
 
-  private loadCatalogBaseLayerItems(
+  loadCatalogBaseLayerItems(
     catalog: Catalog
   ): Observable<CatalogItemGroup[]> {
     return this.getCatalogBaseLayersOptions(catalog).pipe(
@@ -135,10 +137,10 @@ export class CatalogService {
     return this.http.get<LayerOptions[]>(catalog.url);
   }
 
-  private loadCatalogWMSLayerItems(
+  loadCatalogWMSLayerItems(
     catalog: Catalog
   ): Observable<CatalogItem[]> {
-    return this.getCatalogWMSCapabilities(catalog).pipe(
+    return this.getCatalogCapabilities(catalog).pipe(
       map((capabilities: any) => {
         const items = [];
         this.includeRecursiveItems(
@@ -151,34 +153,246 @@ export class CatalogService {
     );
   }
 
-  private loadCatalogWMTSLayerItems(
+  loadCatalogWMTSLayerItems(
     catalog: Catalog
   ): Observable<CatalogItem[]> {
-    return this.getCatalogWMTSCapabilities(catalog).pipe(
+    return this.getCatalogCapabilities(catalog).pipe(
       map((capabilities: any) => this.getWMTSItems(catalog, capabilities))
     );
   }
 
-  private getCatalogWMSCapabilities(catalog: Catalog): Observable<any> {
-    return this.capabilitiesService.getCapabilities(
-      'wms',
-      catalog.url,
-      catalog.version
+  loadCatalogCompositeLayerItems(
+    catalog: Catalog
+  ): Observable<CatalogItem[]> {
+
+    const compositeCatalog = (catalog as CompositeCatalog).composite;
+
+    const catalogsFromInstance = [] as Catalog[];
+    compositeCatalog.map((component: Catalog) => catalogsFromInstance.push(CatalogFactory.createInstanceCatalog(component, this)));
+
+    // get CatalogItems for each original Catalog-----------------------------------------------------
+    const request1$ = [];
+    catalogsFromInstance.map((component: Catalog) => request1$.push(component.collectCatalogItems()));
+
+    // integrate imposed group -----------------------------------------------------
+    let request2$ = [];
+
+    function flatDeepLayer(arr) {
+      return arr.reduce((acc, val) => acc.concat(val.type === CatalogItemType.Group ? flatDeepLayer(val.items) : val), []);
+    }
+
+    if (Object.keys(compositeCatalog).find(k => compositeCatalog[k].groupImpose)) {
+      const pushImposeGroup = (item, index) => {
+        const c = catalogsFromInstance[index];
+        const outGroupImpose = Object.assign({}, c.groupImpose);
+        outGroupImpose.address = c.id;
+        outGroupImpose.type = CatalogItemType.Group;
+        outGroupImpose.items = [];
+
+        const flatLayer = flatDeepLayer(item);
+        flatLayer.map((v) => v.address = `${outGroupImpose.address}.${outGroupImpose.id}`);
+        outGroupImpose.items = flatLayer;
+
+        return outGroupImpose;
+      };
+
+      request2$ = request1$.map((obs, idx) => obs.pipe(
+        map((items) => compositeCatalog[idx].groupImpose ? pushImposeGroup(items, idx) : items )
+      ));
+    } else {
+      request2$ = request1$;
+    }
+
+    // concat Group -----------------------------------------------------
+    const request3$ = zip(...request2$)
+      .pipe(
+          map((output: CatalogItem[]) => [].concat(...output) // [].concat.apply([], result1
+      ));
+
+    // merge Group (first level only) -----------------------------------------------------
+    const groupByGroupId = (data, keyFn) => data.reduce((acc, group) => {
+      const groupId = keyFn(group);
+      const ind = acc.find((x) => x.id === groupId);
+
+      if (!ind) {
+        acc[acc.length] = group;
+      } else {
+        const ix = acc.indexOf(ind);
+        if (acc[ix].address.split('|').indexOf(group.address) === -1) {
+          acc[ix].address = `${acc[ix].address}|${group.address}`;
+        }
+        acc[ix].items.push(...group.items);
+      }
+      return acc;
+    }, []);
+
+    // merge Layer for each Level (catalog, group(recursive))
+    const recursiveGroupByLayerAddress = (items, keyFn) => items.reduce((acc, item, idx, arr) => {
+
+      const layerTitle = keyFn(item);
+      const outItem = Object.assign({}, item);
+
+      if (item.type === CatalogItemType.Layer) {
+        // same title, same address => result: only one item is keep
+
+        // same title, address diff
+        const indicesMatchTitle = [];
+        const diffAddress = arr.filter((x, i) => {
+          let bInd = false;
+          if (x.title === layerTitle && x.type === CatalogItemType.Layer) {
+            if (i !== idx && x.address !== item.address) {
+              bInd = true;
+            }
+            indicesMatchTitle.push(i);
+          }
+          return bInd;
+        }); // $& i !== idx
+
+        if (diffAddress.length > 0) {
+          const nPosition = indicesMatchTitle.findIndex(x => x === idx) + 1;
+          outItem.title = `${item.title} (${nPosition})`; // source: ${item.address.split('.')[0]}
+        }
+
+        const exist = acc.find((x) => x.title === outItem.title && x.type === CatalogItemType.Layer);
+        if (!exist) {
+          acc[acc.length] = outItem;
+        }
+      } else if (item.type === CatalogItemType.Group) {
+          outItem.items = recursiveGroupByLayerAddress(item.items,  layer => layer.title);
+          acc[acc.length] = outItem;
+      }
+
+      return acc;
+    }, []);
+
+    const request4$ = request3$.pipe(
+      map(output => groupByGroupId(output, group => group.id)),
+      map((output) => [].concat(...output)),
+      map(data => recursiveGroupByLayerAddress(data,  layer => layer.title))
     );
+
+    return request4$;
   }
 
-  private getCatalogWMTSCapabilities(catalog: Catalog): Observable<any> {
+  private getCatalogCapabilities(catalog: Catalog): Observable<any> {
+    const sType: string = TypeCatalog[catalog.type as string];
     return this.capabilitiesService.getCapabilities(
-      'wmts',
+      TypeCapabilities[sType],
       catalog.url,
       catalog.version
     );
   }
 
+  private prepareCatalogItemLayer(layer, idParent, layersQueryFormat, catalog,
+                                  catalogQueryParams, catalogSourceOptions, catalogTooltipType) {
+    const configuredQueryFormat = this.retriveLayerInfoFormat(
+      layer.Name,
+      layersQueryFormat
+    );
+
+    const metadata = layer.DataURL ? layer.DataURL[0] : undefined;
+    const abstract = layer.Abstract ? layer.Abstract : undefined;
+    const keywordList = layer.KeywordList
+      ? layer.KeywordList
+      : undefined;
+    const timeFilter = this.capabilitiesService.getTimeFilter(layer);
+    const timeFilterable =
+      timeFilter && Object.keys(timeFilter).length > 0 ? true : false;
+    const legendOptions = layer.Style
+      ? this.capabilitiesService.getStyle(layer.Style)
+      : undefined;
+
+    const params = Object.assign({}, catalogQueryParams, {
+      LAYERS: layer.Name,
+      FEATURE_COUNT: catalog.count,
+      VERSION: catalog.version || '1.3.0'
+    } as WMSDataSourceOptionsParams
+    );
+    const baseSourceOptions = {
+      type: 'wms',
+      url: catalog.url,
+      crossOrigin: catalog.setCrossOriginAnonymous
+        ? 'anonymous'
+        : undefined,
+      timeFilter: { ...timeFilter, ...catalog.timeFilter },
+      timeFilterable: timeFilterable ? true : false,
+      queryable: layer.queryable,
+      queryFormat: configuredQueryFormat,
+      queryHtmlTarget: catalog.queryHtmlTarget || QueryHtmlTarget.IFRAME
+    };
+    const sourceOptions = Object.assign(
+      {},
+      baseSourceOptions,
+      catalogSourceOptions,
+      { params }
+    ) as WMSDataSourceOptions;
+
+    const layerPrepare = {
+      id: generateIdFromSourceOptions(sourceOptions),
+      type: CatalogItemType.Layer,
+      title: layer.Title,
+      address: idParent,
+      options: {
+        title: layer.Title,
+        maxResolution:
+          getResolutionFromScale(layer.MaxScaleDenominator) || Infinity,
+        minResolution:
+          getResolutionFromScale(layer.MinScaleDenominator) || 0,
+        metadata: {
+          url: metadata ? metadata.OnlineResource : undefined,
+          extern: metadata ? true : undefined,
+          abstract,
+          keywordList
+        },
+        legendOptions,
+        tooltip: { type: catalogTooltipType } as TooltipContent,
+        sourceOptions
+      }
+    };
+
+    return layerPrepare;
+  }
+
+  private prepareCatalogItemGroup(itemListIn, regexes, idGroup, layersQueryFormat, catalog,
+                                  catalogQueryParams, catalogSourceOptions, catalogTooltipType) {
+     const groupPrepare = {
+        id: idGroup,
+        type: CatalogItemType.Group,
+        title: itemListIn.Title,
+        address: catalog.id,
+        items: itemListIn.Layer.reduce(
+          (items: CatalogItem[], layer: any) => {
+
+            if (layer.Layer !== undefined) {
+              // recursive, check next level
+              const idGroupItemNextLevel = idGroup + `.group.${layer.Name || layer.Layer[0].Name}`;
+              const groupItem: CatalogItemGroup = this.prepareCatalogItemGroup(layer, regexes, idGroupItemNextLevel,
+                layersQueryFormat, catalog, catalogQueryParams, catalogSourceOptions, catalogTooltipType);
+
+              items.push(groupItem);
+            } else {
+              if (this.testLayerRegexes(layer.Name, regexes) === false) {
+                return items;
+              }
+
+              const layerItem: CatalogItemLayer<ImageLayerOptions> = this.prepareCatalogItemLayer(layer, idGroup, layersQueryFormat,
+                catalog, catalogQueryParams, catalogSourceOptions, catalogTooltipType);
+
+              items.push(layerItem);
+            }
+            return items;
+          },
+          []
+        )
+      };
+     return groupPrepare;
+  }
+
   private includeRecursiveItems(
     catalog: Catalog,
-    layerList: any,
-    items: CatalogItem[]
+    itemListIn: any,
+    itemsPrepare: CatalogItem[],
+    loopLevel: number = 0,
   ) {
     // Dig all levels until last level (layer object are not defined on last level)
     const regexes = (catalog.regFilters || []).map(
@@ -187,105 +401,41 @@ export class CatalogService {
     const catalogQueryParams = catalog.queryParams || {};
     const catalogSourceOptions = catalog.sourceOptions || {};
 
-    if (!layerList.Layer) {
+    if (!itemListIn.Layer) {
       return;
     }
 
-    for (const group of layerList.Layer) {
-      if (group.Layer !== undefined) {
+    for (const item of itemListIn.Layer) {
+      if (item.Layer !== undefined) {
         // recursive, check next level
-        this.includeRecursiveItems(catalog, group, items);
+        this.includeRecursiveItems(catalog, item, itemsPrepare, loopLevel + 1);
         continue;
       }
+
       const catalogTooltipType = this.retrieveTooltipType(catalog);
       const layersQueryFormat = this.findCatalogInfoFormat(catalog);
-      // TODO: Slice that into multiple methods
-      // Define object of group layer
-      const groupItem = {
-        id: `catalog.group.${layerList.Name || group.Name}`,
-        type: CatalogItemType.Group,
-        title: layerList.Title,
-        items: layerList.Layer.reduce(
-          (layers: CatalogItemLayer<ImageLayerOptions>[], layer: any) => {
-            const configuredQueryFormat = this.retriveLayerInfoFormat(
-              layer.Name,
-              layersQueryFormat
-            );
-
-            if (this.testLayerRegexes(layer.Name, regexes) === false) {
-              return layers;
-            }
 
-            const metadata = layer.DataURL ? layer.DataURL[0] : undefined;
-            const abstract = layer.Abstract ? layer.Abstract : undefined;
-            const keywordList = layer.KeywordList
-              ? layer.KeywordList
-              : undefined;
-            const timeFilter = this.capabilitiesService.getTimeFilter(layer);
-            const timeFilterable =
-              timeFilter && Object.keys(timeFilter).length > 0 ? true : false;
-            const legendOptions = layer.Style
-              ? this.capabilitiesService.getStyle(layer.Style)
-              : undefined;
-
-            const params = Object.assign({}, catalogQueryParams, {
-              LAYERS: layer.Name,
-              FEATURE_COUNT: catalog.count,
-              VERSION: catalog.version || '1.3.0'
-            } as WMSDataSourceOptionsParams
-            );
-            const baseSourceOptions = {
-              type: 'wms',
-              url: catalog.url,
-              crossOrigin: catalog.setCrossOriginAnonymous
-                ? 'anonymous'
-                : undefined,
-              timeFilter: { ...timeFilter, ...catalog.timeFilter },
-              timeFilterable: timeFilterable ? true : false,
-              queryable: layer.queryable,
-              queryFormat: configuredQueryFormat,
-              queryHtmlTarget: catalog.queryHtmlTarget || QueryHtmlTarget.IFRAME
-            };
-            const sourceOptions = Object.assign(
-              {},
-              baseSourceOptions,
-              catalogSourceOptions,
-              { params }
-            ) as WMSDataSourceOptions;
-
-            layers.push({
-              id: generateIdFromSourceOptions(sourceOptions),
-              type: CatalogItemType.Layer,
-              title: layer.Title,
-              options: {
-                title: layer.Title,
-                maxResolution:
-                  getResolutionFromScale(layer.MaxScaleDenominator) || Infinity,
-                minResolution:
-                  getResolutionFromScale(layer.MinScaleDenominator) || 0,
-                metadata: {
-                  url: metadata ? metadata.OnlineResource : undefined,
-                  extern: metadata ? true : undefined,
-                  abstract,
-                  keywordList
-                },
-                legendOptions,
-                tooltip: { type: catalogTooltipType } as TooltipContent,
-                sourceOptions
-              }
-            });
-            return layers;
-          },
-          []
-        )
-      };
+      // group(with layers) and layer(without group) level 1
+      if (loopLevel !== 0) {
 
-      if (groupItem.items.length !== 0) {
-        items.push(groupItem);
-      }
+        // TODO: Slice that into multiple methods
+        // Define object of group layer
+        const idGroupItem = `catalog.group.${itemListIn.Name || item.Name}`;
+        const groupItem = this.prepareCatalogItemGroup(itemListIn, regexes, idGroupItem, layersQueryFormat, catalog,
+          catalogQueryParams, catalogSourceOptions, catalogTooltipType);
 
-      // Break the group (don't add a group of layer for each of their layer!)
-      break;
+        if (groupItem.items.length !== 0) {
+          itemsPrepare.push(groupItem);
+        }
+
+        // Break the group (don't add a group of layer for each of their layer!)
+        break;
+      } else {
+        // layer without group
+        const layerItem = this.prepareCatalogItemLayer(item, catalog.id, layersQueryFormat,
+          catalog, catalogQueryParams, catalogSourceOptions, catalogTooltipType);
+        itemsPrepare.push(layerItem);
+      }
     }
   }
 
@@ -331,6 +481,7 @@ export class CatalogService {
           id: generateIdFromSourceOptions(sourceOptions),
           type: CatalogItemType.Layer,
           title: layer.Title,
+          address: catalog.id,
           options: {
             title: layer.Title,
             sourceOptions
diff --git a/packages/geo/src/lib/catalog/shared/index.ts b/packages/geo/src/lib/catalog/shared/index.ts
index b17edaf3d4..2d25a712b7 100644
--- a/packages/geo/src/lib/catalog/shared/index.ts
+++ b/packages/geo/src/lib/catalog/shared/index.ts
@@ -1,3 +1,4 @@
 export * from './catalog.service';
 export * from './catalog.interface';
 export * from './catalog.enum';
+export * from './catalog.abstract';
diff --git a/packages/geo/src/lib/datasource/shared/capabilities.service.ts b/packages/geo/src/lib/datasource/shared/capabilities.service.ts
index e5d4a46a14..95e0699347 100644
--- a/packages/geo/src/lib/datasource/shared/capabilities.service.ts
+++ b/packages/geo/src/lib/datasource/shared/capabilities.service.ts
@@ -28,6 +28,12 @@ import {
   TimeFilterStyle
 } from '../../filter/shared/time-filter.enum';
 
+export enum TypeCapabilities {
+  wms = 'wms', wmts = 'wmts'
+}
+
+export type TypeCapabilitiesStrings = keyof typeof TypeCapabilities;
+
 @Injectable({
   providedIn: 'root'
 })
@@ -131,7 +137,7 @@ export class CapabilitiesService {
     maxCacheCount: 20
   })
   getCapabilities(
-    service: 'wms' | 'wmts',
+    service: TypeCapabilitiesStrings,
     baseUrl: string,
     version?: string
   ): Observable<any> {