@likec4/language-server 1.1.1 → 1.2.0

package/contrib/likec4.monarch.ts

@@ -1,12 +1,12 @@
 // Monarch syntax highlighting for the likec4 language.
 export default {
     keywords: [
-        'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','border','browser','color','crow','cylinder','dashed','description','diamond','dotted','element','exclude','extend','extends','gray','green','head','icon','include','indigo','it','kind','line','link','mobile','model','muted','navigateTo','none','normal','odiamond','of','onormal','opacity','open','person','primary','queue','rectangle','red','relationship','secondary','shape','sky','slate','solid','specification','storage','style','tag','tail','technology','this','title','vee','view','views','with'
+        'BottomTop','LeftRight','RightLeft','TopBottom','amber','autoLayout','blue','border','browser','color','crow','cylinder','dashed','description','diamond','dotted','dynamic','element','exclude','extend','extends','gray','green','head','icon','include','indigo','it','kind','line','link','mobile','model','muted','navigateTo','none','normal','odiamond','of','onormal','opacity','open','person','primary','queue','rectangle','red','relationship','secondary','shape','sky','slate','solid','specification','storage','style','tag','tail','technology','this','title','vee','view','views','with'
     ],
     operators: [
-        '*','->','<->'
+        '*','->','<-','<->'
     ],
-    symbols: /\*|->|-\[|<->|\]->|\{|\}/,
+    symbols: /\*|->|-\[|<-|<->|\]->|\{|\}/,
 
     tokenizer: {
         initial: [
@@ -23,7 +23,7 @@ export default {
             { regex: /,/, action: {"token":"Comma"} },
             { regex: /\b\d+%/, action: {"token":"Percent"} },
             { regex: /"[^"]*"|'[^']*'/, action: {"token":"string"} },
-            { regex: /\b(_+[a-zA-Z]|[a-zA-Z])[\w_-]*/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"IdTerminal"} }} },
+            { regex: /\b[_]*[a-zA-Z][_-\w]*/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"IdTerminal"} }} },
             { include: '@whitespace' },
             { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },
         ],

package/contrib/likec4.tmLanguage.json

