@topconsultnpm/sdkui-react-beta 6.13.48 → 6.13.50

package/lib/components/layout/panelManager/utils.d.ts

@@ -0,0 +1,21 @@
+import { TMPanelDefinition, TMPanelDimensionsMap, TMPanelHierarchyMap } from "./types";
+export declare const flattenPanels: (panels: Array<TMPanelDefinition>) => Array<TMPanelDefinition>;
+export declare function getToolbarStates(panels: Array<TMPanelDefinition>): {
+    visibilityMap: {
+        [id: string]: boolean;
+    };
+    disabledMap: {
+        [id: string]: boolean;
+    };
+};
+export declare const generatePanelHierarchyMap: (panels: Array<TMPanelDefinition>) => TMPanelHierarchyMap;
+export declare const showParentRecursively: (panelId: string, hierarchyMap: TMPanelHierarchyMap) => Array<[string, boolean]>;
+export declare const hideParentRecursively: (panelId: string, hierarchyMap: TMPanelHierarchyMap, currentVisibility: {
+    [id: string]: boolean;
+}) => Array<[string, boolean]>;
+export declare const redistributeDimensionsOnHide: (hiddenPanelId: string, currentDimensions: TMPanelDimensionsMap, hierarchyMap: TMPanelHierarchyMap, panelVisibility: {
+    [id: string]: boolean;
+}) => TMPanelDimensionsMap;
+export declare const redistributeDimensionsOnShow: (shownPanelId: string, currentDimensions: TMPanelDimensionsMap, initialDimensions: TMPanelDimensionsMap, hierarchyMap: TMPanelHierarchyMap, panelVisibility: {
+    [id: string]: boolean;
+}) => TMPanelDimensionsMap;

package/lib/components/layout/panelManager/utils.js

