chore(uve): Clean clientHost param when the value is the default (dotCMS#31418)

This pull request introduces several changes to the
`DotEmaShellComponent` to handle client host URLs more robustly. The
changes include adding new test cases and modifying the component's
logic to sanitize and compare URLs correctly.

Key changes:

### Test Cases Enhancements:
* Added test cases to ensure the `clientHost` is not included in the
location when it matches the base client host, differs from the base
client host, or when sanitized URLs are compared.
(`core-web/libs/portlets/edit-ema/portlet/src/lib/dot-ema-shell/dot-ema-shell.component.spec.ts`)

### Component Logic Update:
* Updated the `$updateQueryParamsEffect` effect in
`DotEmaShellComponent` to sanitize and compare URLs, ensuring the
`clientHost` parameter is only included when necessary.
(`core-web/libs/portlets/edit-ema/portlet/src/lib/dot-ema-shell/dot-ema-shell.component.ts`)

### Screenshots


https://github.com/user-attachments/assets/dc8f917f-6864-45fb-bc73-5a8c6d22e74b

Author: zJaaal

core-web/libs/portlets/edit-ema/portlet/src/lib/dot-ema-shell/dot-ema-shell.component.spec.ts

@@ -588,6 +588,100 @@ describe('DotEmaShellComponent', () => {
                 expect(spyUrlTree).toHaveBeenCalledWith([], { queryParams: userParams });
                 expect(spyLocation).toHaveBeenCalledWith(expectURL.toString());
             });
+
+            it('should not include clientHost in location when it matches base client host', () => {
+                const spyLocation = jest.spyOn(location, 'go');
+                const baseClientHost = 'http://localhost:3000';
+                const params = {
+                    ...INITIAL_PAGE_PARAMS,
+                    clientHost: baseClientHost
+                };
+
+                // Set up route with matching uveConfig.url
+                overrideRouteSnashot(
+                    activatedRoute,
+                    SNAPSHOT_MOCK({
+                        queryParams: params,
+                        data: {
+                            uveConfig: {
+                                url: baseClientHost,
+                                options: BASIC_OPTIONS
+                            }
+                        }
+                    })
+                );
+
+                store.loadPageAsset(params);
+                spectator.detectChanges();
+
+                expect(spyLocation).toHaveBeenCalledWith(
+                    '/?language_id=1&url=index&variantName=DEFAULT&mode=EDIT_MODE'
+                );
+            });
+
+            it('should include clientHost in location when it differs from base client host', () => {
+                const spyLocation = jest.spyOn(location, 'go');
+                const baseClientHost = 'http://localhost:3000';
+                const differentClientHost = 'http://localhost:4000';
+                const params = {
+                    ...INITIAL_PAGE_PARAMS,
+                    clientHost: differentClientHost
+                };
+
+                // Set up route with different uveConfig.url
+                overrideRouteSnashot(
+                    activatedRoute,
+                    SNAPSHOT_MOCK({
+                        queryParams: params,
+                        data: {
+                            uveConfig: {
+                                url: baseClientHost,
+                                options: {
+                                    allowedDevURLs: [differentClientHost]
+                                }
+                            }
+                        }
+                    })
+                );
+
+                store.loadPageAsset(params);
+                spectator.detectChanges();
+
+                expect(spyLocation).toHaveBeenCalledWith(
+                    '/?language_id=1&url=index&variantName=DEFAULT&mode=EDIT_MODE&clientHost=http:%2F%2Flocalhost:4000'
+                );
+            });
+
+            it('should handle sanitized URLs in clientHost comparison', () => {
+                const spyLocation = jest.spyOn(location, 'go');
+                const baseClientHost = 'http://localhost:3000/';
+                const params = {
+                    ...INITIAL_PAGE_PARAMS,
+                    clientHost: 'http://localhost:3000' // No trailing slash
+                };
+
+                // Set up route with uveConfig.url that has trailing slash
+                overrideRouteSnashot(
+                    activatedRoute,
+                    SNAPSHOT_MOCK({
+                        queryParams: params,
+                        data: {
+                            uveConfig: {
+                                url: baseClientHost,
+                                options: BASIC_OPTIONS
+                            }
+                        }
+                    })
+                );
+
+                store.loadPageAsset(params);
+                spectator.detectChanges();
+
+                // Should treat these as the same URL and not include clientHost
+                expect(spyLocation).toHaveBeenCalledWith(
+                    '/?language_id=1&url=index&variantName=DEFAULT&mode=EDIT_MODE'
+                );
+            });
         });
 
         describe('ClientHost', () => {

core-web/libs/portlets/edit-ema/portlet/src/lib/dot-ema-shell/dot-ema-shell.component.ts

@@ -39,6 +39,7 @@ import {
     checkClientHostAccess,
     getAllowedPageParams,
     getTargetUrl,
+    normalizeQueryParams,
     sanitizeURL,
     shouldNavigate
 } from '../utils';
@@ -102,7 +103,14 @@ export class DotEmaShellComponent implements OnInit {
      */
     readonly $updateQueryParamsEffect = effect(() => {
         const params = this.uveStore.$friendlyParams();
-        this.#updateLocation(params);
+
+        const { data } = this.#activatedRoute.snapshot;
+
+        const baseClientHost = data?.uveConfig?.url;
+
+        const cleanedParams = normalizeQueryParams(params, baseClientHost);
+
+        this.#updateLocation(cleanedParams);
     });
 
     ngOnInit(): void {

core-web/libs/portlets/edit-ema/portlet/src/lib/utils/index.ts

@@ -277,9 +277,10 @@ export function getFullPageURL({
  *
  * @export
  * @param {Object} params - The raw query parameters to be processed.
+ * @param {string} baseClientHost - The base client host to be used to compare with the clientHost query param.
  * @return {Object} A cleaned and formatted version of the query parameters.
  */
-export function normalizeQueryParams(params) {
+export function normalizeQueryParams(params, baseClientHost?: string) {
     const queryParams = { ...params };
 
     if (queryParams[PERSONA_KEY] === DEFAULT_PERSONA.identifier) {
@@ -291,6 +292,10 @@ export function normalizeQueryParams(params) {
         delete queryParams[PERSONA_KEY];
     }
 
+    if (baseClientHost && sanitizeURL(baseClientHost) === sanitizeURL(params.clientHost)) {
+        delete queryParams.clientHost;
+    }
+
     return queryParams;
 }
 

core-web/libs/portlets/edit-ema/portlet/src/lib/utils/utils.spec.ts

@@ -879,50 +879,107 @@ describe('utils functions', () => {
     });
 
     describe('normalizeQueryParams', () => {
-        it('should remove PERSONA_KEY if it equals DEFAULT_PERSONA.identifier', () => {
-            const params = {
-                [PERSONA_KEY]: DEFAULT_PERSONA.identifier,
-                someOtherKey: 'someValue'
-            };
+        describe('persona handling', () => {
+            it('should remove PERSONA_KEY if it equals DEFAULT_PERSONA.identifier', () => {
+                const params = {
+                    [PERSONA_KEY]: DEFAULT_PERSONA.identifier,
+                    someOtherKey: 'someValue'
+                };
+
+                const result = normalizeQueryParams(params);
+
+                expect(result).toEqual({
+                    someOtherKey: 'someValue'
+                });
+            });
 
-            const result = normalizeQueryParams(params);
+            it('should rename PERSONA_KEY to personaId if not default', () => {
+                const params = {
+                    [PERSONA_KEY]: 'customPersonaId',
+                    anotherKey: 'anotherValue'
+                };
 
-            expect(result).toEqual({
-                someOtherKey: 'someValue'
+                const result = normalizeQueryParams(params);
+
+                expect(result).toEqual({
+                    personaId: 'customPersonaId',
+                    anotherKey: 'anotherValue'
+                });
             });
         });
 
-        it('should rename PERSONA_KEY to personaId if it is present and not default', () => {
-            const params = {
-                [PERSONA_KEY]: 'customPersonaId',
-                anotherKey: 'anotherValue'
-            };
+        describe('clientHost handling', () => {
+            it('should remove clientHost when it matches baseClientHost exactly', () => {
+                const params = {
+                    clientHost: 'http://example.com',
+                    someKey: 'someValue'
+                };
 
-            const result = normalizeQueryParams(params);
+                const result = normalizeQueryParams(params, 'http://example.com');
 
-            expect(result).toEqual({
-                personaId: 'customPersonaId',
-                anotherKey: 'anotherValue'
+                expect(result).toEqual({
+                    someKey: 'someValue'
+                });
             });
-        });
 
-        it('should not modify params if PERSONA_KEY is absent', () => {
-            const params = {
-                someKey: 'someValue',
-                anotherKey: 'anotherValue'
-            };
+            it('should remove clientHost when it matches baseClientHost with trailing slash', () => {
+                const params = {
+                    clientHost: 'http://example.com/',
+                    someKey: 'someValue'
+                };
+
+                const result = normalizeQueryParams(params, 'http://example.com');
 
-            const result = normalizeQueryParams(params);
+                expect(result).toEqual({
+                    someKey: 'someValue'
+                });
+            });
 
-            expect(result).toEqual(params);
+            it('should keep clientHost if it differs from baseClientHost', () => {
+                const params = {
+                    clientHost: 'http://example.com',
+                    someKey: 'someValue'
+                };
+
+                const result = normalizeQueryParams(params, 'http://different.com');
+
+                expect(result).toEqual({
+                    clientHost: 'http://example.com',
+                    someKey: 'someValue'
+                });
+            });
+
+            it('should keep clientHost if baseClientHost is not provided', () => {
+                const params = {
+                    clientHost: 'http://example.com',
+                    someKey: 'someValue'
+                };
+
+                const result = normalizeQueryParams(params);
+
+                expect(result).toEqual(params);
+            });
         });
 
-        it('should handle empty params object', () => {
-            const params = {};
+        describe('edge cases', () => {
+            it('should handle empty params object', () => {
+                const params = {};
+
+                const result = normalizeQueryParams(params);
+
+                expect(result).toEqual({});
+            });
+
+            it('should handle params with no special keys', () => {
+                const params = {
+                    someKey: 'someValue',
+                    anotherKey: 'anotherValue'
+                };
 
-            const result = normalizeQueryParams(params);
+                const result = normalizeQueryParams(params);
 
-            expect(result).toEqual({});
+                expect(result).toEqual(params);
+            });
         });
     });
 });