@igo2/geo 1.12.0 → 1.13.0-alpha.1

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

@@ -0,0 +1,118 @@
+import { Injectable } from '@angular/core';
+import { stringToLonLat } from '../../map';
+import { sourceCanSearch, sourceCanReverseSearch, sourceCanReverseSearchAsSummary } from './search.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./search-source.service";
+import * as i2 from "../../map/shared/map.service";
+/**
+ * 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 {
+    constructor(searchSourceService, mapService) {
+        this.searchSourceService = searchSourceService;
+        this.mapService = mapService;
+    }
+    /**
+     * 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);
+        return this.reverseSearchSources(sources, lonLat, options || {});
+    }
+    /**
+     * 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) {
+        return sources.map((source) => {
+            return {
+                request: source.reverseSearch(lonLat, options),
+                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 !== '';
+    }
+}
+SearchService.ɵfac = function SearchService_Factory(t) { return new (t || SearchService)(i0.ɵɵinject(i1.SearchSourceService), i0.ɵɵinject(i2.MapService)); };
+SearchService.ɵ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 }]; }, 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":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\nimport { stringToLonLat } from '../../map';\r\nimport { MapService } from '../../map/shared/map.service';\r\n\r\nimport { SearchSource, TextSearch, ReverseSearch } 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 } from './search.interfaces';\r\nimport {\r\n  sourceCanSearch,\r\n  sourceCanReverseSearch,\r\n  sourceCanReverseSearchAsSummary\r\n} from './search.utils';\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  ) {}\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, { distance: response.radius, conf: response.conf });\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    return this.reverseSearchSources(sources, lonLat, options || {});\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  ): 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        ),\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/{esm2015/lib/search/shared/sources/cadastre.js → esm2020/lib/search/shared/sources/cadastre.mjs}

@@ -123,4 +123,4 @@ __decorate([
                 type: Inject,
                 args: ['options']
             }] }]; }, { search: [] }); })();
-//# 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 } from '../search.interfaces';\r\nimport { SearchSource, TextSearch } 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\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  @Cacheable({\r\n    maxCacheCount: 20\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.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(response: string, term: string): 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: '<span class=\"routing\"> <u>' + this.languageService.translate.instant('igo.geo.seeRouting') + '</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(),\r\n      coordinates: feature.getGeometry().getCoordinates()\r\n    };\r\n  }\r\n}\r\n"]}
+//# 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 } from '../search.interfaces';\r\nimport { SearchSource, TextSearch } 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\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  @Cacheable({\r\n    maxCacheCount: 20\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.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(response: string, term: string): 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: '<span class=\"routing\"> <u>' + this.languageService.translate.instant('igo.geo.seeRouting') + '</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(),\r\n      coordinates: (feature.getGeometry() as any).getCoordinates()\r\n    };\r\n  }\r\n}\r\n"]}