@likec4/language-server 1.46.4 → 1.48.0

package/dist/validation/deployment-checks.js

@@ -1,140 +0,0 @@
-import { FqnRef, isSameHierarchy, nonNullable } from '@likec4/core';
-import { loggable } from '@likec4/log';
-import { AstUtils } from 'langium';
-import { ast } from '../ast';
-import { logger } from '../logger';
-import { projectIdFrom } from '../utils';
-import { RESERVED_WORDS, tryOrLog } from './_shared';
-const { getDocument } = AstUtils;
-export const deploymentNodeChecks = (services) => {
-    const DeploymentsIndex = services.likec4.DeploymentsIndex;
-    const Names = services.references.NameProvider;
-    return tryOrLog((el, accept) => {
-        const nodeName = Names.getName(el);
-        if (!nodeName) {
-            accept('error', 'DeploymentNode must be named', {
-                node: el,
-            });
-            return;
-        }
-        const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range;
-        if (RESERVED_WORDS.includes(nodeName)) {
-            accept('error', `Reserved word: ${nodeName}`, {
-                node: el,
-                range,
-            });
-        }
-        const projectId = projectIdFrom(el);
-        const fqnName = DeploymentsIndex.getFqn(el);
-        const withSameName = DeploymentsIndex.byFqn(projectId, fqnName).limit(2).toArray();
-        if (withSameName.length > 1) {
-            accept('error', `Duplicate node name "${fqnName}"`, {
-                node: el,
-                range,
-            });
-        }
-    });
-};
-export const deployedInstanceChecks = (services) => {
-    const DeploymentsIndex = services.likec4.DeploymentsIndex;
-    const Names = services.references.NameProvider;
-    // const Locator = services.workspace.AstNodeLocator
-    return tryOrLog((el, accept) => {
-        const artifactName = Names.getName(el);
-        if (!artifactName) {
-            accept('error', 'Deployed instance must be named, unique inside node', {
-                node: el,
-            });
-            return;
-        }
-        const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range;
-        if (RESERVED_WORDS.includes(artifactName)) {
-            accept('error', `Reserved word: ${artifactName}`, {
-                node: el,
-                range,
-            });
-        }
-        const projectId = projectIdFrom(el);
-        const fqnName = DeploymentsIndex.getFqn(el);
-        const withSameName = DeploymentsIndex.byFqn(projectId, fqnName).limit(2).toArray();
-        if (withSameName.length > 1) {
-            accept('error', `Duplicate instance name "${fqnName}"`, {
-                node: el,
-                range,
-            });
-        }
-    });
-};
-export const deploymentRelationChecks = (services) => {
-    const ModelParser = services.likec4.ModelParser;
-    return tryOrLog((el, accept) => {
-        const target = el.target?.value?.ref;
-        if (!target) {
-            let targetCstText = el.target?.$cstNode?.text ?? '';
-            accept('error', `DeploymentRelation target '${targetCstText}' not resolved`, {
-                node: el,
-                property: 'target',
-            });
-            return;
-        }
-        const doc = getDocument(el);
-        const parser = ModelParser.forDocument(doc);
-        let sourceFqnRef;
-        try {
-            sourceFqnRef = parser._resolveDeploymentRelationSource(el);
-        }
-        catch (e) {
-            logger.warn(loggable(e));
-            accept('error', 'DeploymentRelation source not resolved', {
-                node: el,
-                property: 'source',
-            });
-            return;
-        }
-        if (FqnRef.isImportRef(sourceFqnRef)) {
-            accept('error', 'DeploymentRelation cannot refer imported model (not implemented yet)', {
-                node: el,
-                property: 'source',
-            });
-            return;
-        }
-        if (FqnRef.isModelRef(sourceFqnRef)) {
-            accept('error', 'DeploymentRelation must refer deployment element', {
-                node: el,
-                property: 'source',
-            });
-            return;
-        }
-        const targetFqnRef = parser.parseFqnRef(el.target);
-        if (FqnRef.isImportRef(targetFqnRef)) {
-            accept('error', 'DeploymentRelation cannot refer imported model (not implemented yet)', {
-                node: el,
-                property: 'target',
-            });
-            return;
-        }
-        if (FqnRef.isModelRef(targetFqnRef)) {
-            accept('error', 'DeploymentRelation must refer deployment element', {
-                node: el,
-                property: 'target',
-            });
-            return;
-        }
-        if (isSameHierarchy(sourceFqnRef.deployment, targetFqnRef.deployment)) {
-            accept('error', 'Invalid parent-child relationship', {
-                node: el,
-            });
-        }
-    });
-};
-export const extendDeploymentChecks = (_services) => {
-    return tryOrLog((el, accept) => {
-        const target = el.deploymentNode.value.ref;
-        if (!target || !ast.isDeploymentNode(target)) {
-            accept('error', 'ExtendDeployment allows only DeploymentNode', {
-                node: el,
-                property: 'deploymentNode',
-            });
-        }
-    });
-};

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

