@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/workspace/workspace-selector/workspace-selector.directive.mjs

@@ -0,0 +1,172 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { WorkspaceSelectorComponent } from '@igo2/common/workspace';
+import { debounceTime } from 'rxjs/operators';
+import { FeatureDataSource, WFSDataSource, WMSDataSource } from '../../datasource/shared/datasources';
+import { FeatureStoreInMapExtentStrategy } from '../../feature/shared/strategies/in-map-extent';
+import { isLayerGroup } from '../../layer';
+import { IgoMap } from '../../map/shared/map';
+import { EditionWorkspaceService } from '../shared/edition-workspace.service';
+import { FeatureWorkspaceService } from '../shared/feature-workspace.service';
+import { WfsWorkspaceService } from '../shared/wfs-workspace.service';
+import { WmsWorkspaceService } from '../shared/wms-workspace.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/common/workspace";
+import * as i2 from "../shared/wfs-workspace.service";
+import * as i3 from "../shared/wms-workspace.service";
+import * as i4 from "../shared/edition-workspace.service";
+import * as i5 from "../shared/feature-workspace.service";
+export class WorkspaceSelectorDirective {
+    component;
+    wfsWorkspaceService;
+    wmsWorkspaceService;
+    editionWorkspaceService;
+    featureWorkspaceService;
+    layers$$;
+    entities$$ = [];
+    map;
+    changeWorkspace = new EventEmitter();
+    disableSwitch = new EventEmitter();
+    relationLayers = new EventEmitter();
+    rowsInMapExtentCheckCondition = new EventEmitter();
+    get workspaceStore() {
+        return this.component.store;
+    }
+    constructor(component, wfsWorkspaceService, wmsWorkspaceService, editionWorkspaceService, featureWorkspaceService) {
+        this.component = component;
+        this.wfsWorkspaceService = wfsWorkspaceService;
+        this.wmsWorkspaceService = wmsWorkspaceService;
+        this.editionWorkspaceService = editionWorkspaceService;
+        this.featureWorkspaceService = featureWorkspaceService;
+    }
+    ngOnInit() {
+        this.layers$$ = this.map.layerController.all$
+            .pipe(debounceTime(50))
+            .subscribe((layers) => this.onLayersChange(layers));
+        this.featureWorkspaceService.ws$.subscribe((ws) => {
+            this.changeWorkspace.emit(ws);
+        });
+        this.wmsWorkspaceService.ws$.subscribe((ws) => {
+            this.changeWorkspace.emit(ws);
+        });
+        this.wfsWorkspaceService.ws$.subscribe((ws) => {
+            this.changeWorkspace.emit(ws);
+        });
+        this.editionWorkspaceService.ws$.subscribe((ws) => {
+            this.changeWorkspace.emit(ws);
+        });
+        this.editionWorkspaceService.adding$.subscribe((adding) => {
+            this.disableSwitch.emit(adding);
+        });
+        this.editionWorkspaceService.relationLayers$.subscribe((layers) => {
+            this.relationLayers.emit(layers);
+        });
+        this.editionWorkspaceService.rowsInMapExtentCheckCondition$.subscribe((condition) => {
+            this.rowsInMapExtentCheckCondition.emit(condition);
+        });
+    }
+    ngOnDestroy() {
+        this.layers$$.unsubscribe();
+        this.entities$$.map((entities) => entities.unsubscribe());
+    }
+    onLayersChange(layers) {
+        const editableLayers = layers.filter((layer) => this.layerIsEditable(layer));
+        const editableLayersIds = editableLayers.map((layer) => layer.id);
+        const workspacesToAdd = editableLayers
+            .map((layer) => this.getOrCreateWorkspace(layer))
+            .filter((workspace) => workspace !== undefined);
+        const workspacesToRemove = this.workspaceStore
+            .all()
+            .filter((workspace) => {
+            return editableLayersIds.indexOf(workspace.id) < 0;
+        });
+        if (workspacesToRemove.length > 0) {
+            workspacesToRemove.forEach((workspace) => {
+                workspace.entityStore.deactivateStrategyOfType(FeatureStoreInMapExtentStrategy);
+                workspace.deactivate();
+            });
+            this.workspaceStore.state.updateMany(workspacesToRemove, {
+                active: false,
+                selected: false
+            });
+            this.workspaceStore.deleteMany(workspacesToRemove);
+        }
+        if (workspacesToAdd.length > 0) {
+            this.workspaceStore.insertMany(workspacesToAdd);
+        }
+    }
+    getOrCreateWorkspace(layer) {
+        const workspace = this.workspaceStore.get(layer.id);
+        if (workspace !== undefined) {
+            return;
+        }
+        if (layer.dataSource instanceof WFSDataSource &&
+            layer.dataSource.options.edition?.enabled !== true) {
+            const wfsWks = this.wfsWorkspaceService.createWorkspace(layer, this.map);
+            return wfsWks;
+        }
+        else if (layer.dataSource instanceof WMSDataSource &&
+            layer.dataSource.options.edition?.enabled !== true) {
+            if (!layer.dataSource.options.paramsWFS) {
+                return;
+            }
+            const wmsWks = this.wmsWorkspaceService.createWorkspace(layer, this.map);
+            wmsWks?.inResolutionRange$.subscribe((inResolutionRange) => {
+                layer.dataSource.options.queryable =
+                    !inResolutionRange;
+                wmsWks.layer.dataSource.options.queryable = inResolutionRange;
+            });
+            return wmsWks;
+        }
+        else if (layer.dataSource instanceof FeatureDataSource &&
+            layer.exportable === true &&
+            layer.dataSource.options.edition?.enabled !== true) {
+            const featureWks = this.featureWorkspaceService.createWorkspace(layer, this.map);
+            return featureWks;
+        }
+        else if (layer.dataSource instanceof WMSDataSource &&
+            layer.dataSource.options.edition?.enabled === true) {
+            const editionWks = this.editionWorkspaceService.createWorkspace(layer, this.map);
+            return editionWks;
+        }
+        return;
+    }
+    layerIsEditable(layer) {
+        if (isLayerGroup(layer)) {
+            return false;
+        }
+        const dataSource = layer.dataSource;
+        if (dataSource instanceof WFSDataSource) {
+            return true;
+        }
+        if (dataSource instanceof FeatureDataSource) {
+            return true;
+        }
+        if (dataSource instanceof WMSDataSource) {
+            const dataSourceOptions = (dataSource.options ||
+                {});
+            return (dataSourceOptions.ogcFilters?.enabled ||
+                dataSource.options.paramsWFS?.featureTypes !== undefined);
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WorkspaceSelectorDirective, deps: [{ token: i1.WorkspaceSelectorComponent }, { token: i2.WfsWorkspaceService }, { token: i3.WmsWorkspaceService }, { token: i4.EditionWorkspaceService }, { token: i5.FeatureWorkspaceService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: WorkspaceSelectorDirective, isStandalone: true, selector: "[igoWorkspaceSelector]", inputs: { map: "map" }, outputs: { changeWorkspace: "changeWorkspace", disableSwitch: "disableSwitch", relationLayers: "relationLayers", rowsInMapExtentCheckCondition: "rowsInMapExtentCheckCondition" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WorkspaceSelectorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igoWorkspaceSelector]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.WorkspaceSelectorComponent }, { type: i2.WfsWorkspaceService }, { type: i3.WmsWorkspaceService }, { type: i4.EditionWorkspaceService }, { type: i5.FeatureWorkspaceService }], propDecorators: { map: [{
+                type: Input
+            }], changeWorkspace: [{
+                type: Output
+            }], disableSwitch: [{
+                type: Output
+            }], relationLayers: [{
+                type: Output
+            }], rowsInMapExtentCheckCondition: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace-selector.directive.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/workspace/workspace-selector/workspace-selector.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output\n} from '@angular/core';\n\nimport {\n  Workspace,\n  WorkspaceSelectorComponent,\n  WorkspaceStore\n} from '@igo2/common/workspace';\n\nimport { Subscription } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\nimport {\n  FeatureDataSource,\n  WFSDataSource,\n  WMSDataSource\n} from '../../datasource/shared/datasources';\nimport { FeatureStoreInMapExtentStrategy } from '../../feature/shared/strategies/in-map-extent';\nimport { OgcFilterableDataSourceOptions } from '../../filter/shared';\nimport { isLayerGroup } from '../../layer';\nimport { AnyLayer, ImageLayer, VectorLayer } from '../../layer/shared';\nimport { IgoMap } from '../../map/shared/map';\nimport { QueryableDataSourceOptions } from '../../query/shared/query.interfaces';\nimport { EditionWorkspaceService } from '../shared/edition-workspace.service';\nimport { FeatureWorkspaceService } from '../shared/feature-workspace.service';\nimport { WfsWorkspaceService } from '../shared/wfs-workspace.service';\nimport { WmsWorkspaceService } from '../shared/wms-workspace.service';\n\n@Directive({\n  selector: '[igoWorkspaceSelector]',\n  standalone: true\n})\nexport class WorkspaceSelectorDirective implements OnInit, OnDestroy {\n  private layers$$: Subscription;\n  private entities$$: Subscription[] = [];\n\n  @Input() map: IgoMap;\n\n  @Output() changeWorkspace = new EventEmitter<string>();\n  @Output() disableSwitch = new EventEmitter<boolean>();\n  @Output() relationLayers = new EventEmitter<ImageLayer[] | VectorLayer[]>();\n  @Output() rowsInMapExtentCheckCondition = new EventEmitter<boolean>();\n\n  get workspaceStore(): WorkspaceStore {\n    return this.component.store;\n  }\n\n  constructor(\n    private component: WorkspaceSelectorComponent,\n    private wfsWorkspaceService: WfsWorkspaceService,\n    private wmsWorkspaceService: WmsWorkspaceService,\n    private editionWorkspaceService: EditionWorkspaceService,\n    private featureWorkspaceService: FeatureWorkspaceService\n  ) {}\n\n  ngOnInit() {\n    this.layers$$ = this.map.layerController.all$\n      .pipe(debounceTime(50))\n      .subscribe((layers) => this.onLayersChange(layers));\n\n    this.featureWorkspaceService.ws$.subscribe((ws) => {\n      this.changeWorkspace.emit(ws);\n    });\n    this.wmsWorkspaceService.ws$.subscribe((ws) => {\n      this.changeWorkspace.emit(ws);\n    });\n    this.wfsWorkspaceService.ws$.subscribe((ws) => {\n      this.changeWorkspace.emit(ws);\n    });\n    this.editionWorkspaceService.ws$.subscribe((ws) => {\n      this.changeWorkspace.emit(ws);\n    });\n    this.editionWorkspaceService.adding$.subscribe((adding) => {\n      this.disableSwitch.emit(adding);\n    });\n    this.editionWorkspaceService.relationLayers$.subscribe((layers) => {\n      this.relationLayers.emit(layers);\n    });\n    this.editionWorkspaceService.rowsInMapExtentCheckCondition$.subscribe(\n      (condition) => {\n        this.rowsInMapExtentCheckCondition.emit(condition);\n      }\n    );\n  }\n\n  ngOnDestroy() {\n    this.layers$$.unsubscribe();\n    this.entities$$.map((entities) => entities.unsubscribe());\n  }\n\n  private onLayersChange(layers: AnyLayer[]) {\n    const editableLayers = layers.filter((layer) =>\n      this.layerIsEditable(layer)\n    );\n    const editableLayersIds = editableLayers.map((layer) => layer.id);\n\n    const workspacesToAdd = editableLayers\n      .map((layer: VectorLayer) => this.getOrCreateWorkspace(layer))\n      .filter((workspace: Workspace | undefined) => workspace !== undefined);\n\n    const workspacesToRemove = this.workspaceStore\n      .all()\n      .filter((workspace: Workspace) => {\n        return editableLayersIds.indexOf(workspace.id) < 0;\n      });\n\n    if (workspacesToRemove.length > 0) {\n      workspacesToRemove.forEach((workspace: Workspace) => {\n        workspace.entityStore.deactivateStrategyOfType(\n          FeatureStoreInMapExtentStrategy\n        );\n        workspace.deactivate();\n      });\n      this.workspaceStore.state.updateMany(workspacesToRemove, {\n        active: false,\n        selected: false\n      });\n      this.workspaceStore.deleteMany(workspacesToRemove);\n    }\n\n    if (workspacesToAdd.length > 0) {\n      this.workspaceStore.insertMany(workspacesToAdd);\n    }\n  }\n\n  private getOrCreateWorkspace(\n    layer: VectorLayer | ImageLayer\n  ): Workspace | undefined {\n    const workspace = this.workspaceStore.get(layer.id);\n    if (workspace !== undefined) {\n      return;\n    }\n    if (\n      layer.dataSource instanceof WFSDataSource &&\n      layer.dataSource.options.edition?.enabled !== true\n    ) {\n      const wfsWks = this.wfsWorkspaceService.createWorkspace(\n        layer as VectorLayer,\n        this.map\n      );\n      return wfsWks;\n    } else if (\n      layer.dataSource instanceof WMSDataSource &&\n      layer.dataSource.options.edition?.enabled !== true\n    ) {\n      if (!layer.dataSource.options.paramsWFS) {\n        return;\n      }\n      const wmsWks = this.wmsWorkspaceService.createWorkspace(\n        layer as ImageLayer,\n        this.map\n      );\n      wmsWks?.inResolutionRange$.subscribe((inResolutionRange) => {\n        (layer.dataSource.options as QueryableDataSourceOptions).queryable =\n          !inResolutionRange;\n        (\n          wmsWks.layer.dataSource.options as QueryableDataSourceOptions\n        ).queryable = inResolutionRange;\n      });\n      return wmsWks;\n    } else if (\n      layer.dataSource instanceof FeatureDataSource &&\n      (layer as VectorLayer).exportable === true &&\n      layer.dataSource.options.edition?.enabled !== true\n    ) {\n      const featureWks = this.featureWorkspaceService.createWorkspace(\n        layer as VectorLayer,\n        this.map\n      );\n      return featureWks;\n    } else if (\n      layer.dataSource instanceof WMSDataSource &&\n      layer.dataSource.options.edition?.enabled === true\n    ) {\n      const editionWks = this.editionWorkspaceService.createWorkspace(\n        layer as ImageLayer,\n        this.map\n      );\n      return editionWks;\n    }\n\n    return;\n  }\n\n  private layerIsEditable(layer: AnyLayer): boolean {\n    if (isLayerGroup(layer)) {\n      return false;\n    }\n    const dataSource = layer.dataSource;\n    if (dataSource instanceof WFSDataSource) {\n      return true;\n    }\n    if (dataSource instanceof FeatureDataSource) {\n      return true;\n    }\n    if (dataSource instanceof WMSDataSource) {\n      const dataSourceOptions = (dataSource.options ||\n        {}) as OgcFilterableDataSourceOptions;\n      return (\n        dataSourceOptions.ogcFilters?.enabled ||\n        dataSource.options.paramsWFS?.featureTypes !== undefined\n      );\n    }\n\n    return false;\n  }\n}\n"]}

package/esm2022/lib/workspace/workspace-selector/workspace-selector.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { WorkspaceSelectorDirective } from './workspace-selector.directive';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated import the WorkspaceSelectorDirective directly
+ */
+export class IgoWorkspaceSelectorModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoWorkspaceSelectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoWorkspaceSelectorModule, imports: [WorkspaceSelectorDirective], exports: [WorkspaceSelectorDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoWorkspaceSelectorModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoWorkspaceSelectorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [WorkspaceSelectorDirective],
+                    exports: [WorkspaceSelectorDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLXNlbGVjdG9yLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL3dvcmtzcGFjZS93b3Jrc3BhY2Utc2VsZWN0b3Ivd29ya3NwYWNlLXNlbGVjdG9yLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDOztBQUU1RTs7R0FFRztBQUtILE1BQU0sT0FBTywwQkFBMEI7d0dBQTFCLDBCQUEwQjt5R0FBMUIsMEJBQTBCLFlBSDNCLDBCQUEwQixhQUMxQiwwQkFBMEI7eUdBRXpCLDBCQUEwQjs7NEZBQTFCLDBCQUEwQjtrQkFKdEMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQywwQkFBMEIsQ0FBQztvQkFDckMsT0FBTyxFQUFFLENBQUMsMEJBQTBCLENBQUM7aUJBQ3RDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgV29ya3NwYWNlU2VsZWN0b3JEaXJlY3RpdmUgfSBmcm9tICcuL3dvcmtzcGFjZS1zZWxlY3Rvci5kaXJlY3RpdmUnO1xuXG4vKipcbiAqIEBkZXByZWNhdGVkIGltcG9ydCB0aGUgV29ya3NwYWNlU2VsZWN0b3JEaXJlY3RpdmUgZGlyZWN0bHlcbiAqL1xuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1dvcmtzcGFjZVNlbGVjdG9yRGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW1dvcmtzcGFjZVNlbGVjdG9yRGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBJZ29Xb3Jrc3BhY2VTZWxlY3Rvck1vZHVsZSB7fVxuIl19

package/esm2022/lib/workspace/workspace-updator/workspace-updator.directive.mjs

@@ -0,0 +1,137 @@
+import { Directive, Input } from '@angular/core';
+import { debounceTime } from 'rxjs/operators';
+import { FeatureDataSource, WFSDataSource, WMSDataSource } from '../../datasource/shared/datasources';
+import { FeatureStoreInMapExtentStrategy } from '../../feature/shared/strategies/in-map-extent';
+import { isLayerItem } from '../../layer';
+import { IgoMap } from '../../map/shared/map';
+import { EditionWorkspaceService } from '../shared/edition-workspace.service';
+import { FeatureWorkspaceService } from '../shared/feature-workspace.service';
+import { WfsWorkspaceService } from '../shared/wfs-workspace.service';
+import { WmsWorkspaceService } from '../shared/wms-workspace.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../shared/wfs-workspace.service";
+import * as i2 from "../shared/wms-workspace.service";
+import * as i3 from "../shared/edition-workspace.service";
+import * as i4 from "../shared/feature-workspace.service";
+export class WorkspaceUpdatorDirective {
+    wfsWorkspaceService;
+    wmsWorkspaceService;
+    editionWorkspaceService;
+    featureWorkspaceService;
+    layers$$;
+    entities$$ = [];
+    map;
+    workspaceStore;
+    constructor(wfsWorkspaceService, wmsWorkspaceService, editionWorkspaceService, featureWorkspaceService) {
+        this.wfsWorkspaceService = wfsWorkspaceService;
+        this.wmsWorkspaceService = wmsWorkspaceService;
+        this.editionWorkspaceService = editionWorkspaceService;
+        this.featureWorkspaceService = featureWorkspaceService;
+    }
+    ngOnInit() {
+        this.layers$$ = this.map.layerController.all$
+            .pipe(debounceTime(50))
+            .subscribe((layers) => this.onLayersChange(layers));
+    }
+    ngOnDestroy() {
+        this.layers$$.unsubscribe();
+        this.entities$$.map((entities) => entities.unsubscribe());
+    }
+    onLayersChange(layers) {
+        const editableLayers = layers.filter((layer) => isLayerItem(layer) && this.layerIsEditable(layer));
+        const editableLayersIds = editableLayers.map((layer) => layer.id);
+        const workspacesToAdd = editableLayers
+            .map((layer) => this.getOrCreateWorkspace(layer))
+            .filter((workspace) => workspace !== undefined);
+        const workspacesToRemove = this.workspaceStore
+            .all()
+            .filter((workspace) => {
+            return editableLayersIds.indexOf(workspace.id) < 0;
+        });
+        if (workspacesToRemove.length > 0) {
+            workspacesToRemove.forEach((workspace) => {
+                workspace.entityStore.deactivateStrategyOfType(FeatureStoreInMapExtentStrategy);
+                workspace.deactivate();
+            });
+            this.workspaceStore.state.updateMany(workspacesToRemove, {
+                active: false,
+                selected: false
+            });
+            this.workspaceStore.deleteMany(workspacesToRemove);
+        }
+        if (workspacesToAdd.length > 0) {
+            this.workspaceStore.insertMany(workspacesToAdd);
+        }
+    }
+    getOrCreateWorkspace(layer) {
+        const workspace = this.workspaceStore.get(layer.id);
+        if (workspace !== undefined) {
+            return;
+        }
+        if (layer.dataSource instanceof WFSDataSource &&
+            layer.dataSource.options.edition?.enabled !== true) {
+            const wfsWks = this.wfsWorkspaceService.createWorkspace(layer, this.map);
+            return wfsWks;
+        }
+        else if (layer.dataSource instanceof WMSDataSource &&
+            layer.dataSource.options.edition?.enabled !== true) {
+            if (!layer.dataSource.options.paramsWFS) {
+                return;
+            }
+            const wmsWks = this.wmsWorkspaceService.createWorkspace(layer, this.map);
+            wmsWks?.inResolutionRange$.subscribe((inResolutionRange) => {
+                if (layer.dataSource.options
+                    ?.queryFormatAsWms) {
+                    wmsWks.layer.dataSource.options.queryable = true;
+                    return wmsWks;
+                }
+                layer.dataSource.options.queryable =
+                    !inResolutionRange;
+                wmsWks.layer.dataSource.options.queryable = inResolutionRange;
+            });
+            return wmsWks;
+        }
+        else if (layer.dataSource instanceof FeatureDataSource &&
+            layer.exportable === true &&
+            layer.dataSource.options.edition?.enabled !== true) {
+            const featureWks = this.featureWorkspaceService.createWorkspace(layer, this.map);
+            return featureWks;
+        }
+        else if (layer.dataSource instanceof WMSDataSource &&
+            layer.dataSource.options.edition?.enabled === true) {
+            const editionWks = this.editionWorkspaceService.createWorkspace(layer, this.map);
+            return editionWks;
+        }
+        return;
+    }
+    layerIsEditable(layer) {
+        const dataSource = layer.dataSource;
+        if (dataSource instanceof WFSDataSource) {
+            return true;
+        }
+        if (dataSource instanceof FeatureDataSource) {
+            return true;
+        }
+        if (dataSource instanceof WMSDataSource) {
+            const dataSourceOptions = (dataSource.options ||
+                {});
+            return (dataSourceOptions.ogcFilters?.enabled ||
+                dataSource.options.paramsWFS?.featureTypes !== undefined);
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WorkspaceUpdatorDirective, deps: [{ token: i1.WfsWorkspaceService }, { token: i2.WmsWorkspaceService }, { token: i3.EditionWorkspaceService }, { token: i4.FeatureWorkspaceService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: WorkspaceUpdatorDirective, isStandalone: true, selector: "[igoWorkspaceUpdator]", inputs: { map: "map", workspaceStore: "workspaceStore" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: WorkspaceUpdatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igoWorkspaceUpdator]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.WfsWorkspaceService }, { type: i2.WmsWorkspaceService }, { type: i3.EditionWorkspaceService }, { type: i4.FeatureWorkspaceService }], propDecorators: { map: [{
+                type: Input
+            }], workspaceStore: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace-updator.directive.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/workspace/workspace-updator/workspace-updator.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, OnDestroy, OnInit } from '@angular/core';\n\nimport { Workspace } from '@igo2/common/workspace';\nimport type { WorkspaceStore } from '@igo2/common/workspace';\n\nimport { Subscription } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\nimport {\n  FeatureDataSource,\n  WFSDataSource,\n  WMSDataSource\n} from '../../datasource/shared/datasources';\nimport { FeatureStoreInMapExtentStrategy } from '../../feature/shared/strategies/in-map-extent';\nimport { OgcFilterableDataSourceOptions } from '../../filter/shared';\nimport { isLayerItem } from '../../layer';\nimport { AnyLayer, ImageLayer, Layer, VectorLayer } from '../../layer/shared';\nimport { IgoMap } from '../../map/shared/map';\nimport { QueryableDataSourceOptions } from '../../query/shared/query.interfaces';\nimport { EditionWorkspaceService } from '../shared/edition-workspace.service';\nimport { FeatureWorkspaceService } from '../shared/feature-workspace.service';\nimport { WfsWorkspaceService } from '../shared/wfs-workspace.service';\nimport { WmsWorkspaceService } from '../shared/wms-workspace.service';\n\n@Directive({\n  selector: '[igoWorkspaceUpdator]',\n  standalone: true\n})\nexport class WorkspaceUpdatorDirective implements OnInit, OnDestroy {\n  private layers$$: Subscription;\n  private entities$$: Subscription[] = [];\n\n  @Input() map: IgoMap;\n\n  @Input() workspaceStore: WorkspaceStore;\n\n  constructor(\n    private wfsWorkspaceService: WfsWorkspaceService,\n    private wmsWorkspaceService: WmsWorkspaceService,\n    private editionWorkspaceService: EditionWorkspaceService,\n    private featureWorkspaceService: FeatureWorkspaceService\n  ) {}\n\n  ngOnInit() {\n    this.layers$$ = this.map.layerController.all$\n      .pipe(debounceTime(50))\n      .subscribe((layers) => this.onLayersChange(layers));\n  }\n\n  ngOnDestroy() {\n    this.layers$$.unsubscribe();\n    this.entities$$.map((entities) => entities.unsubscribe());\n  }\n\n  private onLayersChange(layers: AnyLayer[]) {\n    const editableLayers = layers.filter(\n      (layer) => isLayerItem(layer) && this.layerIsEditable(layer)\n    ) as Layer[];\n    const editableLayersIds = editableLayers.map((layer) => layer.id);\n\n    const workspacesToAdd = editableLayers\n      .map((layer: VectorLayer) => this.getOrCreateWorkspace(layer))\n      .filter((workspace: Workspace | undefined) => workspace !== undefined);\n\n    const workspacesToRemove = this.workspaceStore\n      .all()\n      .filter((workspace: Workspace) => {\n        return editableLayersIds.indexOf(workspace.id) < 0;\n      });\n\n    if (workspacesToRemove.length > 0) {\n      workspacesToRemove.forEach((workspace: Workspace) => {\n        workspace.entityStore.deactivateStrategyOfType(\n          FeatureStoreInMapExtentStrategy\n        );\n        workspace.deactivate();\n      });\n      this.workspaceStore.state.updateMany(workspacesToRemove, {\n        active: false,\n        selected: false\n      });\n      this.workspaceStore.deleteMany(workspacesToRemove);\n    }\n\n    if (workspacesToAdd.length > 0) {\n      this.workspaceStore.insertMany(workspacesToAdd);\n    }\n  }\n\n  private getOrCreateWorkspace(\n    layer: VectorLayer | ImageLayer\n  ): Workspace | undefined {\n    const workspace = this.workspaceStore.get(layer.id);\n    if (workspace !== undefined) {\n      return;\n    }\n    if (\n      layer.dataSource instanceof WFSDataSource &&\n      layer.dataSource.options.edition?.enabled !== true\n    ) {\n      const wfsWks = this.wfsWorkspaceService.createWorkspace(\n        layer as VectorLayer,\n        this.map\n      );\n      return wfsWks;\n    } else if (\n      layer.dataSource instanceof WMSDataSource &&\n      layer.dataSource.options.edition?.enabled !== true\n    ) {\n      if (!layer.dataSource.options.paramsWFS) {\n        return;\n      }\n      const wmsWks = this.wmsWorkspaceService.createWorkspace(\n        layer as ImageLayer,\n        this.map\n      );\n      wmsWks?.inResolutionRange$.subscribe((inResolutionRange) => {\n        if (\n          (layer.dataSource.options as QueryableDataSourceOptions)\n            ?.queryFormatAsWms\n        ) {\n          (\n            wmsWks.layer.dataSource.options as QueryableDataSourceOptions\n          ).queryable = true;\n          return wmsWks;\n        }\n        (layer.dataSource.options as QueryableDataSourceOptions).queryable =\n          !inResolutionRange;\n        (\n          wmsWks.layer.dataSource.options as QueryableDataSourceOptions\n        ).queryable = inResolutionRange;\n      });\n      return wmsWks;\n    } else if (\n      layer.dataSource instanceof FeatureDataSource &&\n      (layer as VectorLayer).exportable === true &&\n      layer.dataSource.options.edition?.enabled !== true\n    ) {\n      const featureWks = this.featureWorkspaceService.createWorkspace(\n        layer as VectorLayer,\n        this.map\n      );\n      return featureWks;\n    } else if (\n      layer.dataSource instanceof WMSDataSource &&\n      layer.dataSource.options.edition?.enabled === true\n    ) {\n      const editionWks = this.editionWorkspaceService.createWorkspace(\n        layer as ImageLayer,\n        this.map\n      );\n      return editionWks;\n    }\n\n    return;\n  }\n\n  private layerIsEditable(layer: Layer): boolean {\n    const dataSource = layer.dataSource;\n    if (dataSource instanceof WFSDataSource) {\n      return true;\n    }\n    if (dataSource instanceof FeatureDataSource) {\n      return true;\n    }\n    if (dataSource instanceof WMSDataSource) {\n      const dataSourceOptions = (dataSource.options ||\n        {}) as OgcFilterableDataSourceOptions;\n      return (\n        dataSourceOptions.ogcFilters?.enabled ||\n        dataSource.options.paramsWFS?.featureTypes !== undefined\n      );\n    }\n\n    return false;\n  }\n}\n"]}

package/esm2022/lib/workspace/workspace-updator/workspace-updator.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { WorkspaceUpdatorDirective } from './workspace-updator.directive';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated import the WorkspaceUpdatorDirective directly
+ */
+export class IgoWorkspaceUpdatorModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoWorkspaceUpdatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoWorkspaceUpdatorModule, imports: [WorkspaceUpdatorDirective], exports: [WorkspaceUpdatorDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoWorkspaceUpdatorModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoWorkspaceUpdatorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [WorkspaceUpdatorDirective],
+                    exports: [WorkspaceUpdatorDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLXVwZGF0b3IubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvd29ya3NwYWNlL3dvcmtzcGFjZS11cGRhdG9yL3dvcmtzcGFjZS11cGRhdG9yLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLCtCQUErQixDQUFDOztBQUUxRTs7R0FFRztBQUtILE1BQU0sT0FBTyx5QkFBeUI7d0dBQXpCLHlCQUF5Qjt5R0FBekIseUJBQXlCLFlBSDFCLHlCQUF5QixhQUN6Qix5QkFBeUI7eUdBRXhCLHlCQUF5Qjs7NEZBQXpCLHlCQUF5QjtrQkFKckMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyx5QkFBeUIsQ0FBQztvQkFDcEMsT0FBTyxFQUFFLENBQUMseUJBQXlCLENBQUM7aUJBQ3JDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgV29ya3NwYWNlVXBkYXRvckRpcmVjdGl2ZSB9IGZyb20gJy4vd29ya3NwYWNlLXVwZGF0b3IuZGlyZWN0aXZlJztcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBpbXBvcnQgdGhlIFdvcmtzcGFjZVVwZGF0b3JEaXJlY3RpdmUgZGlyZWN0bHlcbiAqL1xuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1dvcmtzcGFjZVVwZGF0b3JEaXJlY3RpdmVdLFxuICBleHBvcnRzOiBbV29ya3NwYWNlVXBkYXRvckRpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgSWdvV29ya3NwYWNlVXBkYXRvck1vZHVsZSB7fVxuIl19

package/esm2022/lib/workspace/workspace.module.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { MatDialogModule } from '@angular/material/dialog';
+import { IgoWidgetModule } from '@igo2/common/widget';
+import { IgoOgcFilterModule } from './widgets/ogc-filter/ogc-filter.module';
+import { provideOgcFilterWidget } from './widgets/widgets';
+import { IgoWorkspaceSelectorModule } from './workspace-selector/workspace-selector.module';
+import * as i0 from "@angular/core";
+export class IgoGeoWorkspaceModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoGeoWorkspaceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoGeoWorkspaceModule, imports: [IgoWidgetModule,
+            IgoOgcFilterModule,
+            IgoWorkspaceSelectorModule,
+            MatDialogModule], exports: [IgoOgcFilterModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoGeoWorkspaceModule, providers: [provideOgcFilterWidget()], imports: [IgoWidgetModule,
+            IgoOgcFilterModule,
+            IgoWorkspaceSelectorModule,
+            MatDialogModule, IgoOgcFilterModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoGeoWorkspaceModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        IgoWidgetModule,
+                        IgoOgcFilterModule,
+                        IgoWorkspaceSelectorModule,
+                        MatDialogModule
+                    ],
+                    exports: [IgoOgcFilterModule],
+                    providers: [provideOgcFilterWidget()]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL3dvcmtzcGFjZS93b3Jrc3BhY2UubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTNELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV0RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUM1RSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxnREFBZ0QsQ0FBQzs7QUFZNUYsTUFBTSxPQUFPLHFCQUFxQjt3R0FBckIscUJBQXFCO3lHQUFyQixxQkFBcUIsWUFSOUIsZUFBZTtZQUNmLGtCQUFrQjtZQUNsQiwwQkFBMEI7WUFDMUIsZUFBZSxhQUVQLGtCQUFrQjt5R0FHakIscUJBQXFCLGFBRnJCLENBQUMsc0JBQXNCLEVBQUUsQ0FBQyxZQU5uQyxlQUFlO1lBQ2Ysa0JBQWtCO1lBQ2xCLDBCQUEwQjtZQUMxQixlQUFlLEVBRVAsa0JBQWtCOzs0RkFHakIscUJBQXFCO2tCQVZqQyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRTt3QkFDUCxlQUFlO3dCQUNmLGtCQUFrQjt3QkFDbEIsMEJBQTBCO3dCQUMxQixlQUFlO3FCQUNoQjtvQkFDRCxPQUFPLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQztvQkFDN0IsU0FBUyxFQUFFLENBQUMsc0JBQXNCLEVBQUUsQ0FBQztpQkFDdEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTWF0RGlhbG9nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvZGlhbG9nJztcblxuaW1wb3J0IHsgSWdvV2lkZ2V0TW9kdWxlIH0gZnJvbSAnQGlnbzIvY29tbW9uL3dpZGdldCc7XG5cbmltcG9ydCB7IElnb09nY0ZpbHRlck1vZHVsZSB9IGZyb20gJy4vd2lkZ2V0cy9vZ2MtZmlsdGVyL29nYy1maWx0ZXIubW9kdWxlJztcbmltcG9ydCB7IHByb3ZpZGVPZ2NGaWx0ZXJXaWRnZXQgfSBmcm9tICcuL3dpZGdldHMvd2lkZ2V0cyc7XG5pbXBvcnQgeyBJZ29Xb3Jrc3BhY2VTZWxlY3Rvck1vZHVsZSB9IGZyb20gJy4vd29ya3NwYWNlLXNlbGVjdG9yL3dvcmtzcGFjZS1zZWxlY3Rvci5tb2R1bGUnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgSWdvV2lkZ2V0TW9kdWxlLFxuICAgIElnb09nY0ZpbHRlck1vZHVsZSxcbiAgICBJZ29Xb3Jrc3BhY2VTZWxlY3Rvck1vZHVsZSxcbiAgICBNYXREaWFsb2dNb2R1bGVcbiAgXSxcbiAgZXhwb3J0czogW0lnb09nY0ZpbHRlck1vZHVsZV0sXG4gIHByb3ZpZGVyczogW3Byb3ZpZGVPZ2NGaWx0ZXJXaWRnZXQoKV1cbn0pXG5leHBvcnQgY2xhc3MgSWdvR2VvV29ya3NwYWNlTW9kdWxlIHt9XG4iXX0=

package/esm2022/public_api.mjs

@@ -0,0 +1,56 @@
+/*
+ * Public API Surface of geo
+ */
+export * from './lib/geo.module';
+export * from './lib/catalog/catalog-browser/catalog-browser.module';
+export * from './lib/catalog/catalog-library/catalog-library.module';
+export * from './lib/catalog/catalog.module';
+export * from './lib/directions/directions.module';
+export * from './lib/download/download.module';
+export * from './lib/draw/draw/draw.module';
+export * from './lib/draw/drawingTool.module';
+export * from './lib/feature/feature-details/feature-details.directive';
+export * from './lib/feature/feature-details/feature-details.module';
+export * from './lib/feature/feature-form/feature-form.module';
+export * from './lib/feature/feature.module';
+export * from './lib/filter/filter.module';
+export * from './lib/geometry/geometry-form-field/geometry-form-field.module';
+export * from './lib/geometry/geometry.module';
+export * from './lib/import-export/import-export.module';
+export * from './lib/layer/layer.module';
+export * from './lib/map/map.module';
+export * from './lib/measure/measure.module';
+export * from './lib/measure/measurer/measurer.module';
+export * from './lib/metadata/metadata.module';
+export * from './lib/print/print.module';
+export * from './lib/query/query.module';
+export * from './lib/search/search.module';
+export * from './lib/style/style.module';
+export * from './lib/toast/toast.module';
+export * from './lib/wkt/wkt.module';
+export * from './lib/workspace/workspace.module';
+export * from './lib/catalog';
+export * from './lib/datasource';
+export * from './lib/directions';
+export * from './lib/download';
+export * from './lib/draw';
+export * from './lib/environment';
+export * from './lib/feature';
+export * from './lib/filter';
+export * from './lib/geometry';
+export * from './lib/import-export';
+export * from './lib/layer';
+export * from './lib/map';
+export * from './lib/measure';
+export * from './lib/metadata';
+export * from './lib/offline';
+export * from './lib/overlay';
+export * from './lib/print';
+export * from './lib/query';
+export * from './lib/search';
+export * from './lib/style';
+export * from './lib/toast';
+export * from './lib/utils';
+export * from './lib/wkt';
+export * from './lib/workspace';
+//# sourceMappingURL=data:application/json;base64,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