@genesislcap/foundation-workspace 14.406.0-workspaces.7

package/dist/esm/workspace/grid-register/grid-register.js

@@ -0,0 +1,136 @@
+import { __awaiter, __decorate } from "tslib";
+import { attr, customElement } from '@microsoft/fast-element';
+import { GridRegistry, WorkspaceState } from '..';
+import { GridRegisterTemplate as template } from './grid-register.template';
+const name = 'grid-register';
+/**
+ * Registers an AG Grid instance so workspace state can apply/load it.
+ * @alpha
+ */
+let GridRegister = class GridRegister extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        this.gridElement = null;
+        this.gridApi = null;
+        this.columnApi = null;
+        this.workspaceSettingsApplied = false;
+        this.handleGridReady = () => {
+            this.attachToGridApis();
+        };
+    }
+    connectedCallback() {
+        this.findAndRegisterGrid();
+    }
+    disconnectedCallback() {
+        if (this.gridKey) {
+            this.gridRegistry.unregisterGrid(this.gridKey);
+        }
+        this.detachFromGridApis();
+    }
+    findAndRegisterGrid() {
+        this.gridElement = this.querySelector('rapid-grid-pro');
+        if (this.gridElement) {
+            this.gridElement.addEventListener('gridReady', this.handleGridReady);
+            this.attachToGridApis();
+        }
+        else {
+            setTimeout(() => {
+                this.gridElement = this.querySelector('rapid-grid-pro');
+                if (this.gridElement) {
+                    this.gridElement.addEventListener('gridReady', this.handleGridReady);
+                    this.attachToGridApis();
+                }
+                else {
+                    console.warn(`grid-register: rapid-grid-pro element not found`);
+                }
+            }, 100);
+        }
+    }
+    attachToGridApis() {
+        var _a;
+        if (!this.gridElement) {
+            return;
+        }
+        const anyGrid = this.gridElement;
+        const gridApi = anyGrid.gridApi || null;
+        const columnApi = anyGrid.columnApi || null;
+        const persistKey = ((_a = anyGrid === null || anyGrid === void 0 ? void 0 : anyGrid.getAttribute) === null || _a === void 0 ? void 0 : _a.call(anyGrid, 'persist-column-state-key')) || this.gridKey;
+        if (!gridApi || this.gridApi === gridApi) {
+            return;
+        }
+        this.gridApi = gridApi;
+        this.columnApi = columnApi;
+        const effectiveGridKey = persistKey;
+        if (!effectiveGridKey) {
+            console.warn('grid-register: missing persist-column-state-key; grid state will not be saved');
+        }
+        else {
+            this.gridRegistry.registerGrid(effectiveGridKey, gridApi, columnApi);
+            this.gridKey = effectiveGridKey;
+        }
+        if (!this.workspaceSettingsApplied && this.gridApi) {
+            this.loadWorkspaceColumnState().catch((error) => {
+                console.warn(`Failed to apply column state for ${this.gridKey} on gridReady:`, error);
+            });
+        }
+    }
+    detachFromGridApis() {
+        if (this.gridElement && this.handleGridReady) {
+            this.gridElement.removeEventListener('gridReady', this.handleGridReady);
+        }
+        this.gridElement = null;
+        this.gridApi = null;
+        this.columnApi = null;
+    }
+    loadWorkspaceSettings(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.gridKey || !this.columnApi || !this.gridApi) {
+                return;
+            }
+            try {
+                const currentWorkspace = this.workspaceState.getCurrentWorkspace();
+                if (currentWorkspace && currentWorkspace.grids) {
+                    const gridSetting = currentWorkspace.grids.find((g) => g.gridKey === this.gridKey);
+                    if (gridSetting) {
+                        const currentColumnState = this.columnApi.getColumnState() || [];
+                        const targetColumnState = gridSetting.columnState || [];
+                        const columnsEqual = JSON.stringify(currentColumnState) === JSON.stringify(targetColumnState);
+                        const applyColumns = !options || options.applyColumns !== false;
+                        const columnsOk = !applyColumns || columnsEqual;
+                        if (columnsOk) {
+                            return;
+                        }
+                        const applied = yield this.gridRegistry.applyGridSettings(gridSetting, options);
+                        if (!applied) {
+                            console.warn(`Failed to apply grid settings for ${this.gridKey}`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to load workspace settings for grid ${this.gridKey}:`, error);
+            }
+        });
+    }
+    loadWorkspaceColumnState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.loadWorkspaceSettings({ applyColumns: true });
+        });
+    }
+};
+__decorate([
+    attr({ attribute: 'grid-key' })
+], GridRegister.prototype, "gridKey", void 0);
+__decorate([
+    GridRegistry
+], GridRegister.prototype, "gridRegistry", void 0);
+__decorate([
+    WorkspaceState
+], GridRegister.prototype, "workspaceState", void 0);
+GridRegister = __decorate([
+    customElement({
+        name,
+        template,
+    })
+], GridRegister);
+export { GridRegister };

package/dist/esm/workspace/grid-register/grid-register.template.js

@@ -0,0 +1,4 @@
+import { html } from '@microsoft/fast-element';
+export const GridRegisterTemplate = html `
+  <slot></slot>
+`;

package/dist/esm/workspace/grid-register/index.js

@@ -0,0 +1 @@
+export * from './grid-register';

package/dist/esm/workspace/grid-registry.js

@@ -0,0 +1,109 @@
+import { __awaiter } from "tslib";
+import { DI } from '@microsoft/fast-foundation';
+/**
+ * @alpha
+ */
+export class DefaultGridRegistry {
+    constructor() {
+        this.grids = new Map();
+        this.cachedSettings = new Map();
+    }
+    // Note: StatePersistence is not wired here to avoid a hard dependency on grid-pro.
+    registerGrid(gridKey, gridApi, columnApi) {
+        this.grids.set(gridKey, {
+            gridKey,
+            gridApi: gridApi,
+            columnApi: columnApi,
+        });
+    }
+    getGrid(gridKey) {
+        return this.grids.get(gridKey) || null;
+    }
+    unregisterGrid(gridKey) {
+        const grid = this.grids.get(gridKey);
+        if (grid) {
+            const settings = this.getGridSettings(gridKey, grid);
+            if (settings) {
+                this.cachedSettings.set(gridKey, settings);
+            }
+        }
+        this.grids.delete(gridKey);
+    }
+    getAllGridsSettings() {
+        Array.from(this.grids).forEach(([key, grid]) => {
+            const settings = this.getGridSettings(key, grid);
+            if (settings) {
+                this.cachedSettings.set(key, settings);
+            }
+        });
+        return Array.from(this.cachedSettings.values()).filter((s) => !!s);
+    }
+    applyGridSettings(gridSetting, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const gridRegistration = this.grids.get(gridSetting.gridKey);
+            if (!gridRegistration || !gridRegistration.columnApi || !gridRegistration.gridApi) {
+                return false;
+            }
+            const hasColumnState = gridSetting.columnState && gridSetting.columnState.length > 0;
+            const applyColumns = !options || options.applyColumns !== false;
+            const shouldApplyColumns = applyColumns && !!hasColumnState;
+            if (!shouldApplyColumns) {
+                // No column state to apply; treat as a no-op.
+                return false;
+            }
+            try {
+                if (shouldApplyColumns) {
+                    gridRegistration.columnApi.applyColumnState({
+                        state: gridSetting.columnState,
+                        applyOrder: true,
+                    });
+                }
+                return true;
+            }
+            catch (error) {
+                console.warn(`Failed to apply settings for grid ${gridSetting.gridKey}:`, error);
+                return false;
+            }
+        });
+    }
+    applyAllGridsSettings(gridsSettings_1) {
+        return __awaiter(this, arguments, void 0, function* (gridsSettings, maxRetries = 3, delayMs = 200) {
+            // eslint-disable-next-line no-plusplus
+            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                const remainingSettings = [];
+                for (const gridSetting of gridsSettings) {
+                    // eslint-disable-next-line no-await-in-loop
+                    const applied = yield this.applyGridSettings(gridSetting);
+                    if (!applied) {
+                        remainingSettings.push(gridSetting);
+                    }
+                }
+                if (remainingSettings.length === 0 || attempt >= maxRetries - 1) {
+                    break;
+                }
+                // await new Promise((resolve) => setTimeout(resolve, delayMs));
+                gridsSettings = remainingSettings;
+            }
+        });
+    }
+    getGridSettings(gridKey, grid) {
+        var _a;
+        if (grid) {
+            const columnState = (_a = grid.columnApi) === null || _a === void 0 ? void 0 : _a.getColumnState();
+            const columnCount = (columnState === null || columnState === void 0 ? void 0 : columnState.length) || 0;
+            console.log(`Saved grid settings for ${gridKey}: ${columnCount} columns`);
+            return {
+                gridKey: grid.gridKey,
+                columnState: columnState || [],
+                savedAt: new Date().toISOString(),
+            };
+        }
+        console.warn(`No grid found for ${gridKey}`);
+        return null;
+    }
+}
+/**
+ * DI token for grid registry.
+ * @alpha
+ */
+export const GridRegistry = DI.createInterface((x) => x.singleton(DefaultGridRegistry));

package/dist/esm/workspace/index.js

@@ -0,0 +1,8 @@
+export * from './workspace.types';
+export * from './workspace-state.types';
+export * from './workspace-state';
+export * from './layout-registry';
+export * from './grid-registry';
+export * from './filter-registry';
+export * from './grid-register';
+export * from './layout-wrapper';

package/dist/esm/workspace/layout-registry.js

@@ -0,0 +1,45 @@
+import { __awaiter } from "tslib";
+import { DI } from '@microsoft/fast-foundation';
+/**
+ * Default layout registry implementation.
+ * @alpha
+ */
+export class DefaultLayoutRegistry {
+    constructor() {
+        this.layouts = new Map();
+    }
+    registerLayout(layoutKey, layout) {
+        if (!layoutKey) {
+            return;
+        }
+        this.layouts.set(layoutKey, layout);
+    }
+    unregisterLayout(layoutKey) {
+        this.layouts.delete(layoutKey);
+    }
+    getLayoutsConfigs() {
+        return Array.from(this.layouts).map(([key, layout]) => ({
+            layoutKey: key,
+            layout: layout.getLayout(),
+        }));
+    }
+    applySavedLayouts(savedLayouts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            savedLayouts.forEach((s) => {
+                const layout = this.layouts.get(s.layoutKey);
+                if (layout) {
+                    layout.loadLayout(s.layout, 'placeholder', true);
+                }
+                else {
+                    console.warn(`layout for ${s.layoutKey} not found`);
+                }
+            });
+            // await new Promise((resolve) => setTimeout(resolve, 300));
+        });
+    }
+}
+/**
+ * DI token for layout registry.
+ * @alpha
+ */
+export const LayoutRegistry = DI.createInterface((x) => x.singleton(DefaultLayoutRegistry));

package/dist/esm/workspace/layout-wrapper/index.js

@@ -0,0 +1 @@
+export * from './layout-wrapper';

package/dist/esm/workspace/layout-wrapper/layout-wrapper.js

@@ -0,0 +1,64 @@
+import { __decorate } from "tslib";
+import { attr, customElement } from '@microsoft/fast-element';
+import { LayoutRegistry } from '..';
+import { LayoutWrapperTemplate as template } from './layout-wrapper.template';
+const name = 'layout-register';
+/**
+ * Registers a layout instance so workspace state can apply/load it.
+ * @alpha
+ */
+let LayoutWrapper = class LayoutWrapper extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        this.layoutElement = null;
+    }
+    connectedCallback() {
+        this.findAndRegisterLayout();
+    }
+    disconnectedCallback() {
+        var _a, _b, _c, _d, _e;
+        const layoutKey = (_e = (_b = (_a = this.layoutElement) === null || _a === void 0 ? void 0 : _a.autoSaveKey) !== null && _b !== void 0 ? _b : (_d = (_c = this.layoutElement) === null || _c === void 0 ? void 0 : _c.getAttribute) === null || _d === void 0 ? void 0 : _d.call(_c, 'auto-save-key')) !== null && _e !== void 0 ? _e : this.layoutKey;
+        if (layoutKey) {
+            this.layoutRegistry.unregisterLayout(layoutKey);
+        }
+    }
+    findAndRegisterLayout() {
+        let layoutElement = this.querySelector('rapid-layout');
+        const registerLayout = (layout) => {
+            var _a, _b, _c;
+            if (!layout) {
+                console.warn(`layout-register: rapid-layout element not found`);
+                return;
+            }
+            this.layoutElement = layout;
+            const layoutKeyFromLayout = (_c = (_a = layout.autoSaveKey) !== null && _a !== void 0 ? _a : (_b = layout.getAttribute) === null || _b === void 0 ? void 0 : _b.call(layout, 'auto-save-key')) !== null && _c !== void 0 ? _c : this.layoutKey;
+            if (!layoutKeyFromLayout) {
+                console.warn('layout-register: missing layout key (auto-save-key/layout-key)');
+                return;
+            }
+            this.layoutRegistry.registerLayout(layoutKeyFromLayout, layout);
+        };
+        if (layoutElement) {
+            registerLayout(layoutElement);
+        }
+        else {
+            setTimeout(() => {
+                layoutElement = this.querySelector('rapid-layout');
+                registerLayout(layoutElement);
+            }, 100);
+        }
+    }
+};
+__decorate([
+    attr({ attribute: 'layout-key' })
+], LayoutWrapper.prototype, "layoutKey", void 0);
+__decorate([
+    LayoutRegistry
+], LayoutWrapper.prototype, "layoutRegistry", void 0);
+LayoutWrapper = __decorate([
+    customElement({
+        name,
+        template,
+    })
+], LayoutWrapper);
+export { LayoutWrapper };

package/dist/esm/workspace/layout-wrapper/layout-wrapper.template.js

@@ -0,0 +1,4 @@
+import { html } from '@microsoft/fast-element';
+export const LayoutWrapperTemplate = html `
+  <slot></slot>
+`;

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

@@ -0,0 +1,193 @@
+import { __awaiter, __decorate, __param } from "tslib";
+import { Auth, KVStorage, } from '@genesislcap/foundation-comms';
+import { DI } from '@microsoft/fast-foundation';
+/**
+ * Default workspace persistence implementation backed by KVStorage.
+ *
+ * @alpha
+ */
+let DefaultWorkspaceState = class DefaultWorkspaceState {
+    constructor(kvStorage, auth) {
+        this.kvStorage = kvStorage;
+        this.auth = auth;
+        this.STORAGE_PREFIX = 'workspace_';
+        this.WORKSPACES_LIST_KEY = 'workspaces_list';
+        this.currentWorkspace = null;
+    }
+    getCurrentUsername() {
+        var _a, _b;
+        return ((_b = (_a = this.auth) === null || _a === void 0 ? void 0 : _a.loggedUserResult) === null || _b === void 0 ? void 0 : _b.username) || 'anonymous';
+    }
+    getWorkspaceStorageKey(workspaceName) {
+        const username = this.getCurrentUsername();
+        return `${this.STORAGE_PREFIX}${username}_${workspaceName}`;
+    }
+    getWorkspacesListKey() {
+        const username = this.getCurrentUsername();
+        return `${this.STORAGE_PREFIX}${username}_${this.WORKSPACES_LIST_KEY}`;
+    }
+    saveWorkspace(workspaceName, layouts, grids, filters, description) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storageKey = this.getWorkspaceStorageKey(workspaceName);
+            const username = this.getCurrentUsername();
+            const workspace = {
+                name: workspaceName,
+                username,
+                description: (description === null || description === void 0 ? void 0 : description.trim()) || undefined,
+                layouts,
+                grids,
+                filters,
+                savedAt: new Date().toISOString(),
+            };
+            yield this.kvStorage.put([
+                {
+                    key: storageKey,
+                    value: JSON.stringify(workspace),
+                },
+            ]);
+            yield this.updateWorkspacesList(workspaceName);
+        });
+    }
+    loadWorkspace(workspaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workspace = yield this.getWorkspace(workspaceName);
+            this.currentWorkspace = workspace !== null && workspace !== void 0 ? workspace : null;
+            return this.currentWorkspace;
+        });
+    }
+    getWorkspace(workspaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const storageKey = this.getWorkspaceStorageKey(workspaceName);
+            const existing = yield this.kvStorage.get(storageKey);
+            if (!((_a = existing === null || existing === void 0 ? void 0 : existing.kv) === null || _a === void 0 ? void 0 : _a.value)) {
+                return null;
+            }
+            try {
+                const workspace = typeof existing.kv.value === 'string' ? JSON.parse(existing.kv.value) : existing.kv.value;
+                const currentUsername = this.getCurrentUsername();
+                if (workspace.username && workspace.username !== currentUsername) {
+                    console.warn(`Workspace ${workspaceName} does not belong to current user`);
+                    return null;
+                }
+                if (!workspace.username) {
+                    workspace.username = currentUsername;
+                }
+                return workspace || null;
+            }
+            catch (e) {
+                console.warn('Failed to parse saved workspace', e);
+                return null;
+            }
+        });
+    }
+    getCurrentWorkspace() {
+        return this.currentWorkspace;
+    }
+    setCurrentWorkspace(workspace) {
+        this.currentWorkspace = workspace;
+    }
+    getSavedWorkspaces() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const listKey = this.getWorkspaceStorageKey(this.WORKSPACES_LIST_KEY);
+            const existing = yield this.kvStorage.get(listKey);
+            if (!((_a = existing === null || existing === void 0 ? void 0 : existing.kv) === null || _a === void 0 ? void 0 : _a.value)) {
+                return [];
+            }
+            try {
+                const workspaceNames = typeof existing.kv.value === 'string' ? JSON.parse(existing.kv.value) : existing.kv.value;
+                if (!Array.isArray(workspaceNames)) {
+                    return [];
+                }
+                const workspaces = [];
+                const currentUsername = this.getCurrentUsername();
+                for (const name of workspaceNames) {
+                    // eslint-disable-next-line no-await-in-loop
+                    const workspace = yield this.getWorkspace(name);
+                    if (workspace && (!workspace.username || workspace.username === currentUsername)) {
+                        workspaces.push(workspace);
+                    }
+                }
+                return workspaces;
+            }
+            catch (e) {
+                console.warn('Failed to parse saved workspaces list', e);
+                return [];
+            }
+        });
+    }
+    deleteWorkspace(workspaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storageKey = this.getWorkspaceStorageKey(workspaceName);
+            yield this.kvStorage.delete([storageKey]);
+            yield this.removeFromWorkspacesList(workspaceName);
+        });
+    }
+    updateWorkspacesList(workspaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const listKey = this.getWorkspacesListKey();
+            const existing = yield this.kvStorage.get(listKey);
+            let workspaceNames = [];
+            if ((_a = existing === null || existing === void 0 ? void 0 : existing.kv) === null || _a === void 0 ? void 0 : _a.value) {
+                try {
+                    workspaceNames =
+                        typeof existing.kv.value === 'string' ? JSON.parse(existing.kv.value) : existing.kv.value;
+                }
+                catch (e) {
+                    console.warn('Failed to parse workspaces list', e);
+                }
+            }
+            workspaceNames = workspaceNames.filter((name) => name !== workspaceName);
+            workspaceNames.push(workspaceName);
+            yield this.kvStorage.put([
+                {
+                    key: listKey,
+                    value: JSON.stringify(workspaceNames),
+                },
+            ]);
+        });
+    }
+    removeFromWorkspacesList(workspaceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const listKey = this.getWorkspacesListKey();
+            const existing = yield this.kvStorage.get(listKey);
+            if (!((_a = existing === null || existing === void 0 ? void 0 : existing.kv) === null || _a === void 0 ? void 0 : _a.value)) {
+                return;
+            }
+            let workspaceNames = [];
+            try {
+                workspaceNames =
+                    typeof existing.kv.value === 'string' ? JSON.parse(existing.kv.value) : existing.kv.value;
+            }
+            catch (e) {
+                console.warn('Failed to parse workspaces list for deletion', e);
+                return;
+            }
+            workspaceNames = workspaceNames.filter((name) => name !== workspaceName);
+            if (workspaceNames.length === 0) {
+                yield this.kvStorage.delete([listKey]);
+            }
+            else {
+                yield this.kvStorage.put([
+                    {
+                        key: listKey,
+                        value: JSON.stringify(workspaceNames),
+                    },
+                ]);
+            }
+        });
+    }
+};
+DefaultWorkspaceState = __decorate([
+    __param(0, KVStorage),
+    __param(1, Auth)
+], DefaultWorkspaceState);
+export { DefaultWorkspaceState };
+/**
+ * DI token for workspace state.
+ * @alpha
+ */
+export const WorkspaceState = DI.createInterface((x) => x.singleton(DefaultWorkspaceState));

package/dist/esm/workspace/workspace-state.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/workspace/workspace.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/workspace-components.js

@@ -0,0 +1,43 @@
+// Import the custom elements so their `@customElement` decorators run and define tags.
+import { LayoutWrapper, GridRegister } from './workspace';
+import { WorkspaceManager } from './workspace-manager';
+/**
+ * Registration object for workspace-related components.
+ *
+ * Mirrors the shape of `rapidGridComponents` so it can be passed into
+ * `provideDesignSystem().register(...)` without additional glue code.
+ *
+ * @alpha
+ */
+export const workspaceComponents = {
+    workspaceManager: () => ({
+        register(_container, ..._rest) {
+            // Custom elements are defined by decorators at module import time.
+            void WorkspaceManager;
+        },
+    }),
+    layoutWrapper: () => ({
+        register(_container, ..._rest) {
+            void LayoutWrapper;
+        },
+    }),
+    gridRegister: () => ({
+        register(_container, ..._rest) {
+            void GridRegister;
+        },
+    }),
+    register(container, ...rest) {
+        if (!container) {
+            // Preserve backward compatibility with callers that iterate keys.
+            return;
+        }
+        for (const key in this) {
+            if (key === 'register') {
+                continue;
+            }
+            // The values of this object are functions that return a component
+            // registration object with a `.register(...)` method.
+            this[key]().register(container, ...rest);
+        }
+    },
+};

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

@@ -0,0 +1 @@
+export * from './workspace-manager';