@@ -0,0 +1,208 @@
+// Recursive function to flatten the panel hierarchy into a single array (includes children)
+export const flattenPanels = (panels) => {
+    return panels.reduce((acc, panel) => {
+        // Add the current panel
+        acc.push(panel);
+        // Recursively add all child panels
+        if (panel.children && panel.children.length > 0) {
+            acc.push(...flattenPanels(panel.children));
+        }
+        return acc;
+    }, []);
+};
+// Recursive helper to traverse panels and children, accumulating visibility and disabled states
+// Recursive function that returns visibility and disabled maps for panels and all children
+export function getToolbarStates(panels) {
+    let visibilityMap = {};
+    let disabledMap = {};
+    panels.forEach(panel => {
+        if (panel.toolbarOptions?.visible !== undefined) {
+            visibilityMap[panel.id] = panel.toolbarOptions.visible;
+            disabledMap[panel.id] = panel.toolbarOptions.disabled ?? false;
+        }
+        if (panel.children && panel.children.length > 0) {
+            const childStates = getToolbarStates(panel.children);
+            visibilityMap = { ...visibilityMap, ...childStates.visibilityMap };
+            disabledMap = { ...disabledMap, ...childStates.disabledMap };
+        }
+    });
+    return { visibilityMap, disabledMap };
+}
+export const generatePanelHierarchyMap = (panels) => {
+    const hierarchyMap = new Map();
+    const traverse = (node, parentId, siblings = []) => {
+        const children = node.children || [];
+        const info = {
+            parentId: parentId,
+            childrenIds: children.map(child => child.id),
+            siblingIds: siblings.filter(s => s.id !== node.id).map(s => s.id),
+            groupDirection: node.currentGroupDirection ?? 'horizontal',
+        };
+        hierarchyMap.set(node.id, info);
+        for (const child of children) {
+            traverse(child, node.id, children);
+        }
+    };
+    for (const panel of panels) {
+        traverse(panel, undefined, panels);
+    }
+    return hierarchyMap;
+};
+export const showParentRecursively = (panelId, hierarchyMap) => {
+    const result = [];
+    const visit = (id) => {
+        const panelInfo = hierarchyMap.get(id);
+        if (!panelInfo)
+            return;
+        if (panelInfo.parentId) {
+            if (!result.some(([pid]) => pid === panelInfo.parentId)) {
+                result.push([panelInfo.parentId, true]);
+                visit(panelInfo.parentId);
+            }
+        }
+    };
+    visit(panelId);
+    return result;
+};
+export const hideParentRecursively = (panelId, hierarchyMap, currentVisibility) => {
+    const result = [];
+    const visit = (id) => {
+        const panelInfo = hierarchyMap.get(id);
+        if (!panelInfo)
+            return;
+        if (panelInfo.parentId) {
+            const parentInfo = hierarchyMap.get(panelInfo.parentId);
+            if (!parentInfo)
+                return;
+            const visibleChildren = parentInfo.childrenIds.filter(childId => childId !== id && currentVisibility[childId]);
+            if (visibleChildren.length === 0) {
+                if (!result.some(([pid]) => pid === panelInfo.parentId)) {
+                    result.push([panelInfo.parentId, false]);
+                    visit(panelInfo.parentId);
+                }
+            }
+        }
+    };
+    visit(panelId);
+    return result;
+};
+export const redistributeDimensionsOnHide = (hiddenPanelId, currentDimensions, hierarchyMap, panelVisibility) => {
+    const parentId = hierarchyMap.get(hiddenPanelId)?.parentId;
+    const siblings = hierarchyMap.get(hiddenPanelId)?.siblingIds || [];
+    if (siblings.length === 0)
+        return currentDimensions;
+    const hiddenDims = currentDimensions[hiddenPanelId];
+    if (!hiddenDims)
+        return currentDimensions;
+    const hiddenWidthNum = parseFloat(hiddenDims.width);
+    const hiddenHeightNum = parseFloat(hiddenDims.height);
+    const visibleSiblings = siblings.filter(siblingId => panelVisibility[siblingId]);
+    const widthIncrement = hiddenWidthNum / visibleSiblings.length;
+    const heightIncrement = hiddenHeightNum / visibleSiblings.length;
+    let newDimensions = { ...currentDimensions };
+    visibleSiblings.forEach(siblingId => {
+        const siblingDims = newDimensions[siblingId] || { width: '0%', height: '0%' };
+        const siblingWidthNum = parseFloat(siblingDims.width) || 0;
+        const siblingHeightNum = parseFloat(siblingDims.height) || 0;
+        const newWidthNum = Math.min(siblingWidthNum + widthIncrement, 100);
+        const newHeightNum = Math.min(siblingHeightNum + heightIncrement, 100);
+        newDimensions[siblingId] = { width: `${newWidthNum}%`, height: `${newHeightNum}%` };
+    });
+    newDimensions[hiddenPanelId] = { width: '0%', height: '0%' };
+    // Ora controllo se il parent non ha più figli visibili e chiamo ricorsivamente
+    if (parentId) {
+        const parentInfo = hierarchyMap.get(parentId);
+        if (parentInfo) {
+            const visibleSiblings = parentInfo.childrenIds.filter(childId => childId !== hiddenPanelId && panelVisibility[childId]);
+            // Se non ci sono figli visibili rimanenti, chiamo ricorsivamente sul parent
+            if (visibleSiblings.length === 0) {
+                newDimensions = redistributeDimensionsOnHide(parentId, newDimensions, hierarchyMap, panelVisibility);
+            }
+        }
+    }
+    return newDimensions;
+};
+export const redistributeDimensionsOnShow = (shownPanelId, currentDimensions, initialDimensions, hierarchyMap, panelVisibility) => {
+    let updatedDimensions = { ...currentDimensions };
+    const redistribute = (panelId) => {
+        const panel = hierarchyMap.get(panelId);
+        if (!panel)
+            return;
+        const parentId = panel.parentId;
+        if (!parentId) {
+            // Caso root (senza parent)
+            const siblingIds = panel.siblingIds || [];
+            const visibleSiblings = siblingIds.filter(sibId => panelVisibility[sibId]);
+            const allVisible = [panelId, ...visibleSiblings];
+            if (panel.groupDirection === 'horizontal') {
+                const totalInitialWidth = allVisible.reduce((sum, id) => {
+                    const w = parseFloat(initialDimensions[id]?.width || '0');
+                    return sum + w;
+                }, 0);
+                allVisible.forEach(id => {
+                    const w = parseFloat(initialDimensions[id]?.width || '0');
+                    const proportionalWidth = (w / totalInitialWidth) * 100;
+                    updatedDimensions[id] = {
+                        width: `${proportionalWidth}%`,
+                        height: '100%'
+                    };
+                });
+            }
+            else {
+                // vertical
+                const totalInitialHeight = allVisible.reduce((sum, id) => {
+                    const h = parseFloat(initialDimensions[id]?.height || '0');
+                    return sum + h;
+                }, 0);
+                allVisible.forEach(id => {
+                    const h = parseFloat(initialDimensions[id]?.height || '0');
+                    const proportionalHeight = (h / totalInitialHeight) * 100;
+                    updatedDimensions[id] = {
+                        width: '100%',
+                        height: `${proportionalHeight}%`
+                    };
+                });
+            }
+        }
+        else {
+            const siblingIds = panel.siblingIds || [];
+            const visibleSiblings = siblingIds.filter(sibId => panelVisibility[sibId]);
+            const allVisible = [panelId, ...visibleSiblings];
+            if (panel.groupDirection === 'horizontal') {
+                const totalInitialWidth = allVisible.reduce((sum, id) => {
+                    const w = parseFloat(initialDimensions[id]?.width || '0');
+                    return sum + w;
+                }, 0);
+                allVisible.forEach(id => {
+                    const w = parseFloat(initialDimensions[id]?.width || '0');
+                    const proportionalWidth = (w / totalInitialWidth) * 100;
+                    updatedDimensions[id] = {
+                        width: `${proportionalWidth}%`,
+                        height: '100%'
+                    };
+                });
+            }
+            else {
+                // vertical
+                const totalInitialHeight = allVisible.reduce((sum, id) => {
+                    const h = parseFloat(initialDimensions[id]?.height || '0');
+                    return sum + h;
+                }, 0);
+                allVisible.forEach(id => {
+                    const h = parseFloat(initialDimensions[id]?.height || '0');
+                    const proportionalHeight = (h / totalInitialHeight) * 100;
+                    updatedDimensions[id] = {
+                        width: '100%',
+                        height: `${proportionalHeight}%`
+                    };
+                });
+            }
+            // Chiamo ricorsivamente sul parent corretto (non sempre shownPanelId)
+            const parent = hierarchyMap.get(panelId)?.parentId;
+            if (parent)
+                redistribute(parent);
+        }
+    };
+    redistribute(shownPanelId);
+    return updatedDimensions;
+};

