@likec4/core 1.47.0 → 1.48.0

package/dist/compute-view/relationships-view/index.d.mts

@@ -1,51 +1,16 @@
-import { A as Any, U as Unknown, a as ElementId, V as ViewId } from '../../shared/core.D00YbOhQ.mjs';
-import { E as ElementModel, R as RelationshipModel, f as LikeC4Model } from '../../shared/core.BfCKSW-g.mjs';
-import 'type-fest';
-import '../../shared/core.DB0Ue5Wx.mjs';
-import '../../shared/core.C_3y3eqV.mjs';
-import '../../shared/core.CAgYpDtM.mjs';
-import '../../shared/core.DC5IAaDT.mjs';
-import '../../types/fqnRef.mjs';
-import '../../shared/core.Dojz4bvg.mjs';
-import '../../types/expression-model.mjs';
-import '../../shared/core.BPGOjone.mjs';
-import '../../shared/core.CywrQs86.mjs';
-import '../../shared/core.osFs8tU7.mjs';
-
-type RelationshipsViewData<M extends Any = Unknown> = {
-    incomers: ReadonlySet<ElementModel<M>>;
-    incoming: ReadonlySet<RelationshipModel<M>>;
-    subjects: ReadonlySet<ElementModel<M>>;
-    outgoing: ReadonlySet<RelationshipModel<M>>;
-    outgoers: ReadonlySet<ElementModel<M>>;
-};
-
-declare function computeRelationshipsView<M extends Any>(subjectId: ElementId<M>, likec4model: LikeC4Model<M>, scopeViewId: ViewId<M> | null, scope?: 'global' | 'view'): RelationshipsViewData<M>;
-
-declare function treeFromElements<M extends Any>(elements: Iterable<ElementModel<M>>): {
-    sorted: readonly ElementModel<M>[];
-    byId: (id: ElementId<M>) => ElementModel<M>;
-    root: ReadonlySet<ElementModel<M>>;
-    parent: (el: ElementModel<M>) => ElementModel<M> | null;
-    children: (el: ElementModel<M>) => ReadonlyArray<ElementModel<M>>;
-    /**
-     * Flattens the tree structure by removing redundant hierarchy levels.
-     * @example
-     *   A
-     *   └── B
-     *       ├── C
-     *       │   └── D
-     *       │       └── E
-     *       └── F
-     *           └── G
-     * becomes
-     *   A
-     *   ├── C
-     *   │   └── E
-     *   └── F
-     *       └── G
-     */
-    flatten: () => Set<ElementModel<M>>;
-};
-
-export { type RelationshipsViewData, computeRelationshipsView, treeFromElements };
+import "../../_chunks/_aux.mjs";
+import "../../_chunks/scalar.mjs";
+import "../../_chunks/expression.mjs";
+import "../../_chunks/fqnRef.mjs";
+import "../../_chunks/expression-model.mjs";
+import "../../_chunks/index2.mjs";
+import "../../_chunks/RichText.mjs";
+import "../../_chunks/index3.mjs";
+import "../../_chunks/LikeC4Model.mjs";
+import "../../_chunks/const.mjs";
+import "../../_chunks/find.mjs";
+import "../../_chunks/find2.mjs";
+import "../../_chunks/index4.mjs";
+import "../../_chunks/index5.mjs";
+import { n as computeRelationshipsView, r as RelationshipsViewData, t as treeFromElements } from "../../_chunks/index6.mjs";
+export { RelationshipsViewData, computeRelationshipsView, treeFromElements };

package/dist/compute-view/relationships-view/index.mjs

