@likec4/language-server 1.17.0 → 1.18.0

package/src/model-graph/dynamic-view/compute.ts

@@ -1,281 +0,0 @@
-import type {
-  Color,
-  ComputedDynamicView,
-  ComputedEdge,
-  DynamicView,
-  DynamicViewStep,
-  Element,
-  NonEmptyArray,
-  RelationID,
-  RelationshipArrowType,
-  RelationshipLineType,
-  Tag,
-  ViewID
-} from '@likec4/core'
-import {
-  ancestorsFqn,
-  commonAncestor,
-  DefaultArrowType,
-  DefaultLineStyle,
-  DefaultRelationshipColor,
-  isDynamicViewIncludeRule,
-  isDynamicViewParallelSteps,
-  isViewRuleAutoLayout,
-  nonNullable,
-  parentFqn,
-  StepEdgeId
-} from '@likec4/core'
-import { filter, flatMap, hasAtLeast, isTruthy, map, omit, only, pipe, unique } from 'remeda'
-import { resolveGlobalRulesInDynamicView } from '../../view-utils/resolve-global-rules'
-import { calcViewLayoutHash } from '../../view-utils/view-hash'
-import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
-import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
-import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
-import { buildComputeNodes } from '../utils/buildComputeNodes'
-import { buildElementNotations } from '../utils/buildElementNotations'
-import { elementExprToPredicate } from '../utils/elementExpressionToPredicate'
-
-export namespace DynamicViewComputeCtx {
-  export interface Step {
-    id: StepEdgeId
-    source: Element
-    target: Element
-    title: string | null
-    description?: string
-    technology?: string
-    color?: Color
-    line?: RelationshipLineType
-    head?: RelationshipArrowType
-    tail?: RelationshipArrowType
-    relations: RelationID[]
-    isBackward: boolean
-    navigateTo?: ViewID
-    tags?: NonEmptyArray<Tag>
-  }
-}
-
-export class DynamicViewComputeCtx {
-  // Intermediate state
-  private explicits = new Set<Element>()
-  private steps = [] as DynamicViewComputeCtx.Step[]
-
-  public static compute(view: DynamicView, graph: LikeC4ModelGraph): ComputedDynamicView {
-    return new DynamicViewComputeCtx(view, graph).compute()
-  }
-
-  private constructor(
-    protected view: DynamicView,
-    protected graph: LikeC4ModelGraph
-  ) {}
-
-  private addStep(
-    {
-      source: stepSource,
-      target: stepTarget,
-      title: stepTitle,
-      isBackward,
-      navigateTo: stepNavigateTo,
-      ...step
-    }: DynamicViewStep,
-    index: number,
-    parent?: number
-  ) {
-    const id = parent ? StepEdgeId(parent, index) : StepEdgeId(index)
-    const source = this.graph.element(stepSource)
-    const target = this.graph.element(stepTarget)
-
-    this.explicits.add(source)
-    this.explicits.add(target)
-
-    const {
-      title,
-      relations,
-      tags,
-      navigateTo: derivedNavigateTo
-    } = this.findRelations(source, target)
-
-    const navigateTo = isTruthy(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo
-
-    this.steps.push({
-      id,
-      ...step,
-      source,
-      target,
-      title: stepTitle ?? title,
-      relations: relations ?? [],
-      isBackward: isBackward ?? false,
-      ...(navigateTo ? { navigateTo } : {}),
-      ...(tags ? { tags } : {})
-    })
-  }
-
-  protected compute(): ComputedDynamicView {
-    const {
-      docUri: _docUri, // exclude docUri
-      rules: _rules, // exclude rules
-      steps: viewSteps,
-      ...view
-    } = this.view
-
-    let stepNum = 1
-    for (const step of viewSteps) {
-      if (isDynamicViewParallelSteps(step)) {
-        if (step.__parallel.length === 0) {
-          continue
-        }
-        if (step.__parallel.length === 1) {
-          this.addStep(step.__parallel[0]!, stepNum)
-        } else {
-          step.__parallel.forEach((s, i) => this.addStep(s, i + 1, stepNum))
-        }
-      } else {
-        this.addStep(step, stepNum)
-      }
-      stepNum++
-    }
-
-    const rules = resolveGlobalRulesInDynamicView(this.view, this.graph.globals)
-
-    for (const rule of rules) {
-      if (isDynamicViewIncludeRule(rule)) {
-        for (const expr of rule.include) {
-          const predicate = elementExprToPredicate(expr)
-          this.graph.elements.filter(predicate).forEach(e => this.explicits.add(e))
-        }
-      }
-    }
-
-    const elements = [...this.explicits]
-    const nodesMap = buildComputeNodes(elements)
-
-    const edges = this.steps.map(({ source, target, relations, title, isBackward, ...step }) => {
-      const sourceNode = nonNullable(nodesMap.get(source.id), `Source node ${source.id} not found`)
-      const targetNode = nonNullable(nodesMap.get(target.id), `Target node ${target.id} not found`)
-      const edge: ComputedEdge = {
-        parent: commonAncestor(source.id, target.id),
-        source: source.id,
-        target: target.id,
-        label: title,
-        relations,
-        color: DefaultRelationshipColor,
-        line: DefaultLineStyle,
-        head: DefaultArrowType,
-        ...step
-      }
-      if (isBackward) {
-        edge.dir = 'back'
-      }
-
-      while (edge.parent && !nodesMap.has(edge.parent)) {
-        edge.parent = parentFqn(edge.parent)
-      }
-      sourceNode.outEdges.push(edge.id)
-      targetNode.inEdges.push(edge.id)
-      // Process edge source ancestors
-      for (const sourceAncestor of ancestorsFqn(edge.source)) {
-        if (sourceAncestor === edge.parent) {
-          break
-        }
-        nodesMap.get(sourceAncestor)?.outEdges.push(edge.id)
-      }
-      // Process target hierarchy
-      for (const targetAncestor of ancestorsFqn(edge.target)) {
-        if (targetAncestor === edge.parent) {
-          break
-        }
-        nodesMap.get(targetAncestor)?.inEdges.push(edge.id)
-      }
-      return edge
-    })
-
-    const nodes = applyCustomElementProperties(
-      rules,
-      applyViewRuleStyles(
-        rules,
-        // Keep order of elements
-        elements.map(e => nonNullable(nodesMap.get(e.id)))
-      )
-    )
-
-    const autoLayoutRule = rules.findLast(isViewRuleAutoLayout)
-
-    const elementNotations = buildElementNotations(nodes)
-
-    return calcViewLayoutHash({
-      ...view,
-      autoLayout: {
-        direction: autoLayoutRule?.direction ?? 'LR',
-        ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
-        ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep })
-      },
-      nodes: map(nodes, n => {
-        // omit notation
-        delete n.notation
-        if (n.icon === 'none') {
-          delete n.icon
-        }
-        return n
-      }),
-      edges,
-      ...(elementNotations.length > 0 && {
-        notation: {
-          elements: elementNotations
-        }
-      })
-    })
-  }
-
-  private findRelations(source: Element, target: Element): {
-    title: string | null
-    tags: NonEmptyArray<Tag> | null
-    relations: NonEmptyArray<RelationID> | null
-    navigateTo: ViewID | null
-  } {
-    const relationships = unique(this.graph.edgesBetween(source, target).flatMap(e => e.relations))
-    if (relationships.length === 0) {
-      return {
-        title: null,
-        tags: null,
-        relations: null,
-        navigateTo: null
-      }
-    }
-    const alltags = pipe(
-      relationships,
-      flatMap(r => r.tags),
-      filter(isTruthy),
-      unique()
-    )
-    const tags = hasAtLeast(alltags, 1) ? alltags : null
-    const relations = hasAtLeast(relationships, 1) ? map(relationships, r => r.id) : null
-
-    // Most closest relation
-    const relation = only(relationships) || relationships.find(r => r.source === source.id && r.target === target.id)
-
-    // This edge represents mutliple relations
-    // We use label if only it is the same for all relations
-    const title = isTruthy(relation?.title) ? relation.title : pipe(
-      relationships,
-      map(r => r.title),
-      filter(isTruthy),
-      unique(),
-      only()
-    )
-
-    const navigateTo = !!relation?.navigateTo && relation.navigateTo !== this.view.id ? relation.navigateTo : pipe(
-      relationships,
-      map(r => r.navigateTo),
-      filter(isTruthy),
-      filter(v => v !== this.view.id),
-      unique(),
-      only()
-    )
-
-    return {
-      title: title ?? null,
-      tags,
-      relations,
-      navigateTo: navigateTo ?? null
-    }
-  }
-}

