@likec4/language-server 1.43.0 → 1.44.0

package/dist/model-change/changeElementStyle.js

@@ -0,0 +1,134 @@
+import { _type, invariant, isAncestor, } from '@likec4/core';
+import { GrammarUtils } from 'langium';
+import { entries, filter, findLast, isTruthy, last } from 'remeda';
+import { TextEdit } from 'vscode-languageserver-types';
+import { ast } from '../ast';
+const { findNodeForKeyword } = GrammarUtils;
+const asViewStyleRule = (target, style, indent = 0) => {
+    const indentStr = indent > 0 ? ' '.repeat(indent) : '';
+    return [
+        indentStr + `style ${target} {`,
+        ...entries(style).map(([key, value]) => indentStr + `  ${key} ${key === 'opacity' ? value.toString() + '%' : value}`),
+        indentStr + `}`,
+    ];
+};
+/**
+ * - is ViewRuleStyle
+ * - has exactly one target
+ * - the target is an ElementRef to the given fqn
+ */
+const isMatchingViewRule = (fqn, index) => (rule) => {
+    if (!ast.isViewRuleStyle(rule) && !ast.isDeploymentViewRuleStyle(rule)) {
+        return false;
+    }
+    const target = rule.targets.value;
+    if (!target || isTruthy(rule.targets.prev) || target.$type !== 'FqnRefExpr' || isTruthy(target.selector)) {
+        return false;
+    }
+    const ref = target.ref?.value?.ref;
+    const _fqn = ref ? index.resolve(ref) : null;
+    return _fqn === fqn;
+};
+export function changeElementStyle(services, { view, viewAst, targets, style, }) {
+    // Should never happen
+    invariant(viewAst.body, `View ${view.id} has no body`);
+    const viewCstNode = viewAst.$cstNode;
+    invariant(viewCstNode, 'viewCstNode');
+    const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end
+        ?? viewAst.body.$cstNode?.range.end;
+    invariant(insertPos, 'insertPos is not defined');
+    const indent = viewCstNode.range.start.character + 2;
+    const fqnIndex = services.likec4.FqnIndex;
+    const styleRules = filter(viewAst.body.rules, (r) => ast.isViewRuleStyle(r) || ast.isDeploymentViewRuleStyle(r));
+    const viewOf = view[_type] === 'element' ? view.viewOf ?? null : null;
+    // Find existing rules
+    const existing = [];
+    const insert = [];
+    // const existingRules = [] as Array<{ fqn: Fqn, rule: ast.ViewRuleStyle }>
+    targets.forEach(target => {
+        const rule = findLast(styleRules, isMatchingViewRule(target, fqnIndex));
+        // remove viewOf from the target to shorten the fqn
+        const fqn = (viewOf && isAncestor(viewOf, target) ? target.substring(viewOf.length + 1) : target);
+        if (rule) {
+            existing.push({ fqn, rule });
+        }
+        else {
+            insert.push({ fqn });
+        }
+    });
+    const modifiedRange = {
+        start: insertPos,
+        end: insertPos,
+    };
+    const includeRange = (range) => {
+        if (range.start.line <= modifiedRange.start.line) {
+            if (range.start.line == modifiedRange.start.line) {
+                modifiedRange.start.character = Math.min(range.start.character, modifiedRange.start.character);
+            }
+            else {
+                modifiedRange.start = range.start;
+            }
+        }
+        if (range.end.line >= modifiedRange.end.line) {
+            if (range.end.line == modifiedRange.end.line) {
+                modifiedRange.end.character = Math.max(range.end.character, modifiedRange.end.character);
+            }
+            else {
+                modifiedRange.end = range.end;
+            }
+        }
+    };
+    const edits = [];
+    if (insert.length > 0) {
+        const linesToInsert = insert.flatMap(({ fqn }) => asViewStyleRule(fqn, style, indent));
+        edits.push(TextEdit.insert(insertPos, '\n' + linesToInsert.join('\n')));
+        modifiedRange.start = {
+            line: insertPos.line + 1,
+            character: indent,
+        };
+        modifiedRange.end = {
+            line: insertPos.line + linesToInsert.length,
+            character: (last(linesToInsert)?.length ?? 0),
+        };
+    }
+    if (existing.length > 0) {
+        for (const { rule } of existing) {
+            const ruleCstNode = rule.$cstNode;
+            invariant(ruleCstNode, 'RuleCstNode not found');
+            for (const [key, _value] of entries(style)) {
+                const value = key === 'opacity' ? _value.toString() + '%' : _value;
+                const ruleProp = rule.props.find(p => p.key === key);
+                // replace existing  property
+                if (ruleProp && ruleProp.$cstNode) {
+                    const { range: { start, end } } = ruleProp.$cstNode;
+                    includeRange({
+                        start,
+                        end,
+                    });
+                    edits.push(TextEdit.replace({ start, end }, key + ' ' + value));
+                    continue;
+                }
+                // insert new style property right after the opening brace
+                const insertPos = findNodeForKeyword(ruleCstNode, '{')?.range.end;
+                invariant(insertPos, 'Opening brace not found');
+                const indentStr = ' '.repeat(ruleCstNode.range.start.character) + '\t';
+                const insertKeyValue = indentStr + key + ' ' + value;
+                edits.push(TextEdit.insert(insertPos, '\n' + insertKeyValue));
+                includeRange({
+                    start: {
+                        line: insertPos.line + 1,
+                        character: indentStr.length,
+                    },
+                    end: {
+                        line: insertPos.line + 1,
+                        character: insertKeyValue.length,
+                    },
+                });
+            }
+        }
+    }
+    return {
+        modifiedRange,
+        edits,
+    };
+}

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

