@genesislcap/foundation-workspace 14.406.0-workspaces.7

package/dist/esm/workspace-manager/workspace-manager.js

@@ -0,0 +1,436 @@
+import { __awaiter, __decorate } from "tslib";
+import { Auth, Connect } from '@genesislcap/foundation-comms';
+import { showNotificationDialog, showNotificationToast, } from '@genesislcap/foundation-notifications';
+import { customElement, observable } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { LayoutRegistry, GridRegistry, FilterRegistry, WorkspaceState, } from '../workspace';
+import { WorkspaceManagerStyles as styles } from './workspace-manager.styles';
+import { WORKSPACE_DESCRIPTION_MAX, WorkspaceManagerTemplate as template, } from './workspace-manager.template';
+/**
+ * Workspace persistence UI (save/load + share/delete shared workspaces).
+ * @alpha
+ */
+let WorkspaceManager = class WorkspaceManager extends FoundationElement {
+    constructor() {
+        super(...arguments);
+        this.workspaceName = '';
+        this.workspaceDescription = '';
+        this.savedWorkspaces = [];
+        this.sharedWorkspaces = [];
+        this.isLoading = false;
+        this.applyingWorkspace = false;
+        this.loadMode = 'MY';
+        this.saveMode = 'create';
+        this.selectedWorkspaceToOverwrite = '';
+        this.workspaceToShare = '';
+    }
+    sanitizeDescription(input) {
+        const cleaned = (input !== null && input !== void 0 ? input : '')
+            // allow only letters, numbers and whitespace
+            .replace(/[^a-zA-Z0-9\s]/g, '')
+            // normalise whitespace
+            .replace(/\s+/g, ' ')
+            .trim();
+        return cleaned.slice(0, WORKSPACE_DESCRIPTION_MAX);
+    }
+    updateWorkspaceDescription(raw) {
+        this.workspaceDescription = this.sanitizeDescription(raw);
+    }
+    setDescriptionFromSelectedWorkspace() {
+        var _a, _b;
+        const name = (_a = this.selectedWorkspaceToOverwrite) === null || _a === void 0 ? void 0 : _a.trim();
+        if (!name) {
+            this.workspaceDescription = '';
+            return;
+        }
+        const existing = this.savedWorkspaces.find((w) => w.name === name);
+        this.workspaceDescription = this.sanitizeDescription((_b = existing === null || existing === void 0 ? void 0 : existing.description) !== null && _b !== void 0 ? _b : '');
+    }
+    connectedCallback() {
+        const _super = Object.create(null, {
+            connectedCallback: { get: () => super.connectedCallback }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.connectedCallback.call(this);
+            yield this.refreshSavedWorkspaces();
+            yield this.refreshSharedWorkspaces();
+            this.canShareWorkspace = this.auth.currentUser.hasPermission('SHARE_WORKSPACE');
+        });
+    }
+    refreshSavedWorkspaces() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isLoading = true;
+            try {
+                this.savedWorkspaces = yield this.workspaceState.getSavedWorkspaces();
+            }
+            catch (error) {
+                console.error('Failed to load saved workspaces', error);
+                this.savedWorkspaces = [];
+            }
+            finally {
+                this.isLoading = false;
+            }
+        });
+    }
+    refreshSharedWorkspaces() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.connect.request('REQ_SHARED_WORKSPACES');
+                const rows = (response === null || response === void 0 ? void 0 : response.REPLY) || [];
+                this.sharedWorkspaces = rows.map((row) => {
+                    var _a;
+                    return ({
+                        id: row.SHARED_WORKSPACE_ID,
+                        name: row.WORKSPACE_NAME,
+                        userName: row.USER_NAME,
+                        description: (_a = row.DESCRIPTION) !== null && _a !== void 0 ? _a : undefined,
+                        createdOn: row.CREATED_ON,
+                        modifiedOn: row.MODIFIED_ON,
+                        data: row.WORKSPACE_DATA,
+                    });
+                });
+            }
+            catch (error) {
+                this.notifyError(`REQ_SHARED_WORKSPACES ${JSON.stringify(error)}`);
+                console.error('Failed to load shared workspaces', error);
+                this.sharedWorkspaces = [];
+            }
+        });
+    }
+    notifyError(body = 'Error') {
+        showNotificationToast({ title: 'Error', body, iconName: 'bell', toast: { type: 'error', autoClose: false } }, 'rapid');
+    }
+    saveWorkspace() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workspaceName = this.saveMode === 'overwrite'
+                ? this.selectedWorkspaceToOverwrite.trim()
+                : this.workspaceName.trim();
+            if (!workspaceName) {
+                console.error('workspace-manager: workspace name is required');
+                return;
+            }
+            try {
+                const layoutConfigs = this.layoutRegistry.getLayoutsConfigs();
+                const gridSettings = this.gridRegistry.getAllGridsSettings();
+                const filterValues = this.filterRegistry.getAllFiltersValues();
+                yield this.workspaceState.saveWorkspace(workspaceName, layoutConfigs, gridSettings, filterValues, this.workspaceDescription.trim() || undefined);
+                this.workspaceName = '';
+                this.workspaceDescription = '';
+                this.closeSaveDialog();
+                yield this.refreshSavedWorkspaces();
+                console.log('Workspace saved successfully');
+            }
+            catch (error) {
+                console.error('Failed to save workspace', error);
+            }
+        });
+    }
+    applyWorkspace(workspace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (workspace.filters && workspace.filters.length > 0) {
+                this.filterRegistry.applyFiltersValues(workspace.filters);
+            }
+            if (workspace.layouts && workspace.layouts.length > 0) {
+                yield this.layoutRegistry.applySavedLayouts(workspace.layouts);
+            }
+            if (workspace.grids && workspace.grids.length > 0) {
+                yield this.gridRegistry.applyAllGridsSettings(workspace.grids);
+            }
+        });
+    }
+    loadWorkspace(workspaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.applyingWorkspace = true;
+                const workspace = yield this.workspaceState.loadWorkspace(workspaceName);
+                if (workspace) {
+                    yield this.applyWorkspace(workspace);
+                    this.closeLoadDialog();
+                    console.log('Workspace loaded successfully');
+                }
+                else {
+                    console.warn('Workspace not found:', workspaceName);
+                }
+            }
+            catch (error) {
+                this.applyingWorkspace = false;
+                console.error('Failed to load workspace', error);
+            }
+            this.applyingWorkspace = false;
+        });
+    }
+    requestSharedWorkspace(SHARED_WORKSPACE_ID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.connect.request('REQ_LOAD_SHARED_WORKSPACE', {
+                    REQUEST: { SHARED_WORKSPACE_ID },
+                });
+                return response.REPLY || [];
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+    }
+    loadSharedWorkspace(shared) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.applyingWorkspace = true;
+                const sharedData = yield this.requestSharedWorkspace(shared.id);
+                if (!(sharedData === null || sharedData === void 0 ? void 0 : sharedData.length)) {
+                    console.warn('workspace has no data');
+                    return;
+                }
+                const dataJoined = sharedData.map((d) => d.WORKSPACE_DATA).join('');
+                const workspace = JSON.parse(dataJoined);
+                yield this.applyWorkspace(workspace);
+                this.closeLoadDialog();
+                console.log('Shared workspace loaded successfully');
+            }
+            catch (error) {
+                console.error('Failed to load shared workspace', error);
+            }
+            this.applyingWorkspace = false;
+        });
+    }
+    deleteWorkspace(workspaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.workspaceState.deleteWorkspace(workspaceName);
+                yield this.refreshSavedWorkspaces();
+                console.log('Workspace deleted successfully');
+            }
+            catch (error) {
+                console.error('Failed to delete workspace', error);
+            }
+        });
+    }
+    showDeleteConfirmation(title, body, actionFunction, dialogBoundary) {
+        showNotificationDialog({
+            title,
+            body,
+            dialog: {
+                confirmingActions: [{ label: 'Delete', action: actionFunction }],
+                dismissingAction: { label: 'Cancel' },
+            },
+        }, 'rapid', dialogBoundary);
+    }
+    confirmDeleteWorkspace(workspaceName) {
+        const trimmedName = workspaceName === null || workspaceName === void 0 ? void 0 : workspaceName.trim();
+        if (!trimmedName)
+            return;
+        this.showDeleteConfirmation('Delete workspace', `Are you sure you want to delete the workspace "${trimmedName}"? This action cannot be undone.`, () => this.deleteWorkspace(trimmedName), this.dialogBoundary);
+    }
+    modifySharedWorkspace(sharedWorkspace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const layouts = this.layoutRegistry.getLayoutsConfigs();
+                const grids = this.gridRegistry.getAllGridsSettings();
+                const filters = this.filterRegistry.getAllFiltersValues();
+                const baseWorkspace = yield this.workspaceState.loadWorkspace(sharedWorkspace.name);
+                const description = this.sanitizeDescription((_b = (_a = baseWorkspace === null || baseWorkspace === void 0 ? void 0 : baseWorkspace.description) !== null && _a !== void 0 ? _a : sharedWorkspace.description) !== null && _b !== void 0 ? _b : '') ||
+                    undefined;
+                const workspace = {
+                    name: sharedWorkspace.name,
+                    username: sharedWorkspace.userName,
+                    description,
+                    layouts,
+                    grids,
+                    filters,
+                    savedAt: new Date().toISOString(),
+                };
+                const response = yield this.connect.commitEvent('EVENT_SHARED_WORKSPACE_MODIFY', {
+                    VALIDATE: false,
+                    DETAILS: {
+                        WORKSPACE_NAME: sharedWorkspace.name,
+                        WORKSPACE_DATA: JSON.stringify(workspace),
+                        WORKSPACE_DESCRIPTION: description !== null && description !== void 0 ? description : null,
+                    },
+                });
+                if (response.MESSAGE_TYPE == 'EVENT_ACK') {
+                    this.closeSaveDialog();
+                }
+            }
+            catch (e) {
+                this.notifyError(`EVENT_SHARED_WORKSPACE_MODIFY ${JSON.stringify(e)}`);
+                console.error(e);
+            }
+        });
+    }
+    deleteSharedWorkspace(sharedWorkspace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.connect.commitEvent('EVENT_SHARED_WORKSPACE_DELETE', {
+                    VALIDATE: false,
+                    DETAILS: { WORKSPACE_NAME: sharedWorkspace.name },
+                });
+                if (response.MESSAGE_TYPE == 'EVENT_ACK') {
+                    this.closeSaveDialog();
+                    yield this.refreshSharedWorkspaces();
+                }
+            }
+            catch (e) {
+                this.notifyError(`EVENT_SHARED_WORKSPACE_DELETE ${JSON.stringify(e)}`);
+                console.error(e);
+            }
+        });
+    }
+    confirmDeleteSharedWorkspace(sharedWorkspace) {
+        if (!(sharedWorkspace === null || sharedWorkspace === void 0 ? void 0 : sharedWorkspace.name))
+            return;
+        this.showDeleteConfirmation('Delete shared workspace', `Are you sure you want to delete the shared workspace "${sharedWorkspace.name}"? This action cannot be undone.`, () => this.deleteSharedWorkspace(sharedWorkspace), this.sharedWorkspaceDialogBoundary);
+    }
+    shareExistingWorkspace(workspaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const name = workspaceName === null || workspaceName === void 0 ? void 0 : workspaceName.trim();
+            if (!name)
+                return;
+            try {
+                const workspace = yield this.workspaceState.loadWorkspace(name);
+                if (!workspace) {
+                    console.warn('Workspace not found for sharing:', name);
+                    return;
+                }
+                const response = yield this.connect.commitEvent('EVENT_SHARED_WORKSPACE_INSERT', {
+                    VALIDATE: false,
+                    DETAILS: {
+                        WORKSPACE_NAME: workspace.name,
+                        WORKSPACE_DATA: JSON.stringify(workspace),
+                        WORKSPACE_DESCRIPTION: (_a = workspace.description) !== null && _a !== void 0 ? _a : null,
+                    },
+                });
+                if (response.MESSAGE_TYPE == 'EVENT_ACK') {
+                    console.log('Workspace shared successfully');
+                    this.closeSaveDialog();
+                    yield this.refreshSharedWorkspaces();
+                }
+                else if (response.MESSAGE_TYPE == 'EVENT_NACK') {
+                    console.warn('Failed to share workspace', response);
+                    this.closeSaveDialog();
+                }
+            }
+            catch (error) {
+                console.error('Failed to share workspace', error);
+            }
+        });
+    }
+    openSaveDialog() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshSavedWorkspaces();
+            this.saveModal.show();
+            this.workspaceName = '';
+            this.workspaceDescription = '';
+            this.saveMode = 'create';
+            this.selectedWorkspaceToOverwrite = '';
+            this.workspaceToShare = '';
+        });
+    }
+    isWorkspaceExisting(workspaceName) {
+        return this.savedWorkspaces.some((p) => p.name.toLowerCase() === workspaceName.toLowerCase());
+    }
+    saveModeChanged(oldValue, newValue) {
+        if (newValue === 'create') {
+            this.selectedWorkspaceToOverwrite = '';
+            this.workspaceDescription = '';
+        }
+        else if (newValue === 'overwrite') {
+            this.workspaceName = '';
+            this.setDescriptionFromSelectedWorkspace();
+        }
+        else if (newValue === 'shared') {
+            this.workspaceName = '';
+            this.selectedWorkspaceToOverwrite = '';
+            this.workspaceDescription = '';
+        }
+    }
+    selectedWorkspaceToOverwriteChanged(oldValue, newValue) {
+        if (this.saveMode === 'overwrite') {
+            this.setDescriptionFromSelectedWorkspace();
+        }
+    }
+    openLoadDialog() {
+        this.refreshSharedWorkspaces();
+        this.loadModal.show();
+    }
+    closeSaveDialog() {
+        this.saveModal.close();
+        this.workspaceName = '';
+        this.workspaceDescription = '';
+    }
+    closeLoadDialog() {
+        this.loadModal.close();
+    }
+};
+__decorate([
+    observable
+], WorkspaceManager.prototype, "workspaceName", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "workspaceDescription", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "savedWorkspaces", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "sharedWorkspaces", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "isLoading", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "applyingWorkspace", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "loadMode", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "saveModal", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "loadModal", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "saveMode", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "selectedWorkspaceToOverwrite", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "workspaceToShare", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "dialogBoundary", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "sharedWorkspaceDialogBoundary", void 0);
+__decorate([
+    LayoutRegistry
+], WorkspaceManager.prototype, "layoutRegistry", void 0);
+__decorate([
+    GridRegistry
+], WorkspaceManager.prototype, "gridRegistry", void 0);
+__decorate([
+    FilterRegistry
+], WorkspaceManager.prototype, "filterRegistry", void 0);
+__decorate([
+    WorkspaceState
+], WorkspaceManager.prototype, "workspaceState", void 0);
+__decorate([
+    Connect
+], WorkspaceManager.prototype, "connect", void 0);
+__decorate([
+    Auth
+], WorkspaceManager.prototype, "auth", void 0);
+__decorate([
+    observable
+], WorkspaceManager.prototype, "canShareWorkspace", void 0);
+WorkspaceManager = __decorate([
+    customElement({
+        name: 'workspace-manager',
+        template,
+        styles,
+    })
+], WorkspaceManager);
+export { WorkspaceManager };

