@igo2/geo 1.15.4 → 16.0.0-rc.1

package/esm2022/lib/workspace/shared/feature-workspace.mjs

@@ -0,0 +1,41 @@
+import { Workspace } from '@igo2/common';
+import { BehaviorSubject } from 'rxjs';
+export class FeatureWorkspace extends Workspace {
+    options;
+    inResolutionRange$ = new BehaviorSubject(true);
+    get layer() {
+        return this.options.layer;
+    }
+    get map() {
+        return this.options.map;
+    }
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.map.viewController.resolution$.subscribe((mapResolution) => {
+            if (mapResolution > this.layer.minResolution &&
+                mapResolution < this.layer.maxResolution) {
+                this.inResolutionRange$.next(true);
+            }
+            else {
+                this.inResolutionRange$.next(false);
+            }
+        });
+    }
+    getLayerWksOptionTabQuery() {
+        if (this.layer.options.workspace.queryOptions?.tabQuery !== undefined) {
+            return this.layer.options.workspace.queryOptions.tabQuery;
+        }
+        return true;
+    }
+    getLayerWksOptionMapQuery() {
+        if (this.layer.options.workspace.queryOptions?.mapQueryOnOpenTab !== undefined) {
+            return this.layer.options.workspace.queryOptions.mapQueryOnOpenTab;
+        }
+        return true;
+    }
+    getInResolutionRange() {
+        return this.inResolutionRange$.value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/workspace/shared/feature-workspace.service.mjs

@@ -0,0 +1,109 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ActionStore, EntityStoreFilterSelectionStrategy } from '@igo2/common';
+import { FeatureStore, FeatureStoreLoadingLayerStrategy, FeatureStoreSelectionStrategy, FeatureStoreInMapExtentStrategy, FeatureMotion, FeatureStoreInMapResolutionStrategy, FeatureStoreSearchIndexStrategy, GeoPropertiesStrategy } from '../../feature';
+import { LayerService, VectorLayer } from '../../layer/shared';
+import { CapabilitiesService, FeatureDataSource } from '../../datasource';
+import { getCommonVectorSelectedStyle } from '../../style/shared/vector/commonVectorStyle';
+import { FeatureWorkspace } from './feature-workspace';
+import { ConfigService, StorageService } from '@igo2/core';
+import { createFilterInMapExtentOrResolutionStrategy, createTableTemplate } from './workspace.utils';
+import { PropertyTypeDetectorService } from '../../utils/propertyTypeDetector/propertyTypeDetector.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+import * as i2 from "../../layer/shared";
+import * as i3 from "../../utils/propertyTypeDetector/propertyTypeDetector.service";
+import * as i4 from "../../datasource";
+export class FeatureWorkspaceService {
+    storageService;
+    configService;
+    layerService;
+    propertyTypeDetectorService;
+    capabilitiesService;
+    get zoomAuto() {
+        return this.storageService.get('zoomAuto');
+    }
+    ws$ = new BehaviorSubject(undefined);
+    constructor(storageService, configService, layerService, propertyTypeDetectorService, capabilitiesService) {
+        this.storageService = storageService;
+        this.configService = configService;
+        this.layerService = layerService;
+        this.propertyTypeDetectorService = propertyTypeDetectorService;
+        this.capabilitiesService = capabilitiesService;
+    }
+    createWorkspace(layer, map) {
+        if (layer.options.workspace?.enabled === false ||
+            layer.dataSource.options.edition) {
+            return;
+        }
+        layer.options.workspace = Object.assign({}, layer.options.workspace, {
+            srcId: layer.id,
+            workspaceId: layer.id,
+            enabled: true
+        });
+        const wks = new FeatureWorkspace({
+            id: layer.id,
+            title: layer.title,
+            layer,
+            map,
+            entityStore: this.createFeatureStore(layer, map),
+            actionStore: new ActionStore([]),
+            meta: {
+                tableTemplate: undefined
+            }
+        });
+        createTableTemplate(wks, layer, this.layerService, this.ws$);
+        return wks;
+    }
+    createFeatureStore(layer, map) {
+        const store = new FeatureStore([], { map });
+        store.bindLayer(layer);
+        const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});
+        const searchStrategy = new FeatureStoreSearchIndexStrategy({
+            percentDistinctValueRatio: 2,
+            sourceFields: layer.dataSource.options.sourceFields
+        });
+        const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});
+        const geoPropertiesStrategy = new GeoPropertiesStrategy({ map }, this.propertyTypeDetectorService, this.capabilitiesService);
+        const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});
+        const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});
+        const confQueryOverlayStyle = this.configService.getConfig('queryOverlayStyle');
+        const selectionStrategy = new FeatureStoreSelectionStrategy({
+            layer: new VectorLayer({
+                zIndex: 300,
+                source: new FeatureDataSource(),
+                style: (feature) => {
+                    return getCommonVectorSelectedStyle(Object.assign({}, { feature }, confQueryOverlayStyle?.selection || {}));
+                },
+                showInLayerList: false,
+                exportable: false,
+                browsable: false
+            }),
+            map,
+            hitTolerance: 15,
+            motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,
+            many: true,
+            dragBox: true
+        });
+        if (layer.options.workspace?.searchIndexEnabled) {
+            store.addStrategy(searchStrategy, true);
+        }
+        store.addStrategy(loadingStrategy, true);
+        store.addStrategy(inMapExtentStrategy, true);
+        store.addStrategy(geoPropertiesStrategy, true);
+        store.addStrategy(inMapResolutionStrategy, true);
+        store.addStrategy(selectionStrategy, true);
+        store.addStrategy(selectedRecordStrategy, false);
+        store.addStrategy(createFilterInMapExtentOrResolutionStrategy(), true);
+        return store;
+    }
+    static ɵfac = function FeatureWorkspaceService_Factory(t) { return new (t || FeatureWorkspaceService)(i0.ɵɵinject(i1.StorageService), i0.ɵɵinject(i1.ConfigService), i0.ɵɵinject(i2.LayerService), i0.ɵɵinject(i3.PropertyTypeDetectorService), i0.ɵɵinject(i4.CapabilitiesService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FeatureWorkspaceService, factory: FeatureWorkspaceService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FeatureWorkspaceService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.StorageService }, { type: i1.ConfigService }, { type: i2.LayerService }, { type: i3.PropertyTypeDetectorService }, { type: i4.CapabilitiesService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-workspace.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/workspace/shared/feature-workspace.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { ActionStore, EntityStoreFilterSelectionStrategy } from '@igo2/common';\n\nimport {\n  FeatureStore,\n  FeatureStoreLoadingLayerStrategy,\n  FeatureStoreSelectionStrategy,\n  FeatureStoreInMapExtentStrategy,\n  FeatureMotion,\n  FeatureStoreInMapResolutionStrategy,\n  FeatureStoreSearchIndexStrategy,\n  GeoPropertiesStrategy\n} from '../../feature';\nimport { LayerService, VectorLayer } from '../../layer/shared';\nimport { GeoWorkspaceOptions } from '../../layer/shared/layers/layer.interface';\nimport { IgoMap } from '../../map/shared';\nimport { CapabilitiesService, FeatureDataSource } from '../../datasource';\nimport { getCommonVectorSelectedStyle } from '../../style/shared/vector/commonVectorStyle';\n\nimport { FeatureWorkspace } from './feature-workspace';\nimport { ConfigService, StorageService } from '@igo2/core';\n\nimport {\n  createFilterInMapExtentOrResolutionStrategy,\n  createTableTemplate\n} from './workspace.utils';\nimport { PropertyTypeDetectorService } from '../../utils/propertyTypeDetector/propertyTypeDetector.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class FeatureWorkspaceService {\n  get zoomAuto(): boolean {\n    return this.storageService.get('zoomAuto') as boolean;\n  }\n\n  public ws$ = new BehaviorSubject<string>(undefined);\n\n  constructor(\n    private storageService: StorageService,\n    private configService: ConfigService,\n    private layerService: LayerService,\n    private propertyTypeDetectorService: PropertyTypeDetectorService,\n    private capabilitiesService: CapabilitiesService\n  ) {}\n\n  createWorkspace(layer: VectorLayer, map: IgoMap): FeatureWorkspace {\n    if (\n      layer.options.workspace?.enabled === false ||\n      layer.dataSource.options.edition\n    ) {\n      return;\n    }\n\n    layer.options.workspace = Object.assign({}, layer.options.workspace, {\n      srcId: layer.id,\n      workspaceId: layer.id,\n      enabled: true\n    } as GeoWorkspaceOptions);\n\n    const wks = new FeatureWorkspace({\n      id: layer.id,\n      title: layer.title,\n      layer,\n      map,\n      entityStore: this.createFeatureStore(layer, map),\n      actionStore: new ActionStore([]),\n      meta: {\n        tableTemplate: undefined\n      }\n    });\n    createTableTemplate(wks, layer, this.layerService, this.ws$);\n    return wks;\n  }\n\n  private createFeatureStore(layer: VectorLayer, map: IgoMap): FeatureStore {\n    const store = new FeatureStore([], { map });\n    store.bindLayer(layer);\n\n    const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});\n    const searchStrategy = new FeatureStoreSearchIndexStrategy({\n      percentDistinctValueRatio: 2,\n      sourceFields: layer.dataSource.options.sourceFields\n    });\n    const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});\n    const geoPropertiesStrategy = new GeoPropertiesStrategy(\n      { map },\n      this.propertyTypeDetectorService,\n      this.capabilitiesService\n    );\n    const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});\n    const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});\n    const confQueryOverlayStyle =\n      this.configService.getConfig('queryOverlayStyle');\n\n    const selectionStrategy = new FeatureStoreSelectionStrategy({\n      layer: new VectorLayer({\n        zIndex: 300,\n        source: new FeatureDataSource(),\n        style: (feature) => {\n          return getCommonVectorSelectedStyle(\n            Object.assign(\n              {},\n              { feature },\n              confQueryOverlayStyle?.selection || {}\n            )\n          );\n        },\n        showInLayerList: false,\n        exportable: false,\n        browsable: false\n      }),\n      map,\n      hitTolerance: 15,\n      motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,\n      many: true,\n      dragBox: true\n    });\n    if (layer.options.workspace?.searchIndexEnabled) {\n      store.addStrategy(searchStrategy, true);\n    }\n    store.addStrategy(loadingStrategy, true);\n    store.addStrategy(inMapExtentStrategy, true);\n    store.addStrategy(geoPropertiesStrategy, true);\n    store.addStrategy(inMapResolutionStrategy, true);\n    store.addStrategy(selectionStrategy, true);\n    store.addStrategy(selectedRecordStrategy, false);\n    store.addStrategy(createFilterInMapExtentOrResolutionStrategy(), true);\n    return store;\n  }\n}\n"]}

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

@@ -0,0 +1,8 @@
+export * from './wfs-workspace';
+export * from './wfs-workspace.service';
+export * from './feature-workspace';
+export * from './feature-workspace.service';
+export * from './edition-workspace';
+export * from './edition-workspace.service';
+export * from './workspace.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi93b3Jrc3BhY2Uvc2hhcmVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3dmcy13b3Jrc3BhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi93ZnMtd29ya3NwYWNlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mZWF0dXJlLXdvcmtzcGFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZlYXR1cmUtd29ya3NwYWNlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9lZGl0aW9uLXdvcmtzcGFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2VkaXRpb24td29ya3NwYWNlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi93b3Jrc3BhY2UudXRpbHMnO1xuIl19

package/esm2022/lib/workspace/shared/wfs-workspace.mjs

@@ -0,0 +1,41 @@
+import { Workspace } from '@igo2/common';
+import { BehaviorSubject } from 'rxjs';
+export class WfsWorkspace extends Workspace {
+    options;
+    inResolutionRange$ = new BehaviorSubject(true);
+    get layer() {
+        return this.options.layer;
+    }
+    get map() {
+        return this.options.map;
+    }
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.map.viewController.resolution$.subscribe((mapResolution) => {
+            if (mapResolution > this.layer.minResolution &&
+                mapResolution < this.layer.maxResolution) {
+                this.inResolutionRange$.next(true);
+            }
+            else {
+                this.inResolutionRange$.next(false);
+            }
+        });
+    }
+    getLayerWksOptionTabQuery() {
+        if (this.layer.options.workspace.queryOptions?.tabQuery !== undefined) {
+            return this.layer.options.workspace.queryOptions.tabQuery;
+        }
+        return true;
+    }
+    getLayerWksOptionMapQuery() {
+        if (this.layer.options.workspace.queryOptions?.mapQueryOnOpenTab !== undefined) {
+            return this.layer.options.workspace.queryOptions.mapQueryOnOpenTab;
+        }
+        return true;
+    }
+    getInResolutionRange() {
+        return this.inResolutionRange$.value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/workspace/shared/wfs-workspace.service.mjs

@@ -0,0 +1,102 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ActionStore, EntityStoreFilterSelectionStrategy } from '@igo2/common';
+import { FeatureStore, FeatureStoreLoadingLayerStrategy, FeatureStoreSelectionStrategy, FeatureStoreInMapExtentStrategy, FeatureMotion, FeatureStoreInMapResolutionStrategy, GeoPropertiesStrategy } from '../../feature';
+import { LayerService, VectorLayer } from '../../layer/shared';
+import { CapabilitiesService, FeatureDataSource } from '../../datasource';
+import { getCommonVectorSelectedStyle } from '../../style/shared/vector/commonVectorStyle';
+import { WfsWorkspace } from './wfs-workspace';
+import { StorageService, ConfigService } from '@igo2/core';
+import { createFilterInMapExtentOrResolutionStrategy, createTableTemplate } from './workspace.utils';
+import { PropertyTypeDetectorService } from '../../utils/propertyTypeDetector';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+import * as i2 from "../../layer/shared";
+import * as i3 from "../../utils/propertyTypeDetector";
+import * as i4 from "../../datasource";
+export class WfsWorkspaceService {
+    storageService;
+    configService;
+    layerService;
+    propertyTypeDetectorService;
+    capabilitiesService;
+    get zoomAuto() {
+        return this.storageService.get('zoomAuto');
+    }
+    ws$ = new BehaviorSubject(undefined);
+    constructor(storageService, configService, layerService, propertyTypeDetectorService, capabilitiesService) {
+        this.storageService = storageService;
+        this.configService = configService;
+        this.layerService = layerService;
+        this.propertyTypeDetectorService = propertyTypeDetectorService;
+        this.capabilitiesService = capabilitiesService;
+    }
+    createWorkspace(layer, map) {
+        if (layer.options.workspace?.enabled === false ||
+            layer.dataSource.options.edition) {
+            return;
+        }
+        layer.options.workspace = Object.assign({}, layer.options.workspace, {
+            srcId: layer.id,
+            workspaceId: layer.id,
+            enabled: true
+        });
+        const wks = new WfsWorkspace({
+            id: layer.id,
+            title: layer.title,
+            layer,
+            map,
+            entityStore: this.createFeatureStore(layer, map),
+            actionStore: new ActionStore([]),
+            meta: {
+                tableTemplate: undefined
+            }
+        });
+        createTableTemplate(wks, layer, this.layerService, this.ws$);
+        return wks;
+    }
+    createFeatureStore(layer, map) {
+        const store = new FeatureStore([], { map });
+        store.bindLayer(layer);
+        const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});
+        const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});
+        const geoPropertiesStrategy = new GeoPropertiesStrategy({ map }, this.propertyTypeDetectorService, this.capabilitiesService);
+        const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});
+        const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});
+        const confQueryOverlayStyle = this.configService.getConfig('queryOverlayStyle');
+        const selectionStrategy = new FeatureStoreSelectionStrategy({
+            layer: new VectorLayer({
+                zIndex: 300,
+                source: new FeatureDataSource(),
+                style: (feature) => {
+                    return getCommonVectorSelectedStyle(Object.assign({}, { feature }, confQueryOverlayStyle?.selection || {}));
+                },
+                showInLayerList: false,
+                exportable: false,
+                browsable: false
+            }),
+            map,
+            hitTolerance: 15,
+            motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,
+            many: true,
+            dragBox: true
+        });
+        store.addStrategy(loadingStrategy, true);
+        store.addStrategy(inMapExtentStrategy, true);
+        store.addStrategy(geoPropertiesStrategy, true);
+        store.addStrategy(inMapResolutionStrategy, true);
+        store.addStrategy(selectionStrategy, true);
+        store.addStrategy(selectedRecordStrategy, false);
+        store.addStrategy(createFilterInMapExtentOrResolutionStrategy(), true);
+        return store;
+    }
+    static ɵfac = function WfsWorkspaceService_Factory(t) { return new (t || WfsWorkspaceService)(i0.ɵɵinject(i1.StorageService), i0.ɵɵinject(i1.ConfigService), i0.ɵɵinject(i2.LayerService), i0.ɵɵinject(i3.PropertyTypeDetectorService), i0.ɵɵinject(i4.CapabilitiesService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WfsWorkspaceService, factory: WfsWorkspaceService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WfsWorkspaceService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.StorageService }, { type: i1.ConfigService }, { type: i2.LayerService }, { type: i3.PropertyTypeDetectorService }, { type: i4.CapabilitiesService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wfs-workspace.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/workspace/shared/wfs-workspace.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { ActionStore, EntityStoreFilterSelectionStrategy } from '@igo2/common';\n\nimport {\n  FeatureStore,\n  FeatureStoreLoadingLayerStrategy,\n  FeatureStoreSelectionStrategy,\n  FeatureStoreInMapExtentStrategy,\n  FeatureMotion,\n  FeatureStoreInMapResolutionStrategy,\n  GeoPropertiesStrategy\n} from '../../feature';\nimport { LayerService, VectorLayer } from '../../layer/shared';\nimport { GeoWorkspaceOptions } from '../../layer/shared/layers/layer.interface';\nimport { IgoMap } from '../../map/shared';\nimport { CapabilitiesService, FeatureDataSource } from '../../datasource';\nimport { getCommonVectorSelectedStyle } from '../../style/shared/vector/commonVectorStyle';\n\nimport { WfsWorkspace } from './wfs-workspace';\nimport { StorageService, ConfigService } from '@igo2/core';\nimport {\n  createFilterInMapExtentOrResolutionStrategy,\n  createTableTemplate\n} from './workspace.utils';\nimport { PropertyTypeDetectorService } from '../../utils/propertyTypeDetector';\n@Injectable({\n  providedIn: 'root'\n})\nexport class WfsWorkspaceService {\n  get zoomAuto(): boolean {\n    return this.storageService.get('zoomAuto') as boolean;\n  }\n\n  public ws$ = new BehaviorSubject<string>(undefined);\n\n  constructor(\n    private storageService: StorageService,\n    private configService: ConfigService,\n    private layerService: LayerService,\n    private propertyTypeDetectorService: PropertyTypeDetectorService,\n    private capabilitiesService: CapabilitiesService\n  ) {}\n\n  createWorkspace(layer: VectorLayer, map: IgoMap): WfsWorkspace {\n    if (\n      layer.options.workspace?.enabled === false ||\n      layer.dataSource.options.edition\n    ) {\n      return;\n    }\n\n    layer.options.workspace = Object.assign({}, layer.options.workspace, {\n      srcId: layer.id,\n      workspaceId: layer.id,\n      enabled: true\n    } as GeoWorkspaceOptions);\n\n    const wks = new WfsWorkspace({\n      id: layer.id,\n      title: layer.title,\n      layer,\n      map,\n      entityStore: this.createFeatureStore(layer, map),\n      actionStore: new ActionStore([]),\n      meta: {\n        tableTemplate: undefined\n      }\n    });\n    createTableTemplate(wks, layer, this.layerService, this.ws$);\n    return wks;\n  }\n\n  private createFeatureStore(layer: VectorLayer, map: IgoMap): FeatureStore {\n    const store = new FeatureStore([], { map });\n    store.bindLayer(layer);\n\n    const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});\n    const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});\n    const geoPropertiesStrategy = new GeoPropertiesStrategy(\n      { map },\n      this.propertyTypeDetectorService,\n      this.capabilitiesService\n    );\n    const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});\n    const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});\n    const confQueryOverlayStyle =\n      this.configService.getConfig('queryOverlayStyle');\n\n    const selectionStrategy = new FeatureStoreSelectionStrategy({\n      layer: new VectorLayer({\n        zIndex: 300,\n        source: new FeatureDataSource(),\n        style: (feature) => {\n          return getCommonVectorSelectedStyle(\n            Object.assign(\n              {},\n              { feature },\n              confQueryOverlayStyle?.selection || {}\n            )\n          );\n        },\n        showInLayerList: false,\n        exportable: false,\n        browsable: false\n      }),\n      map,\n      hitTolerance: 15,\n      motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,\n      many: true,\n      dragBox: true\n    });\n    store.addStrategy(loadingStrategy, true);\n    store.addStrategy(inMapExtentStrategy, true);\n    store.addStrategy(geoPropertiesStrategy, true);\n    store.addStrategy(inMapResolutionStrategy, true);\n    store.addStrategy(selectionStrategy, true);\n    store.addStrategy(selectedRecordStrategy, false);\n    store.addStrategy(createFilterInMapExtentOrResolutionStrategy(), true);\n    return store;\n  }\n}\n"]}

