@likec4/language-server 1.21.1 → 1.22.0

package/src/model/parser/DeploymentViewParser.ts

@@ -1,122 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
-import { isNonNullish } from 'remeda'
-import { type ParsedAstDeploymentView, ast, toAutoLayout, toElementStyle, ViewOps } from '../../ast'
-import { logWarnError } from '../../logger'
-import { stringHash } from '../../utils'
-import { parseViewManualLayout } from '../../view-utils/manual-layout'
-import { removeIndent, toSingleLine } from './Base'
-import type { WithDeploymentModel } from './DeploymentModelParser'
-import type { WithExpressionV2 } from './FqnRefParser'
-
-export type WithDeploymentView = ReturnType<typeof DeploymentViewParser>
-
-export function DeploymentViewParser<TBase extends WithExpressionV2 & WithDeploymentModel>(B: TBase) {
-  return class DeploymentViewParser extends B {
-    parseDeploymentView(
-      astNode: ast.DeploymentView,
-    ): ParsedAstDeploymentView {
-      const body = astNode.body
-      invariant(body, 'DynamicElementView body is not defined')
-      // only valid props
-      const props = body.props.filter(this.isValid)
-      const astPath = this.getAstNodePath(astNode)
-
-      let id = astNode.name
-      if (!id) {
-        id = 'deployment_' + stringHash(
-          this.doc.uri.toString(),
-          astPath,
-        ) as c4.ViewId
-      }
-
-      const title = toSingleLine(props.find(p => p.key === 'title')?.value) ?? null
-      const description = removeIndent(props.find(p => p.key === 'description')?.value) ?? null
-
-      const tags = this.convertTags(body)
-      const links = this.convertLinks(body)
-
-      ViewOps.writeId(astNode, id as c4.ViewId)
-
-      const manualLayout = parseViewManualLayout(astNode)
-
-      return {
-        __: 'deployment',
-        id: id as c4.ViewId,
-        astPath,
-        title,
-        description,
-        tags,
-        links: isNonEmptyArray(links) ? links : null,
-        rules: body.rules.flatMap(n => {
-          try {
-            return this.isValid(n) ? this.parseDeploymentViewRule(n) : []
-          } catch (e) {
-            logWarnError(e)
-            return []
-          }
-        }),
-        ...(manualLayout && { manualLayout }),
-      }
-    }
-
-    parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule {
-      if (ast.isDeploymentViewRulePredicate(astRule)) {
-        return this.parseDeploymentViewRulePredicate(astRule)
-      }
-      if (ast.isViewRuleAutoLayout(astRule)) {
-        return toAutoLayout(astRule)
-      }
-      if (ast.isDeploymentViewRuleStyle(astRule)) {
-        return this.parseDeploymentViewRuleStyle(astRule)
-      }
-      nonexhaustive(astRule)
-    }
-
-    parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate {
-      const exprs = [] as c4.ExpressionV2[]
-      let iterator: ast.DeploymentViewRulePredicateExpression | undefined = astRule.expr
-      while (iterator) {
-        try {
-          const expr = iterator.value
-          if (isNonNullish(expr) && this.isValid(expr)) {
-            switch (true) {
-              case ast.isFqnExpr(expr):
-                exprs.unshift(this.parseFqnExpr(expr))
-                break
-              case ast.isElementPredicateWhereV2(expr):
-                exprs.unshift(this.parseElementWhereExpr(expr))
-                break
-              case ast.isRelationExpr(expr):
-                exprs.unshift(this.parseRelationExpr(expr))
-                break
-              case ast.isRelationPredicateWhereV2(expr):
-                exprs.unshift(this.parseRelationWhereExpr(expr))
-                break
-              default:
-                nonexhaustive(expr)
-            }
-          }
-        } catch (e) {
-          logWarnError(e)
-        }
-        iterator = iterator.prev
-      }
-      return astRule.isInclude ? { include: exprs } : { exclude: exprs }
-    }
-
-    parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle {
-      const styleProps = astRule.props.filter(ast.isStyleProperty)
-      const notationProperty = astRule.props.find(ast.isNotationProperty)
-      const notation = removeIndent(notationProperty?.value)
-      const targets = this.parseFqnExpressions(astRule.targets)
-      return {
-        targets,
-        ...(notation && { notation }),
-        style: {
-          ...toElementStyle(styleProps, this.isValid),
-        },
-      }
-    }
-  }
-}

package/src/model/parser/FqnRefParser.ts

