@likec4/language-server 0.37.1 → 0.41.0

package/dist/shared/WorkspaceManager.d.ts

@@ -1,14 +1,13 @@
-import type { LangiumDocument, LangiumDocumentFactory, LangiumSharedServices } from 'langium';
+import type { LangiumDocument } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
 import type { WorkspaceFolder } from 'vscode-languageserver';
 export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-    protected readonly documentFactory: LangiumDocumentFactory;
-    constructor(services: LangiumSharedServices);
     /**
      * Load all additional documents that shall be visible in the context of the given workspace
      * folders and add them to the collector. This can be used to include built-in libraries of
      * 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(): WorkspaceFolder | null;
 }
 //# sourceMappingURL=WorkspaceManager.d.ts.map

package/dist/shared/WorkspaceManager.js

@@ -1,18 +1,15 @@
-import { DefaultWorkspaceManager } from 'langium';
+import { nonNullable } from "@likec4/core";
+import { DefaultWorkspaceManager } from "langium";
 export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-    documentFactory;
-    constructor(services) {
-        super(services);
-        this.documentFactory = services.workspace.LangiumDocumentFactory;
-    }
-    /**
-     * Load all additional documents that shall be visible in the context of the given workspace
-     * folders and add them to the collector. This can be used to include built-in libraries of
-     * your language, which can be either loaded from provided files or constructed in memory.
-     */
-    loadAdditionalDocuments(_folders, _collector) {
-        // collector(this.documentFactory.fromString(builtin.specification.document, URI.parse(builtin.specification.uri)))
-        return Promise.resolve();
-    }
+  /**
+   * Load all additional documents that shall be visible in the context of the given workspace
+   * folders and add them to the collector. This can be used to include built-in libraries of
+   * your language, which can be either loaded from provided files or constructed in memory.
+   */
+  loadAdditionalDocuments(_folders, _collector) {
+    return Promise.resolve();
+  }
+  workspace() {
+    return this.folders && this.folders.length > 0 ? nonNullable(this.folders[0]) : null;
+  }
 }
-//# sourceMappingURL=WorkspaceManager.js.map

package/dist/shared/index.js

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

package/dist/test/index.js

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

package/dist/test/testServices.js

