@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/search/shared/sources/icherche.providers.mjs

@@ -0,0 +1,87 @@
+import { HttpClient } from '@angular/common/http';
+import { Injector } from '@angular/core';
+import { ConfigService } from '@igo2/core/config';
+import { LanguageService } from '@igo2/core/language';
+import { StorageService } from '@igo2/core/storage';
+import { IChercheReverseSearchSource, IChercheSearchResultFormatter, IChercheSearchSource } from './icherche';
+import { SearchSource } from './source';
+import { SearchSourceKind } from './source.interfaces';
+/**
+ * ICherche search result formatter factory
+ * @ignore
+ */
+export function defaultIChercheSearchResultFormatterFactory(languageService) {
+    return new IChercheSearchResultFormatter(languageService);
+}
+/**
+ * Function that returns a provider for the ICherche search result formatter
+ */
+export function provideDefaultIChercheSearchResultFormatter() {
+    return {
+        provide: IChercheSearchResultFormatter,
+        useFactory: defaultIChercheSearchResultFormatterFactory,
+        deps: [LanguageService]
+    };
+}
+/**
+ * ICherche search source factory
+ * @ignore
+ */
+export function ichercheSearchSourceFactory(http, languageService, storageService, config, formatter, injector) {
+    return new IChercheSearchSource(http, languageService, storageService, config.getConfig(`searchSources.${IChercheSearchSource.id}`), formatter, injector);
+}
+/**
+ * Function that returns a provider for the ICherche search source
+ */
+export function provideIChercheSearchSource() {
+    return {
+        provide: SearchSource,
+        useFactory: ichercheSearchSourceFactory,
+        multi: true,
+        deps: [
+            HttpClient,
+            LanguageService,
+            StorageService,
+            ConfigService,
+            IChercheSearchResultFormatter,
+            Injector
+        ]
+    };
+}
+export function withIChercheSource() {
+    return {
+        kind: SearchSourceKind.ICherche,
+        providers: [
+            provideIChercheSearchSource(),
+            provideDefaultIChercheSearchResultFormatter()
+        ]
+    };
+}
+/**
+ * IChercheReverse search source factory
+ * @ignore
+ */
+export function ichercheReverseSearchSourceFactory(http, languageService, storageService, config, injector) {
+    return new IChercheReverseSearchSource(http, languageService, storageService, config.getConfig(`searchSources.${IChercheReverseSearchSource.id}`), injector);
+}
+/**
+ * Function that returns a provider for the IChercheReverse search source
+ */
+export function provideIChercheReverseSearchSource() {
+    return {
+        provide: SearchSource,
+        useFactory: ichercheReverseSearchSourceFactory,
+        multi: true,
+        deps: [HttpClient, LanguageService, StorageService, ConfigService, Injector]
+    };
+}
+export function withIChercheReverseSource() {
+    return {
+        kind: SearchSourceKind.IChercheReverse,
+        providers: [
+            provideIChercheReverseSearchSource(),
+            provideDefaultIChercheSearchResultFormatter()
+        ]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/shared/sources/ilayer.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/shared/sources/ilayer.mjs

@@ -0,0 +1,339 @@
+import { __decorate, __metadata } from "tslib";
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { LanguageService } from '@igo2/core/language';
+import { StorageService } from '@igo2/core/storage';
+import { ObjectUtils, customCacheHasher } from '@igo2/utils';
+import { BehaviorSubject, Observable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Cacheable } from 'ts-cacheable';
+import { LAYER } from '../../../layer/shared/layer.enums';
+import { getResolutionFromScale } from '../../../map/shared/map.utils';
+import { computeTermSimilarity } from '../search.utils';
+import { QueryFormat } from './../../../query/shared/query.enums';
+import { SearchSource } from './source';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core/language";
+import * as i2 from "@angular/common/http";
+import * as i3 from "@igo2/core/storage";
+export class ILayerSearchResultFormatter {
+    languageService;
+    constructor(languageService) {
+        this.languageService = languageService;
+    }
+    formatResult(data) {
+        const allowedKey = [
+            'title',
+            'abstract',
+            'groupTitle',
+            'metadataUrl',
+            'downloadUrl',
+            'urlInfo',
+            'name'
+        ];
+        const property = Object.entries(data.properties)
+            .filter(([key]) => allowedKey.indexOf(key) !== -1)
+            .reduce((out, entries) => {
+            const [key, value] = entries;
+            let newKey;
+            try {
+                newKey = this.languageService.translate.instant('igo.geo.search.ilayer.properties.' + key);
+            }
+            catch {
+                newKey = key;
+            }
+            out[newKey] = value ? value : '';
+            return out;
+        }, {});
+        const dataR = Object.assign({}, data);
+        dataR.properties = property;
+        return dataR;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ILayerSearchResultFormatter, deps: [{ token: i1.LanguageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ILayerSearchResultFormatter });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ILayerSearchResultFormatter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.LanguageService }] });
+/**
+ * ILayer search source
+ */
+export class ILayerSearchSource extends SearchSource {
+    http;
+    languageService;
+    formatter;
+    static id = 'ilayer';
+    static type = LAYER;
+    title$ = new BehaviorSubject('');
+    get title() {
+        return this.title$.getValue();
+    }
+    constructor(http, languageService, storageService, options, formatter) {
+        super(options, storageService);
+        this.http = http;
+        this.languageService = languageService;
+        this.formatter = formatter;
+        this.languageService.language$.subscribe(() => {
+            this.title$.next(this.languageService.translate.instant(this.options.title));
+        });
+    }
+    getId() {
+        return ILayerSearchSource.id;
+    }
+    getType() {
+        return ILayerSearchSource.type;
+    }
+    getDefaultOptions() {
+        const limit = this.options.params && this.options.params.limit
+            ? Number(this.options.params.limit)
+            : undefined;
+        const ecmax = this.options.params && this.options.params.ecmax
+            ? Number(this.options.params.ecmax)
+            : undefined;
+        const showAdvancedParams = this.options.showAdvancedSettings;
+        return {
+            title: 'igo.geo.search.ilayer.name',
+            searchUrl: 'https://geoegl.msp.gouv.qc.ca/apis/layers/search',
+            settings: [
+                {
+                    type: 'checkbox',
+                    title: 'results type',
+                    name: 'type',
+                    values: [
+                        {
+                            title: 'igo.geo.search.ilayer.type.layer',
+                            value: 'layer',
+                            enabled: true,
+                            hashtags: ['layer', 'layers', 'couche', 'couches']
+                        },
+                        {
+                            title: 'igo.geo.search.ilayer.type.groupLayer',
+                            value: 'group',
+                            enabled: false,
+                            hashtags: ['gr-layer', 'gr-layers', 'gr-couche', 'gr-couches']
+                        }
+                    ]
+                },
+                {
+                    type: 'radiobutton',
+                    title: 'results limit',
+                    name: 'limit',
+                    values: [
+                        {
+                            title: '1',
+                            value: 1,
+                            enabled: limit === 1
+                        },
+                        {
+                            title: '5',
+                            value: 5,
+                            enabled: limit === 5 || !limit
+                        },
+                        {
+                            title: '10',
+                            value: 10,
+                            enabled: limit === 10
+                        },
+                        {
+                            title: '25',
+                            value: 25,
+                            enabled: limit === 25
+                        },
+                        {
+                            title: '50',
+                            value: 50,
+                            enabled: limit === 50
+                        }
+                    ]
+                },
+                showAdvancedParams &&
+                    {
+                        type: 'radiobutton',
+                        title: 'ecmax',
+                        name: 'ecmax',
+                        values: [
+                            {
+                                title: '10 %',
+                                value: 10,
+                                enabled: ecmax === 10
+                            },
+                            {
+                                title: '30 %',
+                                value: 30,
+                                enabled: ecmax === 30
+                            },
+                            {
+                                title: '50 %',
+                                value: 50,
+                                enabled: ecmax === 50 || !ecmax
+                            },
+                            {
+                                title: '75 %',
+                                value: 75,
+                                enabled: ecmax === 75
+                            },
+                            {
+                                title: '100 %',
+                                value: 100,
+                                enabled: ecmax === 100
+                            }
+                        ]
+                    }
+            ].filter(Boolean)
+        };
+    }
+    /**
+     * Search a layer by name or keyword
+     * @param term Layer name or keyword
+     * @returns Observable of <SearchResult<LayerOptions>[]
+     */
+    search(term, options) {
+        const params = this.computeSearchRequestParams(term, options || {});
+        if (!params.get('q') || !params.get('type')) {
+            return of([]);
+        }
+        this.options.params.page = params.get('page') || '1';
+        return this.getSearch(term, params);
+    }
+    getSearch(term, params) {
+        return this.http
+            .get(this.searchUrl, { params })
+            .pipe(map((response) => this.extractResults(response, term)));
+    }
+    computeSearchRequestParams(term, options) {
+        return new HttpParams({
+            fromObject: ObjectUtils.removeUndefined(Object.assign({
+                q: this.computeTerm(term)
+            }, this.params, this.computeOptionsParam(term, options || {}).params, {
+                page: options.page
+            }))
+        });
+    }
+    /**
+     * Remove hashtag from query
+     * @param term Query with hashtag
+     */
+    computeTerm(term) {
+        return term.replace(/(#[^\s]*)/g, '').replace(/[^\wÀ-ÿ !\-\(\),'#]+/g, '');
+    }
+    /**
+     * Add hashtag to param if valid
+     * @param term Query with hashtag
+     * @param options TextSearchOptions
+     */
+    computeOptionsParam(term, options) {
+        const hashtags = super.getHashtagsValid(term, 'type');
+        if (hashtags) {
+            options.params = Object.assign(options.params || {}, {
+                type: hashtags.join(',')
+            });
+        }
+        return options;
+    }
+    extractResults(response, term) {
+        return response.items.map((data) => this.dataToResult(data, term, response));
+    }
+    dataToResult(data, term, response) {
+        const layerOptions = this.computeLayerOptions(data);
+        const titleHtml = data.highlight.title || data.properties.title;
+        const groupTitle = data.highlight.groupTitle || data.properties.groupTitle;
+        const subtitleHtml = groupTitle
+            ? ' <small style="color: #6f6969"> ' + groupTitle + '</small>'
+            : '';
+        return {
+            source: this,
+            meta: {
+                dataType: LAYER,
+                id: [this.getId(), data.properties.id].join('.'),
+                title: data.properties.title,
+                titleHtml: titleHtml + subtitleHtml,
+                icon: data.properties.type === 'Layer' ? 'layers' : 'map',
+                score: data.score ||
+                    computeTermSimilarity(term.trim(), data.properties.name),
+                nextPage: response.items.length % +this.options.params.limit === 0 &&
+                    +this.options.params.page < 10
+            },
+            data: layerOptions
+        };
+    }
+    computeLayerOptions(data) {
+        const url = data.properties.url;
+        const queryParams = this.extractQueryParamsFromSourceUrl(url);
+        return ObjectUtils.removeUndefined({
+            sourceOptions: {
+                id: data.properties.id,
+                type: data.properties.format,
+                url,
+                queryFormat: queryParams.queryFormat,
+                queryHtmlTarget: queryParams.queryHtmlTarget,
+                params: data.properties.format === 'wms'
+                    ? { LAYERS: data.properties.name }
+                    : undefined,
+                layer: data.properties.format === 'wms' ? undefined : data.properties.name,
+                optionsFromCapabilities: true,
+                crossOrigin: 'anonymous'
+            },
+            title: data.properties.title,
+            maxResolution: getResolutionFromScale(Number(data.properties.maxScaleDenom)),
+            minResolution: getResolutionFromScale(Number(data.properties.minScaleDenom)),
+            metadata: {
+                url: data.properties.metadataUrl,
+                extern: data.properties.metadataUrl ? true : undefined,
+                abstract: data.properties.abstract || undefined
+            },
+            properties: this.formatter.formatResult(data).properties
+        });
+    }
+    extractQueryParamsFromSourceUrl(url) {
+        let queryFormat;
+        let queryHtmlTarget;
+        const formatOpt = this.options.queryFormat;
+        if (formatOpt) {
+            for (const key of Object.keys(formatOpt)) {
+                const value = formatOpt[key];
+                if (value === '*') {
+                    queryFormat = QueryFormat[key.toUpperCase()];
+                    break;
+                }
+                const urls = value.urls;
+                if (Array.isArray(urls)) {
+                    urls.forEach((urlOpt) => {
+                        if (url.indexOf(urlOpt) !== -1) {
+                            queryFormat = QueryFormat[key.toUpperCase()];
+                        }
+                    });
+                    break;
+                }
+            }
+            if (queryFormat === QueryFormat.HTML ||
+                queryFormat === QueryFormat.HTMLGML2) {
+                queryHtmlTarget = 'iframe';
+            }
+        }
+        return {
+            queryFormat,
+            queryHtmlTarget
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ILayerSearchSource, deps: [{ token: i2.HttpClient }, { token: i1.LanguageService }, { token: i3.StorageService }, { token: 'options' }, { token: ILayerSearchResultFormatter }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ILayerSearchSource });
+}
+__decorate([
+    Cacheable({
+        maxCacheCount: 20,
+        cacheHasher: customCacheHasher
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, HttpParams]),
+    __metadata("design:returntype", Observable)
+], ILayerSearchSource.prototype, "getSearch", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ILayerSearchSource, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i2.HttpClient }, { type: i1.LanguageService }, { type: i3.StorageService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['options']
+                }] }, { type: ILayerSearchResultFormatter, decorators: [{
+                    type: Inject,
+                    args: [ILayerSearchResultFormatter]
+                }] }], propDecorators: { getSearch: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ilayer.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/search/shared/sources/ilayer.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpParams } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\n\nimport { LanguageService } from '@igo2/core/language';\nimport { StorageService } from '@igo2/core/storage';\nimport { ObjectUtils, customCacheHasher } from '@igo2/utils';\n\nimport { BehaviorSubject, Observable, of } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Cacheable } from 'ts-cacheable';\n\nimport { LAYER } from '../../../layer/shared/layer.enums';\nimport { getResolutionFromScale } from '../../../map/shared/map.utils';\nimport { QueryableDataSourceOptions } from '../../../query/shared/query.interfaces';\nimport { SearchResult, TextSearch } from '../search.interfaces';\nimport { computeTermSimilarity } from '../search.utils';\nimport {\n  QueryFormat,\n  QueryHtmlTarget\n} from './../../../query/shared/query.enums';\nimport {\n  ILayerData,\n  ILayerDataSource,\n  ILayerItemResponse,\n  ILayerSearchSourceOptions,\n  ILayerServiceResponse\n} from './ilayer.interfaces';\nimport { SearchSource } from './source';\nimport { SearchSourceSettings, TextSearchOptions } from './source.interfaces';\n\n@Injectable()\nexport class ILayerSearchResultFormatter {\n  constructor(private languageService: LanguageService) {}\n\n  formatResult(data: ILayerData): ILayerData {\n    const allowedKey = [\n      'title',\n      'abstract',\n      'groupTitle',\n      'metadataUrl',\n      'downloadUrl',\n      'urlInfo',\n      'name'\n    ];\n\n    const property = Object.entries(data.properties)\n      .filter(([key]) => allowedKey.indexOf(key) !== -1)\n      .reduce((out: Record<string, any>, entries: [string, any]) => {\n        const [key, value] = entries;\n        let newKey;\n        try {\n          newKey = this.languageService.translate.instant(\n            'igo.geo.search.ilayer.properties.' + key\n          );\n        } catch {\n          newKey = key;\n        }\n        out[newKey] = value ? value : '';\n        return out;\n      }, {});\n\n    const dataR = Object.assign({}, data);\n    dataR.properties = property as ILayerDataSource;\n\n    return dataR;\n  }\n}\n\n/**\n * ILayer search source\n */\n@Injectable()\nexport class ILayerSearchSource extends SearchSource implements TextSearch {\n  static id = 'ilayer';\n  static type = LAYER;\n\n  title$: BehaviorSubject<string> = new BehaviorSubject<string>('');\n\n  get title(): string {\n    return this.title$.getValue();\n  }\n\n  constructor(\n    private http: HttpClient,\n    private languageService: LanguageService,\n    storageService: StorageService,\n    @Inject('options') options: ILayerSearchSourceOptions,\n    @Inject(ILayerSearchResultFormatter)\n    private formatter: ILayerSearchResultFormatter\n  ) {\n    super(options, storageService);\n    this.languageService.language$.subscribe(() => {\n      this.title$.next(\n        this.languageService.translate.instant(this.options.title)\n      );\n    });\n  }\n\n  getId(): string {\n    return ILayerSearchSource.id;\n  }\n\n  getType(): string {\n    return ILayerSearchSource.type;\n  }\n\n  protected getDefaultOptions(): ILayerSearchSourceOptions {\n    const limit =\n      this.options.params && this.options.params.limit\n        ? Number(this.options.params.limit)\n        : undefined;\n    const ecmax =\n      this.options.params && this.options.params.ecmax\n        ? Number(this.options.params.ecmax)\n        : undefined;\n\n    const showAdvancedParams = this.options.showAdvancedSettings;\n\n    return {\n      title: 'igo.geo.search.ilayer.name',\n      searchUrl: 'https://geoegl.msp.gouv.qc.ca/apis/layers/search',\n      settings: [\n        {\n          type: 'checkbox',\n          title: 'results type',\n          name: 'type',\n          values: [\n            {\n              title: 'igo.geo.search.ilayer.type.layer',\n              value: 'layer',\n              enabled: true,\n              hashtags: ['layer', 'layers', 'couche', 'couches']\n            },\n            {\n              title: 'igo.geo.search.ilayer.type.groupLayer',\n              value: 'group',\n              enabled: false,\n              hashtags: ['gr-layer', 'gr-layers', 'gr-couche', 'gr-couches']\n            }\n          ]\n        } satisfies SearchSourceSettings,\n        {\n          type: 'radiobutton',\n          title: 'results limit',\n          name: 'limit',\n          values: [\n            {\n              title: '1',\n              value: 1,\n              enabled: limit === 1\n            },\n            {\n              title: '5',\n              value: 5,\n              enabled: limit === 5 || !limit\n            },\n            {\n              title: '10',\n              value: 10,\n              enabled: limit === 10\n            },\n            {\n              title: '25',\n              value: 25,\n              enabled: limit === 25\n            },\n            {\n              title: '50',\n              value: 50,\n              enabled: limit === 50\n            }\n          ]\n        } satisfies SearchSourceSettings,\n        showAdvancedParams &&\n          ({\n            type: 'radiobutton',\n            title: 'ecmax',\n            name: 'ecmax',\n            values: [\n              {\n                title: '10 %',\n                value: 10,\n                enabled: ecmax === 10\n              },\n              {\n                title: '30 %',\n                value: 30,\n                enabled: ecmax === 30\n              },\n              {\n                title: '50 %',\n                value: 50,\n                enabled: ecmax === 50 || !ecmax\n              },\n              {\n                title: '75 %',\n                value: 75,\n                enabled: ecmax === 75\n              },\n              {\n                title: '100 %',\n                value: 100,\n                enabled: ecmax === 100\n              }\n            ]\n          } satisfies SearchSourceSettings)\n      ].filter(Boolean)\n    };\n  }\n\n  /**\n   * Search a layer by name or keyword\n   * @param term Layer name or keyword\n   * @returns Observable of <SearchResult<LayerOptions>[]\n   */\n  search(\n    term: string | undefined,\n    options?: TextSearchOptions\n  ): Observable<SearchResult<ILayerItemResponse>[]> {\n    const params = this.computeSearchRequestParams(term, options || {});\n    if (!params.get('q') || !params.get('type')) {\n      return of([]);\n    }\n    this.options.params.page = params.get('page') || '1';\n    return this.getSearch(term, params);\n  }\n\n  @Cacheable({\n    maxCacheCount: 20,\n    cacheHasher: customCacheHasher\n  })\n  private getSearch(\n    term: string,\n    params: HttpParams\n  ): Observable<SearchResult<ILayerItemResponse>[]> {\n    return this.http\n      .get(this.searchUrl, { params })\n      .pipe(\n        map((response: ILayerServiceResponse) =>\n          this.extractResults(response, term)\n        )\n      );\n  }\n\n  private computeSearchRequestParams(\n    term: string,\n    options: TextSearchOptions\n  ): HttpParams {\n    return new HttpParams({\n      fromObject: ObjectUtils.removeUndefined(\n        Object.assign(\n          {\n            q: this.computeTerm(term)\n          },\n          this.params,\n          this.computeOptionsParam(term, options || {}).params,\n          {\n            page: options.page\n          }\n        )\n      )\n    });\n  }\n\n  /**\n   * Remove hashtag from query\n   * @param term Query with hashtag\n   */\n  private computeTerm(term: string): string {\n    return term.replace(/(#[^\\s]*)/g, '').replace(/[^\\wÀ-ÿ !\\-\\(\\),'#]+/g, '');\n  }\n\n  /**\n   * Add hashtag to param if valid\n   * @param term Query with hashtag\n   * @param options TextSearchOptions\n   */\n  private computeOptionsParam(\n    term: string,\n    options: TextSearchOptions\n  ): TextSearchOptions {\n    const hashtags = super.getHashtagsValid(term, 'type');\n    if (hashtags) {\n      options.params = Object.assign(options.params || {}, {\n        type: hashtags.join(',')\n      });\n    }\n\n    return options;\n  }\n\n  private extractResults(\n    response: ILayerServiceResponse,\n    term: string\n  ): SearchResult<ILayerItemResponse>[] {\n    return response.items.map((data: ILayerData) =>\n      this.dataToResult(data, term, response)\n    );\n  }\n\n  private dataToResult(\n    data: ILayerData,\n    term: string,\n    response?: ILayerServiceResponse\n  ): SearchResult<ILayerItemResponse> {\n    const layerOptions = this.computeLayerOptions(data);\n\n    const titleHtml = data.highlight.title || data.properties.title;\n    const groupTitle = data.highlight.groupTitle || data.properties.groupTitle;\n    const subtitleHtml = groupTitle\n      ? ' <small style=\"color: #6f6969\"> ' + groupTitle + '</small>'\n      : '';\n\n    return {\n      source: this,\n      meta: {\n        dataType: LAYER,\n        id: [this.getId(), data.properties.id].join('.'),\n        title: data.properties.title,\n        titleHtml: titleHtml + subtitleHtml,\n        icon: data.properties.type === 'Layer' ? 'layers' : 'map',\n        score:\n          data.score ||\n          computeTermSimilarity(term.trim(), data.properties.name),\n        nextPage:\n          response.items.length % +this.options.params.limit === 0 &&\n          +this.options.params.page < 10\n      },\n      data: layerOptions\n    };\n  }\n\n  private computeLayerOptions(data: ILayerData): ILayerItemResponse {\n    const url = data.properties.url;\n    const queryParams: QueryableDataSourceOptions =\n      this.extractQueryParamsFromSourceUrl(url);\n    return ObjectUtils.removeUndefined({\n      sourceOptions: {\n        id: data.properties.id,\n        type: data.properties.format,\n        url,\n        queryFormat: queryParams.queryFormat,\n        queryHtmlTarget: queryParams.queryHtmlTarget,\n        params:\n          data.properties.format === 'wms'\n            ? { LAYERS: data.properties.name }\n            : undefined,\n        layer:\n          data.properties.format === 'wms' ? undefined : data.properties.name,\n        optionsFromCapabilities: true,\n        crossOrigin: 'anonymous'\n      },\n      title: data.properties.title,\n      maxResolution: getResolutionFromScale(\n        Number(data.properties.maxScaleDenom)\n      ),\n      minResolution: getResolutionFromScale(\n        Number(data.properties.minScaleDenom)\n      ),\n      metadata: {\n        url: data.properties.metadataUrl,\n        extern: data.properties.metadataUrl ? true : undefined,\n        abstract: data.properties.abstract || undefined\n      },\n      properties: this.formatter.formatResult(data).properties\n    });\n  }\n\n  private extractQueryParamsFromSourceUrl(url: string): {\n    queryFormat: QueryFormat;\n    queryHtmlTarget: QueryHtmlTarget;\n  } {\n    let queryFormat;\n    let queryHtmlTarget;\n    const formatOpt = (this.options as ILayerSearchSourceOptions).queryFormat;\n    if (formatOpt) {\n      for (const key of Object.keys(formatOpt)) {\n        const value = formatOpt[key];\n        if (value === '*') {\n          queryFormat = QueryFormat[key.toUpperCase()];\n          break;\n        }\n\n        const urls = (value as any as { urls: string[] }).urls;\n        if (Array.isArray(urls)) {\n          urls.forEach((urlOpt) => {\n            if (url.indexOf(urlOpt) !== -1) {\n              queryFormat = QueryFormat[key.toUpperCase()];\n            }\n          });\n          break;\n        }\n      }\n\n      if (\n        queryFormat === QueryFormat.HTML ||\n        queryFormat === QueryFormat.HTMLGML2\n      ) {\n        queryHtmlTarget = 'iframe';\n      }\n    }\n\n    return {\n      queryFormat,\n      queryHtmlTarget\n    };\n  }\n}\n"]}

package/esm2022/lib/search/shared/sources/ilayer.providers.mjs

@@ -0,0 +1,58 @@
+import { HttpClient } from '@angular/common/http';
+import { ConfigService } from '@igo2/core/config';
+import { LanguageService } from '@igo2/core/language';
+import { StorageService } from '@igo2/core/storage';
+import { ILayerSearchResultFormatter, ILayerSearchSource } from './ilayer';
+import { SearchSource } from './source';
+import { SearchSourceKind } from './source.interfaces';
+/**
+ * ILayer search result formatter factory
+ * @ignore
+ */
+export function ilayerSearchResultFormatterFactory(languageService) {
+    return new ILayerSearchResultFormatter(languageService);
+}
+/**
+ * Function that returns a provider for the ILayer search result formatter
+ */
+export function provideILayerSearchResultFormatter() {
+    return {
+        provide: ILayerSearchResultFormatter,
+        useFactory: ilayerSearchResultFormatterFactory,
+        deps: [LanguageService]
+    };
+}
+/**
+ * ILayer search source factory
+ * @ignore
+ */
+export function ilayerSearchSourceFactory(http, languageService, storageService, config, formatter) {
+    return new ILayerSearchSource(http, languageService, storageService, config.getConfig(`searchSources.${ILayerSearchSource.id}`), formatter);
+}
+/**
+ * Function that returns a provider for the ILayer search source
+ */
+export function provideILayerSearchSource() {
+    return {
+        provide: SearchSource,
+        useFactory: ilayerSearchSourceFactory,
+        multi: true,
+        deps: [
+            HttpClient,
+            LanguageService,
+            StorageService,
+            ConfigService,
+            ILayerSearchResultFormatter
+        ]
+    };
+}
+export function withILayerSource() {
+    return {
+        kind: SearchSourceKind.ILayer,
+        providers: [
+            provideILayerSearchSource(),
+            provideILayerSearchResultFormatter()
+        ]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/shared/sources/index.mjs

@@ -0,0 +1,23 @@
+export * from './cadastre';
+export * from './cadastre.providers';
+export * from './source';
+export * from './source.interfaces';
+export * from './icherche';
+export * from './icherche.interfaces';
+export * from './icherche.providers';
+export * from './ilayer';
+export * from './ilayer.interfaces';
+export * from './ilayer.providers';
+export * from './nominatim';
+export * from './nominatim.interfaces';
+export * from './nominatim.providers';
+export * from './storedqueries';
+export * from './storedqueries.interfaces';
+export * from './storedqueries.providers';
+export * from './coordinates';
+export * from './coordinates.interfaces';
+export * from './coordinates.providers';
+export * from './workspace';
+export * from './workspace.interfaces';
+export * from './workspace.providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvc2hhcmVkL3NvdXJjZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NhZGFzdHJlJztcbmV4cG9ydCAqIGZyb20gJy4vY2FkYXN0cmUucHJvdmlkZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vc291cmNlLmludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9pY2hlcmNoZSc7XG5leHBvcnQgKiBmcm9tICcuL2ljaGVyY2hlLmludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9pY2hlcmNoZS5wcm92aWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbGF5ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9pbGF5ZXIuaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL2lsYXllci5wcm92aWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9ub21pbmF0aW0nO1xuZXhwb3J0ICogZnJvbSAnLi9ub21pbmF0aW0uaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL25vbWluYXRpbS5wcm92aWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdG9yZWRxdWVyaWVzJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmVkcXVlcmllcy5pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmVkcXVlcmllcy5wcm92aWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb29yZGluYXRlcyc7XG5leHBvcnQgKiBmcm9tICcuL2Nvb3JkaW5hdGVzLmludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb29yZGluYXRlcy5wcm92aWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi93b3Jrc3BhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi93b3Jrc3BhY2UuaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL3dvcmtzcGFjZS5wcm92aWRlcnMnO1xuIl19

package/esm2022/lib/search/shared/sources/nominatim.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9taW5hdGltLmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvc2hhcmVkL3NvdXJjZXMvbm9taW5hdGltLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgTm9taW5hdGltRGF0YSB7XG4gIHBsYWNlX2lkOiBzdHJpbmc7XG4gIGRpc3BsYXlfbmFtZTogc3RyaW5nO1xuICBvc21fdHlwZTogc3RyaW5nO1xuICBjbGFzczogc3RyaW5nO1xuICB0eXBlOiBzdHJpbmc7XG4gIGxvbjogc3RyaW5nO1xuICBsYXQ6IHN0cmluZztcbiAgYm91bmRpbmdib3g6IFtzdHJpbmcsIHN0cmluZywgc3RyaW5nLCBzdHJpbmddO1xufVxuIl19