@igo2/geo 1.12.1 → 1.13.0-alpha.0

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

@@ -0,0 +1,35 @@
+import { Workspace } from '@igo2/common';
+import { BehaviorSubject } from 'rxjs';
+export class FeatureWorkspace extends Workspace {
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.inResolutionRange$ = new BehaviorSubject(true);
+        this.map.viewController.resolution$.subscribe((mapResolution) => {
+            if (mapResolution > this.layer.minResolution && mapResolution < this.layer.maxResolution) {
+                this.inResolutionRange$.next(true);
+            }
+            else {
+                this.inResolutionRange$.next(false);
+            }
+        });
+    }
+    get layer() { return this.options.layer; }
+    get map() { return this.options.map; }
+    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/esm2020/lib/workspace/shared/feature-workspace.service.mjs

@@ -0,0 +1,150 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ActionStore, EntityStoreFilterCustomFuncStrategy, EntityStoreFilterSelectionStrategy, EntityTableColumnRenderer } from '@igo2/common';
+import { FeatureStore, FeatureStoreLoadingLayerStrategy, FeatureStoreSelectionStrategy, FeatureStoreInMapExtentStrategy, FeatureMotion, FeatureStoreInMapResolutionStrategy } from '../../feature';
+import { VectorLayer } from '../../layer';
+import { FeatureDataSource } from '../../datasource';
+import { getCommonVectorSelectedStyle } from '../../utils';
+import { FeatureWorkspace } from './feature-workspace';
+import { skipWhile, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+export class FeatureWorkspaceService {
+    constructor(storageService, configService) {
+        this.storageService = storageService;
+        this.configService = configService;
+        this.ws$ = new BehaviorSubject(undefined);
+    }
+    get zoomAuto() {
+        return this.storageService.get('zoomAuto');
+    }
+    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
+            }
+        });
+        this.createTableTemplate(wks, layer);
+        return wks;
+    }
+    createFeatureStore(layer, map) {
+        const store = new FeatureStore([], { map });
+        store.bindLayer(layer);
+        const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});
+        const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});
+        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(inMapResolutionStrategy, true);
+        store.addStrategy(selectionStrategy, true);
+        store.addStrategy(selectedRecordStrategy, false);
+        store.addStrategy(this.createFilterInMapExtentOrResolutionStrategy(), true);
+        return store;
+    }
+    createTableTemplate(workspace, layer) {
+        const fields = layer.dataSource.options.sourceFields || [];
+        const relations = layer.dataSource.options.relations || [];
+        if (fields.length === 0) {
+            workspace.entityStore.entities$.pipe(skipWhile(val => val.length === 0), take(1)).subscribe(entities => {
+                const ol = entities[0].ol;
+                const columnsFromFeatures = ol.getKeys()
+                    .filter(col => !col.startsWith('_') &&
+                    col !== 'geometry' &&
+                    col !== ol.getGeometryName() &&
+                    !col.match(/boundedby/gi))
+                    .map(key => {
+                    return {
+                        name: `properties.${key}`,
+                        title: key,
+                        renderer: EntityTableColumnRenderer.UnsanitizedHTML
+                    };
+                });
+                workspace.meta.tableTemplate = {
+                    selection: true,
+                    sort: true,
+                    columns: columnsFromFeatures
+                };
+            });
+            return;
+        }
+        const columns = fields.map((field) => {
+            return {
+                name: `properties.${field.name}`,
+                title: field.alias ? field.alias : field.name,
+                renderer: EntityTableColumnRenderer.UnsanitizedHTML,
+                tooltip: field.tooltip
+            };
+        });
+        const relationsColumn = relations.map((relation) => {
+            return {
+                name: `properties.${relation.name}`,
+                title: relation.alias ? relation.alias : relation.name,
+                renderer: EntityTableColumnRenderer.Icon,
+                icon: relation.icon,
+                parent: relation.parent,
+                type: 'relation',
+                tooltip: relation.tooltip,
+                onClick: () => {
+                    this.ws$.next(relation.title);
+                },
+                cellClassFunc: () => {
+                    return { 'class_icon': true };
+                }
+            };
+        });
+        columns.push(...relationsColumn);
+        workspace.meta.tableTemplate = {
+            selection: true,
+            sort: true,
+            columns
+        };
+    }
+    createFilterInMapExtentOrResolutionStrategy() {
+        const filterClauseFunc = (record) => {
+            return record.state.inMapExtent === true && record.state.inMapResolution === true;
+        };
+        return new EntityStoreFilterCustomFuncStrategy({ filterClauseFunc });
+    }
+}
+FeatureWorkspaceService.ɵfac = function FeatureWorkspaceService_Factory(t) { return new (t || FeatureWorkspaceService)(i0.ɵɵinject(i1.StorageService), i0.ɵɵinject(i1.ConfigService)); };
+FeatureWorkspaceService.ɵ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 }]; }, 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';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport {\r\n  ActionStore,\r\n  EntityTableTemplate,\r\n  EntityStoreFilterCustomFuncStrategy,\r\n  EntityRecord,\r\n  EntityStoreStrategyFuncOptions,\r\n  EntityStoreFilterSelectionStrategy,\r\n  EntityTableColumnRenderer\r\n} from '@igo2/common';\r\n\r\nimport {\r\n  FeatureStore,\r\n  FeatureStoreLoadingLayerStrategy,\r\n  FeatureStoreSelectionStrategy,\r\n  FeatureStoreInMapExtentStrategy,\r\n  Feature,\r\n  FeatureMotion,\r\n  FeatureStoreInMapResolutionStrategy\r\n} from '../../feature';\r\nimport { VectorLayer } from '../../layer';\r\nimport { GeoWorkspaceOptions } from '../../layer/shared/layers/layer.interface';\r\nimport { IgoMap } from '../../map';\r\nimport { SourceFieldsOptionsParams, FeatureDataSource, RelationOptions } from '../../datasource';\r\nimport { getCommonVectorSelectedStyle} from '../../utils';\r\n\r\nimport { FeatureWorkspace } from './feature-workspace';\r\nimport { skipWhile, take } from 'rxjs/operators';\r\nimport { ConfigService, StorageService } from '@igo2/core';\r\n\r\nimport olFeature from 'ol/Feature';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class FeatureWorkspaceService {\r\n\r\n  get zoomAuto(): boolean {\r\n    return this.storageService.get('zoomAuto') as boolean;\r\n  }\r\n\r\n  public ws$ = new BehaviorSubject<string>(undefined);\r\n\r\n  constructor(private storageService: StorageService, private configService: ConfigService) {}\r\n\r\n  createWorkspace(layer: VectorLayer, map: IgoMap): FeatureWorkspace {\r\n    if (layer.options.workspace?.enabled === false || layer.dataSource.options.edition) {\r\n      return;\r\n    }\r\n\r\n    layer.options.workspace = Object.assign({}, layer.options.workspace,\r\n      {\r\n        srcId: layer.id,\r\n        workspaceId: layer.id,\r\n        enabled: true\r\n      } as GeoWorkspaceOptions);\r\n\r\n\r\n    const wks = new FeatureWorkspace({\r\n      id: layer.id,\r\n      title: layer.title,\r\n      layer,\r\n      map,\r\n      entityStore: this.createFeatureStore(layer, map),\r\n      actionStore: new ActionStore([]),\r\n      meta: {\r\n        tableTemplate: undefined\r\n      }\r\n    });\r\n    this.createTableTemplate(wks, layer);\r\n    return wks;\r\n\r\n  }\r\n\r\n  private createFeatureStore(layer: VectorLayer, map: IgoMap): FeatureStore {\r\n    const store = new FeatureStore([], {map});\r\n    store.bindLayer(layer);\r\n\r\n    const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});\r\n    const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});\r\n    const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});\r\n    const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});\r\n    const confQueryOverlayStyle= this.configService.getConfig('queryOverlayStyle');\r\n\r\n    const selectionStrategy = new FeatureStoreSelectionStrategy({\r\n      layer: new VectorLayer({\r\n        zIndex: 300,\r\n        source: new FeatureDataSource(),\r\n        style: (feature) => {\r\n          return getCommonVectorSelectedStyle(Object.assign({}, {feature}, confQueryOverlayStyle.selection || {}));\r\n        },\r\n        showInLayerList: false,\r\n        exportable: false,\r\n        browsable: false\r\n      }),\r\n      map,\r\n      hitTolerance: 15,\r\n      motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,\r\n      many: true,\r\n      dragBox: true\r\n    });\r\n    store.addStrategy(loadingStrategy, true);\r\n    store.addStrategy(inMapExtentStrategy, true);\r\n    store.addStrategy(inMapResolutionStrategy, true);\r\n    store.addStrategy(selectionStrategy, true);\r\n    store.addStrategy(selectedRecordStrategy, false);\r\n    store.addStrategy(this.createFilterInMapExtentOrResolutionStrategy(), true);\r\n    return store;\r\n  }\r\n\r\n  private createTableTemplate(workspace: FeatureWorkspace, layer: VectorLayer): EntityTableTemplate {\r\n    const fields = layer.dataSource.options.sourceFields || [];\r\n\r\n    const relations = layer.dataSource.options.relations || [];\r\n\r\n    if (fields.length === 0) {\r\n      workspace.entityStore.entities$.pipe(\r\n        skipWhile(val => val.length === 0),\r\n        take(1)\r\n      ).subscribe(entities => {\r\n        const ol = (entities[0] as Feature).ol as olFeature<OlGeometry>;\r\n        const columnsFromFeatures = ol.getKeys()\r\n        .filter(\r\n          col => !col.startsWith('_') &&\r\n          col !== 'geometry' &&\r\n          col !== ol.getGeometryName() &&\r\n          !col.match(/boundedby/gi))\r\n        .map(key => {\r\n          return {\r\n            name: `properties.${key}`,\r\n            title: key,\r\n            renderer: EntityTableColumnRenderer.UnsanitizedHTML\r\n          };\r\n        });\r\n        workspace.meta.tableTemplate = {\r\n          selection: true,\r\n          sort: true,\r\n          columns: columnsFromFeatures\r\n        };\r\n      });\r\n      return;\r\n    }\r\n    const columns = fields.map((field: SourceFieldsOptionsParams) => {\r\n      return {\r\n        name: `properties.${field.name}`,\r\n        title: field.alias ? field.alias : field.name,\r\n        renderer: EntityTableColumnRenderer.UnsanitizedHTML,\r\n        tooltip: field.tooltip\r\n      };\r\n    });\r\n\r\n    const relationsColumn = relations.map((relation: RelationOptions) => {\r\n      return {\r\n        name: `properties.${relation.name}`,\r\n        title: relation.alias ? relation.alias : relation.name,\r\n        renderer: EntityTableColumnRenderer.Icon,\r\n        icon: relation.icon,\r\n        parent: relation.parent,\r\n        type: 'relation',\r\n        tooltip: relation.tooltip,\r\n        onClick: () => {\r\n            this.ws$.next(relation.title);\r\n        },\r\n        cellClassFunc: () => {\r\n          return { 'class_icon': true };\r\n        }\r\n      };\r\n    });\r\n\r\n    columns.push(...relationsColumn);\r\n    workspace.meta.tableTemplate = {\r\n      selection: true,\r\n      sort: true,\r\n      columns\r\n    };\r\n  }\r\n\r\n  private createFilterInMapExtentOrResolutionStrategy(): EntityStoreFilterCustomFuncStrategy {\r\n    const filterClauseFunc = (record: EntityRecord<object>) => {\r\n      return record.state.inMapExtent === true && record.state.inMapResolution === true;\r\n    };\r\n    return new EntityStoreFilterCustomFuncStrategy({filterClauseFunc} as EntityStoreStrategyFuncOptions);\r\n  }\r\n}\r\n"]}

