@likec4/language-server 1.21.1 → 1.22.0

package/src/model/parser/ViewsParser.ts

@@ -1,428 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
-import { isArray, isDefined, isNonNullish, isTruthy } from 'remeda'
-import type { Writable } from 'type-fest'
-import {
-  ast,
-  type ParsedAstDynamicView,
-  type ParsedAstElementView,
-  toAutoLayout,
-  toColor,
-  toElementStyle,
-  ViewOps
-} from '../../ast'
-import type { NotationProperty } from '../../generated/ast'
-import { logger, logWarnError } from '../../logger'
-import { stringHash } from '../../utils'
-import { elementRef } from '../../utils/elementRef'
-import { parseViewManualLayout } from '../../view-utils/manual-layout'
-import { removeIndent, toSingleLine } from './Base'
-import type { WithDeploymentView } from './DeploymentViewParser'
-import type { WithPredicates } from './PredicatesParser'
-
-export type WithViewsParser = ReturnType<typeof ViewsParser>
-
-export function ViewsParser<TBase extends WithPredicates & WithDeploymentView>(B: TBase) {
-  return class ViewsParser extends B {
-    parseViews() {
-      const isValid = this.isValid
-      for (const viewBlock of this.doc.parseResult.value.views) {
-        const localStyles = viewBlock.styles.flatMap(s => {
-          try {
-            return isValid(s) ? this.parseViewRuleStyleOrGlobalRef(s) : []
-          } catch (e) {
-            logWarnError(e)
-            return []
-          }
-        })
-
-        for (const view of viewBlock.views) {
-          try {
-            if (!isValid(view)) {
-              continue
-            }
-            switch (true) {
-              case ast.isElementView(view):
-                this.doc.c4Views.push(this.parseElementView(view, localStyles))
-                break
-              case ast.isDynamicView(view):
-                this.doc.c4Views.push(this.parseDynamicElementView(view, localStyles))
-                break
-              case ast.isDeploymentView(view):
-                this.doc.c4Views.push(this.parseDeploymentView(view))
-                break
-              default:
-                nonexhaustive(view)
-            }
-          } catch (e) {
-            logWarnError(e)
-          }
-        }
-      }
-    }
-
-    parseElementView(astNode: ast.ElementView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): ParsedAstElementView {
-      const body = astNode.body
-      invariant(body, 'ElementView body is not defined')
-      const astPath = this.getAstNodePath(astNode)
-
-      let viewOf = null as c4.Fqn | null
-      if ('viewOf' in astNode) {
-        const viewOfEl = elementRef(astNode.viewOf)
-        const _viewOf = viewOfEl && this.resolveFqn(viewOfEl)
-        if (!_viewOf) {
-          logger.warn('viewOf is not resolved: ' + astNode.$cstNode?.text)
-        } else {
-          viewOf = _viewOf
-        }
-      }
-
-      let id = astNode.name
-      if (!id) {
-        id = 'view_' + stringHash(
-          this.doc.uri.toString(),
-          astPath,
-          viewOf ?? ''
-        ) as c4.ViewId
-      }
-
-      const title = toSingleLine(body.props.find(p => p.key === 'title')?.value) ?? null
-      const description = removeIndent(body.props.find(p => p.key === 'description')?.value) ?? null
-
-      const tags = this.convertTags(body)
-      const links = this.convertLinks(body)
-
-      const manualLayout = parseViewManualLayout(astNode)
-
-      const view: ParsedAstElementView = {
-        __: 'element',
-        id: id as c4.ViewId,
-        astPath,
-        title,
-        description,
-        tags,
-        links: isNonEmptyArray(links) ? links : null,
-        rules: [
-          ...additionalStyles,
-          ...body.rules.flatMap(n => {
-            try {
-              return this.isValid(n) ? this.parseViewRule(n) : []
-            } catch (e) {
-              logWarnError(e)
-              return []
-            }
-          })
-        ],
-        ...(viewOf && { viewOf }),
-        ...(manualLayout && { manualLayout })
-      }
-      ViewOps.writeId(astNode, view.id)
-
-      if ('extends' in astNode) {
-        const extendsView = astNode.extends.view.ref
-        invariant(extendsView?.name, 'view extends is not resolved: ' + astNode.$cstNode?.text)
-        return Object.assign(view, {
-          extends: extendsView.name as c4.ViewId
-        })
-      }
-
-      return view
-    }
-
-    parseViewRule(astRule: ast.ViewRule): c4.ViewRule {
-      if (ast.isViewRulePredicate(astRule)) {
-        return this.parseViewRulePredicate(astRule)
-      }
-      if (ast.isViewRuleGlobalPredicateRef(astRule)) {
-        return this.parseViewRuleGlobalPredicateRef(astRule)
-      }
-      if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
-        return this.parseViewRuleStyleOrGlobalRef(astRule)
-      }
-      if (ast.isViewRuleAutoLayout(astRule)) {
-        return toAutoLayout(astRule)
-      }
-      if (ast.isViewRuleGroup(astRule)) {
-        return this.parseViewRuleGroup(astRule)
-      }
-      nonexhaustive(astRule)
-    }
-
-    parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ViewRulePredicate {
-      const exprs = [] as c4.Expression[]
-      let predicate = astNode.predicates
-      while (predicate) {
-        const { value, prev } = predicate
-        try {
-          if (isTruthy(value) && this.isValid(value as any)) {
-            exprs.unshift(this.parsePredicate(value))
-          }
-        } catch (e) {
-          logWarnError(e)
-        }
-        if (!prev) {
-          break
-        }
-        predicate = prev
-      }
-      return ast.isIncludePredicate(astNode) ? { include: exprs } : { exclude: exprs }
-    }
-
-    parseViewRuleGlobalPredicateRef(
-      astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef
-    ): c4.ViewRuleGlobalPredicateRef {
-      return {
-        predicateId: astRule.predicate.$refText as c4.GlobalPredicateId
-      }
-    }
-
-    parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleStyleOrGlobalRef {
-      if (ast.isViewRuleStyle(astRule)) {
-        return this.parseViewRuleStyle(astRule)
-      }
-      if (ast.isViewRuleGlobalStyle(astRule)) {
-        return this.parseViewRuleGlobalStyle(astRule)
-      }
-      nonexhaustive(astRule)
-    }
-
-    parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ViewRuleGroup {
-      const groupRules = [] as c4.ViewRuleGroup['groupRules']
-      for (const rule of astNode.groupRules) {
-        try {
-          if (!this.isValid(rule)) {
-            continue
-          }
-          if (ast.isViewRulePredicate(rule)) {
-            groupRules.push(this.parseViewRulePredicate(rule))
-            continue
-          }
-          if (ast.isViewRuleGroup(rule)) {
-            groupRules.push(this.parseViewRuleGroup(rule))
-            continue
-          }
-          nonexhaustive(rule)
-        } catch (e) {
-          logWarnError(e)
-        }
-      }
-      return {
-        title: toSingleLine(astNode.title) ?? null,
-        groupRules,
-        ...toElementStyle(astNode.props, this.isValid)
-      }
-    }
-
-    parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ViewRuleStyle {
-      const styleProps = astRule.props.filter(ast.isStyleProperty)
-      const targets = astRule.target
-      const notation = astRule.props.find(ast.isNotationProperty)
-      return this.parseRuleStyle(styleProps, targets, notation)
-    }
-
-    parseRuleStyle(
-      styleProperties: ast.StyleProperty[],
-      elementExpressionsIterator: ast.ElementExpressionsIterator,
-      notationProperty?: NotationProperty
-    ): c4.ViewRuleStyle {
-      const styleProps = toElementStyle(styleProperties, this.isValid)
-      const notation = removeIndent(notationProperty?.value)
-      const targets = this.parseElementExpressionsIterator(elementExpressionsIterator)
-      return {
-        targets,
-        ...(notation && { notation }),
-        style: {
-          ...styleProps
-        }
-      }
-    }
-
-    parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle {
-      return {
-        styleId: astRule.style.$refText as c4.GlobalStyleID
-      }
-    }
-
-    parseDynamicElementView(
-      astNode: ast.DynamicView,
-      additionalStyles: c4.ViewRuleStyleOrGlobalRef[]
-    ): ParsedAstDynamicView {
-      const body = astNode.body
-      invariant(body, 'DynamicElementView body is not defined')
-      // only valid props
-      const isValid = this.isValid
-      const props = body.props.filter(isValid)
-      const astPath = this.getAstNodePath(astNode)
-
-      let id = astNode.name
-      if (!id) {
-        id = 'dynamic_' + 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 {
-        __: 'dynamic',
-        id: id as c4.ViewId,
-        astPath,
-        title,
-        description,
-        tags,
-        links: isNonEmptyArray(links) ? links : null,
-        rules: [
-          ...additionalStyles,
-          ...body.rules.flatMap(n => {
-            try {
-              return isValid(n) ? this.parseDynamicViewRule(n) : []
-            } catch (e) {
-              logWarnError(e)
-              return []
-            }
-          }, [] as Array<c4.DynamicViewRule>)
-        ],
-        steps: body.steps.reduce((acc, n) => {
-          try {
-            if (isValid(n)) {
-              if (ast.isDynamicViewParallelSteps(n)) {
-                acc.push(this.parseDynamicParallelSteps(n))
-              } else {
-                acc.push(this.parseDynamicStep(n))
-              }
-            }
-          } catch (e) {
-            logWarnError(e)
-          }
-          return acc
-        }, [] as c4.DynamicViewStepOrParallel[]),
-        ...(manualLayout && { manualLayout })
-      }
-    }
-
-    parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule {
-      if (ast.isDynamicViewIncludePredicate(astRule)) {
-        return this.parseDynamicViewIncludePredicate(astRule)
-      }
-      if (ast.isDynamicViewGlobalPredicateRef(astRule)) {
-        return this.parseViewRuleGlobalPredicateRef(astRule)
-      }
-      if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
-        return this.parseViewRuleStyleOrGlobalRef(astRule)
-      }
-      if (ast.isViewRuleAutoLayout(astRule)) {
-        return toAutoLayout(astRule)
-      }
-      nonexhaustive(astRule)
-    }
-
-    parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule {
-      const include = [] as c4.ElementPredicateExpression[]
-      let iter: ast.DynamicViewPredicateIterator | undefined = astRule.predicates
-      while (iter) {
-        try {
-          if (isNonNullish(iter.value) && this.isValid(iter.value as any)) {
-            const c4expr = this.parseElementPredicate(iter.value)
-            include.unshift(c4expr)
-          }
-        } catch (e) {
-          logWarnError(e)
-        }
-        iter = iter.prev
-      }
-      return { include }
-    }
-
-    parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps {
-      return {
-        __parallel: node.steps.map(step => this.parseDynamicStep(step))
-      }
-    }
-
-    parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep {
-      const sourceEl = elementRef(node.source)
-      if (!sourceEl) {
-        throw new Error('Invalid reference to source')
-      }
-      const targetEl = elementRef(node.target)
-      if (!targetEl) {
-        throw new Error('Invalid reference to target')
-      }
-      let source = this.resolveFqn(sourceEl)
-      let target = this.resolveFqn(targetEl)
-      const title = removeIndent(node.title) ?? null
-
-      let step: Writable<c4.DynamicViewStep> = {
-        source,
-        target,
-        title
-      }
-      if (node.isBackward) {
-        step = {
-          source: target,
-          target: source,
-          title,
-          isBackward: true
-        }
-      }
-      if (!isArray(node.custom?.props)) {
-        return step
-      }
-      for (const prop of node.custom.props) {
-        try {
-          switch (true) {
-            case ast.isRelationNavigateToProperty(prop): {
-              const viewId = prop.value.view.ref?.name
-              if (isTruthy(viewId)) {
-                step.navigateTo = viewId as c4.ViewId
-              }
-              break
-            }
-            case ast.isRelationStringProperty(prop):
-            case ast.isNotationProperty(prop):
-            case ast.isNotesProperty(prop): {
-              if (isDefined(prop.value)) {
-                step[prop.key] = removeIndent(prop.value) ?? ''
-              }
-              break
-            }
-            case ast.isArrowProperty(prop): {
-              if (isDefined(prop.value)) {
-                step[prop.key] = prop.value
-              }
-              break
-            }
-            case ast.isColorProperty(prop): {
-              const value = toColor(prop)
-              if (isDefined(value)) {
-                step[prop.key] = value
-              }
-              break
-            }
-            case ast.isLineProperty(prop): {
-              if (isDefined(prop.value)) {
-                step[prop.key] = prop.value
-              }
-              break
-            }
-            default:
-              nonexhaustive(prop)
-          }
-        }
-        catch (e) {
-          logWarnError(e)
-        }
-      }
-      return step
-    }
-  }
-}

