@igo2/geo 1.15.4 → 16.0.0-rc.0

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

@@ -0,0 +1,130 @@
+import { Injectable } from '@angular/core';
+import { stringToLonLat } from '../../map/shared';
+import { MapService } from '../../map/shared/map.service';
+import { SearchSourceService } from './search-source.service';
+import { sourceCanSearch, sourceCanReverseSearch, sourceCanReverseSearchAsSummary } from './search.utils';
+import { StorageService } from '@igo2/core';
+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";
+/**
+ * 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;
+    constructor(searchSourceService, mapService, storageService) {
+        this.searchSourceService = searchSourceService;
+        this.mapService = mapService;
+        this.storageService = storageService;
+    }
+    /**
+     * Perform a research by text
+     * @param term Any text
+     * @returns Researches
+     */
+    search(term, options = {}) {
+        if (!this.termIsValid(term)) {
+            return [];
+        }
+        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 = function SearchService_Factory(t) { return new (t || SearchService)(i0.ɵɵinject(i1.SearchSourceService), i0.ɵɵinject(i2.MapService), i0.ɵɵinject(i3.StorageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SearchService, factory: SearchService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SearchService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.SearchSourceService }, { type: i2.MapService }, { type: i3.StorageService }]; }, null); })();
+//# 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,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAO1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,+BAA+B,EAChC,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;;;;;AAE5C;;;;;;GAMG;AAIH,MAAM,OAAO,aAAa;IAEd;IACA;IACA;IAHV,YACU,mBAAwC,EACxC,UAAsB,EACtB,cAA8B;QAF9B,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,eAAU,GAAV,UAAU,CAAY;QACtB,mBAAc,GAAd,cAAc,CAAgB;IACrC,CAAC;IAEJ;;;;OAIG;IACH,MAAM,CAAC,IAAY,EAAE,UAA6B,EAAE;QAClD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YAC3B,OAAO,EAAE,CAAC;SACX;QAED,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;YACnB,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE;gBACzC,QAAQ,EAAE,QAAQ,CAAC,MAAM;gBACzB,IAAI,EAAE,QAAQ,CAAC,IAAI;aACpB,CAAC,CAAC;SACJ;aAAM,IAAI,QAAQ,CAAC,OAAO,EAAE;YAC3B,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;SAC/B;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;YAClE,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,EAAE,CAAC;SACxD;aAAM;YACL,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,CAAC;SACjD;QAED,IAAI,OAAO,CAAC,QAAQ,EAAE;YACpB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;SAC3E;aAAM,IAAI,OAAO,CAAC,UAAU,EAAE;YAC7B,OAAO,GAAG,OAAO,CAAC,MAAM,CACtB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,OAAO,CAAC,UAAU,CACpD,CAAC;SACH;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,mBAA4B,KAAK;QAEjC,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;uEAvIU,aAAa;gEAAb,aAAa,WAAb,aAAa,mBAFZ,MAAM;;uFAEP,aAAa;cAHzB,UAAU;eAAC;gBACV,UAAU,EAAE,MAAM;aACnB","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\nimport { stringToLonLat } from '../../map/shared';\r\nimport { MapService } from '../../map/shared/map.service';\r\n\r\nimport { SearchSource } from './sources/source';\r\nimport {\r\n  TextSearchOptions,\r\n  ReverseSearchOptions\r\n} from './sources/source.interfaces';\r\nimport { SearchSourceService } from './search-source.service';\r\nimport { Research, TextSearch, ReverseSearch } from './search.interfaces';\r\nimport {\r\n  sourceCanSearch,\r\n  sourceCanReverseSearch,\r\n  sourceCanReverseSearchAsSummary\r\n} from './search.utils';\r\nimport { StorageService } from '@igo2/core';\r\n\r\n/**\r\n * This service perform researches in all the search sources enabled.\r\n * It returns Research objects who's 'request' property needs to be\r\n * subscribed to in order to trigger the research. This services has\r\n * keeps internal state of the researches it performed\r\n * and the results they yielded.\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SearchService {\r\n  constructor(\r\n    private searchSourceService: SearchSourceService,\r\n    private mapService: MapService,\r\n    private storageService: StorageService\r\n  ) {}\r\n\r\n  /**\r\n   * Perform a research by text\r\n   * @param term Any text\r\n   * @returns Researches\r\n   */\r\n  search(term: string, options: TextSearchOptions = {}): Research[] {\r\n    if (!this.termIsValid(term)) {\r\n      return [];\r\n    }\r\n\r\n    const proj = this.mapService.getMap()?.projection || 'EPSG:3857';\r\n    const response = stringToLonLat(term, proj, {\r\n      forceNA: options.forceNA\r\n    });\r\n    if (response.lonLat) {\r\n      return this.reverseSearch(response.lonLat, {\r\n        distance: response.radius,\r\n        conf: response.conf\r\n      });\r\n    } else if (response.message) {\r\n      console.log(response.message);\r\n    }\r\n\r\n    options.extent = this.mapService\r\n      .getMap()\r\n      ?.viewController.getExtent('EPSG:4326');\r\n\r\n    let sources;\r\n\r\n    if (options.getEnabledOnly || options.getEnabledOnly === undefined) {\r\n      sources = this.searchSourceService.getEnabledSources();\r\n    } else {\r\n      sources = this.searchSourceService.getSources();\r\n    }\r\n\r\n    if (options.sourceId) {\r\n      sources = sources.filter((source) => source.getId() === options.sourceId);\r\n    } else if (options.searchType) {\r\n      sources = sources.filter(\r\n        (source) => source.getType() === options.searchType\r\n      );\r\n    }\r\n\r\n    sources = sources.filter(sourceCanSearch);\r\n    return this.searchSources(sources, term, options);\r\n  }\r\n\r\n  /**\r\n   * Perform a research by lon/lat\r\n   * @param lonLat Any lon/lat coordinates\r\n   * @returns Researches\r\n   */\r\n  reverseSearch(\r\n    lonLat: [number, number],\r\n    options?: ReverseSearchOptions,\r\n    asPointerSummary: boolean = false\r\n  ) {\r\n    const reverseSourceFonction = asPointerSummary\r\n      ? sourceCanReverseSearchAsSummary\r\n      : sourceCanReverseSearch;\r\n    const sources = this.searchSourceService\r\n      .getEnabledSources()\r\n      .filter(reverseSourceFonction);\r\n    const reverseSearchCoordsFormat =\r\n      (this.storageService.get(\r\n        'reverseSearchCoordsFormatEnabled'\r\n      ) as boolean) || false;\r\n\r\n    return this.reverseSearchSources(\r\n      sources,\r\n      lonLat,\r\n      options || {},\r\n      reverseSearchCoordsFormat\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Create a text research out of all given search sources\r\n   * @param sources Search sources that implement TextSearch\r\n   * @param term Search term\r\n   * @returns Observable of Researches\r\n   */\r\n  private searchSources(\r\n    sources: SearchSource[],\r\n    term: string,\r\n    options: TextSearchOptions\r\n  ): Research[] {\r\n    return sources.map((source: SearchSource) => {\r\n      return {\r\n        request: (source as any as TextSearch).search(term, options),\r\n        reverse: false,\r\n        source\r\n      };\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Create a reverse research out of all given search sources\r\n   * @param sources Search sources that implement ReverseSearch\r\n   * @param lonLat Any lon/lat coordinates\r\n   * @returns Observable of Researches\r\n   */\r\n  private reverseSearchSources(\r\n    sources: SearchSource[],\r\n    lonLat: [number, number],\r\n    options: ReverseSearchOptions,\r\n    reverseSearchCoordsFormat: boolean\r\n  ): Research[] {\r\n    return sources.map((source: SearchSource) => {\r\n      return {\r\n        request: (source as any as ReverseSearch).reverseSearch(\r\n          lonLat,\r\n          options,\r\n          reverseSearchCoordsFormat\r\n        ),\r\n        reverse: true,\r\n        source\r\n      };\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Validate that a search term is valid\r\n   * @param term Search term\r\n   * @returns True if the search term is valid\r\n   */\r\n  private termIsValid(term: string): boolean {\r\n    return typeof term === 'string' && term !== '';\r\n  }\r\n}\r\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 || 'map-marker'
+        }
+    };
+}
+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,{"version":3,"file":"search.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/search/shared/search.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { FEATURE } from '../../feature/shared/feature.enums';\r\nimport { Feature } from '../../feature/shared/feature.interfaces';\r\nimport { SearchSource } from './sources/source';\r\nimport { SearchResult } from './search.interfaces';\r\n\r\n/**\r\n * Function that checks whether a search source implements TextSearch\r\n * @param source Search source\r\n * @returns True if the search source implements TextSearch\r\n */\r\nexport function sourceCanSearch(source: SearchSource): boolean {\r\n  return (source as any).search !== undefined;\r\n}\r\n\r\n/**\r\n * Function that checks whether a search source implements ReverseSearch\r\n * @param source Search source\r\n * @returns True if the search source implements ReverseSearch\r\n */\r\nexport function sourceCanReverseSearch(source: SearchSource): boolean {\r\n  return (source as any).reverseSearch !== undefined;\r\n}\r\n\r\n/**\r\n * Function that checks whether a search source implements ReverseSearch AND is shown in the pointer summary\r\n * @param source Search source\r\n * @returns True if the search source implements ReverseSearch AND is shown in the pointer summary\r\n */\r\nexport function sourceCanReverseSearchAsSummary(source: SearchSource): boolean {\r\n  return (\r\n    (source as any).reverseSearch !== undefined &&\r\n    source.showInPointerSummary === true\r\n  );\r\n}\r\n\r\n/**\r\n * Return a search result out of an Feature. This is used to adapt\r\n * the IGO query module to the new Feature/SearchResult interfaces\r\n * @param feature feature\r\n * @param source Search source\r\n * @returns SearchResult\r\n */\r\nexport function featureToSearchResult(\r\n  feature: Feature,\r\n  source: SearchSource\r\n): SearchResult<Feature> {\r\n  if (feature.properties) {\r\n    delete feature.properties.geometry;\r\n    delete feature.properties.GEOMETRIE;\r\n    delete feature.properties.boundedBy;\r\n    delete feature.properties.shape;\r\n    delete feature.properties.SHAPE;\r\n    delete feature.properties.SHAPE_S;\r\n    delete feature.properties.SHAPE_L;\r\n    delete feature.properties.SHAPE_P;\r\n    delete feature.properties.the_geom;\r\n    delete feature.properties.geom;\r\n    delete feature.properties.geom32198;\r\n  }\r\n  feature.sourceId = source.getId();\r\n  return {\r\n    source,\r\n    data: feature,\r\n    meta: {\r\n      dataType: FEATURE,\r\n      id: feature.meta.id as string,\r\n      title: feature.meta.title,\r\n      icon: feature.meta.icon || 'map-marker'\r\n    }\r\n  };\r\n}\r\n\r\nexport function findDiff(str1: string, str2: string) {\r\n  let diff = '';\r\n  str2.split('').forEach((val, i) => {\r\n    if (val !== str1.charAt(i)) {\r\n      diff += val;\r\n    }\r\n  });\r\n  return diff;\r\n}\r\n\r\n/**\r\n * Return a score calculation based on \"from\" term with the \"to\" term,\r\n * where the perfect match is 100 and a total difference is 0 or under.\r\n * @param from string\r\n * @param to string\r\n * @param caseSensitive boolean\r\n * @returns number\r\n */\r\nexport function computeTermSimilarity(\r\n  from,\r\n  to,\r\n  caseSensitive: boolean = false\r\n): number {\r\n  if (!from || !to) {\r\n    return 0;\r\n  }\r\n  const termFrom = caseSensitive ? from : from.toString().toLowerCase();\r\n  const termTo = caseSensitive ? to : to.toString().toLowerCase();\r\n  const fromToDiff = findDiff(termFrom, termTo);\r\n  const toFromDiff = findDiff(termTo, termFrom);\r\n  const totalDiff = fromToDiff + toFromDiff;\r\n\r\n  let delta = 0;\r\n  if (totalDiff.length) {\r\n    delta = (totalDiff.length / termFrom.length) * 100;\r\n  }\r\n\r\n  return 100 - Math.floor(delta);\r\n}\r\n"]}

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

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

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

