@likec4/language-server 1.15.0 → 1.16.0

package/src/like-c4.langium

@@ -267,6 +267,7 @@ ViewLayoutDirection returns string:
 
 ViewRule:
   ViewRulePredicate |
+  ViewRuleGlobalPredicateRef |
   ViewRuleGroup |
   ViewRuleStyleOrGlobalRef |
   ViewRuleAutoLayout
@@ -287,6 +288,7 @@ ViewRuleGroup:
 
 DynamicViewRule:
   DynamicViewIncludePredicate |
+  DynamicViewGlobalPredicateRef |
   ViewRuleStyleOrGlobalRef |
   ViewRuleAutoLayout
 ;
@@ -318,6 +320,9 @@ Predicate:
   ElementPredicate
 ;
 
+ViewRuleGlobalPredicateRef:
+  'global' 'predicate' predicate=[GlobalPredicateGroup];
+
 ElementPredicate:
   ElementPredicates;
 
@@ -443,6 +448,9 @@ DynamicViewIncludePredicate:
   'include' predicates=DynamicViewPredicateIterator
 ;
 
+DynamicViewGlobalPredicateRef:
+  'global' 'predicate' predicate=[GlobalDynamicPredicateGroup];
+
 DynamicViewPredicateIterator:
   value=ElementPredicate ({infer DynamicViewPredicateIterator.prev=current} ',' (value=ElementPredicate)?)*
 ;
@@ -506,10 +514,21 @@ RelationNavigateToProperty:
 Globals:
   name='global' '{'
     (
+      predicates+=(GlobalPredicateGroup | GlobalDynamicPredicateGroup)*
       styles+=(GlobalStyle | GlobalStyleGroup)*
     )*
   '}';
 
+GlobalPredicateGroup:
+  'predicateGroup' name=IdTerminal '{'
+    predicates+=ViewRulePredicate*
+  '}';
+
+GlobalDynamicPredicateGroup:
+  'dynamicPredicateGroup' name=IdTerminal '{'
+    predicates+=DynamicViewIncludePredicate*
+  '}';
+
 GlobalStyleId:
   name=IdTerminal;
 

package/src/lsp/SemanticTokenProvider.ts

@@ -68,7 +68,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
           SemanticTokenModifiers.readonly
         ]
       })
