@likec4/language-server 1.17.1 → 1.19.0

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)
-}

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

@@ -1,43 +0,0 @@
-import type { Element, Relation } from '@likec4/core'
-import { Expr, nonexhaustive, whereOperatorAsPredicate } from '@likec4/core'
-import { elementExprToPredicate } from './elementExpressionToPredicate'
-
-type Predicate<T> = (x: T) => boolean
-export type FilterableEdge = Pick<Relation, 'kind' | 'tags'> & {
-  source: Element
-  target: Element
-}
-
-export function relationExpressionToPredicates<T extends FilterableEdge>(
-  expr: Expr.RelationExpression | Expr.RelationWhereExpr
-): Predicate<T> {
-  switch (true) {
-    case Expr.isRelationWhere(expr):
-      const predicate = relationExpressionToPredicates(expr.where.expr)
-      const where = whereOperatorAsPredicate(expr.where.condition)
-
-      return e => predicate(e) && where(e)
-    case Expr.isRelation(expr): {
-      const isSource = elementExprToPredicate(expr.source)
-      const isTarget = elementExprToPredicate(expr.target)
-      return edge => {
-        return (isSource(edge.source) && isTarget(edge.target))
-          || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
-      }
-    }
-    case Expr.isInOut(expr): {
-      const isInOut = elementExprToPredicate(expr.inout)
-      return edge => isInOut(edge.source) || isInOut(edge.target)
-    }
-    case Expr.isIncoming(expr): {
-      const isTarget = elementExprToPredicate(expr.incoming)
-      return edge => isTarget(edge.target)
-    }
-    case Expr.isOutgoing(expr): {
-      const isSource = elementExprToPredicate(expr.outgoing)
-      return edge => isSource(edge.source)
-    }
-    default:
-      nonexhaustive(expr)
-  }
-}

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

@@ -1,105 +0,0 @@
-import {
-  compareByFqnHierarchically,
-  compareRelations,
-  type ComputedEdge,
-  type ComputedNode,
-  type EdgeId,
-  type Fqn,
-  invariant,
-  nonNullable
-} from '@likec4/core'
-import { difference, filter, map, pipe, sort, tap } from 'remeda'
-import { Graph, postorder } from '../../utils/graphlib'
-
-// side effect
-function sortChildren(nodes: readonly ComputedNode[]) {
-  nodes.forEach(parent => {
-    if (parent.children.length > 0) {
-      parent.children = nodes.flatMap(n => (n.parent === parent.id ? n.id : []))
-    }
-  })
-}
-
-export function sortNodes({
-  nodes,
-  edges
-}: {
-  nodes: ComputedNode[]
-  edges: ComputedEdge[]
-}): ComputedNode[] {
-  if (nodes.length < 2) {
-    return nodes
-  }
-  if (edges.length === 0) {
-    return pipe(
-      nodes,
-      sort(compareByFqnHierarchically),
-      tap(sortChildren)
-    )
-  }
-
-  const g = new Graph({
-    compound: false,
-    directed: true,
-    multigraph: false
-  })
-
-  const getNode = (id: Fqn) =>
-    nonNullable(
-      nodes.find(n => n.id === id),
-      'Edge not found'
-    )
-  const getEdge = (id: EdgeId) =>
-    nonNullable(
-      edges.find(edge => edge.id === id),
-      'Edge not found'
-    )
-
-  for (const e of [...edges].sort(compareRelations)) {
-    g.setEdge(e.source, e.target)
-  }
-
-  for (const n of nodes) {
-    g.setNode(n.id, n.id)
-    if (n.children.length > 0) {
-      n.inEdges.forEach(e => {
-        const edge = getEdge(e)
-        // if this edge from leaf to the child of this node
-        if (edge.target !== n.id && getNode(edge.source).children.length === 0) {
-          // const id = `${edge.source}:${n.id}`
-          g.setEdge(edge.source, n.id)
-        }
-      })
-      // n.outEdges.forEach(e => {
-      //   const edge = getEdge(e)
-      //   if (edge.source !== n.id) {
-      //     const id = `${n.id}:${edge.target}`
-      //     g.setEdge(n.id, edge.target, undefined, id)
-      //   }
-      // })
-    }
-    if (n.parent) {
-      g.setEdge(n.parent, n.id)
-    }
-  }
-
-  let sources = g.sources() as unknown as Fqn[]
-  if (sources.length === 0) {
-    sources = pipe(
-      nodes,
-      filter(n => n.inEdges.length === 0 || n.parent === null),
-      sort(compareByFqnHierarchically),
-      map(n => n.id)
-    )
-  }
-  const orderedIds = postorder(g, sources).reverse() as Fqn[]
-  const sorted = orderedIds.map(getNode)
-  if (sorted.length < nodes.length) {
-    const unsorted = difference(nodes, sorted).sort(compareByFqnHierarchically)
-    sorted.push(...unsorted)
-  }
-
-  invariant(sorted.length === nodes.length, 'Not all nodes were processed by graphlib')
-  sortChildren(sorted)
-  return sorted
-}

