@likec4/core 1.41.0 → 1.42.1

package/src/compute-view/utils/applyCustomElementProperties.ts

@@ -1,107 +0,0 @@
-import { isEmpty, isNullish, omitBy } from 'remeda'
-import {
-  type AnyAux,
-  type ComputedNode,
-  type ElementViewRule,
-  type ModelExpression,
-  isGroupElementKind,
-  isViewRuleGroup,
-  isViewRulePredicate,
-  ModelFqnExpr,
-} from '../../types'
-import { elementExprToPredicate } from './elementExpressionToPredicate'
-
-export function flattenGroupRules<A extends AnyAux, T extends ModelExpression<A>>(
-  guard: (expr: ModelExpression<A>) => expr is T,
-) {
-  return (rule: ElementViewRule<A>): 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<A extends AnyAux>(
-  _rules: ElementViewRule<A>[],
-  _nodes: ComputedNode<A>[],
-) {
-  const rules = _rules.flatMap(flattenGroupRules(ModelFqnExpr.isCustom))
-  if (rules.length === 0) {
-    return _nodes
-  }
-  const nodes = [..._nodes]
-  for (
-    const {
-      custom: { expr, ...props },
-    } of rules
-  ) {
-    const {
-      border,
-      opacity,
-      multiple,
-      padding,
-      size,
-      textSize,
-      description,
-      ...rest
-    } = omitBy(props, isNullish)
-    const notEmpty = !isEmpty(rest)
-    const satisfies = elementExprToPredicate(expr)
-    nodes.forEach((node, i) => {
-      if (isGroupElementKind(node) || !satisfies(node)) {
-        return
-      }
-      if (notEmpty) {
-        node = {
-          ...node,
-          isCustomized: true,
-          ...rest,
-        }
-      }
-      if (description !== undefined) {
-        node = {
-          ...node,
-          isCustomized: true,
-          description,
-        }
-      }
-
-      let styleOverride: ComputedNode['style'] | undefined
-      if (border !== undefined) {
-        styleOverride = { border }
-      }
-      if (opacity !== undefined) {
-        styleOverride = { ...styleOverride, opacity }
-      }
-      if (multiple !== undefined) {
-        styleOverride = { ...styleOverride, multiple }
-      }
-      if (padding !== undefined) {
-        styleOverride = { ...styleOverride, padding }
-      }
-      if (size !== undefined) {
-        styleOverride = { ...styleOverride, size }
-      }
-      if (textSize !== undefined) {
-        styleOverride = { ...styleOverride, textSize }
-      }
-      if (styleOverride) {
-        node = {
-          ...node,
-          isCustomized: true,
-          style: {
-            ...node.style,
-            ...styleOverride,
-          },
-        }
-      }
-      nodes[i] = node
-    })
-  }
-  return nodes
-}

package/src/compute-view/utils/applyCustomRelationProperties.ts

@@ -1,58 +0,0 @@
-import { isNullish, omitBy, pick } from 'remeda'
-import { type AnyAux, type ComputedEdge, type ComputedNode, type ElementViewRule, ModelRelationExpr } from '../../types'
-import { flattenGroupRules } from './applyCustomElementProperties'
-import { relationExpressionToPredicates } from './relationExpressionToPredicates'
-
-export function applyCustomRelationProperties<A extends AnyAux>(
-  _rules: ElementViewRule<A>[],
-  nodes: ComputedNode<A>[],
-  _edges: Iterable<ComputedEdge<A>>,
-): ComputedEdge<A>[] {
-  const rules = _rules.flatMap(flattenGroupRules(ModelRelationExpr.isCustom))
-  const edges = Array.from(_edges)
-  if (rules.length === 0 || edges.length === 0) {
-    return edges
-  }
-  for (
-    const {
-      customRelation: {
-        expr,
-        title,
-        description,
-        notes,
-        ...customprops
-      },
-    } of rules
-  ) {
-    const props = omitBy(customprops, isNullish)
-    const satisfies = relationExpressionToPredicates(expr)
-    edges.forEach((edge, i) => {
-      let source, target
-      for (const node of nodes) {
-        if (node.id === edge.source) {
-          source = node
-        }
-        if (node.id === edge.target) {
-          target = node
-        }
-        if (source && target) {
-          break
-        }
-      }
-      if (!source || !target) {
-        return
-      }
-      if (satisfies({ source, target, ...pick(edge, ['kind', 'tags']) })) {
-        edges[i] = {
-          ...edge,
-          ...props,
-          ...description && { description: { txt: description } },
-          ...notes && { notes: { txt: notes } },
-          label: title ?? edge.label,
-          isCustomized: true,
-        }
-      }
-    })
-  }
-  return edges
-}

package/src/compute-view/utils/applyViewRuleStyles.ts

@@ -1,73 +0,0 @@
-import { anyPass, filter, forEach, isDefined, isNot, pipe } from 'remeda'
-import {
-  type AnyAux,
-  type AnyViewRuleStyle,
-  type ComputedNode,
-  type ElementViewRule,
-  isGroupElementKind,
-  isViewRuleStyle,
-} from '../../types'
-import { elementExprToPredicate } from './elementExpressionToPredicate'
-
-type Predicate<T> = (x: T) => boolean
-
-export function applyViewRuleStyle<A extends AnyAux>(
-  rule: Pick<AnyViewRuleStyle<A>, 'style' | 'notation'>,
-  predicates: Predicate<ComputedNode<A>>[],
-  nodes: ComputedNode<A>[],
-): void {
-  pipe(
-    nodes,
-    filter(isNot(isGroupElementKind)),
-    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 (isDefined(rule.style.multiple)) {
-        styleOverride = { ...styleOverride, multiple: rule.style.multiple }
-      }
-      if (isDefined(rule.style.padding)) {
-        styleOverride = { ...styleOverride, padding: rule.style.padding }
-      }
-      if (isDefined(rule.style.size)) {
-        styleOverride = { ...styleOverride, size: rule.style.size }
-      }
-      if (isDefined(rule.style.textSize)) {
-        styleOverride = { ...styleOverride, textSize: rule.style.textSize }
-      }
-      if (styleOverride) {
-        n.style = {
-          ...n.style,
-          ...styleOverride,
-        }
-      }
-    }),
-  )
-}
-
-export function applyViewRuleStyles<A extends AnyAux, N extends ComputedNode<A>[]>(
-  rules: ElementViewRule<A>[],
-  nodes: N,
-): N {
-  for (const rule of rules) {
-    if (!isViewRuleStyle(rule) || rule.targets.length === 0) {
-      continue
-    }
-    const predicates = rule.targets.map(elementExprToPredicate)
-    applyViewRuleStyle(rule, predicates, nodes)
-  }
-  return nodes
-}

