@likec4/core 1.8.1 → 1.9.0

package/dist/types/overview-graph.d.ts

@@ -1,41 +0,0 @@
-import type { NonEmptyArray, Point, XYPoint } from './_common';
-import type { BBox, ViewID } from './view';
-/**
- * OverviewGraph is a graph representation of all views in a model
- */
-export declare namespace OverviewGraph {
-    type Node = {
-        id: string;
-        type: 'folder' | 'file';
-        path: string;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    } | {
-        id: string;
-        type: 'view';
-        viewId: ViewID;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    };
-    /**
-     * Edge represents a navigational link from one view to another
-     */
-    type Edge = {
-        id: string;
-        source: string;
-        target: string;
-        points: NonEmptyArray<Point>;
-    };
-}
-export interface OverviewGraph {
-    nodes: OverviewGraph.Node[];
-    edges: OverviewGraph.Edge[];
-    bounds: BBox;
-}
-//# sourceMappingURL=overview-graph.d.ts.map

package/dist/types/overview-graph.js

@@ -1 +0,0 @@
-export {};

package/dist/types/relation.d.ts

@@ -1,30 +0,0 @@
-import type { NonEmptyArray } from './_common';
-import type { Fqn, Link, Tag } from './element';
-import type { Opaque } from './opaque';
-import type { ThemeColor } from './theme';
-export type RelationID = Opaque<string, 'RelationID'>;
-export type RelationshipKind = Opaque<string, 'RelationshipKind'>;
-export type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
-export type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
-export declare const DefaultLineStyle = "dashed";
-export declare const DefaultArrowType = "normal";
-export declare const DefaultRelationshipColor = "gray";
-export interface Relation {
-    readonly id: RelationID;
-    readonly source: Fqn;
-    readonly target: Fqn;
-    readonly title: string;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly tags?: NonEmptyArray<Tag>;
-    readonly kind?: RelationshipKind;
-    readonly color?: ThemeColor;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly links?: NonEmptyArray<Link>;
-    readonly metadata?: {
-        [key: string]: string;
-    };
-}
-//# sourceMappingURL=relation.d.ts.map

package/dist/types/relation.js

@@ -1,3 +0,0 @@
-export const DefaultLineStyle = 'dashed';
-export const DefaultArrowType = 'normal';
-export const DefaultRelationshipColor = 'gray';

package/dist/types/theme.d.ts

@@ -1,27 +0,0 @@
-export type ThemeColor = 'amber' | 'blue' | 'gray' | 'slate' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky';
-export type HexColorLiteral = `#${string}`;
-export type ColorLiteral = HexColorLiteral;
-export interface ElementThemeColorValues {
-    fill: ColorLiteral;
-    stroke: ColorLiteral;
-    hiContrast: ColorLiteral;
-    loContrast: ColorLiteral;
-}
-export type ElementThemeColors = {
-    [key in ThemeColor]: ElementThemeColorValues;
-};
-export interface RelationshipThemeColorValues {
-    lineColor: ColorLiteral;
-    labelBgColor: ColorLiteral;
-    labelColor: ColorLiteral;
-}
-export type RelationshipThemeColors = {
-    [key in ThemeColor]: RelationshipThemeColorValues;
-};
-export interface LikeC4Theme {
-    font: 'Arial';
-    shadow: ColorLiteral;
-    relationships: RelationshipThemeColors;
-    elements: ElementThemeColors;
-}
-//# sourceMappingURL=theme.d.ts.map

package/dist/types/theme.js

@@ -1 +0,0 @@
-export {};

package/dist/types/view-changes.d.ts

@@ -1,26 +0,0 @@
-import type { NonEmptyArray } from './_common';
-import type { BorderStyle, ElementShape, Fqn } from './element';
-import type { ThemeColor } from './theme';
-import type { AutoLayoutDirection, ViewManualLayout } from './view';
-export declare namespace ViewChange {
-    interface ChangeElementStyle {
-        op: 'change-element-style';
-        style: {
-            border?: BorderStyle;
-            opacity?: number;
-            shape?: ElementShape;
-            color?: ThemeColor;
-        };
-        targets: NonEmptyArray<Fqn>;
-    }
-    interface SaveManualLayout {
-        op: 'save-manual-layout';
-        layout: ViewManualLayout;
-    }
-    interface ChangeAutoLayout {
-        op: 'change-autolayout';
-        layout: AutoLayoutDirection;
-    }
-}
-export type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
-//# sourceMappingURL=view-changes.d.ts.map