package/esm2020/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi93b3Jrc3BhY2Uvc2hhcmVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3dmcy13b3Jrc3BhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3dmcy13b3Jrc3BhY2Uuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZmVhdHVyZS13b3Jrc3BhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2ZlYXR1cmUtd29ya3NwYWNlLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2VkaXRpb24td29ya3NwYWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9lZGl0aW9uLXdvcmtzcGFjZS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi93b3Jrc3BhY2UudXRpbHMnO1xyXG4iXX0=

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

@@ -0,0 +1,35 @@
+import { Workspace } from '@igo2/common';
+import { BehaviorSubject } from 'rxjs';
+export class WfsWorkspace extends Workspace {
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.inResolutionRange$ = new BehaviorSubject(true);
+        this.map.viewController.resolution$.subscribe((mapResolution) => {
+            if (mapResolution > this.layer.minResolution && mapResolution < this.layer.maxResolution) {
+                this.inResolutionRange$.next(true);
+            }
+            else {
+                this.inResolutionRange$.next(false);
+            }
+        });
+    }
+    get layer() { return this.options.layer; }
+    get map() { return this.options.map; }
+    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/esm2020/lib/workspace/shared/wfs-workspace.service.mjs

@@ -0,0 +1,150 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ActionStore, EntityStoreFilterCustomFuncStrategy, EntityStoreFilterSelectionStrategy, EntityTableColumnRenderer } from '@igo2/common';
+import { FeatureStore, FeatureStoreLoadingLayerStrategy, FeatureStoreSelectionStrategy, FeatureStoreInMapExtentStrategy, FeatureMotion, FeatureStoreInMapResolutionStrategy } from '../../feature';
+import { VectorLayer } from '../../layer';
+import { FeatureDataSource } from '../../datasource';
+import { getCommonVectorSelectedStyle } from '../../utils';
+import { WfsWorkspace } from './wfs-workspace';
+import { skipWhile, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+export class WfsWorkspaceService {
+    constructor(storageService, configService) {
+        this.storageService = storageService;
+        this.configService = configService;
+        this.ws$ = new BehaviorSubject(undefined);
+    }
+    get zoomAuto() {
+        return this.storageService.get('zoomAuto');
+    }
+    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
+            }
+        });
+        this.createTableTemplate(wks, layer);
+        return wks;
+    }
+    createFeatureStore(layer, map) {
+        const store = new FeatureStore([], { map });
+        store.bindLayer(layer);
+        const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});
+        const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});
+        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(inMapResolutionStrategy, true);
+        store.addStrategy(selectionStrategy, true);
+        store.addStrategy(selectedRecordStrategy, false);
+        store.addStrategy(this.createFilterInMapExtentOrResolutionStrategy(), true);
+        return store;
+    }
+    createTableTemplate(workspace, layer) {
+        const fields = layer.dataSource.options.sourceFields || [];
+        const relations = layer.dataSource.options.relations || [];
+        if (fields.length === 0) {
+            workspace.entityStore.entities$.pipe(skipWhile(val => val.length === 0), take(1)).subscribe(entities => {
+                const ol = entities[0].ol;
+                const columnsFromFeatures = ol.getKeys()
+                    .filter(col => !col.startsWith('_') &&
+                    col !== 'geometry' &&
+                    col !== ol.getGeometryName() &&
+                    !col.match(/boundedby/gi))
+                    .map(key => {
+                    return {
+                        name: `properties.${key}`,
+                        title: key,
+                        renderer: EntityTableColumnRenderer.UnsanitizedHTML
+                    };
+                });
+                workspace.meta.tableTemplate = {
+                    selection: true,
+                    sort: true,
+                    columns: columnsFromFeatures
+                };
+            });
+            return;
+        }
+        const columns = fields.map((field) => {
+            return {
+                name: `properties.${field.name}`,
+                title: field.alias ? field.alias : field.name,
+                renderer: EntityTableColumnRenderer.UnsanitizedHTML,
+                tooltip: field.tooltip
+            };
+        });
+        const relationsColumn = relations.map((relation) => {
+            return {
+                name: `properties.${relation.name}`,
+                title: relation.alias ? relation.alias : relation.name,
+                renderer: EntityTableColumnRenderer.Icon,
+                icon: relation.icon,
+                parent: relation.parent,
+                type: 'relation',
+                tooltip: relation.tooltip,
+                onClick: () => {
+                    this.ws$.next(relation.title);
+                },
+                cellClassFunc: () => {
+                    return { 'class_icon': true };
+                }
+            };
+        });
+        columns.push(...relationsColumn);
+        workspace.meta.tableTemplate = {
+            selection: true,
+            sort: true,
+            columns
+        };
+    }
+    createFilterInMapExtentOrResolutionStrategy() {
+        const filterClauseFunc = (record) => {
+            return record.state.inMapExtent === true && record.state.inMapResolution === true;
+        };
+        return new EntityStoreFilterCustomFuncStrategy({ filterClauseFunc });
+    }
+}
+WfsWorkspaceService.ɵfac = function WfsWorkspaceService_Factory(t) { return new (t || WfsWorkspaceService)(i0.ɵɵinject(i1.StorageService), i0.ɵɵinject(i1.ConfigService)); };
+WfsWorkspaceService.ɵ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 }]; }, 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';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport {\r\n  ActionStore,\r\n  EntityTableTemplate,\r\n  EntityStoreFilterCustomFuncStrategy,\r\n  EntityRecord,\r\n  EntityStoreStrategyFuncOptions,\r\n  EntityStoreFilterSelectionStrategy,\r\n  EntityTableColumnRenderer\r\n} from '@igo2/common';\r\n\r\nimport {\r\n  FeatureStore,\r\n  FeatureStoreLoadingLayerStrategy,\r\n  FeatureStoreSelectionStrategy,\r\n  FeatureStoreInMapExtentStrategy,\r\n  Feature,\r\n  FeatureMotion,\r\n  FeatureStoreInMapResolutionStrategy\r\n} from '../../feature';\r\nimport { VectorLayer } from '../../layer';\r\nimport { GeoWorkspaceOptions } from '../../layer/shared/layers/layer.interface';\r\nimport { IgoMap } from '../../map';\r\nimport { SourceFieldsOptionsParams, FeatureDataSource, RelationOptions } from '../../datasource';\r\nimport { getCommonVectorSelectedStyle} from '../../utils';\r\n\r\nimport { WfsWorkspace } from './wfs-workspace';\r\nimport { skipWhile, take } from 'rxjs/operators';\r\nimport { StorageService, ConfigService } from '@igo2/core';\r\nimport olFeature from 'ol/Feature';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WfsWorkspaceService {\r\n\r\n  get zoomAuto(): boolean {\r\n    return this.storageService.get('zoomAuto') as boolean;\r\n  }\r\n\r\n  public ws$ = new BehaviorSubject<string>(undefined);\r\n\r\n  constructor(private storageService: StorageService, private configService: ConfigService) {}\r\n\r\n  createWorkspace(layer: VectorLayer, map: IgoMap): WfsWorkspace {\r\n    if (layer.options.workspace?.enabled === false || layer.dataSource.options.edition) {\r\n      return;\r\n    }\r\n\r\n    layer.options.workspace = Object.assign({}, layer.options.workspace,\r\n      {\r\n        srcId: layer.id,\r\n        workspaceId: layer.id,\r\n        enabled: true\r\n      } as GeoWorkspaceOptions);\r\n\r\n    const wks = new WfsWorkspace({\r\n      id: layer.id,\r\n      title: layer.title,\r\n      layer,\r\n      map,\r\n      entityStore: this.createFeatureStore(layer, map),\r\n      actionStore: new ActionStore([]),\r\n      meta: {\r\n        tableTemplate: undefined\r\n      }\r\n    });\r\n    this.createTableTemplate(wks, layer);\r\n    return wks;\r\n  }\r\n\r\n  private createFeatureStore(layer: VectorLayer, map: IgoMap): FeatureStore {\r\n    const store = new FeatureStore([], {map});\r\n    store.bindLayer(layer);\r\n\r\n    const loadingStrategy = new FeatureStoreLoadingLayerStrategy({});\r\n    const inMapExtentStrategy = new FeatureStoreInMapExtentStrategy({});\r\n    const inMapResolutionStrategy = new FeatureStoreInMapResolutionStrategy({});\r\n    const selectedRecordStrategy = new EntityStoreFilterSelectionStrategy({});\r\n    const confQueryOverlayStyle= this.configService.getConfig('queryOverlayStyle');\r\n\r\n    const selectionStrategy = new FeatureStoreSelectionStrategy({\r\n      layer: new VectorLayer({\r\n        zIndex: 300,\r\n        source: new FeatureDataSource(),\r\n        style: (feature) => {\r\n          return getCommonVectorSelectedStyle(Object.assign({}, {feature}, confQueryOverlayStyle.selection || {}));\r\n        },\r\n        showInLayerList: false,\r\n        exportable: false,\r\n        browsable: false\r\n      }),\r\n      map,\r\n      hitTolerance: 15,\r\n      motion: this.zoomAuto ? FeatureMotion.Default : FeatureMotion.None,\r\n      many: true,\r\n      dragBox: true\r\n    });\r\n    store.addStrategy(loadingStrategy, true);\r\n    store.addStrategy(inMapExtentStrategy, true);\r\n    store.addStrategy(inMapResolutionStrategy, true);\r\n    store.addStrategy(selectionStrategy, true);\r\n    store.addStrategy(selectedRecordStrategy, false);\r\n    store.addStrategy(this.createFilterInMapExtentOrResolutionStrategy(), true);\r\n    return store;\r\n  }\r\n\r\n  private createTableTemplate(workspace: WfsWorkspace, layer: VectorLayer): EntityTableTemplate {\r\n    const fields = layer.dataSource.options.sourceFields || [];\r\n\r\n    const relations = layer.dataSource.options.relations || [];\r\n\r\n    if (fields.length === 0) {\r\n      workspace.entityStore.entities$.pipe(\r\n        skipWhile(val => val.length === 0),\r\n        take(1)\r\n      ).subscribe(entities => {\r\n        const ol = (entities[0] as Feature).ol as olFeature<OlGeometry>;\r\n        const columnsFromFeatures = ol.getKeys()\r\n        .filter(\r\n          col => !col.startsWith('_') &&\r\n          col !== 'geometry' &&\r\n          col !== ol.getGeometryName() &&\r\n          !col.match(/boundedby/gi))\r\n        .map(key => {\r\n          return {\r\n            name: `properties.${key}`,\r\n            title: key,\r\n            renderer: EntityTableColumnRenderer.UnsanitizedHTML\r\n          };\r\n        });\r\n        workspace.meta.tableTemplate = {\r\n          selection: true,\r\n          sort: true,\r\n          columns: columnsFromFeatures\r\n        };\r\n      });\r\n      return;\r\n    }\r\n    const columns = fields.map((field: SourceFieldsOptionsParams) => {\r\n      return {\r\n        name: `properties.${field.name}`,\r\n        title: field.alias ? field.alias : field.name,\r\n        renderer: EntityTableColumnRenderer.UnsanitizedHTML,\r\n        tooltip: field.tooltip\r\n      };\r\n    });\r\n\r\n    const relationsColumn = relations.map((relation: RelationOptions) => {\r\n      return {\r\n        name: `properties.${relation.name}`,\r\n        title: relation.alias ? relation.alias : relation.name,\r\n        renderer: EntityTableColumnRenderer.Icon,\r\n        icon: relation.icon,\r\n        parent: relation.parent,\r\n        type: 'relation',\r\n        tooltip: relation.tooltip,\r\n        onClick: () => {\r\n            this.ws$.next(relation.title);\r\n        },\r\n        cellClassFunc: () => {\r\n          return { 'class_icon': true };\r\n        }\r\n      };\r\n    });\r\n\r\n    columns.push(...relationsColumn);\r\n    workspace.meta.tableTemplate = {\r\n      selection: true,\r\n      sort: true,\r\n      columns\r\n    };\r\n  }\r\n  private createFilterInMapExtentOrResolutionStrategy(): EntityStoreFilterCustomFuncStrategy {\r\n    const filterClauseFunc = (record: EntityRecord<object>) => {\r\n      return record.state.inMapExtent === true && record.state.inMapResolution === true;\r\n    };\r\n    return new EntityStoreFilterCustomFuncStrategy({filterClauseFunc} as EntityStoreStrategyFuncOptions);\r\n  }\r\n}\r\n"]}