@likec4/core 1.18.0 → 1.19.0

package/dist/shared/core.D6-fWbM3.d.ts

@@ -0,0 +1,127 @@
+import { F as Fqn } from './core.D74xkKkG.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 };

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

@@ -0,0 +1,148 @@
+import { LiteralUnion, Tagged, Simplify, UnionToIntersection, TupleToUnion } from 'type-fest';
+
+declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
+type ThemeColor = typeof ThemeColors[number];
+type HexColorLiteral = `#${string}`;
+type ColorLiteral = HexColorLiteral;
+type Color = LiteralUnion<ThemeColor, string>;
+declare function isThemeColor(color: Color): color is ThemeColor;
+interface ElementThemeColorValues {
+    fill: ColorLiteral;
+    stroke: ColorLiteral;
+    hiContrast: ColorLiteral;
+    loContrast: ColorLiteral;
+}
+type ElementThemeColors = {
+    [key in ThemeColor]: ElementThemeColorValues;
+};
+interface RelationshipThemeColorValues {
+    lineColor: ColorLiteral;
+    labelBgColor: ColorLiteral;
+    labelColor: ColorLiteral;
+}
+interface ThemeColorValues {
+    elements: ElementThemeColorValues;
+    relationships: RelationshipThemeColorValues;
+}
+type RelationshipThemeColors = {
+    [key in ThemeColor]: RelationshipThemeColorValues;
+};
+interface LikeC4Theme {
+    font: 'Arial';
+    shadow: ColorLiteral;
+    relationships: RelationshipThemeColors;
+    elements: ElementThemeColors;
+}
+
+type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type IconUrl = Tagged<string, 'IconUrl'> | 'none';
+type CustomColor = string;
+type Point = readonly [x: number, y: number];
+interface XYPoint {
+    x: number;
+    y: number;
+}
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
+type AllNever<Expressions> = UnionToIntersection<{
+    [Name in keyof Expressions]: {
+        -readonly [Key in keyof Expressions[Name]]?: never;
+    };
+}[keyof Expressions]>;
+/**
+ * @example
+ *   type Variant1 = {
+ *     a: string
+ *   }
+ *   type Variant2 = {
+ *     b: number
+ *   }
+ *
+ *   type Variants = ExclusiveUnion<{
+ *     Variant1: Variant1,
+ *     Variant2: Variant2
+ *   }>
+ *
+ *   Fail here
+ *   const variant1: Variants = {
+ *      a: 'one',
+ *      b: 1
+ *   }
+ */
+type ExclusiveUnion<Expressions> = Expressions extends object ? {
+    [Name in keyof Expressions]: Simplify<Omit<AllNever<Expressions>, keyof Expressions[Name]> & Expressions[Name]>;
+}[keyof Expressions] : Expressions;
+/**
+ * Copy from https://github.com/remeda/remeda/blob/main/src/internal/types/NTuple.ts
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
+type Predicate<T> = (x: T) => boolean;
+
+type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>;
+declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
+declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
+type BorderStyle = TupleToUnion<typeof BorderStyles>;
+type ElementKind<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>;
+declare namespace ElementKind {
+    const Group: ElementKind;
+}
+declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
+type ElementShape = TupleToUnion<typeof ElementShapes>;
+declare const DefaultThemeColor: ThemeColor;
+declare const DefaultElementShape: ElementShape;
+interface ElementStyle {
+    readonly border?: BorderStyle;
+    /**
+     * In percentage 0-100, 0 is fully transparent
+     *
+     * @default 100
+     */
+    readonly opacity?: number;
+}
+type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>;
+interface TagSpec {
+    readonly id: Tag;
+    readonly style: ElementStyle;
+}
+interface Link {
+    readonly title?: string;
+    readonly url: string;
+    readonly relative?: string;
+}
+interface TypedElement<Ids extends string, Kinds extends string, Tags extends string, MetadataKeys extends string = never> {
+    readonly id: Fqn<Ids>;
+    readonly kind: ElementKind<Kinds>;
+    readonly title: string;
+    readonly description: string | null;
+    readonly technology: string | null;
+    readonly tags: NonEmptyArray<Tag<Tags>> | null;
+    readonly links: NonEmptyArray<Link> | null;
+    readonly icon?: IconUrl;
+    readonly shape?: ElementShape;
+    readonly color?: Color;
+    readonly style?: ElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Record<MetadataKeys, string>;
+}
+interface Element extends TypedElement<string, string, string, string> {
+}
+interface ElementKindSpecificationStyle {
+    shape?: ElementShape;
+    icon?: IconUrl;
+    color?: Color;
+    border?: BorderStyle;
+    opacity?: number;
+}
+interface ElementKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly style: ElementKindSpecificationStyle;
+}
+
+export { AsFqn as A, BorderStyles as B, type CustomColor as C, DefaultElementShape as D, type ExclusiveUnion as E, type Fqn as F, type HexColorLiteral as H, type IconUrl as I, type KeysOf as K, type LikeC4Theme as L, type NonEmptyArray as N, type Point as P, type RelationshipThemeColors as R, type ThemeColorValues as T, type XYPoint as X, type IteratorLike as a, type NonEmptyReadonlyArray as b, type NTuple as c, type Predicate as d, DefaultThemeColor as e, ElementKind as f, ElementShapes as g, type BorderStyle as h, type Element as i, type ElementKindSpecification as j, type ElementKindSpecificationStyle as k, type ElementShape as l, type ElementStyle as m, type Link as n, type Tag as o, type TagSpec as p, type TypedElement as q, isThemeColor as r, type Color as s, type ColorLiteral as t, type ElementThemeColors as u, type ElementThemeColorValues as v, type RelationshipThemeColorValues as w, type ThemeColor as x };

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

