@igo2/geo 18.0.1-next.2 → 18.0.2

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

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

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

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

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

@@ -0,0 +1,119 @@
+import { EntityStoreStrategy } from '@igo2/common/entity';
+import * as olextent from 'ol/extent';
+import { debounceTime, 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);
+        const map = store.map ?? store.layer.map;
+        if (map) {
+            this.states$$.push(map.viewController.state$
+                .pipe(debounceTime(250))
+                .subscribe(() => this.updateEntitiesInExtent(store)));
+        }
+    }
+    updateEntitiesInExtent(store) {
+        if (store?.layer?.map?.viewController) {
+            store.state.updateAll({ inMapExtent: false });
+            const mapExtent = store.layer.map.viewController.getExtent();
+            const features = store.entities$.value;
+            const entitiesInMapExtent = this.getFeaturesInExtent(features, mapExtent);
+            store.state.updateMany(entitiesInMapExtent, { inMapExtent: true }, false);
+        }
+    }
+    getFeaturesInExtent(features, extent) {
+        return features.reduce((acc, feature) => {
+            const geom = feature.ol?.getGeometry();
+            if (geom) {
+                const featureExtent = geom.getExtent();
+                if (olextent.intersects(featureExtent, extent)) {
+                    acc.push(feature);
+                }
+            }
+            else {
+                // By default, keep entity with no geometry
+                acc.push(feature);
+            }
+            return acc;
+        }, []);
+    }
+    /**
+     * 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 { EntityStoreStrategy } from '@igo2/common/entity';\n\nimport * as olextent from 'ol/extent';\n\nimport { Subscription } from 'rxjs';\nimport { debounceTime, skipWhile } from 'rxjs/operators';\n\nimport { MapExtent } from '../../../map/shared/map.interface';\nimport {\n  Feature,\n  FeatureStoreInMapExtentStrategyOptions\n} from '../feature.interfaces';\nimport { FeatureStore } from '../store';\n\n/**\n * This strategy maintain the store features updated while the map is moved.\n * The features's state inside the map are tagged inMapExtent = true;\n */\nexport class FeatureStoreInMapExtentStrategy extends EntityStoreStrategy {\n  /**\n   * Subscription to the store's OL source changes\n   */\n  private stores$$ = new Map<FeatureStore, string>();\n  private states$$: Subscription[] = [];\n  private empty$$: Subscription;\n\n  constructor(protected options: FeatureStoreInMapExtentStrategyOptions) {\n    super(options);\n  }\n\n  /**\n   * Bind this strategy to a store and start watching for Ol source changes\n   * @param store Feature store\n   */\n  bindStore(store: FeatureStore) {\n    super.bindStore(store);\n    if (this.active === true) {\n      this.watchStore(store);\n    }\n    this.empty$$ = store.empty$\n      .pipe(skipWhile((empty) => !empty))\n      .subscribe(() => this.updateEntitiesInExtent(store));\n  }\n\n  /**\n   * Unbind this strategy from a store and stop watching for Ol source changes\n   * @param store Feature store\n   */\n  unbindStore(store: FeatureStore) {\n    super.unbindStore(store);\n    if (this.active === true) {\n      this.unwatchStore(store);\n    }\n  }\n\n  /**\n   * Start watching all stores already bound to that strategy at once.\n   * @internal\n   */\n  protected doActivate() {\n    this.stores.forEach((store: FeatureStore) => this.watchStore(store));\n  }\n\n  /**\n   * Stop watching all stores bound to that strategy\n   * @internal\n   */\n  protected doDeactivate() {\n    this.unwatchAll();\n  }\n\n  /**\n   * Watch for a store's  OL source changes\n   * @param store Feature store\n   */\n  private watchStore(store: FeatureStore) {\n    if (this.stores$$.has(store)) {\n      return;\n    }\n\n    this.updateEntitiesInExtent(store);\n    const map = store.map ?? store.layer.map;\n    if (map) {\n      this.states$$.push(\n        map.viewController.state$\n          .pipe(debounceTime(250))\n          .subscribe(() => this.updateEntitiesInExtent(store))\n      );\n    }\n  }\n\n  private updateEntitiesInExtent(store: FeatureStore) {\n    if (store?.layer?.map?.viewController) {\n      store.state.updateAll({ inMapExtent: false });\n      const mapExtent = store.layer.map.viewController.getExtent();\n      const features = store.entities$.value;\n      const entitiesInMapExtent = this.getFeaturesInExtent(features, mapExtent);\n      store.state.updateMany(entitiesInMapExtent, { inMapExtent: true }, false);\n    }\n  }\n\n  private getFeaturesInExtent(\n    features: Feature<any>[],\n    extent: MapExtent\n  ): Feature[] {\n    return features.reduce((acc, feature) => {\n      const geom = feature.ol?.getGeometry();\n      if (geom) {\n        const featureExtent = geom.getExtent();\n\n        if (olextent.intersects(featureExtent, extent)) {\n          acc.push(feature);\n        }\n      } else {\n        // By default, keep entity with no geometry\n        acc.push(feature);\n      }\n      return acc;\n    }, []);\n  }\n\n  /**\n   * Stop watching for a store's OL source changes\n   * @param store Feature store\n   */\n  private unwatchStore(store: FeatureStore) {\n    const key = this.stores$$.get(store);\n    if (key !== undefined) {\n      this.stores$$.delete(store);\n    }\n  }\n\n  /**\n   * Stop watching for OL source changes in all stores.\n   */\n  private unwatchAll() {\n    this.stores$$.clear();\n    this.states$$.map((state) => state.unsubscribe());\n    if (this.empty$$) {\n      this.empty$$.unsubscribe();\n    }\n  }\n}\n"]}