package/src/model-graph/dynamic-view/index.ts

@@ -1,29 +0,0 @@
-import { type ComputedDynamicView, type DynamicView } from '@likec4/core'
-import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
-import { DynamicViewComputeCtx } from './compute'
-
-type ComputeViewResult =
-  | {
-    isSuccess: true
-    view: ComputedDynamicView
-  }
-  | {
-    isSuccess: false
-    error: Error
-    view: undefined
-  }
-
-export function computeDynamicView(view: DynamicView, graph: LikeC4ModelGraph): ComputeViewResult {
-  try {
-    return {
-      isSuccess: true,
-      view: DynamicViewComputeCtx.compute(view, graph)
-    }
-  } catch (e) {
-    return {
-      isSuccess: false,
-      error: e instanceof Error ? e : new Error(`Unknown error: ${e}`),
-      view: undefined
-    }
-  }
-}

package/src/model-graph/index.ts

@@ -1,3 +0,0 @@
-export * from './compute-view'
-export * from './dynamic-view'
-export * from './LikeC4ModelGraph'

package/src/model-graph/utils/applyCustomElementProperties.ts

@@ -1,65 +0,0 @@
-import { ComputedNode, Expr, type Expression, isViewRuleGroup, isViewRulePredicate, type ViewRule } from '@likec4/core'
-import { isEmpty, isNullish, omitBy } from 'remeda'
-import { elementExprToPredicate } from './elementExpressionToPredicate'
-
-export function flattenGroupRules<T extends Expression>(guard: (expr: Expression) => expr is T) {
-  return (rule: ViewRule): Array<T> => {
-    if (isViewRuleGroup(rule)) {
-      return rule.groupRules.flatMap(flattenGroupRules(guard))
-    }
-    if (isViewRulePredicate(rule)) {
-      return 'include' in rule ? rule.include.filter(guard) : []
-    }
-
-    return []
-  }
-}
-
-export function applyCustomElementProperties(_rules: ViewRule[], _nodes: ComputedNode[]) {
-  const rules = _rules.flatMap(flattenGroupRules(Expr.isCustomElement))
-  if (rules.length === 0) {
-    return _nodes
-  }
-  const nodes = [..._nodes]
-  for (
-    const {
-      custom: { expr, ...props }
-    } of rules
-  ) {
-    const { border, opacity, ...rest } = omitBy(props, isNullish)
-    const notEmpty = !isEmpty(rest)
-    const satisfies = elementExprToPredicate(expr)
-    nodes.forEach((node, i) => {
-      if (ComputedNode.isNodesGroup(node) || !satisfies(node)) {
-        return
-      }
-      if (notEmpty) {
-        node = {
-          ...node,
-          isCustomized: true,
-          ...rest
-        }
-      }
-
-      let styleOverride: ComputedNode['style'] | undefined
-      if (border !== undefined) {
-        styleOverride = { border }
-      }
-      if (opacity !== undefined) {
-        styleOverride = { ...styleOverride, opacity }
-      }
-      if (styleOverride) {
-        node = {
-          ...node,
-          isCustomized: true,
-          style: {
-            ...node.style,
-            ...styleOverride
-          }
-        }
-      }
-      nodes[i] = node
-    })
-  }
-  return nodes
-}