@@ -1,65 +1,77 @@
-import { createLanguageServices } from '../module';
-import { EmptyFileSystem } from 'langium';
-import { URI, Utils } from 'vscode-uri';
-import stripIndent from 'strip-indent';
-export function createTestServices(workspace = 'file:///test/workspace') {
-    const services = createLanguageServices(EmptyFileSystem).likec4;
-    const metaData = services.LanguageMetaData;
-    const langiumDocuments = services.shared.workspace.LangiumDocuments;
-    const documentBuilder = services.shared.workspace.DocumentBuilder;
-    const modelBuilder = services.likec4.ModelBuilder;
-    const workspaceUri = URI.parse(workspace);
-    const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([
-        {
-            name: 'test',
-            uri: workspaceUri.toString()
-        }
-    ]);
-    let documentIndex = 1;
-    const parse = async (input, uri) => {
-        await initPromise;
-        const docUri = Utils.joinPath(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;
-    };
-    const validate = async (input, uri) => {
-        await initPromise;
-        const document = typeof input === 'string' ? await parse(input, uri) : input;
-        await documentBuilder.build([document], { validation: true });
-        const diagnostics = document.diagnostics ?? [];
-        const errors = diagnostics.map(d => d.message);
-        return {
-            document,
-            diagnostics,
-            errors
-        };
-    };
-    const validateAll = async () => {
-        await initPromise;
-        const docs = langiumDocuments.all.toArray();
-        await documentBuilder.build(docs, { validation: true });
-        const diagnostics = docs.flatMap(doc => doc.diagnostics ?? []);
-        const errors = diagnostics.map(d => d.message);
-        return {
-            diagnostics,
-            errors
-        };
-    };
-    const buildModel = async () => {
-        await validateAll();
-        const model = modelBuilder.buildModel();
-        if (!model)
-            throw new Error('No model found');
-        return model;
+import { createLanguageServices } from "../module.js";
+import { EmptyFileSystem } from "langium";
+import { URI, Utils } from "vscode-uri";
+import stripIndent from "strip-indent";
+export function createTestServices(workspace = "file:///test/workspace") {
+  const services = createLanguageServices(EmptyFileSystem).likec4;
+  const metaData = services.LanguageMetaData;
+  const langiumDocuments = services.shared.workspace.LangiumDocuments;
+  const documentBuilder = services.shared.workspace.DocumentBuilder;
+  const modelBuilder = services.likec4.ModelBuilder;
+  const workspaceUri = URI.parse(workspace);
+  const workspaceFolder = {
+    name: "test",
+    uri: workspaceUri.toString()
+  };
+  const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([
+    workspaceFolder
+  ]);
+  void initPromise.finally(() => {
+    Object.assign(services.shared.workspace.WorkspaceManager, {
+      folders: [workspaceFolder]
+    });
+  });
+  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
+    );
+    langiumDocuments.addDocument(document);
+    await documentBuilder.build([document], { validation: false });
+    return document;
+  };
+  const validate = async (input, uri) => {
+    await initPromise;
+    const document = typeof input === "string" ? await parse(input, uri) : input;
+    await documentBuilder.build([document], { validation: true });
+    const diagnostics = document.diagnostics ?? [];
+    const errors = diagnostics.map((d) => d.message);
+    return {
+      document,
+      diagnostics,
+      errors
     };
+  };
+  const validateAll = async () => {
+    await initPromise;
+    const docs = langiumDocuments.all.toArray();
+    await documentBuilder.build(docs, { validation: true });
+    const diagnostics = docs.flatMap((doc) => doc.diagnostics ?? []);
+    const errors = diagnostics.map((d) => d.message);
     return {
-        services,
-        parse,
-        validate,
-        validateAll,
-        buildModel
+      diagnostics,
+      errors
     };
+  };
+  const buildModel = async () => {
+    await validateAll();
+    const model = modelBuilder.buildModel();
+    if (!model)
+      throw new Error("No model found");
+    return model;
+  };
+  return {
+    services,
+    parse,
+    validate,
+    validateAll,
+    buildModel
+  };
 }
-//# sourceMappingURL=testServices.js.map

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/utils.js

@@ -1,3 +1,4 @@
-import { Utils } from 'vscode-uri';
-export const printDocs = (docs) => docs.map(d => '  - ' + Utils.basename(d.uri)).join('\n');
-//# sourceMappingURL=utils.js.map
+export const printDocs = (docs) => docs.map((d) => "  - " + d.uri.path).join("\n");
+export function queueMicrotask(cb) {
+  return Promise.resolve().then(cb);
+}

package/dist/validation/element.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { type ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';

package/dist/validation/element.js

@@ -1,41 +1,34 @@
-import { getDocument } from 'langium';
+import { getDocument } from "langium";
 export const elementChecks = (services) => {
-    const fqnIndex = services.likec4.FqnIndex;
-    return (el, accept) => {
-        const fqn = fqnIndex.getFqn(el);
-        if (!fqn) {
-            accept('error', 'Not indexed element', {
-                node: el,
-                property: 'name'
-            });
-            return;
+  const fqnIndex = services.likec4.FqnIndex;
+  return (el, accept) => {
+    const fqn = fqnIndex.getFqn(el);
+    if (!fqn) {
+      accept("error", "Not indexed element", {
+        node: el,
+        property: "name"
+      });
+      return;
+    }
+    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`
+            }
+          ]
         }
-        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`
-                    }
-                ]
-            });
-        }
-        // for (let i = 3; i < el.props.length; i++) {
-        //   accept('error', `Too many properties, max 3 allowed`, {
-        //     node: el,
-        //     property: 'props',
-        //     index: i
-        //   })
-        // }
-    };
+      );
+    }
+  };
 };
-//# sourceMappingURL=element.js.map

package/dist/validation/index.js