@@ -0,0 +1,23 @@
+import { HttpClient } from '@angular/common/http';
+import { ConfigService, LanguageService, StorageService } from '@igo2/core';
+import { SearchSource } from './source';
+import { CadastreSearchSource } from './cadastre';
+/**
+ * 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]
+    };
+}
+//# 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29vcmRpbmF0ZXMuaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL3NlYXJjaC9zaGFyZWQvc291cmNlcy9jb29yZGluYXRlcy5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENvb3JkaW5hdGVzRGF0YSB7XHJcbiAgY29vcmQ6IFtudW1iZXIsIG51bWJlcl07XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ29vcmRpbmF0ZXNSZXNwb25zZSB7XHJcbiAgZmVhdHVyZXM6IENvb3JkaW5hdGVzRGF0YVtdO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIENvb3JkaW5hdGVzUmV2ZXJzZURhdGEge1xyXG4gIGNvb3JkOiBbbnVtYmVyLCBudW1iZXJdO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIENvb3JkaW5hdGVzUmV2ZXJzZVJlc3BvbnNlIHtcclxuICBmZWF0dXJlczogQ29vcmRpbmF0ZXNEYXRhW107XHJcbn1cclxuIl19

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

@@ -0,0 +1,166 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable, Inject } from '@angular/core';
+import { Observable, BehaviorSubject, of } from 'rxjs';
+import * as olproj from 'ol/proj';
+import { fromCircle } from 'ol/geom/Polygon';
+import OlCircle from 'ol/geom/Circle';
+import * as olformat from 'ol/format';
+import { FEATURE } from '../../../feature';
+import { SearchSource } from './source';
+import { LanguageService, StorageService } from '@igo2/core';
+import { GoogleLinks } from '../../../utils/googleLinks';
+import { lonLatConversion, roundCoordTo, convertDDToDMS } from '../../../map/shared/map.utils';
+import { OsmLinks } from '../../../utils';
+import { Cacheable } from 'ts-cacheable';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+export class CoordinatesSearchResultFormatter {
+    languageService;
+    constructor(languageService) {
+        this.languageService = languageService;
+    }
+    formatResult(result) {
+        return result;
+    }
+    static ɵfac = function CoordinatesSearchResultFormatter_Factory(t) { return new (t || CoordinatesSearchResultFormatter)(i0.ɵɵinject(i1.LanguageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CoordinatesSearchResultFormatter, factory: CoordinatesSearchResultFormatter.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CoordinatesSearchResultFormatter, [{
+        type: Injectable
+    }], function () { return [{ type: i1.LanguageService }]; }, null); })();
+/**
+ * CoordinatesReverse search source
+ */
+export class CoordinatesReverseSearchSource extends SearchSource {
+    languageService;
+    static id = 'coordinatesreverse';
+    static type = FEATURE;
+    projections;
+    title$ = new BehaviorSubject('');
+    get title() {
+        return this.title$.getValue();
+    }
+    constructor(options, languageService, storageService, projections) {
+        super(options, storageService);
+        this.languageService = languageService;
+        this.projections = projections;
+        this.languageService.language$.subscribe(() => {
+            this.title$.next(this.languageService.translate.instant(this.options.title));
+        });
+    }
+    getId() {
+        return CoordinatesReverseSearchSource.id;
+    }
+    getType() {
+        return CoordinatesReverseSearchSource.type;
+    }
+    getDefaultOptions() {
+        return {
+            title: 'igo.geo.search.coordinates.name',
+            order: 1,
+            showInSettings: false
+        };
+    }
+    /**
+     * Search a location by coordinates
+     * @param lonLat Location coordinates
+     * @param options options of ReverseSearchOptions (distance, conf, zoom, params)
+     * @returns Observable of <SearchResult<Feature>[]
+     */
+    reverseSearch(lonLat, options, reverseSearchCoordsFormatEnabled) {
+        return of([
+            this.dataToResult(lonLat, options, reverseSearchCoordsFormatEnabled)
+        ]);
+    }
+    dataToResult(data, options, reverseSearchCoordsFormatEnabled) {
+        const dataDMS = convertDDToDMS(data);
+        const convertedCoord = lonLatConversion(data, this.projections);
+        const coords = convertedCoord.reduce((obj, item) => ((obj[item.alias] = item.igo2CoordFormat), obj), {});
+        const roundedCoordString = !reverseSearchCoordsFormatEnabled
+            ? roundCoordTo(data, 6).join(', ')
+            : roundCoordTo(data, 6).reverse().join(', ');
+        const roundedCoordStringDMS = !reverseSearchCoordsFormatEnabled
+            ? dataDMS.join(', ')
+            : dataDMS.reverse().join(', ');
+        let geometry = {
+            type: 'Point',
+            coordinates: [data[0], data[1]]
+        };
+        const properties = {};
+        let subtitleHtml = '';
+        if (options.distance) {
+            const radiusKey = this.languageService.translate.instant('igo.geo.search.coordinates.radius');
+            properties[radiusKey] = options.distance;
+            subtitleHtml = '<br><small>Rayon: ' + options.distance + ' m</small>';
+            // Create polygon
+            const center = olproj.transform([data[0], data[1]], 'EPSG:4326', 'EPSG:3857');
+            const circleGeometry = new OlCircle(center, options.distance);
+            const polygonGeometry = fromCircle(circleGeometry);
+            const writer = new olformat.GeoJSON();
+            geometry = JSON.parse(writer.writeGeometry(polygonGeometry.transform('EPSG:3857', 'EPSG:4326')));
+        }
+        if (options.conf) {
+            const confKey = this.languageService.translate.instant('igo.geo.search.coordinates.conf');
+            properties[confKey] = options.conf;
+            subtitleHtml += subtitleHtml === '' ? '<br>' : '<small> - </small>';
+            subtitleHtml += '<small>Confiance: ' + options.conf + '%</small>';
+        }
+        const coordKey = !reverseSearchCoordsFormatEnabled
+            ? this.languageService.translate.instant('igo.geo.search.coordinates.coord')
+            : this.languageService.translate.instant('igo.geo.search.coordinates.reversedCoord');
+        properties[coordKey] = roundedCoordString;
+        const coordKeyDMS = !reverseSearchCoordsFormatEnabled
+            ? this.languageService.translate.instant('igo.geo.search.coordinates.coordDMS')
+            : this.languageService.translate.instant('igo.geo.search.coordinates.reversedCoordDMS');
+        properties[coordKeyDMS] = roundedCoordStringDMS;
+        return {
+            source: this,
+            data: {
+                type: FEATURE,
+                projection: 'EPSG:4326',
+                geometry,
+                extent: undefined,
+                properties: Object.assign(properties, coords, {
+                    GoogleMaps: GoogleLinks.getGoogleMapsCoordLink(data[0], data[1]),
+                    GoogleStreetView: GoogleLinks.getGoogleStreetViewLink(data[0], data[1]),
+                    OpenStreetMap: OsmLinks.getOpenStreetMapLink(data[0], data[1], 14),
+                    Route: '<span class="routing"> <u>' +
+                        this.languageService.translate.instant('igo.geo.seeRouting') +
+                        '</u> </span>'
+                }),
+                meta: {
+                    id: data[0].toString() + ',' + data[1].toString(),
+                    title: roundedCoordString
+                }
+            },
+            meta: {
+                dataType: FEATURE,
+                id: data[0].toString() + ',' + data[1].toString(),
+                title: roundedCoordString,
+                titleHtml: roundedCoordString + subtitleHtml,
+                icon: 'map-marker',
+                score: 100 // every coord exists
+            }
+        };
+    }
+    static ɵfac = function CoordinatesReverseSearchSource_Factory(t) { return new (t || CoordinatesReverseSearchSource)(i0.ɵɵinject('options'), i0.ɵɵinject(i1.LanguageService), i0.ɵɵinject(i1.StorageService), i0.ɵɵinject('projections')); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CoordinatesReverseSearchSource, factory: CoordinatesReverseSearchSource.ɵfac });
+}
+__decorate([
+    Cacheable({
+        maxCacheCount: 20
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object, Boolean]),
+    __metadata("design:returntype", Observable)
+], CoordinatesReverseSearchSource.prototype, "reverseSearch", null);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CoordinatesReverseSearchSource, [{
+        type: Injectable
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: ['options']
+            }] }, { type: i1.LanguageService }, { type: i1.StorageService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: ['projections']
+            }] }]; }, { reverseSearch: [] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coordinates.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/search/shared/sources/coordinates.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\r\nimport { Observable, BehaviorSubject, of } from 'rxjs';\r\nimport * as olproj from 'ol/proj';\r\nimport { fromCircle } from 'ol/geom/Polygon';\r\nimport OlCircle from 'ol/geom/Circle';\r\nimport * as olformat from 'ol/format';\r\n\r\nimport { FEATURE, Feature, FeatureGeometry } from '../../../feature';\r\n\r\nimport { SearchResult, ReverseSearch } from '../search.interfaces';\r\nimport { SearchSource } from './source';\r\nimport { SearchSourceOptions, ReverseSearchOptions } from './source.interfaces';\r\n\r\nimport { LanguageService, StorageService } from '@igo2/core';\r\nimport { GoogleLinks } from '../../../utils/googleLinks';\r\nimport { Projection } from '../../../map/shared/projection.interfaces';\r\nimport {\r\n  lonLatConversion,\r\n  roundCoordTo,\r\n  convertDDToDMS\r\n} from '../../../map/shared/map.utils';\r\nimport { OsmLinks } from '../../../utils';\r\nimport { Cacheable } from 'ts-cacheable';\r\n\r\n@Injectable()\r\nexport class CoordinatesSearchResultFormatter {\r\n  constructor(private languageService: LanguageService) {}\r\n\r\n  formatResult(result: SearchResult<Feature>): SearchResult<Feature> {\r\n    return result;\r\n  }\r\n}\r\n/**\r\n * CoordinatesReverse search source\r\n */\r\n@Injectable()\r\nexport class CoordinatesReverseSearchSource\r\n  extends SearchSource\r\n  implements ReverseSearch\r\n{\r\n  static id = 'coordinatesreverse';\r\n  static type = FEATURE;\r\n\r\n  private projections;\r\n\r\n  title$: BehaviorSubject<string> = new BehaviorSubject<string>('');\r\n\r\n  get title(): string {\r\n    return this.title$.getValue();\r\n  }\r\n\r\n  constructor(\r\n    @Inject('options') options: SearchSourceOptions,\r\n    private languageService: LanguageService,\r\n    storageService: StorageService,\r\n    @Inject('projections') projections: Projection[]\r\n  ) {\r\n    super(options, storageService);\r\n    this.projections = projections;\r\n    this.languageService.language$.subscribe(() => {\r\n      this.title$.next(\r\n        this.languageService.translate.instant(this.options.title)\r\n      );\r\n    });\r\n  }\r\n\r\n  getId(): string {\r\n    return CoordinatesReverseSearchSource.id;\r\n  }\r\n\r\n  getType(): string {\r\n    return CoordinatesReverseSearchSource.type;\r\n  }\r\n\r\n  protected getDefaultOptions(): SearchSourceOptions {\r\n    return {\r\n      title: 'igo.geo.search.coordinates.name',\r\n      order: 1,\r\n      showInSettings: false\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Search a location by coordinates\r\n   * @param lonLat Location coordinates\r\n   * @param options options of ReverseSearchOptions (distance, conf, zoom, params)\r\n   * @returns Observable of <SearchResult<Feature>[]\r\n   */\r\n  @Cacheable({\r\n    maxCacheCount: 20\r\n  })\r\n  reverseSearch(\r\n    lonLat: [number, number],\r\n    options?: ReverseSearchOptions,\r\n    reverseSearchCoordsFormatEnabled?: boolean\r\n  ): Observable<SearchResult<Feature>[]> {\r\n    return of([\r\n      this.dataToResult(lonLat, options, reverseSearchCoordsFormatEnabled)\r\n    ]);\r\n  }\r\n\r\n  private dataToResult(\r\n    data: [number, number],\r\n    options: ReverseSearchOptions,\r\n    reverseSearchCoordsFormatEnabled: boolean\r\n  ): SearchResult<Feature> {\r\n    const dataDMS = convertDDToDMS(data);\r\n    const convertedCoord = lonLatConversion(data, this.projections);\r\n    const coords = convertedCoord.reduce(\r\n      (obj, item) => ((obj[item.alias] = item.igo2CoordFormat), obj),\r\n      {}\r\n    );\r\n\r\n    const roundedCoordString = !reverseSearchCoordsFormatEnabled\r\n      ? roundCoordTo(data, 6).join(', ')\r\n      : roundCoordTo(data, 6).reverse().join(', ');\r\n\r\n    const roundedCoordStringDMS = !reverseSearchCoordsFormatEnabled\r\n      ? dataDMS.join(', ')\r\n      : dataDMS.reverse().join(', ');\r\n\r\n    let geometry: FeatureGeometry = {\r\n      type: 'Point',\r\n      coordinates: [data[0], data[1]]\r\n    };\r\n\r\n    const properties = {};\r\n    let subtitleHtml = '';\r\n    if (options.distance) {\r\n      const radiusKey = this.languageService.translate.instant(\r\n        'igo.geo.search.coordinates.radius'\r\n      );\r\n      properties[radiusKey] = options.distance;\r\n      subtitleHtml = '<br><small>Rayon: ' + options.distance + ' m</small>';\r\n\r\n      // Create polygon\r\n      const center = olproj.transform(\r\n        [data[0], data[1]],\r\n        'EPSG:4326',\r\n        'EPSG:3857'\r\n      );\r\n      const circleGeometry = new OlCircle(center, options.distance);\r\n      const polygonGeometry = fromCircle(circleGeometry);\r\n      const writer = new olformat.GeoJSON();\r\n      geometry = JSON.parse(\r\n        writer.writeGeometry(\r\n          polygonGeometry.transform('EPSG:3857', 'EPSG:4326')\r\n        )\r\n      );\r\n    }\r\n\r\n    if (options.conf) {\r\n      const confKey = this.languageService.translate.instant(\r\n        'igo.geo.search.coordinates.conf'\r\n      );\r\n      properties[confKey] = options.conf;\r\n      subtitleHtml += subtitleHtml === '' ? '<br>' : '<small> - </small>';\r\n      subtitleHtml += '<small>Confiance: ' + options.conf + '%</small>';\r\n    }\r\n\r\n    const coordKey = !reverseSearchCoordsFormatEnabled\r\n      ? this.languageService.translate.instant(\r\n          'igo.geo.search.coordinates.coord'\r\n        )\r\n      : this.languageService.translate.instant(\r\n          'igo.geo.search.coordinates.reversedCoord'\r\n        );\r\n    properties[coordKey] = roundedCoordString;\r\n\r\n    const coordKeyDMS = !reverseSearchCoordsFormatEnabled\r\n      ? this.languageService.translate.instant(\r\n          'igo.geo.search.coordinates.coordDMS'\r\n        )\r\n      : this.languageService.translate.instant(\r\n          'igo.geo.search.coordinates.reversedCoordDMS'\r\n        );\r\n    properties[coordKeyDMS] = roundedCoordStringDMS;\r\n\r\n    return {\r\n      source: this,\r\n      data: {\r\n        type: FEATURE,\r\n        projection: 'EPSG:4326',\r\n        geometry,\r\n        extent: undefined,\r\n        properties: Object.assign(properties, coords, {\r\n          GoogleMaps: GoogleLinks.getGoogleMapsCoordLink(data[0], data[1]),\r\n          GoogleStreetView: GoogleLinks.getGoogleStreetViewLink(\r\n            data[0],\r\n            data[1]\r\n          ),\r\n          OpenStreetMap: OsmLinks.getOpenStreetMapLink(data[0], data[1], 14),\r\n          Route:\r\n            '<span class=\"routing\"> <u>' +\r\n            this.languageService.translate.instant('igo.geo.seeRouting') +\r\n            '</u> </span>'\r\n        }),\r\n        meta: {\r\n          id: data[0].toString() + ',' + data[1].toString(),\r\n          title: roundedCoordString\r\n        }\r\n      },\r\n      meta: {\r\n        dataType: FEATURE,\r\n        id: data[0].toString() + ',' + data[1].toString(),\r\n        title: roundedCoordString,\r\n        titleHtml: roundedCoordString + subtitleHtml,\r\n        icon: 'map-marker',\r\n        score: 100 // every coord exists\r\n      }\r\n    };\r\n  }\r\n}\r\n"]}