package/src/model-graph/utils/applyCustomRelationProperties.ts

@@ -1,41 +0,0 @@
-import type { ComputedEdge, ComputedNode, ViewRule } from '@likec4/core'
-import { Expr } from '@likec4/core'
-import { isNullish, omitBy, pick } from 'remeda'
-import { flattenGroupRules } from './applyCustomElementProperties'
-import { relationExpressionToPredicates } from './relationExpressionToPredicates'
-
-export function applyCustomRelationProperties(
-  _rules: ViewRule[],
-  nodes: ComputedNode[],
-  _edges: Iterable<ComputedEdge>
-): ComputedEdge[] {
-  const rules = _rules.flatMap(flattenGroupRules(Expr.isCustomRelationExpr))
-  const edges = Array.from(_edges)
-  if (rules.length === 0 || edges.length === 0) {
-    return edges
-  }
-  for (
-    const {
-      customRelation: { relation, title, ...customprops }
-    } of rules
-  ) {
-    const props = omitBy(customprops, isNullish)
-    const satisfies = relationExpressionToPredicates(relation)
-    edges.forEach((edge, i) => {
-      const source = nodes.find(n => n.id === edge.source)
-      const target = nodes.find(n => n.id === edge.target)
-      if (!source || !target) {
-        return
-      }
-      if (satisfies({ source, target, ...pick(edge, ['kind', 'tags']) })) {
-        edges[i] = {
-          ...edge,
-          ...props,
-          label: title ?? edge.label,
-          isCustomized: true
-        }
-      }
-    })
-  }
-  return edges
-}

