@likec4/language-server 1.44.0 → 1.45.0

package/dist/model/model-parser.js

@@ -1,11 +1,9 @@
 import { DefaultWeakMap, invariant, MultiMap } from '@likec4/core/utils';
-import { loggable } from '@likec4/log';
 import { DocumentState, UriUtils } from 'langium';
 import { pipe } from 'remeda';
 import { DiagnosticSeverity } from 'vscode-languageserver-types';
 import { isLikeC4LangiumDocument } from '../ast';
-import { isLikeC4Builtin } from '../likec4lib';
-import { logger as rootLogger } from '../logger';
+import { logger as rootLogger, logWarnError } from '../logger';
 import { BaseParser } from './parser/Base';
 import { DeploymentModelParser } from './parser/DeploymentModelParser';
 import { DeploymentViewParser } from './parser/DeploymentViewParser';
@@ -25,24 +23,34 @@ export class LikeC4ModelParser {
     cachedParsers = new DefaultWeakMap((doc) => this.createParser(doc));
     constructor(services) {
         this.services = services;
-        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Linked, doc => {
-            try {
+        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Linked, async (doc) => {
+            if (this.cachedParsers.has(doc)) {
+                logger.trace('Linked: clear cached parser {projectId} document {doc}', {
+                    projectId: doc.likec4ProjectId,
+                    doc: UriUtils.basename(doc.uri),
+                });
+                this.cachedParsers.delete(doc);
+            }
+        });
+        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Linked, async (docs) => {
+            for (const doc of docs) {
                 if (services.shared.workspace.ProjectsManager.isExcluded(doc)) {
-                    return;
+                    continue;
                 }
-                if (!isLikeC4Builtin(doc.uri)) {
-                    this.cachedParsers.set(doc, this.createParser(doc));
+                try {
+                    // Force create parser for linked document (if not yet created)
+                    this.parse(doc);
+                }
+                catch (error) {
+                    logWarnError(error);
                 }
-            }
-            catch (e) {
-                logger.warn(loggable(e));
             }
         });
         // We need to clean up cached parser when document is validated and has errors
         // Because after that parser takes into account validation results
-        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Validated, doc => {
+        services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.Validated, async (doc) => {
             if (doc.diagnostics?.some(d => d.severity === DiagnosticSeverity.Error) && this.cachedParsers.has(doc)) {
-                logger.debug('clear cached parser {projectId} document {doc}', {
+                logger.trace('Validated: clear cached parser {projectId} document {doc} because of errors', {
                     projectId: doc.likec4ProjectId,
                     doc: UriUtils.basename(doc.uri),
                 });
@@ -54,31 +62,30 @@ export class LikeC4ModelParser {
         return this.services.shared.workspace.LangiumDocuments.projectDocuments(projectId).map(d => this.parse(d));
     }
     parse(doc) {
-        try {
-            const parser = this.forDocument(doc);
-            return parser.doc;
-        }
-        catch (cause) {
-            throw new Error(`Error parsing document ${doc.uri.toString()}`, { cause });
-        }
+        const parser = this.forDocument(doc);
+        return parser.doc;
     }
     forDocument(doc) {
-        if (doc.state < DocumentState.Linked) {
-            logger.warn(`Document {doc} is not linked`, { doc: doc.uri.toString() });
-        }
         return this.cachedParsers.get(doc);
     }
     createParser(doc) {
         invariant(isLikeC4LangiumDocument(doc), `Document ${doc.uri.toString()} is not a LikeC4 document`);
+        const docbasename = UriUtils.basename(doc.uri);
         if (doc.likec4ProjectId) {
-            logger.debug(`create parser {projectId} document {doc}`, {
+            logger.trace(`create parser {projectId} document {doc}`, {
                 projectId: doc.likec4ProjectId,
-                doc: UriUtils.basename(doc.uri),
+                doc: docbasename,
             });
         }
         else {
             logger.warn(`create parser for document without project {doc}`, { doc: doc.uri.fsPath });
         }
+        if (doc.state < DocumentState.Linked) {
+            logger.warn(`Document {doc} is not linked, state is {state}`, {
+                doc: docbasename,
+                state: doc.state,
+            });
+        }
         const props = {
             c4Specification: {
                 tags: {},
@@ -111,8 +118,8 @@ export class LikeC4ModelParser {
             parser.parseDeployment();
             parser.parseViews();
         }
-        catch (e) {
-            logger.error(`Error parsing document {doc}`, { doc: doc.uri.toString(), error: e });
+        catch (error) {
+            throw new Error(`Error parsing document ${doc.uri.fsPath}`, { cause: error });
         }
         return parser;
     }

package/dist/model/parser/SpecificationParser.js

@@ -55,6 +55,10 @@ export function SpecificationParser(B) {
                     const tag = tagSpec.tag.name;
                     const astPath = this.getAstNodePath(tagSpec.tag);
                     const color = tagSpec.color && this.parseColorLiteral(tagSpec.color);
+                    if (tag in c4Specification.tags) {
+                        logger.warn(`Tag {tag} is already defined, skipping duplicate`, { tag });
+                        continue;
+                    }
                     if (isTruthy(tag)) {
                         c4Specification.tags[tag] = {
                             astPath,

package/dist/model/parser/ViewsParser.js

@@ -63,7 +63,9 @@ export function ViewsParser(B) {
                 const viewOfEl = elementRef(astNode.viewOf);
                 const _viewOf = viewOfEl && this.resolveFqn(viewOfEl);
                 if (!_viewOf) {
-                    logger.warn('viewOf is not resolved: ' + astNode.$cstNode?.text);
+                    const viewId = astNode.name ?? 'unnamed';
+                    const msg = astNode.viewOf.$cstNode?.text ?? '<unknown>';
+                    logger.warn(`viewOf {viewId} not resolved {msg}`, { msg, viewId });
                 }
                 else {
                     viewOf = _viewOf;

package/dist/model-change/ModelChanges.d.ts

@@ -1,5 +1,5 @@
 import { type ViewChange } from '@likec4/core';
-import { Location, Range, TextEdit } from 'vscode-languageserver-types';
+import { Range, TextEdit } from 'vscode-languageserver-types';
 import type { ViewLocateResult } from '../model';
 import type { LikeC4Services } from '../module';
 import type { ChangeView } from '../protocol';
@@ -7,7 +7,7 @@ export declare class LikeC4ModelChanges {
     private services;
     private locator;
     constructor(services: LikeC4Services);
-    applyChange(changeView: ChangeView.Params): Promise<Location | null>;
+    applyChange(changeView: ChangeView.Params): Promise<ChangeView.Res>;
     protected convertToTextEdit({ lookup, change }: {
         lookup: ViewLocateResult;
         change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout>;

package/dist/model-change/ModelChanges.js

@@ -1,5 +1,6 @@
 import { invariant, nonexhaustive } from '@likec4/core';
-import { Location, Range, TextEdit } from 'vscode-languageserver-types';
+import { loggable, wrapError } from '@likec4/log';
+import { Range, TextEdit } from 'vscode-languageserver-types';
 import { logger as mainLogger } from '../logger';
 import { changeElementStyle } from './changeElementStyle';
 import { changeViewLayout } from './changeViewLayout';
@@ -23,7 +24,7 @@ export class LikeC4ModelChanges {
                 logger.debug `Applying model change ${change.op} to view ${viewId} in project ${project.id}`;
                 const lookup = this.locator.locateViewAst(viewId, project.id);
                 if (!lookup) {
-                    throw new Error(`LikeC4ModelChanges: view not found: ${viewId}`);
+                    throw new Error(`View ${viewId} not found in project ${project.id}`);
                 }
                 const textDocument = {
                     uri: lookup.doc.textDocument.uri,
@@ -39,11 +40,26 @@ export class LikeC4ModelChanges {
                             logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
                         });
                     }
-                    result = await this.services.likec4.ManualLayouts.write(project, change.layout);
+                    const location = await this.services.likec4.ManualLayouts.write(project, change.layout);
+                    result = {
+                        success: true,
+                        location,
+                    };
                     return;
                 }
                 if (change.op === 'reset-manual-layout') {
-                    result = await this.services.likec4.ManualLayouts.remove(project, viewId);
+                    // If there is an existing manual layout v1
+                    if (lookup.view.manualLayout) {
+                        // We clean it up
+                        await removeManualLayoutV1(this.services, { lookup }).catch(err => {
+                            logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
+                        });
+                    }
+                    const location = await this.services.likec4.ManualLayouts.remove(project, viewId);
+                    result = {
+                        success: true,
+                        location,
+                    };
                     return;
                 }
                 const { edits, modifiedRange } = this.convertToTextEdit({
@@ -66,15 +82,26 @@ export class LikeC4ModelChanges {
                     return;
                 }
                 result = {
-                    uri: textDocument.uri,
-                    range: modifiedRange,
+                    success: true,
+                    location: {
+                        uri: textDocument.uri,
+                        range: modifiedRange,
+                    },
                 };
             });
         }
-        catch (error) {
-            logger.error(`Failed to apply change ${changeView.change.op} ${changeView.viewId}`, { error });
+        catch (err) {
+            const error = loggable(wrapError(err, `Failed to apply change ${changeView.change.op} ${changeView.viewId}:\n`));
+            logger.error(error);
+            result = {
+                success: false,
+                error,
+            };
         }
-        return result;
+        return result ?? {
+            success: false,
+            error: 'Unknown error applying model change',
+        };
     }
     convertToTextEdit({ lookup, change }) {
         switch (change.op) {

package/dist/protocol.d.ts

@@ -6,6 +6,18 @@ export declare namespace DidChangeModelNotification {
     const type: NotificationType<string>;
     type Type = typeof type;
 }
+/**
+ * When the snapshot of a manual layout changes
+ * Send by the editor to the language server
+ */
+export declare namespace DidChangeSnapshotNotification {
+    type Params = {
+        snapshotUri: DocumentUri;
+    };
+    const Method: "likec4/onDidChangeSnapshot";
+    const type: NotificationType<Params>;
+    type Type = typeof type;
+}
 /**
  * When server requests to open a likec4 preview panel
  * (available only in the editor).
@@ -72,6 +84,7 @@ export declare namespace LayoutView {
     type Params = {
         viewId: ViewId;
         projectId?: string | undefined;
+        layoutType?: 'auto' | 'manual' | undefined;
     };
     type Res = {
         result: {
@@ -102,8 +115,8 @@ export declare namespace ValidateLayout {
             };
         }[] | null;
     };
-    const Req: RequestType<Params, Res, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
 }
 /**
  * Request to reload projects.
@@ -123,7 +136,10 @@ export declare namespace FetchProjects {
         projects: {
             [projectId: ProjectId]: {
                 folder: URI;
-                config: LikeC4ProjectJsonConfig;
+                config: {
+                    name: string;
+                    title?: string | undefined;
+                };
                 docs: NonEmptyArray<DocumentUri>;
             };
         };
@@ -152,8 +168,8 @@ export declare namespace BuildDocuments {
     type Params = {
         docs: DocumentUri[];
     };
-    const Req: RequestType<Params, void, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, void, void>;
+    type Req = typeof req;
 }
 /**
  * Request to locate an element, relation, deployment or view.
@@ -200,8 +216,8 @@ export declare namespace Locate {
         projectId?: string | undefined;
     };
     type Res = Location | null;
-    const Req: RequestType<Params, Res, void>;
-    type Req = typeof Req;
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
 }
 /**
  * Request to change the view
@@ -213,9 +229,16 @@ export declare namespace ChangeView {
         change: ViewChange;
         projectId?: string | undefined;
     };
-    type Res = Location | null;
-    const Req: RequestType<Params, Res, void>;
-    type Req = typeof Req;
+    type Res = {
+        success: true;
+        location: Location | null;
+    } | {
+        success: false;
+        location?: Location | null;
+        error: string;
+    };
+    const req: RequestType<Params, Res, void>;
+    type Req = typeof req;
 }
 /**
  * Request to fetch telemetry metrics

package/dist/protocol.js

@@ -3,6 +3,15 @@ export var DidChangeModelNotification;
 (function (DidChangeModelNotification) {
     DidChangeModelNotification.type = new NotificationType('likec4/onDidChangeModel');
 })(DidChangeModelNotification || (DidChangeModelNotification = {}));
+/**
+ * When the snapshot of a manual layout changes
+ * Send by the editor to the language server
+ */
+export var DidChangeSnapshotNotification;
+(function (DidChangeSnapshotNotification) {
+    DidChangeSnapshotNotification.Method = 'likec4/onDidChangeSnapshot';
+    DidChangeSnapshotNotification.type = new NotificationType(DidChangeSnapshotNotification.Method);
+})(DidChangeSnapshotNotification || (DidChangeSnapshotNotification = {}));
 /**
  * When server requests to open a likec4 preview panel
  * (available only in the editor).
@@ -51,7 +60,7 @@ export var LayoutView;
  */
 export var ValidateLayout;
 (function (ValidateLayout) {
-    ValidateLayout.Req = new RequestType('likec4/validate-layout');
+    ValidateLayout.req = new RequestType('likec4/validate-layout');
 })(ValidateLayout || (ValidateLayout = {}));
 /**
  * Request to reload projects.
@@ -79,7 +88,7 @@ export var RegisterProject;
  */
 export var BuildDocuments;
 (function (BuildDocuments) {
-    BuildDocuments.Req = new RequestType('likec4/build');
+    BuildDocuments.req = new RequestType('likec4/build');
 })(BuildDocuments || (BuildDocuments = {}));
 /**
  * Request to locate an element, relation, deployment or view.
@@ -87,7 +96,7 @@ export var BuildDocuments;
  */
 export var Locate;
 (function (Locate) {
-    Locate.Req = new RequestType('likec4/locate');
+    Locate.req = new RequestType('likec4/locate');
 })(Locate || (Locate = {}));
 // #endregion
 /**
@@ -96,7 +105,7 @@ export var Locate;
  */
 export var ChangeView;
 (function (ChangeView) {
-    ChangeView.Req = new RequestType('likec4/change-view');
+    ChangeView.req = new RequestType('likec4/change-view');
 })(ChangeView || (ChangeView = {}));
 /**
  * Request to fetch telemetry metrics

package/dist/view-utils/manual-layout.js

@@ -14,10 +14,9 @@ function pack({ nodes, edges, ...rest }) {
             b: [x, y, width, height],
             c: isCompound,
         })),
-        edges: mapValues(edges, ({ points, controlPoints, labelBBox, dotpos, ...e }) => ({
+        edges: mapValues(edges, ({ points, controlPoints, labelBBox, ...e }) => ({
             ...!!controlPoints && { cp: controlPoints },
             ...!!labelBBox && { l: labelBBox },
-            ...!!dotpos && { dp: dotpos },
             ...e,
             p: points,
         })),
@@ -36,10 +35,9 @@ function unpack({ nodes, edges, autoLayout, ...rest }) {
             isCompound: c,
             ...n,
         })),
-        edges: mapValues(edges, ({ p, cp, l, dp, ...e }) => ({
+        edges: mapValues(edges, ({ p, cp, l, ...e }) => ({
             ...!!cp && { controlPoints: cp },
             ...!!l && { labelBBox: l },
-            ...!!dp && { dotpos: dp },
             ...e,
             points: p,
         })),

package/dist/views/LikeC4ManualLayouts.d.ts

@@ -1,4 +1,5 @@
-import type { LayoutedView, ViewId } from '@likec4/core';
+import type { LayoutedView, ProjectId, ViewId } from '@likec4/core';
+import { URI, WorkspaceCache } from 'langium';
 import { type Location } from 'vscode-languageserver-types';
 import type { LikeC4Services } from '../module';
 import type { Project } from '../workspace/ProjectsManager';
@@ -19,10 +20,23 @@ export interface LikeC4ManualLayoutsModuleContext {
 export declare const WithLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
 export declare class DefaultLikeC4ManualLayouts implements LikeC4ManualLayouts {
     private services;
-    private manualLayouts;
+    protected cache: WorkspaceCache<ProjectId, Promise<Record<ViewId, LayoutedView> | null>>;
     constructor(services: LikeC4Services);
     read(project: Project): Promise<Record<ViewId, LayoutedView> | null>;
     write(project: Project, layouted: LayoutedView): Promise<Location>;
     remove(project: Project, view: ViewId): Promise<Location | null>;
     clearCaches(): void;
+    /**
+     * When we save snapshot - it may contain fullpath to icons on the machine it was created,
+     * that is wrong when opened on another.
+     *
+     * Prepares a snapshot for writing by converting absolute icon paths to relative paths.
+     * Absolute paths starting with 'file://' are converted to relative paths prefixed with 'file://./'
+     */
+    protected normalizeIconPathsForWrite(layouted: LayoutedView, projectUri: URI): LayoutedView;
+    /**
+     * Postprocesses a snapshot after reading by converting relative icon paths back to absolute paths.
+     * Relative paths prefixed with 'file://./' are converted to absolute paths based on project folder.
+     */
+    protected resolveIconPathsAfterRead(layouted: LayoutedView, projectUri: URI): LayoutedView;
 }

package/dist/views/LikeC4ManualLayouts.js

@@ -1,10 +1,9 @@
-import { getOrCreate } from '@likec4/core/utils';
 import JSON5 from 'json5';
-import { UriUtils } from 'langium';
+import { DocumentState, URI, UriUtils, WorkspaceCache } from 'langium';
 import { indexBy, prop } from 'remeda';
 import { Position, Range, } from 'vscode-languageserver-types';
 import { logger as rootLogger } from '../logger';
-const logger = rootLogger.getChild('manual-layouts');
+const layoutsLogger = rootLogger.getChild('manual-layouts');
 /**
  * @todo sync with vscode extension watchers
  *       (search for ".likec4.snap" references)
@@ -19,14 +18,17 @@ function getManualLayoutsOutDir(project) {
 export const WithLikeC4ManualLayouts = {
     manualLayouts: (services) => new DefaultLikeC4ManualLayouts(services),
 };
+const RELATIVE_PATH_PREFIX = 'file://./';
 export class DefaultLikeC4ManualLayouts {
     services;
-    manualLayouts = new WeakMap();
+    cache;
     constructor(services) {
         this.services = services;
+        this.cache = new WorkspaceCache(services.shared, DocumentState.Validated);
     }
     async read(project) {
-        return await getOrCreate(this.manualLayouts, project.folderUri, async (_) => {
+        return await this.cache.get(project.id, async () => {
+            const logger = layoutsLogger.getChild(project.id);
             const fs = this.services.shared.workspace.FileSystemProvider;
             const outDir = getManualLayoutsOutDir(project);
             const manualLayouts = [];
@@ -39,8 +41,10 @@ export class DefaultLikeC4ManualLayouts {
                     if (file.isFile) {
                         try {
                             const content = await fs.readFile(file.uri);
+                            const parsed = JSON5.parse(content);
+                            const resolved = this.resolveIconPathsAfterRead(parsed, project.folderUri);
                             manualLayouts.push({
-                                ...JSON5.parse(content),
+                                ...resolved,
                                 _layout: 'manual',
                             });
                         }
@@ -63,6 +67,7 @@ export class DefaultLikeC4ManualLayouts {
         });
     }
     async write(project, layouted) {
+        const logger = layoutsLogger.getChild(project.id);
         const outDir = getManualLayoutsOutDir(project);
         const file = UriUtils.joinPath(outDir, fileName(layouted.id));
         // Ensure the manualLayout field is omitted (may exist in migration)
@@ -70,6 +75,8 @@ export class DefaultLikeC4ManualLayouts {
             const { manualLayout: _, ...rest } = layouted;
             layouted = rest;
         }
+        // Normalize icon paths before writing
+        layouted = this.normalizeIconPathsForWrite(layouted, project.folderUri);
         const content = JSON5.stringify(layouted, {
             space: 2,
             quote: '\'',
@@ -81,23 +88,29 @@ export class DefaultLikeC4ManualLayouts {
         logger.debug `write snapshot of ${layouted.id} in project ${project.id} to ${file.fsPath}`;
         const fs = this.services.shared.workspace.FileSystemProvider;
         try {
-            await fs.writeFile(file, content);
+            await fs.writeFile(file, content + '\n');
         }
         catch (err) {
             logger.warn(`Failed to write snapshot ${layouted.id} to ${file.fsPath}`, { err });
         }
-        const projectCaches = await this.read(project);
-        if (projectCaches) {
-            logger.debug `update snapshot cache of ${layouted.id} in project ${project.id}`;
-            projectCaches[layouted.id] = layouted;
-        }
-        else {
-            this.manualLayouts.delete(project.folderUri);
+        const projectCachesPromise = this.cache.get(project.id);
+        if (projectCachesPromise) {
+            const projectCaches = await projectCachesPromise;
+            if (projectCaches) {
+                logger.debug `update snapshot cache of ${layouted.id} in project ${project.id}`;
+                projectCaches[layouted.id] = layouted;
+            }
+            else {
+                logger.debug `clean cache of project ${project.id}`;
+                // Cache was null, remove it entirely
+                this.cache.delete(project.id);
+            }
         }
         this.services.likec4.ModelBuilder.clearCache();
         return location;
     }
     async remove(project, view) {
+        const logger = layoutsLogger.getChild(project.id);
         const outDir = getManualLayoutsOutDir(project);
         const file = UriUtils.joinPath(outDir, fileName(view));
         logger.debug `delete snapshot of ${view} in project ${project.id}. File: ${file.fsPath}`;
@@ -115,18 +128,82 @@ export class DefaultLikeC4ManualLayouts {
         catch (err) {
             logger.warn(`Failed to delete snapshot ${view} from ${file.fsPath}`, { err });
         }
-        const projectCaches = await this.read(project);
-        if (projectCaches) {
-            logger.debug `clean cache of ${view} in project ${project.id}`;
-            delete projectCaches[view];
-        }
-        else {
-            this.manualLayouts.delete(project.folderUri);
+        const projectCachesPromise = this.cache.get(project.id);
+        if (projectCachesPromise) {
+            const projectCaches = await projectCachesPromise;
+            if (projectCaches) {
+                logger.debug `clean cached view ${view} in project ${project.id}`;
+                delete projectCaches[view];
+            }
+            else {
+                logger.debug `reset empty cache of project ${project.id}`;
+                // Cache was null, remove it entirely
+                this.cache.delete(project.id);
+            }
         }
         this.services.likec4.ModelBuilder.clearCache();
         return location;
     }
     clearCaches() {
-        this.manualLayouts = new WeakMap();
+        this.cache.clear();
+    }
+    /**
+     * When we save snapshot - it may contain fullpath to icons on the machine it was created,
+     * that is wrong when opened on another.
+     *
+     * Prepares a snapshot for writing by converting absolute icon paths to relative paths.
+     * Absolute paths starting with 'file://' are converted to relative paths prefixed with 'file://./'
+     */
+    normalizeIconPathsForWrite(layouted, projectUri) {
+        const nodes = layouted.nodes.map((node) => {
+            if (!node.icon || typeof node.icon !== 'string') {
+                return node;
+            }
+            // Check if icon is an absolute file path
+            if (node.icon.startsWith('file://')) {
+                const iconUri = URI.parse(node.icon);
+                // Get relative path from project folder to icon
+                const relativePath = UriUtils.relative(projectUri, iconUri);
+                // If icon is outside of project folder - leave it as is,
+                // to avoid security issues on reading snapshots on another machine
+                if (relativePath.startsWith('..')) {
+                    return node;
+                }
+                return {
+                    ...node,
+                    icon: `${RELATIVE_PATH_PREFIX}${relativePath}`,
+                };
+            }
+            return node;
+        });
+        return {
+            ...layouted,
+            nodes: nodes,
+        };
+    }
+    /**
+     * Postprocesses a snapshot after reading by converting relative icon paths back to absolute paths.
+     * Relative paths prefixed with 'file://./' are converted to absolute paths based on project folder.
+     */
+    resolveIconPathsAfterRead(layouted, projectUri) {
+        const nodes = layouted.nodes.map((node) => {
+            if (!node.icon || typeof node.icon !== 'string') {
+                return node;
+            }
+            // Check if icon is a relative file path
+            if (node.icon.startsWith(RELATIVE_PATH_PREFIX)) {
+                const relativePath = node.icon.substring(RELATIVE_PATH_PREFIX.length);
+                const absoluteUri = UriUtils.joinPath(projectUri, relativePath);
+                return {
+                    ...node,
+                    icon: absoluteUri.toString(),
+                };
+            }
+            return node;
+        });
+        return {
+            ...layouted,
+            nodes: nodes,
+        };
     }
 }