feat(dot-browsing): Enhance tree structure with parent reference and update tests

## Summary
This commit introduces a parent reference in the tree structure for better data management and updates related tests to ensure functionality.

## Changes Made
### Models
- Added `parent` property to `CustomTreeNode` in `dot-browser-selector.model.ts`.

### Store
- Updated `HostFolderFiledStore` to utilize the new `CustomTreeNode` structure in `host-folder-field.store.ts`.

### Service
- Modified `DotBrowsingService` to include the parent reference in the tree response in `dot-browsing.service.ts`.

### Tests
- Expanded test cases in `dot-browsing.service.spec.ts` to validate the presence of the parent reference in tree structures for both single and multi-level paths.

## Technical Details
The addition of the parent reference allows consumers of the tree structure to access the parent folder's hostname directly, improving the usability of the data model.

## Testing
- [x] Unit tests added/updated to cover new functionality.
- [x] Manual testing performed to verify tree structure integrity and parent reference accessibility.

Author: nicobytes

core-web/libs/dotcms-models/src/lib/dot-browser-selector.model.ts

@@ -1,5 +1,7 @@
 import { TreeNode } from 'primeng/api';
 
+import { DotFolder } from './dot-folder.model';
+
 export type TreeNodeData = {
     type: 'site' | 'folder';
     path: string;
@@ -14,6 +16,7 @@ export type TreeNodeSelectItem = TreeNodeSelectEvent<TreeNodeData>;
 export type CustomTreeNode = {
     node: null | TreeNodeItem;
     tree: {
+        parent?: DotFolder;
         path: string;
         folders: TreeNodeItem[];
     } | null;

core-web/libs/edit-content/src/lib/fields/dot-edit-content-host-folder-field/store/host-folder-field.store.ts

@@ -1,13 +1,18 @@
 import { tapResponse } from '@ngrx/operators';
-import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
+import { patchState, signalStore, withComputed, withMethods, withState } from '@ngrx/signals';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 import { of, pipe } from 'rxjs';
 
 import { computed, inject } from '@angular/core';
 
-import { tap, exhaustMap, switchMap, map, filter } from 'rxjs/operators';
+import { exhaustMap, filter, map, switchMap, tap } from 'rxjs/operators';
 
-import { ComponentStatus, TreeNodeItem, TreeNodeSelectItem } from '@dotcms/dotcms-models';
+import {
+    ComponentStatus,
+    CustomTreeNode,
+    TreeNodeItem,
+    TreeNodeSelectItem
+} from '@dotcms/dotcms-models';
 import { DotBrowsingService } from '@dotcms/ui';
 
 export const PEER_PAGE_LIMIT = 7000;
@@ -132,7 +137,7 @@ export const HostFolderFiledStore = signalStore(
                         const hasPaths = path.includes('/');
 
                         if (!hasPaths) {
-                            const response = {
+                            const response: CustomTreeNode = {
                                 node: sites.find((item) => item.data.hostname === path),
                                 tree: null
                             };

core-web/libs/ui/src/lib/services/dot-browsing/dot-browsing.service.spec.ts

@@ -6,14 +6,14 @@ import {
 } from '@ngneat/spectator/jest';
 import { of, throwError } from 'rxjs';
 
-import { DotSiteService, DotFolderService } from '@dotcms/data-access';
+import { DotFolderService, DotSiteService } from '@dotcms/data-access';
 import {
-    DotFolder,
-    SiteEntity,
+    ContentByFolderParams,
     DotCMSContentlet,
-    ContentByFolderParams
+    DotFolder,
+    SiteEntity
 } from '@dotcms/dotcms-models';
-import { createFakeSite, createFakeFolder, createFakeContentlet } from '@dotcms/utils-testing';
+import { createFakeContentlet, createFakeFolder, createFakeSite } from '@dotcms/utils-testing';
 
 import { DotBrowsingService } from './dot-browsing.service';
 
@@ -410,6 +410,112 @@ describe('DotBrowsingService', () => {
                 }
             });
         });
+
+        it('should always return tree with defined parent and hostName for single level path', (done) => {
+            const path = 'example.com';
+            const rootParent = createFakeFolder({
+                id: 'root',
+                hostName: 'example.com',
+                path: '/',
+                addChildrenAllowed: true
+            });
+
+            const rootFolders: DotFolder[] = [rootParent];
+
+            dotFolderService.getFolders.mockReturnValue(of(rootFolders));
+
+            spectator.service.buildTreeByPaths(path).subscribe((result) => {
+                expect(result.tree).toBeDefined();
+                expect(result.tree?.parent).toBeDefined();
+                expect(result.tree?.parent?.hostName).toBe('example.com');
+                expect(result.tree?.path).toBe('/');
+                // Consumer (host-folder-field.store) can safely use tree.parent.hostName
+                expect(() => {
+                    const hostName = result.tree?.parent?.hostName;
+                    return hostName;
+                }).not.toThrow();
+                done();
+            });
+        });
+
+        it('should always return tree with defined parent and hostName for multi level path (regression: tree.parent.hostName in host-folder-field.store)', (done) => {
+            const path = 'demo.com/level1/level2';
+
+            const level2Parent = createFakeFolder({
+                id: 'parent-level2',
+                hostName: 'demo.com',
+                path: '/level1/level2',
+                addChildrenAllowed: true
+            });
+
+            const level2Folders: DotFolder[] = [
+                level2Parent,
+                createFakeFolder({
+                    id: 'child-level2',
+                    hostName: 'demo.com',
+                    path: '/level1/level2/child',
+                    addChildrenAllowed: true
+                })
+            ];
+
+            const level1Folders: DotFolder[] = [
+                createFakeFolder({
+                    id: 'parent-level1',
+                    hostName: 'demo.com',
+                    path: '/level1',
+                    addChildrenAllowed: true
+                }),
+                createFakeFolder({
+                    id: 'parent-level2',
+                    hostName: 'demo.com',
+                    path: '/level1/level2',
+                    addChildrenAllowed: true
+                })
+            ];
+
+            const rootFolders: DotFolder[] = [
+                createFakeFolder({
+                    id: 'root',
+                    hostName: 'demo.com',
+                    path: '/',
+                    addChildrenAllowed: true
+                }),
+                createFakeFolder({
+                    id: 'parent-level1',
+                    hostName: 'demo.com',
+                    path: '/level1',
+                    addChildrenAllowed: true
+                })
+            ];
+
+            dotFolderService.getFolders.mockImplementation((requestedPath: string) => {
+                if (requestedPath === '//demo.com/level1/level2/') {
+                    return of(level2Folders);
+                }
+                if (requestedPath === '//demo.com/level1/') {
+                    return of(level1Folders);
+                }
+                if (requestedPath === '//demo.com/') {
+                    return of(rootFolders);
+                }
+                return of([]);
+            });
+
+            spectator.service.buildTreeByPaths(path).subscribe((result) => {
+                expect(result.tree).toBeDefined();
+                expect(result.tree?.parent).toBeDefined();
+                expect(result.tree?.parent?.hostName).toBeDefined();
+                expect(result.tree?.parent?.hostName).toBe('demo.com');
+                // Simulates host-folder-field.store: item.data.hostname === tree.parent.hostName
+                expect(() => {
+                    const tree = result.tree;
+                    if (tree) {
+                        return tree.parent?.hostName;
+                    }
+                }).not.toThrow();
+                done();
+            });
+        });
     });
 
     describe('getCurrentSiteAsTreeNodeItem', () => {

core-web/libs/ui/src/lib/services/dot-browsing/dot-browsing.service.ts

@@ -4,12 +4,12 @@ import { Injectable, inject } from '@angular/core';
 
 import { filter, map } from 'rxjs/operators';
 
-import { DotSiteService, DotFolderService } from '@dotcms/data-access';
+import { DotFolderService, DotSiteService } from '@dotcms/data-access';
 import {
-    DotFolder,
-    TreeNodeItem,
+    ContentByFolderParams,
     CustomTreeNode,
-    ContentByFolderParams
+    DotFolder,
+    TreeNodeItem
 } from '@dotcms/dotcms-models';
 
 /**
@@ -142,7 +142,11 @@ export class DotBrowsingService {
                             }
                         }
 
-                        rta.tree = { path: node.parent.path, folders: node.folders };
+                        rta.tree = {
+                            path: node.parent.path,
+                            folders: node.folders,
+                            parent: node.parent
+                        };
 
                         return rta;
                     },