@likec4/language-server 1.17.1 → 1.19.0

package/src/validation/dynamic-view-step.ts

@@ -1,9 +1,9 @@
 import { isAncestor } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
 import { ast } from '../ast'
-import { elementRef } from '../elementRef'
 import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
+import { elementRef } from '../utils/elementRef'
 
 export const dynamicViewStep = (services: LikeC4Services): ValidationCheck<ast.DynamicViewStep> => {
   const fqnIndex = services.likec4.FqnIndex

package/src/validation/index.ts

@@ -1,6 +1,10 @@
-import { type ast } from '../ast'
+import type { AstNode } from 'langium'
+import { isNullish } from 'remeda'
+import { DiagnosticSeverity } from 'vscode-languageserver-types'
+import { type LikeC4AstNode, type LikeC4LangiumDocument, ast } from '../ast'
 import { logger } from '../logger'
 import type { LikeC4Services } from '../module'
+import { deployedInstanceChecks, deploymentNodeChecks, deploymentRelationChecks } from './deployment-checks'
 import { dynamicViewRulePredicate } from './dynamic-view-rule'
 import { dynamicViewStep } from './dynamic-view-step'
 import { elementChecks } from './element'
@@ -14,21 +18,115 @@ import {
   modelRuleChecks,
   relationshipChecks,
   specificationRuleChecks,
-  tagChecks
+  tagChecks,
 } from './specification'
 import { viewChecks } from './view'
 import {
   elementPredicateWithChecks,
   expandElementExprChecks,
+  fqnRefExprChecks,
   incomingExpressionChecks,
   outgoingExpressionChecks,
-  relationPredicateWithChecks
+  relationExprChecks,
+  relationPredicateWithChecks,
 } from './view-predicates'
 
+type Guard<N extends AstNode> = (n: AstNode) => n is N
+type Guarded<G> = G extends Guard<infer N> ? N : never
+
+function validatableAstNodeGuards<const Predicates extends Guard<AstNode>[]>(
+  predicates: Predicates,
+) {
+  return (n: AstNode): n is Guarded<Predicates[number]> => predicates.some(p => p(n))
+}
+const isValidatableAstNode = validatableAstNodeGuards([
+  ast.isGlobals,
+  ast.isGlobalPredicateGroup,
+  ast.isGlobalDynamicPredicateGroup,
+  ast.isGlobalStyle,
+  ast.isGlobalStyleGroup,
+  ast.isDynamicViewPredicateIterator,
+  ast.isElementPredicateWith,
+  ast.isRelationPredicateWith,
+  ast.isElementExpression,
+  ast.isRelationExpression,
+  ast.isDynamicViewParallelSteps,
+  ast.isDynamicViewStep,
+  ast.isDeploymentViewRule,
+  ast.isDeploymentViewRulePredicate,
+  ast.isExpressionV2,
+  ast.isRelationExpr,
+  ast.isFqnRefExpr,
+  ast.isViewProperty,
+  ast.isStyleProperty,
+  ast.isPredicate,
+  ast.isTags,
+  ast.isViewRule,
+  ast.isDynamicViewRule,
+  ast.isLikeC4View,
+  ast.isViewRuleStyleOrGlobalRef,
+  ast.isDeployedInstance,
+  ast.isDeploymentNode,
+  ast.isDeploymentRelation,
+  ast.isRelationshipStyleProperty,
+  ast.isMetadataProperty,
+  ast.isRelation,
+  ast.isElementProperty,
+  ast.isStringProperty,
+  ast.isNavigateToProperty,
+  ast.isElement,
+  ast.isExtendElement,
+  ast.isSpecificationElementKind,
+  ast.isSpecificationRelationshipKind,
+  ast.isSpecificationDeploymentNodeKind,
+  ast.isSpecificationTag,
+  ast.isSpecificationColor,
+  ast.isSpecificationRule,
+])
+type ValidatableAstNode = Guarded<typeof isValidatableAstNode>
+
+const findInvalidContainer = (node: LikeC4AstNode): ValidatableAstNode | undefined => {
+  let nd = node as LikeC4AstNode['$container']
+  while (nd && !ast.isLikeC4Grammar(nd)) {
+    if (isValidatableAstNode(nd)) {
+      return nd
+    }
+    nd = nd.$container
+  }
+  return undefined
+}
+
+export function checksFromDiagnostics(doc: LikeC4LangiumDocument) {
+  const errors = 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: ValidatableAstNode) => !invalidNodes.has(n)
+  return {
+    isValid,
+    invalidNodes,
+  }
+}
+export type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>
+export type IsValidFn = ChecksFromDiagnostics['isValid']
+
 export function registerValidationChecks(services: LikeC4Services) {
-  logger.info('registerValidationChecks')
+  logger.debug('registerValidationChecks')
   const registry = services.validation.ValidationRegistry
   registry.register<ast.LikeC4AstType>({
+    DeployedInstance: deployedInstanceChecks(services),
+    DeploymentNode: deploymentNodeChecks(services),
+    DeploymentRelation: deploymentRelationChecks(services),
+    FqnRefExpr: fqnRefExprChecks(services),
+    RelationExpr: relationExprChecks(services),
     NotesProperty: notesPropertyRuleChecks(services),
     OpacityProperty: opacityPropertyRuleChecks(services),
     IconProperty: iconPropertyRuleChecks(services),
@@ -51,7 +149,7 @@ export function registerValidationChecks(services: LikeC4Services) {
     ExpandElementExpression: expandElementExprChecks(services),
     RelationshipKind: relationshipChecks(services),
     IncomingRelationExpression: incomingExpressionChecks(services),
-    OutgoingRelationExpression: outgoingExpressionChecks(services)
+    OutgoingRelationExpression: outgoingExpressionChecks(services),
   })
   const connection = services.shared.lsp.Connection
   if (connection) {
@@ -61,7 +159,7 @@ export function registerValidationChecks(services: LikeC4Services) {
         logger.debug(`clear diagnostics for deleted ${uri.path}`)
         void connection.sendDiagnostics({
           uri: uri.toString(),
-          diagnostics: []
+          diagnostics: [],
         })
       }
     })

package/src/validation/relation.ts

@@ -2,8 +2,8 @@ import { isSameHierarchy } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
 import { isDefined } from 'remeda'
 import { ast } from '../ast'
-import { elementRef } from '../elementRef'
 import type { LikeC4Services } from '../module'
+import { elementRef } from '../utils/elementRef'
 import { tryOrLog } from './_shared'
 
 export const relationChecks = (services: LikeC4Services): ValidationCheck<ast.Relation> => {

package/src/validation/view-predicates/expression-v2.ts

@@ -0,0 +1,101 @@
+import { FqnExpr, FqnRef } from '@likec4/core'
+import { AstUtils, type ValidationCheck } from 'langium'
+import { isNonNullish, isNullish } from 'remeda'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
+
+export const relationExprChecks = (services: LikeC4Services): ValidationCheck<ast.RelationExpr> => {
+  const ModelParser = services.likec4.ModelParser
+  return tryOrLog((node, accept) => {
+    if (node.$container.$type !== 'DeploymentViewRulePredicateExpression') {
+      // skip validation for this node, validated by container
+      return
+    }
+
+    const predicate = AstUtils.getContainerOfType(node, ast.isDeploymentViewRulePredicate)
+    if (!predicate || predicate.isInclude !== true) {
+      // no restriction for exclude predicate
+      return
+    }
+
+    const doc = AstUtils.getDocument(node)
+    const parser = ModelParser.forDocument(doc)
+
+    const ModelRefOnlyExclude = 'Model reference is allowed in exclude predicate only'
+
+    if (ast.isDirectedRelationExpr(node)) {
+      if (FqnExpr.isModelRef(parser.parseFqnExpr(node.source.from))) {
+        accept('error', ModelRefOnlyExclude, {
+          node: node.source,
+          property: 'from'
+        })
+      }
+
+      if (FqnExpr.isModelRef(parser.parseFqnExpr(node.target))) {
+        accept('error', ModelRefOnlyExclude, {
+          node,
+          property: 'target'
+        })
+      }
+      return
+    }
+
+    let expr: ast.FqnExpr
+    if (ast.isIncomingRelationExpr(node)) {
+      expr = node.to
+    } else if (ast.isOutgoingRelationExpr(node)) {
+      expr = node.from
+    } else {
+      expr = node.inout.to
+    }
+    if (FqnExpr.isModelRef(parser.parseFqnExpr(expr))) {
+      accept('error', ModelRefOnlyExclude, {
+        node
+      })
+      return
+    }
+  })
+}
+
+export const fqnRefExprChecks = (services: LikeC4Services): ValidationCheck<ast.FqnRefExpr> => {
+  const ModelParser = services.likec4.ModelParser
+  // const DeploymentsIndex = services.likec4.DeploymentsIndex
+  // const Names = services.references.NameProvider as LikeC4NameProvider
+  // const Locator = services.workspace.AstNodeLocator
+  // const fqnIndex = services.likec4.FqnIndex
+  return tryOrLog((node, accept) => {
+    const referenceTo = node.ref.value.ref
+    if (isNullish(referenceTo)) {
+      accept('error', 'Invalid empty reference', {
+        node
+      })
+      return
+    }
+    const doc = AstUtils.getDocument(node)
+    const expr = ModelParser.forDocument(doc).parseFqnRefExpr(node)
+
+    // This expression is part of element predicate
+    if (node.$container.$type === 'DeploymentViewRulePredicateExpression') {
+      if (FqnExpr.isModelRef(expr)) {
+        accept('error', 'Deployment view predicate must reference deployment model', {
+          node
+        })
+        return
+      }
+      if (FqnExpr.isDeploymentRef(expr) && FqnRef.isInsideInstanceRef(expr.ref)) {
+        accept('error', 'Must reference deployment nodes or instances, but not internals', {
+          node
+        })
+        return
+      }
+    }
+
+    if (!ast.isDeploymentNode(referenceTo) && isNonNullish(node.selector)) {
+      accept('warning', `Selector '${node.selector}' applies to deployment nodes only, ignored here`, {
+        node,
+        property: 'selector'
+      })
+    }
+  })
+}

package/src/validation/view-predicates/index.ts

@@ -1,5 +1,6 @@
 export * from './element-with'
 export * from './expanded-element'
+export * from './expression-v2'
 export * from './incoming'
 export * from './outgoing'
 export * from './relation-with'

package/src/view-utils/assignNavigateTo.ts

@@ -1,11 +1,11 @@
-import { type ComputedView, type Fqn, isComputedElementView, type ViewID } from '@likec4/core'
+import { ComputedNode, ComputedView, type Fqn, type ViewId } from '@likec4/core'
 import { find, isNullish } from 'remeda'
 
 export function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R {
-  const allElementViews = new Map<Fqn, ViewID[]>()
+  const allElementViews = new Map<Fqn, ViewId[]>()
 
   for (const v of views) {
-    if (isComputedElementView(v) && v.viewOf && isNullish(v.extends)) {
+    if (ComputedView.isElement(v) && v.viewOf && isNullish(v.extends)) {
       const viewsOf = allElementViews.get(v.viewOf) ?? []
       viewsOf.push(v.id)
       allElementViews.set(v.viewOf, viewsOf)
@@ -15,11 +15,12 @@ export function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R
   // set default navigateTo
   for (const { id, nodes } of views) {
     for (const node of nodes) {
-      if (node.navigateTo) {
+      const modelRef = ComputedNode.modelRef(node)
+      if (node.navigateTo || !modelRef) {
         continue
       }
       // find first element view that is not the current one
-      const navigateTo = find(allElementViews.get(node.id) ?? [], v => v !== id)
+      const navigateTo = find(allElementViews.get(modelRef) ?? [], v => v !== id)
       if (navigateTo) {
         node.navigateTo = navigateTo
       }

package/src/view-utils/index.ts

@@ -1,3 +1,2 @@
 export * from './assignNavigateTo'
-export * from './resolve-extended-views'
 export * from './resolve-relative-paths'

package/src/view-utils/manual-layout.ts

@@ -1,7 +1,13 @@
+import type * as c4 from '@likec4/core'
 import { isAutoLayoutDirection, type ViewManualLayout } from '@likec4/core'
 import { decode, encode } from '@msgpack/msgpack'
 import { fromBase64, toBase64 } from '@smithy/util-base64'
+import { AstUtils, CstUtils } from 'langium'
 import { mapValues } from 'remeda'
+import type { ast } from '../ast'
+import { logger } from '../logger'
+
+const { getDocument } = AstUtils
 
 function pack({
   nodes,
@@ -89,3 +95,22 @@ export function deserializeFromComment(comment: string): ViewManualLayout {
   const decodedb64 = fromBase64(b64)
   return unpack(decode(decodedb64) as any) as ViewManualLayout
 }
+
+export function parseViewManualLayout(node: ast.LikeC4View): c4.ViewManualLayout | undefined {
+  const commentNode = CstUtils.findCommentNode(node.$cstNode, ['BLOCK_COMMENT'])
+  if (!commentNode || !hasManualLayout(commentNode.text)) {
+    return undefined
+  }
+  try {
+    return deserializeFromComment(commentNode.text)
+  } catch (e) {
+    const doc = getDocument(node)
+    logger.warn(e)
+    logger.warn(
+      `Ignoring manual layout of "${node.name ?? 'unnamed'}" at ${doc.uri.fsPath}:${
+        1 + (commentNode.range.start.line || 0)
+      }`
+    )
+    return undefined
+  }
+}

package/dist/browser.cjs

@@ -1,25 +0,0 @@
-'use strict';
-
-const lsp = require('langium/lsp');
-const browser = require('vscode-languageserver/browser');
-const module$1 = require('./shared/language-server.DKV_FdPN.cjs');
-
-function startLanguageServer() {
-  const messageReader = new browser.BrowserMessageReader(self);
-  const messageWriter = new browser.BrowserMessageWriter(self);
-  const connection = browser.createConnection(messageReader, messageWriter);
-  const services = module$1.createLanguageServices({ connection });
-  lsp.startLanguageServer(services.shared);
-  return {
-    ...services,
-    connection,
-    messageReader,
-    messageWriter
-  };
-}
-
-exports.LikeC4Module = module$1.LikeC4Module;
-exports.createCustomLanguageServices = module$1.createCustomLanguageServices;
-exports.createLanguageServices = module$1.createLanguageServices;
-exports.setLogLevel = module$1.setLogLevel;
-exports.startLanguageServer = startLanguageServer;

package/dist/browser.d.cts

@@ -1,23 +0,0 @@
-import { L as LikeC4SharedServices, a as LikeC4Services } from './shared/language-server.BQRvVmE0.cjs';
-export { f as FqnIndex, F as FqnIndexEntry, I as IsValidFn, k as LanguageServicesContext, j as LikeC4AddedServices, g as LikeC4ModelBuilder, h as LikeC4ModelLocator, i as LikeC4ModelParser, d as LikeC4Module, M as ModelParsedListener, e as computeDocumentFqn, c as createCustomLanguageServices, b as createLanguageServices, l as createSharedServices, s as setLogLevel } from './shared/language-server.BQRvVmE0.cjs';
-import * as vscode_languageserver from 'vscode-languageserver';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageserver/browser';
-import 'langium';
-import 'langium/lsp';
-import 'vscode-languageserver-types';
-import '@likec4/core';
-import 'type-fest';
-import './protocol.cjs';
-import 'vscode-jsonrpc';
-import 'vscode-uri';
-import '@likec4/log';
-
-declare function startLanguageServer(): {
-    connection: vscode_languageserver.Connection;
-    messageReader: BrowserMessageReader;
-    messageWriter: BrowserMessageWriter;
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
-
-export { LikeC4Services, LikeC4SharedServices, startLanguageServer };

package/dist/browser.d.mts

@@ -1,23 +0,0 @@
-import { L as LikeC4SharedServices, a as LikeC4Services } from './shared/language-server._wkyPgso.mjs';
-export { f as FqnIndex, F as FqnIndexEntry, I as IsValidFn, k as LanguageServicesContext, j as LikeC4AddedServices, g as LikeC4ModelBuilder, h as LikeC4ModelLocator, i as LikeC4ModelParser, d as LikeC4Module, M as ModelParsedListener, e as computeDocumentFqn, c as createCustomLanguageServices, b as createLanguageServices, l as createSharedServices, s as setLogLevel } from './shared/language-server._wkyPgso.mjs';
-import * as vscode_languageserver from 'vscode-languageserver';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageserver/browser';
-import 'langium';
-import 'langium/lsp';
-import 'vscode-languageserver-types';
-import '@likec4/core';
-import 'type-fest';
-import './protocol.mjs';
-import 'vscode-jsonrpc';
-import 'vscode-uri';
-import '@likec4/log';
-
-declare function startLanguageServer(): {
-    connection: vscode_languageserver.Connection;
-    messageReader: BrowserMessageReader;
-    messageWriter: BrowserMessageWriter;
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
-
-export { LikeC4Services, LikeC4SharedServices, startLanguageServer };

package/dist/browser.mjs

@@ -1,20 +0,0 @@
-import { startLanguageServer as startLanguageServer$1 } from 'langium/lsp';
-import { BrowserMessageReader, BrowserMessageWriter, createConnection } from 'vscode-languageserver/browser';
-import { c as createLanguageServices } from './shared/language-server.BIbAD1T-.mjs';
-export { L as LikeC4Module, a as createCustomLanguageServices, s as setLogLevel } from './shared/language-server.BIbAD1T-.mjs';
-
-function startLanguageServer() {
-  const messageReader = new BrowserMessageReader(self);
-  const messageWriter = new BrowserMessageWriter(self);
-  const connection = createConnection(messageReader, messageWriter);
-  const services = createLanguageServices({ connection });
-  startLanguageServer$1(services.shared);
-  return {
-    ...services,
-    connection,
-    messageReader,
-    messageWriter
-  };
-}
-
-export { createLanguageServices, startLanguageServer };

package/dist/index.cjs

@@ -1,53 +0,0 @@
-'use strict';
-
-const lsp = require('langium/lsp');
-const node$1 = require('vscode-languageserver/node');
-const langium = require('langium');
-const node = require('langium/node');
-const node_fs = require('node:fs');
-const promises = require('node:fs/promises');
-const node_path = require('node:path');
-const module$1 = require('./shared/language-server.DKV_FdPN.cjs');
-
-const LikeC4FileSystem = {
-  fileSystemProvider: () => new SymLinkTraversingFileSystemProvider()
-};
-class SymLinkTraversingFileSystemProvider extends node.NodeFileSystemProvider {
-  async readDirectory(folderPath) {
-    const dirents = await promises.readdir(folderPath.fsPath, { withFileTypes: true });
-    return dirents.map((dirent) => this.followUri(langium.UriUtils.joinPath(folderPath, dirent.name)));
-  }
-  followUri(uri) {
-    const directoryPath = node_path.dirname(uri.fsPath);
-    const stat = node_fs.lstatSync(uri.fsPath);
-    if (stat.isSymbolicLink()) {
-      const resolved_link = node_fs.readlinkSync(uri.fsPath);
-      const linked_path = node_path.resolve(directoryPath, resolved_link);
-      return this.followUri(langium.URI.file(linked_path));
-    } else {
-      return {
-        isFile: stat.isFile(),
-        isDirectory: stat.isDirectory(),
-        uri
-      };
-    }
-  }
-}
-
-function startLanguageServer() {
-  const connection = node$1.createConnection(node$1.ProposedFeatures.all);
-  const services = module$1.createLanguageServices({ connection, ...LikeC4FileSystem });
-  lsp.startLanguageServer(services.shared);
-  return {
-    ...services,
-    connection
-  };
-}
-
-exports.LikeC4Module = module$1.LikeC4Module;
-exports.createCustomLanguageServices = module$1.createCustomLanguageServices;
-exports.createLanguageServices = module$1.createLanguageServices;
-exports.lspLogger = module$1.logger;
-exports.setLogLevel = module$1.setLogLevel;
-exports.LikeC4FileSystem = LikeC4FileSystem;
-exports.startLanguageServer = startLanguageServer;

package/dist/index.d.cts

@@ -1,34 +0,0 @@
-import { L as LikeC4SharedServices, a as LikeC4Services } from './shared/language-server.BQRvVmE0.cjs';
-export { f as FqnIndex, F as FqnIndexEntry, I as IsValidFn, k as LanguageServicesContext, j as LikeC4AddedServices, g as LikeC4ModelBuilder, h as LikeC4ModelLocator, i as LikeC4ModelParser, d as LikeC4Module, M as ModelParsedListener, e as computeDocumentFqn, c as createCustomLanguageServices, b as createLanguageServices, l as createSharedServices, m as lspLogger, s as setLogLevel } from './shared/language-server.BQRvVmE0.cjs';
-import * as vscode_languageserver_lib_common_inlineCompletion_proposed from 'vscode-languageserver/lib/common/inlineCompletion.proposed';
-import * as vscode_languageserver from 'vscode-languageserver';
-import { URI, FileSystemNode } from 'langium';
-import { NodeFileSystemProvider } from 'langium/node';
-import 'langium/lsp';
-import 'vscode-languageserver-types';
-import '@likec4/core';
-import 'type-fest';
-import './protocol.cjs';
-import 'vscode-jsonrpc';
-import 'vscode-uri';
-import '@likec4/log';
-
-declare const LikeC4FileSystem: {
-    fileSystemProvider: () => SymLinkTraversingFileSystemProvider;
-};
-/**
- * A file system provider that follows symbolic links.
- * @see https://github.com/likec4/likec4/pull/1213
- */
-declare class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
-    readDirectory(folderPath: URI): Promise<FileSystemNode[]>;
-    followUri(uri: URI): FileSystemNode;
-}
-
-declare function startLanguageServer(): {
-    connection: vscode_languageserver._Connection<vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver_lib_common_inlineCompletion_proposed.InlineCompletionFeatureShape, vscode_languageserver._>;
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
-
-export { LikeC4FileSystem, LikeC4Services, LikeC4SharedServices, startLanguageServer };

package/dist/index.d.mts

@@ -1,34 +0,0 @@
-import { L as LikeC4SharedServices, a as LikeC4Services } from './shared/language-server._wkyPgso.mjs';
-export { f as FqnIndex, F as FqnIndexEntry, I as IsValidFn, k as LanguageServicesContext, j as LikeC4AddedServices, g as LikeC4ModelBuilder, h as LikeC4ModelLocator, i as LikeC4ModelParser, d as LikeC4Module, M as ModelParsedListener, e as computeDocumentFqn, c as createCustomLanguageServices, b as createLanguageServices, l as createSharedServices, m as lspLogger, s as setLogLevel } from './shared/language-server._wkyPgso.mjs';
-import * as vscode_languageserver_lib_common_inlineCompletion_proposed from 'vscode-languageserver/lib/common/inlineCompletion.proposed';
-import * as vscode_languageserver from 'vscode-languageserver';
-import { URI, FileSystemNode } from 'langium';
-import { NodeFileSystemProvider } from 'langium/node';
-import 'langium/lsp';
-import 'vscode-languageserver-types';
-import '@likec4/core';
-import 'type-fest';
-import './protocol.mjs';
-import 'vscode-jsonrpc';
-import 'vscode-uri';
-import '@likec4/log';
-
-declare const LikeC4FileSystem: {
-    fileSystemProvider: () => SymLinkTraversingFileSystemProvider;
-};
-/**
- * A file system provider that follows symbolic links.
- * @see https://github.com/likec4/likec4/pull/1213
- */
-declare class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
-    readDirectory(folderPath: URI): Promise<FileSystemNode[]>;
-    followUri(uri: URI): FileSystemNode;
-}
-
-declare function startLanguageServer(): {
-    connection: vscode_languageserver._Connection<vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver._, vscode_languageserver_lib_common_inlineCompletion_proposed.InlineCompletionFeatureShape, vscode_languageserver._>;
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
-
-export { LikeC4FileSystem, LikeC4Services, LikeC4SharedServices, startLanguageServer };

package/dist/index.mjs

@@ -1,46 +0,0 @@
-import { startLanguageServer as startLanguageServer$1 } from 'langium/lsp';
-import { createConnection, ProposedFeatures } from 'vscode-languageserver/node';
-import { UriUtils, URI } from 'langium';
-import { NodeFileSystemProvider } from 'langium/node';
-import { lstatSync, readlinkSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { c as createLanguageServices } from './shared/language-server.BIbAD1T-.mjs';
-export { L as LikeC4Module, a as createCustomLanguageServices, l as lspLogger, s as setLogLevel } from './shared/language-server.BIbAD1T-.mjs';
-
-const LikeC4FileSystem = {
-  fileSystemProvider: () => new SymLinkTraversingFileSystemProvider()
-};
-class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
-  async readDirectory(folderPath) {
-    const dirents = await readdir(folderPath.fsPath, { withFileTypes: true });
-    return dirents.map((dirent) => this.followUri(UriUtils.joinPath(folderPath, dirent.name)));
-  }
-  followUri(uri) {
-    const directoryPath = dirname(uri.fsPath);
-    const stat = lstatSync(uri.fsPath);
-    if (stat.isSymbolicLink()) {
-      const resolved_link = readlinkSync(uri.fsPath);
-      const linked_path = resolve(directoryPath, resolved_link);
-      return this.followUri(URI.file(linked_path));
-    } else {
-      return {
-        isFile: stat.isFile(),
-        isDirectory: stat.isDirectory(),
-        uri
-      };
-    }
-  }
-}
-
-function startLanguageServer() {
-  const connection = createConnection(ProposedFeatures.all);
-  const services = createLanguageServices({ connection, ...LikeC4FileSystem });
-  startLanguageServer$1(services.shared);
-  return {
-    ...services,
-    connection
-  };
-}
-
-export { LikeC4FileSystem, createLanguageServices, startLanguageServer };