package/dist/types/view-changes.js

@@ -1 +0,0 @@
-export {};

package/dist/types/view-notation.d.ts

@@ -1,9 +0,0 @@
-import type { ElementKind, ElementShape } from './element';
-import type { ThemeColor } from './theme';
-export type ElementNotation = {
-    kinds: ElementKind[];
-    shape: ElementShape;
-    color: ThemeColor;
-    title: string;
-};
-//# sourceMappingURL=view-notation.d.ts.map

package/dist/types/view-notation.js

@@ -1 +0,0 @@
-export {};

package/dist/types/view.d.ts

@@ -1,243 +0,0 @@
-import type { IconUrl, NonEmptyArray, Point, XYPoint } from './_common';
-import type { ElementKind, ElementShape, ElementStyle, Fqn, Link, Tag } from './element';
-import type { ElementExpression, ElementPredicateExpression, Expression } from './expression';
-import type { Opaque } from './opaque';
-import type { RelationID, RelationshipArrowType, RelationshipKind, RelationshipLineType } from './relation';
-import type { ThemeColor } from './theme';
-import type { ElementNotation } from './view-notation';
-export type ViewID = Opaque<string, 'ViewID'>;
-export type ViewRulePredicate = {
-    include: Expression[];
-    exclude?: never;
-} | {
-    include?: never;
-    exclude: Expression[];
-};
-export declare function isViewRulePredicate(rule: ViewRule): rule is ViewRulePredicate;
-export interface ViewRuleStyle {
-    targets: ElementExpression[];
-    notation?: string;
-    style: ElementStyle & {
-        color?: ThemeColor;
-        shape?: ElementShape;
-        icon?: IconUrl;
-    };
-}
-export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
-export type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
-export interface ViewRuleAutoLayout {
-    autoLayout: AutoLayoutDirection;
-}
-export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
-export type ViewRule = ViewRulePredicate | ViewRuleStyle | ViewRuleAutoLayout;
-export interface BasicView<ViewType extends 'element' | 'dynamic'> {
-    readonly __?: ViewType;
-    readonly id: ViewID;
-    readonly title: string | null;
-    readonly description: string | null;
-    readonly tags: NonEmptyArray<Tag> | null;
-    readonly links: NonEmptyArray<Link> | null;
-    /**
-     * URI to the source file of this view.
-     * Undefined if the view is auto-generated.
-     */
-    readonly docUri?: string;
-    /**
-     * For all views we find common ancestor path.
-     * This is used to generate relative paths, i.e.:
-     * - "/home/project/index.c4" becomes "index.c4"
-     * - "/home/project/subdir/views.c4" becomes "subdir/views.c4"
-     *
-     * Undefined if the view is auto-generated.
-     */
-    readonly relativePath?: string;
-    /**
-     * If the view is changed manually this field contains the layout data.
-     */
-    readonly manualLayout?: ViewManualLayout | undefined;
-}
-export interface BasicElementView extends BasicView<'element'> {
-    readonly viewOf?: Fqn;
-    readonly rules: ViewRule[];
-}
-export interface ScopedElementView extends BasicElementView {
-    readonly viewOf: Fqn;
-}
-export interface ExtendsElementView extends BasicElementView {
-    readonly extends: ViewID;
-}
-export type ElementView = ScopedElementView | ExtendsElementView | BasicElementView;
-export interface DynamicViewStep {
-    readonly source: Fqn;
-    readonly target: Fqn;
-    readonly title: string | null;
-    readonly description?: string;
-    readonly technology?: string;
-    readonly notation?: string;
-    readonly color?: ThemeColor;
-    readonly line?: RelationshipLineType;
-    readonly head?: RelationshipArrowType;
-    readonly tail?: RelationshipArrowType;
-    readonly isBackward?: boolean;
-}
-export type DynamicViewIncludeRule = {
-    include: ElementPredicateExpression[];
-};
-export declare function isDynamicViewIncludeRule(rule: DynamicViewRule): rule is DynamicViewIncludeRule;
-export type DynamicViewRule = DynamicViewIncludeRule | ViewRuleStyle | ViewRuleAutoLayout;
-export interface DynamicView extends BasicView<'dynamic'> {
-    readonly __: 'dynamic';
-    readonly steps: DynamicViewStep[];
-    readonly rules: DynamicViewRule[];
-}
-export type LikeC4View = ElementView | DynamicView;
-export declare function isDynamicView(view: LikeC4View): view is DynamicView;
-export declare function isElementView(view: LikeC4View): view is ElementView;
-export declare function isExtendsElementView(view: LikeC4View): view is ExtendsElementView;
-export declare function isScopedElementView(view: LikeC4View): view is ScopedElementView;
-export type NodeId = Fqn;
-export type EdgeId = Opaque<string, 'EdgeId'>;
-export type StepEdgeIdLiteral = `step-${number}`;
-export type StepEdgeId = Opaque<StepEdgeIdLiteral, 'EdgeId'>;
-export declare function StepEdgeId(step: number): StepEdgeId;
-export declare function isStepEdgeId(id: string): id is StepEdgeId;
-export declare function extractStep(id: EdgeId): number;
-export interface ComputedNode {
-    id: NodeId;
-    kind: ElementKind;
-    parent: NodeId | null;
-    title: string;
-    description: string | null;
-    technology: string | null;
-    notation?: string;
-    tags: NonEmptyArray<Tag> | null;
-    links: NonEmptyArray<Link> | null;
-    children: NodeId[];
-    inEdges: EdgeId[];
-    outEdges: EdgeId[];
-    shape: ElementShape;
-    /**
-     * @deprecated Use `style` instead
-     */
-    color: ThemeColor;
-    /**
-     * @deprecated Use `style` instead
-     */
-    icon?: IconUrl;
-    style: ElementStyle;
-    navigateTo?: ViewID;
-    level: number;
-    depth?: number;
-    /**
-     * If this node was customized in the view
-     */
-    isCustomized?: boolean;
-}
-export interface ComputedEdge {
-    id: EdgeId;
-    parent: NodeId | null;
-    source: NodeId;
-    target: NodeId;
-    label: string | null;
-    description?: string;
-    technology?: string;
-    relations: RelationID[];
-    kind?: RelationshipKind;
-    color?: ThemeColor;
-    line?: RelationshipLineType;
-    head?: RelationshipArrowType;
-    tail?: RelationshipArrowType;
-    tags?: NonEmptyArray<Tag>;
-    /**
-     * If this edge is derived from custom relationship predicate
-     */
-    isCustomized?: boolean;
-    /**
-     * For layouting purposes
-     * @default 'forward'
-     */
-    dir?: 'forward' | 'back';
-}
-export interface ViewWithHash {
-    /**
-     * Hash of the view object.
-     * This is used to detect changes in layout
-     */
-    hash: string;
-}
-export interface ViewWithNotation {
-    notation?: {
-        elements: ElementNotation[];
-    };
-}
-export interface ComputedElementView extends Omit<ElementView, 'rules' | 'docUri'>, ViewWithHash, ViewWithNotation {
-    readonly extends?: ViewID;
-    readonly autoLayout: ViewRuleAutoLayout['autoLayout'];
-    readonly nodes: ComputedNode[];
-    readonly edges: ComputedEdge[];
-    rules?: never;
-    docUri?: never;
-}
-export interface ComputedDynamicView extends Omit<DynamicView, 'rules' | 'steps' | 'docUri'>, ViewWithHash, ViewWithNotation {
-    readonly autoLayout: ViewRuleAutoLayout['autoLayout'];
-    readonly nodes: ComputedNode[];
-    readonly edges: ComputedEdge[];
-    steps?: never;
-    rules?: never;
-    docUri?: never;
-}
-export declare function isComputedDynamicView(view: ComputedView): view is ComputedDynamicView;
-export type ComputedView = ComputedElementView | ComputedDynamicView;
-export declare function isComputedElementView(view: ComputedView): view is ComputedElementView;
-export type BBox = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-export declare function getBBoxCenter({ x, y, width, height }: BBox): XYPoint;
-export interface DiagramNode extends ComputedNode {
-    width: number;
-    height: number;
-    position: Point;
-    labelBBox: BBox;
-}
-export interface DiagramEdge extends ComputedEdge {
-    points: NonEmptyArray<Point>;
-    controlPoints?: NonEmptyArray<XYPoint>;
-    labelBBox?: BBox | null;
-    dotpos?: string;
-}
-export interface DiagramView extends Omit<ComputedView, 'nodes' | 'edges' | 'manualLayout'> {
-    readonly nodes: DiagramNode[];
-    readonly edges: DiagramEdge[];
-    readonly bounds: BBox;
-    /**
-     * If diagram has manual layout
-     * But was changed and layout should be recalculated
-     */
-    hasLayoutDrift?: boolean;
-    manualLayout?: never;
-}
-export type ViewManualLayout = {
-    readonly hash: string;
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-    readonly autoLayout: AutoLayoutDirection;
-    readonly nodes: Record<string, {
-        isCompound: boolean;
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }>;
-    readonly edges: Record<string, {
-        dotpos?: string;
-        points: NonEmptyArray<Point>;
-        controlPoints?: NonEmptyArray<XYPoint>;
-        labelBBox?: BBox;
-    }>;
-};
-//# sourceMappingURL=view.d.ts.map