@@ -1,49 +1,40 @@
-import { Utils } from 'vscode-uri';
-import { logger } from '../logger';
-import { elementChecks } from './element';
-import { relationChecks } from './relation';
-import { elementKindChecks, tagChecks } from './specification';
-import { viewChecks } from './view';
+import * as vscodeUri from "vscode-uri";
+import { logger } from "../logger.js";
+import { elementChecks } from "./element.js";
+import { relationChecks } from "./relation.js";
+import { elementKindChecks, tagChecks, relationshipChecks } from "./specification.js";
+import { viewChecks } from "./view.js";
 export function registerValidationChecks(services) {
-    logger.info('registerValidationChecks');
-    const registry = services.validation.ValidationRegistry;
-    // const checks: ValidationChecks = {
-    // Element: validator.checkElementNameDuplicates,
-    // Tag: validator.checkTagDuplicates,
-    // ElementKind: elementKindChecks(services),
-    // ElementStyleProperty: validator.checkElementStyleProperty,
-    // View: validator.checkViewNameDuplicates,
-    // ColorStyleProperty: validator.checkColorStyleProperty,
-    // }
-    registry.register({
-        ElementView: viewChecks(services),
-        Element: elementChecks(services),
-        ElementKind: elementKindChecks(services),
-        Relation: relationChecks(services),
-        Tag: tagChecks(services)
-    });
-    const connection = services.shared.lsp.Connection;
-    if (connection) {
-        logger.info('registerValidationChecks');
-        // wokraround for bug in langium
-        services.shared.workspace.DocumentBuilder.onUpdate((changed, deleted) => {
-            const message = [`[DocumentBuilder.onUpdate]`];
-            if (changed.length > 0) {
-                message.push(` changed:`);
-                changed.forEach(u => message.push(`  - ${Utils.basename(u)}`));
-            }
-            if (deleted.length > 0) {
-                message.push(` deleted:`);
-                deleted.forEach(u => message.push(`  - ${Utils.basename(u)}`));
-            }
-            logger.debug(message.join('\n'));
-            for (const uri of deleted) {
-                void connection.sendDiagnostics({
-                    uri: uri.toString(),
-                    diagnostics: []
-                });
-            }
+  logger.info("registerValidationChecks");
+  const registry = services.validation.ValidationRegistry;
+  registry.register({
+    ElementView: viewChecks(services),
+    Element: elementChecks(services),
+    ElementKind: elementKindChecks(services),
+    Relation: relationChecks(services),
+    Tag: tagChecks(services),
+    RelationshipKind: relationshipChecks(services)
+  });
+  const connection = services.shared.lsp.Connection;
+  if (connection) {
+    logger.info("registerValidationChecks");
+    services.shared.workspace.DocumentBuilder.onUpdate((changed, deleted) => {
+      const message = [`[DocumentBuilder.onUpdate]`];
+      if (changed.length > 0) {
+        message.push(` changed:`);
+        changed.forEach((u) => message.push(`  - ${vscodeUri.Utils.basename(u)}`));
+      }
+      if (deleted.length > 0) {
+        message.push(` deleted:`);
+        deleted.forEach((u) => message.push(`  - ${vscodeUri.Utils.basename(u)}`));
+      }
+      logger.debug(message.join("\n"));
+      for (const uri of deleted) {
+        void connection.sendDiagnostics({
+          uri: uri.toString(),
+          diagnostics: []
         });
-    }
+      }
+    });
+  }
 }
-//# sourceMappingURL=index.js.map

package/dist/validation/relation.js

@@ -1,50 +1,50 @@
-import { isSameHierarchy } from '@likec4/core';
-import { ast } from '../ast';
-import { elementRef } from '../elementRef';
-import { logError } from '../logger';
+import { isSameHierarchy } from "@likec4/core";
+import { ast } from "../ast.js";
+import { elementRef } from "../elementRef.js";
+import { logError } from "../logger.js";
 export const relationChecks = (services) => {
-    const fqnIndex = services.likec4.FqnIndex;
-    return (el, accept) => {
-        try {
-            const targetEl = elementRef(el.target);
-            const target = targetEl && fqnIndex.getFqn(targetEl);
-            if (!target) {
-                accept('error', 'Target not found (not parsed/indexed yet)', {
-                    node: el,
-                    property: 'target'
-                });
+  const fqnIndex = services.likec4.FqnIndex;
+  return (el, accept) => {
+    try {
+      const targetEl = elementRef(el.target);
+      const target = targetEl && fqnIndex.getFqn(targetEl);
+      if (!target) {
+        accept("error", "Target not found (not parsed/indexed yet)", {
+          node: el,
+          property: "target"
+        });
+      }
+      let sourceEl;
+      if ("source" in el) {
+        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: "->"
             }
-            let sourceEl;
-            if ('source' in el) {
-                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: '->'
-                    });
-                }
-                else {
-                    sourceEl = el.$container.$container;
-                }
-            }
-            const source = sourceEl && fqnIndex.getFqn(sourceEl);
-            if (sourceEl && !source) {
-                accept('error', 'Source not found (not parsed/indexed yet)', {
-                    node: el,
-                    property: 'source'
-                });
-            }
-            if (source && target && isSameHierarchy(source, target)) {
-                return accept('error', 'Invalid parent-child relationship', {
-                    node: el
-                });
-            }
-        }
-        catch (e) {
-            logError(e);
+          );
+        } else {
+          sourceEl = el.$container.$container;
         }
-    };
+      }
+      const source = sourceEl && fqnIndex.getFqn(sourceEl);
+      if (sourceEl && !source) {
+        accept("error", "Source not found (not parsed/indexed yet)", {
+          node: el,
+          property: "source"
+        });
+      }
+      if (source && target && isSameHierarchy(source, target)) {
+        return accept("error", "Invalid parent-child relationship", {
+          node: el
+        });
+      }
+    } catch (e) {
+      logError(e);
+    }
+  };
 };