@@ -1,6 +1,6 @@
 import { type ViewChange } from '@likec4/core';
 import { TextEdit } from 'vscode-languageserver-types';
-import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast';
+import { type ParsedAstView, type ParsedLikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 type ChangeViewLayoutArg = {
     view: ParsedAstView;
@@ -8,5 +8,5 @@ type ChangeViewLayoutArg = {
     viewAst: ast.LikeC4View;
     layout: ViewChange.ChangeAutoLayout['layout'];
 };
-export declare function changeViewLayout(_services: LikeC4Services, { view, viewAst, layout }: ChangeViewLayoutArg): TextEdit;
+export declare function changeViewLayout(_services: LikeC4Services, { view, viewAst, layout, }: ChangeViewLayoutArg): TextEdit;
 export {};

package/dist/model-change/changeViewLayout.js

@@ -0,0 +1,28 @@
+import { invariant } from '@likec4/core';
+import { GrammarUtils } from 'langium';
+import { findLast, isNumber } from 'remeda';
+import { TextEdit } from 'vscode-languageserver-types';
+import { ast, toAstViewLayoutDirection } from '../ast';
+const { findNodeForKeyword } = GrammarUtils;
+export function changeViewLayout(_services, { view, viewAst, layout, }) {
+    // Should never happen
+    invariant(viewAst.body, `View ${view.id} has no body`);
+    const viewCstNode = viewAst.$cstNode;
+    invariant(viewCstNode, 'viewCstNode');
+    const newdirection = toAstViewLayoutDirection(layout.direction);
+    const existingRule = findLast(viewAst.body.rules, ast.isViewRuleAutoLayout);
+    let newRule = `autoLayout ${newdirection}`;
+    if (isNumber(layout.rankSep)) {
+        newRule += ` ${layout.rankSep}`;
+        if (isNumber(layout.nodeSep)) {
+            newRule += ` ${layout.nodeSep}`;
+        }
+    }
+    if (existingRule && existingRule.$cstNode) {
+        return TextEdit.replace(existingRule.$cstNode.range, newRule);
+    }
+    const insertPos = findNodeForKeyword(viewAst.body.$cstNode, '}')?.range.start;
+    invariant(insertPos, 'Closing brace not found');
+    const insert = `\t${newRule}\n\t`;
+    return TextEdit.insert(insertPos, insert);
+}

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

@@ -0,0 +1,7 @@
+import type { ViewLocateResult } from '../model/model-locator';
+import type { LikeC4Services } from '../module';
+type RemoveManualLayoutV1Args = {
+    lookup: ViewLocateResult;
+};
+export declare function removeManualLayoutV1(services: LikeC4Services, { lookup, }: RemoveManualLayoutV1Args): Promise<boolean>;
+export {};

package/dist/model-change/removeManualLayoutV1.js

@@ -0,0 +1,27 @@
+import { invariant } from '@likec4/core';
+import { CstUtils } from 'langium';
+import { TextEdit } from 'vscode-languageserver-types';
+import { hasManualLayout } from '../view-utils/manual-layout';
+export async function removeManualLayoutV1(services, { lookup, }) {
+    // No manual layout v1 present
+    if (!lookup.view.manualLayout) {
+        return false;
+    }
+    const cstnode = lookup.viewAst.$cstNode;
+    invariant(cstnode, 'invalid view.$cstNode');
+    const lspConnection = services.shared.lsp.Connection;
+    invariant(lspConnection, 'LSP Connection not available');
+    const commentCst = CstUtils.findCommentNode(cstnode, ['BLOCK_COMMENT']);
+    if (commentCst && hasManualLayout(commentCst.text)) {
+        const edit = await lspConnection.workspace.applyEdit({
+            label: `LikeC4 - remove manual layout v1 for ${lookup.view.id}`,
+            edit: {
+                changes: {
+                    [lookup.doc.textDocument.uri]: [TextEdit.del(commentCst.range)],
+                },
+            },
+        });
+        return edit.applied;
+    }
+    return false;
+}

package/dist/module.d.ts

@@ -3,8 +3,9 @@ import { type Module, WorkspaceCache } from 'langium';
 import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
 import { LikeC4DocumentationProvider } from './documentation';
 import { type FileSystemModuleContext, type FileSystemProvider, type FileSystemWatcher } from './filesystem';
+import { LikeC4Formatter } from './formatting/LikeC4Formatter';
 import { type LikeC4LanguageServices } from './LikeC4LanguageServices';
-import { LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
+import { LikeC4CodeActionProvider, LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
 import { type LikeC4MCPServer, type LikeC4MCPServerModuleContext } from './mcp/interfaces';
 import { LikeC4MCPServerFactory } from './mcp/MCPServerFactory';
 import { type LikeC4ModelBuilder, DeploymentsIndex, FqnIndex, LikeC4ModelLocator, LikeC4ModelParser, LikeC4ValueConverter } from './model';
@@ -13,15 +14,17 @@ import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from
 import { Rpc } from './Rpc';
 import { NodeKindProvider, WorkspaceSymbolProvider } from './shared';
 import { LikeC4DocumentValidator } from './validation';
-import { type LikeC4Views } from './views';
+import { type LikeC4ManualLayouts, type LikeC4Views } from './views';
+import type { LikeC4ManualLayoutsModuleContext } from './views/LikeC4ManualLayouts';
 import { IndexManager, LangiumDocuments, LikeC4WorkspaceManager, ProjectsManager } from './workspace';
-export type LanguageServicesContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4MCPServerModuleContext;
+export type LanguageServicesContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4MCPServerModuleContext & LikeC4ManualLayoutsModuleContext;
 interface LikeC4AddedSharedServices {
     lsp: {
         NodeKindProvider: NodeKindProvider;
         WorkspaceSymbolProvider: WorkspaceSymbolProvider;
     };
     workspace: {
+        Cache: WorkspaceCache<string, any>;
         ProjectsManager: ProjectsManager;
         IndexManager: IndexManager;
         LangiumDocuments: LangiumDocuments;
@@ -38,7 +41,6 @@ export interface LikeC4AddedServices {
     documentation: {
         DocumentationProvider: LikeC4DocumentationProvider;
     };
-    ValidatedWorkspaceCache: WorkspaceCache<string, any>;
     validation: {
         DocumentValidator: LikeC4DocumentValidator;
     };
@@ -50,6 +52,7 @@ export interface LikeC4AddedServices {
     likec4: {
         LanguageServices: LikeC4LanguageServices;
         Views: LikeC4Views;
+        ManualLayouts: LikeC4ManualLayouts;
         Layouter: QueueGraphvizLayoter;
         DeploymentsIndex: DeploymentsIndex;
         FqnIndex: FqnIndex;
@@ -66,6 +69,8 @@ export interface LikeC4AddedServices {
         HoverProvider: LikeC4HoverProvider;
         CodeLensProvider: LikeC4CodeLensProvider;
         DocumentLinkProvider: LikeC4DocumentLinkProvider;
+        Formatter: LikeC4Formatter;
+        CodeActionProvider: LikeC4CodeActionProvider;
     };
     references: {
         NameProvider: LikeC4NameProvider;
@@ -78,7 +83,7 @@ export interface LikeC4AddedServices {
     };
 }
 export type LikeC4Services = LangiumServices & LikeC4AddedServices;
-export declare const createLikeC4Module: (context: LikeC4MCPServerModuleContext) => Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
+export declare const createLikeC4Module: (context: LikeC4MCPServerModuleContext & LikeC4ManualLayoutsModuleContext) => Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
 export declare function createLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: Partial<LanguageServicesContext>, module?: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
     shared: LikeC4SharedServices;
     likec4: I;

package/dist/module.js

@@ -0,0 +1,143 @@
+import { onNextTick } from '@likec4/core/utils';
+import { GraphvizWasmAdapter, QueueGraphvizLayoter } from '@likec4/layouts';
+import { DocumentState, inject, WorkspaceCache, } from 'langium';
+import { createDefaultModule, createDefaultSharedModule, } from 'langium/lsp';
+import { LikeC4DocumentationProvider } from './documentation';
+import { NoopFileSystem, } from './filesystem';
+import { LikeC4Formatter } from './formatting/LikeC4Formatter';
+import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule, } from './generated/module';
+import { DefaultLikeC4LanguageServices } from './LikeC4LanguageServices';
+import { LikeC4CodeActionProvider, LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider, } from './lsp';
+import { NoMCPServer, } from './mcp/interfaces';
+import { LikeC4MCPServerFactory } from './mcp/MCPServerFactory';
+import { DefaultLikeC4ModelBuilder, DeploymentsIndex, FqnIndex, LikeC4ModelLocator, LikeC4ModelParser, LikeC4ValueConverter, } from './model';
+import { LikeC4ModelChanges } from './model-change/ModelChanges';
+import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider, } from './references';
+import { Rpc } from './Rpc';
+import { NodeKindProvider, WorkspaceSymbolProvider, } from './shared';
+import { LikeC4DocumentValidator, registerValidationChecks } from './validation';
+import { DefaultLikeC4Views, NoopLikeC4ManualLayouts } from './views';
+import { AstNodeDescriptionProvider, IndexManager, LangiumDocuments, LikeC4WorkspaceManager, ProjectsManager, } from './workspace';
+const createLikeC4SharedModule = (context) => ({
+    lsp: {
+        NodeKindProvider: services => new NodeKindProvider(services),
+        WorkspaceSymbolProvider: services => new WorkspaceSymbolProvider(services),
+    },
+    workspace: {
+        Cache: services => new WorkspaceCache(services, DocumentState.Validated),
+        IndexManager: services => new IndexManager(services),
+        LangiumDocuments: services => new LangiumDocuments(services),
+        ProjectsManager: services => new ProjectsManager(services),
+        WorkspaceManager: services => new LikeC4WorkspaceManager(services),
+        FileSystemProvider: services => context.fileSystemProvider(services),
+        FileSystemWatcher: services => context.fileSystemWatcher(services),
+    },
+});
+function bind(Type) {
+    return (services) => new Type(services);
+}
+export const createLikeC4Module = (context) => ({
+    documentation: {
+        DocumentationProvider: bind(LikeC4DocumentationProvider),
+    },
+    validation: {
+        DocumentValidator: bind(LikeC4DocumentValidator),
+    },
+    Rpc: bind(Rpc),
+    mcp: {
+        Server: (services) => context.mcpServer(services),
+        ServerFactory: bind(LikeC4MCPServerFactory),
+    },
+    likec4: {
+        LanguageServices: bind(DefaultLikeC4LanguageServices),
+        Layouter: (_services) => {
+            return new QueueGraphvizLayoter({
+                graphviz: new GraphvizWasmAdapter(),
+            });
+        },
+        Views: bind(DefaultLikeC4Views),
+        ManualLayouts: (services) => context.manualLayouts(services),
+        DeploymentsIndex: bind(DeploymentsIndex),
+        ModelChanges: bind(LikeC4ModelChanges),
+        FqnIndex: bind(FqnIndex),
+        ModelParser: bind(LikeC4ModelParser),
+        ModelBuilder: bind(DefaultLikeC4ModelBuilder),
+        ModelLocator: bind(LikeC4ModelLocator),
+    },
+    lsp: {
+        // RenameProvider: bind(LikeC4RenameProvider),
+        CompletionProvider: bind(LikeC4CompletionProvider),
+        DocumentHighlightProvider: bind(LikeC4DocumentHighlightProvider),
+        DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
+        SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
+        HoverProvider: bind(LikeC4HoverProvider),
+        CodeLensProvider: bind(LikeC4CodeLensProvider),
+        DocumentLinkProvider: bind(LikeC4DocumentLinkProvider),
+        Formatter: bind(LikeC4Formatter),
+        CodeActionProvider: bind(LikeC4CodeActionProvider),
+    },
+    workspace: {
+        AstNodeDescriptionProvider: bind(AstNodeDescriptionProvider),
+    },
+    references: {
+        NameProvider: bind(LikeC4NameProvider),
+        ScopeComputation: bind(LikeC4ScopeComputation),
+        ScopeProvider: bind(LikeC4ScopeProvider),
+    },
+    parser: {
+        ValueConverter: bind(LikeC4ValueConverter),
+    },
+});
+export function createLanguageServices(context, module, module2, module3) {
+    const shared = createSharedServices(context);
+    const modules = [
+        createDefaultModule({ shared }),
+        LikeC4GeneratedModule,
+        createLikeC4Module({
+            ...NoMCPServer,
+            ...NoopLikeC4ManualLayouts,
+            ...context,
+        }),
+        module,
+        module2,
+        module3,
+    ].reduce(_merge, {});
+    const likec4 = inject(modules);
+    shared.ServiceRegistry.register(likec4);
+    registerValidationChecks(likec4);
+    if (!context.connection) {
+        // We don't run inside a language server
+        // Therefore, initialize the configuration provider instantly
+        void shared.workspace.ConfigurationProvider.initialized({});
+    }
+    else {
+        onNextTick(() => likec4.Rpc.init());
+    }
+    return { shared, likec4 };
+}
+export function createSharedServices(context = {}) {
+    const moduleContext = {
+        ...NoMCPServer,
+        ...NoopFileSystem,
+        ...NoopLikeC4ManualLayouts,
+        ...context,
+    };
+    return inject(createDefaultSharedModule(moduleContext), LikeC4GeneratedSharedModule, createLikeC4SharedModule(moduleContext));
+}
+// Copied from langium/src/dependency-injection.ts as it is not exported
+function _merge(target, source) {
+    if (source) {
+        for (const [key, value2] of Object.entries(source)) {
+            if (value2 !== undefined) {
+                const value1 = target[key];
+                if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {
+                    target[key] = _merge(value1, value2);
+                }
+                else {
+                    target[key] = value2;
+                }
+            }
+        }
+    }
+    return target;
+}

package/dist/protocol.d.ts

@@ -1,5 +1,5 @@
 import type { LikeC4ProjectJsonConfig } from '@likec4/config';
-import type { ComputedLikeC4ModelData, ComputedView, DeploymentFqn, DiagramView, Fqn, LayoutedLikeC4ModelData, NonEmptyArray, ProjectId, RelationId, ViewChange, ViewId } from '@likec4/core';
+import type { ComputedLikeC4ModelData, DeploymentFqn, DiagramView, Fqn, LayoutedLikeC4ModelData, NonEmptyArray, ProjectId, RelationId, ViewChange, ViewId } from '@likec4/core';
 import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
 import type { DiagnosticSeverity, DocumentUri, Location, Position, Range, URI } from 'vscode-languageserver-types';
 export declare namespace DidChangeModelNotification {
@@ -49,22 +49,6 @@ export declare namespace FetchViewsFromAllProjects {
     const req: RequestType0<Res, void>;
     type Req = typeof req;
 }
-/**
- * Request to compute a view.
- * If LSP has multiple projects, the projectId is required.
- * otherwise throws an error.
- */
-export declare namespace ComputeView {
-    type Params = {
-        viewId: ViewId;
-        projectId?: string;
-    };
-    type Result = {
-        view: ComputedView | null;
-    };
-    const req: RequestType<Params, Result, void>;
-    type Req = typeof req;
-}
 /**
  * Request to fetch the layouted model data
  * If LSP has multiple projects, the projectId is required.

package/dist/protocol.js

@@ -0,0 +1,114 @@
+import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
+export var DidChangeModelNotification;
+(function (DidChangeModelNotification) {
+    DidChangeModelNotification.type = new NotificationType('likec4/onDidChangeModel');
+})(DidChangeModelNotification || (DidChangeModelNotification = {}));
+/**
+ * When server requests to open a likec4 preview panel
+ * (available only in the editor).
+ * (not the best place, but seems to be working)
+ */
+export var DidRequestOpenViewNotification;
+(function (DidRequestOpenViewNotification) {
+    DidRequestOpenViewNotification.type = new NotificationType('likec4/onRequestOpenView');
+})(DidRequestOpenViewNotification || (DidRequestOpenViewNotification = {}));
+/**
+ * Request to fetch the computed model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
+export var FetchComputedModel;
+(function (FetchComputedModel) {
+    FetchComputedModel.req = new RequestType('likec4/fetchComputedModel');
+})(FetchComputedModel || (FetchComputedModel = {}));
+/**
+ * Request to fetch all views of all projects
+ */
+export var FetchViewsFromAllProjects;
+(function (FetchViewsFromAllProjects) {
+    FetchViewsFromAllProjects.req = new RequestType0('likec4/fetchViewsFromAllProjects');
+})(FetchViewsFromAllProjects || (FetchViewsFromAllProjects = {}));
+/**
+ * Request to fetch the layouted model data
+ * If LSP has multiple projects, the projectId is required.
+ * otherwise throws an error.
+ */
+export var FetchLayoutedModel;
+(function (FetchLayoutedModel) {
+    FetchLayoutedModel.req = new RequestType('likec4/fetchLayoutedModel');
+})(FetchLayoutedModel || (FetchLayoutedModel = {}));
+/**
+ * Request to layout a view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+export var LayoutView;
+(function (LayoutView) {
+    LayoutView.req = new RequestType('likec4/layout-view');
+})(LayoutView || (LayoutView = {}));
+/**
+ * Request to validate all views
+ * If projects ID is provided, it will validate only the views of that project.
+ */
+export var ValidateLayout;
+(function (ValidateLayout) {
+    ValidateLayout.Req = new RequestType('likec4/validate-layout');
+})(ValidateLayout || (ValidateLayout = {}));
+/**
+ * Request to reload projects.
+ */
+export var ReloadProjects;
+(function (ReloadProjects) {
+    ReloadProjects.req = new RequestType0('likec4/reload-projects');
+})(ReloadProjects || (ReloadProjects = {}));
+/**
+ * Fetch all non-empty projects.
+ */
+export var FetchProjects;
+(function (FetchProjects) {
+    FetchProjects.req = new RequestType0('likec4/fetch-projects');
+})(FetchProjects || (FetchProjects = {}));
+/**
+ * Request from the client to register a project.
+ */
+export var RegisterProject;
+(function (RegisterProject) {
+    RegisterProject.req = new RequestType('likec4/register-project');
+})(RegisterProject || (RegisterProject = {}));
+/**
+ * Request to build documents.
+ */
+export var BuildDocuments;
+(function (BuildDocuments) {
+    BuildDocuments.Req = new RequestType('likec4/build');
+})(BuildDocuments || (BuildDocuments = {}));
+/**
+ * Request to locate an element, relation, deployment or view.
+ * If LSP has multiple projects, the projectId is required.
+ */
+export var Locate;
+(function (Locate) {
+    Locate.Req = new RequestType('likec4/locate');
+})(Locate || (Locate = {}));
+// #endregion
+/**
+ * Request to change the view
+ * If LSP has multiple projects, the projectId is required.
+ */
+export var ChangeView;
+(function (ChangeView) {
+    ChangeView.Req = new RequestType('likec4/change-view');
+})(ChangeView || (ChangeView = {}));
+/**
+ * Request to fetch telemetry metrics
+ */
+export var FetchTelemetryMetrics;
+(function (FetchTelemetryMetrics) {
+    FetchTelemetryMetrics.req = new RequestType0('likec4/metrics');
+})(FetchTelemetryMetrics || (FetchTelemetryMetrics = {}));
+/**
+ * Request to fetch all tags of a document
+ */
+export var GetDocumentTags;
+(function (GetDocumentTags) {
+    GetDocumentTags.req = new RequestType('likec4/document-tags');
+})(GetDocumentTags || (GetDocumentTags = {}));

package/dist/references/index.js

@@ -0,0 +1,3 @@
+export * from './name-provider';
+export * from './scope-computation';
+export * from './scope-provider';

package/dist/references/name-provider.js

@@ -0,0 +1,37 @@
+import { nonNullable } from '@likec4/core';
+import { DefaultNameProvider, isNamed } from 'langium';
+import { ast } from '../ast';
+export class LikeC4NameProvider extends DefaultNameProvider {
+    services;
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    getNameStrict(node) {
+        return nonNullable(this.getName(node), `Failed getName for ${this.services.workspace.AstNodeLocator.getAstNodePath(node)}`);
+    }
+    getName(node) {
+        if (isNamed(node)) {
+            return node.name;
+        }
+        if (ast.isImported(node)) {
+            return node.imported.$refText;
+        }
+        if (ast.isDeployedInstance(node)) {
+            return node.target.modelElement.value.$refText;
+        }
+        return undefined;
+    }
+    getNameNode(node) {
+        if (isNamed(node)) {
+            return super.getNameNode(node);
+        }
+        if (ast.isImported(node)) {
+            return node.imported.$refNode;
+        }
+        if (ast.isDeployedInstance(node)) {
+            return node.target.modelElement.value.$refNode;
+        }
+        return undefined;
+    }
+}