@likec4/language-server 1.47.0 → 1.49.0

package/dist/validation/relation.js

@@ -1,141 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Copyright (c) 2023-2025 Denis Davydkov
-// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-//
-// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
-import { FqnRef, isSameHierarchy } from '@likec4/core';
-import { AstUtils } from 'langium';
-import { ast, isParsedLikeC4LangiumDocument } from '../ast';
-import { safeCall } from '../utils';
-import { stringHash } from '../utils/stringHash';
-import { tryOrLog } from './_shared';
-// Cache of relation match keys to avoid recomputing for every extend validation
-let cachedRelationKeys = null;
-let cachedDocsFingerprint = null;
-const computeDocsFingerprint = (docs) => {
-    return docs
-        .map(doc => {
-        const relationHashes = (doc.c4Relations ?? [])
-            .map(rel => stringHash('extend-relation', FqnRef.flatten(rel.source), FqnRef.flatten(rel.target), rel.kind ?? 'default', rel.title ?? ''))
-            .sort()
-            .join(',');
-        return `${doc.uri.toString()}:${relationHashes}`;
-    })
-        .join('|');
-};
-export const relationChecks = (services) => {
-    const modelParser = services.likec4.ModelParser;
-    return tryOrLog((el, accept) => {
-        const parser = modelParser.forDocument(AstUtils.getDocument(el));
-        const source = safeCall(() => parser._resolveRelationSource(el));
-        if (!source) {
-            accept('error', 'Source not resolved', {
-                node: el,
-                property: 'source',
-            });
-            return;
-        }
-        const target = safeCall(() => parser.parseFqnRef(el.target));
-        if (!target) {
-            accept('error', 'Target not resolved', {
-                node: el,
-                property: 'target',
-            });
-            return;
-        }
-        if (FqnRef.isImportRef(source)) {
-            if (FqnRef.isImportRef(target)) {
-                accept('warning', 'Relationship between imported elements may not be visible in origin projects', {
-                    node: el,
-                });
-            }
-            else {
-                accept('warning', 'Relationship from imported element to local element may not be visible in origin project', {
-                    node: el,
-                    property: 'source',
-                });
-            }
-        }
-        if (isSameHierarchy(FqnRef.flatten(source), FqnRef.flatten(target))) {
-            accept('error', 'Invalid parent-child relationship', {
-                node: el,
-            });
-        }
-    });
-};
-export const checkRelationBody = (_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,
-            });
-        }
-    });
-};
-export const extendRelationChecks = (services) => {
-    const modelParser = services.likec4.ModelParser;
-    return tryOrLog((el, accept) => {
-        const parser = modelParser.forDocument(AstUtils.getDocument(el));
-        const source = safeCall(() => parser.parseFqnRef(el.source));
-        if (!source) {
-            accept('error', 'Source not resolved', {
-                node: el,
-                property: 'source',
-            });
-            return;
-        }
-        const target = safeCall(() => parser.parseFqnRef(el.target));
-        if (!target) {
-            accept('error', 'Target not resolved', {
-                node: el,
-                property: 'target',
-            });
-            return;
-        }
-        if (!FqnRef.isModelRef(source) && !FqnRef.isImportRef(source)) {
-            accept('error', 'Source must reference a model element', {
-                node: el,
-                property: 'source',
-            });
-            return;
-        }
-        if (!FqnRef.isModelRef(target) && !FqnRef.isImportRef(target)) {
-            accept('error', 'Target must reference a model element', {
-                node: el,
-                property: 'target',
-            });
-            return;
-        }
-        // Warn if this extend does not match any relation in the workspace
-        // Build a match key identical to buildModel.ts
-        const kind = (el.kind ?? el.dotKind?.kind)?.ref?.name ?? 'default';
-        // Normalize title using the same parser helper
-        const { title = '' } = parser.parseBaseProps({}, { title: el.title });
-        const extendKey = stringHash('extend-relation', FqnRef.flatten(source), FqnRef.flatten(target), kind, title);
-        // Build (or reuse) a Set of all relation match keys across the workspace.
-        // This avoids O(E x D x R) scans on large workspaces.
-        const docs = services.shared.workspace.LangiumDocuments.all
-            .toArray()
-            .filter(isParsedLikeC4LangiumDocument);
-        const fingerprint = computeDocsFingerprint(docs);
-        if (fingerprint !== cachedDocsFingerprint) {
-            const keys = new Set();
-            for (const d of docs) {
-                for (const rel of d.c4Relations ?? []) {
-                    const key = stringHash('extend-relation', FqnRef.flatten(rel.source), FqnRef.flatten(rel.target), rel.kind ?? 'default', rel.title ?? '');
-                    keys.add(key);
-                }
-            }
-            cachedRelationKeys = keys;
-            cachedDocsFingerprint = fingerprint;
-        }
-        const hasMatch = cachedRelationKeys?.has(extendKey) ?? false;
-        if (!hasMatch) {
-            accept('warning', 'This extend does not match any relation (by source, kind, target, title)', {
-                node: el,
-            });
-        }
-    });
-};