package/dist/types/view.js

@@ -1,50 +0,0 @@
-import { isNullish } from 'remeda';
-export function isViewRulePredicate(rule) {
-    return (('include' in rule && Array.isArray(rule.include))
-        || ('exclude' in rule && Array.isArray(rule.exclude)));
-}
-export function isViewRuleStyle(rule) {
-    return 'style' in rule && 'targets' in rule;
-}
-export function isViewRuleAutoLayout(rule) {
-    return 'autoLayout' in rule;
-}
-export function isDynamicViewIncludeRule(rule) {
-    return 'include' in rule && Array.isArray(rule.include);
-}
-export function isDynamicView(view) {
-    return view.__ === 'dynamic';
-}
-export function isElementView(view) {
-    return isNullish(view.__) || view.__ === 'element';
-}
-export function isExtendsElementView(view) {
-    return isElementView(view) && 'extends' in view;
-}
-export function isScopedElementView(view) {
-    return isElementView(view) && 'viewOf' in view;
-}
-export function StepEdgeId(step) {
-    return `step-${String(step).padStart(3, '0')}`;
-}
-export function isStepEdgeId(id) {
-    return id.startsWith('step-');
-}
-export function extractStep(id) {
-    if (!isStepEdgeId(id)) {
-        throw new Error(`Invalid step edge id: ${id}`);
-    }
-    return Number(id.slice('step-'.length));
-}
-export function isComputedDynamicView(view) {
-    return view.__ === 'dynamic';
-}
-export function isComputedElementView(view) {
-    return isNullish(view.__) || view.__ === 'element';
-}
-export function getBBoxCenter({ x, y, width, height }) {
-    return {
-        x: x + width / 2,
-        y: y + height / 2
-    };
-}

