@likec4/core 1.18.0 → 1.19.1

package/src/builder/Builder.view-common.ts

@@ -0,0 +1,234 @@
+import { isArray, isString, map } from 'remeda'
+import type { LiteralUnion, Simplify } from 'type-fest'
+import {
+  type AutoLayoutDirection,
+  type CustomElementExpr,
+  type CustomRelationExpr,
+  type ElementExpression as C4ElementExpression,
+  type Expression as C4Expression,
+  isElementPredicateExpr,
+  type NonEmptyArray,
+  type ViewRuleStyle,
+  type WhereOperator,
+} from '../types'
+import type { AnyTypes, Types } from './_types'
+
+export interface LikeC4ViewBuilder<
+  Types extends AnyTypes,
+  Fqn extends string,
+  TypedExpr,
+  ElementExpr extends string = ViewPredicate.ElementExpr<Fqn>,
+  Expr extends string = ViewPredicate.AllExpression<ElementExpr>,
+> {
+  Types: Types
+  ElementExpr: ElementExpr
+  Expr: Expr
+  TypedExpr: TypedExpr
+  $expr(expr: Expr | TypedExpr): TypedExpr
+  include(...exprs: Expr[]): this
+  exclude(...exprs: Expr[]): this
+  style(rule: ViewRuleStyle): this
+  autoLayout(layout: AutoLayoutDirection): this
+}
+
+export namespace ViewPredicate {
+  export type ElementExpr<Fqn extends string> = '*' | Fqn | `${Fqn}.*` | `${Fqn}._` | `${Fqn}.**`
+
+  export type AllExpression<ElementExpr extends string> =
+    | ElementExpr
+    | `-> ${ElementExpr} ->`
+    | `-> ${ElementExpr}`
+    | `${ElementExpr} ->`
+    | `${ElementExpr} ${'->' | '<->'} ${ElementExpr}`
+
+  export type Expression<T extends AnyTypes> = T extends
+    Types<any, infer F extends string, any, any, any, any, any, any> ? AllExpression<ViewPredicate.ElementExpr<F>>
+    : never
+
+  export type ConnectionExpression<T extends AnyTypes> = T extends
+    Types<any, infer F extends string, any, any, any, any, any, any> ? `${F} -> ${F}`
+    : never
+
+  export type DeploymentExpression<T extends AnyTypes> = T extends
+    Types<any, any, any, any, any, any, any, infer F extends string> ? AllExpression<ViewPredicate.ElementExpr<F>>
+    : never
+
+  export type DeploymentConnectionExpression<T extends AnyTypes> = T extends
+    Types<any, any, any, any, any, any, any, infer F extends string> ? `${F} -> ${F}`
+    : never
+
+  export type WhereTag<Tag extends string> = `tag ${'is' | 'is not'} #${Tag}`
+  export type WhereKind<Kind extends string> = `kind ${'is' | 'is not'} ${Kind}`
+
+  export type WhereEq<Types extends AnyTypes> =
+    | ViewPredicate.WhereTag<Types['Tag']>
+    | ViewPredicate.WhereKind<Types['ElementKind']>
+
+  export type WhereOperator<Types extends AnyTypes> = ViewPredicate.WhereEq<Types> | {
+    and: NonEmptyArray<ViewPredicate.WhereOperator<Types>>
+    or?: never
+    not?: never
+  } | {
+    or: NonEmptyArray<ViewPredicate.WhereOperator<Types>>
+    and?: never
+    not?: never
+  } | {
+    not: ViewPredicate.WhereOperator<Types>
+    and?: never
+    or?: never
+  }
+
+  export type Custom<Types extends AnyTypes> = {
+    where?: ViewPredicate.WhereOperator<Types>
+    with?: Simplify<
+      Omit<CustomElementExpr['custom'] & CustomRelationExpr['customRelation'], 'expr' | 'relation' | 'navigateTo'> & {
+        navigateTo?: Types['ViewId']
+      }
+    >
+  }
+}
+
+function parseWhere(where: ViewPredicate.WhereOperator<AnyTypes>): WhereOperator<any, any> {
+  if (isString(where)) {
+    const op = where as LiteralUnion<ViewPredicate.WhereEq<AnyTypes>, string>
+    switch (true) {
+      case op.startsWith('tag is not #'):
+        return {
+          tag: {
+            neq: op.replace('tag is not #', ''),
+          },
+        }
+      case op.startsWith('tag is #'):
+        return {
+          tag: {
+            eq: op.replace('tag is #', ''),
+          },
+        }
+      case op.startsWith('kind is not '):
+        return {
+          kind: {
+            neq: op.replace('kind is not ', ''),
+          },
+        }
+      case op.startsWith('kind is '):
+        return {
+          kind: {
+            eq: op.replace('kind is ', ''),
+          },
+        }
+      default:
+        throw new Error(`Unknown where operator: ${where}`)
+    }
+  }
+
+  if (where.and) {
+    return {
+      and: map(where.and, parseWhere),
+    }
+  }
+  if (where.or) {
+    return {
+      or: map(where.or, parseWhere),
+    }
+  }
+  if (where.not) {
+    return {
+      not: parseWhere(where.not),
+    }
+  }
+
+  throw new Error(`Unknown where operator: ${where}`)
+}
+
+function $include<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
+  ...args:
+    | [B['Expr']]
+    | [B['TypedExpr']]
+    | [B['Expr'], ViewPredicate.Custom<B['Types']>]
+): (b: B) => B {
+  return (b) => {
+    let expr = b.$expr(args[0])
+    if (args.length === 2) {
+      const condition = args[1].where ? parseWhere(args[1].where) : undefined
+      if (condition) {
+        expr = {
+          where: {
+            expr: expr as any,
+            condition,
+          },
+        }
+      }
+
+      const custom = args[1].with
+      if (custom) {
+        const isElement = isElementPredicateExpr(expr)
+        if (isElement) {
+          expr = {
+            custom: {
+              ...custom,
+              expr: expr as any,
+            },
+          }
+        } else {
+          expr = {
+            customRelation: {
+              ...custom,
+              relation: expr as any,
+            },
+          }
+        }
+      }
+    }
+    b.include(expr as any)
+    return b
+  }
+}
+
+function $exclude<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
+  ...args:
+    | [B['Expr']]
+    | [B['TypedExpr']]
+    | [B['Expr'], ViewPredicate.Custom<B['Types']>]
+): (b: B) => B {
+  return (b) => {
+    let expr = b.$expr(args[0]) as C4Expression
+    if (args.length === 2 && args[1].where) {
+      const condition = parseWhere(args[1].where)
+      expr = {
+        where: {
+          expr: expr as any,
+          condition,
+        },
+      }
+    }
+    b.exclude(expr)
+    return b
+  }
+}
+
+function $style<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
+  element: B['ElementExpr'] | B['TypedExpr'] | NonEmptyArray<B['ElementExpr']>,
+  { notation, ...style }: ViewRuleStyle['style'] & { notation?: string },
+): (b: B) => B {
+  return (b) =>
+    b.style({
+      targets: (isArray(element) ? element : [element]).map(e => b.$expr(e as any) as C4ElementExpression),
+      ...(notation ? { notation } : {}),
+      style: {
+        ...style,
+      },
+    })
+}
+
+function $autoLayout<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
+  layout: AutoLayoutDirection,
+): (b: B) => B {
+  return (b) => b.autoLayout(layout)
+}
+
+type Op<T> = (b: T) => T
+function $rules<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(...rules: Op<B>[]): (b: B) => B {
+  return (b) => rules.reduce((b, rule) => rule(b), b)
+}
+
+export { $autoLayout, $exclude, $include, $rules, $style }

