@likec4/core 1.40.0 → 1.42.0

package/builder/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/builder/index.d.mts",
+  "module": "../dist/builder/index.mjs"
+}

package/compute-view/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/compute-view/index.d.mts",
+  "module": "../dist/compute-view/index.mjs"
+}

package/compute-view/relationships/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../../dist/compute-view/relationships-view/index.d.mts",
+  "module": "../../dist/compute-view/relationships-view/index.mjs"
+}

package/dist/builder/index.d.mts

@@ -1,12 +1,13 @@
-import { LastArrayElement, Split, Simplify, IsLiteral, Writable, IfNever, IsNever, TupleToUnion, Tagged } from 'type-fest';
-import { g as LikeC4Model } from '../shared/core.CySf-2gP.mjs';
+import { LastArrayElement, Split, Simplify, IsLiteral, Writable, IfNever, IsNever, TupleToUnion, Tagged, PartialDeep } from 'type-fest';
+import { f as LikeC4Model } from '../shared/core.D0PjZzIS.mjs';
 import { D as DeploymentFqn, F as Fqn } from '../shared/core.DX-WYEPA.mjs';
-import { l as DeploymentElement, p as DeploymentRelationship, I as Element, T as ModelRelation, aj as AnyViewRuleStyle, ao as AutoLayoutDirection, $ as ParsedView, aP as ParsedDeploymentView, b4 as ParsedElementView, h as ParsedLikeC4ModelData, U as ElementSpecification$1, Y as RelationshipSpecification, V as TagSpecification } from '../shared/core.Bpou6c2f.mjs';
-import { c as Participant, E as Expression } from '../shared/core.BbThmf6M.mjs';
+import { e as DeploymentElement, h as DeploymentRelationship, r as ParsedView, a0 as ParsedDeploymentView, P as ParsedLikeC4ModelData, E as ElementSpecification$1, p as RelationshipSpecification, T as TagSpecification } from '../shared/core.DdMJk7nx.mjs';
+import { f as Element, h as ModelRelation, n as AnyViewRuleStyle, r as AutoLayoutDirection, aa as ParsedElementView, j as LikeC4ProjectStylesConfig } from '../shared/core.fHR_8Tnq.mjs';
+import { f as Participant, E as Expression, u as ElementShape, D as ThemeColor, s as BorderStyle, q as ShapeSize, r as SpacingSize, p as TextSize, y as RelationshipArrowType, v as RelationshipLineType } from '../shared/core.CQngdcuj.mjs';
 import { ModelFqnExpr, ModelRelationExpr } from '../types/expression-model.mjs';
-import { N as NonEmptyArray, K as KeysOf } from '../shared/core.DrvfVXkh.mjs';
-import { y as setProject, a as Aux, S as SpecAux, A as Any } from '../shared/core.D_fI5Lf6.mjs';
-import { c as ElementShape, h as ThemeColor, b as BorderStyle, a as ShapeSize, S as SpacingSize, T as TextSize, f as RelationshipArrowType, R as RelationshipLineType } from '../shared/core.CzdwsPmY.mjs';
+import { N as NonEmptyArray, K as KeysOf } from '../shared/core.D5fzJWbF.mjs';
+import { O as setProject, a as Aux, S as SpecAux, A as Any } from '../shared/core.Dgs6-nuz.mjs';
+import '../shared/core.yna0OdV5.mjs';
 import '../shared/core.CywrQs86.mjs';
 import '../types/fqnRef.mjs';
 
@@ -180,13 +181,13 @@ interface AddElement<Id extends string> {
 }
 
 interface ModelBuilder<T extends AnyTypes> extends Builder<T> {
-    __addElement(element: Element): Builder<T>;
-    __addRelation(relation: Omit<ModelRelation, 'id'>): Builder<T>;
+    __addElement(this: void, element: Element): Builder<T>;
+    __addRelation(this: void, relation: Omit<ModelRelation, 'id'>): Builder<T>;
     /**
      * Create a fully qualified name from an id (for nested models)
      */
-    __fqn(id: string): Fqn;
-    __addSourcelessRelation(relation: Omit<ModelRelation, 'id' | 'source'>): Builder<T>;
+    __fqn(this: void, id: string): Fqn;
+    __addSourcelessRelation(this: void, relation: Omit<ModelRelation, 'id' | 'source'>): Builder<T>;
 }
 declare function model<A extends AnyTypes>(): (input: Builder<A>) => Builder<A>;
 declare function model<A extends AnyTypes, B extends AnyTypes>(op1: (input: ModelBuilder<A>) => ModelBuilder<B>): (input: Builder<A>) => Builder<B>;
@@ -557,31 +558,89 @@ interface Builder<T extends AnyTypes> extends BuilderMethods<T> {
     toLikeC4Model<const Project extends BuilderProjectSpecification>(project: Project): LikeC4Model.Computed<setProject<Types.ToAux<T>, Project['id']>>;
     toLikeC4Model(): LikeC4Model.Computed<Types.ToAux<T>>;
 }