package/lib/helper/SDKUI_Globals.js

@@ -1,5 +1,6 @@
 import { InvoiceRetrieveFormats, LocalStorageService, OrderRetrieveFormats } from "@topconsultnpm/sdk-ts-beta";
 import { FontSize, Gutters } from "../utils/theme";
+// import { LandingPages } from "./helpers";
 export const dcmtsFileCacheDownload = new Map();
 export const dcmtsFileCachePreview = new Map();
 export const CACHE_SIZE_LIMIT = 10;
@@ -9,7 +10,7 @@ export const isDcmtFileInCache = (key) => dcmtsFileCachePreview.has(key);
 export class UserSettings {
     constructor() {
         this.archiveID = undefined;
-        this.landingPage = '';
+        this.landingPage = 'dashboard'; // TODO: se usiamo LandingPages errore sulle dipendenze.
         this.userID = undefined;
         this.advancedSettings = new AdvancedSettings();
         this.archivingSettings = new ArchivingSettings();

package/lib/helper/helpers.d.ts

@@ -40,7 +40,7 @@ export declare function isPositiveNumber(val: unknown): val is number;
 export declare function sleep(ms: number): Promise<void>;
 export declare const dialogConfirmOperation: (title: string, msg: string, operationAsync: () => Promise<void>) => void;
 export declare enum LandingPages {
-    HOME_PAGE = "homepage",
+    DASHBOARD = "dashboard",
     SEARCH = "search",
     ARCHIVE = "archive",
     WORKING_GROUPS = "workingGroups",

package/lib/helper/helpers.js

@@ -660,7 +660,7 @@ export const dialogConfirmOperation = (title, msg, operationAsync) => {
 };
 export var LandingPages;
 (function (LandingPages) {
-    LandingPages["HOME_PAGE"] = "homepage";
+    LandingPages["DASHBOARD"] = "dashboard";
     LandingPages["SEARCH"] = "search";
     LandingPages["ARCHIVE"] = "archive";
     LandingPages["WORKING_GROUPS"] = "workingGroups";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@topconsultnpm/sdkui-react-beta",
-    "version": "6.13.48",
+    "version": "6.13.50",
     "description": "",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1",