@@ -1,6 +0,0 @@
-import { type ValidationCheck } from 'langium';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare const dynamicViewStepSingle: (services: LikeC4Services) => ValidationCheck<ast.DynamicStepSingle>;
-export declare const dynamicViewStepChain: (services: LikeC4Services) => ValidationCheck<ast.DynamicStepChain>;
-export declare const dynamicViewDisplayVariant: (_services: LikeC4Services) => ValidationCheck<ast.DynamicViewDisplayVariantProperty>;

package/dist/validation/dynamic-view.js

@@ -1,67 +0,0 @@
-import { isAncestor } from '@likec4/core';
-import { AstUtils } from 'langium';
-import { isEmpty } from 'remeda';
-import { ast } from '../ast';
-import { elementRef } from '../utils/elementRef';
-import { tryOrLog } from './_shared';
-export const dynamicViewStepSingle = (services) => {
-    const fqnIndex = services.likec4.FqnIndex;
-    return tryOrLog((el, accept) => {
-        const sourceEl = elementRef(el.source);
-        const source = sourceEl && fqnIndex.getFqn(sourceEl);
-        if (!source) {
-            accept('error', 'Source not found (not parsed/indexed yet)', {
-                node: el,
-                property: 'source',
-            });
-        }
-        const targetEl = elementRef(el.target);
-        const target = targetEl && fqnIndex.getFqn(targetEl);
-        if (!target) {
-            accept('error', 'Target not found (not parsed/indexed yet)', {
-                node: el,
-                property: 'target',
-            });
-        }
-        if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
-            accept('error', 'Invalid parent-child relationship', {
-                node: el,
-            });
-        }
-    });
-};
-export const dynamicViewStepChain = (services) => {
-    const fqnIndex = services.likec4.FqnIndex;
-    return tryOrLog((el, accept) => {
-        const source = el.source;
-        if (ast.isDynamicStepSingle(source) && source.isBackward) {
-            accept('error', 'Invalid chain after backward step', {
-                node: el,
-            });
-        }
-        const targetEl = elementRef(el.target);
-        const target = targetEl && fqnIndex.getFqn(targetEl);
-        if (!target) {
-            accept('error', 'Target not found (not parsed/indexed yet)', {
-                node: el,
-                property: 'target',
-            });
-        }
-    });
-};
-export const dynamicViewDisplayVariant = (_services) => {
-    return tryOrLog((prop, accept) => {
-        if (isEmpty(prop.value) || (prop.value !== 'diagram' && prop.value !== 'sequence')) {
-            accept('error', 'Invalid display variant: "diagram" or "sequence" are allowed', {
-                node: prop,
-                property: 'value',
-            });
-            return;
-        }
-        if (!AstUtils.hasContainerOfType(prop, ast.isDynamicViewBody)) {
-            accept('error', `Display mode can be defined only inside dynamic view`, {
-                node: prop,
-            });
-        }
-    });
-};

package/dist/validation/element-ref.d.ts

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

package/dist/validation/element-ref.js

@@ -1,12 +0,0 @@
-import { isReferenceToDeploymentModel } from '../utils';
-import { tryOrLog } from './_shared';
-export const checkElementRef = (_services) => {
-    return tryOrLog((el, accept) => {
-        if (isReferenceToDeploymentModel(el.modelElement)) {
-            accept('error', 'Only model elements allowed here', {
-                node: el,
-                property: 'modelElement',
-            });
-        }
-    });
-};

