@likec4/language-server 1.46.4 → 1.48.0

package/dist/references/scope-computation.js

@@ -1,288 +0,0 @@
-import { nonexhaustive } from '@likec4/core';
-import { DefaultScopeComputation, MultiMap, } from 'langium';
-import { entries, filter, flatMap, forEachObj, groupBy, isNullish, isTruthy, pipe } from 'remeda';
-import { ast } from '../ast';
-import { logWarnError } from '../logger';
-function uniqueDescriptions(descs) {
-    return pipe(descs, groupBy(desc => `${desc.type}.${desc.name}`), entries(), flatMap(([_, descs]) => descs.length === 1 ? descs : []));
-}
-export class LikeC4ScopeComputation extends DefaultScopeComputation {
-    constructor(services) {
-        super(services);
-    }
-    async computeExports(document, _cancelToken) {
-        const docExports = [];
-        try {
-            const { specifications, models, views, globals, likec4lib, deployments, } = document.parseResult.value;
-            // Process library
-            this.exportLibrary(likec4lib, docExports, document);
-            // Process specification
-            this.exportSpecification(specifications, docExports, document);
-            // Process models
-            this.exportModel(models, docExports, document);
-            // Process views
-            this.exportViews(views, docExports, document);
-            // Process global
-            this.exportGlobals(globals, docExports, document);
-            this.exportDeployments(deployments, docExports, document);
-        }
-        catch (e) {
-            logWarnError(e);
-        }
-        return docExports;
-    }
-    exportViews(modelViews, docExports, document) {
-        const views = modelViews?.flatMap(m => m.views);
-        if (isNullish(views) || views.length === 0) {
-            return;
-        }
-        for (const viewAst of views) {
-            try {
-                if (isTruthy(viewAst.name)) {
-                    docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
-                }
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-    }
-    exportGlobals(globals, docExports, document) {
-        if (isNullish(globals) || globals.length === 0) {
-            return;
-        }
-        for (const globalPredicateAst of globals.flatMap(g => g.predicates)) {
-            try {
-                const id = globalPredicateAst;
-                if (isTruthy(id.name)) {
-                    docExports.push(this.descriptions.createDescription(id, id.name, document));
-                }
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-        for (const globalStyleAst of globals.flatMap(g => g.styles)) {
-            try {
-                const id = globalStyleAst.id;
-                if (isTruthy(id.name)) {
-                    docExports.push(this.descriptions.createDescription(id, id.name, document));
-                }
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-    }
-    exportModel(models, docExports, document) {
-        if (isNullish(models) || models.length === 0) {
-            return;
-        }
-        for (const elAst of models.flatMap(m => m.elements)) {
-            try {
-                if (ast.isElement(elAst) && isTruthy(elAst.name)) {
-                    docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
-                }
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-    }
-    exportLibrary(likec4lib, docExports, document) {
-        if (isNullish(likec4lib)) {
-            return;
-        }
-        try {
-            for (const iconAst of likec4lib.flatMap(l => l.icons)) {
-                docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document));
-            }
-        }
-        catch (e) {
-            logWarnError(e);
-        }
-    }
-    exportSpecification(specifications, docExports, document) {
-        if (isNullish(specifications) || specifications.length === 0) {
-            return;
-        }
-        for (const spec of specifications.flatMap(s => [
-            ...s.elements,
-            ...s.relationships,
-            ...s.deploymentNodes,
-            ...s.tags,
-            ...s.colors,
-        ])) {
-            try {
-                switch (true) {
-                    case ast.isSpecificationDeploymentNodeKind(spec):
-                    case ast.isSpecificationElementKind(spec): {
-                        if (isTruthy(spec.kind.name)) {
-                            docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
-                        }
-                        continue;
-                    }
-                    case ast.isSpecificationTag(spec): {
-                        if (isTruthy(spec.tag.name)) {
-                            docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
-                        }
-                        continue;
-                    }
-                    case ast.isSpecificationRelationshipKind(spec): {
-                        if (isTruthy(spec.kind.name)) {
-                            docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
-                        }
-                        continue;
-                    }
-                    case ast.isSpecificationColor(spec): {
-                        if (isTruthy(spec.name.name)) {
-                            docExports.push(this.descriptions.createDescription(spec.name, spec.name.name, document));
-                        }
-                        continue;
-                    }
-                    // Thow error if not exhaustive
-                    default:
-                        nonexhaustive(spec);
-                }
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-    }
-    exportDeployments(modelDeployments, docExports, document) {
-        const nodes = modelDeployments?.flatMap(m => m.elements);
-        if (isNullish(nodes) || nodes.length === 0) {
-            return;
-        }
-        for (const node of nodes) {
-            try {
-                if (ast.isDeploymentNode(node) && isTruthy(node.name)) {
-                    docExports.push(this.descriptions.createDescription(node, node.name, document));
-                }
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-    }
-    computeLocalScopes(document, _cancelToken) {
-        return new Promise(resolve => {
-            const root = document.parseResult.value;
-            const descendants = [];
-            const scopes = new MultiMap();
-            for (const model of root.models) {
-                try {
-                    descendants.push(...this.processContainer(model, scopes, document));
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-            }
-            for (const deployment of root.deployments) {
-                try {
-                    descendants.push(...this.processDeployments(deployment, scopes, document));
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-            }
-            for (const imports of root.imports.flatMap(i => i.imports)) {
-                try {
-                    let imported = imports;
-                    while (imported) {
-                        descendants.push(this.descriptions.createDescription(imported, imported.imported.$refText));
-                        imported = imported.prev;
-                    }
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-            }
-            uniqueDescriptions(descendants).forEach(desc => {
-                scopes.add(root, desc);
-            });
-            resolve(scopes);
-        });
-    }
-    processContainer(container, scopes, document) {
-        const localScope = new MultiMap();
-        const descedants = [];
-        for (const el of container.elements) {
-            if (ast.isRelation(el)) {
-                continue;
-            }
-            let subcontainer;
-            if (ast.isElement(el)) {
-                if (isTruthy(el.name)) {
-                    localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
-                }
-                subcontainer = el.body;
-                if (subcontainer) {
-                    scopes.add(subcontainer, this.descriptions.createDescription(el, 'this', document));
-                    scopes.add(subcontainer, this.descriptions.createDescription(el, 'it', document));
-                }
-            }
-            else if (ast.isExtendElement(el)) {
-                subcontainer = el.body;
-            }
-            if (subcontainer && subcontainer.elements.length > 0) {
-                try {
-                    descedants.push(...this.processContainer(subcontainer, scopes, document));
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-            }
-        }
-        if (descedants.length) {
-            pipe(descedants, filter(desc => !localScope.has(desc.name)), groupBy(desc => desc.name), forEachObj((descs, name) => {
-                if (descs.length === 1) {
-                    localScope.add(name, descs[0]);
-                }
-            }));
-        }
-        const local = [...localScope.values()];
-        scopes.addAll(container, local);
-        return local;
-    }
-    processDeployments(container, scopes, document) {
-        const localScope = new MultiMap();
-        const descedants = [];
-        for (const el of container.elements) {
-            if (ast.isDeploymentRelation(el)) {
-                continue;
-            }
-            let subcontainer = el.body;
-            if (!ast.isExtendDeployment(el)) {
-                let name = this.nameProvider.getName(el);
-                if (isTruthy(name)) {
-                    const desc = this.descriptions.createDescription(el, name, document);
-                    localScope.add(name, desc);
-                }
-                if (subcontainer) {
-                    scopes.add(subcontainer, this.descriptions.createDescription(el, 'this', document));
-                    scopes.add(subcontainer, this.descriptions.createDescription(el, 'it', document));
-                }
-            }
-            if (subcontainer) {
-                try {
-                    descedants.push(...this.processDeployments(subcontainer, scopes, document));
-                }
-                catch (e) {
-                    logWarnError(e);
-                }
-            }
-        }
-        if (descedants.length) {
-            pipe(descedants, filter(desc => !localScope.has(desc.name)), groupBy(desc => desc.name), forEachObj((descs, name) => {
-                if (descs.length === 1) {
-                    localScope.add(name, descs[0]);
-                }
-            }));
-        }
-        const local = [...localScope.values()];
-        scopes.addAll(container, local);
-        return local;
-    }
-}

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

@@ -1,40 +0,0 @@
-import { type ProjectId } from '@likec4/core';
-import { type AstNodeDescription, type ReferenceInfo, type Scope, type Stream, DefaultScopeProvider } from 'langium';
-import { ast } from '../ast';
-import type { DeploymentsIndex, FqnIndex } from '../model';
-import type { LikeC4Services } from '../module';
-import type { IndexManager } from '../workspace';
-export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
-    protected deploymentsIndex: DeploymentsIndex;
-    protected fqnIndex: FqnIndex;
-    protected readonly indexManager: IndexManager;
-    constructor(services: LikeC4Services);
-    getScope(context: ReferenceInfo): Scope;
-    protected genUniqueDescedants(element: ast.Element | ast.DeploymentNode | undefined): Generator<import("../ast").AstNodeDescriptionWithFqn, void, any>;
-    protected genScopeExtendElement({ element }: ast.ExtendElement): Generator<AstNodeDescription>;
-    protected genScopeElementView({ viewOf, extends: ext }: ast.ElementView): Generator<AstNodeDescription>;
-    protected getScopeForStrictFqnRef(projectId: ProjectId, container: ast.StrictFqnRef, context: ReferenceInfo): Scope;
-    protected genScopeExtendDeployment({ deploymentNode }: ast.ExtendDeployment): Generator<AstNodeDescription>;
-    protected streamForFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Stream<AstNodeDescription>;
-    protected genScopeForParentlessFqnRef(projectId: ProjectId, container: ast.FqnRef, context: ReferenceInfo): Generator<AstNodeDescription>;
-    /**
-     * Computes the scope for a given reference context.
-     *
-     * @param context - The reference information containing the context for which the scope is being computed.
-     * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
-     * @returns A scope containing the relevant AST node descriptions for the given reference context.
-     *
-     * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
-     * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
-     * Finally, it combines the collected scopes with the global scope to produce the final scope.
-     */
-    protected computeScope(projectId: ProjectId, context: ReferenceInfo, referenceType?: string): Generator<AstNodeDescription>;
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    protected getProjectScope(projectId: ProjectId, referenceType: string, context: ReferenceInfo): Scope;
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    protected getGlobalScope(referenceType: string, context: ReferenceInfo): Scope;
-}

package/dist/references/scope-provider.js

@@ -1,239 +0,0 @@
-import { nonexhaustive } from '@likec4/core';
-import { AstUtils, DefaultScopeProvider, EMPTY_SCOPE, EMPTY_STREAM, MapScope, stream, StreamScope, } from 'langium';
-import { ast, isFqnRefInsideGlobals, isFqnRefInsideModel } from '../ast';
-import { logWarnError } from '../logger';
-import { projectIdFrom } from '../utils';
-import { elementRef, readStrictFqn } from '../utils/elementRef';
-const { getDocument } = AstUtils;
-export class LikeC4ScopeProvider extends DefaultScopeProvider {
-    deploymentsIndex;
-    fqnIndex;
-    indexManager;
-    constructor(services) {
-        super(services);
-        this.indexManager = services.shared.workspace.IndexManager;
-        this.fqnIndex = services.likec4.FqnIndex;
-        this.deploymentsIndex = services.likec4.DeploymentsIndex;
-    }
-    getScope(context) {
-        try {
-            const projectId = projectIdFrom(context.container);
-            const referenceType = this.reflection.getReferenceType(context);
-            try {
-                const container = context.container;
-                if (ast.isFqnRef(container)) {
-                    return new StreamScope(this.streamForFqnRef(projectId, container, context));
-                }
-                if (ast.isStrictFqnRef(container)) {
-                    return this.getScopeForStrictFqnRef(projectId, container, context);
-                }
-                if (referenceType !== ast.Element) {
-                    return this.getProjectScope(projectId, referenceType, context);
-                }
-                if (ast.isImported(container)) {
-                    const projectId = projectIdFrom(container);
-                    return new StreamScope(this.fqnIndex.rootElements(projectId));
-                }
-                if (ast.isStrictFqnElementRef(container) && context.property === 'el') {
-                    const parent = container.parent;
-                    if (!parent) {
-                        return this.getProjectScope(projectId, referenceType, context);
-                    }
-                    return new StreamScope(this.fqnIndex.directChildrenOf(projectId, readStrictFqn(parent)));
-                }
-                return new StreamScope(stream(this.computeScope(projectId, context)));
-            }
-            catch (e) {
-                logWarnError(e);
-                return this.getProjectScope(projectId, referenceType, context);
-            }
-        }
-        catch (e) {
-            logWarnError(e);
-            return EMPTY_SCOPE;
-        }
-    }
-    // we need lazy resolving here
-    *genUniqueDescedants(element) {
-        if (!element) {
-            return;
-        }
-        const projectId = projectIdFrom(element);
-        if (ast.isElement(element)) {
-            const fqn = this.fqnIndex.getFqn(element);
-            yield* this.fqnIndex.uniqueDescedants(projectId, fqn);
-            return;
-        }
-        if (ast.isDeploymentNode(element)) {
-            const fqn = this.deploymentsIndex.getFqn(element);
-            yield* this.deploymentsIndex.uniqueDescedants(projectId, fqn);
-        }
-    }
-    *genScopeExtendElement({ element }) {
-        if (element.el.$nodeDescription) {
-            yield element.el.$nodeDescription;
-            yield {
-                ...element.el.$nodeDescription,
-                name: 'this',
-            };
-            yield {
-                ...element.el.$nodeDescription,
-                name: 'it',
-            };
-        }
-        // we make extended element resolvable inside ExtendElementBody
-        yield* this.genUniqueDescedants(elementRef(element));
-    }
-    *genScopeElementView({ viewOf, extends: ext }) {
-        if (viewOf) {
-            // If we have "view of parent.target"
-            // we make "target" resolvable inside ElementView
-            if (viewOf.modelElement.value.$nodeDescription) {
-                yield viewOf.modelElement.value.$nodeDescription;
-            }
-            yield* this.genUniqueDescedants(elementRef(viewOf));
-            return;
-        }
-        if (ext) {
-            const view = ext.view.ref;
-            if (view) {
-                yield* this.genScopeElementView(view);
-            }
-        }
-    }
-    getScopeForStrictFqnRef(projectId, container, context) {
-        const parent = container.parent;
-        if (!parent) {
-            return this.getProjectScope(projectId, ast.DeploymentNode, context);
-        }
-        return new StreamScope(this.deploymentsIndex
-            .directChildrenOf(projectId, readStrictFqn(parent))
-            .filter(desc => this.reflection.isSubtype(desc.type, ast.DeploymentNode)));
-    }
-    *genScopeExtendDeployment({ deploymentNode }) {
-        if (deploymentNode.value.$nodeDescription) {
-            yield deploymentNode.value.$nodeDescription;
-        }
-        const target = deploymentNode.value.ref;
-        if (target && ast.isDeploymentNode(target)) {
-            yield* this.genUniqueDescedants(target);
-        }
-    }
-    streamForFqnRef(projectId, container, context) {
-        const parent = container.parent;
-        if (!parent) {
-            return stream(this.genScopeForParentlessFqnRef(projectId, container, context));
-        }
-        const parentRef = parent.value.ref;
-        if (!parentRef) {
-            return EMPTY_STREAM;
-        }
-        if (ast.isImported(parentRef)) {
-            return stream(this.genUniqueDescedants(parentRef.imported.ref));
-        }
-        if (ast.isDeploymentNode(parentRef)) {
-            return stream(this.genUniqueDescedants(parentRef));
-        }
-        if (ast.isDeployedInstance(parentRef)) {
-            const target = parentRef.target.modelElement.value.ref;
-            // dprint-ignore
-            const resolvedTarget = ast.isImported(target)
-                ? target.imported.ref
-                : ast.isElement(target)
-                    ? target
-                    : undefined;
-            return stream(this.genUniqueDescedants(resolvedTarget));
-        }
-        if (ast.isElement(parentRef)) {
-            return stream(this.genUniqueDescedants(parentRef));
-        }
-        return nonexhaustive(parentRef);
-    }
-    *genScopeForParentlessFqnRef(projectId, container, context) {
-        if (AstUtils.hasContainerOfType(container, ast.isElementRef) ||
-            isFqnRefInsideModel(container)) {
-            // Inside model scope we only need to resolve elements
-            yield* this.computeScope(projectId, context, ast.Element);
-        }
-        else if (isFqnRefInsideGlobals(container)) {
-            yield* this.computeScope(projectId, context, ast.Element);
-            yield* this.computeScope(projectId, context, ast.DeploymentNode);
-            yield* this.computeScope(projectId, context, ast.DeployedInstance);
-        }
-        else {
-            // First preference for deployment nodes
-            yield* this.computeScope(projectId, context, ast.DeploymentNode);
-            // Second preference for deployed instances
-            yield* this.computeScope(projectId, context, ast.DeployedInstance);
-            // Third preference for elements if we are in deployment view
-            if (AstUtils.hasContainerOfType(container, ast.isDeploymentViewBody)) {
-                yield* this.computeScope(projectId, context, ast.Element);
-            }
-        }
-        const doc = getDocument(container);
-        const precomputed = doc.precomputedScopes;
-        // Fourth preference for imported models
-        if (precomputed) {
-            yield* precomputed.values().filter(nd => this.reflection.isSubtype(nd.type, ast.Imported));
-        }
-    }
-    /**
-     * Computes the scope for a given reference context.
-     *
-     * @param context - The reference information containing the context for which the scope is being computed.
-     * @param referenceType - The type of reference being resolved. Defaults to the reference type derived from the context.
-     * @returns A scope containing the relevant AST node descriptions for the given reference context.
-     *
-     * This method first checks if there are precomputed scopes available in the document. If not, it falls back to the global scope.
-     * It then iterates through the container hierarchy, collecting relevant scopes based on the reference type and container type.
-     * Finally, it combines the collected scopes with the global scope to produce the final scope.
-     */
-    *computeScope(projectId, context, referenceType = this.reflection.getReferenceType(context)) {
-        const isElementReference = this.reflection.isSubtype(referenceType, ast.Element);
-        const isDeploymentReference = this.reflection.isSubtype(referenceType, ast.DeploymentElement);
-        const doc = getDocument(context.container);
-        const precomputed = doc.precomputedScopes;
-        if (!precomputed) {
-            yield* this.getProjectScope(projectId, referenceType, context).getAllElements();
-            return;
-        }
-        const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
-        let container = context.container;
-        while (container) {
-            const elements = precomputed.get(container).filter(byReferenceType);
-            if (elements.length > 0) {
-                yield* elements;
-            }
-            if (isDeploymentReference && ast.isExtendDeploymentBody(container)) {
-                yield* this.genScopeExtendDeployment(container.$container);
-            }
-            if (isElementReference && ast.isExtendElementBody(container)) {
-                yield* this.genScopeExtendElement(container.$container);
-            }
-            if (isElementReference && ast.isElementViewBody(container)) {
-                yield* this.genScopeElementView(container.$container);
-            }
-            container = container.$container;
-        }
-        yield* this.getProjectScope(projectId, referenceType, context).getAllElements();
-    }
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    getProjectScope(projectId, referenceType, context) {
-        if (referenceType === ast.LibIcon) {
-            return super.getGlobalScope(referenceType, context);
-        }
-        return this.globalScopeCache.get(`${projectId}::${referenceType}`, () => new MapScope(this.indexManager.projectElements(projectId, referenceType)));
-    }
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    getGlobalScope(referenceType, context) {
-        if (referenceType === ast.LibIcon) {
-            return super.getGlobalScope(referenceType, context);
-        }
-        const projectId = projectIdFrom(context.container);
-        return this.getProjectScope(projectId, referenceType, context);
-    }
-}

package/dist/shared/NodeKindProvider.d.ts

@@ -1,15 +0,0 @@
-import { type AstNode, type AstNodeDescription } from 'langium';
-import type { LangiumSharedServices, NodeKindProvider as LspNodeKindProvider } from 'langium/lsp';
-import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-types';
-export declare class NodeKindProvider implements LspNodeKindProvider {
-    private services;
-    constructor(services: LangiumSharedServices);
-    /**
-     * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
-     */
-    getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind;
-    /**
-     * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
-     */
-    getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind;
-}

package/dist/shared/NodeKindProvider.js

@@ -1,57 +0,0 @@
-import { isAstNode } from 'langium';
-import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-types';
-import { ast } from '../ast';
-export class NodeKindProvider {
-    services;
-    constructor(services) {
-        this.services = services;
-    }
-    /**
-     * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
-     */
-    // prettier-ignore
-    getSymbolKind(node) {
-        const nodeType = isAstNode(node) ? node.$type : node.type;
-        const hasType = (...types) => types.some(t => this.services.AstReflection.isSubtype(nodeType, t));
-        switch (true) {
-            case hasType(ast.Element, ast.ExtendElement, ast.DeploymentNode, ast.DeployedInstance, ast.Imported):
-                return SymbolKind.Constructor;
-            case hasType(ast.Model, ast.ModelViews, ast.ModelDeployments, ast.Globals, ast.SpecificationRule):
-                return SymbolKind.Namespace;
-            case hasType(ast.LikeC4View):
-                return SymbolKind.Class;
-            case hasType(ast.Tag, ast.LibIcon, ast.CustomColor, ast.SpecificationTag):
-                return SymbolKind.EnumMember;
-            case hasType(ast.RelationshipKind, ast.SpecificationRelationshipKind):
-                return SymbolKind.Event;
-            case hasType(ast.ElementKind, ast.DeploymentNodeKind, ast.SpecificationElementKind, ast.SpecificationDeploymentNodeKind):
-                return SymbolKind.TypeParameter;
-        }
-        return SymbolKind.Field;
-    }
-    /**
-     * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
-     */
-    getCompletionItemKind(node) {
-        const nodeType = isAstNode(node) ? node.$type : node.type;
-        const hasType = (...types) => types.some(t => this.services.AstReflection.isSubtype(nodeType, t));
-        switch (true) {
-            case hasType(ast.CustomColor):
-                return CompletionItemKind.Color;
-            case hasType(ast.Element, ast.DeploymentNode, ast.DeployedInstance, ast.ExtendElement, ast.Imported):
-                return CompletionItemKind.Constructor;
-            case hasType(ast.Model, ast.ModelViews, ast.ModelDeployments, ast.Globals, ast.SpecificationRule):
-                return CompletionItemKind.Module;
-            case hasType(ast.LikeC4View):
-                return CompletionItemKind.Class;
-            case hasType(ast.Tag, ast.LibIcon, ast.CustomColor, ast.SpecificationTag):
-                return CompletionItemKind.EnumMember;
-            case hasType(ast.RelationshipKind, ast.SpecificationRelationshipKind):
-                return CompletionItemKind.Event;
-            case hasType(ast.ElementKind, ast.SpecificationElementKind, ast.DeploymentNodeKind, ast.SpecificationDeploymentNodeKind):
-                return CompletionItemKind.TypeParameter;
-            default:
-                return CompletionItemKind.Reference;
-        }
-    }
-}

package/dist/shared/WorkspaceSymbolProvider.d.ts

@@ -1,3 +0,0 @@
-import { DefaultWorkspaceSymbolProvider } from 'langium/lsp';
-export declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {
-}

package/dist/shared/WorkspaceSymbolProvider.js

@@ -1,3 +0,0 @@
-import { DefaultWorkspaceSymbolProvider } from 'langium/lsp';
-export class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {
-}

package/dist/shared/index.d.ts

@@ -1,2 +0,0 @@
-export * from './NodeKindProvider';
-export * from './WorkspaceSymbolProvider';

package/dist/shared/index.js

@@ -1,2 +0,0 @@
-export * from './NodeKindProvider';
-export * from './WorkspaceSymbolProvider';

package/dist/test/index.d.ts

@@ -1 +0,0 @@
-export * from './testServices';

package/dist/test/index.js

@@ -1 +0,0 @@
-export * from './testServices';