-declare namespace Builder {
-    type Any = Builder<AnyTypes>;
-    function forSpecification<const Spec extends BuilderSpecification>(spec: Spec): {
+declare const Builder: {
+    /**
+     * Creates a builder with compositional methods
+     *
+     * @example
+     * ```ts
+     * const {
+     *   model: { model, system, component, relTo },
+     *   deployment: { env, vm},
+     *   views: { view, $include },
+     *   builder,
+     * } = Builder.forSpecification({
+     *   elements: {
+     *     system: {},
+     *     component: {},
+     *   },
+     *   deployments: ['env', 'vm'],
+     * })
+     *
+     * const b = builder
+     *   .with(
+     *     model(
+     *       system('cloud').with(
+     *         component('backend'),
+     *         component('backend.api'),
+     *         component('frontend').with(
+     *           relTo('cloud.backend.api'),
+     *         ),
+     *       ),
+     *     ),
+     *   )
+     * ```
+     */
+    forSpecification<const Spec extends BuilderSpecification>(spec: Spec): {
         builder: Builder<Types.FromSpecification<Spec>>;
         model: ModelHelpers<Types.FromSpecification<Spec>>;
         deployment: DeloymentModelHelpers<Types.FromSpecification<Spec>>;
         views: ViewsHelpers;
     };
-    function specification<const Spec extends BuilderSpecification>(spec: Spec): Builder<Types.FromSpecification<Spec>>;
+    /**
+     * Creates a builder with chainable methods
+     *
+     * @example
+     * ```ts
+     * const b = Builder
+     *   .specification({
+     *     elements: ['system', 'component'],
+     *     deployments: ['env', 'vm'],
+     *   })
+     *   .model(({ system, component, relTo }, _) =>
+     *     _(
+     *       system('cloud').with(
+     *         component('backend').with(
+     *           component('api'),
+     *         ),
+     *         component('frontend').with(
+     *           relTo('cloud.backend.api'),
+     *         )
+     *       )
+     *     )
+     *   )
+     * ```
+     */
+    specification<const Spec extends BuilderSpecification>(spec: Spec): Builder<Types.FromSpecification<Spec>>;
+};
+declare namespace Builder {
+    type Any = Builder<AnyTypes>;
 }
 
 type ElementSpecification = Omit<ElementSpecification$1, 'tags'> & {
     tags?: string[];
 };
 type BuilderSpecification = {
-    elements: {
+    elements: string[] | {
         [kind: string]: Partial<ElementSpecification>;
     };
-    relationships?: {
+    relationships?: string[] | {
         [kind: string]: Partial<RelationshipSpecification>;
     };
-    deployments?: {
+    deployments?: string[] | {
         [kind: string]: Partial<ElementSpecification>;
     };
-    tags?: {
+    tags?: string[] | {
         [kind: string]: Partial<TagSpecification>;
     };
     metadataKeys?: string[];
@@ -594,12 +653,14 @@ type BuilderSpecification = {
 type BuilderProjectSpecification = {
     id: string;
     title?: string;
+    styles?: PartialDeep<LikeC4ProjectStylesConfig>;
 };
 type Metadata<MetadataKey extends string> = IsNever<MetadataKey> extends true ? never : IsLiteral<MetadataKey> extends true ? {
     [key in MetadataKey]?: string;
 } : Record<string, string>;
 type NewElementProps<Tag, Metadata> = {
     title?: string;
+    summary?: string;
     description?: string;
     technology?: string;
     tags?: IfNever<Tag, never, [Tag, ...Tag[]]>;
@@ -621,6 +682,7 @@ type NewElementProps<Tag, Metadata> = {
 };
 type NewDeploymentNodeProps<Tag, Metadata> = {
     title?: string;
+    summary?: string;
     description?: string;
     technology?: string;
     tags?: IfNever<Tag, never, [Tag, ...Tag[]]>;
@@ -676,6 +738,7 @@ interface TypesNested<Parent extends string, ElementKind extends string, Fqn ext
 }
 type AnyTypes = Types<any, any, any, any, any, any, any, any>;
 type AnyTypesNested = TypesNested<any, any, any, any, any, any, any, any, any>;
+type KeysOrTuple<T> = T extends readonly string[] ? TupleToUnion<T> : KeysOf<T>;
 /**
  * Auxilary type to keep track of the types in builder
  */
@@ -695,7 +758,7 @@ interface Types<ElementKind extends string, Fqn extends string, ViewId extends s
     NewDeploymentNodeProps: NewDeploymentNodeProps<Tag, Metadata<MetadataKey>>;
 }
 declare namespace Types {
-    type FromSpecification<Spec> = Spec extends BuilderSpecification ? Types<KeysOf<Spec['elements']>, never, never, KeysOf<Spec['relationships']>, KeysOf<Spec['tags']>, TupleToUnion<Spec['metadataKeys']>, KeysOf<Spec['deployments']>, never> : never;
+    type FromSpecification<Spec> = Spec extends BuilderSpecification ? Types<KeysOrTuple<Spec['elements']>, never, never, KeysOrTuple<Spec['relationships']>, KeysOrTuple<Spec['tags']>, TupleToUnion<Spec['metadataKeys']>, KeysOrTuple<Spec['deployments']>, never> : never;
     type AddFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], `${P}.${Id}` | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], Id | T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never;
     type AddDeploymentFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], `${P}.${Id}` | T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], Id | T['DeploymentFqn']> : never;
     type AddView<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<P, T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : T extends AnyTypes ? Types<T['ElementKind'], T['Fqn'], Id | T['ViewId'], T['RelationshipKind'], T['Tag'], T['MetadataKey'], T['DeploymentKind'], T['DeploymentFqn']> : never;