@likec4/core 1.26.2 → 1.27.1

package/dist/shared/core.C8xqv5sq.mjs

@@ -1,37 +0,0 @@
-import { t as toSet, i as ifind } from './core.DvRnF4Sc.mjs';
-
-function computeRelationshipsView(subjectId, likec4model) {
-  const subject = likec4model.element(subjectId);
-  let relationships = {
-    incoming: [...subject.incoming()],
-    outgoing: [...subject.outgoing()]
-  };
-  const subjectSiblings = toSet(subject.ascendingSiblings());
-  const isSubjectSibling = (e) => subjectSiblings.has(e);
-  const subjects = /* @__PURE__ */ new Set([subject]);
-  const incomers = new Set(relationships.incoming.flatMap((r) => {
-    subjects.add(r.target);
-    if (subjectSiblings.has(r.source)) {
-      return [r.source];
-    }
-    const parent = ifind(r.source.ancestors(), isSubjectSibling);
-    return parent ? [r.source, parent] : [r.source];
-  }));
-  const outgoers = new Set(relationships.outgoing.flatMap((r) => {
-    subjects.add(r.source);
-    if (subjectSiblings.has(r.target)) {
-      return [r.target];
-    }
-    const parent = ifind(r.target.ancestors(), isSubjectSibling);
-    return parent ? [r.target, parent] : [r.target];
-  }));
-  return {
-    incomers,
-    incoming: new Set(relationships.incoming),
-    subjects,
-    outgoing: new Set(relationships.outgoing),
-    outgoers
-  };
-}
-
-export { computeRelationshipsView as c };

package/dist/shared/core.CIbWBWW3.d.ts

@@ -1,127 +0,0 @@
-import { F as Fqn } from './core.30yYKXcZ.js';
-
-declare function parentFqn<E extends string>(fqn: E): E | null;
-declare function nameFromFqn<E extends string>(fqn: E): string;
-/**
- * Check if one element is an ancestor of another
- * Composable version
- * @signature
- *  isAncestor(another)(ancestor)
- */
-declare function isAncestor<A extends string | {
-    id: string;
-}>(another: NoInfer<A>): (ancestor: A) => boolean;
-/**
- * Check if one element is an ancestor of another
- * @signature
- *   isAncestor(ancestor, another)
- */
-declare function isAncestor<A extends string | {
-    id: string;
-}>(ancestor: A, another: A): boolean;
-declare function isSameHierarchy<T extends string>(one: NoInfer<T> | WithId<NoInfer<T>>): (another: T | WithId<T>) => boolean;
-declare function isSameHierarchy<T extends string>(one: T | WithId<T>, another: T | WithId<T>): boolean;
-type WithId<T> = {
-    id: T;
-};
-declare function isDescendantOf<T extends string>(ancestor: WithId<T>): (descedant: WithId<T>) => boolean;
-declare function isDescendantOf<T extends string>(descedant: WithId<T>, ancestor: WithId<T>): boolean;
-/**
- * How deep in the hierarchy the element is.
- * Root element has depth 1
- */
-declare function hierarchyLevel<E extends string | {
-    id: Fqn;
-}>(elementOfFqn: E): number;
-/**
- * Calculate the distance as number of steps from one element to another, i.e.
- * going up to the common ancestor, then going down to the other element.
- * Sibling distance is always 1
- *
- * Can be used for hierarchical clustering
- */
-declare function hierarchyDistance<E extends string | {
-    id: Fqn;
-}>(one: E, another: E): number;
-declare function commonAncestor<E extends string>(first: E, second: E): E | null;
-/**
- * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
- * going up from parent to the root
- */
-declare function ancestorsFqn<Id extends string>(fqn: Id): Id[];
-/**
- * Compares two fully qualified names (fqns) hierarchically based on their depth.
- * From parent nodes to leaves
- *
- * @param {string} a - The first fqn to compare.
- * @param {string} b - The second fqn to compare.
- * @returns {number} - 0 if the fqns have the same depth.
- *                    - Positive number if a is deeper than b.
- *                    - Negative number if b is deeper than a.
- */
-declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): -1 | 0 | 1;
-declare function compareByFqnHierarchically<T extends {
-    id: string;
-}>(a: T, b: T): -1 | 0 | 1;
-type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
-type ReorderedArray<T extends IterableContainer> = {
-    -readonly [P in keyof T]: T[number];
-};
-/**
- * Sorts an array of objects hierarchically based on their fully qualified names (FQN).
- * Objects are sorted by the number of segments in their FQN (defined by dot-separated ID).
- *
- * @typeParam T - Object type that contains an 'id' string property
- * @typeParam A - Type extending IterableContainer of T
- *
- * @param array - Array of objects to be sorted
- * @returns A new array with items sorted by their FQN hierarchy depth (number of segments)
- *
- * @example
- * ```ts
- * const items = [
- *   { id: "a.b.c" },
- *   { id: "a" },
- *   { id: "a.b" }
- * ];
- * sortByFqnHierarchically(items);
- * // Result: [
- * //   { id: "a" },
- * //   { id: "a.b" },
- * //   { id: "a.b.c" }
- * // ]
- * ```
- */
-declare function sortByFqnHierarchically<T extends {
-    id: string;
-}, A extends IterableContainer<T>>(array: A): ReorderedArray<A>;
-/**
- * Keeps initial order of the elements, but ensures that parents are before children
- */
-declare function sortParentsFirst<T extends {
-    id: string;
-}, A extends IterableContainer<T>>(array: A): ReorderedArray<A>;
-/**
- * Sorts an array of objects naturally by their fully qualified name (FQN) identifier.
- *
- * @template T - Type of objects containing an 'id' string property
- * @template A - Type extending IterableContainer of T
- *
- * @param first - Optional. Either the array to sort or the sort direction ('asc'|'desc')
- * @param sort - Optional. The sort direction ('asc'|'desc'). Defaults to 'asc' if not specified
- *
- * @example
- * // As a function that returns a sorting function
- * const sorted = sortNaturalByFqn('desc')(myArray);
- *
- * // Direct array sorting
- * const sorted = sortNaturalByFqn(myArray, 'desc');
- */
-declare function sortNaturalByFqn(sort?: 'asc' | 'desc'): <T extends {
-    id: string;
-}, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>;
-declare function sortNaturalByFqn<T extends {
-    id: string;
-}, A extends IterableContainer<T>>(array: A, sort?: 'asc' | 'desc'): ReorderedArray<A>;
-
-export { type IterableContainer as I, type ReorderedArray as R, ancestorsFqn as a, compareByFqnHierarchically as b, commonAncestor as c, compareFqnHierarchically as d, hierarchyLevel as e, isDescendantOf as f, isSameHierarchy as g, hierarchyDistance as h, isAncestor as i, sortNaturalByFqn as j, sortParentsFirst as k, nameFromFqn as n, parentFqn as p, sortByFqnHierarchically as s };