@likec4/core 1.30.0 → 1.32.0

package/src/utils/compare-natural.ts

@@ -1,7 +1,6 @@
 import compare from 'natural-compare-lite'
 import { isString } from 'remeda'
 
-
 export function compareNatural(a: string | undefined, b: string | undefined): -1 | 0 | 1 {
   if (a === b) return 0
   if (isString(a)) {
@@ -12,3 +11,46 @@ export function compareNatural(a: string | undefined, b: string | undefined): -1
   }
   return isString(b) ? -1 : 0
 }
+
+/**
+ * Compares two strings hierarchically based on their depth.
+ * From parent nodes to leaves
+ *
+ * @example
+ * const lines = [
+ *   'a.b.c',
+ *   'a',
+ *   'a.b',
+ *   'a.c.c',
+ * ]
+ * lines.sort(compareNaturalHierarchically('.'))
+ * // [
+ * //   'a',
+ * //   'a.b',
+ * //   'a.b.c',
+ * //   'a.c.c',
+ * // ]
+ */
+export function compareNaturalHierarchically(
+  separator = '.',
+): (a: string | undefined, b: string | undefined) => number {
+  return (a, b) => {
+    if (a === b) return 0
+    if (!a) return -1
+    if (!b) return 1
+    const aParts = a.split(separator)
+    const bParts = b.split(separator)
+    if (aParts.length !== bParts.length) {
+      return aParts.length - bParts.length
+    }
+    for (let i = 0; i < aParts.length; i++) {
+      const aPart = aParts[i]!
+      const bPart = bParts[i]!
+      const comparison = compare(aPart, bPart)
+      if (comparison !== 0) {
+        return comparison
+      }
+    }
+    return 0
+  }
+}

package/src/utils/getOrCreate.ts

@@ -1,9 +1,3 @@
-// export function getOrCreate<K, V>(map: Map<K, V>): Map<K, V> & {
-//   get(key: K, create: (key: K) => V): V
-//   get(key: K): V | undefined
-// }
-// export function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V
-// export function getOrCreate<K, V>(map: Map<K, V>, key?: K, create?: (key: K) => V) {
 export function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V {
   let entry = map.get(key)
   if (!entry) {
@@ -12,31 +6,3 @@ export function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V)
   }
   return entry
 }
-
-// export class BetterMap<K, V> extends Map<K, V> {
-//   constructor(iterable?: Iterable<readonly [K, V]> | null) {
-//     super(iterable)
-//   }
-
-//   /**
-//    * Returns the element associated with the specified key.
-//    * If no element is associated with the specified key, and a create function is provided, a new element will be created and stored.
-//    * @example
-//    * ```ts
-//    * const map = new BetterMap<Fqn, Element>()
-//    *
-//    * map.get(fqn, () => factory.createElement(fqn))
-//    *
-//    */
-//   override get(key: K, create: (key: K) => V): V
-//   override get(key: K): V | undefined
-//   override get(key: K, create?: (key: K) => V) {
-//     const entry = super.get(key)
-//     if (!entry && create) {
-//       const newEntry = create(key)
-//       this.set(key, newEntry)
-//       return newEntry
-//     }
-//     return entry
-//   }
-// }

package/src/utils/index.ts

@@ -8,13 +8,10 @@ export {
   Stack,
 } from './mnemonist'
 
-export {
-  commonHead,
-} from './common-head'
+export { invariant, nonexhaustive, nonNullable } from './invariant'
 
