@likec4/language-server 1.1.1 → 1.2.1

package/dist/model-change/changeViewLayout.js

@@ -1,30 +0,0 @@
-import { invariant } from "@likec4/core";
-import { GrammarUtils } from "langium";
-import { last } from "remeda";
-import { TextEdit } from "vscode-languageserver-protocol";
-import { ast, toAstViewLayoutDirection } from "../ast.js";
-const { findNodeForProperty } = GrammarUtils;
-export function changeViewLayout(services, {
-  view,
-  viewAst,
-  layout
-}) {
-  const viewCstNode = viewAst.$cstNode;
-  invariant(viewCstNode, "viewCstNode");
-  const newlayout = toAstViewLayoutDirection(layout);
-  const existingRule = viewAst.body.rules.findLast(ast.isViewRuleAutoLayout);
-  if (existingRule && existingRule.$cstNode) {
-    const directionCstNode = findNodeForProperty(existingRule.$cstNode, "direction");
-    if (directionCstNode) {
-      return [TextEdit.replace(directionCstNode.range, newlayout)];
-    }
-    return [TextEdit.replace(existingRule.$cstNode.range, `autoLayout ${newlayout}`)];
-  }
-  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end ?? last(viewAst.body.props)?.$cstNode?.range.end ?? viewAst.body.$cstNode?.range.start;
-  invariant(insertPos, "insertPos is not defined");
-  const indent = " ".repeat(2 + viewCstNode.range.start.character);
-  const insert = `
-
-${indent}autoLayout ${newlayout}`;
-  return [TextEdit.insert(insertPos, insert)];
-}

package/dist/module.d.ts

