@likec4/language-server 1.27.3 → 1.28.1

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

@@ -1,31 +0,0 @@
-import { nonexhaustive } from "@likec4/core";
-import { AstUtils } from "langium";
-import { ast } from "../../ast.js";
-import { tryOrLog } from "../_shared.js";
-export const elementPredicateWithChecks = (_services) => {
-  return tryOrLog((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.js

@@ -1,12 +0,0 @@
-import { AstUtils } from "langium";
-import { ast } from "../../ast.js";
-import { tryOrLog } from "../_shared.js";
-export const expandElementExprChecks = (_services) => {
-  return tryOrLog((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

@@ -1,5 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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"
-      });
-    }
-  });
-};