package/src/model-graph/utils/applyViewRuleStyles.ts

@@ -1,49 +0,0 @@
-import { ComputedNode, type ViewRule } from '@likec4/core'
-import { Expr, isViewRuleStyle } from '@likec4/core'
-import { anyPass, filter, forEach, isDefined, isNot, pipe } from 'remeda'
-import { elementExprToPredicate } from './elementExpressionToPredicate'
-
-type Predicate<T> = (x: T) => boolean
-
-export function applyViewRuleStyles(_rules: ViewRule[], nodes: ComputedNode[]) {
-  const rules = _rules.filter(isViewRuleStyle)
-  if (rules.length === 0) {
-    return nodes
-  }
-  for (const rule of rules) {
-    const predicates = [] as Predicate<ComputedNode>[]
-    for (const target of rule.targets) {
-      predicates.push(elementExprToPredicate(target) as Predicate<ComputedNode>)
-    }
-    pipe(
-      nodes,
-      filter(isNot(ComputedNode.isNodesGroup)),
-      filter(anyPass(predicates)),
-      forEach(n => {
-        n.shape = rule.style.shape ?? n.shape
-        n.color = rule.style.color ?? n.color
-        if (isDefined(rule.style.icon)) {
-          n.icon = rule.style.icon
-        }
-        if (isDefined(rule.notation)) {
-          n.notation = rule.notation
-        }
-        let styleOverride: ComputedNode['style'] | undefined
-        if (isDefined(rule.style.border)) {
-          styleOverride = { border: rule.style.border }
-        }
-        if (isDefined(rule.style.opacity)) {
-          styleOverride = { ...styleOverride, opacity: rule.style.opacity }
-        }
-        if (styleOverride) {
-          n.style = {
-            ...n.style,
-            ...styleOverride
-          }
-        }
-      })
-    )
-  }
-
-  return nodes
-}

package/src/model-graph/utils/buildComputeNodes.ts

@@ -1,113 +0,0 @@
-import type { ComputedNode, Element, Fqn, NodeId } from '@likec4/core'
-import {
-  compareByFqnHierarchically,
-  DefaultElementShape,
-  DefaultThemeColor,
-  ElementKind,
-  nonNullable,
-  parentFqn
-} from '@likec4/core'
-import { NodesGroup } from '../compute-view/compute'
-
-function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<Fqn, ComputedNode>) {
-  let parentNd
-  while (!!node.parent && (parentNd = nodes.get(node.parent))) {
-    const depth = parentNd.depth ?? 1
-    parentNd.depth = Math.max(depth, (node.depth ?? 0) + 1)
-    if (parentNd.depth === depth) {
-      // stop if we didn't change depth
-      break
-    }
-    node = parentNd
-  }
-}
-
-export function buildComputeNodes(elements: Iterable<Element>, groups?: NodesGroup[]) {
-  const nodesMap = new Map<Fqn, ComputedNode>()
-
-  const elementToGroup = new Map<Fqn, NodeId>()
-
-  groups?.forEach(({ id, parent, viewRule, explicits }) => {
-    if (parent) {
-      nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id)
-    }
-    nodesMap.set(id, {
-      id,
-      parent,
-      kind: ElementKind.Group,
-      title: viewRule.title ?? '',
-      color: viewRule.color ?? 'muted',
-      shape: 'rectangle',
-      children: [],
-      inEdges: [],
-      outEdges: [],
-      level: 0,
-      depth: 0,
-      description: null,
-      technology: null,
-      tags: null,
-      links: null,
-      style: {
-        border: viewRule.border ?? 'dashed',
-        opacity: viewRule.opacity ?? 0
-      }
-    })
-    for (const e of explicits) {
-      elementToGroup.set(e.id, id)
-    }
-  })
-
-  return (
-    Array.from(elements)
-      // Sort from Top to Bottom
-      // So we can ensure that parent nodes are created before child nodes
-      .sort(compareByFqnHierarchically)
-      .reduce((map, { id, color, shape, style, kind, title, ...el }) => {
-        let parent = parentFqn(id)
-        let level = 0
-        let parentNd: ComputedNode | undefined
-        // Find the first ancestor that is already in the map
-        while (parent) {
-          parentNd = map.get(parent)
-          if (parentNd) {
-            break
-          }
-          parent = parentFqn(parent)
-        }
-        // If parent is not found in the map, check if it is in a group
-        if (!parentNd && elementToGroup.has(id)) {
-          parent = elementToGroup.get(id)!
-          parentNd = map.get(parent)!
-        }
-        if (parentNd) {
-          // if parent has no children and we are about to add first one
-          // we need to set its depth to 1
-          if (parentNd.children.length == 0) {
-            parentNd.depth = 1
-            // go up the tree and update depth of all parents
-            updateDepthOfAncestors(parentNd, map)
-          }
-          parentNd.children.push(id)
-          level = parentNd.level + 1
-        }
-        const node: ComputedNode = {
-          id,
-          parent,
-          kind,
-          title,
-          color: color ?? DefaultThemeColor,
-          shape: shape ?? DefaultElementShape,
-          children: [],
-          inEdges: [],
-          outEdges: [],
-          level,
-          ...el,
-          style: {
-            ...style
-          }
-        }
-        map.set(id, node)
-        return map
-      }, nodesMap) as ReadonlyMap<Fqn, ComputedNode>
-  )
-}