package/src/builder/Builder.view-deployment.ts

@@ -0,0 +1,135 @@
+import { isString } from 'remeda'
+import { type ExpressionV2, type Fqn } from '../types'
+import type { AnyTypes, Types } from './_types'
+import type { LikeC4ViewBuilder, ViewPredicate } from './Builder.view-common'
+import type { ViewsBuilder } from './Builder.views'
+
+export interface DeploymentViewBuilder<T extends AnyTypes>
+  extends LikeC4ViewBuilder<T, T['DeploymentFqn'], Types.ToExpression<T>>
+{
+}
+
+export type DeploymentRulesBuilderOp<Types extends AnyTypes> = (
+  b: DeploymentViewBuilder<Types>
+) => DeploymentViewBuilder<Types>
+
+export interface AddDeploymentViewRules<Id extends string> {
+  with<S extends AnyTypes>(
+    ...rules: DeploymentRulesBuilderOp<S>[]
+  ): (builder: ViewsBuilder<S>) => ViewsBuilder<Types.AddView<S, Id>>
+}
+
+/**
+ * Chainable builder to create element
+ */
+export interface AddDeploymentViewHelper {
+  <
+    const Id extends string,
+    T extends AnyTypes
+  >(
+    id: Id
+  ): AddDeploymentViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+
+  <
+    const Id extends string,
+    T extends AnyTypes
+  >(
+    id: Id,
+    bulder: (b: DeploymentViewBuilder<T>) => DeploymentViewBuilder<T>
+  ): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>
+
+  <
+    const Id extends string,
+    T extends AnyTypes
+  >(
+    id: Id,
+    propsOrTitle: T['NewViewProps'] | string
+  ): AddDeploymentViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+
+  <
+    const Id extends string,
+    T extends AnyTypes
+  >(
+    id: Id,
+    propsOrTitle: T['NewViewProps'] | string,
+    bulder: (b: DeploymentViewBuilder<T>) => DeploymentViewBuilder<T>
+  ): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>
+}
+
+export function $deploymentExpr<T extends AnyTypes>(
+  expr: ViewPredicate.DeploymentExpression<T> | ExpressionV2
+): Types.ToExpression<T> {
+  if (!isString(expr)) {
+    return expr as any
+  }
+  const asTypedDeploymentExpression = (expr: ExpressionV2): Types.ToExpression<T> => {
+    return expr as any
+  }
+
+  if (expr === '*') {
+    return asTypedDeploymentExpression({ wildcard: true })
+  }
+  if (expr.startsWith('->')) {
+    if (expr.endsWith('->')) {
+      return asTypedDeploymentExpression({
+        inout: $deploymentExpr(expr.replace(/->/g, '').trim()) as any
+      })
+    }
+    return asTypedDeploymentExpression({
+      incoming: $deploymentExpr(expr.replace('-> ', '')) as any
+    })
+  }
+  if (expr.endsWith(' ->')) {
+    return asTypedDeploymentExpression({
+      outgoing: $deploymentExpr(expr.replace(' ->', '')) as any
+    })
+  }
+  if (expr.includes(' <-> ')) {
+    const [source, target] = expr.split(' <-> ')
+    return asTypedDeploymentExpression({
+      source: $deploymentExpr(source) as any,
+      target: $deploymentExpr(target) as any,
+      isBidirectional: true
+    })
+  }
+  if (expr.includes(' -> ')) {
+    const [source, target] = expr.split(' -> ')
+    return asTypedDeploymentExpression({
+      source: $deploymentExpr(source) as any,
+      target: $deploymentExpr(target) as any
+    })
+  }
+  if (expr.endsWith('._')) {
+    return asTypedDeploymentExpression({
+      ref: {
+        deployment: expr.replace('._', '') as Fqn
+      },
+      selector: 'expanded'
+    })
+  }
+  if (expr.endsWith('.**')) {
+    return asTypedDeploymentExpression({
+      ref: {
+        deployment: expr.replace('.**', '') as Fqn
+      },
+      selector: 'descendants'
+    })
+  }
+  if (expr.endsWith('.*')) {
+    return asTypedDeploymentExpression({
+      ref: {
+        deployment: expr.replace('.*', '') as Fqn
+      },
+      selector: 'children'
+    })
+  }
+  return asTypedDeploymentExpression({
+    ref: {
+      deployment: expr as any as Fqn
+    }
+  })
+}