package/dist/utils/fqn.d.ts

@@ -1,39 +0,0 @@
-import type { Element, Fqn } from '../types';
-type Predicate<T> = (x: T) => boolean;
-export declare function nameFromFqn(fqn: Fqn): string;
-export declare function isAncestor<E extends {
-    id: Fqn;
-}>(...args: [ancestor: string, another: string] | [ancestor: E, another: E]): boolean;
-export declare function isSameHierarchy<E extends {
-    id: Fqn;
-}>(one: E | Fqn, another: E | Fqn): boolean;
-export declare function isDescendantOf<E extends {
-    id: Fqn;
-}>(ancestors: E[]): (e: E) => boolean;
-export declare function notDescendantOf(ancestors: Element[]): (e: Element) => boolean;
-export declare function commonAncestor(first: Fqn, second: Fqn): Fqn | null;
-export declare function parentFqn(fqn: Fqn): Fqn | null;
-export declare function parentFqnPredicate<T extends {
-    parent: Fqn | null;
-}>(parent: Fqn): Predicate<T>;
-/**
- * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
- * (from closest to root)
- */
-export declare function ancestorsFqn(fqn: Fqn): Fqn[];
-/**
- * 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.
- */
-export declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): number;
-export declare function compareByFqnHierarchically<T extends {
-    id: string;
-}>(a: T, b: T): number;
-export {};
-//# sourceMappingURL=fqn.d.ts.map

