@igo2/integration 1.11.1 → 1.13.0-alpha.0

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

@@ -0,0 +1,158 @@
+import { Inject, Injectable } from '@angular/core';
+import { EntityStoreFilterCustomFuncStrategy, EntityStoreFilterSelectionStrategy } from '@igo2/common';
+import { BehaviorSubject } from 'rxjs';
+import { mapExtentStrategyActiveToolTip, noElementSelected, OgcFilterWidget, } from '@igo2/geo';
+import { StorageServiceEventEnum } from '@igo2/core';
+import { map, skipWhile } from 'rxjs/operators';
+import { handleZoomAuto } from './workspace.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../storage/storage.state";
+import * as i2 from "@igo2/core";
+import * as i3 from "../../tool/tool.state";
+import * as i4 from "@igo2/common";
+export class WfsActionsService {
+    constructor(ogcFilterWidget, storageState, languageService, mediaService, toolState) {
+        this.ogcFilterWidget = ogcFilterWidget;
+        this.storageState = storageState;
+        this.languageService = languageService;
+        this.mediaService = mediaService;
+        this.toolState = toolState;
+        this.maximize$ = new BehaviorSubject(this.storageService.get('workspaceMaximize'));
+        this.selectOnlyCheckCondition$ = new BehaviorSubject(false);
+        // rowsInMapExtentCheckCondition$: BehaviorSubject<boolean> = new BehaviorSubject(true);
+        this.zoomAuto$ = new BehaviorSubject(false);
+    }
+    get storageService() {
+        return this.storageState.storageService;
+    }
+    get zoomAuto() {
+        return this.storageService.get('zoomAuto');
+    }
+    ngOnDestroy() {
+        if (this.storageChange$$) {
+            this.storageChange$$.unsubscribe();
+        }
+    }
+    loadActions(workspace, rowsInMapExtentCheckCondition$, selectOnlyCheckCondition$) {
+        const actions = this.buildActions(workspace, rowsInMapExtentCheckCondition$, selectOnlyCheckCondition$);
+        workspace.actionStore.load(actions);
+    }
+    buildActions(workspace, rowsInMapExtentCheckCondition$, selectOnlyCheckCondition$) {
+        this.zoomAuto$.next(this.zoomAuto);
+        this.storageChange$$ = this.storageService.storageChange$
+            .pipe(skipWhile((storageChange) => storageChange?.key !== 'zoomAuto' || storageChange?.event === StorageServiceEventEnum.CLEARED))
+            .subscribe(() => {
+            this.zoomAuto$.next(this.zoomAuto);
+            handleZoomAuto(workspace, this.storageService);
+        });
+        const actions = [
+            {
+                id: 'zoomAuto',
+                checkbox: true,
+                title: 'igo.integration.workspace.zoomAuto.title',
+                tooltip: 'igo.integration.workspace.zoomAuto.tooltip',
+                checkCondition: this.zoomAuto$,
+                handler: () => {
+                    handleZoomAuto(workspace, this.storageService);
+                    this.storageService.set('zoomAuto', !this.storageService.get('zoomAuto'));
+                }
+            },
+            {
+                id: 'filterInMapExtent',
+                checkbox: true,
+                title: 'igo.integration.workspace.inMapExtent.title',
+                tooltip: mapExtentStrategyActiveToolTip(workspace),
+                checkCondition: rowsInMapExtentCheckCondition$,
+                handler: () => rowsInMapExtentCheckCondition$.next(!rowsInMapExtentCheckCondition$.value)
+            },
+            {
+                id: 'selectedOnly',
+                checkbox: true,
+                title: 'igo.integration.workspace.selected.title',
+                tooltip: 'igo.integration.workspace.selected.title',
+                checkCondition: selectOnlyCheckCondition$,
+                handler: () => selectOnlyCheckCondition$.next(!selectOnlyCheckCondition$.value)
+            },
+            {
+                id: 'clearselection',
+                icon: 'select-off',
+                title: 'igo.integration.workspace.clearSelection.title',
+                tooltip: 'igo.integration.workspace.clearSelection.tooltip',
+                handler: (ws) => {
+                    ws.entityStore.state.updateMany(ws.entityStore.view.all(), { selected: false });
+                },
+                args: [workspace],
+                availability: (ws) => noElementSelected(ws)
+            },
+            {
+                id: 'wfsDownload',
+                icon: 'file-export',
+                title: 'igo.integration.workspace.download.title',
+                tooltip: 'igo.integration.workspace.download.tooltip',
+                handler: (ws) => {
+                    const filterStrategy = ws.entityStore.getStrategyOfType(EntityStoreFilterCustomFuncStrategy);
+                    const filterSelectionStrategy = ws.entityStore.getStrategyOfType(EntityStoreFilterSelectionStrategy);
+                    const layersWithSelection = filterSelectionStrategy.active ? [ws.layer.id] : [];
+                    this.toolState.toolToActivateFromOptions({
+                        tool: 'importExport',
+                        options: { layers: [ws.layer.id], featureInMapExtent: filterStrategy.active, layersWithSelection }
+                    });
+                },
+                args: [workspace]
+            },
+            {
+                id: 'ogcFilter',
+                icon: 'filter',
+                title: 'igo.integration.workspace.ogcFilter.title',
+                tooltip: 'igo.integration.workspace.ogcFilter.tooltip',
+                handler: (widget, ws) => {
+                    ws.activateWidget(widget, {
+                        map: ws.map,
+                        layer: ws.layer
+                    });
+                },
+                args: [this.ogcFilterWidget, workspace]
+            },
+            {
+                id: 'maximize',
+                title: this.languageService.translate.instant('igo.integration.workspace.maximize'),
+                tooltip: this.languageService.translate.instant('igo.integration.workspace.maximizeTooltip'),
+                icon: 'resize',
+                display: () => {
+                    return this.maximize$.pipe(map((v) => !v && !this.mediaService.isMobile()));
+                },
+                handler: () => {
+                    if (!this.mediaService.isMobile()) {
+                        this.maximize$.next(true);
+                    }
+                },
+            },
+            {
+                id: 'standardExtent',
+                title: this.languageService.translate.instant('igo.integration.workspace.standardExtent'),
+                tooltip: this.languageService.translate.instant('igo.integration.workspace.standardExtentTooltip'),
+                icon: 'resize',
+                display: () => {
+                    return this.maximize$.pipe(map((v) => v && !this.mediaService.isMobile()));
+                },
+                handler: () => {
+                    this.maximize$.next(false);
+                }
+            }
+        ];
+        return workspace.layer.dataSource.ogcFilters$?.value?.enabled ?
+            actions : actions.filter(action => action.id !== 'ogcFilter');
+    }
+}
+WfsActionsService.ɵfac = function WfsActionsService_Factory(t) { return new (t || WfsActionsService)(i0.ɵɵinject(OgcFilterWidget), i0.ɵɵinject(i1.StorageState), i0.ɵɵinject(i2.LanguageService), i0.ɵɵinject(i2.MediaService), i0.ɵɵinject(i3.ToolState)); };
+WfsActionsService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WfsActionsService, factory: WfsActionsService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WfsActionsService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i4.Widget, decorators: [{
+                type: Inject,
+                args: [OgcFilterWidget]
+            }] }, { type: i1.StorageState }, { type: i2.LanguageService }, { type: i2.MediaService }, { type: i3.ToolState }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wfs-actions.service.js","sourceRoot":"","sources":["../../../../../../packages/integration/src/lib/workspace/shared/wfs-actions.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, OnDestroy } from '@angular/core';\r\n\r\nimport {\r\n  Action,\r\n  EntityStoreFilterCustomFuncStrategy,\r\n  EntityStoreFilterSelectionStrategy,\r\n  Widget\r\n} from '@igo2/common';\r\n\r\nimport { BehaviorSubject, Subscription } from 'rxjs';\r\nimport {\r\n  WfsWorkspace,\r\n  mapExtentStrategyActiveToolTip,\r\n  noElementSelected,\r\n  ExportOptions,\r\n  OgcFilterWidget,\r\n  OgcFilterableDataSource,\r\n} from '@igo2/geo';\r\nimport { StorageService, StorageServiceEvent, StorageServiceEventEnum, LanguageService, MediaService} from '@igo2/core';\r\nimport { StorageState } from '../../storage/storage.state';\r\nimport { map, skipWhile } from 'rxjs/operators';\r\nimport { ToolState } from '../../tool/tool.state';\r\nimport { handleZoomAuto } from './workspace.utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WfsActionsService implements OnDestroy {\r\n\r\n  public maximize$: BehaviorSubject<boolean> = new BehaviorSubject(\r\n    this.storageService.get('workspaceMaximize') as boolean\r\n  );\r\n\r\n  selectOnlyCheckCondition$: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n  // rowsInMapExtentCheckCondition$: BehaviorSubject<boolean> = new BehaviorSubject(true);\r\n  zoomAuto$: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n  private storageChange$$: Subscription;\r\n\r\n  get storageService(): StorageService {\r\n    return this.storageState.storageService;\r\n  }\r\n\r\n  get zoomAuto(): boolean {\r\n    return this.storageService.get('zoomAuto') as boolean;\r\n  }\r\n\r\n  constructor(\r\n    @Inject(OgcFilterWidget) private ogcFilterWidget: Widget,\r\n    private storageState: StorageState,\r\n    public languageService: LanguageService,\r\n    private mediaService: MediaService,\r\n    private toolState: ToolState) {}\r\n\r\n  ngOnDestroy(): void {\r\n    if (this.storageChange$$) {\r\n      this.storageChange$$.unsubscribe();\r\n    }\r\n  }\r\n\r\n  loadActions(\r\n    workspace: WfsWorkspace,\r\n    rowsInMapExtentCheckCondition$: BehaviorSubject<boolean>,\r\n    selectOnlyCheckCondition$: BehaviorSubject<boolean>\r\n    ) {\r\n    const actions = this.buildActions(\r\n      workspace,\r\n      rowsInMapExtentCheckCondition$,\r\n      selectOnlyCheckCondition$\r\n      );\r\n    workspace.actionStore.load(actions);\r\n  }\r\n\r\n  buildActions(\r\n    workspace: WfsWorkspace,\r\n    rowsInMapExtentCheckCondition$: BehaviorSubject<boolean>,\r\n    selectOnlyCheckCondition$: BehaviorSubject<boolean>\r\n    ): Action[] {\r\n    this.zoomAuto$.next(this.zoomAuto);\r\n    this.storageChange$$ = this.storageService.storageChange$\r\n      .pipe(skipWhile((storageChange: StorageServiceEvent) =>\r\n        storageChange?.key !== 'zoomAuto' || storageChange?.event === StorageServiceEventEnum.CLEARED))\r\n      .subscribe(() => {\r\n        this.zoomAuto$.next(this.zoomAuto);\r\n        handleZoomAuto(workspace, this.storageService);\r\n      });\r\n    const actions = [\r\n      {\r\n        id: 'zoomAuto',\r\n        checkbox: true,\r\n        title: 'igo.integration.workspace.zoomAuto.title',\r\n        tooltip: 'igo.integration.workspace.zoomAuto.tooltip',\r\n        checkCondition: this.zoomAuto$,\r\n        handler: () => {\r\n          handleZoomAuto(workspace, this.storageService);\r\n          this.storageService.set('zoomAuto', !this.storageService.get('zoomAuto') as boolean);\r\n        }\r\n      },\r\n      {\r\n        id: 'filterInMapExtent',\r\n        checkbox: true,\r\n        title: 'igo.integration.workspace.inMapExtent.title',\r\n        tooltip: mapExtentStrategyActiveToolTip(workspace),\r\n        checkCondition: rowsInMapExtentCheckCondition$,\r\n        handler: () => rowsInMapExtentCheckCondition$.next(!rowsInMapExtentCheckCondition$.value)\r\n      },\r\n      {\r\n        id: 'selectedOnly',\r\n        checkbox: true,\r\n        title: 'igo.integration.workspace.selected.title',\r\n        tooltip: 'igo.integration.workspace.selected.title',\r\n        checkCondition: selectOnlyCheckCondition$,\r\n        handler: () => selectOnlyCheckCondition$.next(!selectOnlyCheckCondition$.value)\r\n      },\r\n      {\r\n        id: 'clearselection',\r\n        icon: 'select-off',\r\n        title: 'igo.integration.workspace.clearSelection.title',\r\n        tooltip: 'igo.integration.workspace.clearSelection.tooltip',\r\n        handler: (ws: WfsWorkspace) => {\r\n          ws.entityStore.state.updateMany(ws.entityStore.view.all(), { selected: false });\r\n        },\r\n        args: [workspace],\r\n        availability: (ws: WfsWorkspace) => noElementSelected(ws)\r\n      },\r\n      {\r\n        id: 'wfsDownload',\r\n        icon: 'file-export',\r\n        title: 'igo.integration.workspace.download.title',\r\n        tooltip: 'igo.integration.workspace.download.tooltip',\r\n        handler: (ws: WfsWorkspace) => {\r\n          const filterStrategy = ws.entityStore.getStrategyOfType(EntityStoreFilterCustomFuncStrategy);\r\n          const filterSelectionStrategy = ws.entityStore.getStrategyOfType(EntityStoreFilterSelectionStrategy);\r\n          const layersWithSelection = filterSelectionStrategy.active ? [ws.layer.id] : [];\r\n          this.toolState.toolToActivateFromOptions({\r\n            tool: 'importExport',\r\n            options: { layers: [ws.layer.id], featureInMapExtent: filterStrategy.active, layersWithSelection } as ExportOptions\r\n          });\r\n        },\r\n        args: [workspace]\r\n      },\r\n      {\r\n        id: 'ogcFilter',\r\n        icon: 'filter',\r\n        title: 'igo.integration.workspace.ogcFilter.title',\r\n        tooltip: 'igo.integration.workspace.ogcFilter.tooltip',\r\n        handler: (widget: Widget, ws: WfsWorkspace) => {\r\n          ws.activateWidget(widget, {\r\n            map: ws.map,\r\n            layer: ws.layer\r\n          });\r\n        },\r\n        args: [this.ogcFilterWidget, workspace]\r\n      },\r\n      {\r\n        id: 'maximize',\r\n        title: this.languageService.translate.instant('igo.integration.workspace.maximize'),\r\n        tooltip: this.languageService.translate.instant(\r\n          'igo.integration.workspace.maximizeTooltip'\r\n        ),\r\n        icon: 'resize',\r\n        display: () => {\r\n          return this.maximize$.pipe(map((v) => !v && !this.mediaService.isMobile()));\r\n        },\r\n        handler: () => {\r\n          if (!this.mediaService.isMobile()) {\r\n            this.maximize$.next(true);\r\n          }\r\n        },\r\n      },\r\n      {\r\n        id: 'standardExtent',\r\n        title: this.languageService.translate.instant(\r\n          'igo.integration.workspace.standardExtent'\r\n        ),\r\n        tooltip: this.languageService.translate.instant(\r\n          'igo.integration.workspace.standardExtentTooltip'\r\n        ),\r\n        icon: 'resize',\r\n        display: () => {\r\n          return this.maximize$.pipe(map((v) => v && !this.mediaService.isMobile()));\r\n        },\r\n        handler: () => {\r\n          this.maximize$.next(false);\r\n        }\r\n      }\r\n    ];\r\n    return (workspace.layer.dataSource as OgcFilterableDataSource).ogcFilters$?.value?.enabled ?\r\n    actions : actions.filter(action => action.id !== 'ogcFilter');\r\n  }\r\n}\r\n"]}

