@likec4/language-server 0.6.3 → 0.18.0

package/dist/protocol.d.ts

@@ -0,0 +1,36 @@
+import type { Fqn, LikeC4Model, RelationID, ViewID } from '@likec4/core';
+import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
+import { NotificationType0, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+interface BuildDocumentsParams {
+    docs: DocumentUri[];
+}
+export interface LocateElementParams {
+    element: Fqn;
+    property?: string;
+}
+export declare const locateElement: RequestType<LocateElementParams, Location | null, void>;
+export declare const locateRelation: RequestType<{
+    id: RelationID;
+}, Location | null, void>;
+export declare const locateView: RequestType<{
+    id: ViewID;
+}, Location | null, void>;
+export declare const Rpc: {
+    readonly onDidChangeModel: NotificationType0;
+    readonly fetchModel: RequestType0<{
+        model: LikeC4Model | null;
+    }, void>;
+    readonly rebuild: RequestType0<{
+        docs: DocumentUri[];
+    }, void>;
+    readonly buildDocuments: RequestType<BuildDocumentsParams, void, void>;
+    readonly locateElement: RequestType<LocateElementParams, Location | null, void>;
+    readonly locateRelation: RequestType<{
+        id: RelationID;
+    }, Location | null, void>;
+    readonly locateView: RequestType<{
+        id: ViewID;
+    }, Location | null, void>;
+};
+export {};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -0,0 +1,22 @@
+import { NotificationType0, RequestType0, RequestType } from 'vscode-languageserver-protocol';
+//#region From server
+const onDidChangeModel = new NotificationType0('likec4/onDidChangeModel');
+//#endregion
+//#region To server
+const fetchModel = new RequestType0('likec4/fetchModel');
+const rebuild = new RequestType0('likec4/rebuildModel');
+const buildDocuments = new RequestType('likec4/buildDocuments');
+export const locateElement = new RequestType('likec4/locateElement');
+export const locateRelation = new RequestType('likec4/locateRelation');
+export const locateView = new RequestType('likec4/locateView');
+//#endregion
+export const Rpc = {
+    onDidChangeModel,
+    fetchModel,
+    rebuild,
+    buildDocuments,
+    locateElement,
+    locateRelation,
+    locateView
+};
+//# sourceMappingURL=protocol.js.map

package/dist/references/index.d.ts

@@ -1,2 +1,3 @@
 export * from './scope-computation';
 export * from './scope-provider';
+//# sourceMappingURL=index.d.ts.map

package/dist/references/index.js

@@ -1,2 +1,3 @@
 export * from './scope-computation';
 export * from './scope-provider';
+//# sourceMappingURL=index.js.map

package/dist/references/scope-computation.d.ts

@@ -1,10 +1,14 @@
 import { DefaultScopeComputation, MultiMap, type AstNodeDescription, type PrecomputedScopes } from 'langium';
-import type { CancellationToken } from 'vscode-languageserver-protocol';
+import type { CancellationToken } from 'vscode-languageserver';
 import { ast, type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
 export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
+    private services;
+    constructor(services: LikeC4Services);
     computeExports(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<AstNodeDescription[]>;
     computeLocalScopes(document: LikeC4LangiumDocument, _cancelToken: CancellationToken): Promise<PrecomputedScopes>;
     protected processContainer(container: ElementsContainer, scopes: PrecomputedScopes, document: LikeC4LangiumDocument): MultiMap<string, AstNodeDescription>;
 }
 export {};
+//# sourceMappingURL=scope-computation.d.ts.map

package/dist/references/scope-computation.js

@@ -1,9 +1,11 @@
 import { DefaultScopeComputation, MultiMap } from 'langium';
 import { ast } from '../ast';
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
-    // constructor(services: LikeC4Services) {
-    //   super(services)
-    // }
+    services;
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
     computeExports(document, _cancelToken) {
         const { specification, model, views } = document.parseResult.value;
         const docExports = [];
@@ -16,6 +18,7 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
                 docExports.push(this.descriptions.createDescription(tag, '#' + tag.name, document));
             }
         }
+        document.c4fqns = undefined;
         if (model) {
             for (const elAst of model.elements) {
                 if (ast.isElement(elAst)) {
@@ -23,6 +26,10 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
                 }
             }
         }
+        // const c4fqns = document.c4fqns
+        // logger.debug(`doc ${document.uri.path}:
+        //  fqns: ${c4fqns ? Array.from(c4fqns.keys()).join(', ') : '--'}
+        // `)
         if (views) {
             for (const viewAst of views.views) {
                 if ('name' in viewAst) {
@@ -74,3 +81,4 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         return localScope;
     }
 }
+//# sourceMappingURL=scope-computation.js.map

package/dist/references/scope-provider.d.ts

@@ -4,7 +4,10 @@ import type { LikeC4Services } from '../module';
 export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     private fqnIndex;
     constructor(services: LikeC4Services);
+    private directChildrenOf;
+    private uniqueDescedants;
     private scopeElementRef;
+    private scopeExtendElement;
     private scopeElementView;
     getScope(context: ReferenceInfo): Scope;
     protected computeScope(node: AstNode, referenceType: string): Scope;
@@ -13,3 +16,4 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
      */
     protected getGlobalScope(referenceType: string): Scope;
 }
+//# sourceMappingURL=scope-provider.d.ts.map

package/dist/references/scope-provider.js

@@ -1,22 +1,34 @@
-import { DONE_RESULT, DefaultScopeProvider, EMPTY_SCOPE, StreamImpl, StreamScope, getDocument, stream, EMPTY_STREAM } from 'langium';
+import { DONE_RESULT, DefaultScopeProvider, EMPTY_STREAM, StreamImpl, StreamScope, getDocument, stream } from 'langium';
 import { ast } from '../ast';
-import { elementRef, isElementRefHead, parentStrictElementRef, strictElementRefFqn } from '../elementRef';
+import { elementRef, isElementRefHead, parentStrictElementRef } from '../elementRef';
+import { logger } from '../logger';
+function toAstNodeDescription(entry) {
+    return {
+        documentUri: entry.doc.uri,
+        name: entry.name,
+        path: entry.path,
+        type: ast.Element
+    };
+}
 export class LikeC4ScopeProvider extends DefaultScopeProvider {
     fqnIndex;
     constructor(services) {
         super(services);
         this.fqnIndex = services.likec4.FqnIndex;
     }
-    scopeElementRef(ref) {
-        const parentNode = ref.$container;
-        if (!ast.isElementRef(parentNode)) {
-            throw new Error('Expected be inside ElementRef');
-        }
+    directChildrenOf(parent) {
+        return this.fqnIndex
+            .directChildrenOf(parent)
+            .map(toAstNodeDescription);
+    }
+    uniqueDescedants(of) {
         return new StreamImpl(() => {
-            const parent = parentNode.el.ref;
-            const fqn = parent && this.fqnIndex.get(parent);
+            const element = of();
+            const fqn = element && this.fqnIndex.get(element);
             if (fqn) {
-                return this.fqnIndex.uniqueDescedants(fqn).iterator();
+                return this.fqnIndex.uniqueDescedants(fqn)
+                    .map(toAstNodeDescription)
+                    .iterator();
             }
             return null;
         }, iterator => {
@@ -26,27 +38,25 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             return DONE_RESULT;
         });
     }
+    scopeElementRef(ref) {
+        const parentNode = ref.$container;
+        if (!ast.isElementRef(parentNode)) {
+            throw new Error('Expected be inside ElementRef');
+        }
+        return this.uniqueDescedants(() => parentNode.el.ref);
+    }
+    scopeExtendElement(extend) {
+        return this.uniqueDescedants(() => elementRef(extend.element));
+    }
     scopeElementView({ viewOf }) {
         if (!viewOf) {
             return EMPTY_STREAM;
         }
-        return new StreamImpl(() => {
-            const target = elementRef(viewOf);
-            const fqn = target && this.fqnIndex.get(target);
-            if (fqn) {
-                return this.fqnIndex.uniqueDescedants(fqn).iterator();
-            }
-            return null;
-        }, iterator => {
-            if (iterator) {
-                return iterator.next();
-            }
-            return DONE_RESULT;
-        });
+        return this.uniqueDescedants(() => elementRef(viewOf));
     }
     getScope(context) {
+        const referenceType = this.reflection.getReferenceType(context);
         try {
-            const referenceType = this.reflection.getReferenceType(context);
             const node = context.container;
             // const path = this.services.workspace.AstNodeLocator.getAstNodePath(node)
             if (referenceType === ast.Element) {
@@ -55,7 +65,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
                         return this.getGlobalScope(referenceType);
                     }
                     const parent = parentStrictElementRef(node);
-                    return new StreamScope(this.fqnIndex.directChildrenOf(parent));
+                    return new StreamScope(this.directChildrenOf(parent));
                 }
                 if (ast.isElementRef(node) && !isElementRefHead(node)) {
                     return new StreamScope(this.scopeElementRef(node));
@@ -64,9 +74,9 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
             return this.computeScope(node, referenceType);
         }
         catch (e) {
-            console.error(e);
-            // logger.error(e)
-            return EMPTY_SCOPE;
+            // console.error(e)
+            logger.error(e);
+            return this.getGlobalScope(referenceType);
         }
     }
     computeScope(node, referenceType) {
@@ -87,8 +97,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
                 }
                 if (referenceType === ast.Element) {
                     if (ast.isExtendElementBody(container)) {
-                        const extendsOf = strictElementRefFqn(container.$container.element);
-                        scopes.push(this.fqnIndex.uniqueDescedants(extendsOf));
+                        scopes.push(this.scopeExtendElement(container.$container));
                     }
                     if (ast.isViewRule(container)) {
                         scopes.push(this.scopeElementView(container.$container));
@@ -108,3 +117,4 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         return new StreamScope(this.indexManager.allElements(referenceType));
     }
 }
+//# sourceMappingURL=scope-provider.js.map

package/dist/registerProtocolHandlers.d.ts

@@ -1,2 +1,3 @@
 import type { LikeC4Services } from './module';
 export declare function registerProtocolHandlers(services: LikeC4Services): void;
+//# sourceMappingURL=registerProtocolHandlers.d.ts.map

package/dist/registerProtocolHandlers.js

@@ -1,5 +1,6 @@
+import { URI } from 'vscode-uri';
 import { logger } from './logger';
-import { buildDocuments, fetchLikeC4Model, locateElement, locateRelation, locateView } from '@likec4/language-protocol';
+import { Rpc } from './protocol';
 export function registerProtocolHandlers(services) {
     const connection = services.shared.lsp.Connection;
     if (!connection) {
@@ -8,7 +9,7 @@ export function registerProtocolHandlers(services) {
     const modelBuilder = services.likec4.ModelBuilder;
     const modelLocator = services.likec4.ModelLocator;
     const LangiumDocuments = services.shared.workspace.LangiumDocuments;
-    connection.onRequest(fetchLikeC4Model, async (_cancelToken) => {
+    connection.onRequest(Rpc.fetchModel, async (_cancelToken) => {
         let model;
         try {
             model = modelBuilder.buildModel() ?? null;
@@ -17,27 +18,56 @@ export function registerProtocolHandlers(services) {
             model = null;
             logger.error(e);
         }
-        return Promise.resolve({
-            model: model ?? null
-        });
+        return Promise.resolve({ model });
     });
-    connection.onRequest(buildDocuments, async (docs, cancelToken) => {
+    connection.onRequest(Rpc.rebuild, async (cancelToken) => {
+        const changed = LangiumDocuments.all.map(d => d.uri).toArray();
+        logger.debug(`Rebuild all documents: [
+      ${changed.map(d => d.toString()).join('\n      ')}
+    ]`);
+        await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
+        return {
+            docs: changed.map(d => d.toString())
+        };
+    });
+    connection.onRequest(Rpc.buildDocuments, async ({ docs }, cancelToken) => {
+        if (docs.length === 0) {
+            logger.debug(`Received empty request to rebuild`);
+            return;
+        }
+        logger.debug(`Received request to rebuild: [
+      ${docs.join('\n      ')}
+    ]`);
         const changed = [];
         for (const d of docs) {
-            const uri = d;
-            if (LangiumDocuments.hasDocument(uri)) {
-                changed.push(uri);
+            try {
+                const uri = URI.parse(d);
+                if (LangiumDocuments.hasDocument(uri)) {
+                    changed.push(uri);
+                }
+                else {
+                    logger.warn(`LangiumDocuments does not have document: ${d}`);
+                    LangiumDocuments.getOrCreateDocument(uri);
+                }
             }
-            else {
-                logger.error(`LangiumDocuments does not have document: ${uri.toString()}`);
+            catch (e) {
+                logger.error(e);
             }
         }
-        logger.debug(`Received request to rebuild: [
-      ${changed.map(d => d.toString()).join('\n      ')}
-    ]`);
+        if (changed.length !== docs.length) {
+            const all = LangiumDocuments.all.map(d => d.uri.toString()).toArray();
+            logger.warn(`
+We have in LangiumDocuments: [
+  ${all.join('\n  ')}
+]
+We rebuild: [
+  ${changed.join('\n  ')}
+]
+`.trim());
+        }
         await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
     });
-    connection.onRequest(locateElement, async ({ element, property }, _cancelToken) => {
+    connection.onRequest(Rpc.locateElement, async ({ element, property }, _cancelToken) => {
         try {
             return Promise.resolve(modelLocator.locateElement(element, property ?? 'name'));
         }
@@ -45,7 +75,7 @@ export function registerProtocolHandlers(services) {
             return Promise.reject(e);
         }
     });
-    connection.onRequest(locateRelation, ({ id }, _cancelToken) => {
+    connection.onRequest(Rpc.locateRelation, ({ id }, _cancelToken) => {
         try {
             return Promise.resolve(modelLocator.locateRelation(id));
         }
@@ -53,7 +83,7 @@ export function registerProtocolHandlers(services) {
             return Promise.reject(e);
         }
     });
-    connection.onRequest(locateView, ({ id }, _cancelToken) => {
+    connection.onRequest(Rpc.locateView, ({ id }, _cancelToken) => {
         try {
             return Promise.resolve(modelLocator.locateView(id));
         }
@@ -62,3 +92,4 @@ export function registerProtocolHandlers(services) {
         }
     });
 }
+//# sourceMappingURL=registerProtocolHandlers.js.map

package/dist/shared/CodeLensProvider.d.ts

@@ -1,8 +1,9 @@
 import type { LangiumDocument, LangiumSharedServices, MaybePromise } from 'langium';
 import type { CodeLensProvider } from 'langium/lib/lsp/code-lens-provider';
-import type { CancellationToken, CodeLens, CodeLensParams } from 'vscode-languageserver-protocol';
+import type { CancellationToken, CodeLens, CodeLensParams } from 'vscode-languageserver';
 export declare class LikeC4CodeLensProvider implements CodeLensProvider {
     private services;
     constructor(services: LangiumSharedServices);
     provideCodeLens(doc: LangiumDocument, _params: CodeLensParams, _cancelToken?: CancellationToken): MaybePromise<CodeLens[] | undefined>;
 }
+//# sourceMappingURL=CodeLensProvider.d.ts.map

package/dist/shared/CodeLensProvider.js

@@ -33,3 +33,4 @@ export class LikeC4CodeLensProvider {
         });
     }
 }
+//# sourceMappingURL=CodeLensProvider.js.map

package/dist/shared/WorkspaceManager.d.ts

@@ -1,6 +1,6 @@
 import type { LangiumDocument, LangiumDocumentFactory, LangiumSharedServices } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
-import type { WorkspaceFolder } from 'vscode-languageserver-protocol';
+import type { WorkspaceFolder } from 'vscode-languageserver';
 export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
     protected readonly documentFactory: LangiumDocumentFactory;
     constructor(services: LangiumSharedServices);
@@ -9,5 +9,6 @@ export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      * folders and add them to the collector. This can be used to include built-in libraries of
      * your language, which can be either loaded from provided files or constructed in memory.
      */
-    protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
+    protected loadAdditionalDocuments(_folders: WorkspaceFolder[], _collector: (document: LangiumDocument) => void): Promise<void>;
 }
+//# sourceMappingURL=WorkspaceManager.d.ts.map

package/dist/shared/WorkspaceManager.js

@@ -1,6 +1,4 @@
 import { DefaultWorkspaceManager } from 'langium';
-import { URI } from 'vscode-uri';
-import * as builtin from '../builtin';
 export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
     documentFactory;
     constructor(services) {
@@ -12,8 +10,9 @@ export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      * folders and add them to the collector. This can be used to include built-in libraries of
      * your language, which can be either loaded from provided files or constructed in memory.
      */
-    loadAdditionalDocuments(folders, collector) {
-        collector(this.documentFactory.fromString(builtin.specification.document, URI.parse(builtin.specification.uri)));
+    loadAdditionalDocuments(_folders, _collector) {
+        // collector(this.documentFactory.fromString(builtin.specification.document, URI.parse(builtin.specification.uri)))
         return Promise.resolve();
     }
 }
+//# sourceMappingURL=WorkspaceManager.js.map

package/dist/shared/index.d.ts

@@ -1,2 +1,3 @@
 export * from './CodeLensProvider';
 export * from './WorkspaceManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/index.js

@@ -1,2 +1,3 @@
 export * from './CodeLensProvider';
 export * from './WorkspaceManager';
+//# sourceMappingURL=index.js.map

package/dist/test/index.d.ts

@@ -0,0 +1,2 @@
+export * from './testServices';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/index.js

@@ -0,0 +1,2 @@
+export * from './testServices';
+//# sourceMappingURL=index.js.map

package/dist/test/testServices.d.ts

@@ -0,0 +1,16 @@
+import type { LikeC4LangiumDocument } from '../ast';
+export declare function createTestServices(): {
+    services: import("../module").LikeC4Services;
+    parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
+    validate: (input: string | LikeC4LangiumDocument) => Promise<{
+        document: LikeC4LangiumDocument;
+        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        errors: string[];
+    }>;
+    validateAll: () => Promise<{
+        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        errors: string[];
+    }>;
+    buildModel: () => Promise<import("@likec4/core").LikeC4Model>;
+};
+//# sourceMappingURL=testServices.d.ts.map

package/dist/test/testServices.js

@@ -0,0 +1,58 @@
+import { createLanguageServices } from '../module';
+import { EmptyFileSystem } from 'langium';
+import { URI } from 'vscode-uri';
+export function createTestServices() {
+    const services = createLanguageServices(EmptyFileSystem).likec4;
+    const metaData = services.LanguageMetaData;
+    const langiumDocuments = services.shared.workspace.LangiumDocuments;
+    const documentBuilder = services.shared.workspace.DocumentBuilder;
+    const modelBuilder = services.likec4.ModelBuilder;
+    const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([]);
+    let documentIndex = 1;
+    const parse = async (input, uri) => {
+        await initPromise;
+        uri = uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`;
+        const document = services.shared.workspace.LangiumDocumentFactory.fromString(input, URI.file(uri));
+        langiumDocuments.addDocument(document);
+        await documentBuilder.build([document], { validationChecks: 'none' });
+        return document;
+    };
+    const validate = async (input) => {
+        await initPromise;
+        const document = typeof input === 'string' ? await parse(input) : input;
+        await documentBuilder.build([document], { validationChecks: 'all' });
+        const diagnostics = document.diagnostics ?? [];
+        const errors = diagnostics.map(d => d.message);
+        return {
+            document,
+            diagnostics,
+            errors
+        };
+    };
+    const validateAll = async () => {
+        await initPromise;
+        const docs = langiumDocuments.all.toArray();
+        await documentBuilder.build(docs, { validationChecks: 'all' });
+        const diagnostics = docs.flatMap(doc => doc.diagnostics ?? []);
+        const errors = diagnostics.map(d => d.message);
+        return {
+            diagnostics,
+            errors
+        };
+    };
+    const buildModel = async () => {
+        await validateAll();
+        const model = modelBuilder.buildModel();
+        if (!model)
+            throw new Error('No model found');
+        return model;
+    };
+    return {
+        services,
+        parse,
+        validate,
+        validateAll,
+        buildModel
+    };
+}
+//# sourceMappingURL=testServices.js.map

package/dist/utils.d.ts

@@ -1,2 +1,3 @@
 export declare function failExpectedNever(arg: never): never;
 export declare function ignoreNeverInRuntime(arg: never): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -5,3 +5,4 @@ export function ignoreNeverInRuntime(arg) {
     console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);
     // throw new Error(`Unexpected value: ${arg}`);
 }
+//# sourceMappingURL=utils.js.map

package/dist/validation/element.d.ts

@@ -3,3 +3,4 @@ import type { ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const elementChecks: (services: LikeC4Services) => ValidationCheck<ast.Element>;
+//# sourceMappingURL=element.d.ts.map

package/dist/validation/element.js

@@ -9,8 +9,14 @@ export const elementChecks = (services) => {
             });
             return;
         }
-        const withSameFqn = fqnIndex.byFqn(fqn);
-        if (withSameFqn.length > 1) {
+        const withSameFqn = fqnIndex.byFqn(fqn).limit(2).count();
+        if (withSameFqn > 1) {
+            // console.error(withSameFqn.map(e => ({
+            //   fqn,
+            //   name: el.name,
+            //   path: e.path,
+            //   doc: e.doc.uri.toString()
+            // })))
             accept('error', `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`, {
                 node: el,
                 property: 'name'
@@ -18,3 +24,4 @@ export const elementChecks = (services) => {
         }
     };
 };
+//# sourceMappingURL=element.js.map

package/dist/validation/index.d.ts

@@ -1,2 +1,3 @@
 import type { LikeC4Services } from '../module';
 export declare function registerValidationChecks(services: LikeC4Services): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/index.js

@@ -20,3 +20,4 @@ export function registerValidationChecks(services) {
         Tag: tagChecks(services)
     });
 }
+//# sourceMappingURL=index.js.map

package/dist/validation/relation.d.ts

@@ -2,3 +2,4 @@ import type { ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const relationChecks: (services: LikeC4Services) => ValidationCheck<ast.Relation>;
+//# sourceMappingURL=relation.d.ts.map

package/dist/validation/relation.js

@@ -51,3 +51,4 @@ export const relationChecks = (services) => {
         // }
     };
 };
+//# sourceMappingURL=relation.js.map

package/dist/validation/specification.d.ts

@@ -3,3 +3,4 @@ import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const elementKindChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
 export declare const tagChecks: (services: LikeC4Services) => ValidationCheck<ast.Tag>;
+//# sourceMappingURL=specification.d.ts.map

package/dist/validation/specification.js

@@ -31,3 +31,4 @@ export const tagChecks = (services) => {
         }
     };
 };
+//# sourceMappingURL=specification.js.map

package/dist/validation/view.d.ts

@@ -2,3 +2,4 @@ import type { ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementView>;
+//# sourceMappingURL=view.d.ts.map

package/dist/validation/view.js

@@ -18,3 +18,4 @@ export const viewChecks = (services) => {
         }
     };
 };
+//# sourceMappingURL=view.js.map