@likec4/core 1.31.0 → 1.32.0

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

@@ -1,18 +1,21 @@
 import type { Simplify } from 'type-fest'
-import { nonNullable } from '../../errors'
+import type { ElementModel } from '../../model'
 import {
+  type AnyAux,
+  type aux,
   type ComputedNode,
   type Element,
-  type Fqn,
-  type NodeId,
+  type scalar,
+  type Unknown,
   DefaultElementShape,
   DefaultThemeColor,
-  ElementKind,
+  GroupElementKind,
 } from '../../types'
+import { nonNullable } from '../../utils'
 import { compareByFqnHierarchically, parentFqn } from '../../utils/fqn'
 import { NodesGroup } from '../element-view/memory'
 
-function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<Fqn, ComputedNode>) {
+function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<string, ComputedNode>) {
   let parentNd
   while (!!node.parent && (parentNd = nodes.get(node.parent))) {
     const depth = parentNd.depth ?? 1
@@ -25,30 +28,27 @@ function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<Fqn, Comp
   }
 }
 
-const modelElementAsNodeSource = (element: Element): ComputedNodeSource => {
-  return {
-    ...element,
-    modelRef: 1,
-  }
-}
-
-// type ComputedNodeSource = Simplify<SetRequired<Partial<Omit<ComputedNode, 'parent' | 'children' | 'inEdges' | 'outEdges' | 'level' | 'depth'>>, 'id' | 'title' | 'kind'>>
-export type ComputedNodeSource = Simplify<
-  & Pick<ComputedNode, 'id' | 'title' | 'kind' | 'deploymentRef' | 'modelRef'>
-  & Partial<Omit<Element, 'id' | 'title' | 'kind'>>
+export type ComputedNodeSource<A extends AnyAux = Unknown> = Simplify<
+  & Pick<ComputedNode<A>, 'id' | 'title' | 'kind' | 'deploymentRef' | 'modelRef'>
+  & Partial<Omit<Element<A>, 'id' | 'title' | 'kind'>>
 >
 