package/{esm2015/lib/workspace/shared/workspace.utils.js → esm2020/lib/workspace/shared/workspace.utils.mjs}

@@ -4,4 +4,4 @@ export function handleZoomAuto(workspace, storageService) {
         .getStrategyOfType(FeatureStoreSelectionStrategy);
     zoomStrategy.setMotion(storageService.get('zoomAuto') ? FeatureMotion.Default : FeatureMotion.None);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLnV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvaW50ZWdyYXRpb24vc3JjL2xpYi93b3Jrc3BhY2Uvc2hhcmVkL3dvcmtzcGFjZS51dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0gsYUFBYSxFQUNiLDZCQUE2QixFQUloQyxNQUFNLFdBQVcsQ0FBQztBQUduQixNQUFNLFVBQVUsY0FBYyxDQUFDLFNBQTZELEVBQUUsY0FBYztJQUN4RyxNQUFNLFlBQVksR0FBRyxTQUFTLENBQUMsV0FBVztTQUNyQyxpQkFBaUIsQ0FBQyw2QkFBNkIsQ0FBa0MsQ0FBQztJQUN2RixZQUFZLENBQUMsU0FBUyxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFZLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUNuSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgICBGZWF0dXJlTW90aW9uLFxuICAgIEZlYXR1cmVTdG9yZVNlbGVjdGlvblN0cmF0ZWd5LFxuICAgIEZlYXR1cmVXb3Jrc3BhY2UsXG4gICAgV2ZzV29ya3NwYWNlLFxuICAgIEVkaXRpb25Xb3Jrc3BhY2Vcbn0gZnJvbSAnQGlnbzIvZ2VvJztcblxuXG5leHBvcnQgZnVuY3Rpb24gaGFuZGxlWm9vbUF1dG8od29ya3NwYWNlOiBGZWF0dXJlV29ya3NwYWNlIHwgV2ZzV29ya3NwYWNlIHwgRWRpdGlvbldvcmtzcGFjZSwgc3RvcmFnZVNlcnZpY2UpIHtcbiAgICBjb25zdCB6b29tU3RyYXRlZ3kgPSB3b3Jrc3BhY2UuZW50aXR5U3RvcmVcbiAgICAgICAgLmdldFN0cmF0ZWd5T2ZUeXBlKEZlYXR1cmVTdG9yZVNlbGVjdGlvblN0cmF0ZWd5KSBhcyBGZWF0dXJlU3RvcmVTZWxlY3Rpb25TdHJhdGVneTtcbiAgICB6b29tU3RyYXRlZ3kuc2V0TW90aW9uKHN0b3JhZ2VTZXJ2aWNlLmdldCgnem9vbUF1dG8nKSBhcyBib29sZWFuID8gRmVhdHVyZU1vdGlvbi5EZWZhdWx0IDogRmVhdHVyZU1vdGlvbi5Ob25lKTtcbn1cblxuXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLnV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvaW50ZWdyYXRpb24vc3JjL2xpYi93b3Jrc3BhY2Uvc2hhcmVkL3dvcmtzcGFjZS51dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0gsYUFBYSxFQUNiLDZCQUE2QixFQUloQyxNQUFNLFdBQVcsQ0FBQztBQUduQixNQUFNLFVBQVUsY0FBYyxDQUFDLFNBQTZELEVBQUUsY0FBYztJQUN4RyxNQUFNLFlBQVksR0FBRyxTQUFTLENBQUMsV0FBVztTQUNyQyxpQkFBaUIsQ0FBQyw2QkFBNkIsQ0FBa0MsQ0FBQztJQUN2RixZQUFZLENBQUMsU0FBUyxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFZLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUNuSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcclxuICAgIEZlYXR1cmVNb3Rpb24sXHJcbiAgICBGZWF0dXJlU3RvcmVTZWxlY3Rpb25TdHJhdGVneSxcclxuICAgIEZlYXR1cmVXb3Jrc3BhY2UsXHJcbiAgICBXZnNXb3Jrc3BhY2UsXHJcbiAgICBFZGl0aW9uV29ya3NwYWNlXHJcbn0gZnJvbSAnQGlnbzIvZ2VvJztcclxuXHJcblxyXG5leHBvcnQgZnVuY3Rpb24gaGFuZGxlWm9vbUF1dG8od29ya3NwYWNlOiBGZWF0dXJlV29ya3NwYWNlIHwgV2ZzV29ya3NwYWNlIHwgRWRpdGlvbldvcmtzcGFjZSwgc3RvcmFnZVNlcnZpY2UpIHtcclxuICAgIGNvbnN0IHpvb21TdHJhdGVneSA9IHdvcmtzcGFjZS5lbnRpdHlTdG9yZVxyXG4gICAgICAgIC5nZXRTdHJhdGVneU9mVHlwZShGZWF0dXJlU3RvcmVTZWxlY3Rpb25TdHJhdGVneSkgYXMgRmVhdHVyZVN0b3JlU2VsZWN0aW9uU3RyYXRlZ3k7XHJcbiAgICB6b29tU3RyYXRlZ3kuc2V0TW90aW9uKHN0b3JhZ2VTZXJ2aWNlLmdldCgnem9vbUF1dG8nKSBhcyBib29sZWFuID8gRmVhdHVyZU1vdGlvbi5EZWZhdWx0IDogRmVhdHVyZU1vdGlvbi5Ob25lKTtcclxufVxyXG5cclxuXHJcbiJdfQ==

package/{esm2015/lib/workspace/workspace-button/index.js → esm2020/lib/workspace/workspace-button/index.mjs}

@@ -1,2 +1,2 @@
 export * from './workspace-button.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9pbnRlZ3JhdGlvbi9zcmMvbGliL3dvcmtzcGFjZS93b3Jrc3BhY2UtYnV0dG9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3dvcmtzcGFjZS1idXR0b24uY29tcG9uZW50JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9pbnRlZ3JhdGlvbi9zcmMvbGliL3dvcmtzcGFjZS93b3Jrc3BhY2UtYnV0dG9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3dvcmtzcGFjZS1idXR0b24uY29tcG9uZW50JztcclxuIl19

package/esm2020/lib/workspace/workspace-button/workspace-button.component.mjs

@@ -0,0 +1,69 @@
+import { Component, Input, ChangeDetectionStrategy } from '@angular/core';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../workspace.state";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/tooltip";
+import * as i6 from "@ngx-translate/core";
+function WorkspaceButtonComponent_button_0_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 1);
+    i0.ɵɵlistener("click", function WorkspaceButtonComponent_button_0_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r2); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.activateWorkspace()); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵelement(2, "mat-icon", 2);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 2, "igo.integration.workspace.toggleWorkspace"))("color", ctx_r0.color);
+} }
+export class WorkspaceButtonComponent {
+    constructor(workspaceState) {
+        this.workspaceState = workspaceState;
+        this.hasWorkspace$ = new BehaviorSubject(false);
+        this.layer$ = new BehaviorSubject(undefined);
+        this.color = 'primary';
+    }
+    set layer(value) {
+        this._layer = value;
+        this.layer$.next(this._layer);
+    }
+    get layer() {
+        return this._layer;
+    }
+    ngOnInit() {
+        this.hasWorkspace$$ = combineLatest([this.workspaceState.workspaceEnabled$, this.layer$])
+            .subscribe(bunch => this.hasWorkspace$.next(bunch[0] && bunch[1]?.options.workspace?.enabled));
+    }
+    ngOnDestroy() {
+        this.hasWorkspace$$.unsubscribe();
+    }
+    activateWorkspace() {
+        if (this.workspaceState.workspace$.value &&
+            this.workspaceState.workspace$.value.layer.id === this.layer.id &&
+            this.workspaceState.workspacePanelExpanded) {
+            this.workspaceState.workspacePanelExpanded = false;
+        }
+        else {
+            this.workspaceState.workspacePanelExpanded = true;
+            this.workspaceState.setActiveWorkspaceById(this.layer.id);
+        }
+    }
+}
+WorkspaceButtonComponent.ɵfac = function WorkspaceButtonComponent_Factory(t) { return new (t || WorkspaceButtonComponent)(i0.ɵɵdirectiveInject(i1.WorkspaceState)); };
+WorkspaceButtonComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: WorkspaceButtonComponent, selectors: [["igo-workspace-button"]], inputs: { layer: "layer", color: "color" }, decls: 2, vars: 3, consts: [["mat-icon-button", "", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "matTooltip", "color", "click", 4, "ngIf"], ["mat-icon-button", "", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "matTooltip", "color", "click"], ["svgIcon", "table"]], template: function WorkspaceButtonComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, WorkspaceButtonComponent_button_0_Template, 3, 4, "button", 0);
+        i0.ɵɵpipe(1, "async");
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(1, 1, ctx.hasWorkspace$));
+    } }, dependencies: [i2.NgIf, i3.MatIcon, i4.MatButton, i5.MatTooltip, i2.AsyncPipe, i6.TranslatePipe], changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WorkspaceButtonComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-workspace-button', changeDetection: ChangeDetectionStrategy.OnPush, template: "<button\r\n  *ngIf=\"hasWorkspace$ | async\"\r\n  mat-icon-button\r\n  tooltip-position=\"below\"\r\n  matTooltipShowDelay=\"500\"\r\n  [matTooltip]=\"'igo.integration.workspace.toggleWorkspace' | translate\"\r\n  [color]=\"color\"\r\n  (click)=\"activateWorkspace()\"\r\n  >\r\n  <mat-icon svgIcon=\"table\"></mat-icon>\r\n</button>\r\n" }]
+    }], function () { return [{ type: i1.WorkspaceState }]; }, { layer: [{
+            type: Input
+        }], color: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/workspace/workspace.module.js → esm2020/lib/workspace/workspace.module.mjs}