package/dist/validation/specification.d.ts

@@ -1,12 +0,0 @@
-import { type ValidationCheck } from 'langium';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare const checkSpecificationRule: (_: LikeC4Services) => ValidationCheck<ast.SpecificationRule>;
-export declare const checkModel: (_: LikeC4Services) => ValidationCheck<ast.Model>;
-export declare const checkGlobals: (_: LikeC4Services) => ValidationCheck<ast.Globals>;
-export declare const checkElementKind: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
-export declare const checkDeploymentNodeKind: (services: LikeC4Services) => ValidationCheck<ast.DeploymentNodeKind>;
-export declare const checkTag: (services: LikeC4Services) => ValidationCheck<ast.Tag>;
-export declare const checkRelationshipKind: (services: LikeC4Services) => ValidationCheck<ast.RelationshipKind>;
-export declare const checkGlobalPredicate: (services: LikeC4Services) => ValidationCheck<ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup>;
-export declare const checkGlobalStyleId: (services: LikeC4Services) => ValidationCheck<ast.GlobalStyleId>;

package/dist/validation/specification.js

@@ -1,190 +0,0 @@
-import { AstUtils } from 'langium';
-import { ast } from '../ast';
-import { projectIdFrom } from '../utils';
-import { RESERVED_WORDS, tryOrLog } from './_shared';
-export const checkSpecificationRule = (_) => {
-    return tryOrLog((node, accept) => {
-        if (node.$containerIndex && node.$containerIndex > 0) {
-            accept('warning', `Prefer one specification per document`, {
-                node: node,
-                property: 'name',
-            });
-        }
-    });
-};
-export const checkModel = (_) => {
-    return tryOrLog((node, accept) => {
-        if (node.$containerIndex && node.$containerIndex > 0) {
-            accept('warning', `Prefer one model per document`, {
-                node: node,
-                property: 'name',
-            });
-        }
-    });
-};
-export const checkGlobals = (_) => {
-    return tryOrLog((node, accept) => {
-        if (node.$containerIndex && node.$containerIndex > 0) {
-            accept('warning', `Prefer one global block per document`, {
-                node: node,
-                property: 'name',
-            });
-        }
-    });
-};
-export const checkElementKind = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return tryOrLog((node, accept) => {
-        if (RESERVED_WORDS.includes(node.name)) {
-            accept('error', `Reserved word: ${node.name}`, {
-                node: node,
-                property: 'name',
-            });
-        }
-        const projectId = projectIdFrom(node);
-        const sameKind = index
-            .projectElements(projectId, 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: node,
-                property: 'name',
-                ...isAnotherDoc && {
-                    relatedInformation: [
-                        {
-                            location: {
-                                range: sameKind.nameSegment.range,
-                                uri: sameKind.documentUri.toString(),
-                            },
-                            message: `conflicting definition`,
-                        },
-                    ],
-                },
-            });
-        }
-    });
-};
-export const checkDeploymentNodeKind = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return tryOrLog((node, accept) => {
-        if (RESERVED_WORDS.includes(node.name)) {
-            accept('error', `Reserved word: ${node.name}`, {
-                node: node,
-                property: 'name',
-            });
-        }
-        const projectId = projectIdFrom(node);
-        const sameKind = index
-            .projectElements(projectId, ast.DeploymentNodeKind)
-            .filter(n => n.name === node.name && n.node !== node)
-            .head();
-        if (sameKind) {
-            const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri;
-            accept('error', `Duplicate deploymentNode kind '${node.name}'`, {
-                node: node,
-                property: 'name',
-                ...isAnotherDoc && {
-                    relatedInformation: [
-                        {
-                            location: {
-                                range: sameKind.nameSegment.range,
-                                uri: sameKind.documentUri.toString(),
-                            },
-                            message: `conflicting definition`,
-                        },
-                    ],
-                },
-            });
-        }
-    });
-};
-export const checkTag = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return tryOrLog((node, accept) => {
-        const tagname = node.name;
-        const projectId = projectIdFrom(node);
-        const sameTag = index
-            .projectElements(projectId, 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 checkRelationshipKind = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return tryOrLog((node, accept) => {
-        if (RESERVED_WORDS.includes(node.name)) {
-            accept('error', `Reserved word: ${node.name}`, {
-                node: node,
-                property: 'name',
-            });
-        }
-        const projectId = projectIdFrom(node);
-        const sameKinds = index
-            .projectElements(projectId, ast.RelationshipKind)
-            .filter(n => n.name === node.name)
-            .limit(2)
-            .count();
-        if (sameKinds > 1) {
-            accept('error', `Duplicate RelationshipKind '${node.name}'`, {
-                node: node,
-                property: 'name',
-            });
-        }
-    });
-};
-export const checkGlobalPredicate = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return tryOrLog((node, accept) => {
-        const projectId = projectIdFrom(node);
-        const predicateGroups = index.projectElements(projectId, ast.GlobalPredicateGroup);
-        const dynamicPredicateGroups = index.projectElements(projectId, 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: node,
-                property: 'name',
-            });
-        }
-    });
-};
-export const checkGlobalStyleId = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return tryOrLog((node, accept) => {
-        const projectId = projectIdFrom(node);
-        const sameName = index
-            .projectElements(projectId, ast.GlobalStyleId)
-            .filter(s => s.name === node.name)
-            .limit(2)
-            .count();
-        if (sameName > 1) {
-            accept('error', `Duplicate GlobalStyleId name '${node.name}'`, {
-                node: node,
-                property: 'name',
-            });
-        }
-    });
-};

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

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

