@likec4/core 1.0.0-next.2 → 1.0.0

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

@@ -1,34 +0,0 @@
-import type { Element, Fqn } from '../types';
-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;
-/**
- * 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;
-//# sourceMappingURL=fqn.d.ts.map

package/dist/types/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

package/dist/types/utils/index.d.ts

@@ -1,4 +0,0 @@
-export * from './fqn';
-export * from './guards';
-export * from './relations';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/utils/relations.d.ts

@@ -1,30 +0,0 @@
-import type { Fqn } from '../types';
-type Relation = {
-    source: string;
-    target: string;
-};
-type RelationPredicate = (rel: Relation) => boolean;
-/**
- * Compares two relations hierarchically.
- * From the most general (implicit) to the most specific.
- */
-export declare const compareRelations: <T extends {
-    source: string;
-    target: string;
-}>(a: T, b: T) => number;
-export declare const Relations: {
-    readonly isInside: (parent: Fqn) => RelationPredicate;
-    readonly isBetween: (source: Fqn, target: Fqn) => RelationPredicate;
-    readonly isAnyBetween: (source: Fqn, target: Fqn) => RelationPredicate;
-    readonly isIncoming: (target: Fqn) => RelationPredicate;
-    readonly isOutgoing: (source: Fqn) => RelationPredicate;
-    readonly isAnyInOut: (source: Fqn) => RelationPredicate;
-    readonly hasRelation: <R extends {
-        source: Fqn;
-        target: Fqn;
-    }>(rel: R) => <E extends {
-        id: Fqn;
-    }>(element: E) => boolean;
-};
-export {};
-//# sourceMappingURL=relations.d.ts.map