@igo2/geo 1.12.1 → 1.13.0-alpha.0

package/esm2020/lib/datasource/shared/datasources/wms-wfs.utils.mjs

@@ -0,0 +1,207 @@
+import { OgcFilterWriter } from '../../../filter/shared/ogc-filter';
+import * as OlFormat from 'ol/format';
+import olFormatGML2 from 'ol/format/GML2';
+import olFormatGML3 from 'ol/format/GML3';
+import olFormatGML32 from 'ol/format/GML32';
+import olFormatOSMXML from 'ol/format/OSMXML';
+export const defaultEpsg = 'EPSG:3857';
+export const defaultMaxFeatures = 5000;
+export const defaultWfsVersion = '2.0.0';
+export const defaultFieldNameGeometry = 'geometry';
+export const gmlRegex = new RegExp(/(.*)?gml(.*)?/gi);
+export const jsonRegex = new RegExp(/(.*)?json(.*)?/gi);
+/**
+ * This method build the WFS URL based on the layer property.
+ * @param options  WFSDataSourceOptions The common wfs datasource options interface
+ * @param extent  An extent like array [number, number, number, number]
+ * @param proj  olProjection
+ * @param ogcFilters  OgcFiltersOptions
+ * @returns A string representing the datasource options, based on filter and views
+ */
+export function buildUrl(options, extent, proj, ogcFilters, randomParam) {
+    const paramsWFS = options.paramsWFS;
+    const queryStringValues = formatWFSQueryString(options, undefined, options.paramsWFS.srsName);
+    let igoFilters;
+    if (ogcFilters && ogcFilters.enabled) {
+        igoFilters = ogcFilters.filters;
+    }
+    const ogcFilterWriter = new OgcFilterWriter();
+    const filterOrBox = ogcFilterWriter.buildFilter(igoFilters, extent, proj, ogcFilters.geometryName, options);
+    let filterOrPush = ogcFilterWriter.handleOgcFiltersAppliedValue(options, ogcFilters.geometryName, extent, proj);
+    let prefix = 'filter';
+    if (!filterOrPush) {
+        prefix = 'bbox';
+        filterOrPush = extent.join(',') + ',' + proj.getCode();
+    }
+    paramsWFS.xmlFilter = ogcFilters.advancedOgcFilters ? filterOrBox : `${prefix}=${filterOrPush}`;
+    let baseUrl = queryStringValues.find(f => f.name === 'getfeature').value;
+    const patternFilter = /(filter|bbox)=.*/gi;
+    baseUrl = patternFilter.test(paramsWFS.xmlFilter) ? `${baseUrl}&${paramsWFS.xmlFilter}` : baseUrl;
+    options.download = Object.assign({}, options.download, { dynamicUrl: baseUrl });
+    if (randomParam) {
+        baseUrl += `$&_t${new Date().getTime()}`;
+    }
+    return baseUrl.replace(/&&/g, '&');
+}
+/**
+ * This method build/standardize WFS call query params based on the layer property.
+ * @param wfsDataSourceOptions  WFSDataSourceOptions The common wfs datasource options interface
+ * @param count  Number: Used to control the number of feature. Used to bypass whe wfs datasource options interface (maxFeatures)
+ * @param epsg  String: Used to control the EPSG code (es: 'EPSG3857'). Used to bypass whe wfs datasource options interface (srsName)
+ * @param properties  String: Used to control the queried fields  (WFS service).
+ * @returns An array array of {name: '', value: ''} of predefined query params.
+ */
+export function formatWFSQueryString(dataSourceOptions, count, epsg, properties, startIndex = 0, forceDefaultOutputFormat = false) {
+    const versionWfs200 = '2.0.0'; // not the same usage as defaultWfsVersion.
+    const url = dataSourceOptions.urlWfs;
+    const paramsWFS = dataSourceOptions.paramsWFS;
+    const effectiveCount = count || defaultMaxFeatures;
+    const effectiveStartIndex = paramsWFS.version === versionWfs200 ? `startIndex=${startIndex}` : '';
+    const epsgCode = epsg || defaultEpsg;
+    let outputFormat = paramsWFS.outputFormat
+        ? `outputFormat=${paramsWFS.outputFormat}`
+        : '';
+    let version = paramsWFS.version
+        ? `version=${paramsWFS.version}`
+        : `version=${defaultWfsVersion}`;
+    const paramTypename = paramsWFS.version === versionWfs200 ? 'typenames' : 'typename';
+    const featureTypes = `${paramTypename}=${paramsWFS.featureTypes}`;
+    const paramMaxFeatures = paramsWFS.version === versionWfs200 ? 'count' : 'maxFeatures';
+    let cnt = count
+        ? `${paramMaxFeatures}=${effectiveCount}`
+        : paramsWFS.maxFeatures
+            ? `${paramMaxFeatures}=${paramsWFS.maxFeatures}`
+            : `${paramMaxFeatures}=${effectiveCount}`;
+    if (forceDefaultOutputFormat) {
+        outputFormat = '';
+        version = 'version=1.1.0';
+        cnt = cnt.replace('count', 'maxFeatures');
+    }
+    const srs = epsg
+        ? `srsname=${epsgCode}`
+        : paramsWFS.srsName
+            ? 'srsname=' + paramsWFS.srsName
+            : `srsname=${epsgCode}`;
+    let propertyName = '';
+    let valueReference = '';
+    if (properties) {
+        propertyName = `propertyName=${properties}`;
+        valueReference = `valueReference=${properties}`;
+    }
+    const sourceFields = dataSourceOptions.sourceFields;
+    if (!propertyName && sourceFields && sourceFields.length > 0) {
+        const fieldsNames = [];
+        dataSourceOptions.sourceFields.forEach(sourcefield => {
+            fieldsNames.push(sourcefield.name);
+        });
+        propertyName = `propertyName=${fieldsNames.join(',')},${paramsWFS.fieldNameGeometry}`;
+    }
+    const separator = url.indexOf('?') === -1 ? '?' : '&';
+    const getCapabilities = `${url}${separator}service=WFS&request=GetCapabilities&${version}`;
+    let getFeature = `${url}${separator}service=WFS&request=GetFeature&${version}&${featureTypes}&`;
+    getFeature += `${outputFormat}&${srs}&${cnt}&${propertyName}&${effectiveStartIndex}`;
+    let getpropertyvalue = `${url}?service=WFS&request=GetPropertyValue&version=${versionWfs200}&${featureTypes}&`;
+    getpropertyvalue += `&${cnt}&${valueReference}`;
+    return [
+        { name: 'outputformat', value: outputFormat },
+        { name: 'version', value: version },
+        { name: 'typename', value: featureTypes },
+        { name: 'count', value: cnt },
+        { name: 'srsname', value: srs },
+        { name: 'propertyname', value: propertyName },
+        { name: 'valuereference', value: valueReference },
+        { name: 'getcapabilities', value: getCapabilities.replace(/&&/g, '&') },
+        { name: 'getfeature', value: getFeature.replace(/&&/g, '&') },
+        { name: 'getpropertyvalue', value: getpropertyvalue.replace(/&&/g, '&') }
+    ];
+}
+/**
+ * Validate/Modify layer's wfs options based on :
+ * 1- an Openlayers's issue with GML provided from WFS. Refer to
+ * https://github.com/openlayers/openlayers/pull/6400
+ * 2- Set default values for optionals parameters.
+ * @param wfsDataSourceOptions  WFSDataSourceOptions The common wfs datasource options interface
+ * @returns An array array of {name: '', value: ''} of predefined query params.
+ */
+export function checkWfsParams(wfsDataSourceOptions, srcType) {
+    if (srcType && srcType === 'wfs') {
+        // reassignation of params to paramsWFS and url to urlWFS to have a common interface with wms-wfs datasources
+        wfsDataSourceOptions.paramsWFS = wfsDataSourceOptions.params;
+    }
+    const paramsWFS = wfsDataSourceOptions.paramsWFS;
+    wfsDataSourceOptions.urlWfs =
+        wfsDataSourceOptions.urlWfs || wfsDataSourceOptions.url;
+    paramsWFS.version = paramsWFS.version || defaultWfsVersion;
+    paramsWFS.fieldNameGeometry =
+        paramsWFS.fieldNameGeometry || defaultFieldNameGeometry;
+    paramsWFS.maxFeatures = paramsWFS.maxFeatures || defaultMaxFeatures;
+    let outputFormat;
+    if (paramsWFS.outputFormat) {
+        outputFormat = paramsWFS.outputFormat;
+    }
+    if (gmlRegex.test(outputFormat) || !outputFormat) {
+        paramsWFS.version = '1.1.0';
+    }
+    return Object.assign({}, wfsDataSourceOptions);
+}
+export function getFormatFromOptions(options) {
+    const wfsOptions = options;
+    let olFormatCls;
+    const outputFormat = wfsOptions.paramsWFS.outputFormat
+        ? wfsOptions.paramsWFS.outputFormat
+        : undefined;
+    if (!outputFormat) {
+        olFormatCls = OlFormat.WFS;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    if (OlFormat[outputFormat]) {
+        olFormatCls = OlFormat[outputFormat];
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    else if (outputFormat.toLowerCase().match('gml2')) {
+        olFormatCls = OlFormat.WFS;
+        return new olFormatCls({ ...wfsOptions.formatOptions, ...{ gmlFormat: olFormatGML2 } });
+    }
+    else if (outputFormat.toLowerCase().match('gml32')) {
+        olFormatCls = OlFormat.WFS;
+        return new olFormatCls({ ...wfsOptions.formatOptions, ...{ gmlFormat: olFormatGML32 } });
+    }
+    else if (outputFormat.toLowerCase().match('gml3')) {
+        olFormatCls = OlFormat.WFS;
+        return new olFormatCls({ ...wfsOptions.formatOptions, ...{ gmlFormat: olFormatGML3 } });
+    }
+    else if (outputFormat.toLowerCase().match('topojson')) {
+        olFormatCls = OlFormat.TopoJSON;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    else if (outputFormat.toLowerCase().match('geojson')) {
+        olFormatCls = OlFormat.GeoJSON;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    else if (outputFormat.toLowerCase().match('esrijson')) {
+        olFormatCls = OlFormat.EsriJSON;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    else if (outputFormat.toLowerCase().match('json')) {
+        olFormatCls = OlFormat.GeoJSON;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    else if (outputFormat.toLowerCase().match('gpx')) {
+        olFormatCls = OlFormat.GPX;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    else if (outputFormat.toLowerCase().match('WKT')) {
+        olFormatCls = OlFormat.WKT;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    else if (outputFormat.toLowerCase().match('osmxml')) {
+        olFormatCls = olFormatOSMXML;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    else if (outputFormat.toLowerCase().match('kml')) {
+        olFormatCls = OlFormat.KML;
+        return new olFormatCls(wfsOptions.formatOptions);
+    }
+    return new olFormatCls();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wms-wfs.utils.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/datasource/shared/datasources/wms-wfs.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { WFSDataSourceOptions } from './wfs-datasource.interface';\r\nimport { WMSDataSourceOptions } from './wms-datasource.interface';\r\nimport { OgcFiltersOptions } from '../../../filter/shared/ogc-filter.interface';\r\nimport { OgcFilterWriter } from '../../../filter/shared/ogc-filter';\r\n\r\nimport * as OlFormat from 'ol/format';\r\nimport olFormatGML2 from 'ol/format/GML2';\r\nimport olFormatGML3 from 'ol/format/GML3';\r\nimport olFormatGML32 from 'ol/format/GML32';\r\nimport olFormatOSMXML from 'ol/format/OSMXML';\r\nimport olProjection from 'ol/proj/Projection';\r\n\r\nexport const defaultEpsg = 'EPSG:3857';\r\nexport const defaultMaxFeatures = 5000;\r\nexport const defaultWfsVersion = '2.0.0';\r\nexport const defaultFieldNameGeometry = 'geometry';\r\nexport const gmlRegex = new RegExp(/(.*)?gml(.*)?/gi);\r\nexport const jsonRegex = new RegExp(/(.*)?json(.*)?/gi);\r\n\r\n\r\n/**\r\n * This method build the WFS URL based on the layer property.\r\n * @param options  WFSDataSourceOptions The common wfs datasource options interface\r\n * @param extent  An extent like array [number, number, number, number]\r\n * @param proj  olProjection\r\n * @param ogcFilters  OgcFiltersOptions\r\n * @returns A string representing the datasource options, based on filter and views\r\n */\r\nexport function buildUrl(\r\n  options: WFSDataSourceOptions,\r\n  extent,\r\n  proj: olProjection,\r\n  ogcFilters: OgcFiltersOptions,\r\n  randomParam?: boolean): string {\r\n  const paramsWFS = options.paramsWFS;\r\n  const queryStringValues = formatWFSQueryString(options, undefined, options.paramsWFS.srsName);\r\n  let igoFilters;\r\n  if (ogcFilters && ogcFilters.enabled) {\r\n    igoFilters = ogcFilters.filters;\r\n  }\r\n  const ogcFilterWriter = new OgcFilterWriter();\r\n  const filterOrBox = ogcFilterWriter.buildFilter(igoFilters, extent, proj, ogcFilters.geometryName, options);\r\n  let filterOrPush = ogcFilterWriter.handleOgcFiltersAppliedValue(options, ogcFilters.geometryName, extent, proj);\r\n\r\n  let prefix = 'filter';\r\n  if (!filterOrPush) {\r\n    prefix = 'bbox';\r\n    filterOrPush = extent.join(',') + ',' + proj.getCode();\r\n  }\r\n\r\n  paramsWFS.xmlFilter = ogcFilters.advancedOgcFilters ? filterOrBox : `${prefix}=${filterOrPush}`;\r\n  let baseUrl = queryStringValues.find(f => f.name === 'getfeature').value;\r\n  const patternFilter = /(filter|bbox)=.*/gi;\r\n  baseUrl = patternFilter.test(paramsWFS.xmlFilter) ? `${baseUrl}&${paramsWFS.xmlFilter}` : baseUrl;\r\n  options.download = Object.assign({}, options.download, { dynamicUrl: baseUrl });\r\n  if (randomParam) {\r\n    baseUrl += `$&_t${new Date().getTime()}`;\r\n  }\r\n  return baseUrl.replace(/&&/g, '&');\r\n}\r\n\r\n\r\n/**\r\n * This method build/standardize WFS call query params based on the layer property.\r\n * @param wfsDataSourceOptions  WFSDataSourceOptions The common wfs datasource options interface\r\n * @param count  Number: Used to control the number of feature. Used to bypass whe wfs datasource options interface (maxFeatures)\r\n * @param epsg  String: Used to control the EPSG code (es: 'EPSG3857'). Used to bypass whe wfs datasource options interface (srsName)\r\n * @param properties  String: Used to control the queried fields  (WFS service).\r\n * @returns An array array of {name: '', value: ''} of predefined query params.\r\n */\r\nexport function formatWFSQueryString(\r\n  dataSourceOptions: WFSDataSourceOptions | WMSDataSourceOptions,\r\n  count?: number,\r\n  epsg?: string,\r\n  properties?: string,\r\n  startIndex: number = 0,\r\n  forceDefaultOutputFormat: boolean = false\r\n): { name: string; value: string }[] {\r\n  const versionWfs200 = '2.0.0'; // not the same usage as defaultWfsVersion.\r\n  const url = dataSourceOptions.urlWfs;\r\n  const paramsWFS = dataSourceOptions.paramsWFS;\r\n  const effectiveCount = count || defaultMaxFeatures;\r\n  const effectiveStartIndex = paramsWFS.version === versionWfs200 ? `startIndex=${startIndex}` : '';\r\n  const epsgCode = epsg || defaultEpsg;\r\n  let outputFormat = paramsWFS.outputFormat\r\n    ? `outputFormat=${paramsWFS.outputFormat}`\r\n    : '';\r\n  let version = paramsWFS.version\r\n    ? `version=${paramsWFS.version}`\r\n    : `version=${defaultWfsVersion}`;\r\n  const paramTypename =\r\n    paramsWFS.version === versionWfs200 ? 'typenames' : 'typename';\r\n  const featureTypes = `${paramTypename}=${paramsWFS.featureTypes}`;\r\n  const paramMaxFeatures =\r\n    paramsWFS.version === versionWfs200 ? 'count' : 'maxFeatures';\r\n  let cnt = count\r\n    ? `${paramMaxFeatures}=${effectiveCount}`\r\n    : paramsWFS.maxFeatures\r\n    ? `${paramMaxFeatures}=${paramsWFS.maxFeatures}`\r\n    : `${paramMaxFeatures}=${effectiveCount}`;\r\n  if (forceDefaultOutputFormat) {\r\n      outputFormat = '';\r\n      version = 'version=1.1.0';\r\n      cnt = cnt.replace('count', 'maxFeatures');\r\n    }\r\n\r\n  const srs = epsg\r\n    ? `srsname=${epsgCode}`\r\n    : paramsWFS.srsName\r\n    ? 'srsname=' + paramsWFS.srsName\r\n    : `srsname=${epsgCode}`;\r\n\r\n  let propertyName = '';\r\n  let valueReference = '';\r\n  if (properties) {\r\n    propertyName = `propertyName=${properties}`;\r\n    valueReference = `valueReference=${properties}`;\r\n  }\r\n  const sourceFields = dataSourceOptions.sourceFields;\r\n  if (!propertyName && sourceFields && sourceFields.length > 0) {\r\n    const fieldsNames = [];\r\n    dataSourceOptions.sourceFields.forEach(sourcefield => {\r\n      fieldsNames.push(sourcefield.name);\r\n    });\r\n    propertyName = `propertyName=${fieldsNames.join(',')},${\r\n      paramsWFS.fieldNameGeometry\r\n    }`;\r\n  }\r\n\r\n  const separator = url.indexOf('?') === -1 ? '?' : '&';\r\n  const getCapabilities = `${url}${separator}service=WFS&request=GetCapabilities&${version}`;\r\n  let getFeature = `${url}${separator}service=WFS&request=GetFeature&${version}&${featureTypes}&`;\r\n  getFeature += `${outputFormat}&${srs}&${cnt}&${propertyName}&${effectiveStartIndex}`;\r\n\r\n  let getpropertyvalue = `${url}?service=WFS&request=GetPropertyValue&version=${versionWfs200}&${featureTypes}&`;\r\n  getpropertyvalue += `&${cnt}&${valueReference}`;\r\n\r\n  return [\r\n    { name: 'outputformat', value: outputFormat },\r\n    { name: 'version', value: version },\r\n    { name: 'typename', value: featureTypes },\r\n    { name: 'count', value: cnt },\r\n    { name: 'srsname', value: srs },\r\n    { name: 'propertyname', value: propertyName },\r\n    { name: 'valuereference', value: valueReference },\r\n    { name: 'getcapabilities', value: getCapabilities.replace(/&&/g, '&') },\r\n    { name: 'getfeature', value: getFeature.replace(/&&/g, '&') },\r\n    { name: 'getpropertyvalue', value: getpropertyvalue.replace(/&&/g, '&') }\r\n  ];\r\n}\r\n\r\n/**\r\n * Validate/Modify layer's wfs options based on :\r\n * 1- an Openlayers's issue with GML provided from WFS. Refer to\r\n * https://github.com/openlayers/openlayers/pull/6400\r\n * 2- Set default values for optionals parameters.\r\n * @param wfsDataSourceOptions  WFSDataSourceOptions The common wfs datasource options interface\r\n * @returns An array array of {name: '', value: ''} of predefined query params.\r\n */\r\nexport function checkWfsParams(wfsDataSourceOptions, srcType?: string) {\r\n  if (srcType && srcType === 'wfs') {\r\n    // reassignation of params to paramsWFS and url to urlWFS to have a common interface with wms-wfs datasources\r\n    wfsDataSourceOptions.paramsWFS = wfsDataSourceOptions.params;\r\n  }\r\n\r\n  const paramsWFS = wfsDataSourceOptions.paramsWFS;\r\n  wfsDataSourceOptions.urlWfs =\r\n    wfsDataSourceOptions.urlWfs || wfsDataSourceOptions.url;\r\n\r\n  paramsWFS.version = paramsWFS.version || defaultWfsVersion;\r\n  paramsWFS.fieldNameGeometry =\r\n    paramsWFS.fieldNameGeometry || defaultFieldNameGeometry;\r\n  paramsWFS.maxFeatures = paramsWFS.maxFeatures || defaultMaxFeatures;\r\n\r\n  let outputFormat;\r\n  if (paramsWFS.outputFormat) {\r\n    outputFormat = paramsWFS.outputFormat;\r\n  }\r\n\r\n  if (gmlRegex.test(outputFormat) || !outputFormat) {\r\n    paramsWFS.version = '1.1.0';\r\n  }\r\n  return Object.assign({}, wfsDataSourceOptions);\r\n}\r\n\r\nexport function getFormatFromOptions(\r\n  options: WFSDataSourceOptions | WMSDataSourceOptions\r\n) {\r\n  const wfsOptions = options as WFSDataSourceOptions;\r\n\r\n  let olFormatCls;\r\n  const outputFormat = wfsOptions.paramsWFS.outputFormat\r\n    ? wfsOptions.paramsWFS.outputFormat\r\n    : undefined;\r\n\r\n  if (!outputFormat) {\r\n    olFormatCls = OlFormat.WFS;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  }\r\n\r\n  if (OlFormat[outputFormat]) {\r\n    olFormatCls = OlFormat[outputFormat];\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  } else if (outputFormat.toLowerCase().match('gml2')) {\r\n    olFormatCls = OlFormat.WFS;\r\n    return new olFormatCls({ ...wfsOptions.formatOptions, ... { gmlFormat: olFormatGML2 }});\r\n  } else if (outputFormat.toLowerCase().match('gml32')) {\r\n    olFormatCls = OlFormat.WFS;\r\n    return new olFormatCls({ ...wfsOptions.formatOptions, ... { gmlFormat: olFormatGML32 }});\r\n  } else if (outputFormat.toLowerCase().match('gml3')) {\r\n    olFormatCls = OlFormat.WFS;\r\n    return new olFormatCls({ ...wfsOptions.formatOptions, ... { gmlFormat: olFormatGML3 }});\r\n  } else if (outputFormat.toLowerCase().match('topojson')) {\r\n    olFormatCls = OlFormat.TopoJSON;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  } else if (outputFormat.toLowerCase().match('geojson')) {\r\n    olFormatCls = OlFormat.GeoJSON;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  } else if (outputFormat.toLowerCase().match('esrijson')) {\r\n    olFormatCls = OlFormat.EsriJSON;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  } else if (outputFormat.toLowerCase().match('json')) {\r\n    olFormatCls = OlFormat.GeoJSON;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  } else if (outputFormat.toLowerCase().match('gpx')) {\r\n    olFormatCls = OlFormat.GPX;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  } else if (outputFormat.toLowerCase().match('WKT')) {\r\n    olFormatCls = OlFormat.WKT;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  } else if (outputFormat.toLowerCase().match('osmxml')) {\r\n    olFormatCls = olFormatOSMXML;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  } else if (outputFormat.toLowerCase().match('kml')) {\r\n    olFormatCls = OlFormat.KML;\r\n    return new olFormatCls(wfsOptions.formatOptions);\r\n  }\r\n\r\n  return new olFormatCls();\r\n}\r\n"]}

package/esm2020/lib/datasource/shared/datasources/wmts-datasource.interface.mjs

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

package/esm2020/lib/datasource/shared/datasources/wmts-datasource.mjs

@@ -0,0 +1,16 @@
+import olSourceWMTS from 'ol/source/WMTS';
+import { createDefaultTileGrid } from '../../utils/tilegrid';
+import { DataSource } from './datasource';
+export class WMTSDataSource extends DataSource {
+    constructor(options) {
+        super(options);
+    }
+    createOlSource() {
+        const sourceOptions = Object.assign({
+            tileGrid: createDefaultTileGrid(this.options.projection)
+        }, this.options);
+        return new olSourceWMTS(sourceOptions);
+    }
+    onUnwatch() { }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid210cy1kYXRhc291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvZGF0YXNvdXJjZS9zaGFyZWQvZGF0YXNvdXJjZXMvd210cy1kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sWUFBWSxNQUFNLGdCQUFnQixDQUFDO0FBRTFDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzdELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFHMUMsTUFBTSxPQUFPLGNBQWUsU0FBUSxVQUFVO0lBSTVDLFlBQVksT0FBOEI7UUFDeEMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2pCLENBQUM7SUFFUyxjQUFjO1FBQ3RCLE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQ2pDO1lBQ0UsUUFBUSxFQUFFLHFCQUFxQixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBb0IsQ0FBQztTQUNuRSxFQUNELElBQUksQ0FBQyxPQUFPLENBQ0YsQ0FBQztRQUViLE9BQU8sSUFBSSxZQUFZLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDekMsQ0FBQztJQUVNLFNBQVMsS0FBSSxDQUFDO0NBRXRCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT3B0aW9ucyB9IGZyb20gJ29sL3NvdXJjZS9XTVRTJztcclxuaW1wb3J0IG9sU291cmNlV01UUyBmcm9tICdvbC9zb3VyY2UvV01UUyc7XHJcblxyXG5pbXBvcnQgeyBjcmVhdGVEZWZhdWx0VGlsZUdyaWQgfSBmcm9tICcuLi8uLi91dGlscy90aWxlZ3JpZCc7XHJcbmltcG9ydCB7IERhdGFTb3VyY2UgfSBmcm9tICcuL2RhdGFzb3VyY2UnO1xyXG5pbXBvcnQgeyBXTVRTRGF0YVNvdXJjZU9wdGlvbnMgfSBmcm9tICcuL3dtdHMtZGF0YXNvdXJjZS5pbnRlcmZhY2UnO1xyXG5cclxuZXhwb3J0IGNsYXNzIFdNVFNEYXRhU291cmNlIGV4dGVuZHMgRGF0YVNvdXJjZSB7XHJcbiAgcHVibGljIG9wdGlvbnM6IFdNVFNEYXRhU291cmNlT3B0aW9ucztcclxuICBwdWJsaWMgb2w6IG9sU291cmNlV01UUztcclxuXHJcbiAgY29uc3RydWN0b3Iob3B0aW9uczogV01UU0RhdGFTb3VyY2VPcHRpb25zKSB7XHJcbiAgICBzdXBlcihvcHRpb25zKTtcclxuICB9XHJcblxyXG4gIHByb3RlY3RlZCBjcmVhdGVPbFNvdXJjZSgpOiBvbFNvdXJjZVdNVFMge1xyXG4gICAgY29uc3Qgc291cmNlT3B0aW9ucyA9IE9iamVjdC5hc3NpZ24oXHJcbiAgICAgIHtcclxuICAgICAgICB0aWxlR3JpZDogY3JlYXRlRGVmYXVsdFRpbGVHcmlkKHRoaXMub3B0aW9ucy5wcm9qZWN0aW9uIGFzIHN0cmluZylcclxuICAgICAgfSxcclxuICAgICAgdGhpcy5vcHRpb25zXHJcbiAgICApIGFzIE9wdGlvbnM7XHJcblxyXG4gICAgcmV0dXJuIG5ldyBvbFNvdXJjZVdNVFMoc291cmNlT3B0aW9ucyk7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgb25VbndhdGNoKCkge31cclxuXHJcbn1cclxuIl19

package/esm2020/lib/datasource/shared/datasources/xyz-datasource.interface.mjs

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

package/esm2020/lib/datasource/shared/datasources/xyz-datasource.mjs

@@ -0,0 +1,9 @@
+import olSourceXYZ from 'ol/source/XYZ';
+import { DataSource } from './datasource';
+export class XYZDataSource extends DataSource {
+    createOlSource() {
+        return new olSourceXYZ(this.options);
+    }
+    onUnwatch() { }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHl6LWRhdGFzb3VyY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kYXRhc291cmNlL3NoYXJlZC9kYXRhc291cmNlcy94eXotZGF0YXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFdBQVcsTUFBTSxlQUFlLENBQUM7QUFFeEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUcxQyxNQUFNLE9BQU8sYUFBYyxTQUFRLFVBQVU7SUFJakMsY0FBYztRQUN0QixPQUFPLElBQUksV0FBVyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUN2QyxDQUFDO0lBRU0sU0FBUyxLQUFJLENBQUM7Q0FFdEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgb2xTb3VyY2VYWVogZnJvbSAnb2wvc291cmNlL1hZWic7XHJcblxyXG5pbXBvcnQgeyBEYXRhU291cmNlIH0gZnJvbSAnLi9kYXRhc291cmNlJztcclxuaW1wb3J0IHsgWFlaRGF0YVNvdXJjZU9wdGlvbnMgfSBmcm9tICcuL3h5ei1kYXRhc291cmNlLmludGVyZmFjZSc7XHJcblxyXG5leHBvcnQgY2xhc3MgWFlaRGF0YVNvdXJjZSBleHRlbmRzIERhdGFTb3VyY2Uge1xyXG4gIHB1YmxpYyBvcHRpb25zOiBYWVpEYXRhU291cmNlT3B0aW9ucztcclxuICBwdWJsaWMgb2w6IG9sU291cmNlWFlaO1xyXG5cclxuICBwcm90ZWN0ZWQgY3JlYXRlT2xTb3VyY2UoKTogb2xTb3VyY2VYWVoge1xyXG4gICAgcmV0dXJuIG5ldyBvbFNvdXJjZVhZWih0aGlzLm9wdGlvbnMpO1xyXG4gIH1cclxuXHJcbiAgcHVibGljIG9uVW53YXRjaCgpIHt9XHJcblxyXG59XHJcbiJdfQ==

package/esm2020/lib/datasource/shared/index.mjs

@@ -0,0 +1,5 @@
+export * from './datasources';
+export * from './datasource.service';
+export * from './capabilities.service';
+export * from './options';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kYXRhc291cmNlL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RhdGFzb3VyY2VzJztcclxuZXhwb3J0ICogZnJvbSAnLi9kYXRhc291cmNlLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NhcGFiaWxpdGllcy5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9vcHRpb25zJztcclxuIl19

package/esm2020/lib/datasource/shared/options/index.mjs

@@ -0,0 +1,5 @@
+export * from './options.service';
+export * from './options-api.service';
+export * from './options-api.interface';
+export * from './options-api.providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9kYXRhc291cmNlL3NoYXJlZC9vcHRpb25zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL29wdGlvbnMuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vb3B0aW9ucy1hcGkuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vb3B0aW9ucy1hcGkuaW50ZXJmYWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9vcHRpb25zLWFwaS5wcm92aWRlcnMnO1xyXG4iXX0=

package/esm2020/lib/datasource/shared/options/options-api.interface.mjs

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

package/esm2020/lib/datasource/shared/options/options-api.providers.mjs

@@ -0,0 +1,15 @@
+import { HttpClient } from '@angular/common/http';
+import { ConfigService } from '@igo2/core';
+import { OptionsService } from './options.service';
+import { OptionsApiService } from './options-api.service';
+export function optionsApiFactory(http, configService) {
+    return new OptionsApiService(http, configService.getConfig('optionsApi'));
+}
+export function provideOptionsApi() {
+    return {
+        provide: OptionsService,
+        useFactory: optionsApiFactory,
+        deps: [HttpClient, ConfigService]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy1hcGkucHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvZGF0YXNvdXJjZS9zaGFyZWQvb3B0aW9ucy9vcHRpb25zLWFwaS5wcm92aWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRWxELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFM0MsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRTFELE1BQU0sVUFBVSxpQkFBaUIsQ0FDL0IsSUFBZ0IsRUFDaEIsYUFBNEI7SUFFNUIsT0FBTyxJQUFJLGlCQUFpQixDQUMxQixJQUFJLEVBQ0osYUFBYSxDQUFDLFNBQVMsQ0FBQyxZQUFZLENBQUMsQ0FDdEMsQ0FBQztBQUNKLENBQUM7QUFFRCxNQUFNLFVBQVUsaUJBQWlCO0lBQy9CLE9BQU87UUFDTCxPQUFPLEVBQUUsY0FBYztRQUN2QixVQUFVLEVBQUUsaUJBQWlCO1FBQzdCLElBQUksRUFBRSxDQUFDLFVBQVUsRUFBRSxhQUFhLENBQUM7S0FDbEMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwQ2xpZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xyXG5cclxuaW1wb3J0IHsgQ29uZmlnU2VydmljZSB9IGZyb20gJ0BpZ28yL2NvcmUnO1xyXG5cclxuaW1wb3J0IHsgT3B0aW9uc1NlcnZpY2UgfSBmcm9tICcuL29wdGlvbnMuc2VydmljZSc7XHJcbmltcG9ydCB7IE9wdGlvbnNBcGlTZXJ2aWNlIH0gZnJvbSAnLi9vcHRpb25zLWFwaS5zZXJ2aWNlJztcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBvcHRpb25zQXBpRmFjdG9yeShcclxuICBodHRwOiBIdHRwQ2xpZW50LFxyXG4gIGNvbmZpZ1NlcnZpY2U6IENvbmZpZ1NlcnZpY2VcclxuKSB7XHJcbiAgcmV0dXJuIG5ldyBPcHRpb25zQXBpU2VydmljZShcclxuICAgIGh0dHAsXHJcbiAgICBjb25maWdTZXJ2aWNlLmdldENvbmZpZygnb3B0aW9uc0FwaScpLFxyXG4gICk7XHJcbn1cclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlT3B0aW9uc0FwaSgpIHtcclxuICByZXR1cm4ge1xyXG4gICAgcHJvdmlkZTogT3B0aW9uc1NlcnZpY2UsXHJcbiAgICB1c2VGYWN0b3J5OiBvcHRpb25zQXBpRmFjdG9yeSxcclxuICAgIGRlcHM6IFtIdHRwQ2xpZW50LCBDb25maWdTZXJ2aWNlXVxyXG4gIH07XHJcbn1cclxuIl19

package/esm2020/lib/datasource/shared/options/options-api.service.mjs

@@ -0,0 +1,81 @@
+import { Injectable, Inject } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { OptionsService } from './options.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class OptionsApiService extends OptionsService {
+    constructor(http, options = {}) {
+        super();
+        this.http = http;
+        this.urlApi = options.url || this.urlApi;
+        this.provideContextUri = options.provideContextUri || this.provideContextUri;
+    }
+    getWMSOptions(baseOptions, detailedContextUri) {
+        if (!this.urlApi) {
+            return of({});
+        }
+        let params = new HttpParams({
+            fromObject: {
+                type: baseOptions.type,
+                url: baseOptions.url,
+                layers: baseOptions.params.LAYERS
+            }
+        });
+        if (detailedContextUri && this.provideContextUri) {
+            params = params.append('context', detailedContextUri);
+        }
+        const request = this.http.get(this.urlApi, {
+            params
+        });
+        return request.pipe(map((res) => {
+            if (!res || !res.sourceOptions) {
+                return {};
+            }
+            if (res.layerOptions) {
+                res.sourceOptions._layerOptionsFromSource = res.layerOptions;
+            }
+            return res.sourceOptions;
+        }));
+    }
+    getArcgisRestOptions(baseOptions, detailedContextUri) {
+        if (!this.urlApi) {
+            return of({});
+        }
+        let params = new HttpParams({
+            fromObject: {
+                type: baseOptions.type,
+                url: baseOptions.url,
+                layers: baseOptions.layer
+            }
+        });
+        if (detailedContextUri && this.provideContextUri) {
+            params = params.append('context', detailedContextUri);
+        }
+        const request = this.http.get(this.urlApi, {
+            params
+        });
+        return request.pipe(map((res) => {
+            if (!res || !res.sourceOptions) {
+                return {};
+            }
+            if (res.layerOptions) {
+                res.sourceOptions._layerOptionsFromSource = res.layerOptions;
+            }
+            return res.sourceOptions;
+        }));
+    }
+}
+OptionsApiService.ɵfac = function OptionsApiService_Factory(t) { return new (t || OptionsApiService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject('options')); };
+OptionsApiService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: OptionsApiService, factory: OptionsApiService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OptionsApiService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                type: Inject,
+                args: ['options']
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options-api.service.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/datasource/shared/options/options-api.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAc,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAQrC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;;;AAMnD,MAAM,OAAO,iBAAkB,SAAQ,cAAc;IAInD,YACU,IAAgB,EACL,UAA6B,EAAE;QAElD,KAAK,EAAE,CAAC;QAHA,SAAI,GAAJ,IAAI,CAAY;QAIxB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC;QACzC,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC;IAC/E,CAAC;IAED,aAAa,CACX,WAAiC,EACjC,kBAA2B;QAE3B,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,OAAO,EAAE,CAAC,EAA0B,CAAC,CAAC;SACvC;QACD,IAAI,MAAM,GAAG,IAAI,UAAU,CAAC;YAC1B,UAAU,EAAE;gBACV,IAAI,EAAE,WAAW,CAAC,IAAI;gBACtB,GAAG,EAAE,WAAW,CAAC,GAAG;gBACpB,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM;aAClC;SACF,CAAC,CAAC;QAEH,IAAI,kBAAkB,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAChD,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;SACvD;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE;YACzC,MAAM;SACP,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC,IAAI,CACjB,GAAG,CACD,CAAC,GAGA,EAAE,EAAE;YACH,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE;gBAC9B,OAAO,EAA0B,CAAC;aACnC;YACD,IAAI,GAAG,CAAC,YAAY,EAAE;gBACpB,GAAG,CAAC,aAAa,CAAC,uBAAuB,GAAG,GAAG,CAAC,YAAY,CAAC;aAC9D;YACD,OAAO,GAAG,CAAC,aAAa,CAAC;QAC3B,CAAC,CACF,CACF,CAAC;IACJ,CAAC;IAGD,oBAAoB,CAClB,WAA6G,EAC7G,kBAA2B;QAE3B,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,OAAO,EAAE,CAAC,EAAsC,CAAC,CAAC;SACnD;QACD,IAAI,MAAM,GAAG,IAAI,UAAU,CAAC;YAC1B,UAAU,EAAE;gBACV,IAAI,EAAE,WAAW,CAAC,IAAI;gBACtB,GAAG,EAAE,WAAW,CAAC,GAAG;gBACpB,MAAM,EAAE,WAAW,CAAC,KAAK;aAC1B;SACF,CAAC,CAAC;QAEH,IAAI,kBAAkB,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAChD,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;SACvD;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE;YACzC,MAAM;SACP,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC,IAAI,CACjB,GAAG,CACD,CAAC,GAGA,EAAE,EAAE;YACH,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE;gBAC9B,OAAO,EAAsG,CAAC;aAC/G;YACD,IAAI,GAAG,CAAC,YAAY,EAAE;gBACpB,GAAG,CAAC,aAAa,CAAC,uBAAuB,GAAG,GAAG,CAAC,YAAY,CAAC;aAC9D;YACD,OAAO,GAAG,CAAC,aAAa,CAAC;QAC3B,CAAC,CACF,CACF,CAAC;IACJ,CAAC;;kFA9FU,iBAAiB,0CAMlB,SAAS;uEANR,iBAAiB,WAAjB,iBAAiB,mBAFhB,MAAM;uFAEP,iBAAiB;cAH7B,UAAU;eAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;sBAOI,MAAM;uBAAC,SAAS","sourcesContent":["import { Injectable, Inject } from '@angular/core';\r\nimport { HttpClient, HttpParams } from '@angular/common/http';\r\nimport { Observable, of } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\n\r\nimport {\r\n  ArcGISRestDataSourceOptions,\r\n  ArcGISRestImageDataSourceOptions,\r\n  TileArcGISRestDataSourceOptions,\r\n  WMSDataSourceOptions\r\n} from '../datasources';\r\nimport { OptionsService } from './options.service';\r\nimport { OptionsApiOptions } from './options-api.interface';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class OptionsApiService extends OptionsService {\r\n  private urlApi: string;\r\n  private provideContextUri: boolean;\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    @Inject('options') options: OptionsApiOptions = {}\r\n  ) {\r\n    super();\r\n    this.urlApi = options.url || this.urlApi;\r\n    this.provideContextUri = options.provideContextUri || this.provideContextUri;\r\n  }\r\n\r\n  getWMSOptions(\r\n    baseOptions: WMSDataSourceOptions,\r\n    detailedContextUri?: string\r\n  ): Observable<WMSDataSourceOptions> {\r\n    if (!this.urlApi) {\r\n      return of({} as WMSDataSourceOptions);\r\n    }\r\n    let params = new HttpParams({\r\n      fromObject: {\r\n        type: baseOptions.type,\r\n        url: baseOptions.url,\r\n        layers: baseOptions.params.LAYERS\r\n      }\r\n    });\r\n\r\n    if (detailedContextUri && this.provideContextUri) {\r\n      params = params.append('context', detailedContextUri);\r\n    }\r\n\r\n    const request = this.http.get(this.urlApi, {\r\n      params\r\n    });\r\n\r\n    return request.pipe(\r\n      map(\r\n        (res: {\r\n          sourceOptions: WMSDataSourceOptions;\r\n          layerOptions: { [keys: string]: string };\r\n        }) => {\r\n          if (!res || !res.sourceOptions) {\r\n            return {} as WMSDataSourceOptions;\r\n          }\r\n          if (res.layerOptions) {\r\n            res.sourceOptions._layerOptionsFromSource = res.layerOptions;\r\n          }\r\n          return res.sourceOptions;\r\n        }\r\n      )\r\n    );\r\n  }\r\n\r\n\r\n  getArcgisRestOptions(\r\n    baseOptions: ArcGISRestDataSourceOptions | ArcGISRestImageDataSourceOptions | TileArcGISRestDataSourceOptions,\r\n    detailedContextUri?: string\r\n  ): Observable<ArcGISRestDataSourceOptions | ArcGISRestImageDataSourceOptions | TileArcGISRestDataSourceOptions> {\r\n    if (!this.urlApi) {\r\n      return of({} as ArcGISRestImageDataSourceOptions);\r\n    }\r\n    let params = new HttpParams({\r\n      fromObject: {\r\n        type: baseOptions.type,\r\n        url: baseOptions.url,\r\n        layers: baseOptions.layer\r\n      }\r\n    });\r\n\r\n    if (detailedContextUri && this.provideContextUri) {\r\n      params = params.append('context', detailedContextUri);\r\n    }\r\n\r\n    const request = this.http.get(this.urlApi, {\r\n      params\r\n    });\r\n\r\n    return request.pipe(\r\n      map(\r\n        (res: {\r\n          sourceOptions: ArcGISRestDataSourceOptions | ArcGISRestImageDataSourceOptions | TileArcGISRestDataSourceOptions;\r\n          layerOptions: { [keys: string]: string };\r\n        }) => {\r\n          if (!res || !res.sourceOptions) {\r\n            return {} as ArcGISRestDataSourceOptions | ArcGISRestImageDataSourceOptions | TileArcGISRestDataSourceOptions;\r\n          }\r\n          if (res.layerOptions) {\r\n            res.sourceOptions._layerOptionsFromSource = res.layerOptions;\r\n          }\r\n          return res.sourceOptions;\r\n        }\r\n      )\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2020/lib/datasource/shared/options/options.service.mjs

@@ -0,0 +1,3 @@
+export class OptionsService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvZGF0YXNvdXJjZS9zaGFyZWQvb3B0aW9ucy9vcHRpb25zLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsTUFBTSxPQUFnQixjQUFjO0NBU25DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xyXG5cclxuaW1wb3J0IHtcclxuICBBcmNHSVNSZXN0RGF0YVNvdXJjZU9wdGlvbnMsXHJcbiAgQXJjR0lTUmVzdEltYWdlRGF0YVNvdXJjZU9wdGlvbnMsXHJcbiAgVGlsZUFyY0dJU1Jlc3REYXRhU291cmNlT3B0aW9ucyxcclxuICBXTVNEYXRhU291cmNlT3B0aW9uc1xyXG59IGZyb20gJy4uL2RhdGFzb3VyY2VzJztcclxuXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBPcHRpb25zU2VydmljZSB7XHJcbiAgYWJzdHJhY3QgZ2V0V01TT3B0aW9ucyhcclxuICAgIF9iYXNlT3B0aW9uczogV01TRGF0YVNvdXJjZU9wdGlvbnMsXHJcbiAgICBkZXRhaWxlZENvbnRleHRVcmk/OiBzdHJpbmdcclxuICApOiBPYnNlcnZhYmxlPFdNU0RhdGFTb3VyY2VPcHRpb25zPjtcclxuICBhYnN0cmFjdCBnZXRBcmNnaXNSZXN0T3B0aW9ucyhcclxuICAgIF9iYXNlT3B0aW9uczogQXJjR0lTUmVzdERhdGFTb3VyY2VPcHRpb25zIHwgQXJjR0lTUmVzdEltYWdlRGF0YVNvdXJjZU9wdGlvbnMgfCBUaWxlQXJjR0lTUmVzdERhdGFTb3VyY2VPcHRpb25zLFxyXG4gICAgZGV0YWlsZWRDb250ZXh0VXJpPzogc3RyaW5nXHJcbiAgKTogT2JzZXJ2YWJsZTxBcmNHSVNSZXN0RGF0YVNvdXJjZU9wdGlvbnMgfCBBcmNHSVNSZXN0SW1hZ2VEYXRhU291cmNlT3B0aW9ucyB8IFRpbGVBcmNHSVNSZXN0RGF0YVNvdXJjZU9wdGlvbnM+O1xyXG59XHJcbiJdfQ==