@@ -1,143 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { nonexhaustive, nonNullable } from '@likec4/core'
-import { isNonNullish } from 'remeda'
-import { ast } from '../../ast'
-import { logWarnError } from '../../logger'
-import { instanceRef } from '../../utils/fqnRef'
-import { parseWhereClause } from '../model-parser-where'
-import type { Base } from './Base'
-
-export type WithExpressionV2 = ReturnType<typeof ExpressionV2Parser>
-
-export function ExpressionV2Parser<TBase extends Base>(B: TBase) {
-  return class ExpressionV2Parser extends B {
-    parseFqnRef(astNode: ast.FqnRef): c4.FqnRef {
-      const refValue = nonNullable(
-        astNode.value.ref,
-        `FqnRef is empty ${astNode.$cstNode?.range.start.line}:${astNode.$cstNode?.range.start.character}`,
-      )
-      if (ast.isElement(refValue)) {
-        const deployedInstanceAst = instanceRef(astNode)
-        if (!deployedInstanceAst) {
-          return {
-            model: this.resolveFqn(refValue),
-          }
-        }
-        const deployment = this.resolveFqn(deployedInstanceAst)
-        const element = this.resolveFqn(refValue)
-        return {
-          deployment,
-          element,
-        }
-      }
-
-      if (ast.isDeploymentElement(refValue)) {
-        return {
-          deployment: this.resolveFqn(refValue),
-        }
-      }
-      nonexhaustive(refValue)
-    }
-
-    parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr {
-      if (ast.isWildcardExpression(astNode)) {
-        return {
-          wildcard: true,
-        }
-      }
-      if (ast.isFqnRefExpr(astNode)) {
-        return this.parseFqnRefExpr(astNode)
-      }
-      nonexhaustive(astNode)
-    }
-
-    parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard {
-      const ref = this.parseFqnRef(astNode.ref)
-      switch (true) {
-        case astNode.selector === '._':
-          return {
-            ref,
-            selector: 'expanded',
-          } as c4.FqnExpr.NonWildcard
-        case astNode.selector === '.**':
-          return {
-            ref,
-            selector: 'descendants',
-          } as c4.FqnExpr.NonWildcard
-        case astNode.selector === '.*':
-          return {
-            ref,
-            selector: 'children',
-          } as c4.FqnExpr.NonWildcard
-        default:
-          return { ref } as c4.FqnExpr.NonWildcard
-      }
-    }
-
-    parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr {
-      return {
-        where: {
-          expr: this.parseFqnExpr(astNode.subject as ast.FqnExpr),
-          condition: astNode.where ? parseWhereClause(astNode.where) : {
-            kind: { neq: '--always-true--' },
-          },
-        },
-      }
-    }
-
-    parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[] {
-      const exprs = [] as c4.FqnExpr[]
-      let iter: ast.FqnExpressions['prev'] = astNode
-      while (iter) {
-        try {
-          if (isNonNullish(iter.value) && this.isValid(iter.value)) {
-            exprs.push(this.parseFqnExpr(iter.value))
-          }
-        } catch (e) {
-          logWarnError(e)
-        }
-        iter = iter.prev
-      }
-      return exprs.reverse()
-    }
-
-    parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr {
-      return {
-        where: {
-          expr: this.parseRelationExpr(astNode.subject as ast.RelationExpr),
-          condition: astNode.where ? parseWhereClause(astNode.where) : {
-            kind: { neq: '--always-true--' },
-          },
-        },
-      }
-    }
-
-    parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr {
-      if (ast.isRelationPredicateWhere(astNode)) {
-      }
-      if (ast.isDirectedRelationExpr(astNode)) {
-        return {
-          source: this.parseFqnExpr(astNode.source.from),
-          target: this.parseFqnExpr(astNode.target),
-          isBidirectional: astNode.source.isBidirectional,
-        }
-      }
-      if (ast.isInOutRelationExpr(astNode)) {
-        return {
-          inout: this.parseFqnExpr(astNode.inout.to),
-        }
-      }
-      if (ast.isOutgoingRelationExpr(astNode)) {
-        return {
-          outgoing: this.parseFqnExpr(astNode.from),
-        }
-      }
-      if (ast.isIncomingRelationExpr(astNode)) {
-        return {
-          incoming: this.parseFqnExpr(astNode.to),
-        }
-      }
-      nonexhaustive(astNode)
-    }
-  }
-}

package/src/model/parser/GlobalsParser.ts