package/src/model-graph/utils/buildElementNotations.ts

@@ -1,63 +0,0 @@
-import type { ComputedNode, ElementNotation } from '@likec4/core'
-import { entries, flatMap, groupBy, map, mapValues, pipe, piped, prop, sortBy, unique } from 'remeda'
-
-/**
- * Build element notations from computed nodes:
- * 1. Group by notation
- * 2. Group by shape
- * 3. Group by color
- * 4. For each group get unique kinds
- * 5. Unwind the groups
- */
-export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[] {
-  return pipe(
-    nodes,
-    groupBy(prop('notation')),
-    mapValues(
-      piped(
-        groupBy(prop('shape')),
-        mapValues(
-          piped(
-            groupBy(prop('color')),
-            mapValues(
-              piped(
-                map(prop('kind')),
-                unique()
-              )
-            ),
-            entries(),
-            map(([color, kinds]) => ({
-              kinds,
-              color
-            }))
-          )
-        ),
-        entries(),
-        flatMap(([shape, colors]) =>
-          colors.map(({ color, kinds }) => ({
-            shape,
-            color,
-            kinds
-          }))
-        )
-      )
-    ),
-    entries(),
-    flatMap(([title, shapes]) =>
-      shapes.map(({ shape, color, kinds }) => ({
-        title,
-        shape,
-        color,
-        kinds
-      }))
-    ),
-    sortBy(
-      prop('shape'),
-      prop('title'),
-      [
-        n => n.kinds.length,
-        'desc'
-      ]
-    )
-  )
-}

package/src/model-graph/utils/elementExpressionToPredicate.ts

@@ -1,39 +0,0 @@
-import { Expr, nonexhaustive, parentFqn } from '@likec4/core'
-import { type Element, whereOperatorAsPredicate } from '@likec4/core'
-import { isNullish } from 'remeda'
-
-type Predicate<T> = (x: T) => boolean
-
-export function elementExprToPredicate<T extends Pick<Element, 'id' | 'kind' | 'tags'>>(
-  target: Expr.ElementPredicateExpression
-): Predicate<T> {
-  if (Expr.isElementWhere(target)) {
-    const predicate = elementExprToPredicate(target.where.expr)
-    const where = whereOperatorAsPredicate(target.where.condition)
-    return n => predicate(n) && where(n)
-  }
-  if (Expr.isWildcard(target)) {
-    return () => true
-  }
-  if (Expr.isElementKindExpr(target)) {
-    return target.isEqual ? n => n.kind === target.elementKind : n => n.kind !== target.elementKind
-  }
-  if (Expr.isElementTagExpr(target)) {
-    return target.isEqual
-      ? ({ tags }) => !!tags && tags.includes(target.elementTag)
-      : ({ tags }) => isNullish(tags) || !tags.includes(target.elementTag)
-  }
-  if (Expr.isExpandedElementExpr(target)) {
-    return n => n.id === target.expanded || parentFqn(n.id) === target.expanded
-  }
-  if (Expr.isElementRef(target)) {
-    const { element, isDescedants } = target
-    return isDescedants
-      ? n => n.id.startsWith(element + '.')
-      : n => (n.id as string) === element
-  }
-  if (Expr.isCustomElement(target)) {
-    return elementExprToPredicate(target.custom.expr)
-  }
-  nonexhaustive(target)
-}