package/dist/validation/element.d.ts

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

package/dist/validation/element.js

@@ -1,49 +0,0 @@
-import { AstUtils } from 'langium';
-import { projectIdFrom } from '../utils';
-import { RESERVED_WORDS, tryOrLog } from './_shared';
-const { getDocument } = AstUtils;
-export const checkElement = (services) => {
-    const fqnIndex = services.likec4.FqnIndex;
-    const locator = services.workspace.AstNodeLocator;
-    return tryOrLog((el, accept) => {
-        const fqn = fqnIndex.getFqn(el);
-        if (!fqn) {
-            accept('error', 'Not indexed element', {
-                node: el,
-                property: 'name',
-            });
-            return;
-        }
-        if (RESERVED_WORDS.includes(el.name)) {
-            accept('error', `Reserved word: ${el.name}`, {
-                node: el,
-                property: 'name',
-            });
-        }
-        const doc = getDocument(el);
-        const docUri = doc.uri;
-        const elPath = locator.getAstNodePath(el);
-        const withSameFqn = fqnIndex
-            .byFqn(projectIdFrom(doc), fqn)
-            .filter(v => v.documentUri !== docUri || v.path !== elPath)
-            .head();
-        if (withSameFqn) {
-            const isAnotherDoc = withSameFqn.documentUri !== docUri;
-            accept('error', `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`, {
-                node: el,
-                property: 'name',
-                ...isAnotherDoc && {
-                    relatedInformation: [
-                        {
-                            location: {
-                                range: (withSameFqn.nameSegment?.range ?? withSameFqn.selectionSegment?.range),
-                                uri: withSameFqn.documentUri.toString(),
-                            },
-                            message: `conflicting element`,
-                        },
-                    ],
-                },
-            });
-        }
-    });
-};

package/dist/validation/imports.d.ts

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

package/dist/validation/imports.js

@@ -1,46 +0,0 @@
-import { AstUtils } from 'langium';
-import { projectIdFrom } from '../utils';
-import { tryOrLog } from './_shared';
-const { getDocument } = AstUtils;
-export const checkImportsFromPoject = (services) => {
-    const projects = services.shared.workspace.ProjectsManager;
-    return tryOrLog((el, accept) => {
-        const doc = getDocument(el);
-        const projectId = projectIdFrom(doc);
-        if (el.project === projectId) {
-            accept('error', 'Imported project cannot be the same as the current project', {
-                node: el,
-                property: 'project',
-            });
-            return;
-        }
-        if (!projects.all.includes(el.project)) {
-            accept('error', 'Imported project not found', {
-                node: el,
-                property: 'project',
-            });
-            return;
-        }
-    });
-};
-// export const checkImported = (services: LikeC4Services): ValidationCheck<ast.Imported> => {
-//   const fqnIndex = services.likec4.FqnIndex
-//   const projects = services.shared.workspace.ProjectsManager
-//   return tryOrLog((el, accept) => {
-//     const doc = getDocument(el)
-//     const importFromProject = el.$container.project as ProjectId
-//     if (importFromProject === projectId || !projects.all.includes(importFromProject)) {
-//       accept('error', 'Invalid import', {
-//         node: el,
-//       })
-//       return
-//     }
-//     const fqn = fqnIndex.byFqn(importFromProject, el.element.$refText as Fqn).head()
-//     if (!fqn) {
-//       accept('error', `Imported element not found in project "${importFromProject}"`, {
-//         node: el,
-//       })
-//       return
-//     }
-//   })
-// }

package/dist/validation/index.d.ts