@@ -1,96 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { nonexhaustive } from '@likec4/core'
-import { isTruthy } from 'remeda'
-import { ast, type ParsedAstGlobals } from '../../ast'
-import { logger, logWarnError } from '../../logger'
-import type { WithViewsParser } from './ViewsParser'
-
-export function GlobalsParser<TBase extends WithViewsParser>(B: TBase) {
-  return class GlobalsParser extends B {
-    parseGlobals() {
-      const { parseResult, c4Globals } = this.doc
-      const isValid = this.isValid
-
-      const globals = parseResult.value.globals.filter(isValid)
-
-      const elRelPredicates = globals.flatMap(r => r.predicates.filter(isValid))
-      for (const predicate of elRelPredicates) {
-        try {
-          const globalPredicateId = predicate.name as c4.GlobalPredicateId
-          if (!isTruthy(globalPredicateId)) {
-            continue
-          }
-          if (globalPredicateId in c4Globals.predicates) {
-            logger.warn(`Global predicate named "${globalPredicateId}" is already defined`)
-            continue
-          }
-
-          this.parseAndStoreGlobalPredicateGroupOrDynamic(predicate, globalPredicateId, c4Globals)
-        } catch (e) {
-          logWarnError(e)
-        }
-      }
-
-      const styles = globals.flatMap(r => r.styles.filter(isValid))
-      for (const style of styles) {
-        try {
-          const globalStyleId = style.id.name as c4.GlobalStyleID
-          if (!isTruthy(globalStyleId)) {
-            continue
-          }
-          if (globalStyleId in c4Globals.styles) {
-            logger.warn(`Global style named "${globalStyleId}" is already defined`)
-            continue
-          }
-
-          const styles = this.parseGlobalStyleOrGroup(style)
-          if (styles.length > 0) {
-            c4Globals.styles[globalStyleId] = styles as c4.NonEmptyArray<c4.ViewRuleStyle>
-          }
-        } catch (e) {
-          logWarnError(e)
-        }
-      }
-    }
-
-    parseAndStoreGlobalPredicateGroupOrDynamic(
-      astRule: ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup,
-      id: c4.GlobalPredicateId,
-      c4Globals: ParsedAstGlobals
-    ) {
-      if (ast.isGlobalPredicateGroup(astRule)) {
-        const predicates = this.parseGlobalPredicateGroup(astRule)
-        if (predicates.length > 0) {
-          c4Globals.predicates[id] = predicates as c4.NonEmptyArray<c4.ViewRulePredicate>
-        }
-        return
-      }
-      if (ast.isGlobalDynamicPredicateGroup(astRule)) {
-        const predicates = this.parseGlobalDynamicPredicateGroup(astRule)
-        if (predicates.length > 0) {
-          c4Globals.dynamicPredicates[id] = predicates as c4.NonEmptyArray<c4.DynamicViewIncludeRule>
-        }
-        return
-      }
-      nonexhaustive(astRule)
-    }
-
-    parseGlobalPredicateGroup(astRule: ast.GlobalPredicateGroup): c4.ViewRulePredicate[] {
-      return astRule.predicates.map(p => this.parseViewRulePredicate(p))
-    }
-
-    parseGlobalDynamicPredicateGroup(astRule: ast.GlobalDynamicPredicateGroup): c4.DynamicViewIncludeRule[] {
-      return astRule.predicates.map(p => this.parseDynamicViewIncludePredicate(p))
-    }
-
-    parseGlobalStyleOrGroup(astRule: ast.GlobalStyle | ast.GlobalStyleGroup): c4.ViewRuleStyle[] {
-      if (ast.isGlobalStyle(astRule)) {
-        return [this.parseViewRuleStyle(astRule)]
-      }
-      if (ast.isGlobalStyleGroup(astRule)) {
-        return astRule.styles.map(s => this.parseViewRuleStyle(s))
-      }
-      nonexhaustive(astRule)
-    }
-  }
-}

package/src/model/parser/ModelParser.ts

