@likec4/core 1.31.0 → 1.32.0

package/src/model/guards.ts

@@ -1,25 +1,77 @@
-import type {
-  DeploymentElementModel,
-  DeploymentRelationEndpoint,
+import type { Any, AnyAux } from '../types'
+import {
+  type DeploymentElementModel,
+  DeployedInstanceModel,
+  DeploymentNodeModel,
+  DeploymentRelationModel,
   NestedElementOfDeployedInstanceModel,
 } from './DeploymentElementModel'
-import { DeployedInstanceModel, DeploymentNodeModel } from './DeploymentElementModel'
-import type { AnyAux } from './types'
+import { ElementModel } from './ElementModel'
+import { type AnyRelationshipModel, RelationshipModel } from './RelationModel'
+import { EdgeModel } from './view/EdgeModel'
+import { LikeC4ViewModel } from './view/LikeC4ViewModel'
+import { NodeModel } from './view/NodeModel'
 
-export function isDeploymentNode(model: DeploymentElementModel): model is DeploymentNodeModel {
-  return model.isDeploymentNode()
+type AnyModel<A extends AnyAux> =
+  | DeploymentNodeModel<A>
+  | DeployedInstanceModel<A>
+  | DeploymentRelationModel<A>
+  | AnyRelationshipModel<A>
+  | NestedElementOfDeployedInstanceModel<A>
+  | ElementModel<A>
+  | RelationshipModel<A>
+  | LikeC4ViewModel<A>
+  | NodeModel<A>
+  | EdgeModel<A>
+
+export function isDeploymentNodeModel<M extends AnyAux>(
+  model: AnyModel<M>,
+): model is DeploymentNodeModel<M> {
+  return model instanceof DeploymentNodeModel
+}
+
+export function isDeployedInstanceModel<M extends AnyAux>(
+  model: AnyModel<M>,
+): model is DeployedInstanceModel<M> {
+  return model instanceof DeployedInstanceModel
 }
 
-export function isDeployedInstance(model: DeploymentElementModel): model is DeployedInstanceModel {
-  return model.isInstance()
+export function isDeploymentElementModel<M extends AnyAux>(model: AnyModel<M>): model is DeploymentElementModel<M> {
+  return isDeploymentNodeModel(model) || isDeployedInstanceModel(model)
 }
 
-export function isNestedElementOfDeployedInstanceModel<M extends AnyAux = AnyAux>(
-  model: DeploymentRelationEndpoint<M>,
+export function isNestedElementOfDeployedInstanceModel<M extends AnyAux>(
+  model: AnyModel<M>,
 ): model is NestedElementOfDeployedInstanceModel<M> {
-  return !model.isInstance() && !model.isDeploymentNode()
+  return model instanceof NestedElementOfDeployedInstanceModel
+}
+
+export function isDeploymentRelationModel<M extends AnyAux>(
+  x: AnyModel<M>,
+): x is DeploymentRelationModel<M> {
+  return x instanceof DeploymentRelationModel
+}
+
+export function isRelationModel<M extends AnyAux>(x: AnyModel<M>): x is RelationshipModel<M> {
+  return x instanceof RelationshipModel
+}
+export {
+  isRelationModel as isModelRelation,
+  isRelationModel as isRelationshipModel,
+}
+
+export function isElementModel<M extends Any>(element: AnyModel<M>): element is ElementModel<M> {
+  return element instanceof ElementModel
+}
+
+export function isLikeC4ViewModel<M extends Any>(view: AnyModel<M>): view is LikeC4ViewModel<M> {
+  return view instanceof LikeC4ViewModel
+}
+
+export function isNodeModel<M extends Any>(node: AnyModel<M>): node is NodeModel<M> {
+  return node instanceof NodeModel
 }
 
-export function isDeploymentElementModel(x: any): x is DeploymentElementModel {
-  return x instanceof DeploymentNodeModel || x instanceof DeployedInstanceModel
+export function isEdgeModel<M extends Any>(edge: AnyModel<M>): edge is EdgeModel<M> {
+  return edge instanceof EdgeModel
 }

package/src/model/index.ts

@@ -1,5 +1,5 @@
 export { ElementModel } from './ElementModel'
-export { LikeC4Model } from './LikeC4Model'
+export { type AnyLikeC4Model, LikeC4Model } from './LikeC4Model'
 export { RelationshipModel } from './RelationModel'
 
 export {
@@ -28,7 +28,9 @@ export {
   DeployedInstanceModel,
   type DeploymentElementModel,
   DeploymentNodeModel,
+  type DeploymentRelationEndpoint,
   DeploymentRelationModel,
+  RelationshipsAccum,
 } from './DeploymentElementModel'
 export { LikeC4DeploymentModel } from './DeploymentModel'
 
@@ -37,11 +39,22 @@ export { LikeC4ViewModel } from './view/LikeC4ViewModel'
 export { NodeModel } from './view/NodeModel'
 
 export type {
-  AnyAux,
-  Aux,
+  DeploymentOrFqn,
+  EdgeOrId,
+  ElementOrFqn,
+  IncomingFilter,
+  NodeOrId,
+  OutgoingFilter,
 } from './types'
 
-export {
-  isDeployedInstance,
-  isDeploymentNode,
-} from './guards'
+export * from './guards'
+
+export type {
+  Any,
+  AnyAux,
+  Aux,
+  aux,
+  AuxFromDump,
+  AuxFromLikeC4ModelData,
+  SpecAux,
+} from '../types'

package/src/model/types.ts

@@ -1,119 +1,63 @@
-import type { IsStringLiteral, LiteralUnion, Simplify } from 'type-fest'
+import type { Tagged } from 'type-fest'
 import type {
+  AnyAux,
+  ComputedLikeC4ModelData,
   ComputedView,
   DiagramView,
-  EdgeId,
-  Fqn,
-  GenericLikeC4ModelData,
-  KeysOf,
   LayoutedLikeC4ModelData,
-  LikeC4ModelDump,
-  NodeId,
   ParsedLikeC4ModelData,
-  RelationId,
-  ViewId,
+  scalar,
+  ViewType,
+  ViewWithType,
 } from '../types'
-import { isString } from '../utils/guards'
+import type * as aux from '../types/aux'
+import type { LikeC4ViewModel } from './view/LikeC4ViewModel'
 
 export type IncomingFilter = 'all' | 'direct' | 'to-descendants'
 export type OutgoingFilter = 'all' | 'direct' | 'from-descendants'
 
+type AnyScalar<V extends string> =
+  | Tagged<V, 'Fqn'>
+  | Tagged<V, 'DeploymentFqn'>
+  | Tagged<V, 'ViewId'>
+  | Tagged<V, 'NodeId'>
+  | Tagged<V, 'EdgeId'>
+  | Tagged<V, 'RelationId'>
+
 /**
  * Utility function to extract `id` from the given element.
  */
-export function getId<Id extends string>(element: string | { id: Id }): Id {
-  return isString(element) ? element as Id : element.id
+export function getId<Id extends string, Scalar extends AnyScalar<Id>>(element: Id | { id: Scalar }): Scalar {
+  return typeof element === 'string' ? element as unknown as Scalar : element.id
 }
 
-type WithId<Id> = { id: Id }
-
-type WithViews<Id extends string, ViewType> = { views: Record<Id, ViewType> }
-
-/**
- * Auxilary type to keep track
- */
-export interface Aux<
-  Element extends string,
-  Deployment extends string,
-  View extends string,
-  ViewType,
-> {
-  Element: Element
-  Deployment: Deployment
-  View: View
-
-  // Wrapped Element
-  // If Fqn is just a string, then we use generic Fqn to have better hints in the editor
-  Fqn: IsStringLiteral<Element> extends true ? Fqn<Element> : Fqn
-  ElementOrFqn: Element | WithId<this['Fqn']>
+export type ElementOrFqn<A extends AnyAux> = aux.ElementId<A> | { id: aux.Fqn<A> }
 
-  // Wrapped Deployment
-  DeploymentFqn: IsStringLiteral<Deployment> extends true ? Fqn<Deployment> : Fqn
-  DeploymentOrFqn: Deployment | WithId<this['DeploymentFqn']>
+export type DeploymentOrFqn<A extends AnyAux> = aux.DeploymentId<A> | { id: aux.DeploymentFqn<A> }
 
-  // Wrapped View
-  ViewId: IsStringLiteral<View> extends true ? ViewId<View> : ViewId
+export type ViewOrId<A extends AnyAux> = aux.ViewId<A> | { id: aux.StrictViewId<A> }
 
-  ViewType: ViewType
+export type NodeOrId = string | { id: scalar.NodeId }
+export type EdgeOrId = string | { id: scalar.EdgeId }
+export type RelationOrId = string | { id: scalar.RelationId }
 
-  RelationId: RelationId
-  NodeId: NodeId
-  NodeIdLiteral: string
-  EdgeId: EdgeId
-  EdgeIdLiteral: string
+export type $View<A extends AnyAux> = {
+  parsed: never
+  computed: ComputedView<A>
+  layouted: DiagramView<A>
+}[aux.Stage<A>]
 
-  NodeOrId: LiteralUnion<this['NodeIdLiteral'], string> | WithId<this['NodeId']>
-  EdgeOrId: LiteralUnion<this['EdgeIdLiteral'], string> | WithId<this['EdgeId']>
+export type $ViewWithType<A extends AnyAux, V extends ViewType> = ViewWithType<$View<A>, V>
 
-  Model: Simplify<Omit<GenericLikeC4ModelData, 'views'> & WithViews<this['ViewId'], ViewType>>
-}
-
-export type AnyAux = Aux<
-  string,
-  string,
-  string,
-  any
->
-
-export namespace Strict {
-  export type Fqn<A extends AnyAux> = A['Element']
-  export type Deployment<A extends AnyAux> = A['Deployment']
-  export type ViewId<A extends AnyAux> = A['View']
-}
-
-export namespace Aux {
-  export type FromParsed<M> = M extends ParsedLikeC4ModelData ? Aux<
-      KeysOf<M['elements']>,
-      KeysOf<M['deployments']['elements']>,
-      KeysOf<M['views']>,
-      ComputedView<ViewId<KeysOf<M['views']>>, string>
-    >
-    : never
-
-  export type FromModel<M> = M extends GenericLikeC4ModelData ? Aux<
-      KeysOf<M['elements']>,
-      KeysOf<M['deployments']['elements']>,
-      KeysOf<M['views']>,
-      M extends LayoutedLikeC4ModelData ? DiagramView<ViewId<KeysOf<M['views']>>, string>
-        : ComputedView<ViewId<KeysOf<M['views']>>, string>
-    >
-    : never
-
-  export type FromDump<M> = M extends LikeC4ModelDump ? Aux<
-      KeysOf<M['elements']>,
-      KeysOf<M['deployments']['elements']>,
-      KeysOf<M['views']>,
-      DiagramView<ViewId<KeysOf<M['views']>>, string>
-    >
-    : never
-}
+export type $ViewModel<A extends AnyAux> = {
+  parsed: never
+  computed: LikeC4ViewModel<A>
+  layouted: LikeC4ViewModel<A>
+}[aux.Stage<A>]
 
-// export type FromModel<M> = LikeC4Model<
-//   M extends AnyLikeC4Model<
-//     infer Fqn extends string,
-//     infer Deployment extends string,
-//     infer ViewId extends string,
-//     any
-//   > ? Aux<Fqn, Deployment, ViewId, M>
-//     : Aux<KeysOf<>, string, string, ComputedLikeC4Model | LayoutedLikeC4Model>
-// >
+// export type $ModelData<A> = A extends infer T extends Any ? {
+export type $ModelData<A extends AnyAux> = {
+  parsed: ParsedLikeC4ModelData<A>
+  computed: ComputedLikeC4ModelData<A>
+  layouted: LayoutedLikeC4ModelData<A>
+}[aux.Stage<A>]

package/src/model/view/EdgeModel.ts

@@ -1,89 +1,90 @@
-import { isNonNullish } from 'remeda'
-import type { LiteralUnion } from 'type-fest'
 import {
+  type Any,
+  type aux,
   type Color,
-  type ComputedDynamicView,
-  type ComputedView,
-  type DiagramView,
+  type ComputedEdge,
+  type DiagramEdge,
   type IteratorLike,
-  type RelationId as C4RelationID,
   type RelationshipLineType,
+  type scalar,
   type StepEdgeId,
-  type Tag as C4Tag,
   extractStep,
   isStepEdgeId,
 } from '../../types'
 import type { DeploymentRelationModel } from '../DeploymentElementModel'
-import type { LikeC4Model } from '../LikeC4Model'
 import type { RelationshipModel } from '../RelationModel'
-import type { AnyAux } from '../types'
+import type { $View } from '../types'
 import type { LikeC4ViewModel } from './LikeC4ViewModel'
 import type { NodeModel } from './NodeModel'
 
-export type EdgesIterator<M extends AnyAux, V extends ComputedView | DiagramView> = IteratorLike<EdgeModel<M, V>>
+export type EdgesIterator<A extends Any, V extends $View<A>> = IteratorLike<EdgeModel<A, V>>
 
-export class EdgeModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
+export class EdgeModel<A extends Any = Any, View extends $View<A> = $View<A>> {
+  #edge: ComputedEdge<A> | DiagramEdge<A>
   constructor(
-    public readonly view: LikeC4ViewModel<M, V>,
-    public readonly $edge: V['edges'][number],
-    public readonly source: NodeModel<M, V>,
-    public readonly target: NodeModel<M, V>,
+    public readonly view: LikeC4ViewModel<A, View>,
+    public readonly $edge: View['edges'][number],
+    public readonly source: NodeModel<A, View>,
+    public readonly target: NodeModel<A, View>,
   ) {
+    this.#edge = $edge
   }
 
-  get id(): M['EdgeId'] {
-    return this.$edge.id
+  get id(): scalar.EdgeId {
+    return this.#edge.id
   }
 
-  get parent(): NodeModel<M, V> | null {
-    return this.$edge.parent ? this.view.node(this.$edge.parent) : null
+  get parent(): NodeModel<A, View> | null {
+    return this.#edge.parent ? this.view.node(this.#edge.parent) : null
   }
 
   get label(): string | null {
-    return this.$edge.label
+    return this.#edge.label
   }
 
   get description(): string | null {
-    return this.$edge.description ?? null
+    return this.#edge.description ?? null
   }
 
   get technology(): string | null {
-    return this.$edge.technology ?? null
+    return this.#edge.technology ?? null
   }
 
-  public hasParent(): this is EdgeModel.WithParent<M, V> {
-    return this.$edge.parent !== null
+  public hasParent(): this is EdgeModel.WithParent<A, View> {
+    return this.#edge.parent !== null
   }
 
-  get tags(): ReadonlyArray<C4Tag> {
-    return this.$edge.tags ?? []
+  get tags(): aux.Tags<A> {
+    return this.#edge.tags ?? []
   }
 
   get stepNumber(): number | null {
     return this.isStep() ? extractStep(this.id) : null
   }
 
-  get navigateTo(): LikeC4ViewModel<M> | null {
-    return this.$edge.navigateTo ? this.view.$model.view(this.$edge.navigateTo) : null
+  get navigateTo(): LikeC4ViewModel<A> | null {
+    return this.#edge.navigateTo ? this.view.$model.view(this.#edge.navigateTo) : null
   }
 
   get color(): Color {
-    return this.$edge.color ?? 'gray'
+    return this.#edge.color ?? 'gray'
   }
 
   get line(): RelationshipLineType {
-    return this.$edge.line ?? 'dashed'
+    return this.#edge.line ?? 'dashed'
   }
 
-  public isStep(): this is EdgeModel.StepEdge<M, ComputedDynamicView> {
+  public isStep(): this is EdgeModel.StepEdge<A, View> {
     return isStepEdgeId(this.id)
   }
 
-  public relationships(type: 'model'): IteratorLike<RelationshipModel<M>>
-  public relationships(type: 'deployment'): IteratorLike<DeploymentRelationModel<M>>
-  public relationships(type?: 'model' | 'deployment'): IteratorLike<LikeC4Model.AnyRelation<M>>
-  public *relationships(type: 'model' | 'deployment' | undefined): IteratorLike<LikeC4Model.AnyRelation<M>> {
-    for (const id of this.$edge.relations) {
+  public relationships(type: 'model'): IteratorLike<RelationshipModel<A>>
+  public relationships(type: 'deployment'): IteratorLike<DeploymentRelationModel<A>>
+  public relationships(type?: 'model' | 'deployment'): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>
+  public *relationships(
+    type: 'model' | 'deployment' | undefined,
+  ): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>> {
+    for (const id of this.#edge.relations) {
       // if type is provided, then we need to filter relationships
       if (type) {
         const rel = this.view.$model.findRelationship(id, type)
@@ -97,17 +98,22 @@ export class EdgeModel<M extends AnyAux, V extends ComputedView | DiagramView =
     return
   }
 
-  public includesRelation(rel: M['RelationId']): boolean {
-    return this.$edge.relations.includes(rel as C4RelationID)
+  public includesRelation(rel: aux.RelationId | { id: aux.RelationId }): boolean {
+    const id = typeof rel === 'string' ? rel : rel.id
+    return this.#edge.relations.includes(id)
+  }
+
+  public isTagged(tag: aux.LooseTag<A>): boolean {
+    return this.tags.includes(tag as aux.Tag<A>)
   }
 }
 
 namespace EdgeModel {
-  export interface StepEdge<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
+  export interface StepEdge<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
     id: StepEdgeId
     stepNumber: number
   }
-  export interface WithParent<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
-    parent: NodeModel<M, V>
+  export interface WithParent<A extends Any, V extends $View<A>> extends EdgeModel<A, V> {
+    parent: NodeModel<A, V>
   }
 }