@likec4/language-server 1.17.1 → 1.18.0

package/src/model-change/changeViewLayout.ts

@@ -1,6 +1,6 @@
 import { invariant, type ViewChange } from '@likec4/core'
 import { GrammarUtils } from 'langium'
-import { isNumber } from 'remeda'
+import { findLast, isNumber } from 'remeda'
 import { TextEdit } from 'vscode-languageserver-types'
 import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument, toAstViewLayoutDirection } from '../ast'
 import type { LikeC4Services } from '../module'
@@ -24,7 +24,7 @@ export function changeViewLayout(_services: LikeC4Services, {
   const viewCstNode = viewAst.$cstNode
   invariant(viewCstNode, 'viewCstNode')
   const newdirection = toAstViewLayoutDirection(layout.direction)
-  const existingRule = viewAst.body.rules.findLast(ast.isViewRuleAutoLayout) as ast.ViewRuleAutoLayout | undefined
+  const existingRule = findLast(viewAst.body.rules, ast.isViewRuleAutoLayout) as ast.ViewRuleAutoLayout | undefined
 
   let newRule = `autoLayout ${newdirection}`
 

package/src/module.ts

@@ -1,4 +1,4 @@
-import { EmptyFileSystem, inject, type Module, WorkspaceCache } from 'langium'
+import { DocumentCache, EmptyFileSystem, inject, type Module, WorkspaceCache } from 'langium'
 import {
   createDefaultModule,
   createDefaultSharedModule,
@@ -8,6 +8,7 @@ import {
   type PartialLangiumServices,
   type PartialLangiumSharedServices
 } from 'langium/lsp'
+import { LikeC4Formatter } from './formatting/LikeC4Formatter'
 import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module'
 import { logErrorToTelemetry, logToLspConnection } from './logger'
 import {
@@ -19,13 +20,12 @@ import {
   LikeC4HoverProvider,
   LikeC4SemanticTokenProvider
 } from './lsp'
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
+import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
 import { LikeC4ModelChanges } from './model-change/ModelChanges'
-import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references'
+import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references'
 import { Rpc } from './Rpc'
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared'
 import { registerValidationChecks } from './validation'
-import { LikeC4Formatter } from './formatting/LikeC4Formatter'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T
@@ -61,8 +61,10 @@ const LikeC4SharedModule: Module<
 export interface LikeC4AddedServices {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   WorkspaceCache: WorkspaceCache<string, any>
+  DocumentCache: DocumentCache<string, any>
   Rpc: Rpc
   likec4: {
+    DeploymentsIndex: DeploymentsIndex
     FqnIndex: FqnIndex
     ModelParser: LikeC4ModelParser
     ModelBuilder: LikeC4ModelBuilder
@@ -80,6 +82,7 @@ export interface LikeC4AddedServices {
     DocumentLinkProvider: LikeC4DocumentLinkProvider
   }
   references: {
+    NameProvider: LikeC4NameProvider
     ScopeComputation: LikeC4ScopeComputation
     ScopeProvider: LikeC4ScopeProvider
   }
@@ -94,8 +97,10 @@ function bind<T>(Type: Constructor<T, [LikeC4Services]>) {
 
 export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices> = {
   WorkspaceCache: (services: LikeC4Services) => new WorkspaceCache(services.shared),
+  DocumentCache: (services: LikeC4Services) => new DocumentCache(services.shared),
   Rpc: bind(Rpc),
   likec4: {
+    DeploymentsIndex: bind(DeploymentsIndex),
     ModelChanges: bind(LikeC4ModelChanges),
     FqnIndex: bind(FqnIndex),
     ModelParser: bind(LikeC4ModelParser),
@@ -114,6 +119,7 @@ export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC
     Formatter: bind(LikeC4Formatter)
   },
   references: {
+    NameProvider: bind(LikeC4NameProvider),
     ScopeComputation: bind(LikeC4ScopeComputation),
     ScopeProvider: bind(LikeC4ScopeProvider)
   }

package/src/protocol.ts

@@ -3,9 +3,9 @@ import type {
   ComputedView,
   Fqn,
   ParsedLikeC4Model,
-  RelationID,
+  RelationId,
   ViewChange,
-  ViewID
+  ViewId
 } from '@likec4/core'
 import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc'
 import type { DocumentUri, Location } from 'vscode-languageserver-types'
@@ -30,7 +30,7 @@ export const fetchComputedModel = new RequestType<
 )
 export type FetchComputedModelRequest = typeof fetchComputedModel
 
-export const computeView = new RequestType<{ viewId: ViewID }, { view: ComputedView | null }, void>(
+export const computeView = new RequestType<{ viewId: ViewId }, { view: ComputedView | null }, void>(
   'likec4/computeView'
 )
 export type ComputeViewRequest = typeof computeView
@@ -47,17 +47,21 @@ export type LocateParams =
     property?: string
   }
   | {
-    relation: RelationID
+    relation: RelationId
   }
   | {
-    view: ViewID
+    deployment: Fqn
+    property?: string
+  }
+  | {
+    view: ViewId
   }
 export const locate = new RequestType<LocateParams, Location | null, void>('likec4/locate')
 export type LocateRequest = typeof locate
 // #endregion
 
 export interface ChangeViewRequestParams {
-  viewId: ViewID
+  viewId: ViewId
   change: ViewChange
 }
 export const changeView = new RequestType<ChangeViewRequestParams, Location | null, void>('likec4/change-view')

package/src/references/index.ts

@@ -1,2 +1,3 @@
+export * from './name-provider'
 export * from './scope-computation'
 export * from './scope-provider'

package/src/references/name-provider.ts

@@ -0,0 +1,37 @@
+import { nonNullable } from '@likec4/core'
+import { type AstNode, type CstNode, DefaultNameProvider, isNamed, type NamedAstNode } from 'langium'
+import { ast } from '../ast'
+import type { LikeC4Services } from '../module'
+
+export class LikeC4NameProvider extends DefaultNameProvider {
+  constructor(protected services: LikeC4Services) {
+    super()
+  }
+
+  public getNameStrict(node: AstNode): string {
+    return nonNullable(
+      this.getName(node),
+      `Failed getName for ${this.services.workspace.AstNodeLocator.getAstNodePath(node)}`
+    )
+  }
+
+  override getName(node: AstNode): string | undefined {
+    if (isNamed(node)) {
+      return node.name
+    }
+    if (ast.isDeployedInstance(node)) {
+      return node.element.el.$refText
+    }
+    return undefined
+  }
+
+  override getNameNode(node: AstNode): CstNode | undefined {
+    if (isNamed(node)) {
+      return super.getNameNode(node)
+    }
+    if (ast.isDeployedInstance(node)) {
+      return node.element.el.$refNode
+    }
+    return undefined
+  }
+}

package/src/references/scope-computation.ts

@@ -6,21 +6,38 @@ import {
   MultiMap,
   type PrecomputedScopes
 } from 'langium'
-import { isNullish, isTruthy } from 'remeda'
+import { entries, filter, flatMap, forEach, forEachObj, groupBy, isNullish, isTruthy, pipe } from 'remeda'
 import type { CancellationToken } from 'vscode-languageserver'
 import { ast, type LikeC4LangiumDocument } from '../ast'
-import { logError } from '../logger'
+import { logError, logWarnError } from '../logger'
+import type { LikeC4Services } from '../module'
 
 type ElementsContainer = ast.Model | ast.ElementBody | ast.ExtendElementBody
+type DeploymentsContainer = ast.ModelDeployments | ast.DeploymentNodeBody
+
+function uniqueDescriptions(
+  descs: AstNodeDescription[]
+): AstNodeDescription[] {
+  return pipe(
+    descs,
+    groupBy(desc => `${desc.type}.${desc.name}`),
+    entries(),
+    flatMap(([_, descs]) => descs.length === 1 ? descs : [])
+  )
+}
 
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
+  constructor(services: LikeC4Services) {
+    super(services)
+  }
+
   override async computeExports(
     document: LikeC4LangiumDocument,
     _cancelToken?: CancellationToken
   ): Promise<AstNodeDescription[]> {
     const docExports: AstNodeDescription[] = []
     try {
-      const { specifications, models, views, globals, likec4lib } = document.parseResult.value
+      const { specifications, models, views, globals, likec4lib, deployments } = document.parseResult.value
 
       // Process library
       this.exportLibrary(likec4lib, docExports, document)
@@ -36,6 +53,8 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
 
       // Process global
       this.exportGlobals(globals, docExports, document)
+
+      this.exportDeployments(deployments, docExports, document)
     } catch (e) {
       logError(e)
     }
@@ -43,14 +62,15 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
   }
 
   private exportViews(
-    views: ast.ModelViews[] | undefined,
+    modelViews: ast.ModelViews[] | undefined,
     docExports: AstNodeDescription[],
     document: LikeC4LangiumDocument
   ) {
+    const views = modelViews?.flatMap(m => m.views)
     if (isNullish(views) || views.length === 0) {
       return
     }
-    for (const viewAst of views.flatMap(v => v.views)) {
+    for (const viewAst of views) {
       try {
         if (isTruthy(viewAst.name)) {
           docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document))
@@ -139,12 +159,14 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       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(
@@ -188,21 +210,58 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     }
   }
 
+  private exportDeployments(
+    modelDeployments: ast.ModelDeployments[] | undefined,
+    docExports: AstNodeDescription[],
+    document: LikeC4LangiumDocument
+  ) {
+    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)
+      }
+    }
+  }
+
   override computeLocalScopes(
     document: LikeC4LangiumDocument,
     _cancelToken?: CancellationToken
   ): Promise<PrecomputedScopes> {
     return new Promise(resolve => {
       const root = document.parseResult.value
+      const descendants = [] as AstNodeDescription[]
       const scopes = new MultiMap<AstNode, AstNodeDescription>()
+
       for (const model of root.models) {
         try {
-          const nested = this.processContainer(model, scopes, document)
-          scopes.addAll(root, nested.values())
+          descendants.push(
+            ...this.processContainer(model, scopes, document)
+          )
         } catch (e) {
           logError(e)
         }
       }
+      for (const deployment of root.deployments) {
+        try {
+          descendants.push(
+            ...this.processDeployments(deployment, scopes, document)
+          )
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+
+      uniqueDescriptions(descendants).forEach(desc => {
+        scopes.add(root, desc)
+      })
+
       resolve(scopes)
     })
   }
@@ -211,9 +270,10 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     container: ElementsContainer,
     scopes: PrecomputedScopes,
     document: LikeC4LangiumDocument
-  ) {
+  ): AstNodeDescription[] {
     const localScope = new MultiMap<string, AstNodeDescription>()
-    const nestedScopes = new MultiMap<string, AstNodeDescription>()
+    const descedants = [] as AstNodeDescription[]
+
     for (const el of container.elements) {
       if (ast.isRelation(el)) {
         continue
@@ -231,25 +291,74 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
 
       if (subcontainer && subcontainer.elements.length > 0) {
         try {
-          const nested = this.processContainer(subcontainer, scopes, document)
-          for (const [nestedName, desc] of nested) {
-            nestedScopes.add(nestedName, desc)
-          }
+          descedants.push(
+            ...this.processContainer(subcontainer, scopes, document)
+          )
         } catch (e) {
-          logError(e)
+          logWarnError(e)
         }
       }
     }
 
-    if (nestedScopes.size > 0) {
-      for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
-        // If name is unique for current scope
-        if (!localScope.has(name) && descriptions.length === 1) {
-          localScope.add(name, descriptions[0]!)
+    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
+  }
+
+  protected processDeployments(
+    container: DeploymentsContainer,
+    scopes: PrecomputedScopes,
+    document: LikeC4LangiumDocument
+  ): AstNodeDescription[] {
+    const localnames = new Set<string>()
+    const descedants = [] as AstNodeDescription[]
+
+    for (const el of container.elements) {
+      if (ast.isDeploymentRelation(el)) {
+        continue
+      }
+
+      let name = this.nameProvider.getName(el)
+      if (isTruthy(name)) {
+        const desc = this.descriptions.createDescription(el, name, document)
+        scopes.add(container, desc)
+        localnames.add(desc.name)
+      }
+
+      if (ast.isDeploymentNode(el) && el.body) {
+        try {
+          descedants.push(
+            ...this.processDeployments(el.body, scopes, document)
+          )
+        } catch (e) {
+          logWarnError(e)
         }
       }
     }
-    scopes.addAll(container, localScope.values())
-    return localScope
+    if (descedants.length > 0) {
+      pipe(
+        descedants,
+        filter(desc => !localnames.has(desc.name)),
+        groupBy(desc => desc.name),
+        forEachObj((descs, name) => {
+          if (descs.length === 1) {
+            scopes.add(container, descs[0])
+          }
+        })
+      )
+    }
+    return [...scopes.get(container).values()]
   }
 }

package/src/references/scope-provider.ts

@@ -1,5 +1,5 @@
-import { invariant } from '@likec4/core'
 import type * as c4 from '@likec4/core'
+import { nonexhaustive } from '@likec4/core'
 import type { AstNode } from 'langium'
 import {
   type AstNodeDescription,
@@ -16,20 +16,22 @@ import {
   StreamImpl,
   StreamScope
 } from 'langium'
-import { ast } from '../ast'
-import { elementRef, getFqnElementRef } from '../elementRef'
+import { ast, isLikeC4LangiumDocument } from '../ast'
 import { logger } from '../logger'
-import type { FqnIndex } from '../model/fqn-index'
+import type { DeploymentsIndex, FqnIndex } from '../model'
 import type { LikeC4Services } from '../module'
+import { elementRef, getFqnElementRef } from '../utils/elementRef'
 
 const { getDocument } = AstUtils
 
 export class LikeC4ScopeProvider extends DefaultScopeProvider {
+  private deploymentsIndex: DeploymentsIndex
   private fqnIndex: FqnIndex
 
   constructor(services: LikeC4Services) {
     super(services)
     this.fqnIndex = services.likec4.FqnIndex
+    this.deploymentsIndex = services.likec4.DeploymentsIndex
   }
 
   private directChildrenOf(parent: c4.Fqn): Stream<AstNodeDescription> {
@@ -87,15 +89,20 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
   override getScope(context: ReferenceInfo): Scope {
     try {
       const referenceType = this.reflection.getReferenceType(context)
-      if (referenceType !== ast.Element) {
-        return this.getGlobalScope(referenceType)
-      }
       try {
         const container = context.container
+        if (ast.isDeploymentRef(container)) {
+          return this.getScopeForDeploymentRef(container, context)
+        }
+
+        if (referenceType !== ast.Element) {
+          return this.getGlobalScope(referenceType, context)
+        }
+
         if (ast.isFqnElementRef(container) && context.property === 'el') {
           const parent = container.parent
           if (!parent) {
-            return this.getGlobalScope(referenceType)
+            return this.getGlobalScope(referenceType, context)
           }
           return new StreamScope(this.directChildrenOf(getFqnElementRef(parent)))
         }
@@ -119,7 +126,7 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
         return this.computeScope(context)
       } catch (e) {
         logger.warn(e)
-        return this.getGlobalScope(referenceType)
+        return this.getGlobalScope(referenceType, context)
       }
     } catch (e) {
       logger.warn(e)
@@ -127,42 +134,62 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
     }
   }
 
-  protected computeScope(context: ReferenceInfo) {
-    const referenceType = this.reflection.getReferenceType(context)
-    // computeScope is called only for elements
-    invariant(referenceType === ast.Element, 'Invalid reference type')
+  protected getScopeForDeploymentRef(container: ast.DeploymentRef, context: ReferenceInfo) {
+    const parent = container.parent
+    if (!parent) {
+      return new MapScope(
+        // First preference for deployment nodes
+        this.computeScope(context, ast.DeploymentNode).getAllElements(),
+        // Second preference for deployed instances
+        this.computeScope(context, ast.DeployedInstance)
+      )
+    }
+    const parentRef = parent.value.ref
+    if (!parentRef) {
+      return EMPTY_SCOPE
+    }
+    if (ast.isDeploymentNode(parentRef)) {
+      return new StreamScope(this.deploymentsIndex.nested(parentRef))
+    }
+    if (ast.isDeployedInstance(parentRef)) {
+      return new StreamScope(this.scopeElementRef(parentRef.element))
+    }
+    if (ast.isElement(parentRef)) {
+      return new StreamScope(this.uniqueDescedants(() => parentRef))
+    }
+    return nonexhaustive(parentRef)
+  }
+
+  protected computeScope(context: ReferenceInfo, referenceType = this.reflection.getReferenceType(context)) {
+    const isElementReference = this.reflection.isSubtype(referenceType, ast.Element)
+
     const scopes: Stream<AstNodeDescription>[] = []
     const doc = getDocument(context.container)
     const precomputed = doc.precomputedScopes
 
-    if (precomputed) {
-      const byReferenceType = (desc: AstNodeDescription) => this.reflection.isSubtype(desc.type, referenceType)
-      let container: AstNode | undefined = context.container
-      while (container) {
-        const elements = precomputed.get(container).filter(byReferenceType)
-        if (elements.length > 0) {
-          scopes.push(stream(elements))
-        }
+    if (!precomputed) {
+      return this.getGlobalScope(referenceType, context)
+    }
 
-        if (ast.isExtendElementBody(container)) {
-          scopes.push(this.scopeExtendElement(container.$container))
-        }
-        if (ast.isElementViewBody(container)) {
-          scopes.push(this.scopeElementView(container.$container))
-        }
-        container = container.$container
+    const byReferenceType = (desc: AstNodeDescription) => this.reflection.isSubtype(desc.type, referenceType)
+    let container: AstNode | undefined = context.container
+    while (container) {
+      const elements = precomputed.get(container).filter(byReferenceType)
+      if (elements.length > 0) {
+        scopes.push(stream(elements))
       }
+
+      if (isElementReference && ast.isExtendElementBody(container)) {
+        scopes.push(this.scopeExtendElement(container.$container))
+      }
+      if (isElementReference && 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.
-   */
-  protected override getGlobalScope(referenceType: string): Scope {
-    return new StreamScope(this.indexManager.allElements(referenceType))
+    }, this.getGlobalScope(referenceType, context))
   }
 }

package/src/shared/NodeKindProvider.ts

@@ -16,13 +16,17 @@ export class NodeKindProvider implements LspNodeKindProvider {
     switch (true) {
       case hasType(
         ast.Element,
-        ast.ExtendElement
+        ast.ExtendElement,
+        ast.DeploymentNode,
+        ast.DeployedInstance
       ):
         return SymbolKind.Constructor
 
       case hasType(
         ast.Model,
         ast.ModelViews,
+        ast.ModelDeployments,
+        ast.Globals,
         ast.SpecificationRule
       ):
         return SymbolKind.Namespace
@@ -46,7 +50,9 @@ export class NodeKindProvider implements LspNodeKindProvider {
 
       case hasType(
         ast.ElementKind,
-        ast.SpecificationElementKind
+        ast.DeploymentNodeKind,
+        ast.SpecificationElementKind,
+        ast.SpecificationDeploymentNodeKind
       ):
         return SymbolKind.TypeParameter
     }
@@ -66,6 +72,8 @@ export class NodeKindProvider implements LspNodeKindProvider {
 
       case hasType(
         ast.Element,
+        ast.DeploymentNode,
+        ast.DeployedInstance,
         ast.ExtendElement
       ):
         return CompletionItemKind.Constructor
@@ -73,6 +81,8 @@ export class NodeKindProvider implements LspNodeKindProvider {
       case hasType(
         ast.Model,
         ast.ModelViews,
+        ast.ModelDeployments,
+        ast.Globals,
         ast.SpecificationRule
       ):
         return CompletionItemKind.Module
@@ -98,7 +108,9 @@ export class NodeKindProvider implements LspNodeKindProvider {
 
       case hasType(
         ast.ElementKind,
-        ast.SpecificationElementKind
+        ast.SpecificationElementKind,
+        ast.DeploymentNodeKind,
+        ast.SpecificationDeploymentNodeKind
       ):
         return CompletionItemKind.TypeParameter
 

package/src/utils/deploymentRef.ts

@@ -0,0 +1,31 @@
+import { AstUtils } from 'langium'
+import { isNullish } from 'remeda'
+import { ast } from '../ast'
+
+export function instanceRef(deploymentRef: ast.DeploymentRef): ast.DeployedInstance | null {
+  let referenceable
+  while ((referenceable = deploymentRef.value?.ref)) {
+    if (ast.isDeploymentNode(referenceable)) {
+      return null
+    }
+    if (ast.isDeployedInstance(referenceable)) {
+      return referenceable
+    }
+    if (isNullish(deploymentRef.parent)) {
+      return null
+    }
+    deploymentRef = deploymentRef.parent
+  }
+  return null
+}
+
+export function deploymentNodeRef(deploymentRef: ast.DeploymentRef): ast.DeploymentNode | null {
+  let referenceable = deploymentRef.value.ref ?? null
+  if (!referenceable || ast.isDeploymentNode(referenceable)) {
+    return referenceable
+  }
+  const artifact = instanceRef(deploymentRef)
+  // Because path in deploymentRef may be omitted,
+  // we find artifact first and then its container
+  return artifact ? AstUtils.getContainerOfType(artifact, ast.isDeploymentNode) ?? null : null
+}

package/src/{elementRef.ts → utils/elementRef.ts}

@@ -1,5 +1,5 @@
 import type * as c4 from '@likec4/core'
-import type { ast } from './ast'
+import type { ast } from '../ast'
 /**
  * Returns referenced AST Element
  */

package/src/utils/stringHash.ts

@@ -1,6 +1,6 @@
-import hash from 'string-hash'
+import { stringHash as hash } from '@likec4/core'
 
 export function stringHash(...str: [string, ...string[]]): string {
   var s = str.length > 1 ? str.join(':::') : str[0]
-  return hash(s).toString(36)
+  return hash(s)
 }