@@ -1,59 +0,0 @@
-import { type Module, WorkspaceCache } from 'langium';
-import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
-import { LikeC4CodeLensProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
-import { LikeC4ModelChanges } from './model-change/ModelChanges';
-import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
-import { Rpc } from './Rpc';
-import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared';
-interface LikeC4AddedSharedServices {
-    lsp: {
-        NodeKindProvider: NodeKindProvider;
-        WorkspaceSymbolProvider: WorkspaceSymbolProvider;
-    };
-    workspace: {
-        WorkspaceManager: LikeC4WorkspaceManager;
-    };
-}
-export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
-/**
- * Declaration of custom services - add your own service classes here.
- */
-export interface LikeC4AddedServices {
-    WorkspaceCache: WorkspaceCache<string, any>;
-    Rpc: Rpc;
-    likec4: {
-        FqnIndex: FqnIndex;
-        ModelParser: LikeC4ModelParser;
-        ModelBuilder: LikeC4ModelBuilder;
-        ModelLocator: LikeC4ModelLocator;
-        ModelChanges: LikeC4ModelChanges;
-    };
-    lsp: {
-        DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
-        DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
-        SemanticTokenProvider: LikeC4SemanticTokenProvider;
-        HoverProvider: LikeC4HoverProvider;
-        CodeLensProvider: LikeC4CodeLensProvider;
-        DocumentLinkProvider: LikeC4DocumentLinkProvider;
-    };
-    references: {
-        ScopeComputation: LikeC4ScopeComputation;
-        ScopeProvider: LikeC4ScopeProvider;
-    };
-    shared?: LikeC4SharedServices;
-}
-export type LikeC4Services = LangiumServices & LikeC4AddedServices;
-export declare const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
-export type LanguageServicesContext = Partial<DefaultSharedModuleContext>;
-export declare function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: LanguageServicesContext, module: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
-    shared: LikeC4SharedServices;
-    likec4: I;
-};
-export declare function createSharedServices(context?: LanguageServicesContext): LikeC4SharedServices;
-export declare function createLanguageServices(context?: LanguageServicesContext): {
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
-export {};
-//# sourceMappingURL=module.d.ts.map

package/dist/module.js

@@ -1,121 +0,0 @@
-import { normalizeError } from "@likec4/core";
-import { EmptyFileSystem, inject, WorkspaceCache } from "langium";
-import {
-  createDefaultModule,
-  createDefaultSharedModule
-} from "langium/lsp";
-import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from "./generated/module.js";
-import { logger } from "./logger.js";
-import {
-  LikeC4CodeLensProvider,
-  LikeC4DocumentHighlightProvider,
-  LikeC4DocumentLinkProvider,
-  LikeC4DocumentSymbolProvider,
-  LikeC4HoverProvider,
-  LikeC4SemanticTokenProvider
-} from "./lsp/index.js";
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from "./model/index.js";
-import { LikeC4ModelChanges } from "./model-change/ModelChanges.js";
-import { LikeC4ScopeComputation, LikeC4ScopeProvider } from "./references/index.js";
-import { Rpc } from "./Rpc.js";
-import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from "./shared/index.js";
-import { registerValidationChecks } from "./validation/index.js";
-const LikeC4SharedModule = {
-  lsp: {
-    NodeKindProvider: (services) => new NodeKindProvider(services),
-    WorkspaceSymbolProvider: (services) => new WorkspaceSymbolProvider(services)
-  },
-  workspace: {
-    WorkspaceManager: (services) => new LikeC4WorkspaceManager(services)
-  }
-};
-function bind(Type) {
-  return (services) => new Type(services);
-}
-export const LikeC4Module = {
-  WorkspaceCache: (services) => new WorkspaceCache(services.shared),
-  Rpc: bind(Rpc),
-  likec4: {
-    ModelChanges: bind(LikeC4ModelChanges),
-    FqnIndex: bind(FqnIndex),
-    ModelParser: bind(LikeC4ModelParser),
-    ModelBuilder: bind(LikeC4ModelBuilder),
-    ModelLocator: bind(LikeC4ModelLocator)
-  },
-  lsp: {
-    DocumentHighlightProvider: bind(LikeC4DocumentHighlightProvider),
-    DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
-    SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
-    HoverProvider: bind(LikeC4HoverProvider),
-    CodeLensProvider: bind(LikeC4CodeLensProvider),
-    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
-  },
-  references: {
-    ScopeComputation: bind(LikeC4ScopeComputation),
-    ScopeProvider: bind(LikeC4ScopeProvider)
-  }
-};
-export function createCustomLanguageServices(context, module, module2, module3) {
-  const shared = createSharedServices(context);
-  const modules = [
-    createDefaultModule({ shared }),
-    LikeC4GeneratedModule,
-    LikeC4Module,
-    module,
-    module2,
-    module3
-  ].reduce(_merge, {});
-  const likec4 = inject(modules);
-  shared.ServiceRegistry.register(likec4);
-  registerValidationChecks(likec4);
-  likec4.Rpc.init();
-  return { shared, likec4 };
-}
-export function createSharedServices(context = {}) {
-  const connection = context.connection;
-  if (connection) {
-    const original = logger.error.bind(logger);
-    logger.error = (arg) => {
-      if (typeof arg === "string") {
-        original(arg);
-        connection.telemetry.logEvent({ eventName: "error", error: arg });
-        return;
-      }
-      const error = normalizeError(arg);
-      original(error);
-      connection.telemetry.logEvent({ eventName: "error", error: error.stack ?? error.message });
-    };
-  }
-  const moduleContext = {
-    ...EmptyFileSystem,
-    ...context
-  };
-  return inject(
-    createDefaultSharedModule(moduleContext),
-    LikeC4GeneratedSharedModule,
-    LikeC4SharedModule
-  );
-}
-export function createLanguageServices(context = {}) {
-  const shared = createSharedServices(context);
-  const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
-  shared.ServiceRegistry.register(likec4);
-  registerValidationChecks(likec4);
-  likec4.Rpc.init();
-  return { shared, likec4 };
-}
-function _merge(target, source) {
-  if (source) {
-    for (const [key, value2] of Object.entries(source)) {
-      if (value2 !== void 0) {
-        const value1 = target[key];
-        if (value1 !== null && value2 !== null && typeof value1 === "object" && typeof value2 === "object") {
-          target[key] = _merge(value1, value2);
-        } else {
-          target[key] = value2;
-        }
-      }
-    }
-  }
-  return target;
-}

package/dist/node/index.d.ts

@@ -1,6 +0,0 @@
-export declare function startLanguageServer(): {
-    connection: import("vscode-languageserver/node")._Connection<import("vscode-languageserver/node")._, import("vscode-languageserver/node")._, import("vscode-languageserver/node")._, import("vscode-languageserver/node")._, import("vscode-languageserver/node")._, import("vscode-languageserver/node")._, import("vscode-languageserver/lib/common/inlineCompletion.proposed").InlineCompletionFeatureShape, import("vscode-languageserver/node")._>;
-    shared: import("../module").LikeC4SharedServices;
-    likec4: import("../module").LikeC4Services;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/node/index.js

@@ -1,13 +0,0 @@
-import { startLanguageServer as startLanguim } from "langium/lsp";
-import { NodeFileSystem } from "langium/node";
-import { createConnection, ProposedFeatures } from "vscode-languageserver/node";
-import { createLanguageServices } from "../module.js";
-export function startLanguageServer() {
-  const connection = createConnection(ProposedFeatures.all);
-  const services = createLanguageServices({ connection, ...NodeFileSystem });
-  startLanguim(services.shared);
-  return {
-    ...services,
-    connection
-  };
-}

package/dist/protocol.d.ts

@@ -1,58 +0,0 @@
-import type { AutoLayoutDirection, BorderStyle, ComputedView, ElementShape, Fqn, LikeC4ComputedModel, LikeC4Model, NonEmptyArray, RelationID, ThemeColor, ViewID } from '@likec4/core';
-import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
-import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
-export declare const onDidChangeModel: NotificationType<string>;
-export type OnDidChangeModelNotification = typeof onDidChangeModel;
-export declare const fetchModel: RequestType0<{
-    model: LikeC4Model | null;
-}, void>;
-export type FetchModelRequest = typeof fetchModel;
-export declare const fetchComputedModel: RequestType0<{
-    model: LikeC4ComputedModel | null;
-}, void>;
-export type FetchComputedModelRequest = typeof fetchComputedModel;
-export declare const computeView: RequestType<{
-    viewId: ViewID;
-}, {
-    view: ComputedView | null;
-}, void>;
-export type ComputeViewRequest = typeof computeView;
-export interface BuildDocumentsParams {
-    docs: DocumentUri[];
-}
-export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
-export type BuildDocumentsRequest = typeof buildDocuments;
-export type LocateParams = {
-    element: Fqn;
-    property?: string;
-} | {
-    relation: RelationID;
-} | {
-    view: ViewID;
-};
-export declare const locate: RequestType<LocateParams, Location | null, void>;
-export type LocateRequest = typeof locate;
-export declare namespace ChangeView {
-    interface ChangeAutoLayout {
-        op: 'change-autolayout';
-        layout: AutoLayoutDirection;
-    }
-    interface ChangeElementStyle {
-        op: 'change-element-style';
-        style: {
-            border?: BorderStyle;
-            opacity?: number;
-            shape?: ElementShape;
-            color?: ThemeColor;
-        };
-        targets: NonEmptyArray<Fqn>;
-    }
-}
-export type ChangeView = ChangeView.ChangeAutoLayout | ChangeView.ChangeElementStyle;
-export interface ChangeViewRequestParams {
-    viewId: ViewID;
-    changes: NonEmptyArray<ChangeView>;
-}
-export declare const changeView: RequestType<ChangeViewRequestParams, Location | null, void>;
-export type ChangeViewRequest = typeof changeView;
-//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -1,14 +0,0 @@
-import { NotificationType, RequestType, RequestType0 } from "vscode-languageserver-protocol";
-export const onDidChangeModel = new NotificationType("likec4/onDidChangeModel");
-export const fetchModel = new RequestType0(
-  "likec4/fetchModel"
-);
-export const fetchComputedModel = new RequestType0(
-  "likec4/fetchComputedModel"
-);
-export const computeView = new RequestType(
-  "likec4/computeView"
-);
-export const buildDocuments = new RequestType("likec4/build");
-export const locate = new RequestType("likec4/locate");
-export const changeView = new RequestType("likec4/change-view");

package/dist/references/index.d.ts

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

package/dist/references/index.js

@@ -1,2 +0,0 @@
-export * from "./scope-computation.js";
-export * from "./scope-provider.js";

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

@@ -1,11 +0,0 @@
-import { type AstNodeDescription, DefaultScopeComputation, MultiMap, type PrecomputedScopes } from 'langium';
-import type { CancellationToken } from 'vscode-languageserver';
-import { ast, type LikeC4LangiumDocument } from '../ast';
-type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody;
-export declare class LikeC4ScopeComputation extends DefaultScopeComputation {
-    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,108 +0,0 @@
-import {
-  DefaultScopeComputation,
-  MultiMap
-} from "langium";
-import { isTruthy } from "remeda";
-import { ast } from "../ast.js";
-import { logError } from "../logger.js";
-export class LikeC4ScopeComputation extends DefaultScopeComputation {
-  computeExports(document, _cancelToken) {
-    return new Promise((resolve) => {
-      const docExports = [];
-      const { specifications, models, views } = document.parseResult.value;
-      try {
-        for (const spec of specifications.flatMap((s) => [...s.elements, ...s.relationships])) {
-          if (spec.kind && isTruthy(spec.kind.name)) {
-            docExports.push(
-              this.descriptions.createDescription(spec.kind, spec.kind.name, document)
-            );
-          }
-        }
-      } catch (e) {
-        logError(e);
-      }
-      try {
-        for (const spec of specifications.flatMap((s) => s.tags)) {
-          if (spec.tag && isTruthy(spec.tag.name)) {
-            docExports.push(
-              this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
-            );
-          }
-        }
-      } catch (e) {
-        logError(e);
-      }
-      try {
-        for (const elAst of models.flatMap((m) => m.elements)) {
-          if (ast.isElement(elAst) && isTruthy(elAst.name)) {
-            docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
-          }
-        }
-      } catch (e) {
-        logError(e);
-      }
-      try {
-        for (const viewAst of views.flatMap((v) => v.views)) {
-          if (isTruthy(viewAst.name)) {
-            docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
-          }
-        }
-      } catch (e) {
-        logError(e);
-      }
-      resolve(docExports);
-    });
-  }
-  computeLocalScopes(document, _cancelToken) {
-    return new Promise((resolve) => {
-      const root = document.parseResult.value;
-      const scopes = new MultiMap();
-      for (const model of root.models) {
-        try {
-          const nested = this.processContainer(model, scopes, document);
-          scopes.addAll(root, nested.values());
-        } catch (e) {
-          logError(e);
-        }
-      }
-      resolve(scopes);
-    });
-  }
-  processContainer(container, scopes, document) {
-    const localScope = new MultiMap();
-    const nestedScopes = new MultiMap();
-    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;
-      } else if (ast.isExtendElement(el)) {
-        subcontainer = el.body;
-      }
-      if (subcontainer && subcontainer.elements.length > 0) {
-        try {
-          const nested = this.processContainer(subcontainer, scopes, document);
-          for (const [nestedName, desc] of nested) {
-            nestedScopes.add(nestedName, desc);
-          }
-        } catch (e) {
-          logError(e);
-        }
-      }
-    }
-    if (nestedScopes.size > 0) {
-      for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
-        if (!localScope.has(name) && descriptions.length === 1) {
-          localScope.add(name, descriptions[0]);
-        }
-      }
-    }
-    scopes.addAll(container, localScope.values());
-    return localScope;
-  }
-}

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