package/dist/utils/fqn.js

@@ -1,102 +0,0 @@
-import { isString } from './guards';
-export function nameFromFqn(fqn) {
-    const lastDot = fqn.lastIndexOf('.');
-    if (lastDot > 0) {
-        return fqn.slice(lastDot + 1);
-    }
-    else {
-        return fqn;
-    }
-}
-export function isAncestor(...args) {
-    const ancestor = isString(args[0]) ? args[0] : args[0].id;
-    const another = isString(args[1]) ? args[1] : args[1].id;
-    return another.startsWith(ancestor + '.');
-}
-export function isSameHierarchy(one, another) {
-    const first = isString(one) ? one : one.id;
-    const second = isString(another) ? another : another.id;
-    return first === second || second.startsWith(first + '.') || first.startsWith(second + '.');
-}
-export function isDescendantOf(ancestors) {
-    const predicates = ancestors.flatMap(a => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
-    return (e) => predicates.some(p => p(e));
-}
-export function notDescendantOf(ancestors) {
-    const isDescendant = isDescendantOf(ancestors);
-    return (e) => !isDescendant(e);
-}
-export function commonAncestor(first, second) {
-    const parentA = parentFqn(first);
-    const parentB = parentFqn(second);
-    if (parentA === parentB) {
-        return parentA;
-    }
-    if (!parentA || !parentB) {
-        return null;
-    }
-    const a = first.split('.');
-    const b = second.split('.');
-    let ancestor = null;
-    while (a.length > 1 && b.length > 1 && !!a[0] && a[0] === b[0]) {
-        ancestor = (ancestor ? `${ancestor}.${a[0]}` : a[0]);
-        a.shift();
-        b.shift();
-    }
-    return ancestor;
-}
-export function parentFqn(fqn) {
-    const lastDot = fqn.lastIndexOf('.');
-    if (lastDot > 0) {
-        return fqn.substring(0, lastDot);
-    }
-    return null;
-}
-export function parentFqnPredicate(parent) {
-    const prefix = parent + '.';
-    return (e) => !!e.parent && (e.parent === parent || e.parent.startsWith(prefix));
-}
-/**
- * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
- * (from closest to root)
- */
-export function ancestorsFqn(fqn) {
-    const path = fqn.split('.');
-    path.pop();
-    if (path.length === 0) {
-        return [];
-    }
-    return path.reduce((acc, _, idx) => {
-        const ancestor = path.slice(0, idx + 1).join('.');
-        acc.unshift(ancestor);
-        return acc;
-    }, []);
-}
-/**
- * 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.
- */
-export function compareFqnHierarchically(a, b) {
-    const depthA = a.split('.').length;
-    const depthB = b.split('.').length;
-    switch (true) {
-        case depthA > depthB: {
-            return 1;
-        }
-        case depthA < depthB: {
-            return -1;
-        }
-        default: {
-            return 0;
-        }
-    }
-}
-export function compareByFqnHierarchically(a, b) {
-    return compareFqnHierarchically(a.id, b.id);
-}

package/dist/utils/fqn.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=fqn.spec.d.ts.map

package/dist/utils/fqn.spec.js

@@ -1,82 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ancestorsFqn, commonAncestor, compareFqnHierarchically, isAncestor, isDescendantOf, notDescendantOf, parentFqn } from './fqn';
-const el = (id) => ({ id });
-describe('parentFqn', () => {
-    it('should return null if no parent', () => {
-        expect(parentFqn('a')).toBeNull();
-    });
-    it('should return parent', () => {
-        expect(parentFqn('a.b')).toBe('a');
-        expect(parentFqn('a.b.c')).toBe('a.b');
-    });
-});
-describe('ancestorsFqn', () => {
-    it('should return empty array if no parent', () => {
-        expect(ancestorsFqn('a')).toEqual([]);
-    });
-    it('should return ancestors', () => {
-        expect(ancestorsFqn('a.b.c.d.e')).toEqual(['a.b.c.d', 'a.b.c', 'a.b', 'a']);
-    });
-});
-describe('commonAncestor', () => {
-    it('should return null if no common ancestor', () => {
-        expect(commonAncestor('a', 'b')).toBeNull();
-        expect(commonAncestor('a.b', 'c.d')).toBeNull();
-    });
-    it('should return common ancestor', () => {
-        expect(commonAncestor('a.b', 'a.c')).toBe('a');
-        expect(commonAncestor('a.b.c', 'a.b.e')).toBe('a.b');
-        expect(commonAncestor('a.b.c.d.e', 'a.b.c.d')).toBe('a.b.c');
-    });
-});
-describe('isAncestor', () => {
-    it('should return true if ancestor', () => {
-        expect(isAncestor('a', 'a.b')).toBe(true);
-        expect(isAncestor('a.b', 'a.b.c')).toBe(true);
-    });
-    it('should return false if not ancestor', () => {
-        expect(isAncestor('a', 'b')).toBe(false);
-        expect(isAncestor('a.b', 'a')).toBe(false);
-        expect(isAncestor('a.b', 'b.a')).toBe(false);
-    });
-});
-describe('isDescendantOf', () => {
-    const predicate = isDescendantOf(['a', 'b', 'a.b', 'a.b.c'].map(el));
-    it('should return true if isDescendantOf', () => {
-        expect(predicate(el('a'))).toBe(true);
-        expect(predicate(el('b.c'))).toBe(true);
-        expect(predicate(el('a.b.c.d.e'))).toBe(true);
-    });
-    it('should return false if not descendantOf', () => {
-        expect(predicate(el('c'))).toBe(false);
-        expect(predicate(el('ac'))).toBe(false);
-        expect(predicate(el('d.a.c'))).toBe(false);
-    });
-});
-describe('notDescendantOf', () => {
-    const predicate = notDescendantOf(['a', 'b', 'a.b', 'a.b.c'].map(el));
-    it('should return true if notDescendantOf', () => {
-        expect(predicate(el('c'))).toBe(true);
-        expect(predicate(el('ac'))).toBe(true);
-        expect(predicate(el('d.a.c'))).toBe(true);
-    });
-    it('should return false if descendantOf', () => {
-        expect(predicate(el('a'))).toBe(false);
-        expect(predicate(el('b.c'))).toBe(false);
-        expect(predicate(el('a.b.c.d.e'))).toBe(false);
-    });
-});
-describe('compareFqnHierarchically', () => {
-    it('should compare hierarchically', () => {
-        expect(['a', 'b', 'a.b', 'a.b.c', 'a.c.c'].sort(compareFqnHierarchically)).toEqual([
-            'a',
-            'b',
-            'a.b',
-            'a.b.c',
-            'a.c.c'
-        ]);
-    });
-    it('should preserve initial order', () => {
-        expect(['aaa', 'aa', 'a', 'aaa.c', 'aa.b', 'a.c', 'a.b'].sort(compareFqnHierarchically)).toEqual(['aaa', 'aa', 'a', 'aaa.c', 'aa.b', 'a.c', 'a.b']);
-    });
-});

package/dist/utils/guards.d.ts

@@ -1,5 +0,0 @@
-import type { NonEmptyArray } from '../types';
-export { hasAtLeast } from 'remeda';
-export declare function isString(value: unknown): value is string;
-export declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
-//# sourceMappingURL=guards.d.ts.map