@likec4/core 1.27.2 → 1.28.0

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { last, reverse } from 'remeda'
 import { invariant } from '../../errors'
-import type { Fqn } from '../../types/element'
+import type { Fqn } from '../../types'
 import type { ComputedEdge, ComputedNode } from '../../types/view'
 import { commonHead } from '../../utils/common-head'
 import { ancestorsOfNode } from './ancestorsOfNode'

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

@@ -1,15 +1,5 @@
-import { pick } from 'remeda'
 import { nonexhaustive } from '../../errors'
-import type { Element } from '../../types/element'
-import {
-  type RelationExpression,
-  type RelationWhereExpr,
-  isIncoming,
-  isInOut,
-  isOutgoing,
-  isRelation,
-  isRelationWhere,
-} from '../../types/expression'
+import { ModelLayer } from '../../types'
 import { whereOperatorAsPredicate } from '../../types/operators'
 import type { ModelRelation } from '../../types/relation'
 import type { ComputedNode } from '../../types/view'
@@ -22,10 +12,13 @@ export type FilterableEdge = Pick<ModelRelation, 'kind' | 'tags'> & {
 }
 
 export function relationExpressionToPredicates<T extends FilterableEdge>(
-  expr: RelationExpression | RelationWhereExpr,
+  expr: ModelLayer.AnyRelationExpr,
 ): Predicate<T> {
   switch (true) {
-    case isRelationWhere(expr): {
+    case ModelLayer.RelationExpr.isCustom(expr): {
+      return relationExpressionToPredicates(expr.customRelation.expr)
+    }
+    case ModelLayer.RelationExpr.isWhere(expr): {
       const predicate = relationExpressionToPredicates(expr.where.expr)
       const where = whereOperatorAsPredicate(expr.where.condition)
       return e =>
@@ -36,7 +29,7 @@ export function relationExpressionToPredicates<T extends FilterableEdge>(
           ...(e.kind && { kind: e.kind }),
         })
     }
-    case isRelation(expr): {
+    case ModelLayer.RelationExpr.isDirect(expr): {
       const isSource = elementExprToPredicate(expr.source)
       const isTarget = elementExprToPredicate(expr.target)
       return edge => {
@@ -44,15 +37,15 @@ export function relationExpressionToPredicates<T extends FilterableEdge>(
           || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
       }
     }
-    case isInOut(expr): {
+    case ModelLayer.RelationExpr.isInOut(expr): {
       const isInOut = elementExprToPredicate(expr.inout)
       return edge => isInOut(edge.source) || isInOut(edge.target)
     }
-    case isIncoming(expr): {
+    case ModelLayer.RelationExpr.isIncoming(expr): {
       const isTarget = elementExprToPredicate(expr.incoming)
       return edge => isTarget(edge.target)
     }
-    case isOutgoing(expr): {
+    case ModelLayer.RelationExpr.isOutgoing(expr): {
       const isSource = elementExprToPredicate(expr.outgoing)
       return edge => isSource(edge.source)
     }

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

@@ -1,7 +1,7 @@
 import { flatMap, hasAtLeast, pipe, sort, unique } from 'remeda'
 import type { LiteralUnion } from 'type-fest'
 import type { NonEmptyReadonlyArray } from '../../types/_common'
-import type { Tag } from '../../types/element'
+import type { Tag } from '../../types/scalars'
 import { compareNatural } from '../../utils/compare-natural'
 
 /**
@@ -9,13 +9,13 @@ import { compareNatural } from '../../utils/compare-natural'
  * and sort in natural order; returns null if no tags are present.
  */
 export function uniqueTags<T extends { tags?: NonEmptyReadonlyArray<LiteralUnion<Tag, string>> | null }>(
-  elements: ReadonlyArray<T>
+  elements: ReadonlyArray<T>,
 ) {
   const tags = pipe(
     elements,
     flatMap(e => e.tags ?? []),
     unique(),
-    sort(compareNatural)
+    sort(compareNatural),
   )
   return hasAtLeast(tags, 1) ? tags as NonEmptyReadonlyArray<Tag> : null
 }

package/src/index.ts

@@ -33,8 +33,6 @@ export * from './types'
 
 export * from './utils'
 
-export * as Expr from './types/expression'
-
 export {
   computeView,
   computeViews,

package/src/model/ElementModel.ts

@@ -1,19 +1,23 @@
 import { isTruthy } from 'remeda'
 import type { SetRequired } from 'type-fest'
+import type { IteratorLike } from '../types/_common'
 import {
   type Element as C4Element,
   type ElementKind as C4ElementKind,
   type ElementShape as C4ElementShape,
   type ElementStyle,
-  type IconUrl,
-  type IteratorLike,
   type Link,
-  type Tag as C4Tag,
-  type ThemeColor,
   DefaultElementShape,
   DefaultThemeColor,
-} from '../types'
+} from '../types/element'
 import { DefaultShapeSize } from '../types/element'
+import {
+  type IconUrl,
+  type ProjectId,
+  type Tag as C4Tag,
+  splitGlobalFqn,
+} from '../types/scalars'
+import type { ThemeColor } from '../types/theme'
 import { commonAncestor, hierarchyLevel, isAncestor, sortNaturalByFqn } from '../utils'
 import { type DeployedInstancesIterator } from './DeploymentElementModel'
 import type { LikeC4Model } from './LikeC4Model'
@@ -28,13 +32,28 @@ export class ElementModel<M extends AnyAux = AnyAux> {
   readonly _literalId: M['Element']
   readonly hierarchyLevel: number
 
+  readonly imported: null | {
+    from: ProjectId
+    fqn: string
+  }
+
   constructor(
     public readonly $model: LikeC4Model<M>,
     public readonly $element: C4Element,
   ) {
     this.id = this.$element.id
     this._literalId = this.$element.id
-    this.hierarchyLevel = hierarchyLevel(this.id)
+    const [projectId, fqn] = splitGlobalFqn(this.id)
+    if (projectId) {
+      this.imported = {
+        from: projectId,
+        fqn,
+      }
+      this.hierarchyLevel = hierarchyLevel(fqn)
+    } else {
+      this.imported = null
+      this.hierarchyLevel = hierarchyLevel(this.id)
+    }
   }
 
   get parent(): ElementModel<M> | null {

package/src/model/LikeC4Model.ts

@@ -1,15 +1,17 @@
-import { mapValues, pipe, sort, values } from 'remeda'
+import { entries, flat, mapValues, pipe, sort, values } from 'remeda'
 import type { LiteralUnion } from 'type-fest'
 import { computeView, unsafeComputeView } from '../compute-view'
 import type { ComputeViewResult } from '../compute-view/compute-view'
 import { invariant, nonNullable } from '../errors'
-import type { ComputedView, DiagramView, IteratorLike, LikeC4View, ModelGlobals } from '../types'
+import type { IteratorLike } from '../types/_common'
 import type { Element } from '../types/element'
-import { type Tag as C4Tag } from '../types/element'
+import type { ModelGlobals } from '../types/global'
 import type { AnyParsedLikeC4ModelData, GenericLikeC4ModelData, LikeC4ModelDump } from '../types/model-data'
 import type { ModelRelation } from '../types/relation'
+import { type ProjectId, type Tag as C4Tag, GlobalFqn, isGlobalFqn } from '../types/scalars'
+import type { ComputedView, DiagramView, LikeC4View } from '../types/view'
 import { compareNatural } from '../utils'
-import { ancestorsFqn, commonAncestor, parentFqn } from '../utils/fqn'
+import { ancestorsFqn, commonAncestor, parentFqn, sortParentsFirst } from '../utils/fqn'
 import { DefaultMap } from '../utils/mnemonist'
 import type {
   DeployedInstanceModel,
@@ -121,6 +123,11 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
         this.#allTags.get(tag).add(el)
       }
     }
+    for (const [projectId, elements] of entries($model.imports)) {
+      for (const element of sortParentsFirst(elements)) {
+        this.addImportedElement(projectId as ProjectId, element)
+      }
+    }
     for (const relation of values($model.relations)) {
       const el = this.addRelation(relation)
       for (const tag of el.tags) {
@@ -365,7 +372,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
     if (this.#elements.has(element.id)) {
       throw new Error(`Element ${element.id} already exists`)
     }
-    const el = new ElementModel(this, Object.freeze(structuredClone(element)))
+    const el = new ElementModel(this, Object.freeze(element))
     this.#elements.set(el.id, el)
     const parentId = parentFqn(el.id)
     if (parentId) {
@@ -378,13 +385,42 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
     return el
   }
 
+  private addImportedElement(projectId: ProjectId, element: Element) {
+    invariant(!isGlobalFqn(element.id), `Imported element already has global FQN`)
+    const id = GlobalFqn(projectId, element.id)
+    if (this.#elements.has(id)) {
+      throw new Error(`Element ${id} already exists`)
+    }
+    const el = new ElementModel(
+      this,
+      Object.freeze({
+        ...element,
+        id,
+      }),
+    )
+    this.#elements.set(el.id, el)
+    let parentId = parentFqn(el.id)
+    while (parentId) {
+      // For imported elements - id has format `@projectId.fqn`
+      // We need to exclude `@projectId` from the parentId
+      if (parentId.includes('.') && this.#elements.has(parentId)) {
+        this.#parents.set(el.id, this.element(parentId))
+        this.#children.get(parentId).add(el)
+        return el
+      }
+      parentId = parentFqn(parentId)
+    }
+    this.#rootElements.add(el)
+    return el
+  }
+
   private addRelation(relation: ModelRelation) {
     if (this.#relations.has(relation.id)) {
       throw new Error(`Relation ${relation.id} already exists`)
     }
     const rel = new RelationshipModel(
       this,
-      Object.freeze(structuredClone(relation)),
+      Object.freeze(relation),
     )
     const { source, target } = rel
     this.#relations.set(rel.id, rel)
@@ -418,6 +454,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
 
 export namespace LikeC4Model {
   export const EMPTY = LikeC4Model.create({
+    projectId: 'default' as ProjectId,
     specification: {
       elements: {},
       relationships: {},
@@ -436,6 +473,7 @@ export namespace LikeC4Model {
     elements: {},
     relations: {},
     views: {},
+    imports: {},
   }) as LikeC4Model<AnyAux>
 
   export type Any = Aux<

package/src/model/RelationModel.ts

@@ -1,12 +1,14 @@
 import { isEmpty } from 'remeda'
-import type { Color, IteratorLike } from '../types'
-import type { Link, Tag } from '../types/element'
+import type { IteratorLike } from '../types/_common'
+import type { Link } from '../types/element'
 import {
   type ModelRelation,
   type RelationshipLineType,
   DefaultLineStyle,
   DefaultRelationshipColor,
 } from '../types/relation'
+import type { Tag } from '../types/scalars'
+import type { Color } from '../types/theme'
 import { commonAncestor } from '../utils/fqn'
 import type { DeploymentRelationModel } from './DeploymentElementModel'
 import type { ElementModel } from './ElementModel'

package/src/model/view/LikeC4ViewModel.ts

@@ -1,6 +1,7 @@
 import { nonNullable } from '../../errors'
-import type { IteratorLike } from '../../types'
-import type { Link, Tag } from '../../types/element'
+import type { IteratorLike } from '../../types/_common'
+import type { Link } from '../../types/element'
+import type { Tag } from '../../types/scalars'
 import {
   type ComputedDeploymentView,
   type ComputedDynamicView,

package/src/types/_common.ts

@@ -1,13 +1,9 @@
 import type { Simplify, Tagged, UnionToIntersection } from 'type-fest'
 
-export type ProjectId = Tagged<string, 'ProjectID'>
-
 export type NonEmptyArray<T> = [T, ...T[]]
 
 export type NonEmptyReadonlyArray<T> = readonly [T, ...T[]]
 
-export type IconUrl = Tagged<string, 'IconUrl'> | 'none'
-
 export type CustomColor = string
 
 export type Point = readonly [x: number, y: number]

package/src/types/deployments.ts

@@ -1,7 +1,8 @@
 import type { MergeExclusive, Simplify, Tagged } from 'type-fest'
-import type { IconUrl, NonEmptyArray } from './_common'
-import type { ElementShape, ElementStyle, Fqn, Link, Tag } from './element'
+import type { NonEmptyArray } from './_common'
+import type { ElementShape, ElementStyle, Link } from './element'
 import type { AbstractRelation, RelationId } from './relation'
+import type { Fqn, IconUrl, Tag } from './scalars'
 import type { Color } from './theme'
 
 export type DeploymentNodeKind<Kinds extends string = string> = Tagged<Kinds, 'DeploymentNodeKind'>

package/src/types/element.ts

@@ -1,14 +1,8 @@
 import type { Tagged, TupleToUnion } from 'type-fest'
-import type { IconUrl, NonEmptyArray } from './_common'
+import type { NonEmptyArray } from './_common'
+import type { Fqn, IconUrl, Tag } from './scalars'
 import type { Color, ShapeSize, SpacingSize, TextSize, ThemeColor } from './theme'
 
-// Full-qualified-name
-export type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>
-
-export function AsFqn(name: string, parent?: Fqn | null) {
-  return (parent ? parent + '.' + name : name) as Fqn
-}
-
 export const BorderStyles = ['solid', 'dashed', 'dotted', 'none'] as const
 
 export type BorderStyle = TupleToUnion<typeof BorderStyles>
@@ -60,8 +54,6 @@ export interface ElementStyle {
   readonly textSize?: TextSize
 }
 
-export type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>
-
 export interface TagSpec {
   readonly id: Tag
   readonly style: ElementStyle