package/src/model-graph/utils/uniqueTags.test.ts

@@ -1,42 +0,0 @@
-import { compareNatural } from '@likec4/core'
-import { describe, expect, it } from 'vitest'
-import { uniqueTags } from './uniqueTags'
-
-describe('uniqueTags function', () => {
-  it('returns unique tags from an array of elements', () => {
-    const input = [
-      { tags: ['tag1', 'tag2', 'tag3'] },
-      { tags: ['tag2', 'tag3', 'tag4'] },
-      { tags: ['tag3', 'tag4', 'tag5'] }
-    ] as const
-    const result = uniqueTags(input)
-    expect(result).toEqual(['tag1', 'tag2', 'tag3', 'tag4', 'tag5'])
-  })
-
-  it('should return unique tags naturally sorted', () => {
-    const input = [
-      { tags: ['tag1', 'tag20', 'tag30'] },
-      { tags: ['tag2', 'tag23', 'tag34'] },
-      { tags: ['tag3'] }
-    ] as const
-    const result = uniqueTags(input)
-    expect(result).toEqual([
-      'tag1',
-      'tag2',
-      'tag3',
-      'tag20',
-      'tag23',
-      'tag30',
-      'tag34'
-    ].sort(compareNatural))
-  })
-
-  it('returns null if the tags array is null', () => {
-    const input = [
-      { tags: null },
-      {}
-    ]
-    const result = uniqueTags(input)
-    expect(result).toBeNull()
-  })
-})

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

@@ -1,19 +0,0 @@
-import { compareNatural, hasAtLeast, type NonEmptyReadonlyArray, type Tag } from '@likec4/core'
-import { flatMap, pipe, sort, unique } from 'remeda'
-import type { LiteralUnion } from 'type-fest'
-
-/**
- * Extracts unique tags from an array of elements.
- * and sort in natural order; returns null if no tags are present.
- */
-export function uniqueTags<T extends { tags?: NonEmptyReadonlyArray<LiteralUnion<Tag, string>> | null }>(
-  elements: ReadonlyArray<T>
-) {
-  const tags = pipe(
-    elements,
-    flatMap(e => e.tags ?? []),
-    unique(),
-    sort(compareNatural)
-  )
-  return hasAtLeast(tags, 1) ? tags : null
-}

package/src/utils/graphlib.ts

@@ -1,9 +0,0 @@
-import dagre from '@dagrejs/dagre'
-
-const Graph = dagre.graphlib.Graph
-
-export { Graph }
-
-export const postorder = dagre.graphlib.alg.postorder
-export const findCycles = dagre.graphlib.alg.findCycles
-export const isAcyclic = dagre.graphlib.alg.isAcyclic

package/src/view-utils/resolve-extended-views.ts