-      return
+      return 'prune'
     }
     if (ast.isWhereRelationKind(node) && isTruthy(node.value)) {
       acceptor({
@@ -97,6 +97,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
       })
+      return 'prune'
     }
     if (ast.isElementTagExpression(node) && isTruthy(node.tag)) {
       acceptor({
@@ -105,6 +106,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
       })
+      return 'prune'
     }
     if (ast.isElementRef(node) || ast.isFqnElementRef(node)) {
       acceptor({

package/src/model/model-builder.ts

@@ -13,10 +13,8 @@ import { deepEqual as eq } from 'fast-equals'
 import type { Cancellation, LangiumDocument, LangiumDocuments, URI, WorkspaceCache } from 'langium'
 import { Disposable, DocumentState, interruptAndCheck } from 'langium'
 import {
-  entries,
   filter,
   flatMap,
-  forEach,
   groupBy,
   indexBy,
   isEmpty,
@@ -46,21 +44,37 @@ import { isParsedLikeC4LangiumDocument } from '../ast'
 import { logError, logger, logWarnError } from '../logger'
 import { computeDynamicView, computeView, LikeC4ModelGraph } from '../model-graph'
 import type { LikeC4Services } from '../module'
-import { assignNavigateTo, resolveGlobalRules, resolveRelativePaths, resolveRulesExtendedViews } from '../view-utils'
+import { assignNavigateTo, resolveRelativePaths, resolveRulesExtendedViews } from '../view-utils'
 
 function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[]): c4.ParsedLikeC4Model {
+  // Merge specifications and globals from all documents
   const c4Specification: ParsedAstSpecification = {
     tags: new Set(),
     elements: {},
     relationships: {},
     colors: {}
   }
-  forEach(map(docs, prop('c4Specification')), spec => {
+  const globals: c4.ModelGlobals = {
+    predicates: {},
+    dynamicPredicates: {},
+    styles: {}
+  }
+  for (const doc of docs) {
+    const {
+      c4Specification: spec,
+      c4Globals
+    } = doc
+
     spec.tags.forEach(t => c4Specification.tags.add(t))
     Object.assign(c4Specification.elements, spec.elements)
     Object.assign(c4Specification.relationships, spec.relationships)
     Object.assign(c4Specification.colors, spec.colors)
-  })
+
+    Object.assign(globals.predicates, c4Globals.predicates)
+    Object.assign(globals.dynamicPredicates, c4Globals.dynamicPredicates)
+    Object.assign(globals.styles, c4Globals.styles)
+  }
+
   function resolveLinks(doc: LangiumDocument, links: c4.NonEmptyArray<ParsedLink>) {
     return map(
       links,
@@ -211,23 +225,6 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
     indexBy(prop('id'))
   )
 
-  const parsedGlobals: {
-    styles: Record<c4.GlobalStyleID, c4.ViewRuleStyle[]>
-  } = {
-    styles: {}
-  }
-  Object.assign(parsedGlobals.styles, ...docs.map(d => d.c4Globals.styles))
-
-  const globals: {
-    styles: Record<c4.GlobalStyleID, c4.GlobalStyle>
-  } = {
-    styles: pipe(
-      entries(parsedGlobals.styles),
-      map(([id, styles]) => ({ id, styles })),
-      indexBy(prop('id'))
-    )
-  }
-
   function toC4View(doc: LangiumDocument) {
     const docUri = doc.uri.toString()
     return (parsedAstView: ParsedAstView): c4.LikeC4View => {
@@ -255,18 +252,23 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
 
       return {
         ...model,
+        customColorDefinitions,
         tags,
         links,
         docUri,
         description,
         title,
-        id,
-        customColorDefinitions
+        id
       }
     }
   }
 
-  const parsedViews = docs.flatMap(d => map(d.c4Views, toC4View(d)))
+  const parsedViews = pipe(
+    docs,
+    flatMap(d => map(d.c4Views, toC4View(d))),
+    // Resolve relative paths and sort by
+    resolveRelativePaths
+  )
   // Add index view if not present
   if (!parsedViews.some(v => v.id === 'index')) {
     parsedViews.unshift({
@@ -291,7 +293,6 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
 
   const views = pipe(
     parsedViews,
-    resolveRelativePaths,
     indexBy(prop('id')),
     resolveRulesExtendedViews
   )
@@ -362,7 +363,7 @@ export class LikeC4ModelBuilder {
         logger.debug('[ModelBuilder] No documents to build model from')
         return null
       }
-      logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)`)
+      logger.debug(`[ModelBuilder] buildModel (${docs.length} docs)`)
       return buildModel(this.services, docs)
     })
   }
@@ -395,7 +396,9 @@ export class LikeC4ModelBuilder {
 
       const allViews = [] as c4.ComputedView[]
       for (const view of values(model.views)) {
-        const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index)
+        const result = isElementView(view)
+          ? computeView(view, index)
+          : computeDynamicView(view, index)
         if (!result.isSuccess) {
           logWarnError(result.error)
           continue
@@ -460,10 +463,9 @@ export class LikeC4ModelBuilder {
           return null
         }
         const index = new LikeC4ModelGraph(model)
-        const resolvedView = resolveGlobalRules(view, model.globals.styles)
-        const result = isElementView(resolvedView)
-          ? computeView(resolvedView, index)
-          : computeDynamicView(resolvedView, index)
+        const result = isElementView(view)
+          ? computeView(view, index)
+          : computeDynamicView(view, index)
         if (!result.isSuccess) {
           logError(result.error)
           return null

package/src/model/model-parser.ts

@@ -11,6 +11,7 @@ import type {
   ParsedAstDynamicView,
   ParsedAstElement,
   ParsedAstElementView,
+  ParsedAstGlobals,
   ParsedAstRelation,
   ParsedLikeC4LangiumDocument,
   ParsedLink
@@ -288,6 +289,25 @@ export class LikeC4ModelParser {
     const { parseResult, c4Globals } = doc
 
     const globals = parseResult.value.globals.filter(isValid)
+
+    const elRelPredicates = globals.flatMap(r => r.predicates.filter(isValid))
+    for (const predicate of elRelPredicates) {
+      try {
+        const globalPredicateId = predicate.name as c4.GlobalPredicateId
+        if (!isTruthy(globalPredicateId)) {
+          continue
+        }
+        if (globalPredicateId in c4Globals.predicates) {
+          logger.warn(`Global predicate named "${globalPredicateId}" is already defined`)
+          continue
+        }
+
+        this.parseAndStoreGlobalPredicateGroupOrDynamic(predicate, globalPredicateId, c4Globals, isValid)
+      } catch (e) {
+        logWarnError(e)
+      }
+    }
+
     const styles = globals.flatMap(r => r.styles.filter(isValid))
     for (const style of styles) {
       try {
@@ -310,12 +330,49 @@ export class LikeC4ModelParser {
     }
   }
 
+  private parseAndStoreGlobalPredicateGroupOrDynamic(
+    astRule: ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup,
+    id: c4.GlobalPredicateId,
+    c4Globals: ParsedAstGlobals,
+    isValid: IsValidFn
+  ) {
+    if (ast.isGlobalPredicateGroup(astRule)) {
+      const predicates = this.parseGlobalPredicateGroup(astRule, isValid)
+      if (predicates.length > 0) {
+        c4Globals.predicates[id] = predicates as c4.NonEmptyArray<c4.ViewRulePredicate>
+      }
+      return
+    }
+    if (ast.isGlobalDynamicPredicateGroup(astRule)) {
+      const predicates = this.parseGlobalDynamicPredicateGroup(astRule, isValid)
+      if (predicates.length > 0) {
+        c4Globals.dynamicPredicates[id] = predicates as c4.NonEmptyArray<c4.DynamicViewIncludeRule>
+      }
+      return
+    }
+    nonexhaustive(astRule)
+  }
+
+  private parseGlobalPredicateGroup(
+    astRule: ast.GlobalPredicateGroup,
+    isValid: IsValidFn
+  ): c4.ViewRulePredicate[] {
+    return astRule.predicates.map(p => this.parseViewRulePredicate(p, isValid))
+  }
+
+  private parseGlobalDynamicPredicateGroup(
+    astRule: ast.GlobalDynamicPredicateGroup,
+    isValid: IsValidFn
+  ): c4.DynamicViewIncludeRule[] {
+    return astRule.predicates.map(p => this.parseDynamicViewIncludePredicate(p, isValid))
+  }
+
   private parseGlobalStyleOrGroup(
     astRule: ast.GlobalStyle | ast.GlobalStyleGroup,
     isValid: IsValidFn
   ): c4.ViewRuleStyle[] {
     if (ast.isGlobalStyle(astRule)) {
-      return [this.parseGlobalStyle(astRule, isValid)]
+      return [this.parseViewRuleStyle(astRule, isValid)]
     }
     if (ast.isGlobalStyleGroup(astRule)) {
       return astRule.styles.map(s => this.parseViewRuleStyle(s, isValid))
@@ -323,19 +380,17 @@ export class LikeC4ModelParser {
     nonexhaustive(astRule)
   }
 
-  private parseGlobalStyle(astRule: ast.GlobalStyle, isValid: IsValidFn): 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, isValid, notation)
-  }
-
   private parseViews(doc: ParsedLikeC4LangiumDocument, isValid: IsValidFn) {
     const viewBlocks = doc.parseResult.value.views.filter(v => isValid(v))
     for (const viewBlock of viewBlocks) {
-      const localStyles = viewBlock.styles
-        .flatMap(s => this.parseViewRuleStyleOrGlobalRef(s, isValid))
-      const stylesToApply = localStyles
+      const localStyles = viewBlock.styles.flatMap(s => {
+        try {
+          return this.parseViewRuleStyleOrGlobalRef(s, isValid)
+        } catch (e) {
+          logWarnError(e)
+          return []
+        }
+      })
 
       for (const view of viewBlock.views) {
         try {
@@ -344,8 +399,8 @@ export class LikeC4ModelParser {
           }
           doc.c4Views.push(
             ast.isElementView(view)
-              ? this.parseElementView(view, stylesToApply, isValid)
-              : this.parseDynamicElementView(view, stylesToApply, isValid)
+              ? this.parseElementView(view, localStyles, isValid)
+              : this.parseDynamicElementView(view, localStyles, isValid)
           )
         } catch (e) {
           logWarnError(e)
@@ -415,14 +470,14 @@ export class LikeC4ModelParser {
       }
     }
     if (ast.isElementKindExpression(astNode)) {
-      invariant(astNode.kind, 'ElementKindExpr kind is not resolved: ' + astNode.$cstNode?.text)
+      invariant(astNode.kind?.ref, 'ElementKindExpr kind is not resolved: ' + astNode.$cstNode?.text)
       return {
-        elementKind: astNode.kind.$refText as c4.ElementKind,
+        elementKind: astNode.kind.ref.name as c4.ElementKind,
         isEqual: astNode.isEqual
       }
     }
     if (ast.isElementTagExpression(astNode)) {
-      invariant(astNode.tag, 'ElementTagExpr tag is not resolved: ' + astNode.$cstNode?.text)
+      invariant(astNode.tag?.ref, 'ElementTagExpr tag is not resolved: ' + astNode.$cstNode?.text)
       let elementTag = astNode.tag.$refText
       if (elementTag.startsWith('#')) {
         elementTag = elementTag.slice(1)
@@ -653,6 +708,9 @@ export class LikeC4ModelParser {
     if (ast.isViewRulePredicate(astRule)) {
       return this.parseViewRulePredicate(astRule, isValid)
     }
+    if (ast.isViewRuleGlobalPredicateRef(astRule)) {
+      return this.parseViewRuleGlobalPredicateRef(astRule, isValid)
+    }
     if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
       return this.parseViewRuleStyleOrGlobalRef(astRule, isValid)
     }
@@ -665,7 +723,19 @@ export class LikeC4ModelParser {
     nonexhaustive(astRule)
   }
 
-  private parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef, isValid: IsValidFn): c4.ViewRuleStyleOrGlobalRef {
+  private parseViewRuleGlobalPredicateRef(
+    astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef,
+    _isValid: IsValidFn
+  ): c4.ViewRuleGlobalPredicateRef {
+    return {
+      predicateId: astRule.predicate.$refText as c4.GlobalPredicateId
+    }
+  }
+
+  private parseViewRuleStyleOrGlobalRef(
+    astRule: ast.ViewRuleStyleOrGlobalRef,
+    isValid: IsValidFn
+  ): c4.ViewRuleStyleOrGlobalRef {
     if (ast.isViewRuleStyle(astRule)) {
       return this.parseViewRuleStyle(astRule, isValid)
     }
@@ -675,7 +745,7 @@ export class LikeC4ModelParser {
     nonexhaustive(astRule)
   }
 
-  private parseViewRuleStyle(astRule: ast.ViewRuleStyle, isValid: IsValidFn): c4.ViewRuleStyle {
+  private parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle, isValid: IsValidFn): c4.ViewRuleStyle {
     const styleProps = astRule.props.filter(ast.isStyleProperty)
     const targets = astRule.target
     const notation = astRule.props.find(ast.isNotationProperty)
@@ -971,6 +1041,9 @@ export class LikeC4ModelParser {
     if (ast.isDynamicViewIncludePredicate(astRule)) {
       return this.parseDynamicViewIncludePredicate(astRule, isValid)
     }
+    if (ast.isDynamicViewGlobalPredicateRef(astRule)) {
+      return this.parseViewRuleGlobalPredicateRef(astRule, isValid)
+    }
     if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
       return this.parseViewRuleStyleOrGlobalRef(astRule, isValid)
     }

package/src/model-graph/LikeC4ModelGraph.ts

@@ -5,6 +5,7 @@ import {
   type Fqn,
   invariant,
   isSameHierarchy,
+  type ModelGlobals,
   parentFqn,
   type Relation,
   type RelationID
@@ -14,7 +15,8 @@ import { isArray, isString } from 'remeda'
 type Params = {
   elements: Record<Fqn, Element>
   relations: Record<RelationID, Relation>
-  // views: ElementView[]
+  // Optional for tests
+  globals?: ModelGlobals
 }
 
 type RelationEdge = {
@@ -41,24 +43,33 @@ function intersection<T>(a: Set<T>, b: Set<T>) {
  * Subject to change.
  */
 export class LikeC4ModelGraph {
-  #elements = new Map<Fqn, Element>()
+  readonly #elements = new Map<Fqn, Element>()
   // Parent element for given FQN
-  #parents = new Map<Fqn, Element>()
+  readonly #parents = new Map<Fqn, Element>()
   // Children elements for given FQN
-  #children = new Map<Fqn, Element[]>()
-  #rootElements = new Set<Element>()
+  readonly #children = new Map<Fqn, Element[]>()
+  readonly #rootElements = new Set<Element>()
 
-  #relations = new Map<RelationID, Relation>()
+  readonly #relations = new Map<RelationID, Relation>()
   // Incoming to an element or its descendants
-  #incoming = new MapRelations()
+  readonly #incoming = new MapRelations()
   // Outgoing from an element or its descendants
-  #outgoing = new MapRelations()
+  readonly #outgoing = new MapRelations()
   // Relationships inside the element, among descendants
-  #internal = new MapRelations()
+  readonly #internal = new MapRelations()
 
-  #cacheAscendingSiblings = new Map<Fqn, Element[]>()
+  readonly #cacheAscendingSiblings = new Map<Fqn, Element[]>()
 
-  constructor({ elements, relations }: Params) {
+  public readonly globals: ModelGlobals
+
+  constructor(
+    { elements, relations, globals }: Params
+  ) {
+    this.globals = globals ?? {
+      predicates: {},
+      dynamicPredicates: {},
+      styles: {}
+    }
     for (const el of Object.values(elements)) {
       this.addElement(el)
     }

package/src/model-graph/compute-view/__test__/fixture.ts

@@ -11,12 +11,17 @@ import {
   type ElementWhereExpr,
   type Expression as C4Expression,
   type Fqn,
+  type GlobalStyleID,
+  type IncomingExpr as C4IncomingExpr,
+  type InOutExpr as C4InOutExpr,
   isElementRef,
   isElementWhere,
   isRelationExpression,
   isRelationWhere,
   type NonEmptyArray,
+  type OutgoingExpr as C4OutgoingExpr,
   type Relation,
+  type RelationExpr as C4RelationExpr,
   type RelationID,
   type RelationshipArrowType,
   type RelationshipLineType,
@@ -24,6 +29,7 @@ import {
   type Tag,
   type ViewID,
   type ViewRule,
+  type ViewRuleGlobalStyle,
   type ViewRuleGroup,
   type ViewRulePredicate,
   type ViewRuleStyle,
@@ -327,11 +333,37 @@ export const fakeRelations = [
   })
 ]
 
+export const globalStyles = {
+  'mute_old': [{
+    targets: [$expr({
+      elementTag: 'old' as Tag,
+      isEqual: true
+    })],
+    style: {
+      color: 'muted'
+    }
+  }],
+  'red_next': [{
+    targets: [$expr({
+      elementTag: 'next' as Tag,
+      isEqual: true
+    })],
+    style: {
+      color: 'red'
+    }
+  }]
+} as const
+
 export type FakeRelationIds = (typeof fakeRelations)[number]['id']
 
 export const fakeModel = new LikeC4ModelGraph({
   elements: fakeElements,
-  relations: indexBy(fakeRelations, r => r.id)
+  relations: indexBy(fakeRelations, r => r.id),
+  globals: {
+    predicates: {},
+    dynamicPredicates: {},
+    styles: globalStyles
+  }
 })
 
 const emptyView = {
@@ -414,6 +446,49 @@ export function $where(
   }
 }
 
+export function $inout(
+  expr: InOutExpr | C4ElementExpression
+): C4InOutExpr {
+  const innerExpression = !isString(expr)
+    ? expr as C4Expression
+    : $expr(expr.replace(/->/g, '').trim() as ElementRefExpr) as any
+
+  return { inout: innerExpression }
+}
+
+export function $incoming(
+  expr: IncomingExpr | C4ElementExpression
+): C4IncomingExpr {
+  const innerExpression = !isString(expr)
+    ? expr as C4Expression
+    : $expr(expr.replace('-> ', '') as ElementRefExpr) as any
+
+  return { incoming: innerExpression }
+}
+
+export function $outgoing(
+  expr: OutgoingExpr | C4ElementExpression
+): C4OutgoingExpr {
+  const innerExpression = !isString(expr)
+    ? expr as C4Expression
+    : $expr(expr.replace(' ->', '') as ElementRefExpr) as any
+
+  return { outgoing: innerExpression }
+}
+
+export function $relation(
+  expr: RelationExpr
+): C4RelationExpr {
+  const [source, target] = expr.split(/ -> | <-> /)
+  const isBidirectional = expr.includes(' <-> ')
+
+  return {
+    source: $expr(source as ElementRefExpr) as any,
+    target: $expr(target as ElementRefExpr) as any,
+    ...(isBidirectional && { isBidirectional })
+  }
+}
+
 export function $expr(expr: Expression | C4Expression): C4Expression {
   if (!isString(expr)) {
     return expr as C4Expression
@@ -422,34 +497,13 @@ export function $expr(expr: Expression | C4Expression): C4Expression {
     return { wildcard: true }
   }
   if (expr.startsWith('->')) {
-    if (expr.endsWith('->')) {
-      return {
-        inout: $expr(expr.replace(/->/g, '').trim() as ElementRefExpr) as any
-      }
-    }
-    return {
-      incoming: $expr(expr.replace('-> ', '') as ElementRefExpr) as any
-    }
+    return expr.endsWith('->') ? $inout(expr as InOutExpr) : $incoming(expr as IncomingExpr)
   }
   if (expr.endsWith(' ->')) {
-    return {
-      outgoing: $expr(expr.replace(' ->', '') as ElementRefExpr) as any
-    }
-  }
-  if (expr.includes(' <-> ')) {
-    const [source, target] = expr.split(' <-> ')
-    return {
-      source: $expr(source as ElementRefExpr) as any,
-      target: $expr(target as ElementRefExpr) as any,
-      isBidirectional: true
-    }
+    return $outgoing(expr as OutgoingExpr)
   }
-  if (expr.includes(' -> ')) {
-    const [source, target] = expr.split(' -> ')
-    return {
-      source: $expr(source as ElementRefExpr) as any,
-      target: $expr(target as ElementRefExpr) as any
-    }
+  if (expr.includes(' -> ') || expr.includes(' <-> ')) {
+    return $relation(expr as RelationExpr)
   }
   if (expr.endsWith('._')) {
     return {
@@ -484,30 +538,34 @@ type CustomProps = {
 }
 export function $include(expr: Expression | C4Expression, props?: CustomProps): ViewRulePredicate {
   let _expr = props?.where ? $where(expr, props.where) : $expr(expr)
-  if (props?.with) {
-    if (isRelationExpression(_expr) || isRelationWhere(_expr)) {
-      _expr = {
-        customRelation: {
-          relation: _expr,
-          ...props.with as any
-        }
+  _expr = props?.with ? $with(_expr, props.with) : _expr
+  return {
+    include: [_expr]
+  }
+}
+export function $with(expr: C4Expression, props?: CustomProps['with']): C4CustomRelationExpr | C4CustomElementExpr {
+  if (isRelationExpression(expr) || isRelationWhere(expr)) {
+    return {
+      customRelation: {
+        relation: expr,
+        ...props as any
       }
-    } else if (isElementRef(_expr) || isElementWhere(_expr)) {
-      _expr = {
-        custom: {
-          expr: _expr,
-          ...props.with as any
-        }
+    }
+  } else if (isElementRef(expr) || isElementWhere(expr)) {
+    return {
+      custom: {
+        expr: expr,
+        ...props as any
       }
     }
   }
-  return {
-    include: [_expr]
-  }
+
+  throw 'Unsupported type of internal expression'
 }
-export function $exclude(expr: Expression | C4Expression): ViewRulePredicate {
+export function $exclude(expr: Expression | C4Expression, where?: WhereOperator<TestTag, string>): ViewRulePredicate {
+  let _expr = where ? $where(expr, where) : $expr(expr)
   return {
-    exclude: [$expr(expr)]
+    exclude: [_expr]
   }
 }
 export function $group(groupRules: ViewRuleGroup['groupRules']): ViewRuleGroup {
@@ -524,6 +582,18 @@ export function $style(element: ElementRefExpr, style: ViewRuleStyle['style']):
   }
 }
 
+type GlobalStyles = keyof typeof globalStyles
+type GlobalExpr = `style ${GlobalStyles}`
+export function $global(expr: GlobalExpr): ViewRuleGlobalStyle {
+  const [_t, id] = expr.split(' ') as [string, string]
+  if (_t === 'style') {
+    return {
+      styleId: id as GlobalStyleID
+    }
+  }
+  throw new Error('Invalid global expression')
+}
+
 export function computeView(
   ...args: [FakeElementIds, ViewRule | ViewRule[]] | [ViewRule | ViewRule[]]
 ) {