@igo2/geo 1.15.3 → 16.0.0-rc.0

package/esm2022/lib/feature/shared/index.mjs

@@ -0,0 +1,8 @@
+export * from './feature.enums';
+export * from './feature.interfaces';
+export * from './feature.utils';
+export * from './feature-store.utils';
+export * from './store';
+export * from './strategies';
+export * from './strategies.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9mZWF0dXJlL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ZlYXR1cmUuZW51bXMnO1xuZXhwb3J0ICogZnJvbSAnLi9mZWF0dXJlLmludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9mZWF0dXJlLnV0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vZmVhdHVyZS1zdG9yZS51dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RyYXRlZ2llcyc7XG5leHBvcnQgKiBmcm9tICcuL3N0cmF0ZWdpZXMudXRpbHMnO1xuIl19

package/esm2022/lib/feature/shared/store.mjs

@@ -0,0 +1,143 @@
+import * as olextent from 'ol/extent';
+import { getEntityId, EntityStoreWithStrategy } from '@igo2/common';
+import { FeatureMotion } from './feature.enums';
+import { computeOlFeaturesDiff, featureFromOl, featureToOl, moveToOlFeatures, computeOlFeaturesExtent } from './feature.utils';
+/**
+ * The class is a specialized version of an EntityStore that stores
+ * features and the map layer to display them on. Synchronization
+ * between the store and the layer is handled by strategies.
+ */
+export class FeatureStore extends EntityStoreWithStrategy {
+    /**
+     * Vector layer to display the features on
+     */
+    layer;
+    /**
+     * The map the layer is bound to
+     */
+    map;
+    /**
+     * The layer's data source
+     */
+    get source() {
+        return this.layer
+            ? this.layer.dataSource
+            : undefined;
+    }
+    /**
+     * The searchable index of loaded feature. Computed if strategy is provided
+     */
+    set searchDocument(v) {
+        this._searchDocument = v;
+    }
+    get searchDocument() {
+        return this._searchDocument;
+    }
+    _searchDocument;
+    constructor(entities, options) {
+        super(entities, options);
+        this.map = options.map;
+    }
+    /**
+     * Bind this store to a vector layer
+     * @param layer Vector layer
+     * @returns Feature store
+     */
+    bindLayer(layer) {
+        this.layer = layer;
+        return this;
+    }
+    /**
+     * Set the layer's features and perform a motion to make them visible. Strategies
+     * make extensive use of that method.
+     * @param features Features
+     * @param motion Optional: The type of motion to perform
+     */
+    setLayerFeatures(features, motion = FeatureMotion.Default, viewScale, areaRatio, getId) {
+        getId = getId ? getId : getEntityId;
+        this.checkLayer();
+        const olFeatures = features.map((feature) => featureToOl(feature, this.map.projection, getId));
+        this.setLayerOlFeatures(olFeatures, motion, viewScale, areaRatio);
+    }
+    /**
+     * Set the store's features from an array of OL features.
+     * @param olFeatures Ol features
+     */
+    setStoreOlFeatures(olFeatures) {
+        this.checkLayer();
+        const features = olFeatures.map((olFeature) => {
+            olFeature.set('_featureStore', this, true);
+            return featureFromOl(olFeature, this.layer.map.projection);
+        });
+        this.load(features);
+    }
+    /**
+     * Remove all features from the layer
+     */
+    clearLayer() {
+        this.checkLayer();
+        this.source.ol.clear();
+    }
+    /**
+     * Check wether a layer is bound or not and throw an error if not.
+     */
+    checkLayer() {
+        if (this.layer === undefined) {
+            throw new Error('This FeatureStore is not bound to a layer.');
+        }
+    }
+    /**
+     * Set the layer's features and perform a motion to make them visible.
+     * @param features Openlayers feature objects
+     * @param motion Optional: The type of motion to perform
+     */
+    setLayerOlFeatures(olFeatures, motion = FeatureMotion.Default, viewScale, areaRatio) {
+        const olSource = this.layer.ol.getSource();
+        const diff = computeOlFeaturesDiff(olSource.getFeatures(), olFeatures);
+        if (diff.remove.length > 0) {
+            this.removeOlFeaturesFromLayer(diff.remove);
+        }
+        if (diff.add.length > 0) {
+            this.addOlFeaturesToLayer(diff.add);
+        }
+        if (diff.add.length > 0) {
+            // If features are added, do a motion toward the newly added features
+            moveToOlFeatures(this.map.viewController, diff.add, motion, viewScale, areaRatio);
+        }
+        else if (diff.remove.length > 0) {
+            // Else, do a motion toward all the features
+            moveToOlFeatures(this.map.viewController, olFeatures, motion, viewScale, areaRatio);
+        }
+    }
+    setLayerExtent() {
+        let features = this.entities$.getValue();
+        let extent = olextent.createEmpty();
+        let olFeatures = [];
+        features.forEach((feature) => {
+            olFeatures.push(featureToOl(feature, this.map.projection));
+        });
+        const featuresExtent = computeOlFeaturesExtent(olFeatures, this.map.viewProjection);
+        olextent.extend(extent, featuresExtent);
+        this.layer.setExtent(extent);
+    }
+    /**
+     * Add features to the the layer
+     * @param features Openlayers feature objects
+     */
+    addOlFeaturesToLayer(olFeatures) {
+        olFeatures.forEach((olFeature) => {
+            olFeature.set('_featureStore', this, true);
+        });
+        this.source.ol.addFeatures(olFeatures);
+    }
+    /**
+     * Remove features from the the layer
+     * @param features Openlayers feature objects
+     */
+    removeOlFeaturesFromLayer(olFeatures) {
+        olFeatures.forEach((olFeature) => {
+            this.source.ol.removeFeature(olFeature);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/feature/shared/store.ts"],"names":[],"mappings":"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","sourcesContent":["import OlFeature from 'ol/Feature';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\nimport * as olextent from 'ol/extent';\r\n\r\nimport { Document } from 'flexsearch';\r\n\r\nimport { getEntityId, EntityKey, EntityStoreWithStrategy } from '@igo2/common';\r\n\r\nimport { FeatureDataSource } from '../../datasource';\r\nimport { VectorLayer } from '../../layer/shared';\r\nimport { IgoMap, MapExtent } from '../../map/shared';\r\n\r\nimport { FeatureMotion } from './feature.enums';\r\nimport { Feature, FeatureStoreOptions } from './feature.interfaces';\r\nimport {\r\n  computeOlFeaturesDiff,\r\n  featureFromOl,\r\n  featureToOl,\r\n  moveToOlFeatures,\r\n  computeOlFeaturesExtent\r\n} from './feature.utils';\r\n\r\n/**\r\n * The class is a specialized version of an EntityStore that stores\r\n * features and the map layer to display them on. Synchronization\r\n * between the store and the layer is handled by strategies.\r\n */\r\nexport class FeatureStore<\r\n  T extends Feature = Feature\r\n> extends EntityStoreWithStrategy<T> {\r\n  /**\r\n   * Vector layer to display the features on\r\n   */\r\n  layer: VectorLayer;\r\n\r\n  /**\r\n   * The map the layer is bound to\r\n   */\r\n  readonly map: IgoMap;\r\n\r\n  /**\r\n   * The layer's data source\r\n   */\r\n  get source(): FeatureDataSource {\r\n    return this.layer\r\n      ? (this.layer.dataSource as FeatureDataSource)\r\n      : undefined;\r\n  }\r\n\r\n  /**\r\n   * The searchable index of loaded feature. Computed if strategy is provided\r\n   */\r\n  set searchDocument(v: Document<T>) {\r\n    this._searchDocument = v;\r\n  }\r\n\r\n  get searchDocument(): Document<T> {\r\n    return this._searchDocument;\r\n  }\r\n  private _searchDocument: Document<T>;\r\n\r\n  constructor(entities: T[], options: FeatureStoreOptions) {\r\n    super(entities, options);\r\n    this.map = options.map;\r\n  }\r\n\r\n  /**\r\n   * Bind this store to a vector layer\r\n   * @param layer Vector layer\r\n   * @returns Feature store\r\n   */\r\n  bindLayer(layer: VectorLayer): FeatureStore {\r\n    this.layer = layer;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Set the layer's features and perform a motion to make them visible. Strategies\r\n   * make extensive use of that method.\r\n   * @param features Features\r\n   * @param motion Optional: The type of motion to perform\r\n   */\r\n  setLayerFeatures(\r\n    features: Feature[],\r\n    motion: FeatureMotion = FeatureMotion.Default,\r\n    viewScale?: [number, number, number, number],\r\n    areaRatio?: number,\r\n    getId?: (Feature) => EntityKey\r\n  ) {\r\n    getId = getId ? getId : getEntityId;\r\n    this.checkLayer();\r\n\r\n    const olFeatures = features.map((feature: Feature) =>\r\n      featureToOl(feature, this.map.projection, getId)\r\n    );\r\n    this.setLayerOlFeatures(olFeatures, motion, viewScale, areaRatio);\r\n  }\r\n\r\n  /**\r\n   * Set the store's features from an array of OL features.\r\n   * @param olFeatures Ol features\r\n   */\r\n  setStoreOlFeatures(olFeatures: OlFeature<OlGeometry>[]) {\r\n    this.checkLayer();\r\n\r\n    const features = olFeatures.map((olFeature: OlFeature<OlGeometry>) => {\r\n      olFeature.set('_featureStore', this, true);\r\n      return featureFromOl(olFeature, this.layer.map.projection);\r\n    });\r\n    this.load(features as T[]);\r\n  }\r\n\r\n  /**\r\n   * Remove all features from the layer\r\n   */\r\n  clearLayer() {\r\n    this.checkLayer();\r\n    this.source.ol.clear();\r\n  }\r\n\r\n  /**\r\n   * Check wether a layer is bound or not and throw an error if not.\r\n   */\r\n  private checkLayer() {\r\n    if (this.layer === undefined) {\r\n      throw new Error('This FeatureStore is not bound to a layer.');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Set the layer's features and perform a motion to make them visible.\r\n   * @param features Openlayers feature objects\r\n   * @param motion Optional: The type of motion to perform\r\n   */\r\n  public setLayerOlFeatures(\r\n    olFeatures: OlFeature<OlGeometry>[],\r\n    motion: FeatureMotion = FeatureMotion.Default,\r\n    viewScale?: [number, number, number, number],\r\n    areaRatio?: number\r\n  ) {\r\n    const olSource = this.layer.ol.getSource();\r\n    const diff = computeOlFeaturesDiff(olSource.getFeatures(), olFeatures);\r\n    if (diff.remove.length > 0) {\r\n      this.removeOlFeaturesFromLayer(diff.remove);\r\n    }\r\n\r\n    if (diff.add.length > 0) {\r\n      this.addOlFeaturesToLayer(diff.add);\r\n    }\r\n\r\n    if (diff.add.length > 0) {\r\n      // If features are added, do a motion toward the newly added features\r\n      moveToOlFeatures(\r\n        this.map.viewController,\r\n        diff.add,\r\n        motion,\r\n        viewScale,\r\n        areaRatio\r\n      );\r\n    } else if (diff.remove.length > 0) {\r\n      // Else, do a motion toward all the features\r\n      moveToOlFeatures(\r\n        this.map.viewController,\r\n        olFeatures,\r\n        motion,\r\n        viewScale,\r\n        areaRatio\r\n      );\r\n    }\r\n  }\r\n\r\n  setLayerExtent(): void {\r\n    let features = this.entities$.getValue();\r\n    let extent = olextent.createEmpty() as MapExtent;\r\n    let olFeatures = [];\r\n\r\n    features.forEach((feature) => {\r\n      olFeatures.push(featureToOl(feature, this.map.projection));\r\n    });\r\n    const featuresExtent = computeOlFeaturesExtent(\r\n      olFeatures,\r\n      this.map.viewProjection\r\n    );\r\n    olextent.extend(extent, featuresExtent);\r\n    this.layer.setExtent(extent);\r\n  }\r\n  /**\r\n   * Add features to the the layer\r\n   * @param features Openlayers feature objects\r\n   */\r\n  private addOlFeaturesToLayer(olFeatures: OlFeature<OlGeometry>[]) {\r\n    olFeatures.forEach((olFeature: OlFeature<OlGeometry>) => {\r\n      olFeature.set('_featureStore', this, true);\r\n    });\r\n    this.source.ol.addFeatures(olFeatures);\r\n  }\r\n\r\n  /**\r\n   * Remove features from the the layer\r\n   * @param features Openlayers feature objects\r\n   */\r\n  private removeOlFeaturesFromLayer(olFeatures: OlFeature<OlGeometry>[]) {\r\n    olFeatures.forEach((olFeature: OlFeature<OlGeometry>) => {\r\n      this.source.ol.removeFeature(olFeature);\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/feature/shared/strategies/geo-properties.mjs

@@ -0,0 +1,216 @@
+import { EntityStoreStrategy } from '@igo2/common';
+import { debounceTime, pairwise } from 'rxjs';
+import { ObjectUtils } from '@igo2/utils';
+import { generateIdFromSourceOptions } from '../../../utils/id-generator';
+/**
+ * This strategy maintain the store features updated to detect geoproperties
+ * (wms/arcgis... layer and url).
+ * The features's state inside the map are tagged haveGeoServiceProperties = true;
+ */
+export class GeoPropertiesStrategy extends EntityStoreStrategy {
+    options;
+    propertyTypeDetectorService;
+    capabilitiesService;
+    /**
+     * Subscription to the store's OL source changes
+     */
+    stores$$ = new Map();
+    states$$ = [];
+    empty$$;
+    /**
+     * The map the layer is bound to
+     */
+    map;
+    constructor(options, propertyTypeDetectorService, capabilitiesService) {
+        super(options);
+        this.options = options;
+        this.propertyTypeDetectorService = propertyTypeDetectorService;
+        this.capabilitiesService = capabilitiesService;
+        this.map = options.map;
+    }
+    /**
+     * Bind this strategy to a store and start watching for Ol source changes
+     * @param store Feature store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.watchStore(store);
+        }
+    }
+    /**
+     * Unbind this strategy from a store and stop watching for Ol source changes
+     * @param store Feature store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unwatchStore(store);
+        }
+    }
+    /**
+     * Start watching all stores already bound to that strategy at once.
+     * @internal
+     */
+    doActivate() {
+        this.stores.forEach((store) => this.watchStore(store));
+    }
+    /**
+     * Stop watching all stores bound to that strategy
+     * @internal
+     */
+    doDeactivate() {
+        this.unwatchAll();
+    }
+    /**
+     * Watch for a store's  OL source changes
+     * @param store Feature store
+     */
+    watchStore(store) {
+        if (this.stores$$.has(store)) {
+            return;
+        }
+        this.updateEntitiesPropertiesState(store);
+        this.states$$.push(this.map.layers$
+            .pipe(debounceTime(750), pairwise())
+            .subscribe(([prevLayers, currentLayers]) => {
+            let prevLayersId;
+            if (prevLayers) {
+                prevLayersId = prevLayers.map((l) => l.id);
+            }
+            const layers = currentLayers.filter((l) => !prevLayersId.includes(l.id));
+            this.updateEntitiesPropertiesState(store, layers);
+        }));
+        this.states$$.push(store.entities$.pipe(debounceTime(750)).subscribe((a) => {
+            this.updateEntitiesPropertiesState(store);
+        }));
+    }
+    updateEntitiesPropertiesState(store, layers) {
+        const layersId = this.map.layers.map((l) => l.id);
+        let entities = [];
+        if (layers) {
+            entities = store.entities$.value;
+        }
+        else {
+            const allSV = store.stateView.all();
+            entities = allSV.length
+                ? store.stateView
+                    .all()
+                    .filter((s) => !s.state.geoService)
+                    .map((e) => e.entity)
+                : store.entities$.value;
+        }
+        const sampling = entities.length >= 250 ? 250 : entities.length;
+        const firstN = entities.slice(0, sampling);
+        let allKeys = [];
+        firstN.map((e) => {
+            allKeys = allKeys.concat(Object.keys(e.properties || {}));
+        });
+        allKeys = [...new Set(allKeys)];
+        const distinctValues = {};
+        allKeys.map((k) => {
+            distinctValues[k] = [
+                ...new Set(entities.map((item) => item.properties[k]))
+            ];
+        });
+        const containGeoServices = {};
+        Object.entries(distinctValues).forEach((entry) => {
+            const [key, values] = entry;
+            const valuedAreGeoservices = values.filter((value) => this.propertyTypeDetectorService.isGeoService(value));
+            if (valuedAreGeoservices?.length) {
+                containGeoServices[key] = valuedAreGeoservices;
+            }
+        });
+        const geoServiceAssociations = [];
+        Object.entries(containGeoServices).forEach((entry) => {
+            const [key, values] = entry;
+            values.map((value) => {
+                const geoService = this.propertyTypeDetectorService.getGeoService(value, allKeys);
+                if (geoService) {
+                    const propertiesForLayerName = allKeys.filter((p) => geoService.propertiesForLayerName.includes(p));
+                    // providing the the first matching regex;
+                    const propertyForLayerName = propertiesForLayerName.length
+                        ? propertiesForLayerName[0]
+                        : undefined;
+                    if (propertyForLayerName) {
+                        geoServiceAssociations.push({
+                            url: value,
+                            urlProperty: key,
+                            layerNameProperty: propertyForLayerName,
+                            geoService
+                        });
+                    }
+                }
+            });
+        });
+        const geoServiceStates = [];
+        geoServiceAssociations.map((geoServiceAssociation) => {
+            const url = geoServiceAssociation.url;
+            const type = geoServiceAssociation.geoService.type || 'wms';
+            distinctValues[geoServiceAssociation.layerNameProperty].map((layerName) => {
+                let appliedLayerName = layerName;
+                let arcgisLayerName = undefined;
+                if (['arcgisrest', 'imagearcgisrest', 'tilearcgisrest'].includes(type)) {
+                    appliedLayerName = undefined;
+                    arcgisLayerName = layerName;
+                }
+                const so = ObjectUtils.removeUndefined({
+                    sourceOptions: {
+                        type: type || 'wms',
+                        url,
+                        optionsFromCapabilities: true,
+                        optionsFromApi: true,
+                        params: {
+                            LAYERS: appliedLayerName,
+                            LAYER: arcgisLayerName
+                        }
+                    }
+                });
+                const potentialLayerId = generateIdFromSourceOptions(so.sourceOptions);
+                geoServiceStates.push({
+                    geoServiceAssociation,
+                    state: {
+                        added: layersId.find((l) => l === potentialLayerId) !== undefined,
+                        haveGeoServiceProperties: true,
+                        type,
+                        url,
+                        layerName
+                    }
+                });
+            });
+        });
+        geoServiceStates.map((geoServiceState) => {
+            const urlProperty = geoServiceState.geoServiceAssociation.urlProperty;
+            const layerNameProperty = geoServiceState.geoServiceAssociation.layerNameProperty;
+            const urlValue = geoServiceState.state.url;
+            const layerNameValue = geoServiceState.state.layerName;
+            const entitiesToProcess = entities.filter((e) => e.properties[urlProperty] === urlValue &&
+                e.properties[layerNameProperty] === layerNameValue);
+            const ns = {
+                geoService: geoServiceState.state
+            };
+            store.state.updateMany(entitiesToProcess, ns, true);
+        });
+    }
+    /**
+     * Stop watching for a store's OL source changes
+     * @param store Feature store
+     */
+    unwatchStore(store) {
+        const key = this.stores$$.get(store);
+        if (key !== undefined) {
+            this.stores$$.delete(store);
+        }
+    }
+    /**
+     * Stop watching for OL source changes in all stores.
+     */
+    unwatchAll() {
+        this.stores$$.clear();
+        this.states$$.map((state) => state.unsubscribe());
+        if (this.empty$$) {
+            this.empty$$.unsubscribe();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geo-properties.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/feature/shared/strategies/geo-properties.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityStoreStrategy } from '@igo2/common';\r\nimport { CapabilitiesService } from '../../../datasource/shared/capabilities.service';\r\nimport { FeatureStore } from '../store';\r\nimport {\r\n  Feature,\r\n  FeatureStorePropertyTypeStrategyOptions\r\n} from '../feature.interfaces';\r\nimport { Subscription, debounceTime, pairwise } from 'rxjs';\r\nimport { PropertyTypeDetectorService } from '../../../utils/propertyTypeDetector/propertyTypeDetector.service';\r\nimport { ObjectUtils } from '@igo2/utils';\r\nimport { generateIdFromSourceOptions } from '../../../utils/id-generator';\r\nimport { IgoMap } from '../../../map/shared/map';\r\nimport { Layer } from '../../../layer/shared/layers/layer';\r\nimport { GeoServiceDefinition } from '../../../utils';\r\n\r\n/**\r\n * This strategy maintain the store features updated to detect geoproperties\r\n * (wms/arcgis... layer and url).\r\n * The features's state inside the map are tagged haveGeoServiceProperties = true;\r\n */\r\nexport class GeoPropertiesStrategy extends EntityStoreStrategy {\r\n  /**\r\n   * Subscription to the store's OL source changes\r\n   */\r\n  private stores$$ = new Map<FeatureStore, string>();\r\n  private states$$: Subscription[] = [];\r\n  private empty$$: Subscription;\r\n\r\n  /**\r\n   * The map the layer is bound to\r\n   */\r\n  private readonly map: IgoMap;\r\n\r\n  constructor(\r\n    protected options: FeatureStorePropertyTypeStrategyOptions,\r\n    private propertyTypeDetectorService: PropertyTypeDetectorService,\r\n    private capabilitiesService: CapabilitiesService\r\n  ) {\r\n    super(options);\r\n    this.map = options.map;\r\n  }\r\n\r\n  /**\r\n   * Bind this strategy to a store and start watching for Ol source changes\r\n   * @param store Feature store\r\n   */\r\n  bindStore(store: FeatureStore) {\r\n    super.bindStore(store);\r\n    if (this.active === true) {\r\n      this.watchStore(store);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Unbind this strategy from a store and stop watching for Ol source changes\r\n   * @param store Feature store\r\n   */\r\n  unbindStore(store: FeatureStore) {\r\n    super.unbindStore(store);\r\n    if (this.active === true) {\r\n      this.unwatchStore(store);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Start watching all stores already bound to that strategy at once.\r\n   * @internal\r\n   */\r\n  protected doActivate() {\r\n    this.stores.forEach((store: FeatureStore) => this.watchStore(store));\r\n  }\r\n\r\n  /**\r\n   * Stop watching all stores bound to that strategy\r\n   * @internal\r\n   */\r\n  protected doDeactivate() {\r\n    this.unwatchAll();\r\n  }\r\n\r\n  /**\r\n   * Watch for a store's  OL source changes\r\n   * @param store Feature store\r\n   */\r\n  private watchStore(store: FeatureStore) {\r\n    if (this.stores$$.has(store)) {\r\n      return;\r\n    }\r\n\r\n    this.updateEntitiesPropertiesState(store);\r\n    this.states$$.push(\r\n      this.map.layers$\r\n        .pipe(debounceTime(750), pairwise())\r\n        .subscribe(([prevLayers, currentLayers]) => {\r\n          let prevLayersId;\r\n          if (prevLayers) {\r\n            prevLayersId = prevLayers.map((l) => l.id);\r\n          }\r\n          const layers = currentLayers.filter(\r\n            (l) => !prevLayersId.includes(l.id)\r\n          );\r\n          this.updateEntitiesPropertiesState(store, layers);\r\n        })\r\n    );\r\n    this.states$$.push(\r\n      store.entities$.pipe(debounceTime(750)).subscribe((a) => {\r\n        this.updateEntitiesPropertiesState(store);\r\n      })\r\n    );\r\n  }\r\n\r\n  private updateEntitiesPropertiesState(store: FeatureStore, layers?: Layer[]) {\r\n    const layersId = this.map.layers.map((l) => l.id);\r\n    let entities: Feature[] = [];\r\n    if (layers) {\r\n      entities = store.entities$.value;\r\n    } else {\r\n      const allSV = store.stateView.all();\r\n      entities = allSV.length\r\n        ? store.stateView\r\n            .all()\r\n            .filter((s) => !s.state.geoService)\r\n            .map((e) => e.entity)\r\n        : store.entities$.value;\r\n    }\r\n    const sampling = entities.length >= 250 ? 250 : entities.length;\r\n    const firstN = entities.slice(0, sampling);\r\n    let allKeys = [];\r\n    firstN.map((e) => {\r\n      allKeys = allKeys.concat(Object.keys(e.properties || {}));\r\n    });\r\n    allKeys = [...new Set(allKeys)];\r\n    const distinctValues = {};\r\n    allKeys.map((k) => {\r\n      distinctValues[k] = [\r\n        ...new Set(entities.map((item) => item.properties[k]))\r\n      ];\r\n    });\r\n    const containGeoServices = {};\r\n    Object.entries(distinctValues).forEach((entry: [string, []]) => {\r\n      const [key, values] = entry;\r\n      const valuedAreGeoservices = values.filter((value) =>\r\n        this.propertyTypeDetectorService.isGeoService(value)\r\n      );\r\n      if (valuedAreGeoservices?.length) {\r\n        containGeoServices[key] = valuedAreGeoservices;\r\n      }\r\n    });\r\n    interface GeoServiceAssociation {\r\n      url: string;\r\n      layerNameProperty: string;\r\n      urlProperty: string;\r\n      geoService: GeoServiceDefinition;\r\n    }\r\n    const geoServiceAssociations: GeoServiceAssociation[] = [];\r\n    Object.entries(containGeoServices).forEach((entry: [string, []]) => {\r\n      const [key, values] = entry;\r\n      values.map((value) => {\r\n        const geoService = this.propertyTypeDetectorService.getGeoService(\r\n          value,\r\n          allKeys\r\n        );\r\n        if (geoService) {\r\n          const propertiesForLayerName = allKeys.filter((p) =>\r\n            geoService.propertiesForLayerName.includes(p)\r\n          );\r\n          // providing the the first matching regex;\r\n          const propertyForLayerName = propertiesForLayerName.length\r\n            ? propertiesForLayerName[0]\r\n            : undefined;\r\n          if (propertyForLayerName) {\r\n            geoServiceAssociations.push({\r\n              url: value,\r\n              urlProperty: key,\r\n              layerNameProperty: propertyForLayerName,\r\n              geoService\r\n            });\r\n          }\r\n        }\r\n      });\r\n    });\r\n    const geoServiceStates: {\r\n      geoServiceAssociation: GeoServiceAssociation;\r\n      state: any;\r\n    }[] = [];\r\n    geoServiceAssociations.map((geoServiceAssociation) => {\r\n      const url = geoServiceAssociation.url;\r\n      const type = geoServiceAssociation.geoService.type || 'wms';\r\n      distinctValues[geoServiceAssociation.layerNameProperty].map(\r\n        (layerName) => {\r\n          let appliedLayerName = layerName;\r\n          let arcgisLayerName = undefined;\r\n          if (\r\n            ['arcgisrest', 'imagearcgisrest', 'tilearcgisrest'].includes(type)\r\n          ) {\r\n            appliedLayerName = undefined;\r\n            arcgisLayerName = layerName;\r\n          }\r\n          const so = ObjectUtils.removeUndefined({\r\n            sourceOptions: {\r\n              type: type || 'wms',\r\n              url,\r\n              optionsFromCapabilities: true,\r\n              optionsFromApi: true,\r\n              params: {\r\n                LAYERS: appliedLayerName,\r\n                LAYER: arcgisLayerName\r\n              }\r\n            }\r\n          });\r\n          const potentialLayerId = generateIdFromSourceOptions(\r\n            so.sourceOptions\r\n          );\r\n          geoServiceStates.push({\r\n            geoServiceAssociation,\r\n            state: {\r\n              added: layersId.find((l) => l === potentialLayerId) !== undefined,\r\n              haveGeoServiceProperties: true,\r\n              type,\r\n              url,\r\n              layerName\r\n            }\r\n          });\r\n        }\r\n      );\r\n    });\r\n    geoServiceStates.map((geoServiceState) => {\r\n      const urlProperty = geoServiceState.geoServiceAssociation.urlProperty;\r\n      const layerNameProperty =\r\n        geoServiceState.geoServiceAssociation.layerNameProperty;\r\n\r\n      const urlValue = geoServiceState.state.url;\r\n      const layerNameValue = geoServiceState.state.layerName;\r\n      const entitiesToProcess = entities.filter(\r\n        (e) =>\r\n          e.properties[urlProperty] === urlValue &&\r\n          e.properties[layerNameProperty] === layerNameValue\r\n      );\r\n      const ns = {\r\n        geoService: geoServiceState.state\r\n      };\r\n      store.state.updateMany(entitiesToProcess, ns, true);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Stop watching for a store's OL source changes\r\n   * @param store Feature store\r\n   */\r\n  private unwatchStore(store: FeatureStore) {\r\n    const key = this.stores$$.get(store);\r\n    if (key !== undefined) {\r\n      this.stores$$.delete(store);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Stop watching for OL source changes in all stores.\r\n   */\r\n  private unwatchAll() {\r\n    this.stores$$.clear();\r\n    this.states$$.map((state) => state.unsubscribe());\r\n    if (this.empty$$) {\r\n      this.empty$$.unsubscribe();\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/feature/shared/strategies/in-map-extent.mjs

@@ -0,0 +1,115 @@
+import * as olextent from 'ol/extent';
+import { EntityStoreStrategy } from '@igo2/common';
+import { skipWhile } from 'rxjs/operators';
+/**
+ * This strategy maintain the store features updated while the map is moved.
+ * The features's state inside the map are tagged inMapExtent = true;
+ */
+export class FeatureStoreInMapExtentStrategy extends EntityStoreStrategy {
+    options;
+    /**
+     * Subscription to the store's OL source changes
+     */
+    stores$$ = new Map();
+    states$$ = [];
+    empty$$;
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    /**
+     * Bind this strategy to a store and start watching for Ol source changes
+     * @param store Feature store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.watchStore(store);
+        }
+        this.empty$$ = store.empty$
+            .pipe(skipWhile((empty) => !empty))
+            .subscribe(() => this.updateEntitiesInExtent(store));
+    }
+    /**
+     * Unbind this strategy from a store and stop watching for Ol source changes
+     * @param store Feature store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unwatchStore(store);
+        }
+    }
+    /**
+     * Start watching all stores already bound to that strategy at once.
+     * @internal
+     */
+    doActivate() {
+        this.stores.forEach((store) => this.watchStore(store));
+    }
+    /**
+     * Stop watching all stores bound to that strategy
+     * @internal
+     */
+    doDeactivate() {
+        this.unwatchAll();
+    }
+    /**
+     * Watch for a store's  OL source changes
+     * @param store Feature store
+     */
+    watchStore(store) {
+        if (this.stores$$.has(store)) {
+            return;
+        }
+        this.updateEntitiesInExtent(store);
+        this.states$$.push(store.layer.map.viewController.state$.subscribe(() => {
+            this.updateEntitiesInExtent(store);
+        }));
+    }
+    updateEntitiesInExtent(store) {
+        if (store?.layer?.map?.viewController) {
+            store.state.updateAll({ inMapExtent: false });
+            const mapExtent = store.layer.map.viewController.getExtent();
+            let entitiesInMapExtent = [];
+            let entitiesWithNoGeom = [];
+            for (const entity of store.entities$.value) {
+                if (entity.ol) {
+                    if (olextent.intersects(entity.ol.getGeometry().getExtent(), mapExtent)) {
+                        entitiesInMapExtent.push(entity);
+                    }
+                }
+                else {
+                    entitiesWithNoGeom.push(entity);
+                }
+            }
+            if (entitiesInMapExtent.length > 0) {
+                store.state.updateMany(entitiesInMapExtent, { inMapExtent: true }, false);
+            }
+            if (entitiesWithNoGeom.length > 0) {
+                store.state.updateMany(entitiesWithNoGeom, { inMapExtent: true }, false);
+            }
+        }
+    }
+    /**
+     * Stop watching for a store's OL source changes
+     * @param store Feature store
+     */
+    unwatchStore(store) {
+        const key = this.stores$$.get(store);
+        if (key !== undefined) {
+            this.stores$$.delete(store);
+        }
+    }
+    /**
+     * Stop watching for OL source changes in all stores.
+     */
+    unwatchAll() {
+        this.stores$$.clear();
+        this.states$$.map((state) => state.unsubscribe());
+        if (this.empty$$) {
+            this.empty$$.unsubscribe();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"in-map-extent.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/feature/shared/strategies/in-map-extent.ts"],"names":[],"mappings":"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","sourcesContent":["import * as olextent from 'ol/extent';\r\n\r\nimport { EntityStoreStrategy } from '@igo2/common';\r\n\r\nimport { FeatureStore } from '../store';\r\nimport { FeatureStoreInMapExtentStrategyOptions } from '../feature.interfaces';\r\nimport { Subscription } from 'rxjs';\r\nimport { skipWhile } from 'rxjs/operators';\r\n\r\n/**\r\n * This strategy maintain the store features updated while the map is moved.\r\n * The features's state inside the map are tagged inMapExtent = true;\r\n */\r\nexport class FeatureStoreInMapExtentStrategy extends EntityStoreStrategy {\r\n  /**\r\n   * Subscription to the store's OL source changes\r\n   */\r\n  private stores$$ = new Map<FeatureStore, string>();\r\n  private states$$: Subscription[] = [];\r\n  private empty$$: Subscription;\r\n\r\n  constructor(protected options: FeatureStoreInMapExtentStrategyOptions) {\r\n    super(options);\r\n  }\r\n\r\n  /**\r\n   * Bind this strategy to a store and start watching for Ol source changes\r\n   * @param store Feature store\r\n   */\r\n  bindStore(store: FeatureStore) {\r\n    super.bindStore(store);\r\n    if (this.active === true) {\r\n      this.watchStore(store);\r\n    }\r\n    this.empty$$ = store.empty$\r\n      .pipe(skipWhile((empty) => !empty))\r\n      .subscribe(() => this.updateEntitiesInExtent(store));\r\n  }\r\n\r\n  /**\r\n   * Unbind this strategy from a store and stop watching for Ol source changes\r\n   * @param store Feature store\r\n   */\r\n  unbindStore(store: FeatureStore) {\r\n    super.unbindStore(store);\r\n    if (this.active === true) {\r\n      this.unwatchStore(store);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Start watching all stores already bound to that strategy at once.\r\n   * @internal\r\n   */\r\n  protected doActivate() {\r\n    this.stores.forEach((store: FeatureStore) => this.watchStore(store));\r\n  }\r\n\r\n  /**\r\n   * Stop watching all stores bound to that strategy\r\n   * @internal\r\n   */\r\n  protected doDeactivate() {\r\n    this.unwatchAll();\r\n  }\r\n\r\n  /**\r\n   * Watch for a store's  OL source changes\r\n   * @param store Feature store\r\n   */\r\n  private watchStore(store: FeatureStore) {\r\n    if (this.stores$$.has(store)) {\r\n      return;\r\n    }\r\n\r\n    this.updateEntitiesInExtent(store);\r\n    this.states$$.push(\r\n      store.layer.map.viewController.state$.subscribe(() => {\r\n        this.updateEntitiesInExtent(store);\r\n      })\r\n    );\r\n  }\r\n\r\n  private updateEntitiesInExtent(store) {\r\n    if (store?.layer?.map?.viewController) {\r\n      store.state.updateAll({ inMapExtent: false });\r\n      const mapExtent = store.layer.map.viewController.getExtent();\r\n      let entitiesInMapExtent = [];\r\n      let entitiesWithNoGeom = [];\r\n      for (const entity of store.entities$.value) {\r\n        if (entity.ol) {\r\n          if (\r\n            olextent.intersects(entity.ol.getGeometry().getExtent(), mapExtent)\r\n          ) {\r\n            entitiesInMapExtent.push(entity);\r\n          }\r\n        } else {\r\n          entitiesWithNoGeom.push(entity);\r\n        }\r\n      }\r\n      if (entitiesInMapExtent.length > 0) {\r\n        store.state.updateMany(\r\n          entitiesInMapExtent,\r\n          { inMapExtent: true },\r\n          false\r\n        );\r\n      }\r\n      if (entitiesWithNoGeom.length > 0) {\r\n        store.state.updateMany(\r\n          entitiesWithNoGeom,\r\n          { inMapExtent: true },\r\n          false\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Stop watching for a store's OL source changes\r\n   * @param store Feature store\r\n   */\r\n  private unwatchStore(store: FeatureStore) {\r\n    const key = this.stores$$.get(store);\r\n    if (key !== undefined) {\r\n      this.stores$$.delete(store);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Stop watching for OL source changes in all stores.\r\n   */\r\n  private unwatchAll() {\r\n    this.stores$$.clear();\r\n    this.states$$.map((state) => state.unsubscribe());\r\n    if (this.empty$$) {\r\n      this.empty$$.unsubscribe();\r\n    }\r\n  }\r\n}\r\n"]}