@likec4/language-server 1.47.0 → 1.48.0

package/dist/model/parser/ViewsParser.d.ts

@@ -1,112 +0,0 @@
-import * as c4 from '@likec4/core';
-import type { Except, Writable } from 'type-fest';
-import { type ParsedAstDynamicView, type ParsedAstElementView, ast } from '../../ast';
-import type { WithDeploymentView } from './DeploymentViewParser';
-import type { WithPredicates } from './PredicatesParser';
-export type WithViewsParser = ReturnType<typeof ViewsParser>;
-type ViewRuleStyleOrGlobalRef = c4.ElementViewRuleStyle | c4.ViewRuleGlobalStyle;
-export declare function ViewsParser<TBase extends WithPredicates & WithDeploymentView>(B: TBase): {
-    new (...args: any[]): {
-        parseViews(): void;
-        parseElementView(astNode: ast.ElementView, additionalStyles: ViewRuleStyleOrGlobalRef[]): ParsedAstElementView;
-        parseElementViewRule(astRule: ast.ViewRule): c4.ElementViewRule;
-        parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ElementViewPredicate;
-        parseViewRuleGlobalPredicateRef(astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef): c4.ViewRuleGlobalPredicateRef;
-        parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): ViewRuleStyleOrGlobalRef;
-        parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ElementViewRuleGroup;
-        parseViewRuleRank(astRule: ast.ViewRuleRank): c4.ElementViewRuleRank;
-        parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ElementViewRuleStyle;
-        parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
-        parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: ViewRuleStyleOrGlobalRef[]): ParsedAstDynamicView;
-        parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
-        parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
-        parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicStepsParallel;
-        /**
-         * @returns non-empty array in case of step chain A -> B -> C
-         */
-        parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicStep | c4.DynamicStepsSeries;
-        recursiveParseDynamicStepChain(node: ast.DynamicStepChain, callstack?: Array<[source: c4.Fqn, target: c4.Fqn]>): c4.DynamicStep[];
-        parseDynamicStepSingle(node: ast.DynamicStepSingle): c4.DynamicStep;
-        parseAbstractDynamicStep(astnode: ast.AbstractDynamicStep): Writable<Except<c4.DynamicStep, "source", {
-            requireExactProps: true;
-        }>>;
-        parsePredicate(astNode: ast.ExpressionV2): c4.ModelExpression;
-        parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelFqnExpr.Any;
-        parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelFqnExpr.OrWhere;
-        parseElementExpression(astNode: ast.FqnExpr): c4.ModelFqnExpr;
-        parseElementPredicateWhere(astNode: ast.FqnExprWhere): c4.ModelFqnExpr.Where;
-        parseElementPredicateWith(astNode: ast.FqnExprWith): c4.ModelFqnExpr.Custom;
-        parseRelationPredicate(astNode: ast.RelationExprOrWith): c4.ModelRelationExpr.Any;
-        parseRelationPredicateOrWhere(astNode: ast.RelationExprOrWhere): c4.ModelRelationExpr.OrWhere;
-        parseRelationPredicateWhere(astNode: ast.RelationExprWhere): c4.ModelRelationExpr.Where;
-        parseRelationPredicateWith(astNode: ast.RelationExprWith): c4.ModelRelationExpr.Custom;
-        parseRelationExpression(astNode: ast.RelationExpr): c4.ModelRelationExpr;
-        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
-        parseExpressionV2(astNode: ast.ExpressionV2): c4.Expression;
-        parseFqnExprOrWith(astNode: ast.FqnExprOrWith): c4.FqnExpr.Any;
-        parseFqnExprWith(astNode: ast.FqnExprWith): c4.FqnExpr.Custom;
-        parseFqnExprOrWhere(astNode: ast.FqnExprOrWhere): c4.FqnExpr.OrWhere;
-        parseFqnExprWhere(astNode: ast.FqnExprWhere): c4.FqnExpr.Where;
-        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
-        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
-        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
-        parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
-        parseCustomRelationProperties(custom: ast.CustomRelationProperties | undefined): Except<c4.RelationExpr.Custom["customRelation"], "expr">;
-        parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
-        parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr.OrWhere;
-        parseInlineKindCondition(astNode: ast.OutgoingRelationExpr): c4.WhereOperator | null;
-        wrapInWhere(expr: c4.RelationExpr, condition: c4.WhereOperator | null): c4.RelationExpr.OrWhere;
-        isValid: import("../../validation").IsValidFn;
-        readonly services: import("../..").LikeC4Services;
-        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
-        get project(): import("../../workspace").Project;
-        resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: import("langium").AstNode): string;
-        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
-            [key: string]: string | string[];
-        } | undefined;
-        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
-        convertTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
-        parseTags<E extends {
-            tags?: ast.Tags;
-        }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
-        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
-        parseImageAlias(value: string): string | undefined;
-        parseColorLiteral(astNode: ast.ColorLiteral): c4.ColorLiteral | undefined;
-        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
-        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
-        parseBaseProps(props: {
-            title?: ast.MarkdownOrString | undefined;
-            summary?: ast.MarkdownOrString | undefined;
-            description?: ast.MarkdownOrString | undefined;
-            technology?: ast.MarkdownOrString | undefined;
-        }, override?: {
-            title?: string | undefined;
-            summary?: string | undefined;
-            description?: string | undefined;
-            technology?: string | undefined;
-        }): {
-            title?: string;
-            summary?: c4.MarkdownOrString;
-            description?: c4.MarkdownOrString;
-            technology?: string;
-        };
-        parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
-        parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
-        parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewPredicate;
-        parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle;
-        parseDeployment(): void;
-        parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
-        parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
-        parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
-        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4.FqnRef;
-        parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
-    };
-} & TBase;
-export {};

package/dist/model/parser/ViewsParser.js

@@ -1,492 +0,0 @@
-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 { safeCall, 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');
-const rankLogger = logger.getChild('rank');
-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 && safeCall(() => this.resolveFqn(viewOfEl));
-                if (!_viewOf) {
-                    const viewId = astNode.name ?? 'unnamed';
-                    const msg = astNode.viewOf.$cstNode?.text ?? '<unknown>';
-                    logger.warn(`viewOf {viewId} not resolved {msg}`, { msg, viewId });
-                }
-                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);
-            }
-            if (ast.isViewRuleRank(astRule)) {
-                return this.parseViewRuleRank(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),
-            };
-        }
-        parseViewRuleRank(astRule) {
-            const targets = this.parseFqnExpressions(astRule.targets).filter((e) => c4.ModelExpression.isFqnExpr(e));
-            const rank = astRule.value ?? 'same';
-            rankLogger.debug `Parsed rank constraint ${rank} with ${targets.length} target(s)`;
-            return {
-                rank,
-                targets,
-            };
-        }
-        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,18 +0,0 @@
-import { type ViewChange } from '@likec4/core';
-import { Range, TextEdit } from 'vscode-languageserver-types';
-import type { ViewLocateResult } from '../model';
-import type { LikeC4Services } from '../module';
-import type { ChangeView } from '../protocol';
-export declare class LikeC4ModelChanges {
-    private services;
-    private locator;
-    constructor(services: LikeC4Services);
-    applyChange(changeView: ChangeView.Params): Promise<ChangeView.Res>;
-    protected convertToTextEdit({ lookup, change }: {
-        lookup: ViewLocateResult;
-        change: Exclude<ViewChange, ViewChange.SaveViewSnapshot | ViewChange.ResetManualLayout>;
-    }): {
-        modifiedRange: Range;
-        edits: TextEdit[];
-    };
-}