package/src/compute-view/utils/buildComputedNodes.ts

@@ -1,166 +0,0 @@
-import type { Except } from 'type-fest'
-import type { ElementModel } from '../../model'
-import {
-  type AnyAux,
-  type aux,
-  type ComputedNode,
-  type scalar,
-  type Unknown,
-  DefaultElementShape,
-  DefaultThemeColor,
-  GroupElementKind,
-  omitUndefined,
-  preferSummary,
-} from '../../types'
-import { nonNullable } from '../../utils'
-import { compareByFqnHierarchically, parentFqn } from '../../utils/fqn'
-import { NodesGroup } from '../element-view/memory'
-
-function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<string, 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 type ComputedNodeSource<A extends AnyAux = Unknown> = Except<
-  ComputedNode<A>,
-  'parent' | 'children' | 'inEdges' | 'outEdges' | 'level' | 'depth',
-  { requireExactProps: true }
->
-
-export function elementModelToNodeSource<A extends AnyAux>(el: ElementModel<A>): ComputedNodeSource<A> {
-  const {
-    id,
-    summary, // omit
-    style,
-    metadata, // omit
-    ...rest
-  } = el.$element
-  return omitUndefined({
-    id: id as scalar.NodeId,
-    modelRef: id,
-    ...rest,
-    style: { ...style },
-    color: el.color,
-    shape: el.shape,
-    description: preferSummary(el.$element),
-    tags: [...el.tags],
-  })
-}
-
-export function buildComputedNodes<A extends AnyAux>(
-  elements: ReadonlyArray<ComputedNodeSource<A>>,
-  groups?: ReadonlyArray<NodesGroup<A>>,
-): ReadonlyMap<scalar.NodeId, ComputedNode<A>> {
-  const nodesMap = new Map<scalar.NodeId, ComputedNode<A>>()
-
-  const elementToGroup = new Map<aux.StrictFqn<A>, scalar.NodeId>()
-
-  groups?.forEach(({ id, parent, viewRule, elements }) => {
-    if (parent) {
-      nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id)
-    }
-    nodesMap.set(id, {
-      id,
-      parent,
-      kind: GroupElementKind,
-      title: viewRule.title ?? '',
-      description: null,
-      technology: null,
-      color: viewRule.color ?? 'muted',
-      shape: 'rectangle',
-      children: [],
-      inEdges: [],
-      outEdges: [],
-      level: 0,
-      depth: 0,
-      tags: [],
-      style: {
-        border: viewRule.border ?? 'dashed',
-        opacity: viewRule.opacity ?? 0,
-        size: viewRule.size ?? 'md',
-        multiple: viewRule.multiple ?? false,
-        padding: viewRule.padding ?? 'md',
-        textSize: viewRule.textSize ?? 'md',
-      },
-    })
-    for (const e of elements) {
-      elementToGroup.set(e.id, id)
-    }
-  })
-
-  // Ensure that parent nodes are created before child nodes
-  Array.from(elements)
-    .sort(compareByFqnHierarchically)
-    .forEach(({ id, style, kind, title, color, shape, tags, notation, ...el }) => {
-      let parent = parentFqn(id)
-      let level = 0
-      let parentNd: ComputedNode<A> | undefined
-      // Find the first ancestor that is already in the map
-      while (parent) {
-        parentNd = nodesMap.get(parent)
-        if (parentNd) {
-          break
-        }
-        parent = parentFqn(parent)
-      }
-      const fqn = el.modelRef ?? id as unknown as aux.StrictFqn<A>
-      // If parent is not found in the map, check if it is in a group
-      if (!parentNd && elementToGroup.has(fqn)) {
-        const parentGroupId = nonNullable(elementToGroup.get(fqn))
-        parentNd = nodesMap.get(parentGroupId)
-        parent = parentGroupId
-      }
-      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, nodesMap)
-        }
-        parentNd.children.push(id)
-        level = parentNd.level + 1
-      }
-      const node: ComputedNode<A> = {
-        id,
-        parent,
-        kind,
-        title,
-        description: null,
-        technology: null,
-        level,
-        color: color ?? DefaultThemeColor,
-        shape: shape ?? DefaultElementShape,
-        tags: tags ?? [],
-        children: [],
-        inEdges: [],
-        outEdges: [],
-        ...notation && { notation },
-        ...el,
-        style: {
-          ...style,
-        },
-      }
-      nodesMap.set(id, node)
-    })
-
-  // Create new map and add elements in the same order as they were in the input
-  const orderedMap = new Map<aux.NodeId, ComputedNode<A>>()
-
-  groups?.forEach(({ id }) => {
-    orderedMap.set(id, nonNullable(nodesMap.get(id)))
-  })
-  elements.forEach(({ id }) => {
-    orderedMap.set(id, nonNullable(nodesMap.get(id)))
-  })
-
-  return orderedMap
-}

