@likec4/language-server 1.42.1 → 1.44.0

package/dist/validation/specification.js

@@ -0,0 +1,190 @@
+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-predicates/fqn-expr-with.js

@@ -0,0 +1,43 @@
+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.js

@@ -0,0 +1,51 @@
+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.js

@@ -0,0 +1,16 @@
+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.js

@@ -0,0 +1,6 @@
+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.js

@@ -0,0 +1,20 @@
+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.js

@@ -0,0 +1,46 @@
+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.js

@@ -0,0 +1,16 @@
+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 +1,4 @@
-import type { ValidationCheck } from 'langium';
+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,42 @@
+import { CstUtils } from 'langium';
+import { ast } from '../ast';
+import { projectIdFrom } from '../utils';
+import { hasManualLayout } from '../view-utils/manual-layout';
+import { RESERVED_WORDS, tryOrLog } from './_shared';
+export const viewChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return tryOrLog((el, accept) => {
+        const commentNode = CstUtils.findCommentNode(el.$cstNode, ['BLOCK_COMMENT']);
+        if (commentNode && hasManualLayout(commentNode.text)) {
+            accept('warning', `Migrate to the new manual layout snapshots (run LikeC4: Migrate manual layouts)`, {
+                node: el,
+                range: commentNode.range,
+                code: 'manual-layout-v1',
+                // codeDescription: {
+                //   href: 'https://likec4.dev/docs/guides/manual-layout#migrating-from-v1-to-v2-manual-layout',
+                // },
+            });
+        }
+        if (!el.name) {
+            return;
+        }
+        if (RESERVED_WORDS.includes(el.name)) {
+            accept('error', `Reserved word: ${el.name}`, {
+                node: el,
+                property: 'name',
+            });
+        }
+        const projectId = projectIdFrom(el);
+        const anotherViews = index
+            .projectElements(projectId, 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.js

@@ -0,0 +1,27 @@
+import { isElementView } from '@likec4/core';
+import { find, isNullish } from 'remeda';
+export function assignNavigateTo(views) {
+    const allElementViews = new Map();
+    for (const v of views) {
+        if (isElementView(v) && v.viewOf && isNullish(v.extends)) {
+            const viewsOf = allElementViews.get(v.viewOf) ?? [];
+            viewsOf.push(v.id);
+            allElementViews.set(v.viewOf, viewsOf);
+        }
+    }
+    // set default navigateTo
+    for (const { id, nodes } of views) {
+        for (const node of nodes) {
+            const modelRef = node.modelRef;
+            if (node.navigateTo || !modelRef) {
+                continue;
+            }
+            // find first element view that is not the current one
+            const navigateTo = find(allElementViews.get(modelRef) ?? [], v => v !== id);
+            if (navigateTo) {
+                node.navigateTo = navigateTo;
+            }
+        }
+    }
+    return views;
+}

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

@@ -1 +1,2 @@
 export * from './assignNavigateTo';
+export * from './manual-layout';

package/dist/view-utils/index.js

@@ -0,0 +1,2 @@
+export * from './assignNavigateTo';
+export * from './manual-layout';

package/dist/view-utils/manual-layout.d.ts

@@ -5,3 +5,9 @@ export declare function serializeToComment(layout: ViewManualLayout): string;
 export declare function hasManualLayout(comment: string): boolean;
 export declare function deserializeFromComment(comment: string): ViewManualLayout;
 export declare function parseViewManualLayout(node: ast.LikeC4View): c4.ViewManualLayout | undefined;
+/**
+ * Applies styles from the latest layout to the manual layout
+ * @param manualLayouted
+ * @param latest
+ */
+export declare function applyStylesToManualLayout<A extends c4.AnyAux>(manualLayouted: NoInfer<c4.LayoutedView<A>>, latest: c4.ComputedView<A> | c4.LayoutedView<A>): c4.LayoutedView<A>;

package/dist/view-utils/manual-layout.js

@@ -0,0 +1,151 @@
+import { exact, isAutoLayoutDirection } from '@likec4/core';
+import { decode, encode } from '@msgpack/msgpack';
+import { fromBase64, toBase64 } from '@smithy/util-base64';
+import { shallowEqual } from 'fast-equals';
+import { AstUtils, CstUtils } from 'langium';
+import { find, mapValues } from 'remeda';
+import { logger, logWarnError } from '../logger';
+const { getDocument } = AstUtils;
+function pack({ nodes, edges, ...rest }) {
+    return {
+        ...rest,
+        nodes: mapValues(nodes, ({ x, y, width, height, isCompound, ...n }) => ({
+            ...n,
+            b: [x, y, width, height],
+            c: isCompound,
+        })),
+        edges: mapValues(edges, ({ points, controlPoints, labelBBox, dotpos, ...e }) => ({
+            ...!!controlPoints && { cp: controlPoints },
+            ...!!labelBBox && { l: labelBBox },
+            ...!!dotpos && { dp: dotpos },
+            ...e,
+            p: points,
+        })),
+    };
+}
+function unpack({ nodes, edges, autoLayout, ...rest }) {
+    return {
+        ...rest,
+        /// Try to parse the old format for backward compatibility
+        autoLayout: isAutoLayoutDirection(autoLayout) ? { direction: autoLayout } : autoLayout,
+        nodes: mapValues(nodes, ({ b, c, ...n }) => ({
+            x: b[0],
+            y: b[1],
+            width: b[2],
+            height: b[3],
+            isCompound: c,
+            ...n,
+        })),
+        edges: mapValues(edges, ({ p, cp, l, dp, ...e }) => ({
+            ...!!cp && { controlPoints: cp },
+            ...!!l && { labelBBox: l },
+            ...!!dp && { dotpos: dp },
+            ...e,
+            points: p,
+        })),
+    };
+}
+const MAX_LINE_LENGTH = 500;
+export function serializeToComment(layout) {
+    const bytes = encode(pack(layout));
+    const base64 = toBase64(bytes);
+    const lines = [];
+    let offset = 0;
+    while (offset < base64.length) {
+        lines.push(' * ' + base64.slice(offset, Math.min(offset + MAX_LINE_LENGTH, base64.length)));
+        offset += MAX_LINE_LENGTH;
+    }
+    lines.unshift('/**', ' * @likec4-generated(v1)');
+    lines.push(' */');
+    return lines.join('\n');
+}
+export function hasManualLayout(comment) {
+    return comment.includes('@likec4-generated');
+}
+export function deserializeFromComment(comment) {
+    if (!hasManualLayout(comment)) {
+        throw new Error(`Not a likec4-generated comment: ${comment}`);
+    }
+    const b64 = comment
+        .trim()
+        .split('\n')
+        .filter(l => !l.includes('**') && !l.includes('@likec4-') && !l.includes('*/'))
+        .map(l => l.replaceAll('*', '').trim())
+        .join('');
+    const decodedb64 = fromBase64(b64);
+    return unpack(decode(decodedb64));
+}
+export function parseViewManualLayout(node) {
+    const commentNode = CstUtils.findCommentNode(node.$cstNode, ['BLOCK_COMMENT']);
+    if (!commentNode || !hasManualLayout(commentNode.text)) {
+        return undefined;
+    }
+    try {
+        return deserializeFromComment(commentNode.text);
+    }
+    catch (e) {
+        const doc = getDocument(node);
+        logWarnError(e);
+        logger.warn(`Ignoring manual layout of "${node.name ?? 'unnamed'}" at ${doc.uri.fsPath}:${1 + (commentNode.range.start.line || 0)}`);
+        return undefined;
+    }
+}
+/**
+ * Applies styles from the latest layout to the manual layout
+ * @param manualLayouted
+ * @param latest
+ */
+export function applyStylesToManualLayout(manualLayouted, latest) {
+    const nodes = manualLayouted.nodes.map(n => {
+        const latestNode = find(latest.nodes, l => l.id === n.id);
+        if (!latestNode) {
+            return n;
+        }
+        const color = latestNode.color;
+        if (color !== n.color) {
+            n = {
+                ...n,
+                color,
+            };
+        }
+        const { opacity, border } = latestNode.style;
+        if (opacity !== n.style.opacity || border !== n.style.border) {
+            n = {
+                ...n,
+                style: exact({
+                    ...n.style,
+                    opacity,
+                    border,
+                }),
+            };
+        }
+        return n;
+    });
+    const edges = manualLayouted.edges.map(e => {
+        const latestEdge = find(latest.edges, l => l.id === e.id);
+        if (!latestEdge) {
+            return e;
+        }
+        if (latestEdge.color !== e.color) {
+            e = {
+                ...e,
+                color: latestEdge.color,
+            };
+        }
+        if (latestEdge.line !== e.line) {
+            e = {
+                ...e,
+                line: latestEdge.line,
+            };
+        }
+        return e;
+    });
+    if (!shallowEqual(manualLayouted.nodes, nodes) || !shallowEqual(manualLayouted.edges, edges)) {
+        return {
+            ...manualLayouted,
+            nodes,
+            edges,
+        };
+    }
+    return manualLayouted;
+}