@@ -0,0 +1,148 @@
+import { LiteralUnion, Tagged, Simplify, UnionToIntersection, TupleToUnion } from 'type-fest';
+
+declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
+type ThemeColor = typeof ThemeColors[number];
+type HexColorLiteral = `#${string}`;
+type ColorLiteral = HexColorLiteral;
+type Color = LiteralUnion<ThemeColor, string>;
+declare function isThemeColor(color: Color): color is ThemeColor;
+interface ElementThemeColorValues {
+    fill: ColorLiteral;
+    stroke: ColorLiteral;
+    hiContrast: ColorLiteral;
+    loContrast: ColorLiteral;
+}
+type ElementThemeColors = {
+    [key in ThemeColor]: ElementThemeColorValues;
+};
+interface RelationshipThemeColorValues {
+    lineColor: ColorLiteral;
+    labelBgColor: ColorLiteral;
+    labelColor: ColorLiteral;
+}
+interface ThemeColorValues {
+    elements: ElementThemeColorValues;
+    relationships: RelationshipThemeColorValues;
+}
+type RelationshipThemeColors = {
+    [key in ThemeColor]: RelationshipThemeColorValues;
+};
+interface LikeC4Theme {
+    font: 'Arial';
+    shadow: ColorLiteral;
+    relationships: RelationshipThemeColors;
+    elements: ElementThemeColors;
+}
+
+type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type IconUrl = Tagged<string, 'IconUrl'> | 'none';
+type CustomColor = string;
+type Point = readonly [x: number, y: number];
+interface XYPoint {
+    x: number;
+    y: number;
+}
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
+type AllNever<Expressions> = UnionToIntersection<{
+    [Name in keyof Expressions]: {
+        -readonly [Key in keyof Expressions[Name]]?: never;
+    };
+}[keyof Expressions]>;
+/**
+ * @example
+ *   type Variant1 = {
+ *     a: string
+ *   }
+ *   type Variant2 = {
+ *     b: number
+ *   }
+ *
+ *   type Variants = ExclusiveUnion<{
+ *     Variant1: Variant1,
+ *     Variant2: Variant2
+ *   }>
+ *
+ *   Fail here
+ *   const variant1: Variants = {
+ *      a: 'one',
+ *      b: 1
+ *   }
+ */
+type ExclusiveUnion<Expressions> = Expressions extends object ? {
+    [Name in keyof Expressions]: Simplify<Omit<AllNever<Expressions>, keyof Expressions[Name]> & Expressions[Name]>;
+}[keyof Expressions] : Expressions;
+/**
+ * Copy from https://github.com/remeda/remeda/blob/main/src/internal/types/NTuple.ts
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
+type Predicate<T> = (x: T) => boolean;
+
+type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>;
+declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
+declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
+type BorderStyle = TupleToUnion<typeof BorderStyles>;
+type ElementKind<Kinds extends string = string> = Tagged<Kinds, 'ElementKind'>;
+declare namespace ElementKind {
+    const Group: ElementKind;
+}
+declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
+type ElementShape = TupleToUnion<typeof ElementShapes>;
+declare const DefaultThemeColor: ThemeColor;
+declare const DefaultElementShape: ElementShape;
+interface ElementStyle {
+    readonly border?: BorderStyle;
+    /**
+     * In percentage 0-100, 0 is fully transparent
+     *
+     * @default 100
+     */
+    readonly opacity?: number;
+}
+type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>;
+interface TagSpec {
+    readonly id: Tag;
+    readonly style: ElementStyle;
+}
+interface Link {
+    readonly title?: string;
+    readonly url: string;
+    readonly relative?: string;
+}
+interface TypedElement<Ids extends string, Kinds extends string, Tags extends string, MetadataKeys extends string = never> {
+    readonly id: Fqn<Ids>;
+    readonly kind: ElementKind<Kinds>;
+    readonly title: string;
+    readonly description: string | null;
+    readonly technology: string | null;
+    readonly tags: NonEmptyArray<Tag<Tags>> | null;
+    readonly links: NonEmptyArray<Link> | null;
+    readonly icon?: IconUrl;
+    readonly shape?: ElementShape;
+    readonly color?: Color;
+    readonly style?: ElementStyle;
+    readonly notation?: string;
+    readonly metadata?: Record<MetadataKeys, string>;
+}
+interface Element extends TypedElement<string, string, string, string> {
+}
+interface ElementKindSpecificationStyle {
+    shape?: ElementShape;
+    icon?: IconUrl;
+    color?: Color;
+    border?: BorderStyle;
+    opacity?: number;
+}
+interface ElementKindSpecification {
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly style: ElementKindSpecificationStyle;
+}
+
+export { AsFqn as A, BorderStyles as B, type CustomColor as C, DefaultElementShape as D, type ExclusiveUnion as E, type Fqn as F, type HexColorLiteral as H, type IconUrl as I, type KeysOf as K, type LikeC4Theme as L, type NonEmptyArray as N, type Point as P, type RelationshipThemeColors as R, type ThemeColorValues as T, type XYPoint as X, type IteratorLike as a, type NonEmptyReadonlyArray as b, type NTuple as c, type Predicate as d, DefaultThemeColor as e, ElementKind as f, ElementShapes as g, type BorderStyle as h, type Element as i, type ElementKindSpecification as j, type ElementKindSpecificationStyle as k, type ElementShape as l, type ElementStyle as m, type Link as n, type Tag as o, type TagSpec as p, type TypedElement as q, isThemeColor as r, type Color as s, type ColorLiteral as t, type ElementThemeColors as u, type ElementThemeColorValues as v, type RelationshipThemeColorValues as w, type ThemeColor as x };

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

@@ -0,0 +1,127 @@
+import { F as Fqn } from './core.D74xkKkG.mjs';
+
+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 };