@likec4/language-server 1.17.1 → 1.19.0

package/dist/validation/index.js

@@ -0,0 +1,152 @@
+import { isNullish } from "remeda";
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+import { ast } from "../ast.js";
+import { logger } from "../logger.js";
+import { deployedInstanceChecks, deploymentNodeChecks, deploymentRelationChecks } from "./deployment-checks.js";
+import { dynamicViewRulePredicate } from "./dynamic-view-rule.js";
+import { dynamicViewStep } from "./dynamic-view-step.js";
+import { elementChecks } from "./element.js";
+import { iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChecks } from "./property-checks.js";
+import { relationBodyChecks, relationChecks } from "./relation.js";
+import {
+  elementKindChecks,
+  globalPredicateChecks,
+  globalsChecks,
+  globalStyleIdChecks,
+  modelRuleChecks,
+  relationshipChecks,
+  specificationRuleChecks,
+  tagChecks
+} from "./specification.js";
+import { viewChecks } from "./view.js";
+import {
+  elementPredicateWithChecks,
+  expandElementExprChecks,
+  fqnRefExprChecks,
+  incomingExpressionChecks,
+  outgoingExpressionChecks,
+  relationExprChecks,
+  relationPredicateWithChecks
+} from "./view-predicates/index.js";
+function validatableAstNodeGuards(predicates) {
+  return (n) => predicates.some((p) => p(n));
+}
+const isValidatableAstNode = validatableAstNodeGuards([
+  ast.isGlobals,
+  ast.isGlobalPredicateGroup,
+  ast.isGlobalDynamicPredicateGroup,
+  ast.isGlobalStyle,
+  ast.isGlobalStyleGroup,
+  ast.isDynamicViewPredicateIterator,
+  ast.isElementPredicateWith,
+  ast.isRelationPredicateWith,
+  ast.isElementExpression,
+  ast.isRelationExpression,
+  ast.isDynamicViewParallelSteps,
+  ast.isDynamicViewStep,
+  ast.isDeploymentViewRule,
+  ast.isDeploymentViewRulePredicate,
+  ast.isExpressionV2,
+  ast.isRelationExpr,
+  ast.isFqnRefExpr,
+  ast.isViewProperty,
+  ast.isStyleProperty,
+  ast.isPredicate,
+  ast.isTags,
+  ast.isViewRule,
+  ast.isDynamicViewRule,
+  ast.isLikeC4View,
+  ast.isViewRuleStyleOrGlobalRef,
+  ast.isDeployedInstance,
+  ast.isDeploymentNode,
+  ast.isDeploymentRelation,
+  ast.isRelationshipStyleProperty,
+  ast.isMetadataProperty,
+  ast.isRelation,
+  ast.isElementProperty,
+  ast.isStringProperty,
+  ast.isNavigateToProperty,
+  ast.isElement,
+  ast.isExtendElement,
+  ast.isSpecificationElementKind,
+  ast.isSpecificationRelationshipKind,
+  ast.isSpecificationDeploymentNodeKind,
+  ast.isSpecificationTag,
+  ast.isSpecificationColor,
+  ast.isSpecificationRule
+]);
+const findInvalidContainer = (node) => {
+  let nd = node;
+  while (nd && !ast.isLikeC4Grammar(nd)) {
+    if (isValidatableAstNode(nd)) {
+      return nd;
+    }
+    nd = nd.$container;
+  }
+  return void 0;
+};
+export function checksFromDiagnostics(doc) {
+  const errors = doc.diagnostics?.filter((d) => d.severity === DiagnosticSeverity.Error) ?? [];
+  const invalidNodes = /* @__PURE__ */ new WeakSet();
+  for (const { node } of errors) {
+    if (isNullish(node) || invalidNodes.has(node)) {
+      continue;
+    }
+    invalidNodes.add(node);
+    const container = findInvalidContainer(node);
+    if (container) {
+      invalidNodes.add(container);
+    }
+  }
+  const isValid = (n) => !invalidNodes.has(n);
+  return {
+    isValid,
+    invalidNodes
+  };
+}
+export function registerValidationChecks(services) {
+  logger.debug("registerValidationChecks");
+  const registry = services.validation.ValidationRegistry;
+  registry.register({
+    DeployedInstance: deployedInstanceChecks(services),
+    DeploymentNode: deploymentNodeChecks(services),
+    DeploymentRelation: deploymentRelationChecks(services),
+    FqnRefExpr: fqnRefExprChecks(services),
+    RelationExpr: relationExprChecks(services),
+    NotesProperty: notesPropertyRuleChecks(services),
+    OpacityProperty: opacityPropertyRuleChecks(services),
+    IconProperty: iconPropertyRuleChecks(services),
+    SpecificationRule: specificationRuleChecks(services),
+    Model: modelRuleChecks(services),
+    Globals: globalsChecks(services),
+    GlobalPredicateGroup: globalPredicateChecks(services),
+    GlobalDynamicPredicateGroup: globalPredicateChecks(services),
+    GlobalStyleId: globalStyleIdChecks(services),
+    DynamicViewStep: dynamicViewStep(services),
+    LikeC4View: viewChecks(services),
+    Element: elementChecks(services),
+    ElementKind: elementKindChecks(services),
+    Relation: relationChecks(services),
+    RelationBody: relationBodyChecks(services),
+    Tag: tagChecks(services),
+    DynamicViewPredicateIterator: dynamicViewRulePredicate(services),
+    ElementPredicateWith: elementPredicateWithChecks(services),
+    RelationPredicateWith: relationPredicateWithChecks(services),
+    ExpandElementExpression: expandElementExprChecks(services),
+    RelationshipKind: relationshipChecks(services),
+    IncomingRelationExpression: incomingExpressionChecks(services),
+    OutgoingRelationExpression: outgoingExpressionChecks(services)
+  });
+  const connection = services.shared.lsp.Connection;
+  if (connection) {
+    services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
+      for (const uri of deleted) {
+        logger.debug(`clear diagnostics for deleted ${uri.path}`);
+        void connection.sendDiagnostics({
+          uri: uri.toString(),
+          diagnostics: []
+        });
+      }
+    });
+  }
+}

