@likec4/language-server 1.42.1 → 1.44.0

package/dist/model/parser/ViewsParser.js

@@ -0,0 +1,477 @@
+import * as c4 from '@likec4/core';
+import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core';
+import { loggable } from '@likec4/log';
+import { filter, find, isDefined, isEmpty, isNonNullish, isNumber, isTruthy, last, mapToObj, pipe } from 'remeda';
+import { ast, parseMarkdownAsString, toAutoLayout, toColor, ViewOps, } from '../../ast';
+import { logger as mainLogger } from '../../logger';
+import { stringHash } from '../../utils';
+import { elementRef } from '../../utils/elementRef';
+import { parseViewManualLayout } from '../../view-utils/manual-layout';
+import { removeIndent, toSingleLine } from './Base';
+const logger = mainLogger.getChild('ViewsParser');
+export function ViewsParser(B) {
+    return class ViewsParser extends B {
+        parseViews() {
+            const isValid = this.isValid;
+            for (const viewBlock of this.doc.parseResult.value.views) {
+                const localStyles = viewBlock.styles.flatMap(s => {
+                    try {
+                        return isValid(s) ? this.parseViewRuleStyleOrGlobalRef(s) : [];
+                    }
+                    catch (e) {
+                        logger.warn(loggable(e));
+                        return [];
+                    }
+                });
+                // Common folder for all views in the block
+                const folder = viewBlock.folder && !isEmpty(viewBlock.folder.trim()) ? toSingleLine(viewBlock.folder) : null;
+                for (const view of viewBlock.views) {
+                    try {
+                        if (!isValid(view)) {
+                            continue;
+                        }
+                        switch (true) {
+                            case ast.isElementView(view):
+                                this.doc.c4Views.push(this.parseElementView(view, localStyles));
+                                break;
+                            case ast.isDynamicView(view):
+                                this.doc.c4Views.push(this.parseDynamicElementView(view, localStyles));
+                                break;
+                            case ast.isDeploymentView(view):
+                                this.doc.c4Views.push(this.parseDeploymentView(view));
+                                break;
+                            default:
+                                nonexhaustive(view);
+                        }
+                        if (folder) {
+                            const view = this.doc.c4Views.at(-1);
+                            view.title = folder + ' / ' + (view.title || view.id);
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(loggable(e));
+                    }
+                }
+            }
+        }
+        parseElementView(astNode, additionalStyles) {
+            const body = astNode.body;
+            invariant(body, 'ElementView body is not defined');
+            const astPath = this.getAstNodePath(astNode);
+            let viewOf = null;
+            if ('viewOf' in astNode) {
+                const viewOfEl = elementRef(astNode.viewOf);
+                const _viewOf = viewOfEl && this.resolveFqn(viewOfEl);
+                if (!_viewOf) {
+                    logger.warn('viewOf is not resolved: ' + astNode.$cstNode?.text);
+                }
+                else {
+                    viewOf = _viewOf;
+                }
+            }
+            let id = astNode.name;
+            if (!id) {
+                id = 'view_' + stringHash(this.doc.uri.toString(), astPath, viewOf ?? '');
+            }
+            const { title = null, description = null } = this.parseBaseProps(pipe(body.props, filter(p => this.isValid(p)), filter(ast.isViewStringProperty), mapToObj(p => [p.key, p.value])));
+            const tags = this.convertTags(body);
+            const links = this.convertLinks(body);
+            const manualLayout = parseViewManualLayout(astNode);
+            const view = {
+                [c4._type]: 'element',
+                id: id,
+                astPath,
+                title: toSingleLine(title) ?? null,
+                description,
+                tags,
+                links: isNonEmptyArray(links) ? links : null,
+                rules: [
+                    ...additionalStyles,
+                    ...body.rules.flatMap(n => {
+                        try {
+                            return this.isValid(n) ? this.parseElementViewRule(n) : [];
+                        }
+                        catch (e) {
+                            logger.warn(loggable(e));
+                            return [];
+                        }
+                    }),
+                ],
+                ...(viewOf && { viewOf }),
+                ...(manualLayout && { manualLayout }),
+            };
+            ViewOps.writeId(astNode, view.id);
+            if ('extends' in astNode) {
+                const extendsView = astNode.extends.view.ref;
+                invariant(extendsView?.name, 'view extends is not resolved: ' + astNode.$cstNode?.text);
+                return Object.assign(view, {
+                    extends: extendsView.name,
+                });
+            }
+            return view;
+        }
+        parseElementViewRule(astRule) {
+            if (ast.isViewRulePredicate(astRule)) {
+                return this.parseViewRulePredicate(astRule);
+            }
+            if (ast.isViewRuleGlobalPredicateRef(astRule)) {
+                return this.parseViewRuleGlobalPredicateRef(astRule);
+            }
+            if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
+                return this.parseViewRuleStyleOrGlobalRef(astRule);
+            }
+            if (ast.isViewRuleAutoLayout(astRule)) {
+                return toAutoLayout(astRule);
+            }
+            if (ast.isViewRuleGroup(astRule)) {
+                return this.parseViewRuleGroup(astRule);
+            }
+            nonexhaustive(astRule);
+        }
+        parseViewRulePredicate(astNode) {
+            const exprs = [];
+            let predicate = astNode.exprs;
+            while (predicate) {
+                const { value, prev } = predicate;
+                try {
+                    if (isTruthy(value) && this.isValid(value)) {
+                        const expr = this.parsePredicate(value);
+                        exprs.unshift(expr);
+                    }
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+                if (!prev) {
+                    break;
+                }
+                predicate = prev;
+            }
+            return astNode.isInclude ? { include: exprs } : { exclude: exprs };
+        }
+        parseViewRuleGlobalPredicateRef(astRule) {
+            return {
+                predicateId: astRule.predicate.$refText,
+            };
+        }
+        parseViewRuleStyleOrGlobalRef(astRule) {
+            if (ast.isViewRuleStyle(astRule)) {
+                return this.parseViewRuleStyle(astRule);
+            }
+            if (ast.isViewRuleGlobalStyle(astRule)) {
+                return this.parseViewRuleGlobalStyle(astRule);
+            }
+            nonexhaustive(astRule);
+        }
+        parseViewRuleGroup(astNode) {
+            const groupRules = [];
+            for (const rule of astNode.groupRules) {
+                try {
+                    if (!this.isValid(rule)) {
+                        continue;
+                    }
+                    if (ast.isViewRulePredicate(rule)) {
+                        groupRules.push(this.parseViewRulePredicate(rule));
+                        continue;
+                    }
+                    if (ast.isViewRuleGroup(rule)) {
+                        groupRules.push(this.parseViewRuleGroup(rule));
+                        continue;
+                    }
+                    nonexhaustive(rule);
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+            return {
+                title: toSingleLine(astNode.title) ?? null,
+                groupRules,
+                ...this.parseStyleProps(astNode.props),
+            };
+        }
+        parseViewRuleStyle(astRule) {
+            const targets = this.parseFqnExpressions(astRule.targets).filter((e) => c4.ModelExpression.isFqnExpr(e));
+            const style = this.parseStyleProps(astRule.props.filter(ast.isStyleProperty));
+            const notation = removeIndent(parseMarkdownAsString(astRule.props.find(ast.isNotationProperty)?.value));
+            return {
+                targets,
+                style,
+                ...(notation && { notation }),
+            };
+        }
+        parseViewRuleGlobalStyle(astRule) {
+            return {
+                styleId: astRule.style.$refText,
+            };
+        }
+        parseDynamicElementView(astNode, additionalStyles) {
+            const body = astNode.body;
+            invariant(body, 'DynamicElementView body is not defined');
+            // only valid props
+            const isValid = this.isValid;
+            const props = body.props.filter(isValid);
+            const astPath = this.getAstNodePath(astNode);
+            let id = astNode.name;
+            if (!id) {
+                id = 'dynamic_' + stringHash(this.doc.uri.toString(), astPath);
+            }
+            const { title = null, description = null } = this.parseBaseProps(pipe(props, filter(ast.isViewStringProperty), mapToObj(p => [p.key, p.value])));
+            const tags = this.convertTags(body);
+            const links = this.convertLinks(body);
+            ViewOps.writeId(astNode, id);
+            const manualLayout = parseViewManualLayout(astNode);
+            const variant = find(props, ast.isDynamicViewDisplayVariantProperty)?.value;
+            return {
+                [c4._type]: 'dynamic',
+                id: id,
+                astPath,
+                title: toSingleLine(title) ?? null,
+                description,
+                tags,
+                links: isNonEmptyArray(links) ? links : null,
+                variant,
+                rules: [
+                    ...additionalStyles,
+                    ...body.rules.flatMap(n => {
+                        try {
+                            return isValid(n) ? this.parseDynamicViewRule(n) : [];
+                        }
+                        catch (e) {
+                            logger.warn(loggable(e));
+                            return [];
+                        }
+                    }, []),
+                ],
+                steps: body.steps.reduce((acc, n) => {
+                    try {
+                        if (isValid(n)) {
+                            if (ast.isDynamicViewParallelSteps(n)) {
+                                acc.push(this.parseDynamicParallelSteps(n));
+                            }
+                            else {
+                                acc.push(this.parseDynamicStep(n));
+                            }
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(loggable(e));
+                    }
+                    return acc;
+                }, []),
+                ...(manualLayout && { manualLayout }),
+            };
+        }
+        parseDynamicViewRule(astRule) {
+            if (ast.isDynamicViewIncludePredicate(astRule)) {
+                return this.parseDynamicViewIncludePredicate(astRule);
+            }
+            if (ast.isDynamicViewGlobalPredicateRef(astRule)) {
+                return this.parseViewRuleGlobalPredicateRef(astRule);
+            }
+            if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
+                return this.parseViewRuleStyleOrGlobalRef(astRule);
+            }
+            if (ast.isViewRuleAutoLayout(astRule)) {
+                return toAutoLayout(astRule);
+            }
+            nonexhaustive(astRule);
+        }
+        parseDynamicViewIncludePredicate(astRule) {
+            const include = [];
+            let iter = astRule.exprs;
+            while (iter) {
+                try {
+                    if (isNonNullish(iter.value) && this.isValid(iter.value)) {
+                        if (ast.isFqnExprOrWith(iter.value)) {
+                            const c4expr = this.parseElementPredicate(iter.value);
+                            include.unshift(c4expr);
+                        }
+                    }
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+                iter = iter.prev;
+            }
+            return { include };
+        }
+        parseDynamicParallelSteps(node) {
+            const parallelId = pathInsideDynamicView(node);
+            const __parallel = node.steps.map(step => this.parseDynamicStep(step));
+            invariant(isNonEmptyArray(__parallel), 'Dynamic parallel steps must have at least one step');
+            return {
+                parallelId,
+                __parallel,
+            };
+        }
+        /**
+         * @returns non-empty array in case of step chain A -> B -> C
+         */
+        parseDynamicStep(node) {
+            if (ast.isDynamicStepSingle(node)) {
+                invariant(this.isValid(node));
+                return this.parseDynamicStepSingle(node);
+            }
+            const __series = this.recursiveParseDynamicStepChain(node);
+            invariant(isNonEmptyArray(__series), 'Dynamic step chain must have at least one step');
+            return {
+                seriesId: pathInsideDynamicView(node),
+                __series,
+            };
+        }
+        recursiveParseDynamicStepChain(node, callstack) {
+            if (ast.isDynamicStepSingle(node.source)) {
+                if (!this.isValid(node.source)) {
+                    return [];
+                }
+                const previous = this.parseDynamicStepSingle(node.source);
+                // Head of the chain cannot be backward
+                if (previous.isBackward) {
+                    return [];
+                }
+                const thisStep = {
+                    ...this.parseAbstractDynamicStep(node),
+                    source: previous.target,
+                };
+                // if target is the same as source of previous step, then it is a backward step
+                // A -> B -> A
+                if (thisStep.target === previous.source) {
+                    thisStep.isBackward = true;
+                }
+                else if (callstack) {
+                    callstack.push([previous.source, previous.target]);
+                    callstack.push([thisStep.source, thisStep.target]);
+                }
+                return [previous, thisStep];
+            }
+            callstack ??= [];
+            const allprevious = this.recursiveParseDynamicStepChain(node.source, callstack);
+            if (!isNonEmptyArray(allprevious) || !this.isValid(node)) {
+                return [];
+            }
+            const previous = last(allprevious);
+            const thisStep = {
+                ...this.parseAbstractDynamicStep(node),
+                source: previous.target,
+            };
+            const index = callstack.findIndex(([source, target]) => source === thisStep.target && target === thisStep.source);
+            if (index !== -1) {
+                thisStep.isBackward = true;
+                callstack.splice(index, callstack.length - index);
+            }
+            else {
+                callstack.push([thisStep.source, thisStep.target]);
+            }
+            return [...allprevious, thisStep];
+        }
+        parseDynamicStepSingle(node) {
+            const sourceEl = elementRef(node.source);
+            if (!sourceEl) {
+                throw new Error('Invalid reference to source');
+            }
+            let baseStep = {
+                ...this.parseAbstractDynamicStep(node),
+                source: this.resolveFqn(sourceEl),
+            };
+            if (node.isBackward) {
+                baseStep = {
+                    ...baseStep,
+                    source: baseStep.target,
+                    target: baseStep.source,
+                    isBackward: true,
+                };
+            }
+            return baseStep;
+        }
+        parseAbstractDynamicStep(astnode) {
+            const targetEl = elementRef(astnode.target);
+            if (!targetEl) {
+                throw new Error('Invalid reference to target');
+            }
+            const step = {
+                target: this.resolveFqn(targetEl),
+                astPath: pathInsideDynamicView(astnode),
+            };
+            const title = removeIndent(astnode.title);
+            if (title) {
+                step.title = title;
+            }
+            const kind = astnode.kind?.ref?.name ?? astnode.dotKind?.kind.ref?.name;
+            if (kind) {
+                step.kind = kind;
+            }
+            for (const prop of astnode.custom?.props ?? []) {
+                try {
+                    switch (true) {
+                        case ast.isRelationNavigateToProperty(prop): {
+                            const viewId = prop.value.view.ref?.name;
+                            if (isTruthy(viewId)) {
+                                step.navigateTo = viewId;
+                            }
+                            break;
+                        }
+                        case ast.isRelationStringProperty(prop):
+                        case ast.isNotationProperty(prop): {
+                            if (isDefined(prop.value)) {
+                                if (prop.key === 'description') {
+                                    const value = removeIndent(prop.value);
+                                    if (value) {
+                                        step.description = value;
+                                    }
+                                }
+                                else {
+                                    step[prop.key] = removeIndent(parseMarkdownAsString(prop.value)) ?? '';
+                                }
+                            }
+                            break;
+                        }
+                        case ast.isNotesProperty(prop): {
+                            if (isDefined(prop.value)) {
+                                step[prop.key] = removeIndent(prop.value);
+                            }
+                            break;
+                        }
+                        case ast.isArrowProperty(prop): {
+                            if (isDefined(prop.value)) {
+                                step[prop.key] = prop.value;
+                            }
+                            break;
+                        }
+                        case ast.isColorProperty(prop): {
+                            const value = toColor(prop);
+                            if (isDefined(value)) {
+                                step[prop.key] = value;
+                            }
+                            break;
+                        }
+                        case ast.isLineProperty(prop): {
+                            if (isDefined(prop.value)) {
+                                step[prop.key] = prop.value;
+                            }
+                            break;
+                        }
+                        default:
+                            nonexhaustive(prop);
+                    }
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+            return step;
+        }
+    };
+}
+function pathInsideDynamicView(_node) {
+    let node = _node;
+    let path = [];
+    while (!ast.isDynamicViewBody(node)) {
+        if (isNumber(node.$containerIndex)) {
+            path.unshift(`@${node.$containerIndex}`);
+        }
+        path.unshift(`/${node.$containerProperty ?? '__invalid__'}`);
+        node = node.$container;
+    }
+    return path.join('');
+}

package/dist/model-change/ModelChanges.d.ts

@@ -1,5 +1,6 @@
+import { type ViewChange } from '@likec4/core';
 import { Location, Range, TextEdit } from 'vscode-languageserver-types';
-import type { ParsedLikeC4LangiumDocument } from '../ast';
+import type { ViewLocateResult } from '../model';
 import type { LikeC4Services } from '../module';
 import type { ChangeView } from '../protocol';
 export declare class LikeC4ModelChanges {
@@ -7,8 +8,10 @@ export declare class LikeC4ModelChanges {
     private locator;
     constructor(services: LikeC4Services);
     applyChange(changeView: ChangeView.Params): Promise<Location | null>;
-    protected convertToTextEdit({ viewId, projectId, change }: ChangeView.Params): {
-        doc: ParsedLikeC4LangiumDocument;
+    protected convertToTextEdit({ lookup, change }: {
+        lookup: ViewLocateResult;
+        change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout>;
+    }): {
         modifiedRange: Range;
         edits: TextEdit[];
     };

package/dist/model-change/ModelChanges.js

@@ -0,0 +1,102 @@
+import { invariant, nonexhaustive } from '@likec4/core';
+import { Location, Range, TextEdit } from 'vscode-languageserver-types';
+import { logger as mainLogger } from '../logger';
+import { changeElementStyle } from './changeElementStyle';
+import { changeViewLayout } from './changeViewLayout';
+import { removeManualLayoutV1 } from './removeManualLayoutV1';
+const logger = mainLogger.getChild('model-changes');
+export class LikeC4ModelChanges {
+    services;
+    locator;
+    constructor(services) {
+        this.services = services;
+        this.locator = services.likec4.ModelLocator;
+    }
+    async applyChange(changeView) {
+        const lspConnection = this.services.shared.lsp.Connection;
+        invariant(lspConnection, 'LSP Connection not available');
+        let result = null;
+        try {
+            await this.services.shared.workspace.WorkspaceLock.write(async () => {
+                let { viewId, projectId: _projectId, change } = changeView;
+                const project = this.services.shared.workspace.ProjectsManager.ensureProject(_projectId);
+                logger.debug `Applying model change ${change.op} to view ${viewId} in project ${project.id}`;
+                const lookup = this.locator.locateViewAst(viewId, project.id);
+                if (!lookup) {
+                    throw new Error(`LikeC4ModelChanges: view not found: ${viewId}`);
+                }
+                const textDocument = {
+                    uri: lookup.doc.textDocument.uri,
+                    version: lookup.doc.textDocument.version,
+                };
+                // TODO refactor to use separate methods for save/reset operations
+                if (change.op === 'save-view-snapshot') {
+                    invariant(viewId === change.layout.id, 'View ID does not match');
+                    // If there is an existing manual layout v1
+                    if (lookup.view.manualLayout) {
+                        // We clean it up
+                        await removeManualLayoutV1(this.services, { lookup }).catch(err => {
+                            logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
+                        });
+                    }
+                    result = await this.services.likec4.ManualLayouts.write(project, change.layout);
+                    return;
+                }
+                if (change.op === 'reset-manual-layout') {
+                    result = await this.services.likec4.ManualLayouts.remove(project, viewId);
+                    return;
+                }
+                const { edits, modifiedRange } = this.convertToTextEdit({
+                    lookup,
+                    change,
+                });
+                if (!edits.length) {
+                    return;
+                }
+                const applyResult = await lspConnection.workspace.applyEdit({
+                    label: `LikeC4 - change view ${changeView.viewId}`,
+                    edit: {
+                        changes: {
+                            [textDocument.uri]: edits,
+                        },
+                    },
+                });
+                if (!applyResult.applied) {
+                    lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`);
+                    return;
+                }
+                result = {
+                    uri: textDocument.uri,
+                    range: modifiedRange,
+                };
+            });
+        }
+        catch (error) {
+            logger.error(`Failed to apply change ${changeView.change.op} ${changeView.viewId}`, { error });
+        }
+        return result;
+    }
+    convertToTextEdit({ lookup, change }) {
+        switch (change.op) {
+            case 'change-element-style': {
+                return changeElementStyle(this.services, {
+                    ...lookup,
+                    targets: change.targets,
+                    style: change.style,
+                });
+            }
+            case 'change-autolayout': {
+                const edit = changeViewLayout(this.services, {
+                    ...lookup,
+                    layout: change.layout,
+                });
+                return {
+                    modifiedRange: edit.range,
+                    edits: [edit],
+                };
+            }
+            default:
+                nonexhaustive(change);
+        }
+    }
+}