-export function buildComputedNodesFromElements(elements: ReadonlyArray<Element>, groups?: NodesGroup[]) {
-  return buildComputedNodes(elements.map(modelElementAsNodeSource), groups)
+export function elementModelToNodeSource<A extends AnyAux>(el: ElementModel<A>): ComputedNodeSource<A> {
+  return {
+    ...el.$element,
+    tags: [...el.tags],
+    id: el.id as scalar.NodeId,
+    modelRef: el.id,
+  }
 }
 
-export function buildComputedNodes(
-  elements: ReadonlyArray<ComputedNodeSource>,
-  groups?: ReadonlyArray<NodesGroup>,
-): ReadonlyMap<Fqn, ComputedNode> {
-  const nodesMap = new Map<Fqn, ComputedNode>()
+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<Fqn, NodeId>()
+  const elementToGroup = new Map<aux.StrictFqn<A>, scalar.NodeId>()
 
   groups?.forEach(({ id, parent, viewRule, elements }) => {
     if (parent) {
@@ -57,8 +57,10 @@ export function buildComputedNodes(
     nodesMap.set(id, {
       id,
       parent,
-      kind: ElementKind.Group,
+      kind: GroupElementKind,
       title: viewRule.title ?? '',
+      description: null,
+      technology: null,
       color: viewRule.color ?? 'muted',
       shape: 'rectangle',
       children: [],
@@ -66,10 +68,7 @@ export function buildComputedNodes(
       outEdges: [],
       level: 0,
       depth: 0,
-      description: null,
-      technology: null,
-      tags: null,
-      links: null,
+      tags: [],
       style: {
         border: viewRule.border ?? 'dashed',
         opacity: viewRule.opacity ?? 0,
@@ -87,10 +86,10 @@ export function buildComputedNodes(
   // Ensure that parent nodes are created before child nodes
   Array.from(elements)
     .sort(compareByFqnHierarchically)
-    .forEach(({ id, style, kind, title, color, shape, ...el }) => {
+    .forEach(({ id, style, kind, title, color, shape, tags, ...el }) => {
       let parent = parentFqn(id)
       let level = 0
-      let parentNd: ComputedNode | undefined
+      let parentNd: ComputedNode<A> | undefined
       // Find the first ancestor that is already in the map
       while (parent) {
         parentNd = nodesMap.get(parent)
@@ -99,10 +98,12 @@ export function buildComputedNodes(
         }
         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(id)) {
-        parent = elementToGroup.get(id)!
-        parentNd = nodesMap.get(parent)!
+      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
@@ -115,18 +116,17 @@ export function buildComputedNodes(
         parentNd.children.push(id)
         level = parentNd.level + 1
       }
-      const node: ComputedNode = {
+      const node: ComputedNode<A> = {
         id,
         parent,
         kind,
         title,
+        description: null,
+        technology: null,
         level,
         color: color ?? DefaultThemeColor,
         shape: shape ?? DefaultElementShape,
-        description: null,
-        technology: null,
-        tags: null,
-        links: null,
+        tags: tags ?? [],
         children: [],
         inEdges: [],
         outEdges: [],
@@ -139,7 +139,7 @@ export function buildComputedNodes(
     })
 
   // Create new map and add elements in the same order as they were in the input
-  const orderedMap = new Map<Fqn, ComputedNode>()
+  const orderedMap = new Map<aux.NodeId, ComputedNode<A>>()
 
   groups?.forEach(({ id }) => {
     orderedMap.set(id, nonNullable(nodesMap.get(id)))

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

@@ -1,5 +1,5 @@
 import { entries, flatMap, groupBy, map, mapValues, pipe, piped, prop, sortBy, unique } from 'remeda'
-import type { ComputedNode, ElementNotation } from '../../types'
+import type { ComputedNode, NodeNotation } from '../../types'
 
 /**
  * Build element notations from computed nodes:
@@ -9,7 +9,7 @@ import type { ComputedNode, ElementNotation } from '../../types'
  * 4. For each group get unique kinds
  * 5. Unwind the groups
  */
-export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[] {
+export function buildElementNotations(nodes: ComputedNode<any>[]): NodeNotation[] {
   return pipe(
     nodes,
     groupBy(prop('notation')),
@@ -22,25 +22,25 @@ export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[]
             mapValues(
               piped(
                 map(prop('kind')),
-                unique()
-              )
+                unique(),
+              ),
             ),
             entries(),
             map(([color, kinds]) => ({
               kinds,
-              color
-            }))
-          )
+              color,
+            })),
+          ),
         ),
         entries(),
         flatMap(([shape, colors]) =>
           colors.map(({ color, kinds }) => ({
             shape,
             color,
-            kinds
+            kinds,
           }))
-        )
-      )
+        ),
+      ),
     ),
     entries(),
     flatMap(([title, shapes]) =>
@@ -48,7 +48,7 @@ export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[]
         title,
         shape,
         color,
-        kinds
+        kinds,
       }))
     ),
     sortBy(
@@ -56,8 +56,8 @@ export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[]
       prop('title'),
       [
         n => n.kinds.length,
-        'desc'
-      ]
-    )
+        'desc',
+      ],
+    ),
   )
 }

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

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

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

@@ -1,7 +1,6 @@
 import { last, reverse } from 'remeda'
-import { invariant } from '../../errors'
-import type { Fqn } from '../../types'
-import type { ComputedEdge, ComputedNode } from '../../types/view'
+import type { AnyAux, ComputedEdge, ComputedNode } from '../../types'
+import { invariant } from '../../utils'
 import { commonHead } from '../../utils/common-head'
 import { ancestorsOfNode } from './ancestorsOfNode'
 
@@ -9,7 +8,10 @@ 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(nodesMap: ReadonlyMap<Fqn, ComputedNode>, edges: ComputedEdge[]) {
+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)

package/src/compute-view/utils/merge-props-from-relationships.ts

@@ -1,9 +1,28 @@
 import { isTruthy, only, pickBy, pipe, reduce, unique } from 'remeda'
-import type { Color, DeploymentRelation, Link, Tag, ViewId } from '../../types'
-import type { ModelRelation, RelationshipArrowType, RelationshipKind, RelationshipLineType } from '../../types/relation'
+import type {
+  AnyAux,
+  aux,
+  Color,
+  DeploymentRelationship,
+  Link,
+  NonEmptyArray,
+  Relationship,
+  RelationshipArrowType,
+  RelationshipLineType,
+} from '../../types'
 import { isNonEmptyArray } from '../../utils'
 
-function pickRelationshipProps(relation: ModelRelation | DeploymentRelation) {
+function pickRelationshipProps<A extends AnyAux>(relation: Relationship<A> | DeploymentRelationship<A>): {
+  title?: string
+  description?: string | null
+  technology: string | null
+  kind: aux.RelationKind<A> | null
+  color: Color | null
+  line: RelationshipLineType | null
+  head: RelationshipArrowType | null
+  tail: RelationshipArrowType | null
+  navigateTo: aux.StrictViewId<A> | null
+} {
   const {
     title,
     description = null,
@@ -13,33 +32,47 @@ function pickRelationshipProps(relation: ModelRelation | DeploymentRelation) {
     line = null,
     head = null,
     tail = null,
-    navigateTo = null
+    navigateTo = null,
   } = relation
   return {
     // Pick description only if title is present
     ...(title && {
       title,
-      description
+      description,
     }),
     technology,
-    kind,
+    kind: kind as aux.RelationKind<A> | null,
     color,
     line,
     head,
     tail,
-    navigateTo
+    navigateTo: navigateTo as aux.StrictViewId<A> | null,
   }
 }
 
+export type MergedRelationshipProps<A extends AnyAux> = {
+  title?: string | null
+  description?: string
+  technology?: string
+  kind?: aux.RelationKind<A>
+  color?: Color
+  line?: RelationshipLineType
+  head?: RelationshipArrowType
+  tail?: RelationshipArrowType
+  navigateTo?: aux.StrictViewId<A>
+  tags?: NonEmptyArray<aux.Tag<A>>
+  links?: NonEmptyArray<Link>
+}
+
 /**
  * Merges properties from multiple relationships into a single object.
  * @param relations - The relationships to merge.
  * @param prefer - The relationship to prefer when merging.
  */
-export function mergePropsFromRelationships(
-  relations: Array<ModelRelation | DeploymentRelation>,
-  prefer?: ModelRelation | DeploymentRelation
-) {
+export function mergePropsFromRelationships<A extends AnyAux>(
+  relations: Array<Relationship<A> | DeploymentRelationship<A>>,
+  prefer?: Relationship<A> | DeploymentRelationship<A>,
+): MergedRelationshipProps<A> {
   const allprops = pipe(
     relations,
     reduce(
@@ -83,16 +116,16 @@ export function mergePropsFromRelationships(
         title: [] as string[],
         description: [] as string[],
         technology: [] as string[],
-        kind: [] as RelationshipKind[],
+        kind: [] as aux.RelationKind<A>[],
         head: [] as RelationshipArrowType[],
         tail: [] as RelationshipArrowType[],
         color: [] as Color[],
-        tags: [] as Tag[],
+        tags: [] as aux.Tag<A>[],
         links: [] as Link[],
         line: [] as RelationshipLineType[],
-        navigateTo: [] as ViewId[]
-      }
-    )
+        navigateTo: [] as aux.ViewId<A>[],
+      },
+    ),
   )
 
   let technology = only(allprops.technology)
@@ -112,17 +145,16 @@ export function mergePropsFromRelationships(
       line: only(allprops.line),
       navigateTo: only(allprops.navigateTo),
       ...isNonEmptyArray(allprops.links) && { links: allprops.links },
-      ...isNonEmptyArray(tags) && { tags }
+      ...isNonEmptyArray(tags) && { tags },
     },
-    isTruthy
+    isTruthy,
   )
 
   if (prefer) {
     return {
       ...merged,
-      ...pickBy(pickRelationshipProps(prefer), isTruthy)
+      ...pickBy(pickRelationshipProps(prefer), isTruthy),
     }
   }
   return merged
 }
-export type MergedRelationshipProps = ReturnType<typeof mergePropsFromRelationships>

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

@@ -1,35 +1,35 @@
-import { nonexhaustive } from '../../errors'
-import { ModelLayer } from '../../types'
-import { whereOperatorAsPredicate } from '../../types/operators'
-import type { ModelRelation } from '../../types/relation'
-import type { ComputedNode } from '../../types/view'
+import type { AnyAux, aux, ComputedNode } from '../../types'
+import { ModelRelationExpr, whereOperatorAsPredicate } from '../../types'
+import { nonexhaustive } from '../../utils'
 import { elementExprToPredicate } from './elementExpressionToPredicate'
 
 type Predicate<T> = (x: T) => boolean
-export type FilterableEdge = Pick<ModelRelation, 'kind' | 'tags'> & {
-  source: ComputedNode
-  target: ComputedNode
+export type FilterableEdge<A extends AnyAux> = {
+  tags?: aux.Tags<A> | null | undefined
+  kind?: string
+  source: ComputedNode<A>
+  target: ComputedNode<A>
 }
 
-export function relationExpressionToPredicates<T extends FilterableEdge>(
-  expr: ModelLayer.AnyRelationExpr,
+export function relationExpressionToPredicates<A extends AnyAux, T extends FilterableEdge<A>>(
+  expr: ModelRelationExpr.Any<A>,
 ): Predicate<T> {
   switch (true) {
-    case ModelLayer.RelationExpr.isCustom(expr): {
+    case ModelRelationExpr.isCustom(expr): {
       return relationExpressionToPredicates(expr.customRelation.expr)
     }
-    case ModelLayer.RelationExpr.isWhere(expr): {
+    case ModelRelationExpr.isWhere(expr): {
       const predicate = relationExpressionToPredicates(expr.where.expr)
       const where = whereOperatorAsPredicate(expr.where.condition)
       return e =>
         predicate(e) && where({
-          source: { tags: e.source.tags, kind: e.source.kind },
-          target: { tags: e.target.tags, kind: e.target.kind },
+          source: { tags: e.source.tags, kind: e.source.kind as aux.AllKinds<A> },
+          target: { tags: e.target.tags, kind: e.target.kind as aux.AllKinds<A> },
           ...(e.tags && { tags: e.tags }),
-          ...(e.kind && { kind: e.kind }),
+          ...(e.kind && { kind: e.kind as aux.AllKinds<A> }),
         })
     }
-    case ModelLayer.RelationExpr.isDirect(expr): {
+    case ModelRelationExpr.isDirect(expr): {
       const isSource = elementExprToPredicate(expr.source)
       const isTarget = elementExprToPredicate(expr.target)
       return edge => {
@@ -37,15 +37,15 @@ export function relationExpressionToPredicates<T extends FilterableEdge>(
           || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
       }
     }
-    case ModelLayer.RelationExpr.isInOut(expr): {
+    case ModelRelationExpr.isInOut(expr): {
       const isInOut = elementExprToPredicate(expr.inout)
       return edge => isInOut(edge.source) || isInOut(edge.target)
     }
-    case ModelLayer.RelationExpr.isIncoming(expr): {
+    case ModelRelationExpr.isIncoming(expr): {
       const isTarget = elementExprToPredicate(expr.incoming)
       return edge => isTarget(edge.target)
     }
-    case ModelLayer.RelationExpr.isOutgoing(expr): {
+    case ModelRelationExpr.isOutgoing(expr): {
       const isSource = elementExprToPredicate(expr.outgoing)
       return edge => isSource(edge.source)
     }

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

@@ -1,21 +1,22 @@
 import { unique, values } from 'remeda'
-import { type ExtendsElementView, type LikeC4View, isElementView, isExtendsElementView } from '../../types/view'
+import { type LikeC4View, isElementView, isExtendsElementView } from '../../types/view'
 
 import Graph from 'graphology'
 import { topologicalSort } from 'graphology-dag/topological-sort'
 import willCreateCycle from 'graphology-dag/will-create-cycle'
+import type { AnyAux, aux, ParsedElementView } from '../../types'
 import { isNonEmptyArray } from '../../utils'
 /**
  * Resolve rules of extended views
  * (Removes invalid views)
  */
-export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
+export function resolveRulesExtendedViews<A extends AnyAux, V extends Record<any, LikeC4View<A>>>(
   unresolvedViews: V,
 ): V {
-  const g = new Graph<{ view: LikeC4View }>({
+  const g = new Graph<{ view: LikeC4View<A> }>({
     type: 'directed',
   })
-  const extendedViews = [] as ExtendsElementView<any, any>[]
+  const extendedViews = [] as ParsedElementView<A>[]
   for (const view of values(unresolvedViews)) {
     g.addNode(view.id, { view })
     if (isExtendsElementView(view)) {
@@ -57,7 +58,7 @@ export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
     const tags = unique([
       ...(extendsFrom.tags ?? []),
       ...(view.tags ?? []),
-    ])
+    ]) as aux.Tags<A>
 
     const links = [
       ...(extendsFrom.links ?? []),
@@ -69,12 +70,12 @@ export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
       ...view,
       title: view.title ?? extendsFrom.title ?? null,
       description: view.description ?? extendsFrom.description ?? null,
-      tags: isNonEmptyArray(tags) ? tags : null,
+      tags,
       links: isNonEmptyArray(links) ? links : null,
       rules: [...extendsFrom.rules, ...view.rules],
     }
     return acc
-  }, {} as Record<string, LikeC4View>) as V
+  }, {} as Record<string, LikeC4View<A>>) as V
 
   // forEachNodeInTopologicalOrder(g, (_id, { view }) => {
 

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

@@ -1,32 +1,37 @@
 import { isNullish } from 'remeda'
-import { nonexhaustive } from '../../errors'
 import {
-  type DynamicView,
+  type AnyAux,
+  type DynamicViewIncludeRule,
   type DynamicViewRule,
-  type ElementView,
+  type ElementViewPredicate,
+  type ElementViewRule,
+  type ModelGlobals,
+  type ParsedDynamicView,
+  type ParsedElementView,
+  type ViewRuleGlobalPredicateRef,
+  type ViewRuleGlobalStyle,
   isDynamicView,
   isElementView,
   isViewRuleGlobalPredicateRef,
   isViewRuleGlobalStyle,
-  type ModelGlobals,
-  type ViewRule,
-  type ViewRuleGlobalPredicateRef,
-  type ViewRuleGlobalStyle
 } from '../../types'
+import { nonexhaustive } from '../../utils'
 
-export function resolveGlobalRules<V extends DynamicView | ElementView>(
-  view: V,
-  globals: ModelGlobals
-): V {
+export function resolveGlobalRules<A extends AnyAux>(
+  view: ParsedElementView<A> | ParsedDynamicView<A>,
+  globals: ModelGlobals<A>,
+) {
   if (isElementView(view)) {
     return {
       ...view,
-      rules: resolveGlobalRulesInElementView(view.rules, globals)
+      rules: resolveGlobalRulesInElementView(view.rules, globals),
     }
-  } else if (isDynamicView(view)) {
+  }
+
+  if (isDynamicView(view)) {
     return {
       ...view,
-      rules: resolveGlobalRulesInDynamicView(view.rules, globals)
+      rules: resolveGlobalRulesInDynamicView(view.rules, globals),
     }
   }
   nonexhaustive(view)
@@ -34,17 +39,17 @@ export function resolveGlobalRules<V extends DynamicView | ElementView>(
 
 type ViewRuleGlobal = ViewRuleGlobalPredicateRef | ViewRuleGlobalStyle
 
-export function resolveGlobalRulesInElementView(
-  rules: ViewRule[],
-  globals: ModelGlobals
-): Array<Exclude<ViewRule, ViewRuleGlobal>> {
+export function resolveGlobalRulesInElementView<M extends AnyAux>(
+  rules: ElementViewRule<M>[],
+  globals: ModelGlobals<M>,
+): Array<Exclude<ElementViewRule<M>, ViewRuleGlobal>> {
   return rules.reduce((acc, rule) => {
     if (isViewRuleGlobalPredicateRef(rule)) {
       const globalPredicates = globals.predicates[rule.predicateId]
       if (isNullish(globalPredicates)) {
         return acc
       }
-      return acc.concat(globalPredicates)
+      return acc.concat(globalPredicates as ElementViewPredicate<M>[])
     }
     if (isViewRuleGlobalStyle(rule)) {
       const globalStyles = globals.styles[rule.styleId]
@@ -55,20 +60,20 @@ export function resolveGlobalRulesInElementView(
     }
     acc.push(rule)
     return acc
-  }, [] as Array<Exclude<ViewRule, ViewRuleGlobal>>)
+  }, [] as Array<Exclude<ElementViewRule<M>, ViewRuleGlobal>>)
 }
 
-export function resolveGlobalRulesInDynamicView(
-  rules: DynamicViewRule[],
-  globals: ModelGlobals
-): Array<Exclude<DynamicViewRule, ViewRuleGlobal>> {
+export function resolveGlobalRulesInDynamicView<M extends AnyAux>(
+  rules: DynamicViewRule<M>[],
+  globals: ModelGlobals<M>,
+): Array<Exclude<DynamicViewRule<M>, ViewRuleGlobal>> {
   return rules.reduce((acc, rule) => {
     if (isViewRuleGlobalPredicateRef(rule)) {
       const globalPredicates = globals.dynamicPredicates[rule.predicateId]
       if (isNullish(globalPredicates)) {
         return acc
       }
-      return acc.concat(globalPredicates)
+      return acc.concat(globalPredicates as DynamicViewIncludeRule<M>[])
     }
     if (isViewRuleGlobalStyle(rule)) {
       const globalStyles = globals.styles[rule.styleId]
@@ -79,5 +84,5 @@ export function resolveGlobalRulesInDynamicView(
     }
     acc.push(rule)
     return acc
-  }, [] as Array<Exclude<DynamicViewRule, ViewRuleGlobal>>)
+  }, [] as Array<Exclude<DynamicViewRule<M>, ViewRuleGlobal>>)
 }