@likec4/language-server 1.18.0 → 1.19.0

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

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

package/dist/model-change/changeViewLayout.js

@@ -0,0 +1,32 @@
+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.js";
+const { findNodeForProperty, findNodeForKeyword } = GrammarUtils;
+export function changeViewLayout(_services, {
+  view,
+  viewAst,
+  layout
+}) {
+  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 = `	${newRule}
+	`;
+  return TextEdit.insert(insertPos, insert);
+}

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

@@ -0,0 +1,11 @@
+import { type ViewChange } from '@likec4/core';
+import { TextEdit } from 'vscode-languageserver-types';
+import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export type ManualLayoutArg = {
+    view: ParsedAstView;
+    doc: ParsedLikeC4LangiumDocument;
+    viewAst: ast.LikeC4View;
+    layout: ViewChange.SaveManualLayout['layout'];
+};
+export declare function saveManualLayout(_services: LikeC4Services, { viewAst, layout }: ManualLayoutArg): TextEdit;

package/dist/model-change/saveManualLayout.js

@@ -0,0 +1,27 @@
+import { invariant } from "@likec4/core";
+import indentString from "indent-string";
+import { CstUtils, GrammarUtils } from "langium";
+import { TextEdit } from "vscode-languageserver-types";
+import { serializeToComment } from "../view-utils/manual-layout.js";
+const { findNodeForProperty } = GrammarUtils;
+export function saveManualLayout(_services, {
+  viewAst,
+  layout
+}) {
+  invariant(viewAst.$cstNode, "invalid view.$cstNode");
+  const commentCst = CstUtils.findCommentNode(viewAst.$cstNode, ["BLOCK_COMMENT"]);
+  let txt = serializeToComment(layout);
+  if (viewAst.$cstNode.range.start.character > 0) {
+    txt = indentString(txt, viewAst.$cstNode.range.start.character);
+  }
+  if (commentCst) {
+    return TextEdit.replace(commentCst.range, txt.trimStart());
+  }
+  return TextEdit.insert(
+    {
+      line: viewAst.$cstNode.range.start.line,
+      character: 0
+    },
+    txt + "\n"
+  );
+}

package/dist/module.d.ts

@@ -0,0 +1,62 @@
+import { type Module, DocumentCache, WorkspaceCache } from 'langium';
+import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
+import { LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
+import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
+import { LikeC4ModelChanges } from './model-change/ModelChanges';
+import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
+import { Rpc } from './Rpc';
+import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared';
+interface LikeC4AddedSharedServices {
+    lsp: {
+        NodeKindProvider: NodeKindProvider;
+        WorkspaceSymbolProvider: WorkspaceSymbolProvider;
+    };
+    workspace: {
+        WorkspaceManager: LikeC4WorkspaceManager;
+    };
+}
+export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+export interface LikeC4AddedServices {
+    WorkspaceCache: WorkspaceCache<string, any>;
+    DocumentCache: DocumentCache<string, any>;
+    Rpc: Rpc;
+    likec4: {
+        DeploymentsIndex: DeploymentsIndex;
+        FqnIndex: FqnIndex;
+        ModelParser: LikeC4ModelParser;
+        ModelBuilder: LikeC4ModelBuilder;
+        ModelLocator: LikeC4ModelLocator;
+        ModelChanges: LikeC4ModelChanges;
+    };
+    lsp: {
+        CompletionProvider: LikeC4CompletionProvider;
+        DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
+        DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
+        SemanticTokenProvider: LikeC4SemanticTokenProvider;
+        HoverProvider: LikeC4HoverProvider;
+        CodeLensProvider: LikeC4CodeLensProvider;
+        DocumentLinkProvider: LikeC4DocumentLinkProvider;
+    };
+    references: {
+        NameProvider: LikeC4NameProvider;
+        ScopeComputation: LikeC4ScopeComputation;
+        ScopeProvider: LikeC4ScopeProvider;
+    };
+    shared?: LikeC4SharedServices;
+}
+export type LikeC4Services = LangiumServices & LikeC4AddedServices;
+export declare const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
+export type LanguageServicesContext = Partial<DefaultSharedModuleContext>;
+export declare function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: LanguageServicesContext, module: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
+    shared: LikeC4SharedServices;
+    likec4: I;
+};
+export declare function createSharedServices(context?: LanguageServicesContext): LikeC4SharedServices;
+export declare function createLanguageServices(context?: LanguageServicesContext): {
+    shared: LikeC4SharedServices;
+    likec4: LikeC4Services;
+};
+export {};

package/dist/module.js

