@esfaenza/extensions 15.2.48 → 15.2.51

package/esm2020/lib/services/extensions.embedding.service.mjs

@@ -0,0 +1,248 @@
+// Angular
+import { Injectable } from "@angular/core";
+// Libraries
+import { Subject, filter } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "./extensions.messages.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+/* Classe che contiene tutte le informazioni sull'embedding in un unico contenitore per semplicità */
+export class AppEmbeddingExtensions {
+    constructor(msgService, router, location) {
+        this.msgService = msgService;
+        this.router = router;
+        this.location = location;
+        this.sidebarWidth = 230;
+        this.Embedded = false;
+        this.EmbeddingLevel = 0;
+        this.MessageObserver = new Subject();
+        this._reloadAllowed = true;
+        this.pushedHistories = [];
+        this.MessageBarrierDebouncMs = 250;
+        this.OnMessageCallBarrier = {};
+        this.MainWindow = window;
+        while (this.MainWindow.parent != this.MainWindow) {
+            this.MainWindow = this.MainWindow.parent;
+            this.EmbeddingLevel++;
+            this.Embedded = true;
+            // Fallback per farlo funzionare forzatamente mentre lo testo
+            this.EmbeddedModule = this.location.path().match(/module=([a-zA-Z_]+)/)?.[1];
+            if (!this.EmbeddedModule)
+                this.waitForMyConfigAndForceEmbeddedModule();
+        }
+        this.configureEmbeddability();
+        if (this.Embedded)
+            this.msgService.configureEmbeddability(this.MainWindow, this.MessageObserver);
+        this.MessageObserver.pipe(filter(ev => ev.event == "menu-navigation")).subscribe(event => {
+            // Mi interessa solo roba relativa all'embedding
+            if (!event.data.routerLink.startsWith("embed"))
+                return;
+            // emb/crm/parties/parties_search?blabla --> parties/parties_search
+            let normalizedRequestedRoute = event.data.routerLink.split("?")[0].split("/").slice(2).join("/");
+            ///pages_ext/parties/parties_search?blabla --> parties/parties_search
+            let normalizedFirstRoute = this.pushedHistories.length > 0 ? this.pushedHistories[0].from.split("?")[0].split("/").slice(2).join("/") : "";
+            // La route su cui sto navigando ora è uguale alla route in cui l'embedding è iniziato. 
+            // Significa che devo simulare dei back fino a che non sono arrivato all'inizio
+            if (normalizedRequestedRoute == normalizedFirstRoute) {
+                this.router.navigate(["pages/" + event.data.routerLink, { wakeup: 1 }], { queryParams: event.data.queryParams, onSameUrlNavigation: "reload" });
+                this.pushedHistories = [];
+            }
+        });
+    }
+    waitForMyConfigAndForceEmbeddedModule() {
+        // Aspetto di ricevere il myconfig e setto con lui l'embeddedmodule. Questo viene eseguito solo se this.location.path() per qualche motivo non contiene il module
+        let interval = setInterval(() => {
+            if (myconfig?.AppData?.ModuleId) {
+                this.EmbeddedModule = myconfig.AppData.ModuleId;
+                clearInterval(interval);
+            }
+        }, 250);
+    }
+    IsReloadAllowed() {
+        let ret = this._reloadAllowed;
+        this._reloadAllowed = true;
+        return ret;
+    }
+    messageHash(event) {
+        return `${JSON.parse(JSON.stringify(event?.data))}`;
+    }
+    configureEmbeddability() {
+        window.onmessage = (event) => {
+            // Ignoro i miei messaggi dato che mi interessano solo quelli degli altri iframe
+            if (event.source == window && event?.data?.type != "modal-open")
+                return;
+            // Posso gestire lo stesso identico messaggio solo 1 volta ogni MessageBarrierDebouncMs
+            let messageHash = this.messageHash(event);
+            if (this.OnMessageCallBarrier[messageHash])
+                return;
+            else {
+                this.OnMessageCallBarrier[messageHash] = true;
+                setTimeout(() => delete this.OnMessageCallBarrier[messageHash], this.MessageBarrierDebouncMs);
+            }
+            this.MessageObserver.next({ event: "window-message", data: event?.data });
+            if (event?.data?.type == "alert") {
+                console.log(`Window message - alert -> Level: ${event?.data?.level}, Message: ${event?.data?.msg}`);
+                switch (event?.data?.level) {
+                    case "success":
+                        this.msgService.simpleSuccess(event?.data?.msg);
+                        break;
+                    case "warning":
+                        this.msgService.simpleWarning(event?.data?.msg);
+                        break;
+                    case "error":
+                        this.msgService.simpleError(event?.data?.msg);
+                        break;
+                    case "info":
+                        this.msgService.simpleInfo(event?.data?.msg);
+                        break;
+                }
+            }
+            else if (event?.data?.type == "replace-state") {
+                console.log(`Window message - replace-state -> Url: ${event?.data?.url}`);
+                this.location.replaceState(event?.data?.url);
+            }
+            else if (event?.data?.type == "confirm") {
+                console.log(`Window message - confirm -> Level: ${event?.data?.level}, Message: ${event?.data?.text}, Title: ${event?.data?.title}, ID: ${event?.data?.guid}`);
+                var sourceWindow = event.source;
+                var baseResponse = { type: "confirm-response", guid: event?.data?.guid };
+                switch (event?.data?.level) {
+                    case "success":
+                        this.msgService.simpleSuccessWithChoice(event?.data?.title, event?.data?.text, () => {
+                            sourceWindow.postMessage({ result: true, ...baseResponse }, "*");
+                        }, () => {
+                            sourceWindow.postMessage({ result: false, ...baseResponse }, "*");
+                        });
+                        break;
+                    case "warning":
+                        this.msgService.simpleWarningWithChoice(event?.data?.title, event?.data?.text, () => {
+                            sourceWindow.postMessage({ result: true, ...baseResponse }, "*");
+                        }, () => {
+                            sourceWindow.postMessage({ result: false, ...baseResponse }, "*");
+                        });
+                        break;
+                }
+            }
+            else if (event?.data?.type == "navigate") {
+                console.log(`Window message - navigate -> ${event?.data?.url}`);
+                var newTab = event?.data?.newTab;
+                var replaceState = event?.data?.replaceState;
+                var current = event?.data?.current;
+                // Controllo se il router sta seguendo la chiamata attuale. Escludo i query params che sono gli unici che possono essere seccati dai replaceState
+                // e che potrebbero fare del casino
+                if (!window.location.href.includes(this.router.url.split("?")[0])) {
+                    console.warn("Doppia chiamata di navigazione, ignoro il secondo evento scoordinato dal router");
+                    return;
+                }
+                let newRelativeUrl = this.router.createUrlTree([event?.data?.url]);
+                let baseUrl = window.location.href.replace(this.router.url.replace("?ignoreStorage=true", ''), '');
+                let newUrl = baseUrl + decodeURIComponent(newRelativeUrl.toString());
+                if (replaceState) {
+                    this.pushedHistories.push({ _pushed: true, url: newUrl, from: current });
+                    history.pushState({ _pushed: true }, "", newUrl);
+                }
+                else if (newTab)
+                    window.open(newUrl, '_blank');
+            }
+            else if (event?.data?.type == "navigate-back") {
+                console.log(`Window message - navigate-back -> ${event?.data?.url}`);
+                this.onNavigateBack();
+            }
+            else if (event?.data?.type == "redirect") {
+                console.log(`Window message - redirect -> ${event?.data?.url}`);
+                window.location.href = event?.data?.url;
+            }
+            else if (event?.data?.type == "navigation") {
+                console.log(`Window message - Navigation -> ${event?.data?.internalNavigation ? "[internal]" : ""} ${event?.data?.title}`);
+                this.MessageObserver.next({ event: "navigation", data: event?.data });
+            }
+            else if (event?.data?.type == "modal-open") {
+                const wrapper = document.body.getElementsByClassName("main-wrapper")[0];
+                let wrapperStyles = window.getComputedStyle(wrapper);
+                const wrapperPaddingLeft = parseInt(wrapperStyles.getPropertyValue("padding-left"));
+                const wrapperPaddingRight = parseInt(wrapperStyles.getPropertyValue("padding-right"));
+                console.log(`Window message - Modal Open -> Backdrop Height: ${event?.data?.backdropHeight}`);
+                var bottomLeftover = 7; // Valore fisso... robina che rimane di sotto per un motivo o quell'altro
+                var topHeight = 86; // valore fisso, distanza fra il top e l'inizio dell'iframe, non sarà mai diverso
+                var rightSpace = wrapperPaddingRight; // valore fisso, distanza fra la fine dell'iframe e il lato sinistro dello schermo, non sarà mai diverso
+                var leftSpace = this.sidebarWidth + wrapperPaddingLeft;
+                let commonStyles = "position: absolute; z-index: 9999; background-color: #000; opacity: 0.5; ";
+                wrapper.style.setProperty("overflow", "hidden", "important");
+                const top = document.createElement("div");
+                top.className = "embedded-modal-top";
+                top.style.cssText = commonStyles + `height: ${topHeight}px; top: 0; width: calc(100% - ${leftSpace}px); left: ${leftSpace}px`;
+                top.id = "top";
+                const left = document.createElement("div");
+                left.className = "embedded-modal-left";
+                left.style.cssText = commonStyles + `height: 100%; top: 0; width: ${leftSpace}px;`;
+                left.id = "left";
+                const right = document.createElement("div");
+                right.className = "embedded-modal-right";
+                right.style.cssText = commonStyles + `height: calc(100% - ${topHeight}px); top: ${topHeight}px; right: 0; width: ${rightSpace}px;`;
+                right.id = "right";
+                const bottom = document.createElement("div");
+                bottom.className = "embedded-modal-bottom";
+                bottom.style.cssText = commonStyles + `height: ${bottomLeftover}px; bottom: 0; width: calc(100% - ${leftSpace + rightSpace}px); left: ${leftSpace}px`;
+                bottom.id = "bottom";
+                document.body.appendChild(top);
+                document.body.appendChild(left);
+                document.body.appendChild(right);
+                document.body.appendChild(bottom);
+            }
+            else if (event?.data?.type == "modal-close") {
+                console.log(`Window message - Modal Close`);
+                let wrapper = document.body.getElementsByClassName("main-wrapper")[0];
+                wrapper.style.removeProperty("overflow");
+                const top = document.getElementById("top");
+                const left = document.getElementById("left");
+                const right = document.getElementById("right");
+                const bottom = document.getElementById("bottom");
+                if (top)
+                    document.body.removeChild(top);
+                if (left)
+                    document.body.removeChild(left);
+                if (right)
+                    document.body.removeChild(right);
+                if (bottom)
+                    document.body.removeChild(bottom);
+            }
+        };
+        if (this.Embedded)
+            document.body.style.setProperty("overflow-y", "auto", "important");
+    }
+    onNavigateBack() {
+        if (history?.state?._pushed) {
+            this._reloadAllowed = false;
+            this.pushedHistories.pop();
+            history.back();
+        }
+    }
+    replaceState(basePath, url) {
+        // Esempio basePath: pages
+        // Esempio url: parties/leads_search
+        // Normalizzazione senza slash prima o dopo
+        basePath = basePath.endsWith("/") ? basePath.substring(0, basePath.length - 2) : basePath;
+        url = url.startsWith("/") ? url.substring(1) : url;
+        this.location.replaceState(`${basePath}/${url}`);
+        this.MainWindow.postMessage({ type: "replace-state", url: `pages/embed/${this.EmbeddedModule}/${url}` }, "*");
+    }
+    refreshBoundariesOnMenuCollapse() {
+        const wrapper = document.body.getElementsByClassName("main-wrapper")[0];
+        let wrapperStyles = window.getComputedStyle(wrapper);
+        const wrapperPaddingLeft = parseInt(wrapperStyles.getPropertyValue("padding-left"));
+        var leftSpace = 230 + wrapperPaddingLeft;
+        const left = document.getElementById("left");
+        const top = document.getElementById("top");
+        if (top) {
+            top.style.setProperty("left", (leftSpace) + "px");
+            top.style.setProperty("width", `calc(100% - ${leftSpace}px)`);
+        }
+        if (left)
+            left.style.setProperty("width", leftSpace + "px");
+    }
+}
+AppEmbeddingExtensions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AppEmbeddingExtensions, deps: [{ token: i1.MessageService }, { token: i2.Router }, { token: i3.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+AppEmbeddingExtensions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AppEmbeddingExtensions });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AppEmbeddingExtensions, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MessageService }, { type: i2.Router }, { type: i3.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extensions.embedding.service.js","sourceRoot":"","sources":["../../../../../projects/extensions/src/lib/services/extensions.embedding.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable } from \"@angular/core\";\r\nimport { Location } from \"@angular/common\";\r\nimport { Router } from \"@angular/router\";\r\n\r\n// Services\r\nimport { MessageService } from \"./extensions.messages.service\";\r\n\r\n// Libraries\r\nimport { Subject, filter } from \"rxjs\";\r\n\r\ndeclare var myconfig: { AppData: { ModuleId: string }; };\r\n\r\n/* Classe che contiene tutte le informazioni sull'embedding in un unico contenitore per semplicità */\r\n@Injectable()\r\nexport class AppEmbeddingExtensions {\r\n\r\n    public sidebarWidth: number = 230;\r\n\r\n    public Embedded: boolean = false;\r\n    public EmbeddingLevel: number = 0;\r\n    public MainWindow: any;\r\n\r\n    public MessageObserver: Subject<{ event: any, data: any }> = new Subject<{ event: any, data: any }>();\r\n\r\n    private _reloadAllowed: boolean = true;\r\n\r\n    public EmbeddedModule: string;\r\n\r\n    private pushedHistories: { _pushed: boolean, url: string, from: string }[] = [];\r\n\r\n    constructor(private msgService: MessageService, private router: Router, private location: Location) {\r\n        this.MainWindow = <{ parent: any, postMessage: Function }>window;\r\n        while (this.MainWindow.parent != this.MainWindow) {\r\n            this.MainWindow = this.MainWindow.parent;\r\n            this.EmbeddingLevel++;\r\n            this.Embedded = true;\r\n\r\n            // Fallback per farlo funzionare forzatamente mentre lo testo\r\n            this.EmbeddedModule = this.location.path().match(/module=([a-zA-Z_]+)/)?.[1];\r\n\r\n            if(!this.EmbeddedModule)\r\n                this.waitForMyConfigAndForceEmbeddedModule();\r\n        }\r\n\r\n        this.configureEmbeddability();\r\n\r\n        if (this.Embedded)\r\n            this.msgService.configureEmbeddability(this.MainWindow, this.MessageObserver);\r\n\r\n        this.MessageObserver.pipe(filter(ev => ev.event == \"menu-navigation\")).subscribe(event => {\r\n\r\n            // Mi interessa solo roba relativa all'embedding\r\n            if (!event.data.routerLink.startsWith(\"embed\"))\r\n                return;\r\n\r\n            // emb/crm/parties/parties_search?blabla --> parties/parties_search\r\n            let normalizedRequestedRoute = event.data.routerLink.split(\"?\")[0].split(\"/\").slice(2).join(\"/\");\r\n            ///pages_ext/parties/parties_search?blabla --> parties/parties_search\r\n            let normalizedFirstRoute = this.pushedHistories.length > 0 ? this.pushedHistories[0].from.split(\"?\")[0].split(\"/\").slice(2).join(\"/\") : \"\";\r\n            // La route su cui sto navigando ora è uguale alla route in cui l'embedding è iniziato. \r\n            // Significa che devo simulare dei back fino a che non sono arrivato all'inizio\r\n            if (normalizedRequestedRoute == normalizedFirstRoute) {\r\n                this.router.navigate([\"pages/\" + event.data.routerLink, {wakeup: 1}], { queryParams: event.data.queryParams, onSameUrlNavigation: \"reload\" });\r\n                this.pushedHistories = [];\r\n            }\r\n        });\r\n    }\r\n\r\n    private waitForMyConfigAndForceEmbeddedModule() {\r\n\r\n        // Aspetto di ricevere il myconfig e setto con lui l'embeddedmodule. Questo viene eseguito solo se this.location.path() per qualche motivo non contiene il module\r\n        let interval = setInterval(() => {\r\n            if (myconfig?.AppData?.ModuleId) {\r\n                this.EmbeddedModule = myconfig.AppData.ModuleId;\r\n                clearInterval(interval);\r\n            }\r\n        }, 250);\r\n    }\r\n\r\n    public IsReloadAllowed() {\r\n        let ret = this._reloadAllowed;\r\n        this._reloadAllowed = true;\r\n        return ret;\r\n    }\r\n\r\n    private MessageBarrierDebouncMs: number = 250;\r\n    private OnMessageCallBarrier: { [id: string]: boolean } = {}\r\n    private messageHash(event: MessageEvent) {\r\n        return `${JSON.parse(JSON.stringify(event?.data))}`;\r\n    }\r\n\r\n    configureEmbeddability() {\r\n        window.onmessage = (event: MessageEvent) => {\r\n            // Ignoro i miei messaggi dato che mi interessano solo quelli degli altri iframe\r\n            if (event.source == window && event?.data?.type != \"modal-open\")\r\n                return;\r\n\r\n            // Posso gestire lo stesso identico messaggio solo 1 volta ogni MessageBarrierDebouncMs\r\n            let messageHash = this.messageHash(event);\r\n            if (this.OnMessageCallBarrier[messageHash])\r\n                return;\r\n            else {\r\n                this.OnMessageCallBarrier[messageHash] = true;\r\n                setTimeout(() => delete this.OnMessageCallBarrier[messageHash], this.MessageBarrierDebouncMs);\r\n            }\r\n\r\n            this.MessageObserver.next({ event: \"window-message\", data: event?.data });\r\n\r\n            if (event?.data?.type == \"alert\") {\r\n                console.log(`Window message - alert -> Level: ${event?.data?.level}, Message: ${event?.data?.msg}`);\r\n\r\n                switch (event?.data?.level) {\r\n                    case \"success\": this.msgService.simpleSuccess(event?.data?.msg); break;\r\n                    case \"warning\": this.msgService.simpleWarning(event?.data?.msg); break;\r\n                    case \"error\": this.msgService.simpleError(event?.data?.msg); break;\r\n                    case \"info\": this.msgService.simpleInfo(event?.data?.msg); break;\r\n                }\r\n            }\r\n            else if (event?.data?.type == \"replace-state\") {\r\n                console.log(`Window message - replace-state -> Url: ${event?.data?.url}`);\r\n\r\n                this.location.replaceState(event?.data?.url);\r\n            }\r\n            else if (event?.data?.type == \"confirm\") {\r\n                console.log(`Window message - confirm -> Level: ${event?.data?.level}, Message: ${event?.data?.text}, Title: ${event?.data?.title}, ID: ${event?.data?.guid}`);\r\n\r\n                var sourceWindow = (event.source as Window);\r\n                var baseResponse = { type: \"confirm-response\", guid: event?.data?.guid };\r\n\r\n                switch (event?.data?.level) {\r\n                    case \"success\":\r\n                        this.msgService.simpleSuccessWithChoice(event?.data?.title, event?.data?.text, () => {\r\n                            sourceWindow.postMessage({ result: true, ...baseResponse }, \"*\")\r\n                        }, () => {\r\n                            sourceWindow.postMessage({ result: false, ...baseResponse }, \"*\")\r\n                        });\r\n                        break;\r\n                    case \"warning\":\r\n                        this.msgService.simpleWarningWithChoice(event?.data?.title, event?.data?.text, () => {\r\n                            sourceWindow.postMessage({ result: true, ...baseResponse }, \"*\")\r\n                        }, () => {\r\n                            sourceWindow.postMessage({ result: false, ...baseResponse }, \"*\")\r\n                        });\r\n                        break;\r\n                }\r\n\r\n            }\r\n            else if (event?.data?.type == \"navigate\") {\r\n                console.log(`Window message - navigate -> ${event?.data?.url}`);\r\n                var newTab = event?.data?.newTab;\r\n                var replaceState = event?.data?.replaceState\r\n                var current = event?.data?.current;\r\n\r\n                // Controllo se il router sta seguendo la chiamata attuale. Escludo i query params che sono gli unici che possono essere seccati dai replaceState\r\n                // e che potrebbero fare del casino\r\n                if (!window.location.href.includes(this.router.url.split(\"?\")[0])) {\r\n                    console.warn(\"Doppia chiamata di navigazione, ignoro il secondo evento scoordinato dal router\");\r\n                    return;\r\n                }\r\n\r\n                let newRelativeUrl = this.router.createUrlTree([event?.data?.url]);\r\n                let baseUrl = window.location.href.replace(this.router.url.replace(\"?ignoreStorage=true\" , ''), '');\r\n                let newUrl = baseUrl + decodeURIComponent(newRelativeUrl.toString());\r\n\r\n                if (replaceState) {\r\n                    this.pushedHistories.push({ _pushed: true, url: newUrl, from: current });\r\n                    history.pushState({ _pushed: true }, \"\", newUrl);\r\n                }\r\n                else if (newTab)\r\n                    window.open(newUrl, '_blank');\r\n            }\r\n            else if (event?.data?.type == \"navigate-back\") {\r\n                console.log(`Window message - navigate-back -> ${event?.data?.url}`);\r\n                this.onNavigateBack();\r\n            }\r\n            else if (event?.data?.type == \"redirect\") {\r\n                console.log(`Window message - redirect -> ${event?.data?.url}`);\r\n\r\n                window.location.href = event?.data?.url;\r\n            }\r\n            else if (event?.data?.type == \"navigation\") {\r\n                console.log(`Window message - Navigation -> ${event?.data?.internalNavigation ? \"[internal]\" : \"\"} ${event?.data?.title}`);\r\n\r\n                this.MessageObserver.next({ event: \"navigation\", data: event?.data });\r\n            }\r\n            else if (event?.data?.type == \"modal-open\") {\r\n                const wrapper = document.body.getElementsByClassName(\"main-wrapper\")[0] as HTMLElement;\r\n                let wrapperStyles = window.getComputedStyle(wrapper);\r\n                const wrapperPaddingLeft = parseInt(wrapperStyles.getPropertyValue(\"padding-left\"));\r\n                const wrapperPaddingRight = parseInt(wrapperStyles.getPropertyValue(\"padding-right\"));\r\n\r\n                console.log(`Window message - Modal Open -> Backdrop Height: ${event?.data?.backdropHeight}`);\r\n\r\n                var bottomLeftover: number = 7; // Valore fisso... robina che rimane di sotto per un motivo o quell'altro\r\n                var topHeight: number = 86; // valore fisso, distanza fra il top e l'inizio dell'iframe, non sarà mai diverso\r\n                var rightSpace: number = wrapperPaddingRight; // valore fisso, distanza fra la fine dell'iframe e il lato sinistro dello schermo, non sarà mai diverso\r\n                var leftSpace: number = this.sidebarWidth + wrapperPaddingLeft;\r\n\r\n                let commonStyles = \"position: absolute; z-index: 9999; background-color: #000; opacity: 0.5; \";\r\n\r\n                wrapper.style.setProperty(\"overflow\", \"hidden\", \"important\");\r\n\r\n                const top = document.createElement(\"div\");\r\n                top.className = \"embedded-modal-top\";\r\n                top.style.cssText = commonStyles + `height: ${topHeight}px; top: 0; width: calc(100% - ${leftSpace}px); left: ${leftSpace}px`;\r\n                top.id = \"top\";\r\n\r\n                const left = document.createElement(\"div\");\r\n                left.className = \"embedded-modal-left\";\r\n                left.style.cssText = commonStyles + `height: 100%; top: 0; width: ${leftSpace}px;`;\r\n                left.id = \"left\";\r\n\r\n                const right = document.createElement(\"div\");\r\n                right.className = \"embedded-modal-right\";\r\n                right.style.cssText = commonStyles + `height: calc(100% - ${topHeight}px); top: ${topHeight}px; right: 0; width: ${rightSpace}px;`;\r\n                right.id = \"right\";\r\n\r\n                const bottom = document.createElement(\"div\");\r\n                bottom.className = \"embedded-modal-bottom\";\r\n                bottom.style.cssText = commonStyles + `height: ${bottomLeftover}px; bottom: 0; width: calc(100% - ${leftSpace + rightSpace}px); left: ${leftSpace}px`;\r\n                bottom.id = \"bottom\";\r\n\r\n                document.body.appendChild(top);\r\n                document.body.appendChild(left);\r\n                document.body.appendChild(right);\r\n                document.body.appendChild(bottom);\r\n            }\r\n            else if (event?.data?.type == \"modal-close\") {\r\n                console.log(`Window message - Modal Close`);\r\n\r\n                let wrapper = document.body.getElementsByClassName(\"main-wrapper\")[0] as HTMLElement;\r\n                wrapper.style.removeProperty(\"overflow\");\r\n\r\n                const top = document.getElementById(\"top\");\r\n                const left = document.getElementById(\"left\");\r\n                const right = document.getElementById(\"right\");\r\n                const bottom = document.getElementById(\"bottom\");\r\n\r\n                if (top) document.body.removeChild(top);\r\n                if (left) document.body.removeChild(left);\r\n                if (right) document.body.removeChild(right);\r\n                if (bottom) document.body.removeChild(bottom);\r\n            }\r\n        };\r\n\r\n        if (this.Embedded)\r\n            document.body.style.setProperty(\"overflow-y\", \"auto\", \"important\");\r\n    }\r\n\r\n    private onNavigateBack() {\r\n        \r\n        if (history?.state?._pushed) {\r\n            this._reloadAllowed = false;\r\n            this.pushedHistories.pop();\r\n            history.back();\r\n        }\r\n    }\r\n\r\n    public replaceState(basePath: string, url: string) {\r\n        // Esempio basePath: pages\r\n        // Esempio url: parties/leads_search\r\n\r\n        // Normalizzazione senza slash prima o dopo\r\n        basePath = basePath.endsWith(\"/\") ? basePath.substring(0, basePath.length -2) : basePath;\r\n        url = url.startsWith(\"/\") ? url.substring(1) : url;\r\n\r\n        this.location.replaceState(`${basePath}/${url}`);\r\n        this.MainWindow.postMessage({ type: \"replace-state\", url: `pages/embed/${this.EmbeddedModule}/${url}` }, \"*\");\r\n    }\r\n\r\n    public refreshBoundariesOnMenuCollapse() {\r\n        const wrapper = document.body.getElementsByClassName(\"main-wrapper\")[0] as HTMLElement;\r\n        let wrapperStyles = window.getComputedStyle(wrapper);\r\n        const wrapperPaddingLeft = parseInt(wrapperStyles.getPropertyValue(\"padding-left\"));\r\n        var leftSpace: number = 230 + wrapperPaddingLeft;\r\n\r\n        const left = document.getElementById(\"left\");\r\n        const top = document.getElementById(\"top\");\r\n\r\n        if (top) {\r\n            top.style.setProperty(\"left\", (leftSpace) + \"px\");\r\n            top.style.setProperty(\"width\", `calc(100% - ${leftSpace}px)`);\r\n        }\r\n\r\n        if (left)\r\n            left.style.setProperty(\"width\", leftSpace + \"px\");\r\n    }\r\n}"]}