@@ -1,15 +0,0 @@
-import { type AstNode } from 'langium';
-import { type LikeC4LangiumDocument, ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export { LikeC4DocumentValidator } from './DocumentValidator';
-type Guard<N extends AstNode> = (n: AstNode) => n is N;
-type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | ast.RelationStringProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.Imported | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.ViewRuleRank | ast.DynamicViewParallelSteps | ast.SpecificationRelationshipKind | ast.SpecificationRule | ast.ElementRef | ast.DeploymentRelation | ast.Relation | ast.GlobalDynamicPredicateGroup | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyle | ast.SpecificationDeploymentNodeKind | ast.SpecificationElementKind | ast.GlobalStyleGroup | ast.SpecificationColor | ast.NavigateToProperty | ast.Tags | ast.ExtendRelation | ast.ImportsFromPoject | ast.SpecificationTag;
-type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
-export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
-    isValid: (n: ValidatableAstNode) => boolean;
-    invalidNodes: WeakSet<object>;
-};
-export type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
-export type IsValidFn = ChecksFromDiagnostics['isValid'];
-export declare function registerValidationChecks(services: LikeC4Services): void;

package/dist/validation/index.js

@@ -1,167 +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 { onNextTick } from '@likec4/core/utils';
-import { loggable } from '@likec4/log';
-import { DocumentState } from 'langium';
-import { isNullish } from 'remeda';
-import { DiagnosticSeverity } from 'vscode-languageserver-types';
-import { ast } from '../ast';
-import { logger } from '../logger';
-import { deployedInstanceChecks, deploymentNodeChecks, deploymentRelationChecks, extendDeploymentChecks, } from './deployment-checks';
-import { dynamicViewDisplayVariant, dynamicViewStepChain, dynamicViewStepSingle } from './dynamic-view';
-import { checkElement } from './element';
-import { checkElementRef } from './element-ref';
-import { checkImportsFromPoject } from './imports';
-import { colorLiteralRuleChecks, iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChecks, } from './property-checks';
-import { checkRelationBody, extendRelationChecks, relationChecks } from './relation';
-import { checkDeploymentNodeKind, checkElementKind, checkGlobalPredicate, checkGlobals, checkGlobalStyleId, checkModel, checkRelationshipKind, checkSpecificationRule, checkTag, } from './specification';
-import { viewChecks } from './view';
-import { viewRuleRankChecks } from './view-checks';
-import { checkFqnExprWith, checkFqnRefExpr, checkIncomingRelationExpr, checkOutgoingRelationExpr, checkRelationExpr, checkRelationExprWith, } from './view-predicates';
-export { LikeC4DocumentValidator } from './DocumentValidator';
-function validatableAstNodeGuards(predicates) {
-    return (n) => predicates.some(p => p(n));
-}
-const isValidatableAstNode = validatableAstNodeGuards([
-    ast.isImportsFromPoject,
-    ast.isImported,
-    ast.isGlobals,
-    ast.isGlobalPredicateGroup,
-    ast.isGlobalDynamicPredicateGroup,
-    ast.isGlobalStyle,
-    ast.isGlobalStyleGroup,
-    ast.isFqnExprWith,
-    ast.isRelationExprWith,
-    ast.isFqnExpr,
-    ast.isRelationExpr,
-    ast.isDynamicViewParallelSteps,
-    ast.isDynamicStepChain,
-    ast.isDynamicStepSingle,
-    ast.isDeploymentViewRule,
-    ast.isDeploymentViewRulePredicate,
-    ast.isExpressionV2,
-    ast.isRelationExpr,
-    ast.isFqnRefExpr,
-    ast.isViewProperty,
-    ast.isStyleProperty,
-    ast.isTags,
-    ast.isViewRule,
-    ast.isDynamicViewRule,
-    ast.isLikeC4View,
-    ast.isViewRuleStyleOrGlobalRef,
-    ast.isDeployedInstance,
-    ast.isDeploymentNode,
-    ast.isDeploymentRelation,
-    ast.isRelationshipStyleProperty,
-    ast.isDynamicViewDisplayVariantProperty,
-    ast.isMetadataProperty,
-    ast.isRelation,
-    ast.isElementProperty,
-    ast.isStringProperty,
-    ast.isNavigateToProperty,
-    ast.isElement,
-    ast.isElementRef,
-    ast.isExtendElement,
-    ast.isExtendDeployment,
-    ast.isExtendRelation,
-    ast.isSpecificationElementKind,
-    ast.isSpecificationRelationshipKind,
-    ast.isSpecificationDeploymentNodeKind,
-    ast.isSpecificationTag,
-    ast.isSpecificationColor,
-    ast.isSpecificationRule,
-    ast.isColorLiteral,
-]);
-const findInvalidContainer = (node) => {
-    let nd = node;
-    while (nd && !ast.isLikeC4Grammar(nd)) {
-        if (isValidatableAstNode(nd)) {
-            return nd;
-        }
-        nd = nd.$container;
-    }
-    return undefined;
-};
-export function checksFromDiagnostics(doc) {
-    const errors = doc.state >= DocumentState.Validated
-        ? (doc.diagnostics?.filter(d => d.severity === DiagnosticSeverity.Error) ?? [])
-        : [];
-    const invalidNodes = new WeakSet();
-    for (const { node } of errors) {
-        if (isNullish(node) || invalidNodes.has(node)) {
-            continue;
-        }
-        invalidNodes.add(node);
-        const container = findInvalidContainer(node);
-        if (container) {
-            invalidNodes.add(container);
-        }
-    }
-    const isValid = (n) => !invalidNodes.has(n);
-    return {
-        isValid,
-        invalidNodes,
-    };
-}
-export function registerValidationChecks(services) {
-    logger.debug('registerValidationChecks');
-    const registry = services.validation.ValidationRegistry;
-    registry.register({
-        DeployedInstance: deployedInstanceChecks(services),
-        DeploymentNodeKind: checkDeploymentNodeKind(services),
-        DeploymentNode: deploymentNodeChecks(services),
-        DeploymentRelation: deploymentRelationChecks(services),
-        ExtendDeployment: extendDeploymentChecks(services),
-        ExtendRelation: extendRelationChecks(services),
-        FqnRefExpr: checkFqnRefExpr(services),
-        RelationExpr: checkRelationExpr(services),
-        NotesProperty: notesPropertyRuleChecks(services),
-        OpacityProperty: opacityPropertyRuleChecks(services),
-        IconProperty: iconPropertyRuleChecks(services),
-        SpecificationRule: checkSpecificationRule(services),
-        Model: checkModel(services),
-        Globals: checkGlobals(services),
-        GlobalPredicateGroup: checkGlobalPredicate(services),
-        GlobalDynamicPredicateGroup: checkGlobalPredicate(services),
-        GlobalStyleId: checkGlobalStyleId(services),
-        DynamicStepSingle: dynamicViewStepSingle(services),
-        DynamicStepChain: dynamicViewStepChain(services),
-        LikeC4View: viewChecks(services),
-        Element: checkElement(services),
-        ElementRef: checkElementRef(services),
-        ElementKind: checkElementKind(services),
-        Relation: relationChecks(services),
-        RelationBody: checkRelationBody(services),
-        Tag: checkTag(services),
-        FqnExprWith: checkFqnExprWith(services),
-        RelationExprWith: checkRelationExprWith(services),
-        RelationshipKind: checkRelationshipKind(services),
-        IncomingRelationExpr: checkIncomingRelationExpr(services),
-        OutgoingRelationExpr: checkOutgoingRelationExpr(services),
-        ImportsFromPoject: checkImportsFromPoject(services),
-        // Imported: checkImported(services),
-        ColorLiteral: colorLiteralRuleChecks(services),
-        DynamicViewDisplayVariantProperty: dynamicViewDisplayVariant(services),
-        ViewRuleRank: viewRuleRankChecks(services),
-    });
-    const connection = services.shared.lsp.Connection;
-    if (connection) {
-        // delay initialization
-        onNextTick(() => {
-            // workaround for bug in langium
-            services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
-                for (const uri of deleted) {
-                    logger.debug(`clear diagnostics for deleted ${uri.path}`);
-                    connection.sendDiagnostics({
-                        uri: uri.toString(),
-                        diagnostics: [],
-                    }).catch(e => logger.error(loggable(e)));
-                }
-            });
-        });
-    }
-}

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