@@ -1,170 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { isNonEmptyArray, nonexhaustive, nonNullable } from '@likec4/core'
-import { filter, first, isEmpty, isNonNullish, isTruthy, map, mapToObj, pipe } from 'remeda'
-import {
-  type ParsedAstElement,
-  type ParsedAstExtendElement,
-  type ParsedAstRelation,
-  ast,
-  resolveRelationPoints,
-  streamModel,
-  toElementStyle,
-  toRelationshipStyleExcludeDefaults,
-} from '../../ast'
-import { logWarnError } from '../../logger'
-import { stringHash } from '../../utils/stringHash'
-import { type Base, removeIndent, toSingleLine } from './Base'
-
-export type WithModel = ReturnType<typeof ModelParser>
-
-export function ModelParser<TBase extends Base>(B: TBase) {
-  return class ModelParser extends B {
-    parseModel() {
-      const doc = this.doc
-      for (const el of streamModel(doc)) {
-        try {
-          if (ast.isElement(el)) {
-            doc.c4Elements.push(this.parseElement(el))
-            continue
-          }
-          if (ast.isRelation(el)) {
-            if (this.isValid(el)) {
-              doc.c4Relations.push(this.parseRelation(el))
-            }
-            continue
-          }
-          if (ast.isExtendElement(el)) {
-            const parsed = this.parseExtendElement(el)
-            if (parsed) {
-              doc.c4ExtendElements.push(parsed)
-            }
-            continue
-          }
-          nonexhaustive(el)
-        } catch (e) {
-          logWarnError(e)
-        }
-      }
-    }
-
-    parseElement(astNode: ast.Element): ParsedAstElement {
-      const isValid = this.isValid
-      const id = this.resolveFqn(astNode)
-      const kind = nonNullable(astNode.kind.ref, 'Element kind is not resolved').name as c4.ElementKind
-      const tags = this.parseTags(astNode.body)
-      const stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props
-      const style = toElementStyle(stylePropsAst, isValid)
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty))
-      const astPath = this.getAstNodePath(astNode)
-
-      let [title, description, technology] = astNode.props ?? []
-
-      const bodyProps = pipe(
-        astNode.body?.props ?? [],
-        filter(isValid),
-        filter(ast.isElementStringProperty),
-        mapToObj(p => [p.key, p.value || undefined]),
-      )
-
-      title = removeIndent(title ?? bodyProps.title)
-      description = removeIndent(bodyProps.description ?? description)
-      technology = toSingleLine(bodyProps.technology ?? technology)
-
-      const links = this.parseLinks(astNode.body)
-
-      // Property has higher priority than from style
-      const iconProp = astNode.body?.props.find(ast.isIconProperty)
-      if (iconProp && isValid(iconProp)) {
-        const value = iconProp.libicon?.ref?.name ?? iconProp.value
-        if (isTruthy(value)) {
-          style.icon = value as c4.IconUrl
-        }
-      }
-
-      return {
-        id,
-        kind,
-        astPath,
-        title: title ?? astNode.name,
-        ...(metadata && { metadata }),
-        ...(tags && { tags }),
-        ...(links && isNonEmptyArray(links) && { links }),
-        ...(isTruthy(technology) && { technology }),
-        ...(isTruthy(description) && { description }),
-        style,
-      }
-    }
-
-    parseExtendElement(astNode: ast.ExtendElement): ParsedAstExtendElement | null {
-      const isValid = this.isValid
-      const id = this.resolveFqn(astNode)
-      const tags = this.parseTags(astNode.body)
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty))
-      const astPath = this.getAstNodePath(astNode)
-      const links = this.parseLinks(astNode.body) ?? []
-
-      if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
-        return null
-      }
-
-      return {
-        id,
-        astPath,
-        ...(metadata && { metadata }),
-        ...(tags && { tags }),
-        ...(links && isNonEmptyArray(links) && { links }),
-      }
-    }
-
-    parseRelation(astNode: ast.Relation): ParsedAstRelation {
-      const isValid = this.isValid
-      const coupling = resolveRelationPoints(astNode)
-      const target = this.resolveFqn(coupling.target)
-      const source = this.resolveFqn(coupling.source)
-      const tags = this.parseTags(astNode) ?? this.parseTags(astNode.body)
-      const links = this.parseLinks(astNode.body)
-      const kind = astNode.kind?.ref?.name as (c4.RelationshipKind | undefined)
-      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty))
-      const astPath = this.getAstNodePath(astNode)
-
-      const bodyProps = mapToObj(
-        astNode.body?.props.filter(ast.isRelationStringProperty).filter(p => isNonNullish(p.value)) ?? [],
-        p => [p.key, p.value],
-      )
-
-      const navigateTo = pipe(
-        astNode.body?.props ?? [],
-        filter(ast.isRelationNavigateToProperty),
-        map(p => p.value.view.ref?.name),
-        filter(isTruthy),
-        first(),
-      )
-
-      const title = removeIndent(astNode.title ?? bodyProps.title) ?? ''
-      const description = removeIndent(bodyProps.description)
-      const technology = toSingleLine(astNode.technology) ?? removeIndent(bodyProps.technology)
-
-      const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty)
-      const id = stringHash(
-        astPath,
-        source,
-        target,
-      ) as c4.RelationId
-      return {
-        id,
-        astPath,
-        source,
-        target,
-        title,
-        ...(metadata && { metadata }),
-        ...(isTruthy(technology) && { technology }),
-        ...(isTruthy(description) && { description }),
-        ...(kind && { kind }),
-        ...(tags && { tags }),
-        ...(isNonEmptyArray(links) && { links }),
-        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid),
-        ...(navigateTo && { navigateTo: navigateTo as c4.ViewId }),
-      }
-    }
-  }
-}