@@ -1,18 +0,0 @@
-import { DefaultScopeProvider, type ReferenceInfo, type Scope } from 'langium';
-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(context: ReferenceInfo): Scope;
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    protected getGlobalScope(referenceType: string): Scope;
-}
-//# sourceMappingURL=scope-provider.d.ts.map

package/dist/references/scope-provider.js

@@ -1,136 +0,0 @@
-import {
-  AstUtils,
-  CstUtils,
-  DefaultScopeProvider,
-  DONE_RESULT,
-  EMPTY_STREAM,
-  GrammarUtils,
-  stream,
-  StreamImpl,
-  StreamScope
-} from "langium";
-import { ast } from "../ast.js";
-import { elementRef, getFqnElementRef } from "../elementRef.js";
-import { logError } from "../logger.js";
-const { findNodeForProperty } = GrammarUtils;
-const { toDocumentSegment } = CstUtils;
-const { getDocument } = AstUtils;
-function toAstNodeDescription(entry) {
-  const $cstNode = findNodeForProperty(entry.el.$cstNode, "name");
-  return {
-    documentUri: entry.doc.uri,
-    name: entry.name,
-    ...entry.el.$cstNode && {
-      selectionSegment: toDocumentSegment(entry.el.$cstNode)
-    },
-    ...$cstNode && {
-      nameSegment: toDocumentSegment($cstNode)
-    },
-    path: entry.path,
-    type: ast.Element
-  };
-}
-export class LikeC4ScopeProvider extends DefaultScopeProvider {
-  fqnIndex;
-  constructor(services) {
-    super(services);
-    this.fqnIndex = services.likec4.FqnIndex;
-  }
-  directChildrenOf(parent) {
-    return this.fqnIndex.directChildrenOf(parent).map(toAstNodeDescription);
-  }
-  // we need lazy resolving here
-  uniqueDescedants(of) {
-    return new StreamImpl(
-      () => {
-        const element = of();
-        const fqn = element && this.fqnIndex.getFqn(element);
-        if (fqn) {
-          return this.fqnIndex.uniqueDescedants(fqn).map(toAstNodeDescription).iterator();
-        }
-        return null;
-      },
-      (iterator) => {
-        if (iterator) {
-          return iterator.next();
-        }
-        return DONE_RESULT;
-      }
-    );
-  }
-  scopeElementRef(ref) {
-    return this.uniqueDescedants(() => ref.el.ref);
-  }
-  scopeExtendElement({ element }) {
-    return stream([element.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(element)));
-  }
-  scopeElementView({ viewOf, extends: ext }) {
-    if (viewOf) {
-      return stream([viewOf.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(viewOf)));
-    }
-    if (ext) {
-      return stream([ext]).flatMap((v) => {
-        const view = v.view.ref;
-        return view ? this.scopeElementView(view) : EMPTY_STREAM;
-      });
-    }
-    return EMPTY_STREAM;
-  }
-  getScope(context) {
-    const referenceType = this.reflection.getReferenceType(context);
-    try {
-      const container = context.container;
-      if (ast.isFqnElementRef(container) && context.property === "el") {
-        const parent = container.parent;
-        if (!parent) {
-          return this.getGlobalScope(referenceType);
-        }
-        return new StreamScope(this.directChildrenOf(getFqnElementRef(parent)));
-      }
-      if (ast.isElementRef(container) && context.property === "el") {
-        const parent = container.parent;
-        if (parent) {
-          return new StreamScope(this.scopeElementRef(parent));
-        }
-      }
-      return this.computeScope(context);
-    } catch (e) {
-      logError(e);
-      return this.getGlobalScope(referenceType);
-    }
-  }
-  computeScope(context) {
-    const referenceType = this.reflection.getReferenceType(context);
-    const scopes = [];
-    const doc = getDocument(context.container);
-    const precomputed = doc.precomputedScopes;
-    if (precomputed) {
-      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) {
-          scopes.push(stream(elements));
-        }
-        if (referenceType === ast.Element) {
-          if (ast.isExtendElementBody(container)) {
-            scopes.push(this.scopeExtendElement(container.$container));
-          }
-          if (ast.isElementViewBody(container)) {
-            scopes.push(this.scopeElementView(container.$container));
-          }
-        }
-        container = container.$container;
-      }
-    }
-    return scopes.reduceRight((outerScope, elements) => {
-      return this.createScope(elements, outerScope);
-    }, this.getGlobalScope(referenceType));
-  }
-  /**
-   * Create a global scope filtered for the given reference type.
-   */
-  getGlobalScope(referenceType) {
-    return new StreamScope(this.indexManager.allElements(referenceType));
-  }
-}