package/dist/validation/view-checks.js

@@ -1,46 +0,0 @@
-import { ast } from '../ast';
-import { tryOrLog } from './_shared';
-// Helper to collect FqnExpr values from FqnExpressions linked list
-function collectFqnExprs(exprs) {
-    const result = [];
-    let iter = exprs;
-    while (iter) {
-        if (iter.value) {
-            result.push(iter.value);
-        }
-        iter = iter.prev;
-    }
-    return result.reverse();
-}
-export const viewRuleRankChecks = (_services) => {
-    return tryOrLog((el, accept) => {
-        const targetExprs = collectFqnExprs(el.targets);
-        if (targetExprs.length < 2 && el.value === 'same') {
-            accept('warning', 'Rank rule should have at least 2 targets', {
-                node: el,
-                property: 'targets',
-            });
-        }
-        // Filter to only FqnRefExpr for parent comparison
-        const fqnRefExprs = targetExprs.filter(ast.isFqnRefExpr);
-        const firstParent = fqnRefExprs[0]?.ref?.parent;
-        for (let i = 1; i < fqnRefExprs.length; i++) {
-            const target = fqnRefExprs[i];
-            if (el.value === 'same' && !areSame(firstParent, target?.ref?.parent)) {
-                accept('error', 'All targets must have the same parent rank same', {
-                    node: el,
-                    property: 'targets',
-                });
-            }
-        }
-    });
-};
-function areSame(a, b) {
-    if (!a && !b)
-        return true;
-    if (!a || !b)
-        return false;
-    if (a.value.ref !== b.value.ref)
-        return false;
-    return areSame(a.parent, b.parent);
-}

package/dist/validation/view-predicates/fqn-expr-with.d.ts

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

package/dist/validation/view-predicates/fqn-expr-with.js