package/src/compute-view/utils/buildElementNotations.ts

@@ -1,64 +0,0 @@
-import { entries, filter, flatMap, groupBy, map, mapValues, pipe, piped, prop, sortBy, unique } from 'remeda'
-import type { ComputedNode, NodeNotation } from '../../types'
-
-/**
- * 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<any>[]): NodeNotation[] {
-  return pipe(
-    nodes,
-    filter((n): n is ComputedNode<any> & { notation: string } => !!n.notation),
-    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/compute-view/utils/elementExpressionToPredicate.ts

@@ -1,50 +0,0 @@
-import {
-  FqnRef,
-  ModelFqnExpr,
-  whereOperatorAsPredicate,
-} from '../../types'
-import { nonexhaustive, parentFqn } from '../../utils'
-
-type Predicate<T> = (x: T) => boolean
-
-export function elementExprToPredicate<T extends { id: string; tags: readonly string[]; kind: string }>(
-  target: ModelFqnExpr.Any,
-): Predicate<T> {
-  if (ModelFqnExpr.isCustom(target)) {
-    return elementExprToPredicate(target.custom.expr)
-  }
-  if (ModelFqnExpr.isWhere(target)) {
-    const predicate = elementExprToPredicate(target.where.expr)
-    const where = whereOperatorAsPredicate(target.where.condition)
-    return n => predicate(n) && where(n)
-  }
-  if (ModelFqnExpr.isElementKindExpr(target)) {
-    return target.isEqual ? n => n.kind === target.elementKind : n => n.kind !== target.elementKind
-  }
-  if (ModelFqnExpr.isElementTagExpr(target)) {
-    return target.isEqual
-      ? ({ tags }) => tags.includes(target.elementTag)
-      : ({ tags }) => !tags.includes(target.elementTag)
-  }
-  if (ModelFqnExpr.isWildcard(target)) {
-    return () => true
-  }
-  if (ModelFqnExpr.isModelRef(target)) {
-    const fqn = FqnRef.flatten(target.ref)
-    if (target.selector === 'expanded') {
-      return (n) => {
-        return n.id === fqn || parentFqn(n.id) === fqn
-      }
-    }
-    if (target.selector === 'descendants' || target.selector === 'children') {
-      const fqnWithDot = fqn + '.'
-      return (n) => {
-        return n.id.startsWith(fqnWithDot)
-      }
-    }
-    return (n) => {
-      return n.id === fqn
-    }
-  }
-  nonexhaustive(target)
-}

package/src/compute-view/utils/link-nodes-with-edges.ts

@@ -1,56 +0,0 @@
-import { last, reverse } from 'remeda'
-import type { AnyAux, ComputedEdge, ComputedNode } from '../../types'
-import { invariant } from '../../utils'
-import { commonHead } from '../../utils/common-head'
-import { ancestorsOfNode } from './ancestorsOfNode'
-
-/**
- * Update `inEdges` and `outEdges` props of nodes based on the edges
- * Mutates nodes and updates their in/out edges
- */
-export function linkNodesWithEdges<A extends AnyAux>(
-  nodesMap: ReadonlyMap<any, ComputedNode<A>>,
-  edges: ComputedEdge<A>[],
-) {
-  for (const edge of edges) {
-    const source = nodesMap.get(edge.source)
-    const target = nodesMap.get(edge.target)
-    invariant(source, `Source node ${edge.source} not found`)
-    invariant(target, `Target node ${edge.target} not found`)
-
-    source.outEdges.push(edge.id)
-    target.inEdges.push(edge.id)
-
-    // These ancestors are reversed: from bottom to top
-    // Ensure that ancestors are in computed nodes
-    const sourceAncestors = ancestorsOfNode(source, nodesMap)
-    const targetAncestors = ancestorsOfNode(target, nodesMap)
-
-    const hasAncestors = sourceAncestors.length > 0 && targetAncestors.length > 0
-
-    const edgeParent = hasAncestors
-      ? last(
-        commonHead(
-          reverse(sourceAncestors),
-          reverse(targetAncestors),
-        ),
-      )
-      : null
-    edge.parent = edgeParent ? edgeParent.id : null
-
-    // Process edge source ancestors
-    for (const sourceAncestor of sourceAncestors) {
-      if (sourceAncestor === edgeParent) {
-        break
-      }
-      sourceAncestor.outEdges.push(edge.id)
-    }
-    // Process target hierarchy
-    for (const targetAncestor of targetAncestors) {
-      if (targetAncestor === edgeParent) {
-        break
-      }
-      targetAncestor.inEdges.push(edge.id)
-    }
-  }
-}