package/src/builder/Builder.view-element.ts

@@ -0,0 +1,189 @@
+import { isString } from 'remeda'
+import type { IsStringLiteral } from 'type-fest/source/is-literal'
+import { type Expression as C4Expression, type Fqn } from '../types'
+import type { AnyTypes, Invalid, Types } from './_types'
+import type { LikeC4ViewBuilder, ViewPredicate } from './Builder.view-common'
+import type { ViewsBuilder } from './Builder.views'
+
+export interface ElementViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], C4Expression> {
+}
+
+export type ElementViewRulesBuilder<T extends AnyTypes> = (b: ElementViewBuilder<T>) => ElementViewBuilder<T>
+
+export interface AddViewRules<Id extends string> {
+  with<S extends AnyTypes>(
+    ...rules: ElementViewRulesBuilder<S>[]
+  ): (builder: ViewsBuilder<S>) => ViewsBuilder<Types.AddView<S, Id>>
+}
+
+export interface AddViewHelper {
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+  ): AddViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    builder: (b: ElementViewBuilder<T>) => ElementViewBuilder<T>,
+  ): AddViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    propsOrTitle: NoInfer<T['NewViewProps']> | string,
+  ): AddViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    propsOrTitle: NoInfer<T['NewViewProps']> | string | undefined,
+    builder: (b: ElementViewBuilder<T>) => ElementViewBuilder<T>,
+  ): AddViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+}
+
+type ValidFqn<T extends AnyTypes> = IsStringLiteral<T['Fqn']> extends true ? T['Fqn']
+  : Invalid<'Fqn must be from known'>
+
+export interface AddViewOfHelper {
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    of: ValidFqn<T>,
+  ): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>
+
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    of: ValidFqn<T>,
+    propsOrTitle: T['NewViewProps'] | string | ElementViewRulesBuilder<T>,
+  ): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>
+
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    of: ValidFqn<T>,
+    propsOrTitle: NoInfer<T>['NewViewProps'] | string,
+    builder: (b: ElementViewBuilder<T>) => ElementViewBuilder<T>,
+  ): (builder: ViewsBuilder<T>) => ViewsBuilder<Types.AddView<T, Id>>
+}
+
+export interface TypedAddViewOfHelper<A extends AnyTypes> {
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    of: ValidFqn<A>,
+  ): AddViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    of: ValidFqn<A>,
+    builder: ((b: ElementViewBuilder<A>) => ElementViewBuilder<A>) | A['NewViewProps'] | string,
+  ): AddViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+
+  <
+    const Id extends string,
+    T extends AnyTypes,
+  >(
+    id: Id,
+    of: ValidFqn<A>,
+    propsOrTitle: A['NewViewProps'] | string,
+    builder: (b: ElementViewBuilder<A>) => ElementViewBuilder<A>,
+  ): AddViewRules<Id> & {
+    (builder: ViewsBuilder<T>): ViewsBuilder<Types.AddView<T, Id>>
+  }
+}
+// To hook types
+const asTypedExpr = (expr: C4Expression): C4Expression => {
+  return expr as C4Expression
+}
+
+export function $expr<Types extends AnyTypes>(expr: ViewPredicate.Expression<Types> | C4Expression): C4Expression {
+  if (!isString(expr)) {
+    return expr as C4Expression
+  }
+  if (expr === '*') {
+    return asTypedExpr({ wildcard: true })
+  }
+  if (expr.startsWith('->')) {
+    if (expr.endsWith('->')) {
+      return asTypedExpr({
+        inout: $expr(expr.replace(/->/g, '').trim()) as any,
+      })
+    }
+    return asTypedExpr({
+      incoming: $expr(expr.replace('-> ', '')) as any,
+    })
+  }
+  if (expr.endsWith(' ->')) {
+    return asTypedExpr({
+      outgoing: $expr(expr.replace(' ->', '')) as any,
+    })
+  }
+  if (expr.includes(' <-> ')) {
+    const [source, target] = expr.split(' <-> ')
+    return asTypedExpr({
+      source: $expr(source) as any,
+      target: $expr(target) as any,
+      isBidirectional: true,
+    })
+  }
+  if (expr.includes(' -> ')) {
+    const [source, target] = expr.split(' -> ')
+    return asTypedExpr({
+      source: $expr(source) as any,
+      target: $expr(target) as any,
+    })
+  }
+  if (expr.endsWith('._')) {
+    return asTypedExpr({
+      expanded: expr.replace('._', '') as Fqn,
+    })
+  }
+  if (expr.endsWith('.*')) {
+    return asTypedExpr({
+      element: expr.replace('.*', '') as Fqn,
+      isChildren: true,
+    })
+  }
+  if (expr.endsWith('.**')) {
+    return asTypedExpr({
+      element: expr.replace('.**', '') as Fqn,
+      isDescendants: true,
+    })
+  }
+  return asTypedExpr({
+    element: expr as any as Fqn,
+  })
+}