@@ -0,0 +1,123 @@
+import { DocumentCache, EmptyFileSystem, inject, WorkspaceCache } from "langium";
+import {
+  createDefaultModule,
+  createDefaultSharedModule
+} from "langium/lsp";
+import { LikeC4Formatter } from "./formatting/LikeC4Formatter.js";
+import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from "./generated/module.js";
+import { logToLspConnection } from "./logger.js";
+import {
+  LikeC4CodeLensProvider,
+  LikeC4CompletionProvider,
+  LikeC4DocumentHighlightProvider,
+  LikeC4DocumentLinkProvider,
+  LikeC4DocumentSymbolProvider,
+  LikeC4HoverProvider,
+  LikeC4SemanticTokenProvider
+} from "./lsp/index.js";
+import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from "./model/index.js";
+import { LikeC4ModelChanges } from "./model-change/ModelChanges.js";
+import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from "./references/index.js";
+import { Rpc } from "./Rpc.js";
+import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from "./shared/index.js";
+import { registerValidationChecks } from "./validation/index.js";
+const LikeC4SharedModule = {
+  lsp: {
+    NodeKindProvider: (services) => new NodeKindProvider(services),
+    WorkspaceSymbolProvider: (services) => new WorkspaceSymbolProvider(services)
+  },
+  workspace: {
+    WorkspaceManager: (services) => new LikeC4WorkspaceManager(services)
+  }
+};
+function bind(Type) {
+  return (services) => new Type(services);
+}
+export const LikeC4Module = {
+  WorkspaceCache: (services) => new WorkspaceCache(services.shared),
+  DocumentCache: (services) => new DocumentCache(services.shared),
+  Rpc: bind(Rpc),
+  likec4: {
+    DeploymentsIndex: bind(DeploymentsIndex),
+    ModelChanges: bind(LikeC4ModelChanges),
+    FqnIndex: bind(FqnIndex),
+    ModelParser: bind(LikeC4ModelParser),
+    ModelBuilder: bind(LikeC4ModelBuilder),
+    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)
+  },
+  references: {
+    NameProvider: bind(LikeC4NameProvider),
+    ScopeComputation: bind(LikeC4ScopeComputation),
+    ScopeProvider: bind(LikeC4ScopeProvider)
+  }
+};
+export function createCustomLanguageServices(context, module, module2, module3) {
+  const shared = createSharedServices(context);
+  const modules = [
+    createDefaultModule({ shared }),
+    LikeC4GeneratedModule,
+    LikeC4Module,
+    module,
+    module2,
+    module3
+  ].reduce(_merge, {});
+  const likec4 = inject(modules);
+  shared.ServiceRegistry.register(likec4);
+  registerValidationChecks(likec4);
+  if (!context.connection) {
+    shared.workspace.ConfigurationProvider.initialized({});
+  } else {
+    likec4.Rpc.init();
+  }
+  return { shared, likec4 };
+}
+export function createSharedServices(context = {}) {
+  const moduleContext = {
+    ...EmptyFileSystem,
+    ...context
+  };
+  if (context.connection) {
+    logToLspConnection(context.connection);
+  }
+  return inject(
+    createDefaultSharedModule(moduleContext),
+    LikeC4GeneratedSharedModule,
+    LikeC4SharedModule
+  );
+}
+export function createLanguageServices(context = {}) {
+  const shared = createSharedServices(context);
+  const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
+  shared.ServiceRegistry.register(likec4);
+  registerValidationChecks(likec4);
+  if (context.connection) {
+    likec4.Rpc.init();
+  }
+  return { shared, likec4 };
+}
+function _merge(target, source) {
+  if (source) {
+    for (const [key, value2] of Object.entries(source)) {
+      if (value2 !== void 0) {
+        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,31 +1,30 @@
-import { ParsedLikeC4Model, ComputedLikeC4Model, ViewId, ComputedView, Fqn, RelationId, ViewChange } from '@likec4/core';
-import { NotificationType, RequestType0, RequestType } from 'vscode-jsonrpc';
-import { DocumentUri, Location } from 'vscode-languageserver-types';
-
-declare const onDidChangeModel: NotificationType<string>;
-type OnDidChangeModelNotification = typeof onDidChangeModel;
-declare const fetchModel: RequestType0<{
+import type { ComputedLikeC4Model, ComputedView, Fqn, ParsedLikeC4Model, RelationId, ViewChange, ViewId } from '@likec4/core';
+import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
+import type { DocumentUri, Location } from 'vscode-languageserver-types';
+export declare const onDidChangeModel: NotificationType<string>;
+export type OnDidChangeModelNotification = typeof onDidChangeModel;
+export declare const fetchModel: RequestType0<{
     model: ParsedLikeC4Model | null;
 }, void>;
-type FetchModelRequest = typeof fetchModel;
-declare const fetchComputedModel: RequestType<{
+export type FetchModelRequest = typeof fetchModel;
+export declare const fetchComputedModel: RequestType<{
     cleanCaches?: boolean | undefined;
 }, {
     model: ComputedLikeC4Model | null;
 }, void>;
-type FetchComputedModelRequest = typeof fetchComputedModel;
-declare const computeView: RequestType<{
+export type FetchComputedModelRequest = typeof fetchComputedModel;
+export declare const computeView: RequestType<{
     viewId: ViewId;
 }, {
     view: ComputedView | null;
 }, void>;
-type ComputeViewRequest = typeof computeView;
-interface BuildDocumentsParams {
+export type ComputeViewRequest = typeof computeView;
+export interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
-declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
-type BuildDocumentsRequest = typeof buildDocuments;
-type LocateParams = {
+export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
+export type BuildDocumentsRequest = typeof buildDocuments;
+export type LocateParams = {
     element: Fqn;
     property?: string;
 } | {
@@ -36,13 +35,11 @@ type LocateParams = {
 } | {
     view: ViewId;
 };
-declare const locate: RequestType<LocateParams, Location, void>;
-type LocateRequest = typeof locate;
-interface ChangeViewRequestParams {
+export declare const locate: RequestType<LocateParams, Location | null, void>;
+export type LocateRequest = typeof locate;
+export interface ChangeViewRequestParams {
     viewId: ViewId;
     change: ViewChange;
 }
-declare const changeView: RequestType<ChangeViewRequestParams, Location, void>;
-type ChangeViewRequest = typeof changeView;
-
-export { type BuildDocumentsParams, type BuildDocumentsRequest, type ChangeViewRequest, type ChangeViewRequestParams, type ComputeViewRequest, type FetchComputedModelRequest, type FetchModelRequest, type LocateParams, type LocateRequest, type OnDidChangeModelNotification, buildDocuments, changeView, computeView, fetchComputedModel, fetchModel, locate, onDidChangeModel };
+export declare const changeView: RequestType<ChangeViewRequestParams, Location | null, void>;
+export type ChangeViewRequest = typeof changeView;

package/dist/protocol.js

@@ -0,0 +1,14 @@
+import { NotificationType, RequestType, RequestType0 } from "vscode-jsonrpc";
+export const onDidChangeModel = new NotificationType("likec4/onDidChangeModel");
+export const fetchModel = new RequestType0(
+  "likec4/fetchModel"
+);
+export const fetchComputedModel = new RequestType(
+  "likec4/fetchComputedModel"
+);
+export const computeView = new RequestType(
+  "likec4/computeView"
+);
+export const buildDocuments = new RequestType("likec4/build");
+export const locate = new RequestType("likec4/locate");
+export const changeView = new RequestType("likec4/change-view");

package/dist/references/index.d.ts

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

package/dist/references/index.js

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

package/dist/references/name-provider.d.ts

@@ -0,0 +1,9 @@
+import { type AstNode, type CstNode, DefaultNameProvider } from 'langium';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4NameProvider extends DefaultNameProvider {
+    protected services: LikeC4Services;
+    constructor(services: LikeC4Services);
+    getNameStrict(node: AstNode): string;
+    getName(node: AstNode): string | undefined;
+    getNameNode(node: AstNode): CstNode | undefined;
+}

package/dist/references/name-provider.js

@@ -0,0 +1,33 @@
+import { nonNullable } from "@likec4/core";
+import { DefaultNameProvider, isNamed } from "langium";
+import { ast } from "../ast.js";
+export class LikeC4NameProvider extends DefaultNameProvider {
+  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.isDeployedInstance(node)) {
+      return node.element.el.$refText;
+    }
+    return void 0;
+  }
+  getNameNode(node) {
+    if (isNamed(node)) {
+      return super.getNameNode(node);
+    }
+    if (ast.isDeployedInstance(node)) {
+      return node.element.el.$refNode;
+    }
+    return void 0;
+  }
+}

package/dist/references/scope-computation.d.ts

@@ -0,0 +1,20 @@
+import { type AstNodeDescription, DefaultScopeComputation, type PrecomputedScopes } from 'langium';
+import type { CancellationToken } from 'vscode-languageserver';
+import { ast, type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
+type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody;
+export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+    constructor(services: LikeC4Services);
+    computeExports(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<AstNodeDescription[]>;
+    private exportViews;
+    private exportGlobals;
+    private exportModel;
+    private exportLibrary;
+    private exportSpecification;
+    private exportDeployments;
+    computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken?: CancellationToken): Promise<PrecomputedScopes>;
+    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+    protected processDeployments(container: DeploymentsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): AstNodeDescription[];
+}
+export {};