@@ -1,43 +0,0 @@
-import { FqnExpr } from '@likec4/core/types';
-import { nonexhaustive } from '@likec4/core/utils';
-import { AstUtils } from 'langium';
-import { ast, getViewRulePredicateContainer } from '../../ast';
-import { tryOrLog } from '../_shared';
-export const checkFqnExprWith = (services) => {
-    const modelParser = services.likec4.ModelParser;
-    return tryOrLog((el, accept) => {
-        const container = getViewRulePredicateContainer(el);
-        if (container?.$type !== 'DynamicViewIncludePredicate' && container?.isInclude !== true) {
-            accept('error', 'Invalid usage inside "exclude"', {
-                node: el,
-            });
-            return;
-        }
-        const isInsideDynamicView = container.$type === 'DynamicViewIncludePredicate';
-        const parser = modelParser.forDocument(AstUtils.getDocument(container));
-        let expr = FqnExpr.unwrap(parser.parseFqnExprWith(el).custom.expr);
-        switch (true) {
-            case FqnExpr.isWildcard(expr) && isInsideDynamicView:
-            case FqnExpr.isElementKindExpr(expr) && isInsideDynamicView:
-            case FqnExpr.isElementTagExpr(expr) && isInsideDynamicView: {
-                accept('warning', `Predicate is ignored, as not supported in dynamic views`, {
-                    node: el,
-                });
-                return;
-            }
-            case FqnExpr.isWildcard(expr):
-            case FqnExpr.isModelRef(expr):
-            case FqnExpr.isDeploymentRef(expr):
-                return;
-            case FqnExpr.isElementKindExpr(expr):
-            case FqnExpr.isElementTagExpr(expr):
-                accept('error', 'Invalid target (expect reference to specific element)', {
-                    node: el,
-                    property: 'subject',
-                });
-                return;
-            default:
-                nonexhaustive(expr);
-        }
-    });
-};

package/dist/validation/view-predicates/fqn-ref-expr.d.ts

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

package/dist/validation/view-predicates/fqn-ref-expr.js