@@ -10,13 +10,11 @@ export class IgoAppWorkspaceModule {
 }
 IgoAppWorkspaceModule.ɵfac = function IgoAppWorkspaceModule_Factory(t) { return new (t || IgoAppWorkspaceModule)(); };
 IgoAppWorkspaceModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoAppWorkspaceModule });
-IgoAppWorkspaceModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [[
-            CommonModule,
-            MatIconModule,
-            MatButtonModule,
-            MatTooltipModule,
-            IgoLanguageModule
-        ]] });
+IgoAppWorkspaceModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+        MatIconModule,
+        MatButtonModule,
+        MatTooltipModule,
+        IgoLanguageModule] });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoAppWorkspaceModule, [{
         type: NgModule,
         args: [{
@@ -36,4 +34,4 @@ IgoAppWorkspaceModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [[
         MatButtonModule,
         MatTooltipModule,
         IgoLanguageModule], exports: [WorkspaceButtonComponent] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2ludGVncmF0aW9uL3NyYy9saWIvd29ya3NwYWNlL3dvcmtzcGFjZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUN6RixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDN0QsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUMvQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7O0FBYS9DLE1BQU0sT0FBTyxxQkFBcUI7OzBGQUFyQixxQkFBcUI7dUVBQXJCLHFCQUFxQjsyRUFUOUIsWUFBWTtRQUNaLGFBQWE7UUFDYixlQUFlO1FBQ2YsZ0JBQWdCO1FBQ2hCLGlCQUFpQjt1RkFLUixxQkFBcUI7Y0FYakMsUUFBUTtlQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO29CQUNaLGFBQWE7b0JBQ2IsZUFBZTtvQkFDZixnQkFBZ0I7b0JBQ2hCLGlCQUFpQjtpQkFDbEI7Z0JBQ0QsWUFBWSxFQUFFLENBQUMsd0JBQXdCLENBQUM7Z0JBQ3hDLE9BQU8sRUFBRSxDQUFDLHdCQUF3QixDQUFDO2FBQ3BDOzt3RkFDWSxxQkFBcUIsbUJBSGpCLHdCQUF3QixhQU5yQyxZQUFZO1FBQ1osYUFBYTtRQUNiLGVBQWU7UUFDZixnQkFBZ0I7UUFDaEIsaUJBQWlCLGFBR1Qsd0JBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgV29ya3NwYWNlQnV0dG9uQ29tcG9uZW50IH0gZnJvbSAnLi93b3Jrc3BhY2UtYnV0dG9uL3dvcmtzcGFjZS1idXR0b24uY29tcG9uZW50JztcclxuaW1wb3J0IHsgTWF0QnV0dG9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvYnV0dG9uJztcclxuaW1wb3J0IHsgTWF0VG9vbHRpcE1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL3Rvb2x0aXAnO1xyXG5pbXBvcnQgeyBNYXRJY29uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvbic7XHJcbmltcG9ydCB7IElnb0xhbmd1YWdlTW9kdWxlIH0gZnJvbSAnQGlnbzIvY29yZSc7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGltcG9ydHM6IFtcclxuICAgIENvbW1vbk1vZHVsZSxcclxuICAgIE1hdEljb25Nb2R1bGUsXHJcbiAgICBNYXRCdXR0b25Nb2R1bGUsXHJcbiAgICBNYXRUb29sdGlwTW9kdWxlLFxyXG4gICAgSWdvTGFuZ3VhZ2VNb2R1bGVcclxuICBdLFxyXG4gIGRlY2xhcmF0aW9uczogW1dvcmtzcGFjZUJ1dHRvbkNvbXBvbmVudF0sXHJcbiAgZXhwb3J0czogW1dvcmtzcGFjZUJ1dHRvbkNvbXBvbmVudF1cclxufSlcclxuZXhwb3J0IGNsYXNzIElnb0FwcFdvcmtzcGFjZU1vZHVsZSB7fVxyXG4iXX0=

package/esm2020/lib/workspace/workspace.state.mjs

@@ -0,0 +1,188 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, of } from 'rxjs';
+import { WorkspaceStore, EntityStoreFilterCustomFuncStrategy, EntityStoreFilterSelectionStrategy } from '@igo2/common';
+import { WfsWorkspace, FeatureWorkspace, EditionWorkspace } from '@igo2/geo';
+import * as i0 from "@angular/core";
+import * as i1 from "./shared/feature-actions.service";
+import * as i2 from "./shared/wfs-actions.service";
+import * as i3 from "./shared/edition-actions.service";
+import * as i4 from "@igo2/core";
+/**
+ * Service that holds the state of the workspace module
+ */
+export class WorkspaceState {
+    constructor(featureActionsService, wfsActionsService, editionActionsService, storageService) {
+        this.featureActionsService = featureActionsService;
+        this.wfsActionsService = wfsActionsService;
+        this.editionActionsService = editionActionsService;
+        this.storageService = storageService;
+        this.workspacePanelExpanded = false;
+        this.workspaceEnabled$ = new BehaviorSubject(false);
+        this.rowsInMapExtentCheckCondition$ = new BehaviorSubject(true);
+        this.selectOnlyCheckCondition$ = new BehaviorSubject(false);
+        this.workspaceMaximize$ = new BehaviorSubject(this.storageService.get('workspaceMaximize'));
+        this.actionMaximize$$ = [];
+        /** Active widget observable. Only one may be active for all available workspaces */
+        this.activeWorkspaceWidget$ = new BehaviorSubject(undefined);
+        /**
+         * Observable of the active workspace
+         */
+        this.workspace$ = new BehaviorSubject(undefined);
+        this.initWorkspaces();
+    }
+    /**
+     * Store that holds all the available workspaces
+     */
+    get store() { return this._store; }
+    get workspaceSelection() {
+        if (this.workspace$.value) {
+            return this.workspace$.value?.entityStore.stateView.manyBy((r) => r.state.selected === true);
+        }
+        else {
+            return [];
+        }
+    }
+    get workspaceSelection$() {
+        if (this.workspace$.value) {
+            return this.workspace$.value?.entityStore?.stateView.manyBy$((r) => r.state.selected === true);
+        }
+        else {
+            return of([]);
+        }
+    }
+    /**
+     * Initialize the workspace store. Each time a workspace is activated,
+     * subscribe to it's active widget. Tracking the active widget is useful
+     * to make sure only one widget is active at a time.
+     */
+    initWorkspaces() {
+        this._store = new WorkspaceStore([]);
+        this._store.stateView
+            .firstBy$((record) => record.state.active === true)
+            .subscribe((record) => {
+            const workspace = record ? record.entity : undefined;
+            this.workspace$.next(workspace);
+        });
+        this._store.stateView.all$()
+            .subscribe((workspaces) => {
+            workspaces.map((wks) => {
+                if (wks.entity.actionStore.empty) {
+                    if (wks.entity instanceof WfsWorkspace) {
+                        this.wfsActionsService.loadActions(wks.entity, this.rowsInMapExtentCheckCondition$, this.selectOnlyCheckCondition$);
+                    }
+                    else if (wks.entity instanceof FeatureWorkspace) {
+                        this.featureActionsService.loadActions(wks.entity, this.rowsInMapExtentCheckCondition$, this.selectOnlyCheckCondition$);
+                    }
+                    else if (wks.entity instanceof EditionWorkspace) {
+                        this.editionActionsService.loadActions(wks.entity, this.rowsInMapExtentCheckCondition$, this.selectOnlyCheckCondition$);
+                    }
+                }
+            });
+        });
+        this.actionMaximize$$.push(this.featureActionsService.maximize$.subscribe(maximized => {
+            this.setWorkspaceIsMaximized(maximized);
+        }));
+        this.actionMaximize$$.push(this.wfsActionsService.maximize$.subscribe(maximized => {
+            this.setWorkspaceIsMaximized(maximized);
+        }));
+        this.actionMaximize$$.push(this.editionActionsService.maximize$.subscribe(maximized => {
+            this.setWorkspaceIsMaximized(maximized);
+        }));
+        this.activeWorkspace$$ = this.workspace$
+            .subscribe((workspace) => {
+            if (this.activeWorkspaceWidget$$ !== undefined) {
+                this.activeWorkspaceWidget$$.unsubscribe();
+                this.activeWorkspaceWidget$$ = undefined;
+            }
+            if (workspace !== undefined) {
+                this.activeWorkspaceWidget$$ = workspace.widget$
+                    .subscribe((widget) => this.activeWorkspaceWidget$.next(widget));
+            }
+        });
+        this.rowsInMapExtentCheckCondition$$ = this.rowsInMapExtentCheckCondition$.subscribe((rowsInMapExtent) => {
+            this._store.stateView.all().map((wks) => {
+                if (!wks.entity.actionStore.empty) {
+                    const filterStrategy = wks.entity.entityStore.getStrategyOfType(EntityStoreFilterCustomFuncStrategy);
+                    if (filterStrategy) {
+                        if (rowsInMapExtent) {
+                            filterStrategy.activate();
+                        }
+                        else {
+                            filterStrategy.deactivate();
+                        }
+                    }
+                }
+            });
+        });
+        this.selectOnlyCheckCondition$$ = this.selectOnlyCheckCondition$.subscribe((selectOnly) => {
+            this._store.stateView.all().map((wks) => {
+                if (!wks.entity.actionStore.empty) {
+                    const filterStrategy = wks.entity.entityStore.getStrategyOfType(EntityStoreFilterSelectionStrategy);
+                    if (filterStrategy) {
+                        if (selectOnly) {
+                            filterStrategy.activate();
+                        }
+                        else {
+                            filterStrategy.deactivate();
+                        }
+                    }
+                }
+            });
+        });
+    }
+    setWorkspaceIsMaximized(maximized) {
+        this.storageService.set('workspaceMaximize', maximized);
+        this.workspaceMaximize$.next(maximized);
+    }
+    setActiveWorkspaceById(id) {
+        const wksFromId = this.store
+            .all()
+            .find(workspace => workspace.id === id);
+        if (wksFromId) {
+            this.store.activateWorkspace(wksFromId);
+        }
+    }
+    setActiveWorkspaceByTitle(title) {
+        const wksFromTitle = this.store
+            .all()
+            .find(workspace => workspace.title === title);
+        if (wksFromTitle) {
+            this.store.activateWorkspace(wksFromTitle);
+        }
+    }
+    /**
+     * Teardown all the workspaces
+     * @internal
+     */
+    ngOnDestroy() {
+        this.teardownWorkspaces();
+        this.actionMaximize$$.map(a => a.unsubscribe());
+        if (this.rowsInMapExtentCheckCondition$$) {
+            this.selectOnlyCheckCondition$$.unsubscribe();
+        }
+        if (this.selectOnlyCheckCondition$$) {
+            this.selectOnlyCheckCondition$$.unsubscribe();
+        }
+    }
+    /**
+     * Teardown the workspace store and any subscribers
+     */
+    teardownWorkspaces() {
+        this.store.clear();
+        if (this.activeWorkspaceWidget$$ !== undefined) {
+            this.activeWorkspaceWidget$$.unsubscribe();
+        }
+        if (this.activeWorkspace$$ !== undefined) {
+            this.activeWorkspace$$.unsubscribe();
+        }
+    }
+}
+WorkspaceState.ɵfac = function WorkspaceState_Factory(t) { return new (t || WorkspaceState)(i0.ɵɵinject(i1.FeatureActionsService), i0.ɵɵinject(i2.WfsActionsService), i0.ɵɵinject(i3.EditionActionsService), i0.ɵɵinject(i4.StorageService)); };
+WorkspaceState.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WorkspaceState, factory: WorkspaceState.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WorkspaceState, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.FeatureActionsService }, { type: i2.WfsActionsService }, { type: i3.EditionActionsService }, { type: i4.StorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace.state.js","sourceRoot":"","sources":["../../../../../packages/integration/src/lib/workspace/workspace.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\n\r\nimport { BehaviorSubject, Subscription, Observable, of } from 'rxjs';\r\n\r\nimport {\r\n  EntityRecord,\r\n  Workspace,\r\n  WorkspaceStore,\r\n  Widget,\r\n  EntityStoreFilterCustomFuncStrategy,\r\n  EntityStoreFilterSelectionStrategy,\r\n  EntityState } from '@igo2/common';\r\nimport { WfsWorkspace, FeatureWorkspace, EditionWorkspace } from '@igo2/geo';\r\nimport { FeatureActionsService } from './shared/feature-actions.service';\r\nimport { WfsActionsService } from './shared/wfs-actions.service';\r\nimport { StorageService } from '@igo2/core';\r\nimport { EditionActionsService } from './shared/edition-actions.service';\r\n\r\n/**\r\n * Service that holds the state of the workspace module\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WorkspaceState implements OnDestroy {\r\n\r\n  public workspacePanelExpanded: boolean = false;\r\n\r\n  readonly workspaceEnabled$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n  readonly rowsInMapExtentCheckCondition$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);\r\n  readonly selectOnlyCheckCondition$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n\r\n  readonly workspaceMaximize$: BehaviorSubject<boolean> = new BehaviorSubject(\r\n    this.storageService.get('workspaceMaximize') as boolean\r\n  );\r\n  private actionMaximize$$: Subscription[] = [];\r\n\r\n  private rowsInMapExtentCheckCondition$$: Subscription;\r\n  private selectOnlyCheckCondition$$: Subscription;\r\n\r\n  /** Subscription to the active workspace */\r\n  private activeWorkspace$$: Subscription;\r\n\r\n  /** Subscription to the active workspace widget */\r\n  private activeWorkspaceWidget$$: Subscription;\r\n\r\n  /** Active widget observable. Only one may be active for all available workspaces */\r\n  readonly activeWorkspaceWidget$: BehaviorSubject<Widget> = new BehaviorSubject<Widget>(undefined);\r\n\r\n  /**\r\n   * Observable of the active workspace\r\n   */\r\n  public workspace$ = new BehaviorSubject<Workspace>(undefined);\r\n\r\n  /**\r\n   * Store that holds all the available workspaces\r\n   */\r\n  get store(): WorkspaceStore { return this._store; }\r\n  private _store: WorkspaceStore;\r\n\r\n  get workspaceSelection() {\r\n    if (this.workspace$.value) {\r\n    return this.workspace$.value?.entityStore.stateView.manyBy((r) => r.state.selected === true);\r\n    } else {\r\n      return [];\r\n    }\r\n  }\r\n\r\n  get workspaceSelection$(): Observable<EntityRecord<object, EntityState>[]> {\r\n    if (this.workspace$.value) {\r\n      return this.workspace$.value?.entityStore?.stateView.manyBy$((r) => r.state.selected === true);\r\n    } else {\r\n      return of([]);\r\n    }\r\n  }\r\n\r\n  constructor(\r\n    private featureActionsService: FeatureActionsService,\r\n    private wfsActionsService: WfsActionsService,\r\n    private editionActionsService: EditionActionsService,\r\n    private storageService: StorageService\r\n  ) {\r\n    this.initWorkspaces();\r\n  }\r\n\r\n  /**\r\n   * Initialize the workspace store. Each time a workspace is activated,\r\n   * subscribe to it's active widget. Tracking the active widget is useful\r\n   * to make sure only one widget is active at a time.\r\n   */\r\n  private initWorkspaces() {\r\n    this._store = new WorkspaceStore([]);\r\n    this._store.stateView\r\n      .firstBy$((record: EntityRecord<Workspace>) => record.state.active === true)\r\n      .subscribe((record: EntityRecord<Workspace>) => {\r\n        const workspace = record ? record.entity : undefined;\r\n        this.workspace$.next(workspace);\r\n      });\r\n\r\n    this._store.stateView.all$()\r\n    .subscribe((workspaces: EntityRecord<Workspace>[]) => {\r\n      workspaces.map((wks: EntityRecord<Workspace>) => {\r\n        if (wks.entity.actionStore.empty) {\r\n          if (wks.entity instanceof WfsWorkspace) {\r\n            this.wfsActionsService.loadActions(\r\n              wks.entity,\r\n              this.rowsInMapExtentCheckCondition$,\r\n              this.selectOnlyCheckCondition$);\r\n          } else if (wks.entity instanceof FeatureWorkspace) {\r\n            this.featureActionsService.loadActions(\r\n              wks.entity,\r\n              this.rowsInMapExtentCheckCondition$,\r\n              this.selectOnlyCheckCondition$);\r\n          } else if (wks.entity instanceof EditionWorkspace) {\r\n            this.editionActionsService.loadActions(\r\n              wks.entity,\r\n              this.rowsInMapExtentCheckCondition$,\r\n              this.selectOnlyCheckCondition$);\r\n          }\r\n        }\r\n\r\n      });\r\n    });\r\n\r\n    this.actionMaximize$$.push(this.featureActionsService.maximize$.subscribe(maximized => {\r\n      this.setWorkspaceIsMaximized(maximized);\r\n    }));\r\n\r\n    this.actionMaximize$$.push(this.wfsActionsService.maximize$.subscribe(maximized => {\r\n      this.setWorkspaceIsMaximized(maximized);\r\n    }));\r\n\r\n    this.actionMaximize$$.push(this.editionActionsService.maximize$.subscribe(maximized => {\r\n      this.setWorkspaceIsMaximized(maximized);\r\n    }));\r\n\r\n    this.activeWorkspace$$ = this.workspace$\r\n      .subscribe((workspace: Workspace) => {\r\n        if (this.activeWorkspaceWidget$$ !== undefined) {\r\n          this.activeWorkspaceWidget$$.unsubscribe();\r\n          this.activeWorkspaceWidget$$ = undefined;\r\n        }\r\n\r\n        if (workspace !== undefined) {\r\n          this.activeWorkspaceWidget$$ = workspace.widget$\r\n            .subscribe((widget: Widget) => this.activeWorkspaceWidget$.next(widget));\r\n        }\r\n      });\r\n\r\n    this.rowsInMapExtentCheckCondition$$ = this.rowsInMapExtentCheckCondition$.subscribe((rowsInMapExtent) => {\r\n      this._store.stateView.all().map((wks: EntityRecord<Workspace>) => {\r\n        if (!wks.entity.actionStore.empty) {\r\n          const filterStrategy = wks.entity.entityStore.getStrategyOfType(EntityStoreFilterCustomFuncStrategy);\r\n          if (filterStrategy) {\r\n            if (rowsInMapExtent) {\r\n              filterStrategy.activate();\r\n            } else {\r\n              filterStrategy.deactivate();\r\n            }\r\n          }\r\n        }\r\n      });\r\n    });\r\n\r\n    this.selectOnlyCheckCondition$$ = this.selectOnlyCheckCondition$.subscribe((selectOnly) => {\r\n      this._store.stateView.all().map((wks: EntityRecord<Workspace>) => {\r\n        if (!wks.entity.actionStore.empty) {\r\n          const filterStrategy = wks.entity.entityStore.getStrategyOfType(EntityStoreFilterSelectionStrategy);\r\n          if (filterStrategy) {\r\n            if (selectOnly) {\r\n              filterStrategy.activate();\r\n            } else {\r\n              filterStrategy.deactivate();\r\n            }\r\n          }\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  private setWorkspaceIsMaximized(maximized: boolean) {\r\n    this.storageService.set('workspaceMaximize', maximized);\r\n    this.workspaceMaximize$.next(maximized);\r\n  }\r\n\r\n  public setActiveWorkspaceById(id: string) {\r\n    const wksFromId = this.store\r\n    .all()\r\n    .find(workspace => workspace.id === id);\r\n    if (wksFromId) {\r\n      this.store.activateWorkspace(wksFromId);\r\n    }\r\n  }\r\n\r\n  public setActiveWorkspaceByTitle(title: string) {\r\n    const wksFromTitle = this.store\r\n      .all()\r\n      .find(workspace => workspace.title === title);\r\n    if (wksFromTitle) {\r\n      this.store.activateWorkspace(wksFromTitle);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Teardown all the workspaces\r\n   * @internal\r\n   */\r\n  ngOnDestroy() {\r\n    this.teardownWorkspaces();\r\n    this.actionMaximize$$.map(a => a.unsubscribe());\r\n    if (this.rowsInMapExtentCheckCondition$$) {\r\n      this.selectOnlyCheckCondition$$.unsubscribe();\r\n    }\r\n    if (this.selectOnlyCheckCondition$$) {\r\n      this.selectOnlyCheckCondition$$.unsubscribe();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Teardown the workspace store and any subscribers\r\n   */\r\n  private teardownWorkspaces() {\r\n    this.store.clear();\r\n    if (this.activeWorkspaceWidget$$ !== undefined) {\r\n      this.activeWorkspaceWidget$$.unsubscribe();\r\n    }\r\n    if (this.activeWorkspace$$ !== undefined) {\r\n      this.activeWorkspace$$.unsubscribe();\r\n    }\r\n  }\r\n\r\n}\r\n"]}

package/{esm2015/public_api.js → esm2020/public_api.mjs}

@@ -32,4 +32,4 @@ export * from './lib/print';
 export * from './lib/search';
 export * from './lib/tool';
 export * from './lib/storage';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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