@@ -1,185 +1,7 @@
-import { t } from '../../shared/core.3ZhnKAlZ.mjs';
-import { f as sortParentsFirst, b as isDescendantOf, i as isAncestor } from '../../shared/core.CdNCAwq7.mjs';
-import { D as DefaultMap } from '../../shared/core.BbE4y-yl.mjs';
-import { a as nonNullable, i as invariant } from '../../shared/core.D4npX2q8.mjs';
-import { t as toSet, a as toArray, i as imap } from '../../shared/core.C3JowhaZ.mjs';
-import { i as ifilter } from '../../shared/core.DRJma0Ol.mjs';
+import "../../_chunks/libs/natural-compare-lite.mjs";
+import "../../_chunks/libs/graphology-dag.mjs";
+import "../../_chunks/libs/defu.mjs";
+import "../../_chunks/libs/extend.mjs";
+import { n as treeFromElements, t as computeRelationshipsView } from "../../_chunks/relationships-view.mjs";
 
-function treeFromElements(elements) {
-  const sorted = sortParentsFirst([...elements]);
-  const root = new Set(sorted);
-  const map = new Map(sorted.map((e) => [e._literalId, e]));
-  const parents = new DefaultMap(() => null);
-  const children = sorted.reduce((acc, parent, index, all) => {
-    acc.set(
-      parent,
-      all.slice(index + 1).filter(isDescendantOf(parent)).map((e) => {
-        root.delete(e);
-        return e;
-      }).reduce((acc2, el) => {
-        if (!acc2.some(isAncestor(el))) {
-          acc2.push(el);
-          parents.set(el, parent);
-        }
-        return acc2;
-      }, [])
-    );
-    return acc;
-  }, new DefaultMap(() => []));
-  return {
-    sorted,
-    byId: (id) => nonNullable(map.get(id), `Element not found by id: ${id}`),
-    root,
-    parent: (el) => parents.get(el),
-    children: (el) => children.get(el),
-    /**
-     * Flattens the tree structure by removing redundant hierarchy levels.
-     * @example
-     *   A
-     *   └── B
-     *       ├── C
-     *       │   └── D
-     *       │       └── E
-     *       └── F
-     *           └── G
-     * becomes
-     *   A
-     *   ├── C
-     *   │   └── E
-     *   └── F
-     *       └── G
-     */
-    flatten: () => {
-      return /* @__PURE__ */ new Set([
-        ...root,
-        ...sorted.reduce((acc, el) => {
-          const _children = children.get(el);
-          if (_children.length === 0) {
-            acc.push(el);
-            return acc;
-          }
-          if (_children.length > 1) {
-            acc.push(..._children);
-          }
-          return acc;
-        }, [])
-      ]);
-    }
-  };
-}
-
-const finalize = (elements, explicits) => {
-  if (elements.size > 2 && explicits.size !== elements.size) {
-    return new Set(sortParentsFirst([
-      ...treeFromElements(elements).flatten(),
-      ...explicits
-    ]));
-  }
-  if (elements.size > 1) {
-    return new Set(sortParentsFirst([...elements]));
-  }
-  return elements;
-};
-function computeRelationships(subject, others, relationships) {
-  const isOther = (e) => others.has(e);
-  let subjects = /* @__PURE__ */ new Set([subject]);
-  const explicits = {
-    incomers: /* @__PURE__ */ new Set(),
-    subjects: /* @__PURE__ */ new Set([subject]),
-    outgoers: /* @__PURE__ */ new Set()
-  };
-  let incomers = new Set(relationships.incoming.flatMap((r) => {
-    explicits.subjects.add(r.target);
-    explicits.incomers.add(r.source);
-    subjects.add(r.target);
-    if (r.target !== subject) {
-      let target = r.target.parent;
-      while (target && target !== subject) {
-        subjects.add(target);
-        target = target.parent;
-      }
-    }
-    let source = r.source;
-    const incomerBranch = [];
-    while (true) {
-      incomerBranch.push(source);
-      if (isOther(source) || !source.parent) {
-        break;
-      }
-      source = source.parent;
-    }
-    return incomerBranch;
-  }));
-  let outgoers = new Set(relationships.outgoing.flatMap((r) => {
-    explicits.subjects.add(r.source);
-    explicits.outgoers.add(r.target);
-    subjects.add(r.source);
-    if (r.source !== subject) {
-      let source = r.source.parent;
-      while (source && source !== subject) {
-        subjects.add(source);
-        source = source.parent;
-      }
-    }
-    let target = r.target;
-    const outgoerBranch = [];
-    while (true) {
-      outgoerBranch.push(target);
-      if (isOther(target) || !target.parent) {
-        break;
-      }
-      target = target.parent;
-    }
-    return outgoerBranch;
-  }));
-  return {
-    incomers: finalize(incomers, explicits.incomers),
-    incoming: new Set(relationships.incoming),
-    subjects: finalize(subjects, explicits.subjects),
-    outgoing: new Set(relationships.outgoing),
-    outgoers: finalize(outgoers, explicits.outgoers)
-  };
-}
-function computeRelationshipsView(subjectId, likec4model, scopeViewId, scope = "global") {
-  const view = scopeViewId ? likec4model.findView(scopeViewId) : null;
-  if (scope === "view") {
-    invariant(
-      view,
-      'Scope view id is required when scope is "view"'
-    );
-    return computeScopedRelationshipsView(subjectId, view, likec4model);
-  }
-  const subject = likec4model.element(subjectId);
-  const subjectSiblings = toSet(subject.ascendingSiblings());
-  return computeRelationships(
-    subject,
-    subjectSiblings,
-    {
-      incoming: [...subject.incoming()],
-      outgoing: [...subject.outgoing()]
-    }
-  );
-}
-function computeScopedRelationshipsView(subjectId, view, likec4model) {
-  const subject = likec4model.element(subjectId);
-  let relationships = {
-    incoming: toArray(ifilter(subject.incoming(), (r) => view.includesRelation(r.id))),
-    outgoing: toArray(ifilter(subject.outgoing(), (r) => view.includesRelation(r.id)))
-  };
-  const isDescendant = isDescendantOf(subject);
-  const others = /* @__PURE__ */ new Set([
-    ...subject.ascendingSiblings(),
-    ...t(
-      view.elements(),
-      imap((e) => e.element),
-      ifilter((e) => e !== subject && isDescendant(e))
-    )
-  ]);
-  return computeRelationships(
-    subject,
-    others,
-    relationships
-  );
-}
-
-export { computeRelationshipsView, treeFromElements };
+export { computeRelationshipsView, treeFromElements };