-//# sourceMappingURL=relation.js.map

package/dist/validation/specification.d.ts

@@ -3,4 +3,5 @@ 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

@@ -1,34 +1,37 @@
-import { ast } from '../ast';
+import { ast } from "../ast.js";
 export const elementKindChecks = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return (node, accept) => {
-        const sameKinds = index
-            .allElements(ast.ElementKind)
-            .filter(n => n.name === node.name)
-            .limit(2)
-            .count();
-        if (sameKinds > 1) {
-            accept('error', `Duplicate element kind '${node.name}'`, {
-                node: node,
-                property: 'name'
-            });
-        }
-    };
+  const index = services.shared.workspace.IndexManager;
+  return (node, accept) => {
+    const sameKinds = index.allElements(ast.ElementKind).filter((n) => n.name === node.name).limit(2).count();
+    if (sameKinds > 1) {
+      accept("error", `Duplicate element kind '${node.name}'`, {
+        node,
+        property: "name"
+      });
+    }
+  };
 };
 export const tagChecks = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return (node, accept) => {
-        const sameKinds = index
-            .allElements(ast.Tag)
-            .filter(n => n.name === node.name)
-            .limit(2)
-            .count();
-        if (sameKinds > 1) {
-            accept('error', `Duplicate tag '${node.name}'`, {
-                node: node,
-                property: 'name'
-            });
-        }
-    };
+  const index = services.shared.workspace.IndexManager;
+  return (node, accept) => {
+    const sameKinds = index.allElements(ast.Tag).filter((n) => n.name === node.name).limit(2).count();
+    if (sameKinds > 1) {
+      accept("error", `Duplicate tag '${node.name}'`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};
+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"
+      });
+    }
+  };
 };
-//# sourceMappingURL=specification.js.map

package/dist/validation/view.js

@@ -1,24 +1,18 @@
-import { ast } from '../ast';
+import { ast } from "../ast.js";
 export const viewChecks = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return (el, accept) => {
-        if (el.extends) {
-            // TODO: circular dependency check
-        }
-        if (!el.name) {
-            return;
-        }
-        const anotherViews = index
-            .allElements(ast.View)
-            .filter(n => n.name === el.name)
-            .limit(2)
-            .count();
-        if (anotherViews > 1) {
-            accept('error', `Duplicate view '${el.name}'`, {
-                node: el,
-                property: 'name'
-            });
-        }
-    };
+  const index = services.shared.workspace.IndexManager;
+  return (el, accept) => {
+    if (el.extends) {
+    }
+    if (!el.name) {
+      return;
+    }
+    const anotherViews = index.allElements(ast.View).filter((n) => n.name === el.name).limit(2).count();
+    if (anotherViews > 1) {
+      accept("error", `Duplicate view '${el.name}'`, {
+        node: el,
+        property: "name"
+      });
+    }
+  };
 };
-//# sourceMappingURL=view.js.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