@likec4/core 1.41.0 → 1.42.0

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

@@ -1,273 +0,0 @@
-import { isArray, isString, map } from 'remeda'
-import type { LiteralUnion, Simplify } from 'type-fest'
-import {
-  type Any,
-  type AnyAux,
-  type AnyViewRuleStyle as ViewRuleStyle,
-  type AutoLayoutDirection,
-  type Expression,
-  type ModelRelationExpr,
-  type NonEmptyArray,
-  type WhereOperator,
-  ModelFqnExpr,
-} from '../types'
-import type { Participant, ParticipantOperator } from '../types/operators'
-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<any>): 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 WhereParticipant<Types extends AnyTypes> = `${Participant}.${
-    | WhereTag<Types['Tag']>
-    | WhereKind<Types['ElementKind']>}`
-
-  export type WhereEq<Types extends AnyTypes> =
-    | ViewPredicate.WhereTag<Types['Tag']>
-    | ViewPredicate.WhereKind<Types['ElementKind']>
-    | ViewPredicate.WhereKind<Types['DeploymentKind']>
-    | ViewPredicate.WhereParticipant<Types>
-
-  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<
-        ModelFqnExpr.Custom['custom'] & ModelRelationExpr.Custom['customRelation'],
-        'expr' | 'relation' | 'navigateTo'
-      > & {
-        navigateTo?: Types['ViewId']
-      }
-    >
-  }
-}
-
-function parseWhere(where: ViewPredicate.WhereOperator<AnyTypes>): WhereOperator<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 ', ''),
-          },
-        }
-      case op.startsWith('source.'):
-        return {
-          operator: parseWhere(
-            op.replace('source.', '') as ViewPredicate.WhereOperator<AnyTypes>,
-          ) as ParticipantOperator<AnyAux>['operator'],
-          participant: 'source',
-        }
-      case op.startsWith('target.'):
-        return {
-          operator: parseWhere(
-            op.replace('target.', '') as ViewPredicate.WhereOperator<AnyTypes>,
-          ) as ParticipantOperator<AnyAux>['operator'],
-          participant: 'target',
-        }
-      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 = ModelFqnExpr.is(expr)
-        if (isElement) {
-          expr = {
-            custom: {
-              ...custom,
-              expr: expr as any,
-            },
-          }
-        } else {
-          expr = {
-            customRelation: {
-              ...custom,
-              expr: 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['TypedExpr'], ViewPredicate.Custom<B['Types']>]
-): (b: B) => B {
-  return (b) => {
-    let expr = b.$expr(args[0]) as Expression
-    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
-  }
-}
-
-/**
- * @example
- *  builder.views(({ view, $style }, _) =>
- *    _(
- *      view('view1').with(
- *        $style('*', {
- *          color: 'red',
- *        }),
- *        $style(['bob', 'alice'], {
- *          color: 'blue',
- *        }),
- *      ),
- *    )
- *  )
- */
-function $style<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
-  element: B['ElementExpr'] | B['TypedExpr'] | NonEmptyArray<B['ElementExpr']>,
-  { notation, ...style }: ViewRuleStyle<any>['style'] & { notation?: string },
-): (b: B) => B {
-  return (b) =>
-    b.style({
-      targets: (isArray(element) ? element : [element]).map(e => b.$expr(e as any) as ModelFqnExpr),
-      ...(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

@@ -1,135 +0,0 @@
-import { isString } from 'remeda'
-import { type DeploymentFqn, type Expression } 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> | Expression,
-): Types.ToExpression<T> {
-  if (!isString(expr)) {
-    return expr as any
-  }
-  const asTypedDeploymentExpression = (expr: Expression): 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 DeploymentFqn,
-      },
-      selector: 'expanded',
-    })
-  }
-  if (expr.endsWith('.**')) {
-    return asTypedDeploymentExpression({
-      ref: {
-        deployment: expr.replace('.**', '') as DeploymentFqn,
-      },
-      selector: 'descendants',
-    })
-  }
-  if (expr.endsWith('.*')) {
-    return asTypedDeploymentExpression({
-      ref: {
-        deployment: expr.replace('.*', '') as DeploymentFqn,
-      },
-      selector: 'children',
-    })
-  }
-  return asTypedDeploymentExpression({
-    ref: {
-      deployment: expr as DeploymentFqn,
-    },
-  })
-}

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

@@ -1,202 +0,0 @@
-import { isString } from 'remeda'
-import type { IsLiteral } from 'type-fest'
-import { type Expression, 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'], Expression<Types.ToAux<T>>>
-{
-}
-
-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> = IsLiteral<T['Fqn']> extends true ? T['Fqn']
-  : Invalid<'Fqn must be a literal'>
-
-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 = <T extends AnyTypes>(expr: Expression): Expression<Types.ToAux<T>> => {
-  return expr as Expression<Types.ToAux<T>>
-}
-
-export function $expr<T extends AnyTypes>(
-  expr: ViewPredicate.Expression<T> | Expression,
-): Expression<Types.ToAux<T>> {
-  if (!isString(expr)) {
-    return expr as Expression<Types.ToAux<T>>
-  }
-  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({
-      ref: {
-        model: expr.replace('._', '') as Fqn,
-      },
-      selector: 'expanded',
-    })
-  }
-  if (expr.endsWith('.**')) {
-    return asTypedExpr({
-      ref: {
-        model: expr.replace('.**', '') as Fqn,
-      },
-      selector: 'descendants',
-    })
-  }
-  if (expr.endsWith('.*')) {
-    return asTypedExpr({
-      ref: {
-        model: expr.replace('.*', '') as Fqn,
-      },
-      selector: 'children',
-    })
-  }
-  return asTypedExpr({
-    ref: {
-      model: expr as any as Fqn,
-    },
-  })
-}