@igo2/geo 18.0.1-next.2 → 18.0.1

package/esm2022/lib/search/shared/search.service.mjs

@@ -0,0 +1,149 @@
+import { Inject, Injectable, Optional, effect, signal } from '@angular/core';
+import { AnalyticsService } from '@igo2/core/analytics';
+import { StorageService } from '@igo2/core/storage';
+import { MapService } from '../../map/shared/map.service';
+import { stringToLonLat } from '../../map/shared/map.utils';
+import { SearchSourceService } from './search-source.service';
+import { sourceCanReverseSearch, sourceCanReverseSearchAsSummary, sourceCanSearch } from './search.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./search-source.service";
+import * as i2 from "../../map/shared/map.service";
+import * as i3 from "@igo2/core/storage";
+import * as i4 from "@igo2/core/analytics";
+/**
+ * This service perform researches in all the search sources enabled.
+ * It returns Research objects who's 'request' property needs to be
+ * subscribed to in order to trigger the research. This services has
+ * keeps internal state of the researches it performed
+ * and the results they yielded.
+ */
+export class SearchService {
+    searchSourceService;
+    mapService;
+    storageService;
+    analyticsService;
+    searchTerm = signal(null);
+    constructor(searchSourceService, mapService, storageService, analyticsService, analytics) {
+        this.searchSourceService = searchSourceService;
+        this.mapService = mapService;
+        this.storageService = storageService;
+        this.analyticsService = analyticsService;
+        if (analytics) {
+            this.handleAnalytics();
+        }
+    }
+    handleAnalytics() {
+        effect(() => {
+            const term = this.searchTerm();
+            if (term != null) {
+                this.analyticsService.trackSearch(term, null);
+            }
+        });
+    }
+    /**
+     * Perform a research by text
+     * @param term Any text
+     * @returns Researches
+     */
+    search(term, options = {}) {
+        if (!this.termIsValid(term)) {
+            return [];
+        }
+        this.searchTerm.set(term);
+        const proj = this.mapService.getMap()?.projection || 'EPSG:3857';
+        const response = stringToLonLat(term, proj, {
+            forceNA: options.forceNA
+        });
+        if (response.lonLat) {
+            return this.reverseSearch(response.lonLat, {
+                distance: response.radius,
+                conf: response.conf
+            });
+        }
+        else if (response.message) {
+            console.log(response.message);
+        }
+        options.extent = this.mapService
+            .getMap()
+            ?.viewController.getExtent('EPSG:4326');
+        let sources;
+        if (options.getEnabledOnly || options.getEnabledOnly === undefined) {
+            sources = this.searchSourceService.getEnabledSources();
+        }
+        else {
+            sources = this.searchSourceService.getSources();
+        }
+        if (options.sourceId) {
+            sources = sources.filter((source) => source.getId() === options.sourceId);
+        }
+        else if (options.searchType) {
+            sources = sources.filter((source) => source.getType() === options.searchType);
+        }
+        sources = sources.filter(sourceCanSearch);
+        return this.searchSources(sources, term, options);
+    }
+    /**
+     * Perform a research by lon/lat
+     * @param lonLat Any lon/lat coordinates
+     * @returns Researches
+     */
+    reverseSearch(lonLat, options, asPointerSummary = false) {
+        const reverseSourceFonction = asPointerSummary
+            ? sourceCanReverseSearchAsSummary
+            : sourceCanReverseSearch;
+        const sources = this.searchSourceService
+            .getEnabledSources()
+            .filter(reverseSourceFonction);
+        const reverseSearchCoordsFormat = this.storageService.get('reverseSearchCoordsFormatEnabled') || false;
+        return this.reverseSearchSources(sources, lonLat, options || {}, reverseSearchCoordsFormat);
+    }
+    /**
+     * Create a text research out of all given search sources
+     * @param sources Search sources that implement TextSearch
+     * @param term Search term
+     * @returns Observable of Researches
+     */
+    searchSources(sources, term, options) {
+        return sources.map((source) => {
+            return {
+                request: source.search(term, options),
+                reverse: false,
+                source
+            };
+        });
+    }
+    /**
+     * Create a reverse research out of all given search sources
+     * @param sources Search sources that implement ReverseSearch
+     * @param lonLat Any lon/lat coordinates
+     * @returns Observable of Researches
+     */
+    reverseSearchSources(sources, lonLat, options, reverseSearchCoordsFormat) {
+        return sources.map((source) => {
+            return {
+                request: source.reverseSearch(lonLat, options, reverseSearchCoordsFormat),
+                reverse: true,
+                source
+            };
+        });
+    }
+    /**
+     * Validate that a search term is valid
+     * @param term Search term
+     * @returns True if the search term is valid
+     */
+    termIsValid(term) {
+        return typeof term === 'string' && term !== '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, deps: [{ token: i1.SearchSourceService }, { token: i2.MapService }, { token: i3.StorageService }, { token: i4.AnalyticsService }, { token: 'searchAnalytics', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.SearchSourceService }, { type: i2.MapService }, { type: i3.StorageService }, { type: i4.AnalyticsService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['searchAnalytics']
+                }, {
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/search/shared/search.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,UAAU,EACV,QAAQ,EAER,MAAM,EACN,MAAM,EACP,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EACL,sBAAsB,EACtB,+BAA+B,EAC/B,eAAe,EAChB,MAAM,gBAAgB,CAAC;;;;;;AAOxB;;;;;;GAMG;AAEH,MAAM,OAAO,aAAa;IAId;IACA;IACA;IACA;IANV,UAAU,GAA2B,MAAM,CAAC,IAAI,CAAC,CAAC;IAElD,YACU,mBAAwC,EACxC,UAAsB,EACtB,cAA8B,EAC9B,gBAAkC,EAG1C,SAAkB;QANV,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,eAAU,GAAV,UAAU,CAAY;QACtB,mBAAc,GAAd,cAAc,CAAgB;QAC9B,qBAAgB,GAAhB,gBAAgB,CAAkB;QAK1C,IAAI,SAAS,EAAE,CAAC;YACd,IAAI,CAAC,eAAe,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAEO,eAAe;QACrB,MAAM,CAAC,GAAG,EAAE;YACV,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YAC/B,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;gBACjB,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAChD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAY,EAAE,UAA6B,EAAE;QAClD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5B,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAE1B,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,UAAU,IAAI,WAAW,CAAC;QACjE,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE;YAC1C,OAAO,EAAE,OAAO,CAAC,OAAO;SACzB,CAAC,CAAC;QACH,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE;gBACzC,QAAQ,EAAE,QAAQ,CAAC,MAAM;gBACzB,IAAI,EAAE,QAAQ,CAAC,IAAI;aACpB,CAAC,CAAC;QACL,CAAC;aAAM,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;YAC5B,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;QAED,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU;aAC7B,MAAM,EAAE;YACT,EAAE,cAAc,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QAE1C,IAAI,OAAO,CAAC;QAEZ,IAAI,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACnE,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,EAAE,CAAC;QACzD,CAAC;aAAM,CAAC;YACN,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,CAAC;QAClD,CAAC;QAED,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC5E,CAAC;aAAM,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YAC9B,OAAO,GAAG,OAAO,CAAC,MAAM,CACtB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,OAAO,CAAC,UAAU,CACpD,CAAC;QACJ,CAAC;QAED,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,aAAa,CACX,MAAwB,EACxB,OAA8B,EAC9B,gBAAgB,GAAG,KAAK;QAExB,MAAM,qBAAqB,GAAG,gBAAgB;YAC5C,CAAC,CAAC,+BAA+B;YACjC,CAAC,CAAC,sBAAsB,CAAC;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,mBAAmB;aACrC,iBAAiB,EAAE;aACnB,MAAM,CAAC,qBAAqB,CAAC,CAAC;QACjC,MAAM,yBAAyB,GAC5B,IAAI,CAAC,cAAc,CAAC,GAAG,CACtB,kCAAkC,CACvB,IAAI,KAAK,CAAC;QAEzB,OAAO,IAAI,CAAC,oBAAoB,CAC9B,OAAO,EACP,MAAM,EACN,OAAO,IAAI,EAAE,EACb,yBAAyB,CAC1B,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACK,aAAa,CACnB,OAAuB,EACvB,IAAY,EACZ,OAA0B;QAE1B,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAoB,EAAE,EAAE;YAC1C,OAAO;gBACL,OAAO,EAAG,MAA4B,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC;gBAC5D,OAAO,EAAE,KAAK;gBACd,MAAM;aACP,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,oBAAoB,CAC1B,OAAuB,EACvB,MAAwB,EACxB,OAA6B,EAC7B,yBAAkC;QAElC,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAoB,EAAE,EAAE;YAC1C,OAAO;gBACL,OAAO,EAAG,MAA+B,CAAC,aAAa,CACrD,MAAM,EACN,OAAO,EACP,yBAAyB,CAC1B;gBACD,OAAO,EAAE,IAAI;gBACb,MAAM;aACP,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,WAAW,CAAC,IAAY;QAC9B,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,EAAE,CAAC;IACjD,CAAC;wGA5JU,aAAa,6IAQd,iBAAiB;4GARhB,aAAa;;4FAAb,aAAa;kBADzB,UAAU;;0BASN,MAAM;2BAAC,iBAAiB;;0BACxB,QAAQ","sourcesContent":["import {\n  Inject,\n  Injectable,\n  Optional,\n  WritableSignal,\n  effect,\n  signal\n} from '@angular/core';\n\nimport { AnalyticsService } from '@igo2/core/analytics';\nimport { StorageService } from '@igo2/core/storage';\n\nimport { MapService } from '../../map/shared/map.service';\nimport { stringToLonLat } from '../../map/shared/map.utils';\nimport { SearchSourceService } from './search-source.service';\nimport { Research, ReverseSearch, TextSearch } from './search.interfaces';\nimport {\n  sourceCanReverseSearch,\n  sourceCanReverseSearchAsSummary,\n  sourceCanSearch\n} from './search.utils';\nimport { SearchSource } from './sources/source';\nimport {\n  ReverseSearchOptions,\n  TextSearchOptions\n} from './sources/source.interfaces';\n\n/**\n * This service perform researches in all the search sources enabled.\n * It returns Research objects who's 'request' property needs to be\n * subscribed to in order to trigger the research. This services has\n * keeps internal state of the researches it performed\n * and the results they yielded.\n */\n@Injectable()\nexport class SearchService {\n  searchTerm: WritableSignal<string> = signal(null);\n\n  constructor(\n    private searchSourceService: SearchSourceService,\n    private mapService: MapService,\n    private storageService: StorageService,\n    private analyticsService: AnalyticsService,\n    @Inject('searchAnalytics')\n    @Optional()\n    analytics: boolean\n  ) {\n    if (analytics) {\n      this.handleAnalytics();\n    }\n  }\n\n  private handleAnalytics(): void {\n    effect(() => {\n      const term = this.searchTerm();\n      if (term != null) {\n        this.analyticsService.trackSearch(term, null);\n      }\n    });\n  }\n\n  /**\n   * Perform a research by text\n   * @param term Any text\n   * @returns Researches\n   */\n  search(term: string, options: TextSearchOptions = {}): Research[] {\n    if (!this.termIsValid(term)) {\n      return [];\n    }\n\n    this.searchTerm.set(term);\n\n    const proj = this.mapService.getMap()?.projection || 'EPSG:3857';\n    const response = stringToLonLat(term, proj, {\n      forceNA: options.forceNA\n    });\n    if (response.lonLat) {\n      return this.reverseSearch(response.lonLat, {\n        distance: response.radius,\n        conf: response.conf\n      });\n    } else if (response.message) {\n      console.log(response.message);\n    }\n\n    options.extent = this.mapService\n      .getMap()\n      ?.viewController.getExtent('EPSG:4326');\n\n    let sources;\n\n    if (options.getEnabledOnly || options.getEnabledOnly === undefined) {\n      sources = this.searchSourceService.getEnabledSources();\n    } else {\n      sources = this.searchSourceService.getSources();\n    }\n\n    if (options.sourceId) {\n      sources = sources.filter((source) => source.getId() === options.sourceId);\n    } else if (options.searchType) {\n      sources = sources.filter(\n        (source) => source.getType() === options.searchType\n      );\n    }\n\n    sources = sources.filter(sourceCanSearch);\n    return this.searchSources(sources, term, options);\n  }\n\n  /**\n   * Perform a research by lon/lat\n   * @param lonLat Any lon/lat coordinates\n   * @returns Researches\n   */\n  reverseSearch(\n    lonLat: [number, number],\n    options?: ReverseSearchOptions,\n    asPointerSummary = false\n  ) {\n    const reverseSourceFonction = asPointerSummary\n      ? sourceCanReverseSearchAsSummary\n      : sourceCanReverseSearch;\n    const sources = this.searchSourceService\n      .getEnabledSources()\n      .filter(reverseSourceFonction);\n    const reverseSearchCoordsFormat =\n      (this.storageService.get(\n        'reverseSearchCoordsFormatEnabled'\n      ) as boolean) || false;\n\n    return this.reverseSearchSources(\n      sources,\n      lonLat,\n      options || {},\n      reverseSearchCoordsFormat\n    );\n  }\n\n  /**\n   * Create a text research out of all given search sources\n   * @param sources Search sources that implement TextSearch\n   * @param term Search term\n   * @returns Observable of Researches\n   */\n  private searchSources(\n    sources: SearchSource[],\n    term: string,\n    options: TextSearchOptions\n  ): Research[] {\n    return sources.map((source: SearchSource) => {\n      return {\n        request: (source as any as TextSearch).search(term, options),\n        reverse: false,\n        source\n      };\n    });\n  }\n\n  /**\n   * Create a reverse research out of all given search sources\n   * @param sources Search sources that implement ReverseSearch\n   * @param lonLat Any lon/lat coordinates\n   * @returns Observable of Researches\n   */\n  private reverseSearchSources(\n    sources: SearchSource[],\n    lonLat: [number, number],\n    options: ReverseSearchOptions,\n    reverseSearchCoordsFormat: boolean\n  ): Research[] {\n    return sources.map((source: SearchSource) => {\n      return {\n        request: (source as any as ReverseSearch).reverseSearch(\n          lonLat,\n          options,\n          reverseSearchCoordsFormat\n        ),\n        reverse: true,\n        source\n      };\n    });\n  }\n\n  /**\n   * Validate that a search term is valid\n   * @param term Search term\n   * @returns True if the search term is valid\n   */\n  private termIsValid(term: string): boolean {\n    return typeof term === 'string' && term !== '';\n  }\n}\n"]}

package/esm2022/lib/search/shared/search.utils.mjs

@@ -0,0 +1,92 @@
+import { FEATURE } from '../../feature/shared/feature.enums';
+/**
+ * Function that checks whether a search source implements TextSearch
+ * @param source Search source
+ * @returns True if the search source implements TextSearch
+ */
+export function sourceCanSearch(source) {
+    return source.search !== undefined;
+}
+/**
+ * Function that checks whether a search source implements ReverseSearch
+ * @param source Search source
+ * @returns True if the search source implements ReverseSearch
+ */
+export function sourceCanReverseSearch(source) {
+    return source.reverseSearch !== undefined;
+}
+/**
+ * Function that checks whether a search source implements ReverseSearch AND is shown in the pointer summary
+ * @param source Search source
+ * @returns True if the search source implements ReverseSearch AND is shown in the pointer summary
+ */
+export function sourceCanReverseSearchAsSummary(source) {
+    return (source.reverseSearch !== undefined &&
+        source.showInPointerSummary === true);
+}
+/**
+ * Return a search result out of an Feature. This is used to adapt
+ * the IGO query module to the new Feature/SearchResult interfaces
+ * @param feature feature
+ * @param source Search source
+ * @returns SearchResult
+ */
+export function featureToSearchResult(feature, source) {
+    if (feature.properties) {
+        delete feature.properties.geometry;
+        delete feature.properties.GEOMETRIE;
+        delete feature.properties.boundedBy;
+        delete feature.properties.shape;
+        delete feature.properties.SHAPE;
+        delete feature.properties.SHAPE_S;
+        delete feature.properties.SHAPE_L;
+        delete feature.properties.SHAPE_P;
+        delete feature.properties.the_geom;
+        delete feature.properties.geom;
+        delete feature.properties.geom32198;
+    }
+    feature.sourceId = source.getId();
+    return {
+        source,
+        data: feature,
+        meta: {
+            dataType: FEATURE,
+            id: feature.meta.id,
+            title: feature.meta.title,
+            icon: feature.meta.icon || 'location_on'
+        }
+    };
+}
+export function findDiff(str1, str2) {
+    let diff = '';
+    str2.split('').forEach((val, i) => {
+        if (val !== str1.charAt(i)) {
+            diff += val;
+        }
+    });
+    return diff;
+}
+/**
+ * Return a score calculation based on "from" term with the "to" term,
+ * where the perfect match is 100 and a total difference is 0 or under.
+ * @param from string
+ * @param to string
+ * @param caseSensitive boolean
+ * @returns number
+ */
+export function computeTermSimilarity(from, to, caseSensitive = false) {
+    if (!from || !to) {
+        return 0;
+    }
+    const termFrom = caseSensitive ? from : from.toString().toLowerCase();
+    const termTo = caseSensitive ? to : to.toString().toLowerCase();
+    const fromToDiff = findDiff(termFrom, termTo);
+    const toFromDiff = findDiff(termTo, termFrom);
+    const totalDiff = fromToDiff + toFromDiff;
+    let delta = 0;
+    if (totalDiff.length) {
+        delta = (totalDiff.length / termFrom.length) * 100;
+    }
+    return 100 - Math.floor(delta);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,142 @@
+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 { customCacheHasher } from '@igo2/utils';
+import olWKT from 'ol/format/WKT';
+import { Observable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Cacheable } from 'ts-cacheable';
+import { FEATURE } from '../../../feature/shared/feature.enums';
+import { computeTermSimilarity } from '../search.utils';
+import { SearchSource } from './source';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@igo2/core/language";
+import * as i3 from "@igo2/core/storage";
+/**
+ * Cadastre search source
+ */
+export class CadastreSearchSource extends SearchSource {
+    http;
+    languageService;
+    static id = 'cadastre';
+    static type = FEATURE;
+    constructor(http, languageService, storageService, options) {
+        super(options, storageService);
+        this.http = http;
+        this.languageService = languageService;
+    }
+    getId() {
+        return CadastreSearchSource.id;
+    }
+    getType() {
+        return CadastreSearchSource.type;
+    }
+    /*
+     * Source : https://wiki.openstreetmap.org/wiki/Key:amenity
+     */
+    getDefaultOptions() {
+        return {
+            title: 'Cadastre (Québec)',
+            searchUrl: 'https://carto.cptaq.gouv.qc.ca/php/find_lot_v1.php?'
+        };
+    }
+    /**
+     * Search a place by name
+     * @param term Place name
+     * @returns Observable of <SearchResult<Feature>[]
+     */
+    search(term, options) {
+        term = term.replace(/ /g, '');
+        term = term.replace(/,+/g, ',');
+        term = term.endsWith(',') ? term.slice(0, -1) : term;
+        term = term.startsWith(',') ? term.substr(1) : term;
+        const params = this.computeSearchRequestParams(term, options || {});
+        if (!params.get('numero') || !params.get('numero').match(/^[0-9,]+$/g)) {
+            return of([]);
+        }
+        return this.getCadastre(term, params);
+    }
+    getCadastre(term, params) {
+        return this.http
+            .get(this.searchUrl, { params, responseType: 'text' })
+            .pipe(map((response) => this.extractResults(response, term)));
+    }
+    computeSearchRequestParams(term, options) {
+        return new HttpParams({
+            fromObject: Object.assign({
+                numero: term,
+                epsg: '4326'
+            }, this.params, options.params || {})
+        });
+    }
+    extractResults(response, term) {
+        return response
+            .split('<br />')
+            .filter((lot) => lot.length > 0)
+            .map((lot) => this.dataToResult(lot, term));
+    }
+    dataToResult(data, term) {
+        const lot = data.split(';');
+        const numero = lot[0];
+        const wkt = lot[7];
+        const geometry = this.computeGeometry(wkt);
+        const properties = {
+            NoLot: numero,
+            Route: '<span class="routing"> <u>' +
+                this.languageService.translate.instant('igo.geo.seeRouting') +
+                '</u> </span>'
+        };
+        const id = [this.getId(), 'cadastre', numero].join('.');
+        return {
+            source: this,
+            meta: {
+                dataType: FEATURE,
+                id,
+                title: numero,
+                score: computeTermSimilarity(term.trim(), numero),
+                icon: 'location_on'
+            },
+            data: {
+                type: FEATURE,
+                projection: 'EPSG:4326',
+                geometry,
+                properties,
+                meta: {
+                    id,
+                    title: numero
+                }
+            }
+        };
+    }
+    computeGeometry(wkt) {
+        const feature = new olWKT().readFeature(wkt, {
+            dataProjection: 'EPSG:4326',
+            featureProjection: 'EPSG:4326'
+        });
+        return {
+            type: feature.getGeometry().getType(),
+            coordinates: feature.getGeometry().getCoordinates()
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CadastreSearchSource, deps: [{ token: i1.HttpClient }, { token: i2.LanguageService }, { token: i3.StorageService }, { token: 'options' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CadastreSearchSource });
+}
+__decorate([
+    Cacheable({
+        maxCacheCount: 20,
+        cacheHasher: customCacheHasher
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, HttpParams]),
+    __metadata("design:returntype", Observable)
+], CadastreSearchSource.prototype, "getCadastre", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CadastreSearchSource, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.LanguageService }, { type: i3.StorageService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['options']
+                }] }], propDecorators: { getCadastre: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cadastre.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/search/shared/sources/cadastre.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 { customCacheHasher } from '@igo2/utils';\n\nimport olWKT from 'ol/format/WKT';\n\nimport { GeoJsonGeometryTypes } from 'geojson';\nimport { Observable, of } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Cacheable } from 'ts-cacheable';\n\nimport { FEATURE } from '../../../feature/shared/feature.enums';\nimport {\n  Feature,\n  FeatureGeometry\n} from '../../../feature/shared/feature.interfaces';\nimport { SearchResult, TextSearch } from '../search.interfaces';\nimport { computeTermSimilarity } from '../search.utils';\nimport { SearchSource } from './source';\nimport { SearchSourceOptions, TextSearchOptions } from './source.interfaces';\n\n/**\n * Cadastre search source\n */\n@Injectable()\nexport class CadastreSearchSource extends SearchSource implements TextSearch {\n  static id = 'cadastre';\n  static type = FEATURE;\n\n  constructor(\n    private http: HttpClient,\n    private languageService: LanguageService,\n    storageService: StorageService,\n    @Inject('options') options: SearchSourceOptions\n  ) {\n    super(options, storageService);\n  }\n\n  getId(): string {\n    return CadastreSearchSource.id;\n  }\n\n  getType(): string {\n    return CadastreSearchSource.type;\n  }\n\n  /*\n   * Source : https://wiki.openstreetmap.org/wiki/Key:amenity\n   */\n  protected getDefaultOptions(): SearchSourceOptions {\n    return {\n      title: 'Cadastre (Québec)',\n      searchUrl: 'https://carto.cptaq.gouv.qc.ca/php/find_lot_v1.php?'\n    };\n  }\n\n  /**\n   * Search a place by name\n   * @param term Place name\n   * @returns Observable of <SearchResult<Feature>[]\n   */\n  search(\n    term: string | undefined,\n    options?: TextSearchOptions\n  ): Observable<SearchResult<Feature>[]> {\n    term = term.replace(/ /g, '');\n    term = term.replace(/,+/g, ',');\n    term = term.endsWith(',') ? term.slice(0, -1) : term;\n    term = term.startsWith(',') ? term.substr(1) : term;\n\n    const params = this.computeSearchRequestParams(term, options || {});\n    if (!params.get('numero') || !params.get('numero').match(/^[0-9,]+$/g)) {\n      return of([]);\n    }\n    return this.getCadastre(term, params);\n  }\n\n  @Cacheable({\n    maxCacheCount: 20,\n    cacheHasher: customCacheHasher\n  })\n  private getCadastre(\n    term: string,\n    params: HttpParams\n  ): Observable<SearchResult<Feature>[]> {\n    return this.http\n      .get(this.searchUrl, { params, responseType: 'text' })\n      .pipe(map((response: string) => this.extractResults(response, term)));\n  }\n\n  private computeSearchRequestParams(\n    term: string,\n    options: TextSearchOptions\n  ): HttpParams {\n    return new HttpParams({\n      fromObject: Object.assign(\n        {\n          numero: term,\n          epsg: '4326'\n        },\n        this.params,\n        options.params || {}\n      )\n    });\n  }\n\n  private extractResults(\n    response: string,\n    term: string\n  ): SearchResult<Feature>[] {\n    return response\n      .split('<br />')\n      .filter((lot: string) => lot.length > 0)\n      .map((lot: string) => this.dataToResult(lot, term));\n  }\n\n  private dataToResult(data: string, term: string): SearchResult<Feature> {\n    const lot = data.split(';');\n    const numero = lot[0];\n    const wkt = lot[7];\n    const geometry = this.computeGeometry(wkt);\n\n    const properties = {\n      NoLot: numero,\n      Route:\n        '<span class=\"routing\"> <u>' +\n        this.languageService.translate.instant('igo.geo.seeRouting') +\n        '</u> </span>'\n    };\n    const id = [this.getId(), 'cadastre', numero].join('.');\n\n    return {\n      source: this,\n      meta: {\n        dataType: FEATURE,\n        id,\n        title: numero,\n        score: computeTermSimilarity(term.trim(), numero),\n        icon: 'location_on'\n      },\n      data: {\n        type: FEATURE,\n        projection: 'EPSG:4326',\n        geometry,\n        properties,\n        meta: {\n          id,\n          title: numero\n        }\n      }\n    };\n  }\n\n  private computeGeometry(wkt: string): FeatureGeometry {\n    const feature = new olWKT().readFeature(wkt, {\n      dataProjection: 'EPSG:4326',\n      featureProjection: 'EPSG:4326'\n    });\n    return {\n      type: feature.getGeometry().getType() as GeoJsonGeometryTypes,\n      coordinates: (feature.getGeometry() as any).getCoordinates()\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,32 @@
+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 { CadastreSearchSource } from './cadastre';
+import { SearchSource } from './source';
+import { SearchSourceKind } from './source.interfaces';
+/**
+ * Cadastre search source factory
+ * @ignore
+ */
+export function cadastreSearchSourceFactory(http, languageService, storageService, config) {
+    return new CadastreSearchSource(http, languageService, storageService, config.getConfig(`searchSources.${CadastreSearchSource.id}`));
+}
+/**
+ * Function that returns a provider for the Cadastre search source
+ */
+export function provideCadastreSearchSource() {
+    return {
+        provide: SearchSource,
+        useFactory: cadastreSearchSourceFactory,
+        multi: true,
+        deps: [HttpClient, LanguageService, StorageService, ConfigService]
+    };
+}
+export function withCadastreSource() {
+    return {
+        kind: SearchSourceKind.Cadastre,
+        providers: [provideCadastreSearchSource()]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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