@@ -1,66 +0,0 @@
-import { isExtendsElementView, type LikeC4View } from '@likec4/core'
-import { logger } from '@likec4/log'
-import { first, last, values } from 'remeda'
-import { findCycles, Graph, isAcyclic, postorder } from '../utils/graphlib'
-
-/**
- * Resolve rules of extended views
- * (Removes invalid views)
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
-  unresolvedViews: V
-): V {
-  const g = new Graph({
-    directed: true,
-    multigraph: false,
-    compound: false
-  })
-  for (const view of values(unresolvedViews)) {
-    g.setNode(view.id, view.id)
-    if (isExtendsElementView(view)) {
-      // view -> parent
-      g.setEdge(view.id, view.extends)
-    }
-  }
-  if (g.edgeCount() === 0) {
-    return unresolvedViews
-  }
-
-  // Remove circular dependencies
-  while (!isAcyclic(g)) {
-    const firstCycle = first(findCycles(g))
-    if (!firstCycle) {
-      break
-    }
-    const cycledNode = last(firstCycle)
-    if (!cycledNode) {
-      break
-    }
-    g.removeNode(cycledNode)
-  }
-
-  const ordered = postorder(g, g.sources() as unknown as string[])
-
-  return ordered.reduce((acc, id) => {
-    const view = unresolvedViews[id]
-    if (!view) {
-      return acc
-    }
-    if (isExtendsElementView(view)) {
-      const extendsFrom = acc[view.extends]
-      if (!extendsFrom) {
-        logger.debug(`View "${view.id}" extends from "${view.extends}" which does not exist`)
-        return acc
-      }
-      return Object.assign(acc, {
-        [view.id]: {
-          ...extendsFrom,
-          ...view,
-          rules: [...extendsFrom.rules, ...view.rules]
-        }
-      })
-    }
-    return Object.assign(acc, { [view.id]: view })
-  }, {} as V)
-}

package/src/view-utils/resolve-global-rules.ts

@@ -1,88 +0,0 @@
-import {
-  type DynamicView,
-  type DynamicViewRule,
-  type ElementView,
-  isDynamicView,
-  isElementView,
-  isViewRuleGlobalPredicateRef,
-  isViewRuleGlobalStyle,
-  type ModelGlobals,
-  nonexhaustive,
-  type ViewRule,
-  type ViewRuleGlobalPredicateRef,
-  type ViewRuleGlobalStyle
-} from '@likec4/core'
-import { logger } from '@likec4/log'
-import { isNullish } from 'remeda'
-
-export function resolveGlobalRules<V extends DynamicView | ElementView>(
-  view: V,
-  globals: ModelGlobals
-): V {
-  if (isElementView(view)) {
-    return {
-      ...view,
-      rules: resolveGlobalRulesInElementView(view, globals)
-    }
-  } else if (isDynamicView(view)) {
-    return {
-      ...view,
-      rules: resolveGlobalRulesInDynamicView(view, globals)
-    }
-  }
-  nonexhaustive(view)
-}
-
-type ViewRuleGlobal = ViewRuleGlobalPredicateRef | ViewRuleGlobalStyle
-
-export function resolveGlobalRulesInElementView(
-  view: ElementView,
-  globals: ModelGlobals
-): Array<Exclude<ViewRule, ViewRuleGlobal>> {
-  return view.rules.reduce((acc, rule) => {
-    if (isViewRuleGlobalPredicateRef(rule)) {
-      const globalPredicates = globals.predicates[rule.predicateId]
-      if (isNullish(globalPredicates)) {
-        logger.warn(`Global predicate not found: ${rule.predicateId}`)
-        return acc
-      }
-      return acc.concat(globalPredicates)
-    }
-    if (isViewRuleGlobalStyle(rule)) {
-      const globalStyles = globals.styles[rule.styleId]
-      if (isNullish(globalStyles)) {
-        logger.warn(`Global style not found: ${rule.styleId}`)
-        return acc
-      }
-      return acc.concat(globalStyles)
-    }
-    acc.push(rule)
-    return acc
-  }, [] as Array<Exclude<ViewRule, ViewRuleGlobal>>)
-}
-
-export function resolveGlobalRulesInDynamicView(
-  view: DynamicView,
-  globals: ModelGlobals
-): Array<Exclude<DynamicViewRule, ViewRuleGlobal>> {
-  return view.rules.reduce((acc, rule) => {
-    if (isViewRuleGlobalPredicateRef(rule)) {
-      const globalPredicates = globals.dynamicPredicates[rule.predicateId]
-      if (isNullish(globalPredicates)) {
-        logger.warn(`Global predicate not found: ${rule.predicateId}`)
-        return acc
-      }
-      return acc.concat(globalPredicates)
-    }
-    if (isViewRuleGlobalStyle(rule)) {
-      const globalStyles = globals.styles[rule.styleId]
-      if (isNullish(globalStyles)) {
-        logger.warn(`Global style not found: ${rule.styleId}`)
-        return acc
-      }
-      return acc.concat(globalStyles)
-    }
-    acc.push(rule)
-    return acc
-  }, [] as Array<Exclude<DynamicViewRule, ViewRuleGlobal>>)
-}

package/src/view-utils/view-hash.ts

@@ -1,27 +0,0 @@
-import type { ComputedView } from '@likec4/core'
-import objectHash from 'object-hash'
-import { isTruthy, map, mapToObj, pick, pipe } from 'remeda'
-import type { SetOptional } from 'type-fest'
-
-export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V, 'hash'>): V {
-  const tohash = {
-    id: view.id,
-    __: view.__ ?? 'element',
-    autoLayout: view.autoLayout,
-    nodes: pipe(
-      view.nodes,
-      map(pick(['id', 'title', 'description', 'technology', 'shape', 'icon', 'children'])),
-      mapToObj(({ id, icon, ...node }) => [id, { ...node, icon: isTruthy(icon) ? 'Y' : 'N' }])
-    ),
-    edges: pipe(
-      view.edges,
-      map(pick(['source', 'target', 'label', 'description', 'technology', 'dir', 'head', 'tail', 'line'])),
-      mapToObj(({ source, target, ...edge }) => [`${source}:${target}`, edge])
-    )
-  }
-  view.hash = objectHash(tohash, {
-    ignoreUnknown: true,
-    respectType: false
-  })
-  return view as V
-}