package/dist/geometry/index.d.mts

@@ -1,109 +1,2 @@
-export { B as BBox, P as Point, R as RectBox, X as XYPoint } from '../shared/core.BPGOjone.mjs';
-
-interface VectorValue {
-    readonly x: number;
-    readonly y: number;
-}
-declare class Vector implements VectorValue {
-    readonly x: number;
-    readonly y: number;
-    constructor(x: number, y: number);
-    static create(position: VectorValue): Vector;
-    static create(x: number, y: number): Vector;
-    /**
-     * Adds two vectors.
-     * @param a The first vector.
-     * @param b The second vector.
-     * @returns The sum of the two vectors.
-     */
-    static add(a: VectorValue, b: VectorValue): VectorValue;
-    /**
-     * Subtracts two vectors.
-     * @param a The first vector.
-     * @param b The second vector.
-     * @returns The difference of the two vectors.
-     */
-    static subtract(a: VectorValue, b: VectorValue): VectorValue;
-    /**
-     * Multiplies a vector by a scalar.
-     * @param a The vector.
-     * @param b The scalar.
-     * @returns The scaled vector.
-     */
-    static multiply(a: VectorValue, b: number): VectorValue;
-    /**
-     * Divides a vector by a scalar.
-     * @param a The vector.
-     * @param b The scalar.
-     * @returns The scaled vector.
-     */
-    static divide(a: VectorValue, b: number): VectorValue;
-    /**
-     * Calculates the dot product of the vectors.
-     * @param a The first vector.
-     * @param b The second vector.
-     * @returns The dot product.
-     */
-    static dot(a: VectorValue, b: VectorValue): number;
-    /**
-     * Adds the given vector to this vector.
-     * @param b The vector to add.
-     * @returns A new vector that is the sum of this vector and the given vector.
-     */
-    add(b: VectorValue): Vector;
-    /**
-     * Subtracts the given vector from this vector.
-     * @param b The vector to subtract.
-     * @returns A new vector that is the difference of this vector and the given vector.
-     */
-    subtract(b: VectorValue): Vector;
-    /**
-     * Multiplies this vector by a scalar.
-     * @param b The scalar to multiply by.
-     * @returns A new vector that is the product of this vector and the given scalar.
-     */
-    multiply(b: number): Vector;
-    /**
-     * Divides this vector by a scalar.
-     * @param b The scalar to divide by.
-     * @returns A new vector that is the quotient of this vector and the given scalar.
-     */
-    divide(b: number): Vector;
-    /**
-     * Calculates the dot product of this vector and another vector.
-     * @param b The other vector.
-     * @returns The dot product.
-     */
-    dot(b: VectorValue): number;
-    /**
-     * Calculates the cross product of this vector and another vector.
-     * The cross product of two 2D vectors is a scalar value: a.x * b.y - a.y * b.x
-     * @param b The other vector.
-     * @returns The cross product as a scalar.
-     */
-    cross(b: VectorValue): number;
-    /**
-     * Calculates the length (magnitude) of this vector.
-     * @returns The length of the vector.
-     */
-    length(): number;
-    /**
-     * Normalizes the vector (makes it unit length, i.e., has a length of 1).
-     * @returns A new vector that is the normalized version of this vector.
-     */
-    normalize(): Vector;
-    /**
-     * Rounds the components of the vector to the nearest integers.
-     * @returns A new vector with rounded components.
-     */
-    round(): Vector;
-    /**
-     * Converts the vector to a plain object.
-     * @returns An object with x and y properties.
-     */
-    toObject(): VectorValue;
-}
-declare function vector(source: VectorValue | Vector): Vector;
-declare function vector(x: number, y: number): Vector;
-
-export { Vector, type VectorValue, vector };
+import { a as Point, i as BBox, n as VectorValue, o as RectBox, r as vector, s as XYPoint, t as Vector } from "../_chunks/index.mjs";
+export { BBox, Point, RectBox, Vector, VectorValue, XYPoint, vector };

