@likec4/language-server 0.40.0 → 0.42.0

package/dist/model/model-builder.js

@@ -1,13 +1,8 @@
 import {
-  ModelIndex,
-  assignNavigateTo,
   compareByFqnHierarchically,
-  computeView,
   invariant,
   isStrictElementView,
-  parentFqn,
-  resolveRulesExtendedViews,
-  resolveRelativePaths
+  parentFqn
 } from "@likec4/core";
 import {
   DocumentState,
@@ -19,17 +14,19 @@ import { isValidLikeC4LangiumDocument } from "../ast.js";
 import { logError, logWarnError, logger } from "../logger.js";
 import { LikeC4WorkspaceManager } from "../shared/index.js";
 import { printDocs, queueMicrotask } from "../utils.js";
+import { assignNavigateTo, resolveRelativePaths, resolveRulesExtendedViews } from "../view-utils/index.js";
+import { LikeC4ModelGraph, computeView } from "@likec4/graph";
 function isRelativeLink(link) {
   return link.startsWith(".") || link.startsWith("/");
 }
 function buildModel(docs) {
   const c4Specification = {
-    kinds: {}
+    kinds: {},
+    relationships: {}
   };
-  R.forEach(
-    R.map(docs, R.prop("c4Specification")),
-    (spec) => Object.assign(c4Specification.kinds, spec.kinds)
-  );
+  R.forEach(R.map(docs, R.prop("c4Specification")), (spec) => {
+    Object.assign(c4Specification.kinds, spec.kinds), Object.assign(c4Specification.relationships, spec.relationships);
+  });
   const resolveLinks = (doc, links) => {
     const base = new URL(doc.uri.toString());
     return links.map(
@@ -84,6 +81,15 @@ function buildModel(docs) {
     ...model
   }) => {
     if (source in elements && target in elements) {
+      if (model.kind) {
+        const kind = c4Specification.relationships[model.kind];
+        return {
+          source,
+          target,
+          ...kind,
+          ...model
+        };
+      }
       return {
         source,
         target,
@@ -134,8 +140,7 @@ function buildModel(docs) {
       links: null,
       rules: [
         {
-          isInclude: true,
-          exprs: [
+          include: [
             {
               wildcard: true
             }
@@ -199,7 +204,7 @@ ${printDocs(docs)}`);
       if (!model) {
         return null;
       }
-      const index = ModelIndex.from(model);
+      const index = new LikeC4ModelGraph(model);
       const views = R.pipe(
         R.values(model.views),
         R.map((view) => computeView(view, index).view),
@@ -220,7 +225,8 @@ ${printDocs(docs)}`);
       logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
       return null;
     }
-    const result = computeView(view, ModelIndex.from(model));
+    const index = new LikeC4ModelGraph(model);
+    const result = computeView(view, index);
     if (!result.isSuccess) {
       logError(result.error);
       return null;

package/dist/model/model-locator.d.ts

@@ -14,3 +14,4 @@ export declare class LikeC4ModelLocator {
     locateRelation(relationId: c4.RelationID): Location | null;
     locateView(viewId: c4.ViewID): Location | null;
 }
+//# sourceMappingURL=model-locator.d.ts.map

package/dist/model/model-parser.d.ts

@@ -20,3 +20,4 @@ export declare class LikeC4ModelParser {
     private getAstNodePath;
     private convertTags;
 }
+//# sourceMappingURL=model-parser.d.ts.map

package/dist/model/model-parser.js

@@ -11,7 +11,8 @@ import {
   streamModel,
   toAutoLayout,
   toElementStyle,
-  toElementStyleExcludeDefaults
+  toElementStyleExcludeDefaults,
+  toRelationshipStyleExcludeDefaults
 } from "../ast.js";
 import { elementRef, fqnElementRef } from "../elementRef.js";
 import { logError, logWarnError, logger } from "../logger.js";
@@ -22,33 +23,6 @@ export class LikeC4ModelParser {
     this.fqnIndex = services.likec4.FqnIndex;
   }
   fqnIndex;
-  // public onParsed(callback: ModelParsedListener): Disposable {
-  //   this.listeners.push(callback)
-  //   return Disposable.create(() => {
-  //     const index = this.listeners.indexOf(callback)
-  //     if (index >= 0) {
-  //       this.listeners.splice(index, 1)
-  //     }
-  //   })
-  // }
-  // protected async onValidated(docs: LangiumDocument[], cancelToken: CancellationToken): Promise<void> {
-  //   let countOfChangedDocs = 0
-  //   logger.debug(`[ModelParser] onValidated (${docs.length} docs)\n${printDocs(docs)}`)
-  //   for (const doc of docs) {
-  //     if (!isLikeC4LangiumDocument(doc)) {
-  //       continue
-  //     }
-  //     countOfChangedDocs++
-  //     try {
-  //       await this.parseDocument(doc, cancelToken)
-  //     } catch (cause) {
-  //       logError(new InvalidModelError(`Error parsing document ${doc.uri.toString()}`, { cause }))
-  //     }
-  //   }
-  //   if (countOfChangedDocs > 0) {
-  //     this.notifyListeners()
-  //   }
-  // }
   parse(doc) {
     const docs = Array.isArray(doc) ? doc : [doc];
     logger.debug(`[ModelParser] onValidated (${docs.length} docs)
@@ -82,6 +56,22 @@ ${printDocs(docs)}`);
         }
       }
     }
+    const relations_specs = doc.parseResult.value.specification?.relationships;
+    if (relations_specs) {
+      for (const { kind, props } of relations_specs) {
+        if (kind.name in specification.relationships) {
+          logger.warn(`Duplicate specification for kind ${kind.name}`);
+          continue;
+        }
+        try {
+          specification.relationships[kind.name] = toRelationshipStyleExcludeDefaults(
+            props
+          );
+        } catch (e) {
+          logWarnError(e);
+        }
+      }
+    }
     for (const el of streamModel(doc)) {
       if (ast.isElement(el)) {
         try {
@@ -146,6 +136,7 @@ ${printDocs(docs)}`);
     const coupling = resolveRelationPoints(astNode);
     const target = this.resolveFqn(coupling.target);
     const source = this.resolveFqn(coupling.source);
+    const kind = astNode.kind?.ref?.name;
     const hashdata = {
       astPath: this.getAstNodePath(astNode),
       source,
@@ -156,6 +147,7 @@ ${printDocs(docs)}`);
     return {
       id,
       ...hashdata,
+      ...kind && { kind },
       title
     };
   }
@@ -225,10 +217,7 @@ ${printDocs(docs)}`);
   parseViewRule(astRule) {
     if (ast.isViewRuleExpression(astRule)) {
       const exprs = astRule.expressions.map((n) => this.parseExpression(n));
-      return {
-        isInclude: astRule.isInclude,
-        exprs
-      };
+      return astRule.isInclude ? { include: exprs } : { exclude: exprs };
     }
     if (ast.isViewRuleStyle(astRule)) {
       const styleProps = toElementStyle(astRule.props);

package/dist/module.d.ts

@@ -26,3 +26,4 @@ export declare function createLanguageServices(context?: LanguageServicesContext
     likec4: LikeC4Services;
 };
 export {};
+//# sourceMappingURL=module.d.ts.map

package/dist/protocol.d.ts

@@ -30,3 +30,4 @@ export type LocateParams = {
 };
 export declare const locate: RequestType<LocateParams, Location | null, void>;
 export {};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/references/index.d.ts

@@ -1,2 +1,3 @@
 export * from './scope-computation';
 export * from './scope-provider';
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,10 +1,11 @@
-import { DefaultScopeComputation, type AstNodeDescription, type PrecomputedScopes } from 'langium';
+import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
 import type { CancellationToken } from 'vscode-languageserver';
 import { ast, type LikeC4LangiumDocument } from '../ast';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
 export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
     computeExports(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<AstNodeDescription[]>;
     computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<PrecomputedScopes>;
-    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): any;
+    protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
 }
 export {};
+//# sourceMappingURL=scope-computation.d.ts.map

package/dist/references/scope-computation.js

@@ -20,6 +20,11 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
           docExports.push(this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document));
         }
       }
+      for (const spec of specification.relationships) {
+        if (spec.kind && !isEmpty(spec.kind.name)) {
+          docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
+        }
+      }
     }
     if (model && model.elements.length > 0) {
       for (const elAst of model.elements) {

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

@@ -10,9 +10,10 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     private scopeExtendElement;
     private scopeElementView;
     getScope(context: ReferenceInfo): Scope;
-    protected computeScope(node: AstNode, referenceType: string): Stream<AstNodeDescription>;
+    protected computeScope(node: AstNode, referenceType: string): Scope;
     /**
      * Create a global scope filtered for the given reference type.
      */
     protected getGlobalScope(referenceType: string): Scope;
 }
+//# sourceMappingURL=scope-provider.d.ts.map

package/dist/shared/WorkspaceManager.d.ts

@@ -8,5 +8,6 @@ export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      * your language, which can be either loaded from provided files or constructed in memory.
      */
     protected loadAdditionalDocuments(_folders: WorkspaceFolder[], _collector: (document: LangiumDocument) => void): Promise<void>;
-    workspace(): any;
+    workspace(): WorkspaceFolder | null;
 }
+//# sourceMappingURL=WorkspaceManager.d.ts.map

package/dist/shared/index.d.ts

@@ -1 +1,2 @@
 export * from './WorkspaceManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/index.d.ts

@@ -1 +1,2 @@
 export * from './testServices';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/testServices.d.ts

@@ -1,15 +1,16 @@
 import type { LikeC4LangiumDocument } from '../ast';
 export declare function createTestServices(workspace?: string): {
-    services: any;
+    services: import("../module").LikeC4Services;
     parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;
-        diagnostics: any;
-        errors: any;
+        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        errors: string[];
     }>;
     validateAll: () => Promise<{
-        diagnostics: any;
-        errors: any;
+        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        errors: string[];
     }>;
-    buildModel: () => Promise<any>;
+    buildModel: () => Promise<import("@likec4/core").LikeC4Model>;
 };
+//# sourceMappingURL=testServices.d.ts.map

package/dist/test/testServices.js

@@ -13,7 +13,9 @@ export function createTestServices(workspace = "file:///test/workspace") {
     name: "test",
     uri: workspaceUri.toString()
   };
-  const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+  const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([
+    workspaceFolder
+  ]);
   void initPromise.finally(() => {
     Object.assign(services.shared.workspace.WorkspaceManager, {
       folders: [workspaceFolder]
@@ -22,8 +24,15 @@ export function createTestServices(workspace = "file:///test/workspace") {
   let documentIndex = 1;
   const parse = async (input, uri) => {
     await initPromise;
-    const docUri = Utils.resolvePath(workspaceUri, "./src/", uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`);
-    const document = services.shared.workspace.LangiumDocumentFactory.fromString(stripIndent(input), docUri);
+    const docUri = Utils.resolvePath(
+      workspaceUri,
+      "./src/",
+      uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`
+    );
+    const document = services.shared.workspace.LangiumDocumentFactory.fromString(
+      stripIndent(input),
+      docUri
+    );
     langiumDocuments.addDocument(document);
     await documentBuilder.build([document], { validation: false });
     return document;

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
 import type { LangiumDocument } from 'langium';
 export declare const printDocs: (docs: LangiumDocument[]) => string;
 export declare function queueMicrotask(cb: () => void): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/validation/element.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="react" />
+import { type ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const elementChecks: (services: LikeC4Services) => ValidationCheck<ast.Element>;
+//# sourceMappingURL=element.d.ts.map

package/dist/validation/element.js

@@ -12,19 +12,23 @@ export const elementChecks = (services) => {
     }
     const withSameFqn = fqnIndex.byFqn(fqn).filter((v) => v.el !== el).head();
     if (withSameFqn) {
-      accept("error", `Duplicate element name ${el.name !== fqn ? el.name + " (" + fqn + ")" : el.name}`, {
-        node: el,
-        property: "name",
-        relatedInformation: [
-          {
-            location: {
-              range: withSameFqn.el.$cstNode.range,
-              uri: getDocument(withSameFqn.el).uri.toString()
-            },
-            message: `Already defined here`
-          }
-        ]
-      });
+      accept(
+        "error",
+        `Duplicate element name ${el.name !== fqn ? el.name + " (" + fqn + ")" : el.name}`,
+        {
+          node: el,
+          property: "name",
+          relatedInformation: [
+            {
+              location: {
+                range: withSameFqn.el.$cstNode.range,
+                uri: getDocument(withSameFqn.el).uri.toString()
+              },
+              message: `Already defined here`
+            }
+          ]
+        }
+      );
     }
   };
 };

package/dist/validation/index.d.ts

@@ -1,2 +1,3 @@
 import type { LikeC4Services } from '../module';
 export declare function registerValidationChecks(services: LikeC4Services): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/index.js

@@ -2,7 +2,7 @@ import * as vscodeUri from "vscode-uri";
 import { logger } from "../logger.js";
 import { elementChecks } from "./element.js";
 import { relationChecks } from "./relation.js";
-import { elementKindChecks, tagChecks } from "./specification.js";
+import { elementKindChecks, tagChecks, relationshipChecks } from "./specification.js";
 import { viewChecks } from "./view.js";
 export function registerValidationChecks(services) {
   logger.info("registerValidationChecks");
@@ -12,7 +12,8 @@ export function registerValidationChecks(services) {
     Element: elementChecks(services),
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
-    Tag: tagChecks(services)
+    Tag: tagChecks(services),
+    RelationshipKind: relationshipChecks(services)
   });
   const connection = services.shared.lsp.Connection;
   if (connection) {

package/dist/validation/relation.d.ts

@@ -1,3 +1,5 @@
+import type { ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const relationChecks: (services: LikeC4Services) => ValidationCheck<ast.Relation>;
+//# sourceMappingURL=relation.d.ts.map

package/dist/validation/relation.js

@@ -19,10 +19,14 @@ export const relationChecks = (services) => {
         sourceEl = elementRef(el.source);
       } else {
         if (!ast.isElementBody(el.$container)) {
-          accept("error", "Invalid relation, expected to have source defined or be inside the element", {
-            node: el,
-            keyword: "->"
-          });
+          accept(
+            "error",
+            "Invalid relation, expected to have source defined or be inside the element",
+            {
+              node: el,
+              keyword: "->"
+            }
+          );
         } else {
           sourceEl = el.$container.$container;
         }

package/dist/validation/specification.d.ts

@@ -1,4 +1,7 @@
+import type { ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const elementKindChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
 export declare const tagChecks: (services: LikeC4Services) => ValidationCheck<ast.Tag>;
+export declare const relationshipChecks: (services: LikeC4Services) => ValidationCheck<ast.RelationshipKind>;
+//# sourceMappingURL=specification.d.ts.map

package/dist/validation/specification.js

@@ -23,3 +23,15 @@ export const tagChecks = (services) => {
     }
   };
 };
+export const relationshipChecks = (services) => {
+  const index = services.shared.workspace.IndexManager;
+  return (node, accept) => {
+    const sameKinds = index.allElements(ast.RelationshipKind).filter((n) => n.name === node.name).limit(2).count();
+    if (sameKinds > 1) {
+      accept("error", `Duplicate RelationshipKind '${node.name}'`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};

package/dist/validation/view.d.ts

@@ -1,3 +1,5 @@
+import type { ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementView>;
+//# sourceMappingURL=view.d.ts.map

package/dist/view-utils/assignNavigateTo.d.ts

@@ -0,0 +1,3 @@
+import type { ComputedView } from '@likec4/core';
+export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;
+//# sourceMappingURL=assignNavigateTo.d.ts.map

package/dist/view-utils/assignNavigateTo.js

@@ -0,0 +1,20 @@
+import { find } from "remeda";
+export function assignNavigateTo(views) {
+  const allElementViews = /* @__PURE__ */ new Map();
+  for (const v of views) {
+    if (v.viewOf && !v.extends) {
+      const viewsOf = allElementViews.get(v.viewOf) ?? [];
+      viewsOf.push(v.id);
+      allElementViews.set(v.viewOf, viewsOf);
+    }
+  }
+  for (const { id, nodes } of views) {
+    for (const node of nodes) {
+      const navigateTo = find(allElementViews.get(node.id) ?? [], (v) => v !== id);
+      if (navigateTo) {
+        node.navigateTo = navigateTo;
+      }
+    }
+  }
+  return views;
+}

package/dist/view-utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './assignNavigateTo';
+export * from './resolve-extended-views';
+export * from './resolve-relative-paths';
+//# sourceMappingURL=index.d.ts.map

package/dist/view-utils/index.js

@@ -0,0 +1,3 @@
+export * from "./assignNavigateTo.js";
+export * from "./resolve-extended-views.js";
+export * from "./resolve-relative-paths.js";

package/dist/view-utils/resolve-extended-views.d.ts

@@ -0,0 +1,7 @@
+import { type ElementView } from '@likec4/core';
+/**
+ * Resolve rules of extended views
+ * (Removes invalid views)
+ */
+export declare function resolveRulesExtendedViews<V extends Record<any, ElementView>>(unresolvedViews: V): V;
+//# sourceMappingURL=resolve-extended-views.d.ts.map

package/dist/view-utils/resolve-extended-views.js

@@ -0,0 +1,41 @@
+import graphlib from "@dagrejs/graphlib";
+import { isExtendsElementView } from "@likec4/core";
+const { Graph, alg } = graphlib;
+export function resolveRulesExtendedViews(unresolvedViews) {
+  const g = new Graph({
+    directed: true,
+    multigraph: false,
+    compound: false
+  });
+  for (const view of Object.values(unresolvedViews)) {
+    g.setNode(view.id);
+    if (isExtendsElementView(view)) {
+      g.setEdge(view.id, view.extends);
+    }
+  }
+  const cycles = alg.findCycles(g);
+  if (cycles.length > 0) {
+    cycles.flat().forEach((id) => g.removeNode(id));
+  }
+  const ordered = alg.postorder(g, g.sources());
+  return ordered.reduce((acc, id) => {
+    const view = unresolvedViews[id];
+    if (!view) {
+      return acc;
+    }
+    if (isExtendsElementView(view)) {
+      const extendsFrom = acc[view.extends];
+      if (!extendsFrom) {
+        return acc;
+      }
+      return Object.assign(acc, {
+        [view.id]: {
+          ...extendsFrom,
+          ...view,
+          rules: [...extendsFrom.rules, ...view.rules]
+        }
+      });
+    }
+    return Object.assign(acc, { [view.id]: view });
+  }, {});
+}

package/dist/view-utils/resolve-relative-paths.d.ts

@@ -0,0 +1,3 @@
+import type { ElementView } from '@likec4/core';
+export declare function resolveRelativePaths(views: ElementView[]): ElementView[];
+//# sourceMappingURL=resolve-relative-paths.d.ts.map

package/dist/view-utils/resolve-relative-paths.js

@@ -0,0 +1,76 @@
+import { uniq, zip } from "rambdax";
+import { hasAtLeast } from "remeda";
+import { invariant } from "@likec4/core";
+function commonAncestorPath(views, sep = "/") {
+  if (views.length <= 1)
+    return "";
+  const uniqURIs = uniq(views.flatMap(({ docUri }) => docUri ? [docUri] : []));
+  if (uniqURIs.length === 0)
+    return "";
+  if (uniqURIs.length === 1) {
+    invariant(hasAtLeast(uniqURIs, 1));
+    return new URL(uniqURIs[0]).pathname;
+  }
+  invariant(hasAtLeast(uniqURIs, 2), "Expected at least 2 unique URIs");
+  const [baseUri, ...tail] = uniqURIs;
+  const parts = new URL(baseUri).pathname.split(sep);
+  let endOfPrefix = parts.length;
+  for (const uri of tail) {
+    if (uri === baseUri) {
+      continue;
+    }
+    const compare = new URL(uri).pathname.split(sep);
+    for (let i = 0; i < endOfPrefix; i++) {
+      if (compare[i] !== parts[i]) {
+        endOfPrefix = i;
+      }
+    }
+    if (endOfPrefix === 0)
+      return "";
+  }
+  const prefix = parts.slice(0, endOfPrefix).join(sep);
+  return prefix.endsWith(sep) ? prefix : prefix + sep;
+}
+export function resolveRelativePaths(views) {
+  const commonPrefix = commonAncestorPath(views);
+  return views.map((view) => {
+    if (!view.docUri) {
+      return {
+        ...view,
+        parts: []
+      };
+    }
+    const path = new URL(view.docUri).pathname;
+    const parts = path.replace(commonPrefix, "").split("/");
+    parts.pop();
+    return {
+      ...view,
+      parts
+    };
+  }).sort((a, b) => {
+    if (a.parts.length === b.parts.length) {
+      if (a.parts.length === 0) {
+        return 0;
+      }
+      if (a.parts.length === 1 && hasAtLeast(a.parts, 1) && hasAtLeast(b.parts, 1)) {
+        return a.parts[0].localeCompare(b.parts[0]);
+      }
+      for (const [_a, _b] of zip(a.parts, b.parts)) {
+        const compare = _a.localeCompare(_b);
+        if (compare !== 0) {
+          return compare;
+        }
+      }
+      return 0;
+    }
+    return a.parts.length - b.parts.length;
+  }).map(({ parts, ...view }) => {
+    if (view.docUri) {
+      return {
+        ...view,
+        relativePath: parts.join("/")
+      };
+    }
+    return view;
+  });
+}