package/esm2022/lib/workspace/shared/wms-workspace.service.mjs

@@ -0,0 +1,225 @@
+import { Injectable } from '@angular/core';
+import { ActionStore, EntityStoreFilterSelectionStrategy } from '@igo2/common';
+import { StorageService, ConfigService } from '@igo2/core';
+import { CapabilitiesService } from '../../datasource';
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { FeatureMotion, FeatureStore, FeatureStoreInMapExtentStrategy, FeatureStoreInMapResolutionStrategy, FeatureStoreLoadingLayerStrategy, FeatureStoreSelectionStrategy, GeoPropertiesStrategy } from '../../feature';
+import { LayerService, LinkedProperties, VectorLayer } from '../../layer/shared';
+import { StyleService } from '../../style/style-service/style.service';
+import { WfsWorkspace } from './wfs-workspace';
+import { getCommonVectorSelectedStyle } from '../../style/shared/vector/commonVectorStyle';
+import { PropertyTypeDetectorService } from '../../utils/propertyTypeDetector/propertyTypeDetector.service';
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { createFilterInMapExtentOrResolutionStrategy, createTableTemplate } from './workspace.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../layer/shared";
+import * as i2 from "@igo2/core";
+import * as i3 from "../../datasource";
+import * as i4 from "../../style/style-service/style.service";
+import * as i5 from "../../utils/propertyTypeDetector/propertyTypeDetector.service";
+export class WmsWorkspaceService {
+    layerService;
+    storageService;
+    capabilitiesService;
+    styleService;
+    configService;
+    propertyTypeDetectorService;
+    get zoomAuto() {
+        return this.storageService.get('zoomAuto');
+    }
+    ws$ = new BehaviorSubject(undefined);
+    constructor(layerService, storageService, capabilitiesService, styleService, configService, propertyTypeDetectorService) {
+        this.layerService = layerService;
+        this.storageService = storageService;
+        this.capabilitiesService = capabilitiesService;
+        this.styleService = styleService;
+        this.configService = configService;
+        this.propertyTypeDetectorService = propertyTypeDetectorService;
+    }
+    createWorkspace(layer, map) {
+        if (!layer.options.workspace ||
+            map.layers.find((lay) => lay.id === layer.id + '.WfsWorkspaceTableDest') ||
+            layer.dataSource.options.edition) {
+            return;
+        }
+        const dataSource = layer.dataSource;
+        const wmsLinkId = layer.id + '.WmsWorkspaceTableSrc';
+        const wfsLinkId = layer.id + '.WfsWorkspaceTableDest';
+        if (!layer.options.linkedLayers) {
+            layer.options.linkedLayers = { linkId: wmsLinkId, links: [] };
+        }
+        const linkProperties = {
+            syncedDelete: true,
+            linkedIds: [wfsLinkId],
+            properties: [LinkedProperties.ZINDEX, LinkedProperties.VISIBLE]
+        };
+        if (!layer.options.workspace?.minResolution) {
+            linkProperties.properties.push(LinkedProperties.MINRESOLUTION);
+        }
+        let hasOgcFilters = false;
+        if (dataSource.options.ogcFilters?.enabled) {
+            linkProperties.properties.push(LinkedProperties.OGCFILTERS);
+            hasOgcFilters = true;
+        }
+        if (!layer.options.workspace?.maxResolution) {
+            linkProperties.properties.push(LinkedProperties.MAXRESOLUTION);
+        }
+        let clonedLinks = [];
+        if (layer.options.linkedLayers.links) {
+            clonedLinks = JSON.parse(JSON.stringify(layer.options.linkedLayers.links));
+        }
+        clonedLinks.push(linkProperties);
+        (layer.options.linkedLayers.linkId = layer.options.linkedLayers.linkId
+            ? layer.options.linkedLayers.linkId
+            : wmsLinkId),
+            (layer.options.linkedLayers.links = clonedLinks);
+        let wks;
+        let wksLayerOption = {
+            printable: layer.options.workspace?.printable,
+            srcId: layer.id,
+            workspaceId: undefined,
+            enabled: false,
+            queryOptions: {
+                mapQueryOnOpenTab: layer.options.workspace?.queryOptions?.mapQueryOnOpenTab,
+                tabQuery: layer.options.workspace?.queryOptions?.tabQuery
+            },
+            pageSize: layer.options.workspace?.pageSize,
+            pageSizeOptions: layer.options.workspace?.pageSizeOptions
+        };
+        this.layerService
+            .createAsyncLayer({
+            isIgoInternalLayer: true,
+            id: wfsLinkId,
+            linkedLayers: {
+                linkId: wfsLinkId
+            },
+            workspace: wksLayerOption,
+            showInLayerList: false,
+            opacity: 0,
+            title: layer.title,
+            minResolution: layer.options.workspace?.minResolution || layer.minResolution || 0,
+            maxResolution: layer.options.workspace?.maxResolution ||
+                layer.maxResolution ||
+                Infinity,
+            style: this.styleService.createStyle({
+                fill: {
+                    color: 'rgba(255, 255, 255, 0.01)'
+                },
+                stroke: {
+                    color: 'rgba(255, 255, 255, 0.01)'
+                },
+                circle: {
+                    fill: {
+                        color: 'rgba(255, 255, 255, 0.01)'
+                    },
+                    stroke: {
+                        color: 'rgba(255, 255, 255, 0.01)'
+                    },
+                    radius: 5
+                }
+            }),
+            sourceOptions: {
+                download: dataSource.options.download,
+                type: 'wfs',
+                url: dataSource.options.urlWfs || dataSource.options.url,
+                queryable: true,
+                relations: dataSource.options.relations,
+                queryTitle: dataSource.options
+                    .queryTitle,
+                queryFormatAsWms: layer.options.workspace?.enabled
+                    ? dataSource.options
+                        .queryFormatAsWms
+                    : true,
+                params: dataSource.options.paramsWFS,
+                ogcFilters: Object.assign({}, dataSource.ogcFilters, {
+                    enabled: hasOgcFilters
+                }),
+                sourceFields: dataSource.options.sourceFields || undefined
+            }
+        })
+            .subscribe((workspaceLayer) => {
+            map.addLayer(workspaceLayer);
+            layer.ol.setProperties({
+                linkedLayers: {
+                    linkId: layer.options.linkedLayers.linkId,
+                    links: clonedLinks
+                }
+            }, false);
+            workspaceLayer.dataSource.ol.refresh();
+            if (!layer.options.workspace?.enabled) {
+                return;
+            }
+            wks = new WfsWorkspace({
+                id: layer.id,
+                title: layer.title,
+                layer: workspaceLayer,
+                map,
+                entityStore: this.createFeatureStore(workspaceLayer, map),
+                actionStore: new ActionStore([]),
+                meta: {
+                    tableTemplate: undefined
+                }
+            });
+            createTableTemplate(wks, workspaceLayer, this.layerService, this.ws$);
+            workspaceLayer.options.workspace.workspaceId = workspaceLayer.id;
+            layer.options.workspace = Object.assign({}, layer.options.workspace, {
+                enabled: true,
+                srcId: layer.id,
+                workspaceId: workspaceLayer.id,
+                queryOptions: {
+                    mapQueryOnOpenTab: layer.options.workspace?.queryOptions?.mapQueryOnOpenTab,
+                    tabQuery: layer.options.workspace?.queryOptions?.tabQuery
+                },
+                pageSize: layer.options.workspace?.pageSize,
+                pageSizeOptions: layer.options.workspace?.pageSizeOptions
+            });
+            delete dataSource.options.download;
+            return wks;
+        });
+        return wks;
+    }
+    createFeatureStore(layer, map) {
+        const store = new FeatureStore([], { map });
+        store.bindLayer(layer);
+        const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});
+        const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});
+        const geoPropertiesStrategy = new GeoPropertiesStrategy({ map }, this.propertyTypeDetectorService, this.capabilitiesService);
+        const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});
+        const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});
+        const confQueryOverlayStyle = this.configService.getConfig('queryOverlayStyle');
+        const selectionStrategy = new FeatureStoreSelectionStrategy({
+            layer: new VectorLayer({
+                zIndex: 300,
+                source: new FeatureDataSource(),
+                style: (feature) => {
+                    return getCommonVectorSelectedStyle(Object.assign({}, { feature }, confQueryOverlayStyle?.selection || {}));
+                },
+                showInLayerList: false,
+                exportable: false,
+                browsable: false
+            }),
+            map,
+            hitTolerance: 15,
+            motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,
+            many: true,
+            dragBox: true
+        });
+        store.addStrategy(loadingStrategy, true);
+        store.addStrategy(inMapExtentStrategy, true);
+        store.addStrategy(geoPropertiesStrategy, true);
+        store.addStrategy(inMapResolutionStrategy, true);
+        store.addStrategy(selectionStrategy, true);
+        store.addStrategy(selectedRecordStrategy, false);
+        store.addStrategy(createFilterInMapExtentOrResolutionStrategy(), true);
+        return store;
+    }
+    static ɵfac = function WmsWorkspaceService_Factory(t) { return new (t || WmsWorkspaceService)(i0.ɵɵinject(i1.LayerService), i0.ɵɵinject(i2.StorageService), i0.ɵɵinject(i3.CapabilitiesService), i0.ɵɵinject(i4.StyleService), i0.ɵɵinject(i2.ConfigService), i0.ɵɵinject(i5.PropertyTypeDetectorService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WmsWorkspaceService, factory: WmsWorkspaceService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WmsWorkspaceService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.LayerService }, { type: i2.StorageService }, { type: i3.CapabilitiesService }, { type: i4.StyleService }, { type: i2.ConfigService }, { type: i5.PropertyTypeDetectorService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wms-workspace.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/workspace/shared/wms-workspace.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ActionStore, EntityStoreFilterSelectionStrategy } from '@igo2/common';\nimport { StorageService, ConfigService } from '@igo2/core';\nimport { CapabilitiesService, WMSDataSource } from '../../datasource';\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\nimport { WFSDataSourceOptions } from '../../datasource/shared/datasources/wfs-datasource.interface';\nimport {\n  FeatureMotion,\n  FeatureStore,\n  FeatureStoreInMapExtentStrategy,\n  FeatureStoreInMapResolutionStrategy,\n  FeatureStoreLoadingLayerStrategy,\n  FeatureStoreSelectionStrategy,\n  GeoPropertiesStrategy\n} from '../../feature';\n\nimport { OgcFilterableDataSourceOptions } from '../../filter/shared/ogc-filter.interface';\nimport {\n  ImageLayer,\n  LayerService,\n  LayersLinkProperties,\n  LinkedProperties,\n  VectorLayer\n} from '../../layer/shared';\nimport { StyleService } from '../../style/style-service/style.service';\nimport { GeoWorkspaceOptions } from '../../layer/shared/layers/layer.interface';\nimport { IgoMap } from '../../map/shared';\nimport { QueryableDataSourceOptions } from '../../query/shared/query.interfaces';\nimport { WfsWorkspace } from './wfs-workspace';\nimport { getCommonVectorSelectedStyle } from '../../style/shared/vector/commonVectorStyle';\n\nimport { PropertyTypeDetectorService } from '../../utils/propertyTypeDetector/propertyTypeDetector.service';\nimport { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';\nimport {\n  createFilterInMapExtentOrResolutionStrategy,\n  createTableTemplate\n} from './workspace.utils';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class WmsWorkspaceService {\n  get zoomAuto(): boolean {\n    return this.storageService.get('zoomAuto') as boolean;\n  }\n\n  public ws$ = new BehaviorSubject<string>(undefined);\n\n  constructor(\n    private layerService: LayerService,\n    private storageService: StorageService,\n    private capabilitiesService: CapabilitiesService,\n    private styleService: StyleService,\n    private configService: ConfigService,\n    private propertyTypeDetectorService: PropertyTypeDetectorService\n  ) {}\n\n  createWorkspace(layer: ImageLayer, map: IgoMap): WfsWorkspace {\n    if (\n      !layer.options.workspace ||\n      map.layers.find(\n        (lay) => lay.id === layer.id + '.WfsWorkspaceTableDest'\n      ) ||\n      layer.dataSource.options.edition\n    ) {\n      return;\n    }\n    const dataSource: WMSDataSource = layer.dataSource as WMSDataSource;\n    const wmsLinkId = layer.id + '.WmsWorkspaceTableSrc';\n    const wfsLinkId = layer.id + '.WfsWorkspaceTableDest';\n    if (!layer.options.linkedLayers) {\n      layer.options.linkedLayers = { linkId: wmsLinkId, links: [] };\n    }\n    const linkProperties = {\n      syncedDelete: true,\n      linkedIds: [wfsLinkId],\n      properties: [LinkedProperties.ZINDEX, LinkedProperties.VISIBLE]\n    } as LayersLinkProperties;\n\n    if (!layer.options.workspace?.minResolution) {\n      linkProperties.properties.push(LinkedProperties.MINRESOLUTION);\n    }\n    let hasOgcFilters = false;\n    if (\n      (dataSource.options as OgcFilterableDataSourceOptions).ogcFilters?.enabled\n    ) {\n      linkProperties.properties.push(LinkedProperties.OGCFILTERS);\n      hasOgcFilters = true;\n    }\n    if (!layer.options.workspace?.maxResolution) {\n      linkProperties.properties.push(LinkedProperties.MAXRESOLUTION);\n    }\n\n    let clonedLinks: LayersLinkProperties[] = [];\n    if (layer.options.linkedLayers.links) {\n      clonedLinks = JSON.parse(\n        JSON.stringify(layer.options.linkedLayers.links)\n      );\n    }\n    clonedLinks.push(linkProperties);\n\n    (layer.options.linkedLayers.linkId = layer.options.linkedLayers.linkId\n      ? layer.options.linkedLayers.linkId\n      : wmsLinkId),\n      (layer.options.linkedLayers.links = clonedLinks);\n    interface WFSoptions\n      extends WFSDataSourceOptions,\n        OgcFilterableDataSourceOptions {}\n\n    let wks;\n    let wksLayerOption: GeoWorkspaceOptions = {\n      printable: layer.options.workspace?.printable,\n      srcId: layer.id,\n      workspaceId: undefined,\n      enabled: false,\n      queryOptions: {\n        mapQueryOnOpenTab:\n          layer.options.workspace?.queryOptions?.mapQueryOnOpenTab,\n        tabQuery: layer.options.workspace?.queryOptions?.tabQuery\n      },\n      pageSize: layer.options.workspace?.pageSize,\n      pageSizeOptions: layer.options.workspace?.pageSizeOptions\n    };\n\n    this.layerService\n      .createAsyncLayer({\n        isIgoInternalLayer: true,\n        id: wfsLinkId,\n        linkedLayers: {\n          linkId: wfsLinkId\n        },\n        workspace: wksLayerOption,\n        showInLayerList: false,\n        opacity: 0,\n        title: layer.title,\n        minResolution:\n          layer.options.workspace?.minResolution || layer.minResolution || 0,\n        maxResolution:\n          layer.options.workspace?.maxResolution ||\n          layer.maxResolution ||\n          Infinity,\n        style: this.styleService.createStyle({\n          fill: {\n            color: 'rgba(255, 255, 255, 0.01)'\n          },\n          stroke: {\n            color: 'rgba(255, 255, 255, 0.01)'\n          },\n          circle: {\n            fill: {\n              color: 'rgba(255, 255, 255, 0.01)'\n            },\n            stroke: {\n              color: 'rgba(255, 255, 255, 0.01)'\n            },\n            radius: 5\n          }\n        }),\n        sourceOptions: {\n          download: dataSource.options.download,\n          type: 'wfs',\n          url: dataSource.options.urlWfs || dataSource.options.url,\n          queryable: true,\n          relations: dataSource.options.relations,\n          queryTitle: (dataSource.options as QueryableDataSourceOptions)\n            .queryTitle,\n          queryFormatAsWms: layer.options.workspace?.enabled\n            ? (dataSource.options as QueryableDataSourceOptions)\n                .queryFormatAsWms\n            : true,\n          params: dataSource.options.paramsWFS,\n          ogcFilters: Object.assign({}, dataSource.ogcFilters, {\n            enabled: hasOgcFilters\n          }),\n          sourceFields: dataSource.options.sourceFields || undefined\n        } as WFSoptions\n      })\n      .subscribe((workspaceLayer: VectorLayer) => {\n        map.addLayer(workspaceLayer);\n        layer.ol.setProperties(\n          {\n            linkedLayers: {\n              linkId: layer.options.linkedLayers.linkId,\n              links: clonedLinks\n            }\n          },\n          false\n        );\n        workspaceLayer.dataSource.ol.refresh();\n\n        if (!layer.options.workspace?.enabled) {\n          return;\n        }\n        wks = new WfsWorkspace({\n          id: layer.id,\n          title: layer.title,\n          layer: workspaceLayer,\n          map,\n          entityStore: this.createFeatureStore(workspaceLayer, map),\n          actionStore: new ActionStore([]),\n          meta: {\n            tableTemplate: undefined\n          }\n        });\n        createTableTemplate(wks, workspaceLayer, this.layerService, this.ws$);\n\n        workspaceLayer.options.workspace.workspaceId = workspaceLayer.id;\n        layer.options.workspace = Object.assign({}, layer.options.workspace, {\n          enabled: true,\n          srcId: layer.id,\n          workspaceId: workspaceLayer.id,\n          queryOptions: {\n            mapQueryOnOpenTab:\n              layer.options.workspace?.queryOptions?.mapQueryOnOpenTab,\n            tabQuery: layer.options.workspace?.queryOptions?.tabQuery\n          },\n          pageSize: layer.options.workspace?.pageSize,\n          pageSizeOptions: layer.options.workspace?.pageSizeOptions\n        } as GeoWorkspaceOptions);\n\n        delete dataSource.options.download;\n        return wks;\n      });\n\n    return wks;\n  }\n\n  private createFeatureStore(layer: VectorLayer, map: IgoMap): FeatureStore {\n    const store = new FeatureStore([], { map });\n    store.bindLayer(layer);\n\n    const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});\n    const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});\n    const geoPropertiesStrategy = new GeoPropertiesStrategy(\n      { map },\n      this.propertyTypeDetectorService,\n      this.capabilitiesService\n    );\n    const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});\n    const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});\n    const confQueryOverlayStyle =\n      this.configService.getConfig('queryOverlayStyle');\n\n    const selectionStrategy = new FeatureStoreSelectionStrategy({\n      layer: new VectorLayer({\n        zIndex: 300,\n        source: new FeatureDataSource(),\n        style: (feature) => {\n          return getCommonVectorSelectedStyle(\n            Object.assign(\n              {},\n              { feature },\n              confQueryOverlayStyle?.selection || {}\n            )\n          );\n        },\n        showInLayerList: false,\n        exportable: false,\n        browsable: false\n      }),\n      map,\n      hitTolerance: 15,\n      motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,\n      many: true,\n      dragBox: true\n    });\n    store.addStrategy(loadingStrategy, true);\n    store.addStrategy(inMapExtentStrategy, true);\n    store.addStrategy(geoPropertiesStrategy, true);\n    store.addStrategy(inMapResolutionStrategy, true);\n    store.addStrategy(selectionStrategy, true);\n    store.addStrategy(selectedRecordStrategy, false);\n    store.addStrategy(createFilterInMapExtentOrResolutionStrategy(), true);\n    return store;\n  }\n}\n"]}