-export {
-  compareNatural,
-} from './compare-natural'
+export { commonHead } from './common-head'
+export { compareNatural, compareNaturalHierarchically } from './compare-natural'
 export {
   ancestorsFqn,
   commonAncestor,
@@ -34,9 +31,7 @@ export {
   sortParentsFirst,
 } from './fqn'
 
-export {
-  getOrCreate,
-} from './getOrCreate'
+export { getOrCreate } from './getOrCreate'
 
 export {
   hasAtLeast,
@@ -47,6 +42,7 @@ export {
   ifilter,
   ifind,
   iflat,
+  ihead,
   imap,
   ireduce,
   isIterable,
@@ -55,9 +51,8 @@ export {
   toArray,
   toSet,
 } from './iterable'
-export {
-  delay,
-} from './promises'
+export { memoizeProp } from './memoize-prop'
+export { delay } from './promises'
 
 export {
   compareRelations,

package/src/utils/iterable/filter.ts

@@ -1,6 +1,6 @@
 import { isFunction } from 'remeda'
-import { invariant } from '../../errors'
 import type { IteratorLike } from '../../types'
+import { invariant } from '../../utils/invariant'
 
 /**
  * Filters an iterable based on a predicate.

package/src/utils/iterable/find.ts

@@ -1,5 +1,5 @@
 import { isFunction } from 'remeda'
-import { invariant } from '../../errors'
+import { invariant } from '../../utils/invariant'
 
 /**
  * Finds the first element in the iterable that satisfies the predicate.
@@ -7,6 +7,7 @@ import { invariant } from '../../errors'
  * @signature
  *   ifind(predicate)(data)
  */
+export function ifind<T, S extends T>(predicate: (item: T) => item is S): (iterable: Iterable<T>) => S | undefined
 export function ifind<T>(predicate: (item: T) => boolean): (iterable: Iterable<T>) => T | undefined
 /**
  * Finds the first element in the iterable that satisfies the predicate.
@@ -14,6 +15,7 @@ export function ifind<T>(predicate: (item: T) => boolean): (iterable: Iterable<T
  * @signature
  *  ifind(data, predicate)
  */
+export function ifind<T, S extends T>(iterable: Iterable<T>, predicate: (item: T) => item is S): S | undefined
 export function ifind<T>(iterable: Iterable<T>, predicate: (item: T) => boolean): T | undefined
 
 export function ifind(arg1: unknown, arg2?: unknown) {

package/src/utils/iterable/head.ts

@@ -0,0 +1,22 @@
+export function ihead<T>(): (iterable: Iterable<T>) => T | undefined
+/**
+ * Finds the first element in the iterable that satisfies the predicate.
+ * Data first version of `find`.
+ * @signature
+ *  ifind(data, predicate)
+ */
+export function ihead<T>(iterable: Iterable<T>): T | undefined
+
+export function ihead<T>(iterable?: Iterable<T>) {
+  if (!iterable) {
+    return _head
+  }
+  return _head(iterable)
+}
+
+function _head<T>(iter: Iterable<T>) {
+  for (const value of iter) {
+    return value
+  }
+  return
+}

package/src/utils/iterable/index.ts

@@ -6,6 +6,7 @@ export { isIterable } from './_types'
 export { ifilter } from './filter'
 export { ifind } from './find'
 export { iflat } from './flat'
+export { ihead } from './head'
 export { imap } from './map'
 export { ireduce } from './reduce'
 export { isome } from './some'

package/src/utils/iterable/map.ts

@@ -1,6 +1,6 @@
 import { isFunction } from 'remeda'
-import { invariant } from '../../errors'
 import type { IteratorLike } from '../../types'
+import { invariant } from '../../utils/invariant'
 
 type MapFunction<T, S> = (item: T) => S
 

package/src/utils/iterable/reduce.ts

@@ -1,5 +1,5 @@
 import { isDefined, isFunction } from 'remeda'
-import { invariant } from '../../errors'
+import { invariant } from '../../utils/invariant'
 
 export function ireduce<T, R>(reducer: (acc: R, item: T) => R, initialValue: R): (iterable: Iterable<T>) => R
 export function ireduce<T, R>(iterable: Iterable<T>, reducer: (acc: R, item: T) => R, initialValue: R): R

package/src/utils/iterable/some.ts

@@ -1,5 +1,5 @@
 import { isFunction } from 'remeda'
-import { invariant } from '../../errors'
+import { invariant } from '../../utils/invariant'
 
 /**
  * Checks if at least one element in the iterable satisfies the predicate.

package/src/utils/memoize-prop.ts

@@ -0,0 +1,30 @@
+/**
+ * Saves the value returned by fn() in a hidden property tag of obj object, so next time memoizeProp() is called,
+ * that value will be returned, and fn won't be called.
+ *
+ * @example
+ * ```ts
+ * class Model {
+ *   // using same Symbol
+ *   get computed1() {
+ *     return memoizeProp(this, Symbol.for('computed1'), () => doOnce())
+ *   }
+ *   // using string
+ *   get computed2() {
+ *     return memoizeProp(this, 'computed2', () => doOnce())
+ *   }
+ *
+ * }
+ * ```
+ */
+export function memoizeProp<Tag extends symbol | string, Res>(obj: object, tag: Tag, fn: () => Res): Res {
+  const tagSymbol = typeof tag === 'symbol' ? tag : Symbol.for(tag)
+  if (!obj.hasOwnProperty(tagSymbol)) {
+    Object.defineProperty(obj, tagSymbol, {
+      enumerable: false,
+      writable: false,
+      value: fn(),
+    })
+  }
+  return (obj as any)[tagSymbol]!
+}

package/src/utils/object-hash.ts

@@ -1,6 +1,6 @@
 import objecthash from 'object-hash'
 import { isNonNullish } from 'remeda'
-import { invariant } from '../errors'
+import { invariant } from '../utils/invariant'
 
 export function objectHash(value: any): string {
   invariant(

package/src/utils/relations.ts

@@ -1,20 +1,23 @@
-import type { Fqn } from '../types'
-import { commonAncestor, compareFqnHierarchically, isAncestor } from './fqn'
+import { commonAncestor, compareFqnHierarchically } from './fqn'
 
-export type Relation = {
-  source: string
-  target: string
+export type RelationshipLike = {
+  source: {
+    model: string
+  }
+  target: {
+    model: string
+  }
 }
 
-export type RelationPredicate = (rel: Relation) => boolean
+export type RelationPredicate = (rel: RelationshipLike) => boolean
 
 /**
  * Compares two relations hierarchically.
  * From the most general (implicit) to the most specific.
  */
-export const compareRelations = <T extends { source: string; target: string }>(a: T, b: T): number => {
-  const parentA = commonAncestor(a.source as Fqn, a.target as Fqn)
-  const parentB = commonAncestor(b.source as Fqn, b.target as Fqn)
+export const compareRelations = <T extends RelationshipLike>(a: T, b: T): number => {
+  const parentA = commonAncestor(a.source.model, a.target.model)
+  const parentB = commonAncestor(b.source.model, b.target.model)
   if (parentA && !parentB) {
     return 1
   }
@@ -25,9 +28,9 @@ export const compareRelations = <T extends { source: string; target: string }>(a
   if (compareParents !== 0) {
     return compareParents
   }
-  const compareSource = compareFqnHierarchically(a.source, b.source)
+  const compareSource = compareFqnHierarchically(a.source.model, b.source.model)
   if (compareSource !== 0) {
     return compareSource
   }
-  return compareFqnHierarchically(a.target, b.target)
+  return compareFqnHierarchically(a.target.model, b.target.model)
 }

package/src/utils/string-hash.ts

@@ -1,4 +1,4 @@
-import { invariant } from '../errors'
+import { invariant } from '../utils/invariant'
 
 /**
  * @see https://gist.github.com/victor-homyakov/bcb7d7911e4a388b1c810f8c3ce17bcf

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

@@ -1,146 +0,0 @@
-import { E as ElementModel, d as DeploymentElementModel, A as AnyAux, e as DeploymentNodeModel, D as DeployedInstanceModel, j as RelationshipsAccum, R as RelationshipModel, f as DeploymentRelationModel } from './core.CiFKryGW.mjs';
-import { F as Fqn, I as IteratorLike } from './core.SjLhMA7a.mjs';
-
-interface Connection<Elem = ElementModel | DeploymentElementModel, Id = string> {
-    readonly id: Id;
-    readonly source: Elem;
-    readonly target: Elem;
-    /**
-     * Common ancestor of the source and target elements.
-     * Represents the boundary of the connection.
-     */
-    readonly boundary: Elem | null;
-    /**
-     * Human readable expression of the connection
-     * Mostly used for testing and debugging
-     */
-    readonly expression: string;
-    mergeWith(this: Connection<Elem, Id>, other: typeof this): typeof this;
-    nonEmpty(): boolean;
-    difference(this: Connection<Elem, Id>, other: typeof this): typeof this;
-    intersect(this: Connection<Elem, Id>, other: typeof this): typeof this;
-    equals(other: Connection): boolean;
-}
-declare namespace Connection {
-    type ConnectionPredicate = <C extends Connection<{
-        id: string;
-    }, any>>(connection: C) => boolean;
-    type ElementId = Fqn | string;
-    export const isInside: (fqn: ElementId) => ConnectionPredicate;
-    export const isDirectedBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
-    export const isAnyBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
-    export const isIncoming: (target: ElementId) => ConnectionPredicate;
-    export const isOutgoing: (source: ElementId) => ConnectionPredicate;
-    export const isAnyInOut: (source: ElementId) => ConnectionPredicate;
-    export {  };
-}
-
-declare const customInspectSymbol: unique symbol;
-
-/**
- * Connection is ephemeral entity, result of a resolving relationships between source and target.
- * Includes direct relationships and/or between their nested elements.
- */
-declare class DeploymentConnectionModel<M extends AnyAux = AnyAux> implements Connection<DeploymentElementModel<M>, M['EdgeId']> {
-    readonly source: DeploymentNodeModel<M> | DeployedInstanceModel<M>;
-    readonly target: DeploymentNodeModel<M> | DeployedInstanceModel<M>;
-    readonly relations: RelationshipsAccum<M>;
-    constructor(source: DeploymentNodeModel<M> | DeployedInstanceModel<M>, target: DeploymentNodeModel<M> | DeployedInstanceModel<M>, relations: RelationshipsAccum<M>);
-    readonly id: M['EdgeId'];
-    /**
-     * Human readable expression of the connection
-     * Mostly used for testing and debugging
-     */
-    get expression(): string;
-    private _boundary;
-    /**
-     * Common ancestor of the source and target elements.
-     * Represents the boundary of the connection.
-     */
-    get boundary(): DeploymentNodeModel<M> | null;
-    nonEmpty(): boolean;
-    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
-    toString(): string;
-    /**
-     * Check if connection contains deployment relation,
-     * that is directly connected to source or target.
-     */
-    hasDirectDeploymentRelation(): boolean;
-    values(): IteratorLike<RelationshipModel<M> | DeploymentRelationModel<M>>;
-    /**
-     * Merge with another connections, if it has the same source and target.
-     * Returns new connection with union of relationships.
-     */
-    mergeWith(others: DeploymentConnectionModel<M>[]): DeploymentConnectionModel<M>;
-    /**
-     * Merge with another connection, if it has the same source and target.
-     * Returns new connection with union of relationships.
-     */
-    mergeWith(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
-    difference(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
-    intersect(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>;
-    equals(other: Connection): boolean;
-    /**
-     * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
-     * if `null` is provided in overrides, the corresponding relation set will be empty.
-     */
-    update(overrides?: {
-        model?: ReadonlySet<RelationshipModel<M>> | null;
-        deployment?: ReadonlySet<DeploymentRelationModel<M>> | null;
-    }): DeploymentConnectionModel<M>;
-}
-
-/**
- * Connection refers to any relationships between two elements,
- * both direct and implicit ones (between their nested elements).
- *
- * Merges relationships together to an single edge on the diagram.
- */
-declare class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<ElementModel<M>, M['EdgeId']> {
-    readonly source: ElementModel<M>;
-    readonly target: ElementModel<M>;
-    readonly relations: ReadonlySet<RelationshipModel<M>>;
-    readonly id: M['EdgeId'];
-    constructor(source: ElementModel<M>, target: ElementModel<M>, relations?: ReadonlySet<RelationshipModel<M>>);
-    private _boundary;
-    /**
-     * Common ancestor of the source and target elements.
-     * Represents the boundary of the connection.
-     */
-    get boundary(): ElementModel<M> | null;
-    /**
-     * Human readable expression of the connection
-     * Mostly used for testing and debugging
-     */
-    get expression(): string;
-    /**
-     * Returns true if only includes relations between the source and target elements.
-     */
-    get isDirect(): boolean;
-    /**
-     * Returns true if includes relations between nested elements of the source and target elements.
-     */
-    get isImplicit(): boolean;
-    get directRelations(): ReadonlySet<RelationshipModel<M>>;
-    nonEmpty(): boolean;
-    mergeWith(other: ConnectionModel<M>): ConnectionModel<M>;
-    difference(other: ConnectionModel<M>): ConnectionModel<M>;
-    intersect(other: ConnectionModel<M>): ConnectionModel<M>;
-    equals(other: Connection): boolean;
-    /**
-     * Returns a new instance with the updated relations.
-     *
-     * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
-     * @returns A new `ConnectionModel` instance with the updated relations.
-     */
-    update(relations: ReadonlySet<RelationshipModel<M>>): ConnectionModel<M>;
-    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
-    toString(): string;
-    /**
-     * Creates a new connection with reversed direction (target becomes source and vice versa)
-     * @param search - When true, attempts to find an existing connection between the reversed nodes
-     */
-    reversed(search?: boolean): ConnectionModel<M>;
-}
-
-export { Connection as C, DeploymentConnectionModel as D, ConnectionModel as a };