@@ -1,7 +0,0 @@
-import { type ValidationCheck } from 'langium';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare const opacityPropertyRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.OpacityProperty>;
-export declare const iconPropertyRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.IconProperty>;
-export declare const notesPropertyRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.NotesProperty>;
-export declare const colorLiteralRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.ColorLiteral>;

package/dist/validation/property-checks.js

@@ -1,108 +0,0 @@
-import { nonexhaustive } from '@likec4/core';
-import { AstUtils } from 'langium';
-import { isNumber, isString } from 'remeda';
-import { ast } from '../ast';
-import { tryOrLog } from './_shared';
-export const opacityPropertyRuleChecks = (_) => {
-    return tryOrLog((node, accept) => {
-        const opacity = parseFloat(node.value);
-        if (isNaN(opacity) || opacity < 0 || opacity > 100) {
-            accept('warning', `Value ignored, must be between 0% and 100%`, {
-                node,
-                property: 'value',
-            });
-        }
-    });
-};
-export const iconPropertyRuleChecks = (_) => {
-    return (node, accept) => {
-        const container = node.$container;
-        const anotherIcon = container.props.some(p => ast.isIconProperty(p) && p !== node);
-        if (anotherIcon) {
-            accept('error', `Icon must be defined once`, {
-                node,
-            });
-        }
-        if (ast.isElementStyleProperty(container) && ast.isElementBody(container.$container)
-            && container.$container.props.some(p => ast.isIconProperty(p))) {
-            accept('warning', `Redundant as icon defined on element`, {
-                node,
-            });
-        }
-        if (node.value?.startsWith('file://')) {
-            accept('error', `Icon URI must not start with file://`, {
-                node,
-                property: 'value',
-            });
-        }
-    };
-};
-export const notesPropertyRuleChecks = (_) => {
-    return (node, accept) => {
-        if (!AstUtils.hasContainerOfType(node, ast.isDynamicViewStep)) {
-            accept('error', `Notes can be defined only inside dynamic view`, {
-                node,
-            });
-        }
-    };
-};
-export const colorLiteralRuleChecks = (_) => {
-    return (node, accept) => {
-        if (node.$type === 'HexColor') {
-            if (node.hex === undefined || (isString(node.hex) && !node.hex.match(/^[a-fA-F0-9]+$/))) {
-                accept('error', `Invalid HEX`, {
-                    node,
-                    property: 'hex',
-                });
-                return;
-            }
-            const length = isNumber(node.hex) ? node.hex.toString().length : node.hex.length;
-            if (length !== 6 && length !== 3 && length !== 8) {
-                accept('error', `Invalid value "${node.$cstNode?.text}", must be 3, 6 or 8 characters long`, {
-                    node,
-                    property: 'hex',
-                });
-            }
-            return;
-        }
-        if (node.$type === 'RGBAColor') {
-            if (!isNumber(node.red) || node.red < 0 || node.red > 255) {
-                accept('error', `Invalid value, must be between 0 and 255`, {
-                    node,
-                    property: 'red',
-                });
-            }
-            if (!isNumber(node.green) || node.green < 0 || node.green > 255) {
-                accept('error', `Invalid value, must be between 0 and 255`, {
-                    node,
-                    property: 'green',
-                });
-            }
-            if (!isNumber(node.blue) || node.blue < 0 || node.blue > 255) {
-                accept('error', `Invalid value, must be between 0 and 255`, {
-                    node,
-                    property: 'blue',
-                });
-            }
-            if (isNumber(node.alpha)) {
-                if (node.alpha < 0 || node.alpha > 1) {
-                    accept('error', `Invalid value, must be between 0 and 1`, {
-                        node,
-                        property: 'alpha',
-                    });
-                }
-            }
-            if (isString(node.alpha)) {
-                const alpha = parseFloat(node.alpha);
-                if (alpha < 0 || alpha > 100) {
-                    accept('error', `Invalid value, must be between 0% and 100%`, {
-                        node,
-                        property: 'alpha',
-                    });
-                }
-            }
-            return;
-        }
-        nonexhaustive(node);
-    };
-};

package/dist/validation/relation.d.ts

@@ -1,6 +0,0 @@
-import { type ValidationCheck } from 'langium';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare const relationChecks: (services: LikeC4Services) => ValidationCheck<ast.Relation>;
-export declare const checkRelationBody: (_services: LikeC4Services) => ValidationCheck<ast.RelationBody>;
-export declare const extendRelationChecks: (services: LikeC4Services) => ValidationCheck<ast.ExtendRelation>;