package/dist/validation/property-checks.d.ts

@@ -0,0 +1,6 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const opacityPropertyRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.OpacityProperty>;
+export declare const iconPropertyRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.IconProperty>;
+export declare const notesPropertyRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.NotesProperty>;

package/dist/validation/property-checks.js

@@ -0,0 +1,38 @@
+import { AstUtils } from "langium";
+import { ast } from "../ast.js";
+export const opacityPropertyRuleChecks = (_) => {
+  return (node, accept) => {
+    const opacity = parseFloat(node.value);
+    if (isNaN(opacity) || opacity < 0 || opacity > 100) {
+      accept("warning", `Value ignored, must be between 0% and 100%`, {
+        node,
+        property: "value"
+      });
+    }
+  };
+};
+export const iconPropertyRuleChecks = (_) => {
+  return (node, accept) => {
+    const container = node.$container;
+    const anotherIcon = container.props.some((p) => ast.isIconProperty(p) && p !== node);
+    if (anotherIcon) {
+      accept("error", `Icon must be defined once`, {
+        node
+      });
+    }
+    if (ast.isElementStyleProperty(container) && ast.isElementBody(container.$container) && container.$container.props.some((p) => ast.isIconProperty(p))) {
+      accept("warning", `Redundant as icon defined on element`, {
+        node
+      });
+    }
+  };
+};
+export const notesPropertyRuleChecks = (_) => {
+  return (node, accept) => {
+    if (!AstUtils.hasContainerOfType(node, ast.isDynamicViewStep)) {
+      accept("error", `Notes can be defined only inside dynamic view`, {
+        node
+      });
+    }
+  };
+};

