@likec4/core 1.27.3 → 1.28.1

package/src/compute-view/element-view/predicates/element-ref.ts

@@ -1,22 +1,11 @@
 import { findConnectionsWithin } from '../../../model/connection/model'
-import type { ElementRefExpr } from '../../../types/expression'
-import * as Expr from '../../../types/expression'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import type { Elem, PredicateExecutor } from '../_types'
+import { resolveElements } from './_utils'
 
-function applyElementSelector(elem: Elem, expr: Expr.ElementRefExpr) {
-  let children
-  if (expr.isChildren) {
-    children = [...elem.children()]
-  } else if (expr.isDescendants) {
-    children = [...elem.descendants()]
-  }
-  return children && children.length > 0 ? children : [elem]
-}
-
-export const ElementRefPredicate: PredicateExecutor<ElementRefExpr> = {
-  include: ({ expr, model, stage, where }) => {
-    const element = model.element(expr.element)
-    const elements = applyElementSelector(element, expr).filter(where)
+export const ElementRefPredicate: PredicateExecutor<ModelLayer.FqnExpr.ModelRef> = {
+  include: ({ expr, model, stage, filterWhere }) => {
+    const elements = filterWhere(resolveElements(model, expr))
     if (elements.length === 0) {
       return
     }
@@ -28,10 +17,9 @@ export const ElementRefPredicate: PredicateExecutor<ElementRefExpr> = {
     return stage
   },
   exclude: ({ expr, model, stage, filterWhere }) => {
-    const element = model.element(expr.element)
-    const elements = filterWhere(applyElementSelector(element, expr))
+    const elements = filterWhere(resolveElements(model, expr))
     stage.exclude(elements)
 
     return stage
-  }
+  },
 }

package/src/compute-view/element-view/predicates/relation-direct.ts

@@ -3,7 +3,7 @@ import { invariant } from '../../../errors'
 import { ConnectionModel, findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/model'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
-import * as Expr from '../../../types/expression'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import { isSameHierarchy } from '../../../utils'
 import { ifilter, iflat, iunique, toArray, toSet } from '../../../utils/iterable'
 import { intersection, union } from '../../../utils/set'
@@ -11,10 +11,12 @@ import type { Elem, PredicateCtx, PredicateExecutor } from '../_types'
 import { NoWhere } from '../utils'
 import { includeDescendantsFromMemory, resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationExpr> = {
+const isWildcard = ModelLayer.FqnExpr.isWildcard
+
+export const DirectRelationExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Direct> = {
   include: ({ expr: { source, target, isBidirectional = false }, memory, model, stage, where, filterWhere }) => {
-    const sourceIsWildcard = Expr.isWildcard(source)
-    const targetIsWildcard = Expr.isWildcard(target)
+    const sourceIsWildcard = isWildcard(source)
+    const targetIsWildcard = isWildcard(target)
 
     const connections = [] as ConnectionModel<AnyAux>[]
     switch (true) {
@@ -166,8 +168,8 @@ export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationE
       }
 
       default: {
-        invariant(!Expr.isWildcard(source), 'Inference failed - source must be not a wildcard')
-        invariant(!Expr.isWildcard(target), 'Inference failed - target must be not a wildcard')
+        invariant(!isWildcard(source), 'Inference failed - source must be not a wildcard')
+        invariant(!isWildcard(target), 'Inference failed - target must be not a wildcard')
         const sources = resolveAndIncludeFromMemory(source, { memory, model })
         const targets = resolveAndIncludeFromMemory(target, { memory, model })
         const dir = isBidirectional ? 'both' : 'directed'
@@ -186,8 +188,8 @@ export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationE
     return stage
   },
   exclude: ({ expr: { source, target, isBidirectional }, model, memory, stage, where }) => {
-    const sourceIsWildcard = Expr.isWildcard(source)
-    const targetIsWildcard = Expr.isWildcard(target)
+    const sourceIsWildcard = isWildcard(source)
+    const targetIsWildcard = isWildcard(target)
 
     let relations: Set<RelationshipModel<AnyAux>>
 
@@ -249,8 +251,8 @@ export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationE
       }
 
       default: {
-        invariant(!Expr.isWildcard(source), 'Inferrence failed - source must be not a wildcard')
-        invariant(!Expr.isWildcard(target), 'Inferrence failed - target must be not a wildcard')
+        invariant(!isWildcard(source), 'Inferrence failed - source must be not a wildcard')
+        invariant(!isWildcard(target), 'Inferrence failed - target must be not a wildcard')
         const sources = resolveElements(model, source)
         const targets = resolveElements(model, target)
 
@@ -281,7 +283,7 @@ export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationE
  * Resolve elements for both source and target, when one of them is a wildcard
  */
 function resolveWildcard(
-  nonWildcard: Expr.NonWilcard,
+  nonWildcard: ModelLayer.FqnExpr.NonWildcard,
   { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
 ): [elements: Elem[], wildcard: Elem[]] {
   let sources = resolveElements(model, nonWildcard)
@@ -289,8 +291,8 @@ function resolveWildcard(
     return [[], []]
   }
 
-  if (Expr.isExpandedElementExpr(nonWildcard) || Expr.isElementRef(nonWildcard)) {
-    const parent = model.element(nonWildcard.element ?? nonWildcard.expanded)
+  if (ModelLayer.FqnExpr.isModelRef(nonWildcard)) {
+    const parent = model.element(ModelLayer.FqnRef.toFqn(nonWildcard.ref))
     const targets = toArray(parent.ascendingSiblings())
     return [
       includeDescendantsFromMemory(sources, memory),

package/src/compute-view/element-view/predicates/relation-in-out.ts

@@ -2,16 +2,15 @@ import { unique } from 'remeda'
 import { type ConnectionModel, findConnectionsBetween } from '../../../model/connection/model'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
-import * as Expr from '../../../types/expression'
-import { toArray } from '../../../utils/iterable'
-import { toSet } from '../../../utils/iterable/to'
+import { ModelLayer } from '../../../types/expression-v2-model'
+import { toArray, toSet } from '../../../utils/iterable/to'
 import type { PredicateExecutor } from '../_types'
 import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const InOutRelationPredicate: PredicateExecutor<Expr.InOutExpr> = {
+export const InOutRelationPredicate: PredicateExecutor<ModelLayer.RelationExpr.InOut> = {
   include: ({ expr: { inout }, scope, model, memory, stage, filterWhere }) => {
     const connections = [] as ConnectionModel<AnyAux>[]
-    if (Expr.isWildcard(inout)) {
+    if (ModelLayer.FqnExpr.isWildcard(inout)) {
       if (!scope) {
         return
       }
@@ -47,7 +46,7 @@ export const InOutRelationPredicate: PredicateExecutor<Expr.InOutExpr> = {
   },
   exclude: ({ expr: { inout }, model, scope, stage, where }) => {
     const excluded = [] as RelationshipModel[]
-    if (Expr.isWildcard(inout)) {
+    if (ModelLayer.FqnExpr.isWildcard(inout)) {
       if (!scope) {
         return
       }

package/src/compute-view/element-view/predicates/relation-in.ts

@@ -2,23 +2,23 @@ import { anyPass, unique } from 'remeda'
 import { nonexhaustive } from '../../../errors'
 import type { LikeC4Model } from '../../../model'
 import {
-  Connection,
   type ConnectionModel,
+  Connection,
   findConnection,
-  findConnectionsBetween
+  findConnectionsBetween,
 } from '../../../model/connection/model'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
-import * as Expr from '../../../types/expression'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
 import type { ConnectionWhere, PredicateExecutor } from '../_types'
 import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
+export const IncomingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Incoming> = {
   include: ({ expr, scope, model, memory, stage, filterWhere }) => {
     const target = expr.incoming
     const connections = [] as ConnectionModel<AnyAux>[]
-    if (Expr.isWildcard(target)) {
+    if (ModelLayer.FqnExpr.isWildcard(target)) {
       if (!scope) {
         return
       }
@@ -27,8 +27,8 @@ export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
           ...findConnection(
             sibling,
             scope,
-            'directed'
-          )
+            'directed',
+          ),
         )
       }
     } else {
@@ -37,8 +37,8 @@ export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
       if (visibleElements.length === 0) {
         visibleElements.push(
           ...unique(
-            targets.flatMap(el => [...el.ascendingSiblings()])
-          )
+            targets.flatMap(el => [...el.ascendingSiblings()]),
+          ),
         )
       }
       const ensureIncoming = incomingConnectionPredicate(model, target)
@@ -47,21 +47,21 @@ export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
           ...findConnectionsBetween(
             visible,
             targets,
-            'directed'
-          ).filter(ensureIncoming)
+            'directed',
+          ).filter(ensureIncoming),
         )
       }
     }
 
     stage.addConnections(
-      filterWhere(connections)
+      filterWhere(connections),
     )
 
     return stage
   },
   exclude: ({ expr: { incoming }, model, scope, stage, where }) => {
     const excluded = [] as RelationshipModel[]
-    if (Expr.isWildcard(incoming)) {
+    if (ModelLayer.FqnExpr.isWildcard(incoming)) {
       if (!scope) {
         return
       }
@@ -69,48 +69,52 @@ export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
     } else {
       const elements = resolveElements(model, incoming)
       excluded.push(
-        ...elements.flatMap(e => [...e.allIncoming])
+        ...elements.flatMap(e => [...e.allIncoming]),
       )
     }
     stage.excludeRelations(new Set(excluded.filter(where)))
 
     return stage
-  }
+  },
 }
 
 export function incomingConnectionPredicate(
   model: LikeC4Model,
-  expr: Exclude<Expr.ElementExpression, Expr.WildcardExpr>
+  expr: ModelLayer.FqnExpr.NonWildcard,
 ): ConnectionWhere {
   switch (true) {
-    case Expr.isElementKindExpr(expr):
-    case Expr.isElementTagExpr(expr): {
+    case ModelLayer.FqnExpr.isElementKindExpr(expr):
+    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
       const isElement = elementExprToPredicate(expr)
       return (connection) => isElement(connection.target)
     }
-    case Expr.isElementRef(expr) && expr.isChildren: {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'children': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass(
-        [...model.children(expr.element)].map(
-          el => Connection.isIncoming(el.id)
-        )
+        [...model.children(fqn)].map(
+          el => Connection.isIncoming(el.id),
+        ),
       )
     }
-    case Expr.isElementRef(expr) && expr.isDescendants: {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass([
-        Connection.isInside(expr.element),
-        ...[...model.children(expr.element)].map(
-          el => Connection.isIncoming(el.id)
-        )
+        Connection.isInside(fqn),
+        ...[...model.children(fqn)].map(
+          el => Connection.isIncoming(el.id),
+        ),
       ])
     }
-    case Expr.isExpandedElementExpr(expr): {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass([
-        Connection.isIncoming(expr.expanded),
-        Connection.isInside(expr.expanded)
+        Connection.isIncoming(fqn),
+        Connection.isInside(fqn),
       ])
     }
-    case Expr.isElementRef(expr): {
-      return Connection.isIncoming(expr.element)
+    case ModelLayer.FqnExpr.isModelRef(expr): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+      return Connection.isIncoming(fqn)
     }
     default:
       nonexhaustive(expr)

package/src/compute-view/element-view/predicates/relation-out.ts

@@ -1,20 +1,20 @@
 import { anyPass, unique } from 'remeda'
 import { nonexhaustive } from '../../../errors'
-import type { LikeC4Model } from '../../../model'
-import { Connection, type ConnectionModel, findConnectionsBetween } from '../../../model/connection/model'
+import { type ConnectionModel, Connection, findConnectionsBetween } from '../../../model/connection/model'
+import type { LikeC4Model } from '../../../model/LikeC4Model'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
-import * as Expr from '../../../types/expression'
+import { ModelLayer } from '../../../types/expression-v2-model'
 import { toSet } from '../../../utils/iterable/to'
 import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
 import type { ConnectionWhere, PredicateExecutor } from '../_types'
 import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const OutgoingExprPredicate: PredicateExecutor<Expr.OutgoingExpr> = {
+export const OutgoingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Outgoing> = {
   include: ({ expr, scope, model, memory, stage, filterWhere }) => {
     const target = expr.outgoing
     const connections = [] as ConnectionModel<AnyAux>[]
-    if (Expr.isWildcard(target)) {
+    if (ModelLayer.FqnExpr.isWildcard(target)) {
       if (!scope) {
         return
       }
@@ -23,8 +23,8 @@ export const OutgoingExprPredicate: PredicateExecutor<Expr.OutgoingExpr> = {
         ...findConnectionsBetween(
           scope,
           scope.ascendingSiblings(),
-          'directed'
-        )
+          'directed',
+        ),
       )
     } else {
       const elements = resolveAndIncludeFromMemory(target, { memory, model })
@@ -32,8 +32,8 @@ export const OutgoingExprPredicate: PredicateExecutor<Expr.OutgoingExpr> = {
       if (visibleElements.length === 0) {
         visibleElements.push(
           ...unique(
-            elements.flatMap(el => [...el.ascendingSiblings()])
-          )
+            elements.flatMap(el => [...el.ascendingSiblings()]),
+          ),
         )
       }
       const ensureOutgoing = outgoingConnectionPredicate(model, target)
@@ -43,21 +43,21 @@ export const OutgoingExprPredicate: PredicateExecutor<Expr.OutgoingExpr> = {
           ...findConnectionsBetween(
             source,
             visibleElements,
-            'directed'
-          ).filter(ensureOutgoing)
+            'directed',
+          ).filter(ensureOutgoing),
         )
       }
     }
 
     stage.addConnections(
-      filterWhere(connections)
+      filterWhere(connections),
     )
 
     return stage
   },
   exclude: ({ expr: { outgoing }, model, scope, stage, where }) => {
     const excluded = [] as RelationshipModel[]
-    if (Expr.isWildcard(outgoing)) {
+    if (ModelLayer.FqnExpr.isWildcard(outgoing)) {
       if (!scope) {
         return
       }
@@ -65,50 +65,54 @@ export const OutgoingExprPredicate: PredicateExecutor<Expr.OutgoingExpr> = {
     } else {
       const elements = resolveElements(model, outgoing)
       excluded.push(
-        ...elements.flatMap(e => [...e.allOutgoing])
+        ...elements.flatMap(e => [...e.allOutgoing]),
       )
     }
     stage.excludeRelations(
-      toSet(excluded.filter(where))
+      toSet(excluded.filter(where)),
     )
 
     return stage
-  }
+  },
 }
 
 export function outgoingConnectionPredicate(
   model: LikeC4Model,
-  expr: Exclude<Expr.ElementExpression, Expr.WildcardExpr>
+  expr: ModelLayer.FqnExpr.NonWildcard,
 ): ConnectionWhere {
   switch (true) {
-    case Expr.isElementKindExpr(expr):
-    case Expr.isElementTagExpr(expr): {
+    case ModelLayer.FqnExpr.isElementKindExpr(expr):
+    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
       const isElement = elementExprToPredicate(expr)
       return (connection) => isElement(connection.source)
     }
-    case Expr.isElementRef(expr) && expr.isChildren: {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'children': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass(
-        [...model.children(expr.element)].map(
-          el => Connection.isOutgoing(el.id)
-        )
+        [...model.children(fqn)].map(
+          el => Connection.isOutgoing(el.id),
+        ),
       )
     }
-    case Expr.isElementRef(expr) && expr.isDescendants: {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass([
-        Connection.isInside(expr.element),
-        ...[...model.children(expr.element)].map(
-          el => Connection.isOutgoing(el.id)
-        )
+        Connection.isInside(fqn),
+        ...[...model.children(fqn)].map(
+          el => Connection.isOutgoing(el.id),
+        ),
       ])
     }
-    case Expr.isExpandedElementExpr(expr): {
+    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
       return anyPass([
-        Connection.isOutgoing(expr.expanded),
-        Connection.isInside(expr.expanded)
+        Connection.isOutgoing(fqn),
+        Connection.isInside(fqn),
       ])
     }
-    case Expr.isElementRef(expr): {
-      return Connection.isOutgoing(expr.element)
+    case ModelLayer.FqnExpr.isModelRef(expr): {
+      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+      return Connection.isOutgoing(fqn)
     }
     default:
       nonexhaustive(expr)

package/src/compute-view/element-view/predicates/wildcard.ts

@@ -1,12 +1,12 @@
 import { filter } from 'remeda'
 import { findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/model'
-import type { WildcardExpr } from '../../../types/expression'
+import type { ModelLayer } from '../../../types/expression-v2-model'
 import { ifilter, toArray } from '../../../utils/iterable'
 import { toSet } from '../../../utils/iterable/to'
 import { type PredicateExecutor, Memory } from '../_types'
 import { NoWhere } from '../utils'
 
-export const WildcardPredicate: PredicateExecutor<WildcardExpr> = {
+export const WildcardPredicate: PredicateExecutor<ModelLayer.FqnExpr.Wildcard> = {
   include: ({ scope, model, stage, memory, where }) => {
     if (!scope) {
       const rootElements = [...model.roots()].filter(where)

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

@@ -1,9 +1,14 @@
 import { isEmpty, isNullish, omitBy } from 'remeda'
-import { type ViewRule, ComputedNode, isCustomElement, isViewRuleGroup, isViewRulePredicate } from '../../types'
-import type { Expression } from '../../types/expression'
+import {
+  type ViewRule,
+  ComputedNode,
+  isViewRuleGroup,
+  isViewRulePredicate,
+  ModelLayer,
+} from '../../types'
 import { elementExprToPredicate } from './elementExpressionToPredicate'
 
-export function flattenGroupRules<T extends Expression>(guard: (expr: Expression) => expr is T) {
+export function flattenGroupRules<T extends ModelLayer.Expression>(guard: (expr: ModelLayer.Expression) => expr is T) {
   return (rule: ViewRule): Array<T> => {
     if (isViewRuleGroup(rule)) {
       return rule.groupRules.flatMap(flattenGroupRules(guard))
@@ -17,7 +22,7 @@ export function flattenGroupRules<T extends Expression>(guard: (expr: Expression
 }
 
 export function applyCustomElementProperties(_rules: ViewRule[], _nodes: ComputedNode[]) {
-  const rules = _rules.flatMap(flattenGroupRules(isCustomElement))
+  const rules = _rules.flatMap(flattenGroupRules(ModelLayer.FqnExpr.isCustom))
   if (rules.length === 0) {
     return _nodes
   }

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

@@ -1,26 +1,29 @@
 import { isNullish, omitBy, pick } from 'remeda'
-import type { ComputedEdge, ComputedNode, ViewRule } from '../../types'
-import * as Expr from '../../types/expression'
+import { type ComputedEdge, type ComputedNode, type ViewRule, ModelLayer } from '../../types'
 import { flattenGroupRules } from './applyCustomElementProperties'
 import { relationExpressionToPredicates } from './relationExpressionToPredicates'
 
 export function applyCustomRelationProperties(
   _rules: ViewRule[],
   nodes: ComputedNode[],
-  _edges: Iterable<ComputedEdge>
+  _edges: Iterable<ComputedEdge>,
 ): ComputedEdge[] {
-  const rules = _rules.flatMap(flattenGroupRules(Expr.isCustomRelationExpr))
+  const rules = _rules.flatMap(flattenGroupRules(ModelLayer.RelationExpr.isCustom))
   const edges = Array.from(_edges)
   if (rules.length === 0 || edges.length === 0) {
     return edges
   }
   for (
     const {
-      customRelation: { relation, title, ...customprops }
+      customRelation: {
+        expr,
+        title,
+        ...customprops
+      },
     } of rules
   ) {
     const props = omitBy(customprops, isNullish)
-    const satisfies = relationExpressionToPredicates(relation)
+    const satisfies = relationExpressionToPredicates(expr)
     edges.forEach((edge, i) => {
       const source = nodes.find(n => n.id === edge.source)
       const target = nodes.find(n => n.id === edge.target)
@@ -32,7 +35,7 @@ export function applyCustomRelationProperties(
           ...edge,
           ...props,
           label: title ?? edge.label,
-          isCustomized: true
+          isCustomized: true,
         }
       }
     })

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

@@ -1,50 +1,51 @@
 import { isNullish } from 'remeda'
 import { nonexhaustive } from '../../errors'
 import {
-  type ElementPredicateExpression,
-  isCustomElement,
-  isElementKindExpr,
-  isElementRef,
-  isElementTagExpr,
-  isElementWhere,
-  isExpandedElementExpr,
-  isWildcard,
-  whereOperatorAsPredicate
+  ModelLayer,
+  whereOperatorAsPredicate,
 } from '../../types'
 import { parentFqn } from '../../utils'
 
 type Predicate<T> = (x: T) => boolean
 
 export function elementExprToPredicate<T extends { id: string; tags?: readonly string[] | null; kind: string }>(
-  target: ElementPredicateExpression
+  target: ModelLayer.AnyFqnExpr,
 ): Predicate<T> {
-  if (isElementWhere(target)) {
+  if (ModelLayer.FqnExpr.isCustom(target)) {
+    return elementExprToPredicate(target.custom.expr)
+  }
+  if (ModelLayer.FqnExpr.isWhere(target)) {
     const predicate = elementExprToPredicate(target.where.expr)
     const where = whereOperatorAsPredicate(target.where.condition)
     return n => predicate(n) && where(n)
   }
-  if (isWildcard(target)) {
-    return () => true
-  }
-  if (isElementKindExpr(target)) {
+  if (ModelLayer.FqnExpr.isElementKindExpr(target)) {
     return target.isEqual ? n => n.kind === target.elementKind : n => n.kind !== target.elementKind
   }
-  if (isElementTagExpr(target)) {
+  if (ModelLayer.FqnExpr.isElementTagExpr(target)) {
     return target.isEqual
       ? ({ tags }) => !!tags && tags.includes(target.elementTag)
       : ({ tags }) => isNullish(tags) || !tags.includes(target.elementTag)
   }
-  if (isExpandedElementExpr(target)) {
-    return n => n.id === target.expanded || parentFqn(n.id) === target.expanded
-  }
-  if (isElementRef(target)) {
-    const { element, isChildren, isDescendants } = target
-    return isChildren || isDescendants
-      ? n => n.id.startsWith(element + '.')
-      : n => (n.id as string) === element
+  if (ModelLayer.FqnExpr.isWildcard(target)) {
+    return () => true
   }
-  if (isCustomElement(target)) {
-    return elementExprToPredicate(target.custom.expr)
+  if (ModelLayer.FqnExpr.isModelRef(target)) {
+    const fqn = ModelLayer.FqnRef.toFqn(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,6 +1,6 @@
 import { last, reverse } from 'remeda'
 import { invariant } from '../../errors'
-import type { Fqn } from '../../types/element'
+import type { Fqn } from '../../types'
 import type { ComputedEdge, ComputedNode } from '../../types/view'
 import { commonHead } from '../../utils/common-head'
 import { ancestorsOfNode } from './ancestorsOfNode'