package/dist/shared/NodeKindProvider.d.ts

@@ -1,16 +0,0 @@
-import { type AstNode, type AstNodeDescription } from 'langium';
-import type { LangiumSharedServices, NodeKindProvider as LspNodeKindProvider } from 'langium/lsp';
-import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-protocol';
-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;
-}
-//# sourceMappingURL=NodeKindProvider.d.ts.map

package/dist/shared/NodeKindProvider.js

@@ -1,58 +0,0 @@
-import { CompletionItemKind, SymbolKind } from "vscode-languageserver-protocol";
-import { ast } from "../ast.js";
-export class NodeKindProvider {
-  constructor(services) {
-    this.services = services;
-  }
-  /**
-   * Returns a `SymbolKind` as used by `WorkspaceSymbolProvider` or `DocumentSymbolProvider`.
-   */
-  // prettier-ignore
-  getSymbolKind(node) {
-    const hasType = (type) => "type" in node && this.services.AstReflection.isSubtype(node.type, type);
-    switch (true) {
-      case (ast.isElement(node) || hasType(ast.Element) || (ast.isExtendElement(node) || hasType(ast.ExtendElement))): {
-        return SymbolKind.Constructor;
-      }
-      case (ast.isModel(node) || ast.isModelViews(node) || ast.isSpecificationRule(node) || hasType(ast.Model) || hasType(ast.ModelViews) || hasType(ast.SpecificationRule)): {
-        return SymbolKind.Namespace;
-      }
-      case (ast.isElementView(node) || hasType(ast.ElementView)): {
-        return SymbolKind.Class;
-      }
-      case (ast.isTag(node) || hasType(ast.Tag) || (ast.isSpecificationTag(node) || hasType(ast.SpecificationTag))): {
-        return SymbolKind.EnumMember;
-      }
-      case (ast.isRelationshipKind(node) || hasType(ast.RelationshipKind) || (ast.isSpecificationRelationshipKind(node) || hasType(ast.SpecificationRelationshipKind))): {
-        return SymbolKind.Event;
-      }
-      case (ast.isElementKind(node) || hasType(ast.ElementKind) || (ast.isSpecificationElementKind(node) || hasType(ast.SpecificationElementKind))): {
-        return SymbolKind.TypeParameter;
-      }
-    }
-    return SymbolKind.Constant;
-  }
-  /**
-   * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
-   */
-  getCompletionItemKind(node) {
-    switch (this.getSymbolKind(node)) {
-      case SymbolKind.Constructor:
-        return CompletionItemKind.Constructor;
-      case SymbolKind.Namespace:
-        return CompletionItemKind.Module;
-      case SymbolKind.Class:
-        return CompletionItemKind.Class;
-      case SymbolKind.EnumMember:
-        return CompletionItemKind.EnumMember;
-      case SymbolKind.TypeParameter:
-        return CompletionItemKind.TypeParameter;
-      case SymbolKind.Interface:
-        return CompletionItemKind.Interface;
-      case SymbolKind.Event:
-        return CompletionItemKind.Event;
-      default:
-        return CompletionItemKind.Keyword;
-    }
-  }
-}