package/dist/validation/relation.d.ts

@@ -0,0 +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>;
+export declare const relationBodyChecks: (_services: LikeC4Services) => ValidationCheck<ast.RelationBody>;

package/dist/validation/relation.js

@@ -0,0 +1,56 @@
+import { isSameHierarchy } from "@likec4/core";
+import { isDefined } from "remeda";
+import { ast } from "../ast.js";
+import { elementRef } from "../utils/elementRef.js";
+import { tryOrLog } from "./_shared.js";
+export const relationChecks = (services) => {
+  const fqnIndex = services.likec4.FqnIndex;
+  return tryOrLog((el, accept) => {
+    const targetEl = elementRef(el.target);
+    const target = targetEl && fqnIndex.getFqn(targetEl);
+    if (!target) {
+      accept("error", "Target not resolved", {
+        node: el,
+        property: "target"
+      });
+    }
+    let sourceEl;
+    if (isDefined(el.source)) {
+      sourceEl = elementRef(el.source);
+      if (!sourceEl) {
+        return accept("error", "Source not resolved", {
+          node: el,
+          property: "source"
+        });
+      }
+    } else {
+      if (!ast.isElementBody(el.$container)) {
+        return accept("error", "Sourceless relation must be nested", {
+          node: el
+        });
+      }
+      sourceEl = el.$container.$container;
+    }
+    const source = fqnIndex.getFqn(sourceEl);
+    if (!source) {
+      accept("error", "Source not resolved", {
+        node: el
+      });
+    }
+    if (source && target && isSameHierarchy(source, target)) {
+      accept("error", "Invalid parent-child relationship", {
+        node: el
+      });
+    }
+  });
+};
+export const relationBodyChecks = (_services) => {
+  return tryOrLog((body, accept) => {
+    const relation = body.$container;
+    if (relation.tags?.values && body.tags?.values) {
+      accept("error", "Relation cannot have tags in both header and body", {
+        node: body.tags
+      });
+    }
+  });
+};

package/dist/validation/specification.d.ts

@@ -0,0 +1,11 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const specificationRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.SpecificationRule>;
+export declare const modelRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.Model>;
+export declare const globalsChecks: (_: LikeC4Services) => ValidationCheck<ast.Globals>;
+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>;
+export declare const globalPredicateChecks: (services: LikeC4Services) => ValidationCheck<ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup>;
+export declare const globalStyleIdChecks: (services: LikeC4Services) => ValidationCheck<ast.GlobalStyleId>;

package/dist/validation/specification.js

