@likec4/core 1.40.0 → 1.42.0

package/dist/shared/{core.vWJTxpLV.d.mts → core.D_vkffV4.d.mts}

@@ -1,5 +1,6 @@
-import { I as IterableContainer, R as ReorderedArray, N as NonEmptyArray } from './core.DrvfVXkh.mjs';
+import { I as IterableContainer, R as ReorderedArray, N as NonEmptyArray } from './core.D5fzJWbF.mjs';
 import { F as Fqn } from './core.DX-WYEPA.mjs';
+import { SetRequired, SetNonNullable } from 'type-fest';
 
 /**
  * Mnemonist DefaultWeakMap Typings
@@ -305,6 +306,7 @@ declare function sortNaturalByFqn<A extends IterableContainer<WithId>>(array: A,
 
 declare function isString(value: unknown): value is string;
 declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
+declare function hasProp<T extends object, P extends keyof T & string>(value: T, path: P): value is SetRequired<SetNonNullable<T, P>, P>;
 
 /**
  * Saves the value returned by fn() in a hidden property tag of obj object, so next time memoizeProp() is called,
@@ -327,4 +329,4 @@ declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEm
  */
 declare function memoizeProp<Tag extends symbol | string, Res>(obj: object, tag: Tag, fn: () => Res): Res;
 
-export { BiMap as B, DefaultWeakMap as D, LinkedList as L, MultiMap as M, Queue as Q, ancestorsFqn as a, isAncestor as b, isDescendantOf as c, isNonEmptyArray as d, isSameHierarchy as e, isString as f, nonexhaustive as g, nonNullable as h, invariant as i, sortParentsFirst as j, commonAncestor as k, compareByFqnHierarchically as l, memoizeProp as m, nameFromFqn as n, compareFqnHierarchically as o, parentFqn as p, hierarchyDistance as q, hierarchyLevel as r, sortNaturalByFqn as s, sortByFqnHierarchically as t };
+export { BiMap as B, DefaultWeakMap as D, LinkedList as L, MultiMap as M, Queue as Q, ancestorsFqn as a, isAncestor as b, isDescendantOf as c, isNonEmptyArray as d, isSameHierarchy as e, isString as f, nonexhaustive as g, hasProp as h, invariant as i, nonNullable as j, sortParentsFirst as k, commonAncestor as l, memoizeProp as m, nameFromFqn as n, compareByFqnHierarchically as o, parentFqn as p, compareFqnHierarchically as q, hierarchyDistance as r, sortNaturalByFqn as s, hierarchyLevel as t, sortByFqnHierarchically as u };

package/dist/shared/core.DdMJk7nx.d.mts