package/dist/esm/workspace-manager/workspace-manager.styles.js

@@ -0,0 +1,138 @@
+import { css } from '@microsoft/fast-element';
+export const WorkspaceManagerStyles = css `
+  .workspace-manager {
+    display: flex;
+    gap: 10px;
+    align-items: center;
+  }
+
+  .dialog-content {
+    padding: 16px;
+    min-width: 400px;
+    max-width: 400px;
+    display: flex;
+    flex-direction: column;
+    max-height: 90vh;
+    overflow: hidden;
+  }
+
+  .button-group {
+    display: flex;
+    gap: 8px;
+    justify-content: flex-end;
+  }
+
+  .workspace-list {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    max-height: 400px;
+    overflow-y: auto;
+    margin: 10px 0;
+    align-items: unset;
+  }
+
+  rapid-label {
+    margin-bottom: 10px;
+    display: block;
+  }
+
+  .empty-state {
+    padding: 24px;
+    text-align: center;
+    color: var(--neutral-foreground-hint);
+  }
+
+  .save-mode-selector {
+    margin-bottom: 16px;
+  }
+
+  .warning-message {
+    margin: 12px 0;
+    padding: 12px;
+    border: 1px solid var(--warning-color);
+    border-radius: 4px;
+    font-size: 14px;
+  }
+
+  .workspace-item {
+    padding: 12px;
+    border: 1px solid var(--neutral-stroke-rest);
+    border-radius: 4px;
+    background: var(--neutral-fill-rest);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+  }
+
+  .workspace-item:hover {
+    background: var(--neutral-fill-hover);
+  }
+
+  .workspace-item::part(control) {
+    margin-top: 2px;
+  }
+
+  .workspace-info {
+    flex: 1;
+    margin-left: 8px;
+  }
+
+  .workspace-name {
+    font-weight: 600;
+    margin-bottom: 4px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+  }
+
+  .workspace-date {
+    font-size: 12px;
+    color: var(--neutral-foreground-hint);
+  }
+
+  .workspace-description {
+    font-size: 12px;
+    color: var(--neutral-foreground-hint);
+    margin-top: 4px;
+    white-space: pre-wrap;
+    word-break: break-word;
+    line-height: 1.4;
+  }
+
+  .workspace-description-input {
+    width: 100%;
+    min-height: 60px;
+    padding: 8px 12px;
+    margin-bottom: 16px;
+    font-family: inherit;
+    font-size: 14px;
+    border: 1px solid var(--neutral-stroke-rest);
+    border-radius: 4px;
+    background: var(--neutral-fill-rest);
+    color: var(--neutral-foreground-rest);
+    resize: vertical;
+    box-sizing: border-box;
+  }
+
+  .workspace-description-input::placeholder {
+    color: var(--neutral-foreground-hint);
+  }
+
+  .workspace-description-input:focus {
+    outline: none;
+    border-color: var(--accent-fill-rest);
+  }
+
+  .loading-container {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 24px;
+  }
+
+  .save-field {
+    margin-bottom: 20px;
+  }
+`;