@@ -0,0 +1,136 @@
+import { AstUtils } from "langium";
+import { ast } from "../ast.js";
+import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
+export const specificationRuleChecks = (_) => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept("warning", `Prefer one specification per document`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};
+export const modelRuleChecks = (_) => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept("warning", `Prefer one model per document`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};
+export const globalsChecks = (_) => {
+  return (node, accept) => {
+    if (node.$containerIndex && node.$containerIndex > 0) {
+      accept("warning", `Prefer one global block per document`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};
+export const elementKindChecks = (services) => {
+  const index = services.shared.workspace.IndexManager;
+  return tryOrLog((node, accept) => {
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept("error", `Reserved word: ${node.name}`, {
+        node,
+        property: "name"
+      });
+    }
+    const sameKind = index.allElements(ast.ElementKind).filter((n) => n.name === node.name && n.node !== node).head();
+    if (sameKind) {
+      const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri;
+      accept("error", `Duplicate element kind '${node.name}'`, {
+        node,
+        property: "name",
+        ...isAnotherDoc && {
+          relatedInformation: [
+            {
+              location: {
+                range: sameKind.nameSegment.range,
+                uri: sameKind.documentUri.toString()
+              },
+              message: `conflicting definition`
+            }
+          ]
+        }
+      });
+    }
+  });
+};
+export const tagChecks = (services) => {
+  const index = services.shared.workspace.IndexManager;
+  return (node, accept) => {
+    const tagname = "#" + node.name;
+    const sameTag = index.allElements(ast.Tag).filter((n) => n.name === tagname && n.node !== node).head();
+    if (sameTag) {
+      const isAnotherDoc = sameTag.documentUri !== AstUtils.getDocument(node).uri;
+      accept(
+        "error",
+        `Duplicate tag '${node.name}'`,
+        {
+          node,
+          property: "name",
+          ...isAnotherDoc && {
+            relatedInformation: [
+              {
+                location: {
+                  range: sameTag.nameSegment.range,
+                  uri: sameTag.documentUri.toString()
+                },
+                message: `conflicting definition`
+              }
+            ]
+          }
+        }
+      );
+    }
+  };
+};
+export const relationshipChecks = (services) => {
+  const index = services.shared.workspace.IndexManager;
+  return (node, accept) => {
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept("error", `Reserved word: ${node.name}`, {
+        node,
+        property: "name"
+      });
+    }
+    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"
+      });
+    }
+  };
+};
+export const globalPredicateChecks = (services) => {
+  const index = services.shared.workspace.IndexManager;
+  return (node, accept) => {
+    const predicateGroups = index.allElements(ast.GlobalPredicateGroup);
+    const dynamicPredicateGroups = index.allElements(ast.GlobalDynamicPredicateGroup);
+    const sameName = predicateGroups.concat(dynamicPredicateGroups).filter((s) => s.name === node.name).limit(2).count();
+    if (sameName > 1) {
+      accept("error", `Duplicate GlobalPredicateGroup or GlobalDynamicPredicateGroup name '${node.name}'`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};
+export const globalStyleIdChecks = (services) => {
+  const index = services.shared.workspace.IndexManager;
+  return (node, accept) => {
+    const sameName = index.allElements(ast.GlobalStyleId).filter((s) => s.name === node.name).limit(2).count();
+    if (sameName > 1) {
+      accept("error", `Duplicate GlobalStyleId name '${node.name}'`, {
+        node,
+        property: "name"
+      });
+    }
+  };
+};

package/dist/validation/view-predicates/element-with.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../../ast';
+import type { LikeC4Services } from '../../module';
+export declare const elementPredicateWithChecks: (_services: LikeC4Services) => ValidationCheck<ast.ElementPredicateWith>;

package/dist/validation/view-predicates/element-with.js

@@ -0,0 +1,30 @@
+import { nonexhaustive } from "@likec4/core";
+import { AstUtils } from "langium";
+import { ast } from "../../ast.js";
+export const elementPredicateWithChecks = (_services) => {
+  return (el, accept) => {
+    const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate);
+    if (ast.isExcludePredicate(container)) {
+      accept("error", 'Invalid usage inside "exclude"', {
+        node: el
+      });
+    }
+    const subject = ast.isElementPredicateWhere(el.subject) ? el.subject.subject : el.subject;
+    switch (true) {
+      case ast.isElementRef(subject):
+      case ast.isElementDescedantsExpression(subject):
+      case ast.isExpandElementExpression(subject):
+      case ast.isWildcardExpression(subject):
+        return;
+      case ast.isElementKindExpression(subject):
+      case ast.isElementTagExpression(subject):
+        accept("error", "Invalid target (expect reference to specific element)", {
+          node: el,
+          property: "subject"
+        });
+        return;
+      default:
+        nonexhaustive(subject);
+    }
+  };
+};

package/dist/validation/view-predicates/expanded-element.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../../ast';
+import type { LikeC4Services } from '../../module';
+export declare const expandElementExprChecks: (_services: LikeC4Services) => ValidationCheck<ast.ExpandElementExpression>;

package/dist/validation/view-predicates/expanded-element.js

@@ -0,0 +1,11 @@
+import { AstUtils } from "langium";
+import { ast } from "../../ast.js";
+export const expandElementExprChecks = (_services) => {
+  return (el, accept) => {
+    if (AstUtils.hasContainerOfType(el, ast.isRelationExpression)) {
+      accept("warning", `Redundant usage, expand predicate resolves parent element only when used in relations`, {
+        node: el
+      });
+    }
+  };
+};

package/dist/validation/view-predicates/expression-v2.d.ts

@@ -0,0 +1,5 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../../ast';
+import type { LikeC4Services } from '../../module';
+export declare const relationExprChecks: (services: LikeC4Services) => ValidationCheck<ast.RelationExpr>;
+export declare const fqnRefExprChecks: (services: LikeC4Services) => ValidationCheck<ast.FqnRefExpr>;

package/dist/validation/view-predicates/expression-v2.js

@@ -0,0 +1,83 @@
+import { FqnExpr, FqnRef } from "@likec4/core";
+import { AstUtils } from "langium";
+import { isNonNullish, isNullish } from "remeda";
+import { ast } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
+export const relationExprChecks = (services) => {
+  const ModelParser = services.likec4.ModelParser;
+  return tryOrLog((node, accept) => {
+    if (node.$container.$type !== "DeploymentViewRulePredicateExpression") {
+      return;
+    }
+    const predicate = AstUtils.getContainerOfType(node, ast.isDeploymentViewRulePredicate);
+    if (!predicate || predicate.isInclude !== true) {
+      return;
+    }
+    const doc = AstUtils.getDocument(node);
+    const parser = ModelParser.forDocument(doc);
+    const ModelRefOnlyExclude = "Model reference is allowed in exclude predicate only";
+    if (ast.isDirectedRelationExpr(node)) {
+      if (FqnExpr.isModelRef(parser.parseFqnExpr(node.source.from))) {
+        accept("error", ModelRefOnlyExclude, {
+          node: node.source,
+          property: "from"
+        });
+      }
+      if (FqnExpr.isModelRef(parser.parseFqnExpr(node.target))) {
+        accept("error", ModelRefOnlyExclude, {
+          node,
+          property: "target"
+        });
+      }
+      return;
+    }
+    let expr;
+    if (ast.isIncomingRelationExpr(node)) {
+      expr = node.to;
+    } else if (ast.isOutgoingRelationExpr(node)) {
+      expr = node.from;
+    } else {
+      expr = node.inout.to;
+    }
+    if (FqnExpr.isModelRef(parser.parseFqnExpr(expr))) {
+      accept("error", ModelRefOnlyExclude, {
+        node
+      });
+      return;
+    }
+  });
+};
+export const fqnRefExprChecks = (services) => {
+  const ModelParser = services.likec4.ModelParser;
+  return tryOrLog((node, accept) => {
+    const referenceTo = node.ref.value.ref;
+    if (isNullish(referenceTo)) {
+      accept("error", "Invalid empty reference", {
+        node
+      });
+      return;
+    }
+    const doc = AstUtils.getDocument(node);
+    const expr = ModelParser.forDocument(doc).parseFqnRefExpr(node);
+    if (node.$container.$type === "DeploymentViewRulePredicateExpression") {
+      if (FqnExpr.isModelRef(expr)) {
+        accept("error", "Deployment view predicate must reference deployment model", {
+          node
+        });
+        return;
+      }
+      if (FqnExpr.isDeploymentRef(expr) && FqnRef.isInsideInstanceRef(expr.ref)) {
+        accept("error", "Must reference deployment nodes or instances, but not internals", {
+          node
+        });
+        return;
+      }
+    }
+    if (!ast.isDeploymentNode(referenceTo) && isNonNullish(node.selector)) {
+      accept("warning", `Selector '${node.selector}' applies to deployment nodes only, ignored here`, {
+        node,
+        property: "selector"
+      });
+    }
+  });
+};

package/dist/validation/view-predicates/incoming.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../../ast';
+import type { LikeC4Services } from '../../module';
+export declare const incomingExpressionChecks: (_services: LikeC4Services) => ValidationCheck<ast.IncomingRelationExpression>;

package/dist/validation/view-predicates/incoming.js

@@ -0,0 +1,15 @@
+import { AstUtils } from "langium";
+import { isNullish } from "remeda";
+import { ast } from "../../ast.js";
+export const incomingExpressionChecks = (_services) => {
+  return (el, accept) => {
+    if (ast.isWildcardExpression(el.to) && !ast.isInOutRelationExpression(el.$container)) {
+      const view = AstUtils.getContainerOfType(el, ast.isElementView);
+      if (isNullish(view?.viewOf)) {
+        accept("warning", "Predicate is ignored as it concerns all relationships", {
+          node: el
+        });
+      }
+    }
+  };
+};

package/dist/validation/view-predicates/index.d.ts

@@ -0,0 +1,6 @@
+export * from './element-with';
+export * from './expanded-element';
+export * from './expression-v2';
+export * from './incoming';
+export * from './outgoing';
+export * from './relation-with';

package/dist/validation/view-predicates/index.js

@@ -0,0 +1,6 @@
+export * from "./element-with.js";
+export * from "./expanded-element.js";
+export * from "./expression-v2.js";
+export * from "./incoming.js";
+export * from "./outgoing.js";
+export * from "./relation-with.js";

package/dist/validation/view-predicates/outgoing.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../../ast';
+import type { LikeC4Services } from '../../module';
+export declare const outgoingExpressionChecks: (_services: LikeC4Services) => ValidationCheck<ast.OutgoingRelationExpression>;

package/dist/validation/view-predicates/outgoing.js

@@ -0,0 +1,15 @@
+import { AstUtils } from "langium";
+import { isNullish } from "remeda";
+import { ast } from "../../ast.js";
+export const outgoingExpressionChecks = (_services) => {
+  return (el, accept) => {
+    if (ast.isWildcardExpression(el.from) && !ast.isDirectedRelationExpression(el.$container)) {
+      const view = AstUtils.getContainerOfType(el, ast.isElementView);
+      if (isNullish(view?.viewOf)) {
+        accept("warning", "Predicate is ignored as it concerns all relationships", {
+          node: el
+        });
+      }
+    }
+  };
+};

package/dist/validation/view-predicates/relation-with.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../../ast';
+import type { LikeC4Services } from '../../module';
+export declare const relationPredicateWithChecks: (_services: LikeC4Services) => ValidationCheck<ast.RelationPredicateWith>;

package/dist/validation/view-predicates/relation-with.js

@@ -0,0 +1,12 @@
+import { AstUtils } from "langium";
+import { ast } from "../../ast.js";
+export const relationPredicateWithChecks = (_services) => {
+  return (el, accept) => {
+    const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate);
+    if (ast.isExcludePredicate(container)) {
+      accept("error", 'Invalid usage inside "exclude"', {
+        node: el
+      });
+    }
+  };
+};

package/dist/validation/view.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.LikeC4View>;

package/dist/validation/view.js

@@ -0,0 +1,23 @@
+import { ast } from "../ast.js";
+import { RESERVED_WORDS } from "./_shared.js";
+export const viewChecks = (services) => {
+  const index = services.shared.workspace.IndexManager;
+  return (el, accept) => {
+    if (!el.name) {
+      return;
+    }
+    if (RESERVED_WORDS.includes(el.name)) {
+      accept("error", `Reserved word: ${el.name}`, {
+        node: el,
+        property: "name"
+      });
+    }
+    const anotherViews = index.allElements(ast.LikeC4View).filter((n) => n.name === el.name).limit(2).count();
+    if (anotherViews > 1) {
+      accept("error", `Duplicate view '${el.name}'`, {
+        node: el,
+        property: "name"
+      });
+    }
+  };
+};

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

@@ -0,0 +1,2 @@
+import { ComputedView } from '@likec4/core';
+export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;