package/src/model-change/ModelChanges.ts

@@ -1,101 +0,0 @@
-import { invariant, nonexhaustive } from '@likec4/core'
-import { logger } from '@likec4/log'
-import { Location, Range, TextEdit } from 'vscode-languageserver-types'
-import { type ParsedLikeC4LangiumDocument } from '../ast'
-import type { LikeC4ModelLocator } from '../model'
-import type { LikeC4Services } from '../module'
-import type { ChangeViewRequestParams } from '../protocol'
-import { changeElementStyle } from './changeElementStyle'
-import { changeViewLayout } from './changeViewLayout'
-import { saveManualLayout } from './saveManualLayout'
-
-export class LikeC4ModelChanges {
-  private locator: LikeC4ModelLocator
-
-  constructor(private services: LikeC4Services) {
-    this.locator = services.likec4.ModelLocator
-  }
-
-  public async applyChange(changeView: ChangeViewRequestParams): Promise<Location | null> {
-    const lspConnection = this.services.shared.lsp.Connection
-    invariant(lspConnection, 'LSP Connection not available')
-    let result: Location | null = null
-    try {
-      await this.services.shared.workspace.WorkspaceLock.write(async () => {
-        const { doc, edits, modifiedRange } = this.convertToTextEdit(changeView)
-        const textDocument = {
-          uri: doc.textDocument.uri,
-          version: doc.textDocument.version
-        }
-        if (!edits.length) {
-          return
-        }
-        const applyResult = await lspConnection.workspace.applyEdit({
-          label: `LikeC4 - change view ${changeView.viewId}`,
-          edit: {
-            changes: {
-              [textDocument.uri]: edits
-            }
-          }
-        })
-        if (!applyResult.applied) {
-          lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`)
-          return
-        }
-        result = {
-          uri: textDocument.uri,
-          range: modifiedRange
-        }
-      })
-    } catch (e) {
-      logger.error(`Failed to apply change ${changeView.change.op} ${changeView.viewId}`, e)
-    }
-    return result
-  }
-
-  protected convertToTextEdit({ viewId, change }: ChangeViewRequestParams): {
-    doc: ParsedLikeC4LangiumDocument
-    modifiedRange: Range
-    edits: TextEdit[]
-  } {
-    const lookup = this.locator.locateViewAst(viewId)
-    if (!lookup) {
-      throw new Error(`LikeC4ModelChanges: view not found: ${viewId}`)
-    }
-    switch (change.op) {
-      case 'change-element-style': {
-        return {
-          doc: lookup.doc,
-          ...changeElementStyle(this.services, {
-            ...lookup,
-            targets: change.targets,
-            style: change.style
-          })
-        }
-      }
-      case 'change-autolayout': {
-        const edit = changeViewLayout(this.services, {
-          ...lookup,
-          layout: change.layout
-        })
-        return {
-          doc: lookup.doc,
-          modifiedRange: edit.range,
-          edits: [edit]
-        }
-      }
-      case 'save-manual-layout':
-        const edit = saveManualLayout(this.services, {
-          ...lookup,
-          layout: change.layout
-        })
-        return {
-          doc: lookup.doc,
-          modifiedRange: edit.range,
-          edits: [edit]
-        }
-      default:
-        nonexhaustive(change)
-    }
-  }
-}

package/src/model-change/changeElementStyle.ts

@@ -1,172 +0,0 @@
-import { type Fqn, invariant, isAncestor, type NonEmptyArray, nonNullable, type ViewChange } from '@likec4/core'
-import { GrammarUtils } from 'langium'
-import { entries, filter, findLast, isTruthy, last } from 'remeda'
-import { type Range, TextEdit } from 'vscode-languageserver-types'
-import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
-import type { FqnIndex } from '../model'
-import type { LikeC4Services } from '../module'
-
-const { findNodeForKeyword, findNodeForProperty } = GrammarUtils
-
-const asViewStyleRule = (target: string, style: ViewChange.ChangeElementStyle['style'], indent = 0) => {
-  const indentStr = indent > 0 ? ' '.repeat(indent) : ''
-  return [
-    indentStr + `style ${target} {`,
-    ...entries(style).map(([key, value]) =>
-      indentStr + `  ${key} ${key === 'opacity' ? value.toString() + '%' : value}`
-    ),
-    indentStr + `}`
-  ]
-}
-
-type ChangeElementStyleArg = {
-  view: ParsedAstView
-  doc: ParsedLikeC4LangiumDocument
-  viewAst: ast.LikeC4View
-  targets: NonEmptyArray<Fqn>
-  style: ViewChange.ChangeElementStyle['style']
-}
-
-/**
- * - is ViewRuleStyle
- * - has exactly one target
- * - the target is an ElementRef to the given fqn
- */
-const isMatchingViewRule =
-  (fqn: string, index: FqnIndex) => (rule: ast.ViewRule | ast.DynamicViewRule): rule is ast.ViewRuleStyle => {
-    if (!ast.isViewRuleStyle(rule)) {
-      return false
-    }
-    const target = rule.target.value
-    if (!target || isTruthy(rule.target.prev) || !ast.isElementRef(target)) {
-      return false
-    }
-    const ref = target.el.ref
-    const _fqn = ref ? index.getFqn(ref) : null
-    return _fqn === fqn
-  }
-
-export function changeElementStyle(services: LikeC4Services, {
-  view,
-  viewAst,
-  targets,
-  style
-}: ChangeElementStyleArg): {
-  modifiedRange: Range
-  edits: TextEdit[]
-} {
-  // Should never happen
-  invariant(viewAst.body, `View ${view.id} has no body`)
-
-  const viewCstNode = viewAst.$cstNode
-  invariant(viewCstNode, 'viewCstNode')
-  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end
-    ?? viewAst.body.$cstNode?.range.end
-  invariant(insertPos, 'insertPos is not defined')
-  const indent = viewCstNode.range.start.character + 2
-  const fqnIndex = services.likec4.FqnIndex
-  const styleRules = filter(viewAst.body.rules, ast.isViewRuleStyle)
-  const viewOf = view.__ === 'element' ? view.viewOf : null
-  // Find existing rules
-  const existing = [] as Array<{ fqn: Fqn; rule: ast.ViewRuleStyle }>
-  const insert = [] as Array<{ fqn: Fqn }>
-  // const existingRules = [] as Array<{ fqn: Fqn, rule: ast.ViewRuleStyle }>
-  targets.forEach(target => {
-    const rule = findLast(styleRules, isMatchingViewRule(target, fqnIndex))
-    // remove viewOf from the target to shorten the fqn
-    const fqn = (viewOf && isAncestor(viewOf, target) ? target.substring(viewOf.length + 1) : target) as Fqn
-    if (rule) {
-      existing.push({ fqn, rule })
-    } else {
-      insert.push({ fqn })
-    }
-  })
-
-  const modifiedRange = {
-    start: insertPos,
-    end: insertPos
-  }
-
-  const includeRange = (range: Range) => {
-    if (range.start.line <= modifiedRange.start.line) {
-      if (range.start.line == modifiedRange.start.line) {
-        modifiedRange.start.character = Math.min(range.start.character, modifiedRange.start.character)
-      } else {
-        modifiedRange.start = range.start
-      }
-    }
-    if (range.end.line >= modifiedRange.end.line) {
-      if (range.end.line == modifiedRange.end.line) {
-        modifiedRange.end.character = Math.max(range.end.character, modifiedRange.end.character)
-      } else {
-        modifiedRange.end = range.end
-      }
-    }
-  }
-
-  const edits = [] as TextEdit[]
-
-  if (insert.length > 0) {
-    const linesToInsert = insert.flatMap(({ fqn }) => asViewStyleRule(fqn, style, indent))
-    edits.push(
-      TextEdit.insert(
-        insertPos,
-        '\n' + linesToInsert.join('\n')
-      )
-    )
-    modifiedRange.start = {
-      line: insertPos.line + 1,
-      character: indent
-    }
-    modifiedRange.end = {
-      line: insertPos.line + linesToInsert.length,
-      character: (last(linesToInsert)?.length ?? 0)
-    }
-  }
-
-  if (existing.length > 0) {
-    for (const { rule } of existing) {
-      const ruleCstNode = rule.$cstNode
-      invariant(ruleCstNode, 'RuleCstNode not found')
-      for (const [key, _value] of entries(style)) {
-        const value = key === 'opacity' ? _value.toString() + '%' : _value
-        const ruleProp = rule.props.find(p => p.key === key)
-        // replace existing  property
-        if (ruleProp && ruleProp.$cstNode) {
-          const { range: { start, end } } = ruleProp.$cstNode
-          includeRange({
-            start,
-            end
-          })
-          edits.push(TextEdit.replace({ start, end }, key + ' ' + value))
-          continue
-        }
-        // insert new style property right after the opening brace
-        const insertPos = findNodeForKeyword(ruleCstNode, '{')?.range.end
-        invariant(insertPos, 'Opening brace not found')
-        const indentStr = ' '.repeat(2 + ruleCstNode.range.start.character)
-        const insertKeyValue = indentStr + key + ' ' + value
-        edits.push(
-          TextEdit.insert(
-            insertPos,
-            '\n' + insertKeyValue
-          )
-        )
-        includeRange({
-          start: {
-            line: insertPos.line + 1,
-            character: indentStr.length
-          },
-          end: {
-            line: insertPos.line + 1,
-            character: insertKeyValue.length
-          }
-        })
-      }
-    }
-  }
-  return {
-    modifiedRange,
-    edits
-  }
-}