package/dist/geometry/index.mjs

@@ -1,328 +1,3 @@
-import { a as t } from '../shared/core.BsSXS-_R.mjs';
-import { i as invariant } from '../shared/core.D4npX2q8.mjs';
+import { i as RectBox, n as vector, r as BBox, t as Vector } from "../_chunks/geometry.mjs";
 
-var BBox;
-((BBox2) => {
-  function center({ x, y, width, height }) {
-    return {
-      x: x + width / 2,
-      y: y + height / 2
-    };
-  }
-  BBox2.center = center;
-  function toPoints({ x, y, width, height }) {
-    return [
-      { x, y },
-      // Top left
-      { x: x + width, y },
-      // Top right
-      { x: x + width, y: y + height },
-      // Bottom right
-      { x, y: y + height }
-      // Bottom left
-    ];
-  }
-  BBox2.toPoints = toPoints;
-  function fromPoints(points) {
-    const { x1, y1, x2, y2 } = RectBox.fromPoints(points);
-    return {
-      x: x1,
-      y: y1,
-      width: x2 - x1,
-      height: y2 - y1
-    };
-  }
-  BBox2.fromPoints = fromPoints;
-  function merge(...boxes) {
-    invariant(t(boxes, 1), "No boxes provided");
-    if (boxes.length === 1) {
-      return boxes[0];
-    }
-    let minX = boxes[0].x;
-    let minY = boxes[0].y;
-    let maxX = boxes[0].x + boxes[0].width;
-    let maxY = boxes[0].y + boxes[0].height;
-    for (let i = 1; i < boxes.length; i++) {
-      const box = boxes[i];
-      minX = Math.min(minX, box.x);
-      minY = Math.min(minY, box.y);
-      maxX = Math.max(maxX, box.x + box.width);
-      maxY = Math.max(maxY, box.y + box.height);
-    }
-    return {
-      x: Math.floor(minX),
-      y: Math.floor(minY),
-      width: Math.round(maxX - minX),
-      height: Math.round(maxY - minY)
-    };
-  }
-  BBox2.merge = merge;
-  function fromRectBox(rect) {
-    return {
-      x: Math.min(rect.x1, rect.x2),
-      y: Math.min(rect.y1, rect.y2),
-      width: Math.abs(rect.x2 - rect.x1),
-      height: Math.abs(rect.y2 - rect.y1)
-    };
-  }
-  BBox2.fromRectBox = fromRectBox;
-  function toRectBox(box) {
-    return {
-      x1: box.x,
-      y1: box.y,
-      x2: box.x + box.width,
-      y2: box.y + box.height
-    };
-  }
-  BBox2.toRectBox = toRectBox;
-  function expand(box, plus) {
-    if (plus === 0) {
-      return box;
-    }
-    return {
-      x: box.x - plus,
-      y: box.y - plus,
-      width: box.width + plus * 2,
-      height: box.height + plus * 2
-    };
-  }
-  BBox2.expand = expand;
-  function shrink(box, minus) {
-    if (minus === 0) {
-      return box;
-    }
-    return {
-      x: box.x + minus,
-      y: box.y + minus,
-      width: box.width - minus * 2,
-      height: box.height - minus * 2
-    };
-  }
-  BBox2.shrink = shrink;
-  function includes(a, b) {
-    if (a === b) {
-      return true;
-    }
-    return a.x <= b.x && a.y <= b.y && a.x + a.width >= b.x + b.width && a.y + a.height >= b.y + b.height;
-  }
-  BBox2.includes = includes;
-})(BBox || (BBox = {}));
-var RectBox;
-((RectBox2) => {
-  function center({ x1, y1, x2, y2 }) {
-    return {
-      x: (x1 + x2) / 2,
-      y: (y1 + y2) / 2
-    };
-  }
-  RectBox2.center = center;
-  function fromPoints(points) {
-    invariant(points.length > 0, "At least one point is required");
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    for (const [x, y] of points) {
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-    }
-    return {
-      x1: minX,
-      y1: minY,
-      x2: maxX,
-      y2: maxY
-    };
-  }
-  RectBox2.fromPoints = fromPoints;
-  function merge(...boxes) {
-    invariant(boxes.length > 0, "No boxes provided");
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    for (const box of boxes) {
-      minX = Math.min(minX, box.x1);
-      minY = Math.min(minY, box.y1);
-      maxX = Math.max(maxX, box.x2);
-      maxY = Math.max(maxY, box.y2);
-    }
-    return {
-      x1: minX,
-      y1: minY,
-      x2: maxX,
-      y2: maxY
-    };
-  }
-  RectBox2.merge = merge;
-  function toBBox(box) {
-    return {
-      x: box.x1,
-      y: box.y1,
-      width: box.x2 - box.x1,
-      height: box.y2 - box.y1
-    };
-  }
-  RectBox2.toBBox = toBBox;
-  function includes(a, b) {
-    if (a === b) {
-      return true;
-    }
-    return a.x1 <= b.x1 && a.y1 <= b.y1 && a.x2 >= b.x2 && a.y2 >= b.y2;
-  }
-  RectBox2.includes = includes;
-})(RectBox || (RectBox = {}));
-
-class Vector {
-  constructor(x, y) {
-    this.x = x;
-    this.y = y;
-  }
-  static create(...args) {
-    if (args.length === 2) {
-      return new Vector(args[0], args[1]);
-    }
-    return new Vector(args[0].x, args[0].y);
-  }
-  /**
-   * Adds two vectors.
-   * @param a The first vector.
-   * @param b The second vector.
-   * @returns The sum of the two vectors.
-   */
-  static add(a, b) {
-    return { x: a.x + b.x, y: a.y + b.y };
-  }
-  /**
-   * Subtracts two vectors.
-   * @param a The first vector.
-   * @param b The second vector.
-   * @returns The difference of the two vectors.
-   */
-  static subtract(a, b) {
-    return { x: a.x - b.x, y: a.y - b.y };
-  }
-  /**
-   * Multiplies a vector by a scalar.
-   * @param a The vector.
-   * @param b The scalar.
-   * @returns The scaled vector.
-   */
-  static multiply(a, b) {
-    return { x: a.x * b, y: a.y * b };
-  }
-  /**
-   * Divides a vector by a scalar.
-   * @param a The vector.
-   * @param b The scalar.
-   * @returns The scaled vector.
-   */
-  static divide(a, b) {
-    return { x: a.x / b, y: a.y / b };
-  }
-  /**
-   * Calculates the dot product of the vectors.
-   * @param a The first vector.
-   * @param b The second vector.
-   * @returns The dot product.
-   */
-  static dot(a, b) {
-    return a.x * b.x + a.y * b.y;
-  }
-  /**
-   * Adds the given vector to this vector.
-   * @param b The vector to add.
-   * @returns A new vector that is the sum of this vector and the given vector.
-   */
-  add(b) {
-    return new Vector(this.x + b.x, this.y + b.y);
-  }
-  /**
-   * Subtracts the given vector from this vector.
-   * @param b The vector to subtract.
-   * @returns A new vector that is the difference of this vector and the given vector.
-   */
-  subtract(b) {
-    return new Vector(this.x - b.x, this.y - b.y);
-  }
-  /**
-   * Multiplies this vector by a scalar.
-   * @param b The scalar to multiply by.
-   * @returns A new vector that is the product of this vector and the given scalar.
-   */
-  multiply(b) {
-    return new Vector(this.x * b, this.y * b);
-  }
-  /**
-   * Divides this vector by a scalar.
-   * @param b The scalar to divide by.
-   * @returns A new vector that is the quotient of this vector and the given scalar.
-   */
-  divide(b) {
-    return new Vector(this.x / b, this.y / b);
-  }
-  /**
-   * Calculates the dot product of this vector and another vector.
-   * @param b The other vector.
-   * @returns The dot product.
-   */
-  dot(b) {
-    return this.x * b.x + this.y * b.y;
-  }
-  /**
-   * Calculates the cross product of this vector and another vector.
-   * The cross product of two 2D vectors is a scalar value: a.x * b.y - a.y * b.x
-   * @param b The other vector.
-   * @returns The cross product as a scalar.
-   */
-  cross(b) {
-    return this.x * b.y - this.y * b.x;
-  }
-  /**
-   * Calculates the length (magnitude) of this vector.
-   * @returns The length of the vector.
-   */
-  length() {
-    if (this.x === 0 && this.y === 0) {
-      return 0;
-    }
-    return Math.sqrt(this.x ** 2 + this.y ** 2);
-  }
-  /**
-   * Normalizes the vector (makes it unit length, i.e., has a length of 1).
-   * @returns A new vector that is the normalized version of this vector.
-   */
-  normalize() {
-    const len = this.length();
-    if (len === 0) {
-      return new Vector(0, 0);
-    }
-    return new Vector(this.x / len, this.y / len);
-  }
-  /**
-   * Rounds the components of the vector to the nearest integers.
-   * @returns A new vector with rounded components.
-   */
-  round() {
-    return new Vector(Math.round(this.x), Math.round(this.y));
-  }
-  /**
-   * Converts the vector to a plain object.
-   * @returns An object with x and y properties.
-   */
-  toObject() {
-    return { x: this.x, y: this.y };
-  }
-}
-function vector(...args) {
-  if (args.length === 1 && args[0] instanceof Vector) {
-    return args[0];
-  }
-  if (args.length === 2) {
-    return new Vector(args[0], args[1]);
-  }
-  return new Vector(args[0].x, args[0].y);
-}
-
-export { BBox, RectBox, Vector, vector };
+export { BBox, RectBox, Vector, vector };