@@ -1,51 +0,0 @@
-import { FqnExpr, FqnRef } from '@likec4/core/types';
-import { AstUtils } from 'langium';
-import { isTruthy } from 'remeda';
-import { ast, getViewRulePredicateContainer, isFqnRefInsideDeployment } from '../../ast';
-import { tryOrLog } from '../_shared';
-export const checkFqnRefExpr = (services) => {
-    const modelParser = services.likec4.ModelParser;
-    return tryOrLog((node, accept) => {
-        const parser = modelParser.forDocument(AstUtils.getDocument(node));
-        const expr = parser.parseFqnRefExpr(node);
-        const viewRulePredicate = getViewRulePredicateContainer(node);
-        const isInsideDeploymentButNotStyle = isFqnRefInsideDeployment(node) && !AstUtils.hasContainerOfType(node, n => ast.isDeploymentViewRuleStyle(n) || ast.isViewRuleStyle(n));
-        if (viewRulePredicate?.$type === 'DeploymentViewRulePredicate' || isInsideDeploymentButNotStyle) {
-            const isPartOfRelationExpr = AstUtils.hasContainerOfType(node, ast.isRelationExpr);
-            // This expression is part of element predicate
-            if (!isPartOfRelationExpr) {
-                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 (isTruthy(node.selector) && !ast.isDeploymentNode(node.ref.value?.ref)) {
-                accept('warning', `Selector '${node.selector}' applies to deployment nodes only, ignored here`, {
-                    node,
-                    property: 'selector',
-                });
-            }
-            return;
-        }
-        if (viewRulePredicate?.$type === 'DynamicViewIncludePredicate') {
-            switch (true) {
-                case FqnExpr.isElementKindExpr(expr):
-                case FqnExpr.isElementTagExpr(expr):
-                case FqnExpr.isWildcard(expr): {
-                    accept('warning', `Predicate is ignored, as not supported in dynamic views`, {
-                        node,
-                    });
-                    return;
-                }
-            }
-        }
-    });
-};

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

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

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

@@ -1,16 +0,0 @@
-import { AstUtils } from 'langium';
-import { isNullish } from 'remeda';
-import { ast } from '../../ast';
-import { tryOrLog } from '../_shared';
-export const checkIncomingRelationExpr = (_services) => {
-    return tryOrLog((el, accept) => {
-        if (el.to.$type === 'WildcardExpression' && !ast.isInOutRelationExpr(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

@@ -1,6 +0,0 @@
-export { checkFqnExprWith } from './fqn-expr-with';
-export { checkFqnRefExpr } from './fqn-ref-expr';
-export { checkIncomingRelationExpr } from './incoming';
-export { checkOutgoingRelationExpr } from './outgoing';
-export { checkRelationExpr } from './relation-expr';
-export { checkRelationExprWith } from './relation-with';

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

@@ -1,6 +0,0 @@
-export { checkFqnExprWith } from './fqn-expr-with';
-export { checkFqnRefExpr } from './fqn-ref-expr';
-export { checkIncomingRelationExpr } from './incoming';
-export { checkOutgoingRelationExpr } from './outgoing';
-export { checkRelationExpr } from './relation-expr';
-export { checkRelationExprWith } from './relation-with';

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

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

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

@@ -1,20 +0,0 @@
-import { AstUtils } from 'langium';
-import { isNullish } from 'remeda';
-import { ast, getViewRulePredicateContainer } from '../../ast';
-import { tryOrLog } from '../_shared';
-export const checkOutgoingRelationExpr = (_services) => {
-    return tryOrLog((el, accept) => {
-        const viewRulePredicate = getViewRulePredicateContainer(el);
-        if (viewRulePredicate?.$type !== 'ViewRulePredicate') {
-            return;
-        }
-        if (el.$container.$type !== 'DirectedRelationExpr' && el.from.$type === 'WildcardExpression') {
-            const view = AstUtils.getContainerOfType(el, ast.isElementView);
-            if (view && isNullish(view.viewOf)) {
-                accept('warning', 'Predicate is ignored as it concerns all relationships', {
-                    node: el,
-                });
-            }
-        }
-    });
-};

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

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

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

@@ -1,46 +0,0 @@
-import { FqnExpr, RelationExpr } from '@likec4/core';
-import { AstUtils } from 'langium';
-import { ast } from '../../ast';
-import { tryOrLog } from '../_shared';
-export const checkRelationExpr = (services) => {
-    const ModelParser = services.likec4.ModelParser;
-    return tryOrLog((node, accept) => {
-        // if (node.$container.$type !== 'DeploymentViewRulePredicateExpression') {
-        //   // skip validation for this node, validated by container
-        //   return
-        // }
-        const predicate = AstUtils.getContainerOfType(node, ast.isDeploymentViewRulePredicate);
-        if (!predicate || predicate.isInclude !== true) {
-            // no restriction for exclude predicate
-            return;
-        }
-        const doc = AstUtils.getDocument(node);
-        const parser = ModelParser.forDocument(doc);
-        let relationExpr = RelationExpr.unwrap(parser.parseRelationExpr(node));
-        const ModelRefOnlyExclude = 'Model reference is allowed in exclude predicate only';
-        if (RelationExpr.isDirect(relationExpr)) {
-            if (FqnExpr.isModelRef(relationExpr.source) || FqnExpr.isModelRef(relationExpr.target)) {
-                accept('error', ModelRefOnlyExclude, {
-                    node: node,
-                });
-            }
-            return;
-        }
-        let expr;
-        if (RelationExpr.isIncoming(relationExpr)) {
-            expr = relationExpr.incoming;
-        }
-        else if (RelationExpr.isOutgoing(relationExpr)) {
-            expr = relationExpr.outgoing;
-        }
-        else {
-            expr = relationExpr.inout;
-        }
-        if (FqnExpr.isModelRef(expr)) {
-            accept('error', ModelRefOnlyExclude, {
-                node,
-            });
-            return;
-        }
-    });
-};

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

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

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

@@ -1,16 +0,0 @@
-import { ast, getViewRulePredicateContainer } from '../../ast';
-import { tryOrLog } from '../_shared';
-export const checkRelationExprWith = (_services) => {
-    return tryOrLog((el, accept) => {
-        const container = getViewRulePredicateContainer(el);
-        if (!container || container.$type == 'DynamicViewIncludePredicate') {
-            return;
-        }
-        if (!container.isInclude) {
-            accept('error', 'Invalid usage inside "exclude"', {
-                node: el,
-            });
-            return;
-        }
-    });
-};

package/dist/validation/view.d.ts

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