@@ -12,7 +12,7 @@
     },
     {
       "name": "keyword.control.likec4",
-      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|border|browser|color|crow|cylinder|dashed|description|diamond|dotted|element|exclude|extend|extends|gray|green|head|icon|include|indigo|it|kind|line|link|mobile|model|muted|navigateTo|none|normal|odiamond|of|onormal|opacity|open|person|primary|queue|rectangle|red|relationship|secondary|shape|sky|slate|solid|specification|storage|style|tag|tail|technology|this|title|vee|view|views|with)\\b"
+      "match": "\\b(BottomTop|LeftRight|RightLeft|TopBottom|amber|autoLayout|blue|border|browser|color|crow|cylinder|dashed|description|diamond|dotted|dynamic|element|exclude|extend|extends|gray|green|head|icon|include|indigo|it|kind|line|link|mobile|model|muted|navigateTo|none|normal|odiamond|of|onormal|opacity|open|person|primary|queue|rectangle|red|relationship|secondary|shape|sky|slate|solid|specification|storage|style|tag|tail|technology|this|title|vee|view|views|with)\\b"
     },
     {
       "name": "string.quoted.double.likec4",

package/dist/ast.d.ts

@@ -14,6 +14,9 @@ declare module './generated/ast' {
     interface ElementView {
         [idattr]?: c4.ViewID | undefined;
     }
+    interface DynamicView {
+        [idattr]?: c4.ViewID | undefined;
+    }
 }
 type ParsedElementStyle = {
     shape?: c4.ElementShape;
@@ -57,19 +60,32 @@ export interface ParsedAstRelation {
     links?: c4.NonEmptyArray<string>;
 }
 export interface ParsedAstElementView {
+    __: 'element';
     id: c4.ViewID;
     viewOf?: c4.Fqn;
     extends?: c4.ViewID;
     astPath: string;
-    title?: string;
-    description?: string;
-    tags?: c4.NonEmptyArray<c4.Tag>;
-    links?: c4.NonEmptyArray<string>;
+    title: string | null;
+    description: string | null;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<string> | null;
     rules: c4.ViewRule[];
 }
-export declare const ElementViewOps: {
-    writeId(node: ast.ElementView, id: c4.ViewID): ast.ElementView;
-    readId(node: ast.ElementView): c4.ViewID | undefined;
+export interface ParsedAstDynamicView {
+    __: 'dynamic';
+    id: c4.ViewID;
+    astPath: string;
+    title: string | null;
+    description: string | null;
+    tags: c4.NonEmptyArray<c4.Tag> | null;
+    links: c4.NonEmptyArray<string> | null;
+    steps: c4.DynamicViewStep[];
+    rules: Array<c4.DynamicViewRule>;
+}
+export type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView;
+export declare const ViewOps: {
+    writeId<T extends ast.LikeC4View>(node: T, id: c4.ViewID): T;
+    readId(node: ast.LikeC4View): c4.ViewID | undefined;
 };
 export declare const ElementOps: {
     writeId(node: ast.Element, id: c4.Fqn | null): ast.Element;
@@ -87,7 +103,7 @@ export interface LikeC4DocumentProps {
     c4Specification?: ParsedAstSpecification;
     c4Elements?: ParsedAstElement[];
     c4Relations?: ParsedAstRelation[];
-    c4Views?: ParsedAstElementView[];
+    c4Views?: ParsedAstView[];
     c4fqns?: MultiMap<c4.Fqn, DocFqnIndexEntry>;
 }
 export interface LikeC4LangiumDocument extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps {
@@ -102,14 +118,14 @@ export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is Li
 export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;
 type Guard<N extends AstNode> = (n: AstNode) => n is N;
 type Guarded<G> = G extends Guard<infer N> ? N : never;
-declare const isValidatableAstNode: (n: AstNode) => n is ast.DescedantsExpr | ast.ElementKindExpr | ast.ElementRef | ast.ElementTagExpr | ast.ExpandElementExpr | ast.WildcardExpr | ast.ElementStringProperty | ast.LinkProperty | ast.StyleProperties | ast.ExplicitRelation | ast.ImplicitRelation | ast.RelationStringProperty | ast.RelationStyleProperty | ast.ViewStringProperty | ast.ViewRuleAutoLayout | ast.ExcludePredicate | ast.IncludePredicate | ast.ViewRuleStyle | ast.CustomElementExpr | ast.InOutExpr | ast.IncomingExpr | ast.OutgoingExpr | ast.RelationExpr | ast.SpecificationRelationshipKind | ast.RelationBody | ast.ElementBody | ast.ExtendElementBody | ast.Model | ast.Element | ast.ExtendElement | ast.SpecificationRule | ast.CustomElementExprBody | ast.SpecificationElementKind | ast.ElementViewBody | ast.ElementView | ast.ModelViews | ast.Tags | ast.SpecificationTag;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.DynamicViewRulePredicate | ast.ViewRuleAutoLayout | ast.ViewRuleStyle | ast.DescedantsExpr | ast.ElementKindExpr | ast.ElementRef | ast.ElementTagExpr | ast.ExpandElementExpr | ast.WildcardExpr | ast.ElementStringProperty | ast.LinkProperty | ast.StyleProperties | ast.DynamicView | ast.ElementView | ast.ExplicitRelation | ast.ImplicitRelation | ast.RelationStringProperty | ast.RelationStyleProperty | ast.ColorProperty | ast.BorderProperty | ast.IconProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewStringProperty | ast.ExcludePredicate | ast.IncludePredicate | ast.CustomElementExpr | ast.InOutExpr | ast.IncomingExpr | ast.OutgoingExpr | ast.RelationExpr | ast.SpecificationRelationshipKind | ast.RelationBody | ast.ElementBody | ast.ExtendElementBody | ast.Model | ast.Element | ast.ExtendElement | ast.SpecificationRule | ast.CustomElementExprBody | ast.DynamicViewBody | ast.ElementViewBody | ast.ModelViews | ast.SpecificationElementKind | ast.DynamicViewStep | ast.Tags | ast.SpecificationTag;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;
-    invalidNodes: WeakSet<ast.DescedantsExpr | ast.ElementKindExpr | ast.ElementRef | ast.ElementTagExpr | ast.ExpandElementExpr | ast.WildcardExpr | ast.ElementStringProperty | ast.LinkProperty | ast.StyleProperties | ast.ExplicitRelation | ast.ImplicitRelation | ast.RelationStringProperty | ast.RelationStyleProperty | ast.ViewStringProperty | ast.ViewRuleAutoLayout | ast.ExcludePredicate | ast.IncludePredicate | ast.ViewRuleStyle | ast.CustomElementExpr | ast.InOutExpr | ast.IncomingExpr | ast.OutgoingExpr | ast.RelationExpr | ast.SpecificationRelationshipKind | ast.RelationBody | ast.ElementBody | ast.ExtendElementBody | ast.Model | ast.Element | ast.ExtendElement | ast.SpecificationRule | ast.CustomElementExprBody | ast.SpecificationElementKind | ast.ElementViewBody | ast.ElementView | ast.ModelViews | ast.Tags | ast.SpecificationTag>;
+    invalidNodes: WeakSet<ast.DynamicViewRulePredicate | ast.ViewRuleAutoLayout | ast.ViewRuleStyle | ast.DescedantsExpr | ast.ElementKindExpr | ast.ElementRef | ast.ElementTagExpr | ast.ExpandElementExpr | ast.WildcardExpr | ast.ElementStringProperty | ast.LinkProperty | ast.StyleProperties | ast.DynamicView | ast.ElementView | ast.ExplicitRelation | ast.ImplicitRelation | ast.RelationStringProperty | ast.RelationStyleProperty | ast.ColorProperty | ast.BorderProperty | ast.IconProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewStringProperty | ast.ExcludePredicate | ast.IncludePredicate | ast.CustomElementExpr | ast.InOutExpr | ast.IncomingExpr | ast.OutgoingExpr | ast.RelationExpr | ast.SpecificationRelationshipKind | ast.RelationBody | ast.ElementBody | ast.ExtendElementBody | ast.Model | ast.Element | ast.ExtendElement | ast.SpecificationRule | ast.CustomElementExprBody | ast.DynamicViewBody | ast.ElementViewBody | ast.ModelViews | ast.SpecificationElementKind | ast.DynamicViewStep | ast.Tags | ast.SpecificationTag>;
 };
 export type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
-export declare function streamModel(doc: LikeC4LangiumDocument): Generator<ast.Relation | ast.Element, void, unknown>;
+export declare function streamModel(doc: LikeC4LangiumDocument, isValid: ChecksFromDiagnostics['isValid']): Generator<ast.Relation | ast.Element, void, unknown>;
 export declare function resolveRelationPoints(node: ast.Relation): {
     source: ast.Element;
     target: ast.Element;

package/dist/ast.js

@@ -13,7 +13,7 @@ import * as ast from "./generated/ast.js";
 import { LikeC4LanguageMetaData } from "./generated/module.js";
 export { ast };
 const idattr = Symbol.for("idattr");
-export const ElementViewOps = {
+export const ViewOps = {
   writeId(node, id) {
     node[idattr] = id;
     return node;
@@ -62,11 +62,16 @@ function validatableAstNodeGuards(predicates) {
 const isValidatableAstNode = validatableAstNodeGuards([
   ast.isCustomElementExprBody,
   ast.isViewRulePredicateExpr,
+  ast.isDynamicViewRulePredicate,
+  ast.isViewProperty,
+  ast.isStyleProperty,
   ast.isTags,
   ast.isViewRule,
-  ast.isViewProperty,
+  ast.isDynamicViewRule,
+  ast.isDynamicViewStep,
   ast.isElementViewBody,
-  ast.isElementView,
+  ast.isDynamicViewBody,
+  ast.isLikeC4View,
   ast.isRelationProperty,
   ast.isRelationBody,
   ast.isRelation,
@@ -79,8 +84,8 @@ const isValidatableAstNode = validatableAstNodeGuards([
   ast.isSpecificationRelationshipKind,
   ast.isSpecificationTag,
   ast.isSpecificationRule,
-  ast.isModel,
-  ast.isModelViews
+  ast.isModelViews,
+  ast.isModel
 ]);
 export function checksFromDiagnostics(doc) {
   const errors = doc.diagnostics?.filter((d) => d.severity === DiagnosticSeverity.Error) ?? [];
@@ -95,8 +100,7 @@ export function checksFromDiagnostics(doc) {
     invalidNodes
   };
 }
-export function* streamModel(doc) {
-  const { isValid } = checksFromDiagnostics(doc);
+export function* streamModel(doc, isValid) {
   const traverseStack = doc.parseResult.value.models.flatMap((m) => isValid(m) ? m.elements : []);
   const relations = [];
   let el;

package/dist/generated/ast.d.ts

@@ -27,6 +27,9 @@ export type ArrowType = 'crow' | 'diamond' | 'none' | 'normal' | 'odiamond' | 'o
 export declare function isArrowType(item: unknown): item is ArrowType;
 export type BorderStyleValue = 'none' | LineOptions;
 export declare function isBorderStyleValue(item: unknown): item is BorderStyleValue;
+export type DynamicViewRule = DynamicViewRulePredicate | ViewRuleAutoLayout | ViewRuleStyle;
+export declare const DynamicViewRule = "DynamicViewRule";
+export declare function isDynamicViewRule(item: unknown): item is DynamicViewRule;
 export type ElementExpr = DescedantsExpr | ElementKindExpr | ElementRef | ElementTagExpr | ExpandElementExpr | WildcardExpr;
 export declare const ElementExpr = "ElementExpr";
 export declare function isElementExpr(item: unknown): item is ElementExpr;
@@ -37,6 +40,9 @@ export type ElementShape = 'browser' | 'cylinder' | 'mobile' | 'person' | 'queue
 export declare function isElementShape(item: unknown): item is ElementShape;
 export type Id = 'element' | 'model' | ArrowType | ElementShape | LineOptions | ThemeColor | string;
 export declare function isId(item: unknown): item is Id;
+export type LikeC4View = DynamicView | ElementView;
+export declare const LikeC4View = "LikeC4View";
+export declare function isLikeC4View(item: unknown): item is LikeC4View;
 export type LineOptions = 'dashed' | 'dotted' | 'solid';
 export declare function isLineOptions(item: unknown): item is LineOptions;
 export type Relation = ExplicitRelation | ImplicitRelation;
@@ -96,7 +102,7 @@ export interface ColorProperty extends AstNode {
 export declare const ColorProperty = "ColorProperty";
 export declare function isColorProperty(item: unknown): item is ColorProperty;
 export interface CustomElementExpr extends AstNode {
-    readonly $container: ExcludePredicate | IncludePredicate;
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
     readonly $type: 'CustomElementExpr';
     body: CustomElementExprBody;
     target: ElementExpr;
@@ -111,12 +117,48 @@ export interface CustomElementExprBody extends AstNode {
 export declare const CustomElementExprBody = "CustomElementExprBody";
 export declare function isCustomElementExprBody(item: unknown): item is CustomElementExprBody;
 export interface DescedantsExpr extends AstNode {
-    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
     readonly $type: 'DescedantsExpr';
     parent: ElementRef;
 }
 export declare const DescedantsExpr = "DescedantsExpr";
 export declare function isDescedantsExpr(item: unknown): item is DescedantsExpr;
+export interface DynamicView extends AstNode {
+    readonly $container: ModelViews;
+    readonly $type: 'DynamicView';
+    body: DynamicViewBody;
+    name: Id;
+}
+export declare const DynamicView = "DynamicView";
+export declare function isDynamicView(item: unknown): item is DynamicView;
+export interface DynamicViewBody extends AstNode {
+    readonly $container: DynamicView;
+    readonly $type: 'DynamicViewBody';
+    props: Array<ViewProperty>;
+    rules: Array<DynamicViewRule>;
+    steps: Array<DynamicViewStep>;
+    tags?: Tags;
+}
+export declare const DynamicViewBody = "DynamicViewBody";
+export declare function isDynamicViewBody(item: unknown): item is DynamicViewBody;
+export interface DynamicViewRulePredicate extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewRulePredicate';
+    expressions: Array<ViewRulePredicateExpr>;
+}
+export declare const DynamicViewRulePredicate = "DynamicViewRulePredicate";
+export declare function isDynamicViewRulePredicate(item: unknown): item is DynamicViewRulePredicate;
+export interface DynamicViewStep extends AstNode {
+    readonly $container: DynamicViewBody;
+    readonly $type: 'DynamicViewStep';
+    isBackward: boolean;
+    kind?: Reference<RelationshipKind>;
+    source: ElementRef;
+    target: ElementRef;
+    title?: string;
+}
+export declare const DynamicViewStep = "DynamicViewStep";
+export declare function isDynamicViewStep(item: unknown): item is DynamicViewStep;
 export interface Element extends AstNode {
     readonly $container: ElementBody | ExtendElementBody | Model;
     readonly $type: 'Element';
@@ -144,7 +186,7 @@ export interface ElementKind extends AstNode {
 export declare const ElementKind = "ElementKind";
 export declare function isElementKind(item: unknown): item is ElementKind;
 export interface ElementKindExpr extends AstNode {
-    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
     readonly $type: 'ElementKindExpr';
     isEqual: boolean;
     kind: Reference<ElementKind>;
@@ -152,7 +194,7 @@ export interface ElementKindExpr extends AstNode {
 export declare const ElementKindExpr = "ElementKindExpr";
 export declare function isElementKindExpr(item: unknown): item is ElementKindExpr;
 export interface ElementRef extends AstNode {
-    readonly $container: CustomElementExpr | DescedantsExpr | ElementRef | ElementView | ExcludePredicate | ExpandElementExpr | ExplicitRelation | ImplicitRelation | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $container: CustomElementExpr | DescedantsExpr | DynamicViewRulePredicate | DynamicViewStep | ElementRef | ElementView | ExcludePredicate | ExpandElementExpr | ExplicitRelation | ImplicitRelation | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
     readonly $type: 'ElementRef';
     el: Reference<Element>;
     parent?: ElementRef;
@@ -168,7 +210,7 @@ export interface ElementStringProperty extends AstNode {
 export declare const ElementStringProperty = "ElementStringProperty";
 export declare function isElementStringProperty(item: unknown): item is ElementStringProperty;
 export interface ElementTagExpr extends AstNode {
-    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
     readonly $type: 'ElementTagExpr';
     isEqual: boolean;
     tag: Reference<Tag>;
@@ -195,7 +237,7 @@ export interface ElementViewBody extends AstNode {
 export declare const ElementViewBody = "ElementViewBody";
 export declare function isElementViewBody(item: unknown): item is ElementViewBody;
 export interface ElementViewRef extends AstNode {
-    readonly $container: ElementView | NavigateToProperty;
+    readonly $container: ElementView;
     readonly $type: 'ElementViewRef';
     view: Reference<ElementView>;
 }
@@ -209,7 +251,7 @@ export interface ExcludePredicate extends AstNode {
 export declare const ExcludePredicate = "ExcludePredicate";
 export declare function isExcludePredicate(item: unknown): item is ExcludePredicate;
 export interface ExpandElementExpr extends AstNode {
-    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
     readonly $type: 'ExpandElementExpr';
     parent: ElementRef;
 }
@@ -277,14 +319,14 @@ export interface IncludePredicate extends AstNode {
 export declare const IncludePredicate = "IncludePredicate";
 export declare function isIncludePredicate(item: unknown): item is IncludePredicate;
 export interface IncomingExpr extends AstNode {
-    readonly $container: ExcludePredicate | InOutExpr | IncludePredicate;
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | InOutExpr | IncludePredicate;
     readonly $type: 'IncomingExpr';
     to: ElementExpr;
 }
 export declare const IncomingExpr = "IncomingExpr";
 export declare function isIncomingExpr(item: unknown): item is IncomingExpr;
 export interface InOutExpr extends AstNode {
-    readonly $container: ExcludePredicate | IncludePredicate;
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
     readonly $type: 'InOutExpr';
     inout: IncomingExpr;
 }
@@ -307,7 +349,7 @@ export interface LineProperty extends AstNode {
 export declare const LineProperty = "LineProperty";
 export declare function isLineProperty(item: unknown): item is LineProperty;
 export interface LinkProperty extends AstNode {
-    readonly $container: ElementBody | ElementViewBody | RelationBody;
+    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | RelationBody;
     readonly $type: 'LinkProperty';
     key: 'link';
     value: Uri;
@@ -326,14 +368,14 @@ export interface ModelViews extends AstNode {
     readonly $container: LikeC4Grammar;
     readonly $type: 'ModelViews';
     name: 'views';
-    views: Array<ElementView>;
+    views: Array<DynamicView | ElementView>;
 }
 export declare const ModelViews = "ModelViews";
 export declare function isModelViews(item: unknown): item is ModelViews;
 export interface NavigateToProperty extends AstNode {
     readonly $container: CustomElementExprBody;
     readonly $type: 'NavigateToProperty';
-    value: ElementViewRef;
+    value: ViewRef;
 }
 export declare const NavigateToProperty = "NavigateToProperty";
 export declare function isNavigateToProperty(item: unknown): item is NavigateToProperty;
@@ -346,7 +388,7 @@ export interface OpacityProperty extends AstNode {
 export declare const OpacityProperty = "OpacityProperty";
 export declare function isOpacityProperty(item: unknown): item is OpacityProperty;
 export interface OutgoingExpr extends AstNode {
-    readonly $container: ExcludePredicate | IncludePredicate;
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
     readonly $type: 'OutgoingExpr';
     from: ElementExpr;
 }
@@ -361,7 +403,7 @@ export interface RelationBody extends AstNode {
 export declare const RelationBody = "RelationBody";
 export declare function isRelationBody(item: unknown): item is RelationBody;
 export interface RelationExpr extends AstNode {
-    readonly $container: ExcludePredicate | IncludePredicate;
+    readonly $container: DynamicViewRulePredicate | ExcludePredicate | IncludePredicate;
     readonly $type: 'RelationExpr';
     isBidirectional: boolean;
     source: ElementExpr;
@@ -449,21 +491,28 @@ export interface Tag extends AstNode {
 export declare const Tag = "Tag";
 export declare function isTag(item: unknown): item is Tag;
 export interface Tags extends AstNode {
-    readonly $container: ElementBody | ElementViewBody | ExplicitRelation | ImplicitRelation | RelationBody;
+    readonly $container: DynamicViewBody | ElementBody | ElementViewBody | ExplicitRelation | ImplicitRelation | RelationBody;
     readonly $type: 'Tags';
     value: Array<Reference<Tag>>;
 }
 export declare const Tags = "Tags";
 export declare function isTags(item: unknown): item is Tags;
+export interface ViewRef extends AstNode {
+    readonly $container: NavigateToProperty;
+    readonly $type: 'ViewRef';
+    view: Reference<LikeC4View>;
+}
+export declare const ViewRef = "ViewRef";
+export declare function isViewRef(item: unknown): item is ViewRef;
 export interface ViewRuleAutoLayout extends AstNode {
-    readonly $container: ElementViewBody;
+    readonly $container: DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewRuleAutoLayout';
     direction: ViewLayoutDirection;
 }
 export declare const ViewRuleAutoLayout = "ViewRuleAutoLayout";
 export declare function isViewRuleAutoLayout(item: unknown): item is ViewRuleAutoLayout;
 export interface ViewRuleStyle extends AstNode {
-    readonly $container: ElementViewBody;
+    readonly $container: DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewRuleStyle';
     styleprops: Array<StyleProperty>;
     targets: Array<ElementExpr>;
@@ -471,7 +520,7 @@ export interface ViewRuleStyle extends AstNode {
 export declare const ViewRuleStyle = "ViewRuleStyle";
 export declare function isViewRuleStyle(item: unknown): item is ViewRuleStyle;
 export interface ViewStringProperty extends AstNode {
-    readonly $container: ElementViewBody;
+    readonly $container: DynamicViewBody | ElementViewBody;
     readonly $type: 'ViewStringProperty';
     key: 'description' | 'title';
     value: string;
@@ -479,7 +528,7 @@ export interface ViewStringProperty extends AstNode {
 export declare const ViewStringProperty = "ViewStringProperty";
 export declare function isViewStringProperty(item: unknown): item is ViewStringProperty;
 export interface WildcardExpr extends AstNode {
-    readonly $container: CustomElementExpr | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
+    readonly $container: CustomElementExpr | DynamicViewRulePredicate | ExcludePredicate | IncludePredicate | IncomingExpr | OutgoingExpr | RelationExpr | ViewRuleStyle;
     readonly $type: 'WildcardExpr';
     isWildcard: boolean;
 }
@@ -492,6 +541,11 @@ export type LikeC4AstType = {
     CustomElementExpr: CustomElementExpr;
     CustomElementExprBody: CustomElementExprBody;
     DescedantsExpr: DescedantsExpr;
+    DynamicView: DynamicView;
+    DynamicViewBody: DynamicViewBody;
+    DynamicViewRule: DynamicViewRule;
+    DynamicViewRulePredicate: DynamicViewRulePredicate;
+    DynamicViewStep: DynamicViewStep;
     Element: Element;
     ElementBody: ElementBody;
     ElementExpr: ElementExpr;
@@ -516,6 +570,7 @@ export type LikeC4AstType = {
     IncludePredicate: IncludePredicate;
     IncomingExpr: IncomingExpr;
     LikeC4Grammar: LikeC4Grammar;
+    LikeC4View: LikeC4View;
     LineProperty: LineProperty;
     LinkProperty: LinkProperty;
     Model: Model;
@@ -541,6 +596,7 @@ export type LikeC4AstType = {
     Tag: Tag;
     Tags: Tags;
     ViewProperty: ViewProperty;
+    ViewRef: ViewRef;
     ViewRule: ViewRule;
     ViewRuleAutoLayout: ViewRuleAutoLayout;
     ViewRulePredicate: ViewRulePredicate;

package/dist/generated/ast.js

@@ -16,7 +16,7 @@ export const LikeC4Terminals = {
   Comma: /,/,
   Percent: /\b\d+%/,
   String: /"[^"]*"|'[^']*'/,
-  IdTerminal: /\b(_+[a-zA-Z]|[a-zA-Z])[\w_-]*/
+  IdTerminal: /\b[_]*[a-zA-Z][_-\w]*/
 };
 export function isArrowType(item) {
   return item === "none" || item === "normal" || item === "onormal" || item === "diamond" || item === "odiamond" || item === "crow" || item === "open" || item === "vee";
@@ -24,6 +24,10 @@ export function isArrowType(item) {
 export function isBorderStyleValue(item) {
   return isLineOptions(item) || item === "none";
 }
+export const DynamicViewRule = "DynamicViewRule";
+export function isDynamicViewRule(item) {
+  return reflection.isInstance(item, DynamicViewRule);
+}
 export const ElementExpr = "ElementExpr";
 export function isElementExpr(item) {
   return reflection.isInstance(item, ElementExpr);
@@ -36,7 +40,11 @@ export function isElementShape(item) {
   return item === "rectangle" || item === "person" || item === "browser" || item === "mobile" || item === "cylinder" || item === "storage" || item === "queue";
 }
 export function isId(item) {
-  return isElementShape(item) || isThemeColor(item) || isArrowType(item) || isLineOptions(item) || item === "element" || item === "model" || typeof item === "string" && /\b(_+[a-zA-Z]|[a-zA-Z])[\w_-]*/.test(item);
+  return isElementShape(item) || isThemeColor(item) || isArrowType(item) || isLineOptions(item) || item === "element" || item === "model" || typeof item === "string" && /\b[_]*[a-zA-Z][_-\w]*/.test(item);
+}
+export const LikeC4View = "LikeC4View";
+export function isLikeC4View(item) {
+  return reflection.isInstance(item, LikeC4View);
 }
 export function isLineOptions(item) {
   return item === "solid" || item === "dashed" || item === "dotted";
@@ -109,6 +117,22 @@ export const DescedantsExpr = "DescedantsExpr";
 export function isDescedantsExpr(item) {
   return reflection.isInstance(item, DescedantsExpr);
 }
+export const DynamicView = "DynamicView";
+export function isDynamicView(item) {
+  return reflection.isInstance(item, DynamicView);
+}
+export const DynamicViewBody = "DynamicViewBody";
+export function isDynamicViewBody(item) {
+  return reflection.isInstance(item, DynamicViewBody);
+}
+export const DynamicViewRulePredicate = "DynamicViewRulePredicate";
+export function isDynamicViewRulePredicate(item) {
+  return reflection.isInstance(item, DynamicViewRulePredicate);
+}
+export const DynamicViewStep = "DynamicViewStep";
+export function isDynamicViewStep(item) {
+  return reflection.isInstance(item, DynamicViewStep);
+}
 export const Element = "Element";
 export function isElement(item) {
   return reflection.isInstance(item, Element);
@@ -277,6 +301,10 @@ export const Tags = "Tags";
 export function isTags(item) {
   return reflection.isInstance(item, Tags);
 }
+export const ViewRef = "ViewRef";
+export function isViewRef(item) {
+  return reflection.isInstance(item, ViewRef);
+}
 export const ViewRuleAutoLayout = "ViewRuleAutoLayout";
 export function isViewRuleAutoLayout(item) {
   return reflection.isInstance(item, ViewRuleAutoLayout);
@@ -295,7 +323,7 @@ export function isWildcardExpr(item) {
 }
 export class LikeC4AstReflection extends AbstractAstReflection {
   getAllTypes() {
-    return ["ArrowProperty", "BorderProperty", "ColorProperty", "CustomElementExpr", "CustomElementExprBody", "DescedantsExpr", "Element", "ElementBody", "ElementExpr", "ElementKind", "ElementKindExpr", "ElementProperty", "ElementRef", "ElementStringProperty", "ElementTagExpr", "ElementView", "ElementViewBody", "ElementViewRef", "ExcludePredicate", "ExpandElementExpr", "ExplicitRelation", "ExtendElement", "ExtendElementBody", "FqnElementRef", "IconProperty", "ImplicitRelation", "InOutExpr", "IncludePredicate", "IncomingExpr", "LikeC4Grammar", "LineProperty", "LinkProperty", "Model", "ModelViews", "NavigateToProperty", "OpacityProperty", "OutgoingExpr", "Relation", "RelationBody", "RelationExpr", "RelationProperty", "RelationStringProperty", "RelationStyleProperty", "RelationshipKind", "RelationshipStyleProperty", "ShapeProperty", "SpecificationElementKind", "SpecificationRelationshipKind", "SpecificationRule", "SpecificationTag", "StyleProperties", "StyleProperty", "Tag", "Tags", "ViewProperty", "ViewRule", "ViewRuleAutoLayout", "ViewRulePredicate", "ViewRulePredicateExpr", "ViewRuleStyle", "ViewStringProperty", "WildcardExpr"];
+    return ["ArrowProperty", "BorderProperty", "ColorProperty", "CustomElementExpr", "CustomElementExprBody", "DescedantsExpr", "DynamicView", "DynamicViewBody", "DynamicViewRule", "DynamicViewRulePredicate", "DynamicViewStep", "Element", "ElementBody", "ElementExpr", "ElementKind", "ElementKindExpr", "ElementProperty", "ElementRef", "ElementStringProperty", "ElementTagExpr", "ElementView", "ElementViewBody", "ElementViewRef", "ExcludePredicate", "ExpandElementExpr", "ExplicitRelation", "ExtendElement", "ExtendElementBody", "FqnElementRef", "IconProperty", "ImplicitRelation", "InOutExpr", "IncludePredicate", "IncomingExpr", "LikeC4Grammar", "LikeC4View", "LineProperty", "LinkProperty", "Model", "ModelViews", "NavigateToProperty", "OpacityProperty", "OutgoingExpr", "Relation", "RelationBody", "RelationExpr", "RelationProperty", "RelationStringProperty", "RelationStyleProperty", "RelationshipKind", "RelationshipStyleProperty", "ShapeProperty", "SpecificationElementKind", "SpecificationRelationshipKind", "SpecificationRule", "SpecificationTag", "StyleProperties", "StyleProperty", "Tag", "Tags", "ViewProperty", "ViewRef", "ViewRule", "ViewRuleAutoLayout", "ViewRulePredicate", "ViewRulePredicateExpr", "ViewRuleStyle", "ViewStringProperty", "WildcardExpr"];
   }
   computeIsSubtype(subtype, supertype) {
     switch (subtype) {
@@ -328,6 +356,13 @@ export class LikeC4AstReflection extends AbstractAstReflection {
       case WildcardExpr: {
         return this.isSubtype(ElementExpr, supertype);
       }
+      case DynamicView:
+      case ElementView: {
+        return this.isSubtype(LikeC4View, supertype);
+      }
+      case DynamicViewRulePredicate: {
+        return this.isSubtype(DynamicViewRule, supertype);
+      }
       case ElementStringProperty:
       case StyleProperties: {
         return this.isSubtype(ElementProperty, supertype);
@@ -348,8 +383,10 @@ export class LikeC4AstReflection extends AbstractAstReflection {
         return this.isSubtype(RelationProperty, supertype);
       }
       case ViewRuleAutoLayout:
-      case ViewRulePredicate:
       case ViewRuleStyle: {
+        return this.isSubtype(DynamicViewRule, supertype) || this.isSubtype(ViewRule, supertype);
+      }
+      case ViewRulePredicate: {
         return this.isSubtype(ViewRule, supertype);
       }
       case ViewStringProperty: {
@@ -363,6 +400,11 @@ export class LikeC4AstReflection extends AbstractAstReflection {
   getReferenceType(refInfo) {
     const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
     switch (referenceId) {
+      case "DynamicViewStep:kind":
+      case "ExplicitRelation:kind":
+      case "ImplicitRelation:kind": {
+        return RelationshipKind;
+      }
       case "Element:kind":
       case "ElementKindExpr:kind": {
         return ElementKind;
@@ -378,9 +420,8 @@ export class LikeC4AstReflection extends AbstractAstReflection {
       case "ElementViewRef:view": {
         return ElementView;
       }
-      case "ExplicitRelation:kind":
-      case "ImplicitRelation:kind": {
-        return RelationshipKind;
+      case "ViewRef:view": {
+        return LikeC4View;
       }
       default: {
         throw new Error(`${referenceId} is not a valid reference id.`);
@@ -441,6 +482,46 @@ export class LikeC4AstReflection extends AbstractAstReflection {
           ]
         };
       }
+      case "DynamicView": {
+        return {
+          name: "DynamicView",
+          properties: [
+            { name: "body" },
+            { name: "name" }
+          ]
+        };
+      }
+      case "DynamicViewBody": {
+        return {
+          name: "DynamicViewBody",
+          properties: [
+            { name: "props", defaultValue: [] },
+            { name: "rules", defaultValue: [] },
+            { name: "steps", defaultValue: [] },
+            { name: "tags" }
+          ]
+        };
+      }
+      case "DynamicViewRulePredicate": {
+        return {
+          name: "DynamicViewRulePredicate",
+          properties: [
+            { name: "expressions", defaultValue: [] }
+          ]
+        };
+      }
+      case "DynamicViewStep": {
+        return {
+          name: "DynamicViewStep",
+          properties: [
+            { name: "isBackward", defaultValue: false },
+            { name: "kind" },
+            { name: "source" },
+            { name: "target" },
+            { name: "title" }
+          ]
+        };
+      }
       case "Element": {
         return {
           name: "Element",
@@ -822,6 +903,14 @@ export class LikeC4AstReflection extends AbstractAstReflection {
           ]
         };
       }
+      case "ViewRef": {
+        return {
+          name: "ViewRef",
+          properties: [
+            { name: "view" }
+          ]
+        };
+      }
       case "ViewRuleAutoLayout": {
         return {
           name: "ViewRuleAutoLayout",