@@ -0,0 +1,476 @@
+import { IsNever, IsAny } from 'type-fest';
+import { A as Any, U as Unknown, W as WithDescriptionAndTech, n as WithOptionalTags, o as WithOptionalLinks, q as WithMetadata, r as WithNotation, s as DeploymentFqn, t as DeploymentKind, F as Fqn, T as Tag, j as ElementKind, R as RelationKind, u as MetadataKey, f as _stage, g as _type, h as StrictViewId, N as NodeId, v as EdgeId, E as ExtractOnStage, M as ModelStage, P as ProjectId, k as ElementId, D as DeploymentId, d as UnknownParsed, V as ViewId, b as UnknownComputed, c as UnknownLayouted, S as SpecAux, a as Aux, w as Never } from './core.Dgs6-nuz.mjs';
+import { N as NonEmptyArray, L as Link, E as ExclusiveUnion, K as KeysOf } from './core.D5fzJWbF.mjs';
+import { E as ElementStyle, A as AbstractRelationship, y as BaseViewProperties, D as ViewWithHash, C as ViewWithNotation, v as ViewAutoLayout, H as ComputedNode, B as BBox, I as ComputedEdge, P as Point, X as XYPoint, a1 as DynamicViewDisplayVariant, z as BaseParsedViewProperties, l as AnyIncludePredicate, m as AnyExcludePredicate, n as AnyViewRuleStyle, t as ViewRuleAutoLayout, aa as ParsedElementView, a2 as ParsedDynamicView, J as ComputedElementView, K as ComputedDeploymentView, O as ComputedDynamicView, x as ViewType, k as LikeC4Project, f as Element, g as Relationship, M as ModelGlobals } from './core.fHR_8Tnq.mjs';
+import { FqnRef } from '../types/fqnRef.mjs';
+import { D as ThemeColor, C as ColorLiteral, u as ElementShape, Q as Color, s as BorderStyle, q as ShapeSize, r as SpacingSize, p as TextSize, v as RelationshipLineType, y as RelationshipArrowType, I as CustomColorDefinitions, E as Expression, F as FqnExpr } from './core.CQngdcuj.mjs';
+import { T as Tag$1, M as MarkdownOrString, I as Icon, d as RelationId } from './core.DX-WYEPA.mjs';
+
+interface DeploymentNode<A extends Any = Unknown> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+    element?: never;
+    readonly id: DeploymentFqn<A>;
+    readonly kind: DeploymentKind<A>;
+    readonly title: string;
+    readonly style: ElementStyle;
+}
+interface DeployedInstance<A extends Any = Unknown> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+    kind?: never;
+    /**
+     * Format: `<DeploymentNode Fqn>.<Instance Id>`
+     * i.e parent fqn is deployment target
+     */
+    readonly id: DeploymentFqn<A>;
+    readonly element: Fqn<A>;
+    readonly title?: string;
+    readonly style: ElementStyle;
+}
+type DeploymentElement<A extends Any = Unknown> = DeploymentNode<A> | DeployedInstance<A>;
+type DeploymentElementRef<A extends Any = Unknown> = {
+    readonly id: DeploymentFqn<A>;
+    readonly element?: Fqn<A>;
+};
+declare function isDeploymentNode<A extends Any>(el: DeploymentElement<A>): el is DeploymentNode<A>;
+declare function isDeployedInstance<A extends Any>(el: DeploymentElement<A>): el is DeployedInstance<A>;
+/**
+ * Relationship in deployment model
+ */
+interface DeploymentRelationship<A extends Any = Unknown> extends AbstractRelationship<A> {
+    readonly source: FqnRef.DeploymentRef<A>;
+    readonly target: FqnRef.DeploymentRef<A>;
+}
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link DeploymentRelationship} instead
+ */
+type DeploymentRelation<A extends Any = Unknown> = DeploymentRelationship<A>;
+
+/**
+ * Element and deployment kind specification
+ */
+interface ElementSpecification {
+    tags?: Tag$1[];
+    title?: string;
+    summary?: MarkdownOrString;
+    description?: MarkdownOrString;
+    technology?: string;
+    notation?: string;
+    links?: NonEmptyArray<Link>;
+    style: {
+        shape?: ElementShape;
+        icon?: Icon;
+        color?: Color;
+        border?: BorderStyle;
+        opacity?: number;
+        size?: ShapeSize;
+        padding?: SpacingSize;
+        textSize?: TextSize;
+        multiple?: boolean;
+    };
+}
+interface TagSpecification {
+    color: ThemeColor | ColorLiteral;
+}
+/**
+ * Checks if tag color is defined in the specification
+ * Expects HEX, `rgb(...)` or `rgba(...)` color
+ */
+declare function isTagColorSpecified(spec: string | TagSpecification): spec is {
+    color: ColorLiteral;
+};
+interface RelationshipSpecification {
+    technology?: string;
+    notation?: string;
+    color?: Color;
+    line?: RelationshipLineType;
+    head?: RelationshipArrowType;
+    tail?: RelationshipArrowType;
+}
+type Specification<A> = A extends Any ? {
+    tags: {
+        [key in Tag<A>]: TagSpecification;
+    };
+    elements: {
+        [key in ElementKind<A>]: Partial<ElementSpecification>;
+    };
+    deployments: {
+        [key in DeploymentKind<A>]: Partial<ElementSpecification>;
+    };
+    relationships: {
+        [key in RelationKind<A>]: Partial<RelationshipSpecification>;
+    };
+    metadataKeys?: IsNever<MetadataKey<A>> extends true ? never : MetadataKey<A>[];
+    customColors?: CustomColorDefinitions;
+} : never;
+
+interface DiagramNode<A extends Any = Any> extends ComputedNode<A>, BBox {
+    /**
+     * Absolute X coordinate
+     */
+    x: number;
+    /**
+     * Absolute Y coordinate
+     */
+    y: number;
+    width: number;
+    height: number;
+    /**
+     * Bounding box of label
+     * (Absolute coordinates)
+     */
+    labelBBox: BBox;
+}
+interface DiagramEdge<A extends Any = Any> extends ComputedEdge<A> {
+    /**
+     * Bezier points
+     * (Absolute coordinates)
+     */
+    points: NonEmptyArray<Point>;
+    /**
+     * Control points to adjust the edge
+     * (Absolute coordinates)
+     */
+    controlPoints?: NonEmptyArray<XYPoint>;
+    /**
+     * Bounding box of label
+     * (Absolute coordinates)
+     */
+    labelBBox?: BBox | null;
+    /**
+     * Graphviz edge POS
+     *
+     * TODO: temporary solution, should be moved out
+     * @deprecated
+     */
+    dotpos?: string;
+}
+interface BaseLayoutedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+    readonly [_stage]: 'layouted';
+    readonly autoLayout: ViewAutoLayout;
+    readonly nodes: DiagramNode<A>[];
+    readonly edges: DiagramEdge<A>[];
+    readonly bounds: BBox;
+    /**
+     * If diagram has manual layout
+     * But was changed and layout should be recalculated
+     */
+    hasLayoutDrift?: boolean;
+}
+interface LayoutedElementView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+    readonly [_type]: 'element';
+    readonly viewOf?: Fqn<A>;
+    readonly extends?: StrictViewId<A>;
+}
+interface LayoutedDeploymentView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+    readonly [_type]: 'deployment';
+}
+interface LayoutedDynamicView<A extends Any = Any> extends BaseLayoutedViewProperties<A> {
+    readonly [_type]: 'dynamic';
+    /**
+     * How to display the dynamic view
+     * - `diagram`: display as a regular likec4 view
+     * - `sequence`: display as a sequence diagram
+     */
+    readonly variant: DynamicViewDisplayVariant;
+    /**
+     * Sequence layout of this dynamic view
+     */
+    readonly sequenceLayout: LayoutedDynamicView.Sequence.Layout;
+}
+declare namespace LayoutedDynamicView {
+    namespace Sequence {
+        interface ActorPort {
+            readonly id: string;
+            readonly cx: number;
+            readonly cy: number;
+            readonly height: number;
+            readonly type: 'target' | 'source';
+            readonly position: 'left' | 'right' | 'top' | 'bottom';
+        }
+        interface Actor {
+            readonly id: NodeId;
+            readonly x: number;
+            readonly y: number;
+            readonly width: number;
+            readonly height: number;
+            readonly ports: ReadonlyArray<ActorPort>;
+        }
+        interface Compound {
+            readonly id: NodeId;
+            /**
+             * Original node id, since multiple compound nodes can be built from one node
+             */
+            readonly origin: NodeId;
+            readonly x: number;
+            readonly y: number;
+            readonly width: number;
+            readonly height: number;
+            readonly depth: number;
+        }
+        interface ParallelArea {
+            readonly parallelPrefix: string;
+            readonly x: number;
+            readonly y: number;
+            readonly width: number;
+            readonly height: number;
+        }
+        interface Step {
+            readonly id: EdgeId;
+            readonly labelBBox?: {
+                width: number;
+                height: number;
+            } | undefined;
+            readonly sourceHandle: string;
+            readonly targetHandle: string;
+        }
+        interface Layout {
+            readonly actors: ReadonlyArray<Actor>;
+            /**
+             * Steps in the sequence diagram (filtered edges with compound nodes)
+             */
+            readonly steps: ReadonlyArray<Step>;
+            readonly compounds: ReadonlyArray<Compound>;
+            readonly parallelAreas: ReadonlyArray<ParallelArea>;
+            readonly bounds: BBox;
+        }
+    }
+}
+
+/**
+ * Predicates scoped to deployment model
+ */
+interface DeploymentViewIncludePredicate<A extends Any = Unknown> extends AnyIncludePredicate<Expression<A>> {
+}
+interface DeploymentViewExcludePredicate<A extends Any = Unknown> extends AnyExcludePredicate<Expression<A>> {
+}
+type DeploymentViewPredicate<A extends Any = Unknown> = DeploymentViewIncludePredicate<A> | DeploymentViewExcludePredicate<A>;
+interface DeploymentViewRuleStyle<A extends Any = Unknown> extends AnyViewRuleStyle<FqnExpr<A>> {
+}
+type DeploymentViewRule<A extends Any = Unknown> = ExclusiveUnion<{
+    Include: DeploymentViewIncludePredicate<A>;
+    Exclude: DeploymentViewExcludePredicate<A>;
+    Style: DeploymentViewRuleStyle<A>;
+    AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedDeploymentView<A extends Any = Unknown> extends BaseParsedViewProperties<A> {
+    [_type]: 'deployment';
+    readonly rules: DeploymentViewRule<A>[];
+}
+
+type ParsedView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A>;
+
+type ComputedView<A extends Any = Any> = ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A>;
+type LayoutedView<A extends Any = Any> = LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
+type ProcessedView<A extends Any = Any> = ComputedView<A> | LayoutedView<A>;
+
+type AnyView<A extends Any = Any> = ParsedElementView<A> | ParsedDeploymentView<A> | ParsedDynamicView<A> | ComputedElementView<A> | ComputedDeploymentView<A> | ComputedDynamicView<A> | LayoutedElementView<A> | LayoutedDeploymentView<A> | LayoutedDynamicView<A>;
+type ViewOnStage<V extends AnyView<Any>, T extends ModelStage> = Extract<V, {
+    [_stage]: T;
+}>;
+type ViewWithType<V extends AnyView<Any>, T extends ViewType> = Extract<V, {
+    [_type]: T;
+}>;
+type ViewRule<A extends Any = Any> = ParsedView<A>['rules'][number];
+type ViewRulePredicate<A extends Any = Any> = Extract<ViewRule<A>, {
+    include: any[];
+} | {
+    exclude: any[];
+}>;
+declare function isViewRulePredicate<V extends ViewRule<any>>(rule: V): rule is Extract<V, {
+    include: any[];
+} | {
+    exclude: any[];
+}>;
+declare function isViewRuleStyle<V extends ViewRule<any>>(rule: V): rule is Extract<V, {
+    targets: any[];
+    style: {};
+}>;
+declare function isComputedView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'computed'>;
+declare function isDiagramView<V extends AnyView<any>>(view: V): view is ExtractOnStage<V, 'layouted'>;
+
+declare function isElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'>;
+declare function isScopedElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> & {
+    viewOf: Fqn<Any>;
+};
+declare function isExtendsElementView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'element'> & {
+    extends: StrictViewId<Any>;
+};
+declare function isDeploymentView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'deployment'>;
+declare function isDynamicView<V extends AnyView<any>>(view: V): view is ViewWithType<V, 'dynamic'>;
+
+interface BaseLikeC4ModelData<A extends Any> {
+    projectId: ProjectId<A>;
+    project: LikeC4Project;
+    specification: Specification<A>;
+    elements: Record<ElementId<A>, Element<A>>;
+    deployments: {
+        elements: Record<DeploymentId<A>, DeploymentElement<A>>;
+        relations: Record<RelationId, DeploymentRelationship<A>>;
+    };
+    relations: Record<RelationId, Relationship<A>>;
+    globals: ModelGlobals;
+    imports: Record<string, NonEmptyArray<Element<A>>>;
+}
+type AuxFromLikeC4ModelData<D> = D extends BaseLikeC4ModelData<infer A extends Any> ? IsAny<A> extends true ? never : A : never;
+/**
+ * Represents a LikeC4 model with customizable type parameters,
+ * parsed from DSL or result from Builder
+ *
+ * !IMPORTANT: This is a low-level type, use `LikeC4Model` instead.
+ * !NOTE: Views are not computed yet.
+ *
+ * @typeParam ElementKinds - Types of elements in the model (defaults to string)
+ * @typeParam RelationKinds - Types of relationships (defaults to string)
+ * @typeParam Tags - Types of tags that can be applied (defaults to string)
+ * @typeParam Fqns - Fully Qualified Names for elements (defaults to string)
+ * @typeParam Views - Types of views in the model (defaults to string)
+ * @typeParam DeploymentFqns - Fully Qualified Names for deployment nodes (defaults to string)
+ */
+interface ParsedLikeC4ModelData<A extends Any = UnknownParsed> extends BaseLikeC4ModelData<A> {
+    [_stage]: 'parsed';
+    views: Record<ViewId<A>, ParsedView<A>>;
+}
+interface ComputedLikeC4ModelData<A extends Any = UnknownComputed> extends BaseLikeC4ModelData<A> {
+    [_stage]: 'computed';
+    views: Record<ViewId<A>, ComputedView<A>>;
+}
+interface LayoutedLikeC4ModelData<A extends Any = UnknownLayouted> extends BaseLikeC4ModelData<A> {
+    [_stage]: 'layouted';
+    views: Record<ViewId<A>, LayoutedView<A>>;
+}
+type LikeC4ModelData<A extends Any> = ParsedLikeC4ModelData<A> | ComputedLikeC4ModelData<A> | LayoutedLikeC4ModelData<A>;
+
+/**
+ * JSON representation of {@link Specification}
+ */
+interface SpecificationDump {
+    elements: {
+        [kind: string]: object;
+    };
+    tags?: {
+        [tag: string]: object;
+    };
+    deployments?: {
+        [kind: string]: object;
+    };
+    relationships?: {
+        [kind: string]: object;
+    };
+    metadataKeys?: string[];
+    customColors?: {
+        [kind: string]: object;
+    };
+}
+type SpecTypesFromDump<J> = J extends SpecificationDump ? SpecAux<KeysOf<J['elements']>, KeysOf<J['deployments']>, KeysOf<J['relationships']>, KeysOf<J['tags']>, J['metadataKeys'] extends readonly [string, ...string[]] ? J['metadataKeys'][number] : never> : SpecAux<never, never, never, never, never>;
+/**
+ * Dump differs from {@link ParsedLikeC4ModelData} by the fact that it is computed or layouted
+ */
+type LikeC4ModelDump = {
+    [_stage]?: 'computed' | 'layouted';
+    projectId?: string;
+    project?: ProjectDump;
+    specification: SpecificationDump;
+    elements?: {
+        [kind: string]: object;
+    };
+    deployments: {
+        elements?: {
+            [kind: string]: object;
+        };
+        relations?: {};
+    };
+    views?: {
+        [kind: string]: object;
+    };
+    relations?: {};
+    globals?: {
+        predicates?: {};
+        dynamicPredicates?: {};
+        styles?: {};
+    };
+    imports?: {};
+};
+type ProjectDump = {
+    id: string;
+    name?: string;
+    title?: string | undefined;
+};
+type AuxFromDump<D> = D extends LikeC4ModelDump ? Aux<D[_stage] extends infer S extends 'computed' | 'layouted' ? S : 'computed' | 'layouted' | 'parsed', KeysOf<D['elements']>, KeysOf<D['deployments']['elements']>, KeysOf<D['views']>, D['projectId'] extends infer PID extends string ? PID : never, SpecTypesFromDump<D['specification']>> : Never;
+
+interface RichTextEmpty {
+    readonly isEmpty: true;
+    readonly isMarkdown: false;
+    readonly nonEmpty: false;
+    readonly $source: null;
+    readonly text: null;
+    readonly md: null;
+    readonly html: null;
+    equals(other: unknown): boolean;
+}
+interface RichTextNonEmpty {
+    readonly isEmpty: false;
+    readonly nonEmpty: true;
+    readonly isMarkdown: boolean;
+    readonly $source: MarkdownOrString;
+    readonly text: string;
+    readonly md: string;
+    readonly html: string;
+    equals(other: unknown): boolean;
+}
+type RichTextOrEmpty = RichTextNonEmpty | RichTextEmpty;
+/**
+ * RichText is a class that represents a potentially markdown string.
+ * It can be either a plain text or a markdown.
+ * It is used to represent the content of a node or a link.
+ */
+declare class RichText {
+    private static _cache;
+    /**
+     * Creates and memoizes a RichText instance.
+     * @see ElementModel.description
+     * @example
+     *
+     *  get description(): RichTextOrEmpty {
+     *    return RichText.memoize(this, this.$element.description)
+     *  }
+     */
+    static memoize(obj: object, tag: symbol | string, source: MarkdownOrString | null | undefined): RichTextOrEmpty;
+    /**
+     * Creates a RichText instance from a source.
+     */
+    static from(source: RichTextOrEmpty | MarkdownOrString | string | null | undefined): RichTextOrEmpty;
+    /**
+     * This is a workaround for the fact that we need instance of RichText for `instanceof` checks
+     * It is invalid inheritance (returning `null` from getters), and we cast to @see RichTextEmpty
+     */
+    static EMPTY: RichTextEmpty;
+    readonly $source: Readonly<MarkdownOrString> | null;
+    readonly isEmpty: boolean;
+    readonly nonEmpty: boolean;
+    readonly isMarkdown: boolean;
+    /**
+     * Private constructor to prevent direct instantiation.
+     * Use {@link RichText.from} or {@link RichText.memoize} instead.
+     */
+    private constructor();
+    /**
+     * Returns the text content of the rich text.
+     * If the source is a string, it returns the string.
+     * If the source is a markdown, it returns the markdown.
+     */
+    get text(): string;
+    /**
+     * Returns the markdown content of the rich text.
+     * If the source is a string, it returns the string.
+     * If the source is a markdown, it returns the markdown.
+     */
+    get md(): string;
+    /**
+     * Returns the html content of the rich text.
+     * If the source is a string, it returns the string.
+     * If the source is a markdown, it returns the HTML.
+     */
+    get html(): string;
+    equals(other: unknown): boolean;
+}
+
+export { type DeploymentViewRule as $, type AuxFromLikeC4ModelData as A, isViewRulePredicate as B, type ComputedLikeC4ModelData as C, type DeploymentNode as D, type ElementSpecification as E, isViewRuleStyle as F, isComputedView as G, isElementView as H, isScopedElementView as I, isExtendsElementView as J, isDeploymentView as K, type LayoutedLikeC4ModelData as L, isDynamicView as M, type DiagramNode as N, type DiagramEdge as O, type ParsedLikeC4ModelData as P, type LayoutedElementView as Q, RichText as R, type SpecificationDump as S, type TagSpecification as T, type LayoutedDeploymentView as U, type ViewOnStage as V, LayoutedDynamicView as W, type DeploymentViewIncludePredicate as X, type DeploymentViewExcludePredicate as Y, type DeploymentViewPredicate as Z, type DeploymentViewRuleStyle as _, type RichTextEmpty as a, type ParsedDeploymentView as a0, type RichTextOrEmpty as b, type LikeC4ModelData as c, type DeployedInstance as d, type DeploymentElement as e, type DeploymentElementRef as f, isDeployedInstance as g, type DeploymentRelationship as h, isDeploymentNode as i, type DeploymentRelation as j, type SpecTypesFromDump as k, type LikeC4ModelDump as l, type ProjectDump as m, type AuxFromDump as n, isTagColorSpecified as o, type RelationshipSpecification as p, type Specification as q, type ParsedView as r, type LayoutedView as s, isDiagramView as t, type ComputedView as u, type ProcessedView as v, type AnyView as w, type ViewWithType as x, type ViewRule as y, type ViewRulePredicate as z };

package/dist/shared/{core.D_fI5Lf6.d.mts → core.Dgs6-nuz.d.mts}

@@ -1,6 +1,6 @@
 import { IfNever, IsNever, IsLiteral } from 'type-fest';
-import { C as Coalesce, L as Link } from './core.DrvfVXkh.mjs';
-import { D as DeploymentFqn$1, F as Fqn$1, d as RelationId$1, N as NodeId$1, j as EdgeId$1, P as ProjectId$1, V as ViewId$1, T as Tag$1, E as ElementKind$1, b as DeploymentKind$1, c as RelationshipKind } from './core.DX-WYEPA.mjs';
+import { C as Coalesce, L as Link } from './core.D5fzJWbF.mjs';
+import { D as DeploymentFqn$1, F as Fqn$1, d as RelationId$1, N as NodeId$1, j as EdgeId$1, P as ProjectId$1, V as ViewId$1, T as Tag$1, E as ElementKind$1, b as DeploymentKind$1, c as RelationshipKind, M as MarkdownOrString } from './core.DX-WYEPA.mjs';
 
 /**
  * Determines the stage of the model:
@@ -172,6 +172,19 @@ type StrictTag<A> = A extends infer T extends Any ? Tag$1<Tag<T>> : never;
 type StrictElementKind<A> = A extends infer T extends Any ? ElementKind$1<ElementKind<T>> : never;
 type StrictDeploymentKind<A> = A extends infer T extends Any ? DeploymentKind$1<DeploymentKind<T>> : never;
 type StrictRelationKind<A> = A extends infer T extends Any ? RelationshipKind<RelationKind<T>> : never;
+type WithDescriptionAndTech = {
+    readonly summary?: MarkdownOrString | null;
+    readonly description?: MarkdownOrString | null;
+    readonly technology?: string | null;
+};
+/**
+ * Returns summary if it is not null, otherwise returns description
+ */
+declare function preferSummary(a: WithDescriptionAndTech): MarkdownOrString | null | undefined;
+/**
+ * Returns description if it is not null, otherwise returns summary
+ */
+declare function preferDescription(a: WithDescriptionAndTech): MarkdownOrString | null | undefined;
 type WithTags<A extends Any> = {
     readonly tags: Tags<A>;
 };
@@ -187,6 +200,9 @@ type WithOptionalLinks = {
 type WithMetadata<A extends Any> = {
     readonly metadata?: Metadata<A>;
 };
+type WithNotation = {
+    readonly notation?: string | null;
+};
 /**
  * @see {@link LiteralUnion} from type-fest (https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts)
  */
@@ -244,18 +260,22 @@ type _aux_UnknownComputed = UnknownComputed;
 type _aux_UnknownLayouted = UnknownLayouted;
 type _aux_UnknownParsed = UnknownParsed;
 type _aux_ViewId<A> = ViewId<A>;
+type _aux_WithDescriptionAndTech = WithDescriptionAndTech;
 type _aux_WithLinks = WithLinks;
 type _aux_WithMetadata<A extends Any> = WithMetadata<A>;
+type _aux_WithNotation = WithNotation;
 type _aux_WithOptionalLinks = WithOptionalLinks;
 type _aux_WithOptionalTags<A extends Any> = WithOptionalTags<A>;
 type _aux_WithTags<A extends Any> = WithTags<A>;
+declare const _aux_preferDescription: typeof preferDescription;
+declare const _aux_preferSummary: typeof preferSummary;
 type _aux_setProject<A, P extends string> = setProject<A, P>;
 type _aux_setStage<A, S extends ModelStage> = setStage<A, S>;
 type _aux_toComputed<A> = toComputed<A>;
 type _aux_toLayouted<A> = toLayouted<A>;
 type _aux_toParsed<A> = toParsed<A>;
 declare namespace _aux {
-  export type { _aux_AllKinds as AllKinds, _aux_Any as Any, Any as AnyAux, _aux_AnySpec as AnySpec, _aux_Aux as Aux, _aux_DeploymentFqn as DeploymentFqn, _aux_DeploymentId as DeploymentId, _aux_DeploymentKind as DeploymentKind, _aux_EdgeId as EdgeId, _aux_ElementId as ElementId, _aux_ElementKind as ElementKind, _aux_Fqn as Fqn, _aux_LooseDeploymentId as LooseDeploymentId, _aux_LooseDeploymentKind as LooseDeploymentKind, _aux_LooseElementId as LooseElementId, _aux_LooseElementKind as LooseElementKind, _aux_LooseRelationKind as LooseRelationKind, _aux_LooseTag as LooseTag, _aux_LooseTags as LooseTags, _aux_LooseViewId as LooseViewId, _aux_Metadata as Metadata, _aux_MetadataKey as MetadataKey, _aux_Never as Never, _aux_NodeId as NodeId, _aux_OrString as OrString, _aux_PickByStage as PickByStage, _aux_ProjectId as ProjectId, _aux_RelationId as RelationId, _aux_RelationKind as RelationKind, _aux_Spec as Spec, _aux_SpecAux as SpecAux, _aux_Stage as Stage, DeploymentFqn as StrictDeploymentFqn, _aux_StrictDeploymentKind as StrictDeploymentKind, _aux_StrictElementKind as StrictElementKind, Fqn as StrictFqn, _aux_StrictProjectId as StrictProjectId, _aux_StrictRelationKind as StrictRelationKind, _aux_StrictTag as StrictTag, _aux_StrictViewId as StrictViewId, _aux_Tag as Tag, _aux_Tags as Tags, _aux_Unknown as Unknown, _aux_UnknownComputed as UnknownComputed, _aux_UnknownLayouted as UnknownLayouted, _aux_UnknownParsed as UnknownParsed, _aux_ViewId as ViewId, _aux_WithLinks as WithLinks, _aux_WithMetadata as WithMetadata, _aux_WithOptionalLinks as WithOptionalLinks, _aux_WithOptionalTags as WithOptionalTags, _aux_WithTags as WithTags, _aux_setProject as setProject, _aux_setStage as setStage, _aux_toComputed as toComputed, _aux_toLayouted as toLayouted, _aux_toParsed as toParsed };
+  export { type _aux_AllKinds as AllKinds, type _aux_Any as Any, type Any as AnyAux, type _aux_AnySpec as AnySpec, type _aux_Aux as Aux, type _aux_DeploymentFqn as DeploymentFqn, type _aux_DeploymentId as DeploymentId, type _aux_DeploymentKind as DeploymentKind, type _aux_EdgeId as EdgeId, type _aux_ElementId as ElementId, type _aux_ElementKind as ElementKind, type _aux_Fqn as Fqn, type _aux_LooseDeploymentId as LooseDeploymentId, type _aux_LooseDeploymentKind as LooseDeploymentKind, type _aux_LooseElementId as LooseElementId, type _aux_LooseElementKind as LooseElementKind, type _aux_LooseRelationKind as LooseRelationKind, type _aux_LooseTag as LooseTag, type _aux_LooseTags as LooseTags, type _aux_LooseViewId as LooseViewId, type _aux_Metadata as Metadata, type _aux_MetadataKey as MetadataKey, type _aux_Never as Never, type _aux_NodeId as NodeId, type _aux_OrString as OrString, type _aux_PickByStage as PickByStage, type _aux_ProjectId as ProjectId, type _aux_RelationId as RelationId, type _aux_RelationKind as RelationKind, type _aux_Spec as Spec, type _aux_SpecAux as SpecAux, type _aux_Stage as Stage, type DeploymentFqn as StrictDeploymentFqn, type _aux_StrictDeploymentKind as StrictDeploymentKind, type _aux_StrictElementKind as StrictElementKind, type Fqn as StrictFqn, type _aux_StrictProjectId as StrictProjectId, type _aux_StrictRelationKind as StrictRelationKind, type _aux_StrictTag as StrictTag, type _aux_StrictViewId as StrictViewId, type _aux_Tag as Tag, type _aux_Tags as Tags, type _aux_Unknown as Unknown, type _aux_UnknownComputed as UnknownComputed, type _aux_UnknownLayouted as UnknownLayouted, type _aux_UnknownParsed as UnknownParsed, type _aux_ViewId as ViewId, type _aux_WithDescriptionAndTech as WithDescriptionAndTech, type _aux_WithLinks as WithLinks, type _aux_WithMetadata as WithMetadata, type _aux_WithNotation as WithNotation, type _aux_WithOptionalLinks as WithOptionalLinks, type _aux_WithOptionalTags as WithOptionalTags, type _aux_WithTags as WithTags, _aux_preferDescription as preferDescription, _aux_preferSummary as preferSummary, type _aux_setProject as setProject, type _aux_setStage as setStage, type _aux_toComputed as toComputed, type _aux_toLayouted as toLayouted, type _aux_toParsed as toParsed };
 }
 
-export { type WithTags as $, type Any as A, type WithMetadata as B, type EdgeId as C, type DeploymentId as D, type ExtractOnStage as E, type Fqn as F, type AnySpec as G, type PickByStage as H, type setStage as I, type NodeId as J, type Spec as K, type LooseTag as L, type ModelStage as M, type Never as N, type StrictProjectId as O, type ProjectId as P, type StrictTag as Q, type RelationKind as R, type SpecAux as S, type Tag as T, type Unknown as U, type ViewId as V, type WithOptionalTags as W, type StrictElementKind as X, type StrictDeploymentKind as Y, type StrictRelationKind as Z, _aux as _, type Aux as a, type WithLinks as a0, type OrString as a1, type LooseTags as a2, type LooseElementKind as a3, type LooseDeploymentKind as a4, type LooseRelationKind as a5, type UnknownComputed as b, type UnknownLayouted as c, type UnknownParsed as d, _stage as e, _type as f, type StrictViewId as g, type ElementKind as h, isOnStage as i, type ElementId as j, type AllKinds as k, type Tags as l, type Metadata as m, type MetadataKey as n, type DeploymentKind as o, type RelationId as p, type LooseElementId as q, type LooseDeploymentId as r, type DeploymentFqn as s, type toComputed as t, type toLayouted as u, type Stage as v, type toParsed as w, type LooseViewId as x, type setProject as y, type WithOptionalLinks as z };
+export { type StrictProjectId as $, type Any as A, type LooseElementId as B, type LooseDeploymentId as C, type DeploymentId as D, type ExtractOnStage as E, type Fqn as F, type toComputed as G, type toLayouted as H, type Stage as I, type toParsed as J, type LooseViewId as K, type LooseTag as L, type ModelStage as M, type NodeId as N, type setProject as O, type ProjectId as P, type AnySpec as Q, type RelationKind as R, type SpecAux as S, type Tag as T, type Unknown as U, type ViewId as V, type WithDescriptionAndTech as W, type PickByStage as X, type setStage as Y, type Spec as Z, _aux as _, type Aux as a, type StrictTag as a0, type StrictElementKind as a1, type StrictDeploymentKind as a2, type StrictRelationKind as a3, type WithLinks as a4, type OrString as a5, type LooseTags as a6, type LooseElementKind as a7, type LooseDeploymentKind as a8, type LooseRelationKind as a9, type UnknownComputed as b, type UnknownLayouted as c, type UnknownParsed as d, preferSummary as e, _stage as f, _type as g, type StrictViewId as h, isOnStage as i, type ElementKind as j, type ElementId as k, type AllKinds as l, type Tags as m, type WithOptionalTags as n, type WithOptionalLinks as o, preferDescription as p, type WithMetadata as q, type WithNotation as r, type DeploymentFqn as s, type DeploymentKind as t, type MetadataKey as u, type EdgeId as v, type Never as w, type WithTags as x, type Metadata as y, type RelationId as z };

package/dist/shared/{core.Be4Jy9Qx.mjs → core.FZ305VYd.mjs}

@@ -1,9 +1,9 @@
-import { isFunction } from 'remeda';
+import { e } from './core.DRJma0Ol.mjs';
 import { i as invariant } from './core.D4npX2q8.mjs';
 
 function isome(arg1, arg2) {
   const pred = arg2 ?? arg1;
-  invariant(isFunction(pred));
+  invariant(e(pred));
   function _some(iter) {
     for (const value of iter) {
       if (pred(value)) {

package/dist/shared/core.OHD4KXm9.mjs

@@ -0,0 +1,5 @@
+const e={done:true,hasNext:false},t$1={done:false,hasNext:false},n$1=()=>e;
+
+function t(e,...t){let a=e,o=t.map(e=>`lazy`in e?r(e):void 0),s=0;for(;s<t.length;){if(o[s]===void 0||!i(a)){let e=t[s];a=e(a),s+=1;continue}let e=[];for(let n=s;n<t.length;n++){let t=o[n];if(t===void 0||(e.push(t),t.isSingle))break}let r=[];for(let t of a)if(n(t,r,e))break;let{isSingle:c}=e.at(-1);a=c?r[0]:r,s+=e.length;}return a}function n(t,r,i){if(i.length===0)return r.push(t),false;let a=t,o=t$1,s=false;for(let[e,t]of i.entries()){let{index:c,items:l}=t;if(l.push(a),o=t(a,c,l),t.index+=1,o.hasNext){if(o.hasMany??false){for(let t of o.next)if(n(t,r,i.slice(e+1)))return  true;return s}a=o.next;}if(!o.hasNext)break;o.done&&(s=true);}return o.hasNext&&r.push(a),s}function r(e){let{lazy:t,lazyArgs:n}=e,r=t(...n);return Object.assign(r,{isSingle:t.single??false,index:0,items:[]})}function i(e){return typeof e==`string`||typeof e==`object`&&!!e&&Symbol.iterator in e}
+
+export { t$1 as a, n$1 as n, t };

package/dist/shared/{core.GTgsmXS_.mjs → core.QJD_fcrc.mjs}

@@ -1,9 +1,9 @@
-import { isFunction } from 'remeda';
+import { e } from './core.DRJma0Ol.mjs';
 import { i as invariant } from './core.D4npX2q8.mjs';
 
 function ifind(arg1, arg2) {
   const pred = arg2 ?? arg1;
-  invariant(isFunction(pred));
+  invariant(e(pred));
   function _find(iter) {
     for (const value of iter) {
       if (pred(value)) {

package/dist/shared/core.RfnaEmgA.mjs

@@ -0,0 +1,7 @@
+function e(e){return e!=null}
+
+function isIterable(something) {
+  return e(something) && typeof something === "object" && Symbol.iterator in something;
+}
+
+export { e, isIterable as i };