@igo2/geo 1.11.1 → 1.13.0-alpha.0

package/esm2020/lib/layer/shared/layers/vectortile-layer.mjs

@@ -0,0 +1,104 @@
+import olLayerVectorTile from 'ol/layer/VectorTile';
+import { Layer } from './layer';
+import { TileWatcher } from '../../utils';
+export class VectorTileLayer extends Layer {
+    constructor(options, messageService, authInterceptor) {
+        super(options, messageService, authInterceptor);
+        this.messageService = messageService;
+        this.authInterceptor = authInterceptor;
+        this.watcher = new TileWatcher(this);
+        this.status$ = this.watcher.status$;
+    }
+    createOlLayer() {
+        const olOptions = Object.assign({}, this.options, {
+            source: this.options.source.ol
+        });
+        const vectorTile = new olLayerVectorTile(olOptions);
+        const vectorTileSource = vectorTile.getSource();
+        vectorTileSource.setTileLoadFunction((tile, url) => {
+            const loader = this.customLoader(url, tile.getFormat(), this.authInterceptor, tile.onLoad.bind(tile));
+            if (loader) {
+                tile.setLoader(loader);
+            }
+        });
+        return vectorTile;
+    }
+    /**
+     * Custom loader for vector tile layer. Modified from the loadFeaturesXhr function in ol\featureloader.js
+     * @internal
+     * @param url the url string or function to retrieve the data
+     * @param format the format of the tile
+     * @param interceptor the interceptor of the data
+     * @param success On success event action to trigger
+     * @param failure On failure event action to trigger TODO
+     */
+    customLoader(url, format, interceptor, success, failure) {
+        return ((extent, resolution, projection) => {
+            const xhr = new XMLHttpRequest();
+            let modifiedUrl = url;
+            if (typeof url !== 'function') {
+                const alteredUrlWithKeyAuth = interceptor.alterUrlWithKeyAuth(url);
+                if (alteredUrlWithKeyAuth) {
+                    modifiedUrl = alteredUrlWithKeyAuth;
+                }
+            }
+            else {
+                modifiedUrl = url(extent, resolution, projection);
+            }
+            xhr.open('GET', modifiedUrl);
+            if (interceptor) {
+                interceptor.interceptXhr(xhr, modifiedUrl);
+            }
+            if (format.getType() === 'arraybuffer') {
+                xhr.responseType = 'arraybuffer';
+            }
+            xhr.onload = (event) => {
+                if (!xhr.status || xhr.status >= 200 && xhr.status < 300) {
+                    const type = format.getType();
+                    let source;
+                    if (type === 'json' || type === 'text') {
+                        source = xhr.responseText;
+                    }
+                    else if (type === 'xml') {
+                        source = xhr.responseXML;
+                        if (!source) {
+                            source = new DOMParser().parseFromString(xhr.responseText, 'application/xml');
+                        }
+                    }
+                    else if (type === 'arraybuffer') {
+                        source = xhr.response;
+                    }
+                    if (source) {
+                        success.call(this, format.readFeatures(source, {
+                            extent,
+                            featureProjection: projection
+                        }), format.readProjection(source));
+                    }
+                    else {
+                        // TODO
+                        failure.call(this);
+                    }
+                }
+                else {
+                    // TODO
+                    failure.call(this);
+                }
+            };
+            xhr.onerror = () => {
+                // TODO
+                failure.call(this);
+            };
+            xhr.send();
+        });
+    }
+    setMap(map) {
+        if (map === undefined) {
+            this.watcher.unsubscribe();
+        }
+        else {
+            this.watcher.subscribe(() => { });
+        }
+        super.setMap(map);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vectortile-layer.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/layer/shared/layers/vectortile-layer.ts"],"names":[],"mappings":"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","sourcesContent":["import olLayerVectorTile from 'ol/layer/VectorTile';\r\nimport olSourceVectorTile from 'ol/source/VectorTile';\r\n\r\nimport { MVTDataSource } from '../../../datasource/shared/datasources/mvt-datasource';\r\n\r\nimport { Layer } from './layer';\r\nimport { VectorTileLayerOptions } from './vectortile-layer.interface';\r\nimport { TileWatcher } from '../../utils';\r\nimport { AuthInterceptor } from '@igo2/auth';\r\nimport { IgoMap } from '../../../map';\r\nimport { MessageService } from '@igo2/core';\r\nimport VectorTile from 'ol/VectorTile';\r\n\r\nexport class VectorTileLayer extends Layer {\r\n  public dataSource: MVTDataSource;\r\n  public options: VectorTileLayerOptions;\r\n  public ol: olLayerVectorTile;\r\n\r\n  private watcher: TileWatcher;\r\n\r\n  constructor(\r\n    options: VectorTileLayerOptions,\r\n    public messageService?: MessageService,\r\n    public authInterceptor?: AuthInterceptor) {\r\n    super(options, messageService, authInterceptor);\r\n    this.watcher = new TileWatcher(this);\r\n    this.status$ = this.watcher.status$;\r\n  }\r\n\r\n  protected createOlLayer(): olLayerVectorTile {\r\n    const olOptions = Object.assign({}, this.options, {\r\n      source: this.options.source.ol as olSourceVectorTile\r\n    });\r\n\r\n    const vectorTile = new olLayerVectorTile(olOptions);\r\n    const vectorTileSource = vectorTile.getSource() as olSourceVectorTile;\r\n\r\n    vectorTileSource.setTileLoadFunction((tile: VectorTile, url: string) => {\r\n      const loader = this.customLoader(url, tile.getFormat(), this.authInterceptor, tile.onLoad.bind(tile));\r\n      if (loader) {\r\n        tile.setLoader(loader);\r\n      }\r\n    }\r\n    );\r\n\r\n    return vectorTile;\r\n  }\r\n\r\n  /**\r\n   * Custom loader for vector tile layer. Modified from the loadFeaturesXhr function in ol\\featureloader.js\r\n   * @internal\r\n   * @param url the url string or function to retrieve the data\r\n   * @param format the format of the tile\r\n   * @param interceptor the interceptor of the data\r\n   * @param success On success event action to trigger\r\n   * @param failure On failure event action to trigger TODO\r\n   */\r\n  customLoader(url, format, interceptor, success, failure?) {\r\n    return ((extent, resolution, projection) => {\r\n      const xhr = new XMLHttpRequest();\r\n      let modifiedUrl = url;\r\n      if (typeof url !== 'function') {\r\n        const alteredUrlWithKeyAuth = interceptor.alterUrlWithKeyAuth(url);\r\n        if (alteredUrlWithKeyAuth) {\r\n          modifiedUrl = alteredUrlWithKeyAuth;\r\n        }\r\n      } else {\r\n        modifiedUrl = url(extent, resolution, projection);\r\n      }\r\n      xhr.open( 'GET', modifiedUrl);\r\n      if (interceptor) {\r\n        interceptor.interceptXhr(xhr, modifiedUrl);\r\n      }\r\n\r\n      if (format.getType() === 'arraybuffer') {\r\n        xhr.responseType = 'arraybuffer';\r\n      }\r\n      xhr.onload = (event) => {\r\n        if (!xhr.status || xhr.status >= 200 && xhr.status < 300) {\r\n          const type = format.getType();\r\n          let source;\r\n          if (type === 'json' || type === 'text') {\r\n            source = xhr.responseText;\r\n          }\r\n          else if (type === 'xml') {\r\n            source = xhr.responseXML;\r\n            if (!source) {\r\n              source = new DOMParser().parseFromString(xhr.responseText, 'application/xml');\r\n            }\r\n          }\r\n          else if (type === 'arraybuffer') {\r\n            source = xhr.response;\r\n          }\r\n          if (source) {\r\n            success.call(this, format.readFeatures(source, {\r\n              extent,\r\n              featureProjection: projection\r\n            }), format.readProjection(source));\r\n          }\r\n          else {\r\n            // TODO\r\n            failure.call(this);\r\n          }\r\n        } else {\r\n          // TODO\r\n          failure.call(this);\r\n        }\r\n      };\r\n      xhr.onerror = () => {\r\n        // TODO\r\n        failure.call(this);\r\n      };\r\n      xhr.send();\r\n    });\r\n  }\r\n\r\n  public setMap(map: IgoMap | undefined) {\r\n    if (map === undefined) {\r\n      this.watcher.unsubscribe();\r\n    } else {\r\n      this.watcher.subscribe(() => {});\r\n    }\r\n    super.setMap(map);\r\n  }\r\n}\r\n"]}

package/esm2020/lib/layer/shared/style.service.mjs

@@ -0,0 +1,356 @@
+import { Injectable } from '@angular/core';
+import * as olstyle from 'ol/style';
+import OlFeature from 'ol/Feature';
+import { createOverlayMarkerStyle } from '../../overlay/shared/overlay-marker-style.utils';
+import { getResolutionFromScale } from '../../map/shared/map.utils';
+import * as i0 from "@angular/core";
+export class StyleService {
+    /**
+     * Create a style based on a object as
+     * style: {
+     *       "stroke": {
+     *         "color": "blue",
+     *         "lineDash": [10, 5]
+     *       },
+     *       "text": {
+     *         "minScaleDenom": 50000,
+     *         "maxScaleDenom": 200000,
+     *         "minResolution": 100,
+     *         "maxResolution": 400,
+     *         "attribute": "THE COLUMN NAME TO RETRIEVE THE LABEL VALUE",
+     *         "text": "MY HARCODED TEXT",
+     *         "stroke": {
+     *           "color": "blue",
+     *           "width": 0.75
+     *         },
+     *         "fill": {
+     *           "color": "black"
+     *         },
+     *         "font": "20px sans-serif",
+     *         "overflow": true,
+     *         "offsetX": 10,
+     *         "offsetY": 20,
+     *         "padding": [2.5, 2.5, 2.5, 2.5]
+     *       },
+     *       "width": 5
+     *     }
+     *
+     * @param options
+     * @param feature feature to apply style on
+     * @param resolution current map resolution, to control label resolution range
+     * @returns
+     */
+    createStyle(options, feature, resolution) {
+        if (!options) {
+            return createOverlayMarkerStyle();
+        }
+        if (typeof options === 'function' || options instanceof olstyle.Style) {
+            return options;
+        }
+        const parsedStyle = this.parseStyle('style', options);
+        if (parsedStyle.getText()) {
+            let labelMinResolution = 0;
+            let labelMaxResolution = Infinity;
+            if (options.text) {
+                const labelMinResolutionFromScale = options.text?.minScaleDenom ? getResolutionFromScale(Number(options.text.minScaleDenom)) : undefined;
+                const labelMaxResolutionFromScale = options.text?.maxScaleDenom ? getResolutionFromScale(Number(options.text.maxScaleDenom)) : undefined;
+                const minResolution = options.text?.minResolution ? options.text.minResolution : 0;
+                const maxResolution = options.text?.maxResolution ? options.text.maxResolution : Infinity;
+                labelMinResolution = labelMinResolutionFromScale || minResolution;
+                labelMaxResolution = labelMaxResolutionFromScale || maxResolution;
+            }
+            if (feature && resolution >= labelMinResolution && resolution <= labelMaxResolution) {
+                if (feature && options.text.attribute) {
+                    parsedStyle.getText().setText(this.getLabel(feature, options.text.attribute));
+                }
+            }
+            else {
+                parsedStyle.setText();
+            }
+        }
+        return parsedStyle;
+    }
+    parseStyle(key, value) {
+        const styleOptions = {};
+        const olCls = this.getOlCls(key);
+        if (olCls && value instanceof Object) {
+            Object.keys(value).forEach(_key => {
+                const olKey = this.getOlKey(_key);
+                styleOptions[olKey] = this.parseStyle(_key, value[_key]);
+            });
+            return new olCls(styleOptions);
+        }
+        else {
+            return value;
+        }
+    }
+    getOlKey(key) {
+        let olKey;
+        switch (key.toLowerCase()) {
+            case 'circle':
+            case 'regularshape':
+            case 'icon':
+                olKey = 'image';
+                break;
+            default:
+                break;
+        }
+        return olKey || key;
+    }
+    getOlCls(key) {
+        let olCls = olstyle[key.charAt(0).toUpperCase() + key.slice(1)];
+        if (key === 'regularshape') {
+            olCls = olstyle.RegularShape;
+        }
+        if (key === 'backgroundFill') {
+            olCls = olstyle.Fill;
+        }
+        if (key === 'backgroundStroke') {
+            olCls = olstyle.Stroke;
+        }
+        return olCls;
+    }
+    createStyleByAttribute(feature, styleByAttribute, resolution) {
+        let style;
+        const type = styleByAttribute.type ? styleByAttribute.type : this.guessTypeFeature(feature);
+        const attribute = styleByAttribute.attribute;
+        const data = styleByAttribute.data;
+        const stroke = styleByAttribute.stroke;
+        const width = styleByAttribute.width;
+        const fill = styleByAttribute.fill;
+        const anchor = styleByAttribute.anchor;
+        const radius = styleByAttribute.radius;
+        const icon = styleByAttribute.icon;
+        const scale = styleByAttribute.scale;
+        const size = data ? data.length : 0;
+        const label = styleByAttribute.label ? styleByAttribute.label.attribute : undefined;
+        const labelMinResolutionFromScale = styleByAttribute.label?.minScaleDenom ? getResolutionFromScale(Number(styleByAttribute.label.minScaleDenom)) : undefined;
+        const labelMaxResolutionFromScale = styleByAttribute.label?.maxScaleDenom ? getResolutionFromScale(Number(styleByAttribute.label.maxScaleDenom)) : undefined;
+        const minResolution = styleByAttribute.label?.minResolution ? styleByAttribute.label.minResolution : 0;
+        const maxResolution = styleByAttribute.label?.maxResolution ? styleByAttribute.label.maxResolution : Infinity;
+        const labelMinResolution = labelMinResolutionFromScale || minResolution;
+        const labelMaxResolution = labelMaxResolutionFromScale || maxResolution;
+        let labelStyle = styleByAttribute.label?.style ? this.parseStyle('text', styleByAttribute.label.style) : undefined;
+        if (!labelStyle && label) {
+            labelStyle = new olstyle.Text();
+        }
+        const baseStyle = styleByAttribute.baseStyle;
+        if (labelStyle) {
+            if (resolution >= labelMinResolution && resolution <= labelMaxResolution) {
+                labelStyle.setText(this.getLabel(feature, label));
+            }
+            else {
+                labelStyle.setText('');
+            }
+        }
+        if (type === 'circle') {
+            for (let i = 0; i < size; i++) {
+                const val = typeof feature.get(attribute) !== 'undefined' && feature.get(attribute) !== null
+                    ? feature.get(attribute)
+                    : '';
+                if (val === data[i] || val.toString().match(new RegExp(data[i], 'gmi'))) {
+                    if (icon) {
+                        style = [
+                            new olstyle.Style({
+                                image: new olstyle.Icon({
+                                    color: fill ? fill[i] : undefined,
+                                    src: icon[i],
+                                    scale: scale ? scale[i] : 1,
+                                    anchor: anchor ? anchor[i] : [0.5, 0.5]
+                                }),
+                                text: labelStyle instanceof olstyle.Text ? labelStyle : undefined
+                            })
+                        ];
+                        return style;
+                    }
+                    style = [
+                        new olstyle.Style({
+                            image: new olstyle.Circle({
+                                radius: radius ? radius[i] : 4,
+                                stroke: new olstyle.Stroke({
+                                    color: stroke ? stroke[i] : 'black',
+                                    width: width ? width[i] : 1
+                                }),
+                                fill: new olstyle.Fill({
+                                    color: fill ? fill[i] : 'black'
+                                })
+                            }),
+                            text: labelStyle instanceof olstyle.Text ? labelStyle : undefined
+                        })
+                    ];
+                    return style;
+                }
+            }
+            if (!feature.getStyle()) {
+                if (baseStyle) {
+                    style = this.createStyle(baseStyle, feature, resolution);
+                    if (labelStyle) {
+                        style.setText(labelStyle);
+                    }
+                    return style;
+                }
+                style = [
+                    new olstyle.Style({
+                        image: new olstyle.Circle({
+                            radius: 4,
+                            stroke: new olstyle.Stroke({
+                                color: 'black'
+                            }),
+                            fill: new olstyle.Fill({
+                                color: '#bbbbf2'
+                            })
+                        })
+                    })
+                ];
+                return style;
+            }
+        }
+        else if (type === 'regular') {
+            for (let i = 0; i < size; i++) {
+                const val = typeof feature.get(attribute) !== 'undefined' && feature.get(attribute) !== null
+                    ? feature.get(attribute)
+                    : '';
+                if (val === data[i] || val.toString().match(new RegExp(data[i], 'gmi'))) {
+                    style = [
+                        new olstyle.Style({
+                            stroke: new olstyle.Stroke({
+                                color: stroke ? stroke[i] : 'black',
+                                width: width ? width[i] : 1
+                            }),
+                            fill: new olstyle.Fill({
+                                color: fill ? fill[i] : 'rgba(255,255,255,0.4)'
+                            }),
+                            text: labelStyle instanceof olstyle.Text ? labelStyle : undefined
+                        })
+                    ];
+                    return style;
+                }
+            }
+            if (feature instanceof OlFeature) {
+                if (!feature.getStyle()) {
+                    if (baseStyle) {
+                        style = this.createStyle(baseStyle, feature, resolution);
+                        if (labelStyle) {
+                            style.setText(labelStyle);
+                        }
+                        return style;
+                    }
+                    style = [
+                        new olstyle.Style({
+                            stroke: new olstyle.Stroke({
+                                color: 'black'
+                            }),
+                            fill: new olstyle.Fill({
+                                color: '#bbbbf2'
+                            })
+                        })
+                    ];
+                    return style;
+                }
+            }
+        }
+    }
+    createClusterStyle(feature, resolution, clusterParam = {}, layerStyle) {
+        let style;
+        const size = feature.get('features').length;
+        if (size !== 1) {
+            if (clusterParam.clusterRanges) {
+                for (const r of clusterParam.clusterRanges) {
+                    if ((!r.minRadius || r.minRadius <= size) &&
+                        (!r.maxRadius || r.maxRadius >= size)) {
+                        style = this.createStyle(r.style);
+                        if (r.showRange) {
+                            const text = new olstyle.Text({
+                                text: size.toString(),
+                                fill: new olstyle.Fill({
+                                    color: '#fff'
+                                })
+                            });
+                            style.setText(text);
+                        }
+                        if (r.dynamicRadius) {
+                            let clusterRadius;
+                            const radiusMin = style.getRadius();
+                            clusterRadius = 5 * Math.log(size);
+                            if (clusterRadius < radiusMin) {
+                                clusterRadius = radiusMin;
+                            }
+                            style.image_.setRadius(clusterRadius);
+                        }
+                        break;
+                    }
+                }
+            }
+            if (!style) {
+                let clusterRadius;
+                if (clusterParam.radiusCalc) {
+                    clusterRadius = clusterParam.radiusCalc(size);
+                }
+                else {
+                    const radiusMin = 6;
+                    clusterRadius = 5 * Math.log(size);
+                    if (clusterRadius < radiusMin) {
+                        clusterRadius = radiusMin;
+                    }
+                }
+                style = [
+                    new olstyle.Style({
+                        image: new olstyle.Circle({
+                            radius: clusterRadius,
+                            stroke: new olstyle.Stroke({
+                                color: 'black'
+                            }),
+                            fill: new olstyle.Fill({
+                                color: 'rgba(24, 134, 45, 0.5)'
+                            })
+                        }),
+                        text: new olstyle.Text({
+                            text: size.toString(),
+                            fill: new olstyle.Fill({
+                                color: '#fff'
+                            })
+                        })
+                    })
+                ];
+            }
+        }
+        else {
+            style = this.createStyle(layerStyle, feature, resolution);
+        }
+        return style;
+    }
+    getLabel(feature, labelMatch) {
+        let label = labelMatch;
+        if (!label) {
+            return;
+        }
+        const labelToGet = Array.from(labelMatch.matchAll(/\$\{([^\{\}]+)\}/g));
+        labelToGet.forEach(v => {
+            label = label.replace(v[0], feature.get(v[1]));
+        });
+        // Nothing done? check feature's attribute
+        if (labelToGet.length === 0 && label === labelMatch) {
+            label = feature.get(labelMatch) || labelMatch;
+        }
+        return label;
+    }
+    guessTypeFeature(feature) {
+        switch (feature.getGeometry().getType()) {
+            case 'Point':
+            case 'MultiPoint':
+            case 'Circle':
+                return 'circle';
+            default:
+                return 'regular';
+        }
+    }
+}
+StyleService.ɵfac = function StyleService_Factory(t) { return new (t || StyleService)(); };
+StyleService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: StyleService, factory: StyleService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StyleService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"style.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/layer/shared/style.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\nimport * as olstyle from 'ol/style';\r\nimport OlFeature from 'ol/Feature';\r\nimport { StyleByAttribute } from './vector-style.interface';\r\n\r\nimport { ClusterParam } from './clusterParam';\r\nimport { createOverlayMarkerStyle } from '../../overlay/shared/overlay-marker-style.utils';\r\nimport RenderFeature from 'ol/render/Feature';\r\nimport { getResolutionFromScale } from '../../map/shared/map.utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class StyleService {\r\n  public style: olstyle.Style;\r\n\r\n  /**\r\n   * Create a style based on a object as\r\n   * style: {\r\n   *       \"stroke\": {\r\n   *         \"color\": \"blue\",\r\n   *         \"lineDash\": [10, 5]\r\n   *       },\r\n   *       \"text\": {\r\n   *         \"minScaleDenom\": 50000,\r\n   *         \"maxScaleDenom\": 200000,\r\n   *         \"minResolution\": 100,\r\n   *         \"maxResolution\": 400,\r\n   *         \"attribute\": \"THE COLUMN NAME TO RETRIEVE THE LABEL VALUE\",\r\n   *         \"text\": \"MY HARCODED TEXT\",\r\n   *         \"stroke\": {\r\n   *           \"color\": \"blue\",\r\n   *           \"width\": 0.75\r\n   *         },\r\n   *         \"fill\": {\r\n   *           \"color\": \"black\"\r\n   *         },\r\n   *         \"font\": \"20px sans-serif\",\r\n   *         \"overflow\": true,\r\n   *         \"offsetX\": 10,\r\n   *         \"offsetY\": 20,\r\n   *         \"padding\": [2.5, 2.5, 2.5, 2.5]\r\n   *       },\r\n   *       \"width\": 5\r\n   *     }\r\n   *\r\n   * @param options\r\n   * @param feature feature to apply style on\r\n   * @param resolution current map resolution, to control label resolution range\r\n   * @returns\r\n   */\r\n  createStyle(options: { [key: string]: any }, feature?: RenderFeature | OlFeature<OlGeometry>, resolution?: number) {\r\n\r\n    if (!options) {\r\n      return createOverlayMarkerStyle();\r\n    }\r\n    if (typeof options === 'function' || options instanceof olstyle.Style) {\r\n      return options;\r\n    }\r\n    const parsedStyle = this.parseStyle('style', options);\r\n    if (parsedStyle.getText()) {\r\n      let labelMinResolution = 0;\r\n      let labelMaxResolution = Infinity;\r\n      if (options.text) {\r\n        const labelMinResolutionFromScale =\r\n          options.text?.minScaleDenom ? getResolutionFromScale(Number(options.text.minScaleDenom)) : undefined;\r\n        const labelMaxResolutionFromScale =\r\n          options.text?.maxScaleDenom ? getResolutionFromScale(Number(options.text.maxScaleDenom)) : undefined;\r\n        const minResolution = options.text?.minResolution ? options.text.minResolution : 0;\r\n        const maxResolution = options.text?.maxResolution ? options.text.maxResolution : Infinity;\r\n\r\n        labelMinResolution = labelMinResolutionFromScale || minResolution;\r\n        labelMaxResolution = labelMaxResolutionFromScale || maxResolution;\r\n      }\r\n      if (feature && resolution >= labelMinResolution && resolution <= labelMaxResolution) {\r\n        if (feature && options.text.attribute) {\r\n          parsedStyle.getText().setText(this.getLabel(feature, options.text.attribute));\r\n        }\r\n      } else {\r\n        parsedStyle.setText();\r\n      }\r\n    }\r\n    return parsedStyle;\r\n  }\r\n\r\n  private parseStyle(key: string, value: any) {\r\n    const styleOptions = {};\r\n    const olCls = this.getOlCls(key);\r\n\r\n    if (olCls && value instanceof Object) {\r\n      Object.keys(value).forEach(_key => {\r\n        const olKey = this.getOlKey(_key);\r\n        styleOptions[olKey] = this.parseStyle(_key, value[_key]);\r\n      });\r\n      return new olCls(styleOptions);\r\n    } else {\r\n      return value;\r\n    }\r\n  }\r\n\r\n  private getOlKey(key: any) {\r\n    let olKey;\r\n    switch (key.toLowerCase()) {\r\n      case 'circle':\r\n      case 'regularshape':\r\n      case 'icon':\r\n        olKey = 'image';\r\n        break;\r\n      default:\r\n        break;\r\n    }\r\n\r\n    return olKey || key;\r\n  }\r\n\r\n  private getOlCls(key: any) {\r\n    let olCls = olstyle[key.charAt(0).toUpperCase() + key.slice(1)];\r\n    if (key === 'regularshape') {\r\n      olCls = olstyle.RegularShape;\r\n    }\r\n    if (key === 'backgroundFill') {\r\n      olCls = olstyle.Fill;\r\n    }\r\n    if (key === 'backgroundStroke') {\r\n      olCls = olstyle.Stroke;\r\n    }\r\n\r\n    return olCls;\r\n  }\r\n\r\n  createStyleByAttribute(feature: RenderFeature | OlFeature<OlGeometry>, styleByAttribute: StyleByAttribute, resolution: number) {\r\n\r\n    let style;\r\n    const type = styleByAttribute.type ? styleByAttribute.type : this.guessTypeFeature(feature);\r\n    const attribute = styleByAttribute.attribute;\r\n    const data = styleByAttribute.data;\r\n    const stroke = styleByAttribute.stroke;\r\n    const width = styleByAttribute.width;\r\n    const fill = styleByAttribute.fill;\r\n    const anchor = styleByAttribute.anchor;\r\n    const radius = styleByAttribute.radius;\r\n    const icon = styleByAttribute.icon;\r\n    const scale = styleByAttribute.scale;\r\n    const size = data ? data.length : 0;\r\n    const label = styleByAttribute.label ? styleByAttribute.label.attribute : undefined;\r\n    const labelMinResolutionFromScale =\r\n      styleByAttribute.label?.minScaleDenom ? getResolutionFromScale(Number(styleByAttribute.label.minScaleDenom)) : undefined;\r\n    const labelMaxResolutionFromScale =\r\n      styleByAttribute.label?.maxScaleDenom ? getResolutionFromScale(Number(styleByAttribute.label.maxScaleDenom)) : undefined;\r\n    const minResolution = styleByAttribute.label?.minResolution ? styleByAttribute.label.minResolution : 0;\r\n    const maxResolution = styleByAttribute.label?.maxResolution ? styleByAttribute.label.maxResolution : Infinity;\r\n\r\n    const labelMinResolution = labelMinResolutionFromScale || minResolution;\r\n    const labelMaxResolution = labelMaxResolutionFromScale || maxResolution;\r\n\r\n    let labelStyle = styleByAttribute.label?.style ? this.parseStyle('text', styleByAttribute.label.style) : undefined;\r\n    if (!labelStyle && label) {\r\n        labelStyle = new olstyle.Text();\r\n    }\r\n    const baseStyle = styleByAttribute.baseStyle;\r\n\r\n    if (labelStyle) {\r\n      if (resolution >= labelMinResolution && resolution <= labelMaxResolution) {\r\n        labelStyle.setText(this.getLabel(feature, label));\r\n      } else {\r\n        labelStyle.setText('');\r\n      }\r\n    }\r\n\r\n    if (type === 'circle') {\r\n      for (let i = 0; i < size; i++) {\r\n        const val =\r\n          typeof feature.get(attribute) !== 'undefined' && feature.get(attribute) !== null\r\n            ? feature.get(attribute)\r\n            : '';\r\n        if (val === data[i] || val.toString().match(new RegExp(data[i], 'gmi'))) {\r\n          if (icon) {\r\n            style = [\r\n              new olstyle.Style({\r\n                image: new olstyle.Icon({\r\n                  color: fill ? fill[i] : undefined,\r\n                  src: icon[i],\r\n                  scale: scale ? scale[i] : 1,\r\n                  anchor: anchor ? anchor[i] : [0.5, 0.5]\r\n                }),\r\n                text: labelStyle instanceof olstyle.Text ? labelStyle : undefined\r\n              })\r\n            ];\r\n            return style;\r\n          }\r\n          style = [\r\n            new olstyle.Style({\r\n              image: new olstyle.Circle({\r\n                radius: radius ? radius[i] : 4,\r\n                stroke: new olstyle.Stroke({\r\n                  color: stroke ? stroke[i] : 'black',\r\n                  width: width ? width[i] : 1\r\n                }),\r\n                fill: new olstyle.Fill({\r\n                  color: fill ? fill[i] : 'black'\r\n                })\r\n              }),\r\n              text: labelStyle instanceof olstyle.Text ? labelStyle : undefined\r\n            })\r\n          ];\r\n          return style;\r\n        }\r\n      }\r\n      if (!(feature as OlFeature<OlGeometry>).getStyle()) {\r\n        if (baseStyle) {\r\n          style = this.createStyle(baseStyle, feature, resolution);\r\n          if (labelStyle) {\r\n            style.setText(labelStyle);\r\n          }\r\n          return style;\r\n        }\r\n        style = [\r\n          new olstyle.Style({\r\n            image: new olstyle.Circle({\r\n              radius: 4,\r\n              stroke: new olstyle.Stroke({\r\n                color: 'black'\r\n              }),\r\n              fill: new olstyle.Fill({\r\n                color: '#bbbbf2'\r\n              })\r\n            })\r\n          })\r\n        ];\r\n        return style;\r\n      }\r\n    } else if (type === 'regular') {\r\n      for (let i = 0; i < size; i++) {\r\n        const val =\r\n        typeof feature.get(attribute) !== 'undefined' && feature.get(attribute) !== null\r\n            ? feature.get(attribute)\r\n            : '';\r\n        if (val === data[i] || val.toString().match(new RegExp(data[i], 'gmi'))) {\r\n          style = [\r\n            new olstyle.Style({\r\n              stroke: new olstyle.Stroke({\r\n                color: stroke ? stroke[i] : 'black',\r\n                width: width ? width[i] : 1\r\n              }),\r\n              fill: new olstyle.Fill({\r\n                color: fill ? fill[i] : 'rgba(255,255,255,0.4)'\r\n              }),\r\n              text: labelStyle instanceof olstyle.Text ? labelStyle : undefined\r\n            })\r\n          ];\r\n          return style;\r\n        }\r\n      }\r\n      if (feature instanceof OlFeature) {\r\n        if (!feature.getStyle()) {\r\n          if (baseStyle) {\r\n            style = this.createStyle(baseStyle, feature, resolution);\r\n            if (labelStyle) {\r\n              style.setText(labelStyle);\r\n            }\r\n            return style;\r\n          }\r\n          style = [\r\n            new olstyle.Style({\r\n              stroke: new olstyle.Stroke({\r\n                color: 'black'\r\n              }),\r\n              fill: new olstyle.Fill({\r\n                color: '#bbbbf2'\r\n              })\r\n            })\r\n          ];\r\n          return style;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  createClusterStyle(feature: RenderFeature | OlFeature<OlGeometry>, resolution: number, clusterParam: ClusterParam = {}, layerStyle) {\r\n    let style;\r\n    const size = feature.get('features').length;\r\n    if (size !== 1) {\r\n      if (clusterParam.clusterRanges) {\r\n        for (const r of clusterParam.clusterRanges) {\r\n          if (\r\n            (!r.minRadius || r.minRadius <= size) &&\r\n            (!r.maxRadius || r.maxRadius >= size)\r\n          ) {\r\n            style = this.createStyle(r.style) as olstyle.Circle;\r\n\r\n            if (r.showRange) {\r\n              const text = new olstyle.Text({\r\n                text: size.toString(),\r\n                fill: new olstyle.Fill({\r\n                  color: '#fff'\r\n                })\r\n              });\r\n              style.setText(text);\r\n            }\r\n\r\n            if (r.dynamicRadius) {\r\n              let clusterRadius: number;\r\n              const radiusMin = style.getRadius();\r\n              clusterRadius = 5 * Math.log(size);\r\n              if (clusterRadius < radiusMin) {\r\n                clusterRadius = radiusMin;\r\n              }\r\n              style.image_.setRadius(clusterRadius);\r\n            }\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      if (!style) {\r\n        let clusterRadius: number;\r\n        if (clusterParam.radiusCalc) {\r\n          clusterRadius = clusterParam.radiusCalc(size);\r\n        } else {\r\n          const radiusMin = 6;\r\n          clusterRadius = 5 * Math.log(size);\r\n          if (clusterRadius < radiusMin) {\r\n            clusterRadius = radiusMin;\r\n          }\r\n        }\r\n\r\n        style = [\r\n          new olstyle.Style({\r\n            image: new olstyle.Circle({\r\n              radius: clusterRadius,\r\n              stroke: new olstyle.Stroke({\r\n                color: 'black'\r\n              }),\r\n              fill: new olstyle.Fill({\r\n                color: 'rgba(24, 134, 45, 0.5)'\r\n              })\r\n            }),\r\n            text: new olstyle.Text({\r\n              text: size.toString(),\r\n              fill: new olstyle.Fill({\r\n                color: '#fff'\r\n              })\r\n            })\r\n          })\r\n        ];\r\n      }\r\n    } else {\r\n      style = this.createStyle(layerStyle, feature, resolution);\r\n    }\r\n    return style;\r\n  }\r\n\r\n  getLabel(feature, labelMatch): string {\r\n    let label = labelMatch;\r\n    if (!label) {\r\n      return;\r\n    }\r\n    const labelToGet = Array.from(labelMatch.matchAll(/\\$\\{([^\\{\\}]+)\\}/g));\r\n\r\n    labelToGet.forEach(v => {\r\n      label = label.replace(v[0], feature.get(v[1]));\r\n    });\r\n\r\n    // Nothing done? check feature's attribute\r\n    if (labelToGet.length === 0 && label === labelMatch) {\r\n      label = feature.get(labelMatch) || labelMatch;\r\n    }\r\n\r\n    return label;\r\n  }\r\n\r\n  private guessTypeFeature(feature) {\r\n    switch (feature.getGeometry().getType()) {\r\n      case 'Point':\r\n      case 'MultiPoint':\r\n      case 'Circle':\r\n        return 'circle';\r\n      default:\r\n        return 'regular';\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/lib/layer/shared/vector-style.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVjdG9yLXN0eWxlLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL2xheWVyL3NoYXJlZC92ZWN0b3Itc3R5bGUuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFN0eWxlQnlBdHRyaWJ1dGUge1xyXG4gICAgYW5jaG9yPzogQXJyYXk8W251bWJlcixudW1iZXJdPjtcclxuICAgIHR5cGU/OiBzdHJpbmc7XHJcbiAgICBhdHRyaWJ1dGU/OiBzdHJpbmc7XHJcbiAgICBkYXRhPzogQXJyYXk8YW55PjtcclxuICAgIGZpbGw/OiBBcnJheTxzdHJpbmc+O1xyXG4gICAgc3Ryb2tlPzogQXJyYXk8c3RyaW5nPjtcclxuICAgIHdpZHRoPzogQXJyYXk8bnVtYmVyPjtcclxuICAgIHJhZGl1cz86IEFycmF5PG51bWJlcj47XHJcbiAgICBpY29uPzogQXJyYXk8c3RyaW5nPjtcclxuICAgIHNjYWxlPzogQXJyYXk8bnVtYmVyPjtcclxuICAgIGxhYmVsPzogSWdvTGFiZWw7XHJcbiAgICBiYXNlU3R5bGU/OiB7IFtrZXk6IHN0cmluZ106IGFueSwgYWxsbz86IHN0cmluZyB9O1xyXG4gICAgaG92ZXJTdHlsZT86IFN0eWxlQnlBdHRyaWJ1dGU7XHJcbn1cclxuXHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIENyZWF0ZVN0eWxlIHtcclxuICBpZ29MYWJlbD86IElnb0xhYmVsLFxyXG4gIGlnb1N0eWxlPzogeyBba2V5OiBzdHJpbmddOiBhbnkgfTtcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBJZ29MYWJlbCB7XHJcbiAgYXR0cmlidXRlOiBzdHJpbmc7XHJcbiAgc3R5bGU/OiB7IFtrZXk6IHN0cmluZ106IGFueSB9O1xyXG4gIG1pblJlc29sdXRpb24/OiBudW1iZXI7XHJcbiAgbWF4UmVzb2x1dGlvbj86IG51bWJlcjtcclxuICBtaW5TY2FsZURlbm9tPzogbnVtYmVyO1xyXG4gIG1heFNjYWxlRGVub20/OiBudW1iZXI7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgTWFwYm94U3R5bGUge1xyXG4gIHVybDogc3RyaW5nO1xyXG4gIHNvdXJjZTogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2020/lib/layer/track-feature-button/index.mjs

@@ -0,0 +1,2 @@
+export * from './track-feature-button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9sYXllci90cmFjay1mZWF0dXJlLWJ1dHRvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90cmFjay1mZWF0dXJlLWJ1dHRvbi5jb21wb25lbnQnO1xyXG4iXX0=

package/esm2020/lib/layer/track-feature-button/track-feature-button.component.mjs

@@ -0,0 +1,59 @@
+import { Component, Input, ChangeDetectionStrategy } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/icon";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/tooltip";
+import * as i5 from "@ngx-translate/core";
+function TrackFeatureButtonComponent_button_0_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 1);
+    i0.ɵɵlistener("click", function TrackFeatureButtonComponent_button_0_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r2); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.toggleTrackFeature()); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵelement(2, "mat-icon", 2);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 2, "igo.geo.layer.trackFeature"))("color", ctx_r0.color);
+} }
+export class TrackFeatureButtonComponent {
+    constructor() {
+        this.trackFeature = false;
+        this.color = 'primary';
+    }
+    get options() {
+        if (!this.layer) {
+            return;
+        }
+        return this.layer.options;
+    }
+    ngOnInit() {
+        this.color = this.trackFeature ? 'primary' : 'basic';
+    }
+    toggleTrackFeature() {
+        if (this.trackFeature) {
+            this.layer.disableTrackFeature(this.layer.options.trackFeature);
+            this.color = 'basic';
+        }
+        else {
+            this.layer.enableTrackFeature(this.layer.options.trackFeature);
+            this.color = 'primary';
+        }
+        this.trackFeature = !this.trackFeature;
+    }
+}
+TrackFeatureButtonComponent.ɵfac = function TrackFeatureButtonComponent_Factory(t) { return new (t || TrackFeatureButtonComponent)(); };
+TrackFeatureButtonComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: TrackFeatureButtonComponent, selectors: [["igo-track-feature-button"]], inputs: { layer: "layer", trackFeature: "trackFeature" }, decls: 1, vars: 1, consts: [["mat-icon-button", "", "collapsibleButton", "", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "matTooltip", "color", "click", 4, "ngIf"], ["mat-icon-button", "", "collapsibleButton", "", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "matTooltip", "color", "click"], ["svgIcon", "crosshairs-gps"]], template: function TrackFeatureButtonComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, TrackFeatureButtonComponent_button_0_Template, 3, 4, "button", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.options.trackFeature);
+    } }, dependencies: [i1.NgIf, i2.MatIcon, i3.MatButton, i4.MatTooltip, i5.TranslatePipe], changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TrackFeatureButtonComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-track-feature-button', changeDetection: ChangeDetectionStrategy.OnPush, template: "<button *ngIf=\"options.trackFeature\"\r\n  mat-icon-button\r\n  collapsibleButton\r\n  tooltip-position=\"below\"\r\n  matTooltipShowDelay=\"500\"\r\n  [matTooltip]=\"'igo.geo.layer.trackFeature' | translate\"\r\n  [color]=\"color\"\r\n  (click)=\"toggleTrackFeature()\">\r\n  <mat-icon svgIcon=\"crosshairs-gps\"></mat-icon>\r\n</button>\r\n" }]
+    }], function () { return []; }, { layer: [{
+            type: Input
+        }], trackFeature: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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