@likec4/core 1.41.0 → 1.42.0

package/src/utils/fqn.ts

@@ -1,302 +0,0 @@
-import type { Fqn, IterableContainer, ReorderedArray } from '../types'
-import { compareNatural } from './compare-natural'
-import { isString } from './guards'
-
-export type Predicate<T> = (x: T) => boolean
-
-export function parentFqn<E extends string>(fqn: E): E | null {
-  const lastDot = fqn.lastIndexOf('.')
-  if (lastDot > 0) {
-    return fqn.slice(0, lastDot) as E
-  }
-  return null
-}
-
-export function parentFqnPredicate<T extends { parent: Fqn | null }>(parent: Fqn): Predicate<T> {
-  const prefix = parent + '.'
-  return (e: T) => !!e.parent && (e.parent === parent || e.parent.startsWith(prefix))
-}
-
-export function nameFromFqn<E extends string>(fqn: E): string {
-  const lastDot = fqn.lastIndexOf('.')
-  if (lastDot > 0) {
-    return fqn.slice(lastDot + 1)
-  } else {
-    return fqn
-  }
-}
-
-const asString: <E extends string | { id: string }>(e: E) => string = e => (isString(e) ? e : e.id)
-
-/**
- * Check if one element is an ancestor of another
- * Composable version
- * @signature
- *  isAncestor(another)(ancestor)
- */
-export 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)
- */
-export function isAncestor<A extends string | { id: string }>(ancestor: A, another: A): boolean
-
-export function isAncestor<T extends string>(
-  arg1: T | WithId<T>,
-  arg2?: NoInfer<T> | WithId<NoInfer<T>>,
-) {
-  const arg1Id = asString(arg1)
-  if (arg2) {
-    const arg2Id = asString(arg2)
-    return arg2Id.startsWith(arg1Id + '.')
-  }
-  return (ancestor: T | WithId<T>) => {
-    const ancestorId = asString(ancestor)
-    return arg1Id.startsWith(ancestorId + '.')
-  }
-}
-
-export function isSameHierarchy<T extends string>(
-  one: NoInfer<T> | WithId<NoInfer<T>>,
-): (another: T | WithId<T>) => boolean
-export function isSameHierarchy<T extends string>(one: T | WithId<T>, another: T | WithId<T>): boolean
-export function isSameHierarchy<T extends string>(one: T | WithId<T>, another?: T | WithId<T>) {
-  if (!another) {
-    return (b: T | WithId<T>) => isSameHierarchy(one, b)
-  }
-  const first = asString(one)
-  const second = asString(another)
-  return first === second || second.startsWith(first + '.') || first.startsWith(second + '.')
-}
-
-type WithId<T = string> = { id: T }
-
-export function isDescendantOf<T extends string>(ancestor: WithId<T>): (descedant: WithId<T>) => boolean
-export function isDescendantOf<T extends string>(descedant: WithId<T>, ancestor: WithId<T>): boolean
-export function isDescendantOf<T extends string>(descedant: WithId<T>, ancestor?: WithId<T>) {
-  if (!ancestor) {
-    return (d: WithId<T>) => isAncestor(descedant, d)
-  }
-  return isAncestor(ancestor, descedant)
-}
-
-/**
- * How deep in the hierarchy the element is.
- * Root element has depth 1
- */
-export function hierarchyLevel<E extends string | { id: Fqn }>(elementOfFqn: E): number {
-  const first = isString(elementOfFqn) ? elementOfFqn : elementOfFqn.id
-  return first.split('.').length
-}
-
-/**
- * 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
- */
-export function hierarchyDistance<E extends string | { id: Fqn }>(one: E, another: E): number {
-  const first = isString(one) ? one as Fqn : one.id
-  const second = isString(another) ? another as Fqn : another.id
-
-  if (first === second) {
-    return 0
-  }
-
-  const firstDepth = hierarchyLevel(first)
-  const secondDepth = hierarchyLevel(second)
-
-  if (isSameHierarchy(first, second)) {
-    return Math.abs(firstDepth - secondDepth)
-  }
-
-  const ancestor = commonAncestor(first as Fqn, second as Fqn)
-  const ancestorDepth = ancestor ? hierarchyLevel(ancestor) : 0
-
-  return firstDepth + secondDepth - (2 * ancestorDepth + 1)
-}
-
-export function commonAncestor<E extends string>(first: E, second: E): E | null {
-  const a = first.split('.')
-  if (a.length < 2) {
-    return null
-  }
-  const b = second.split('.')
-  if (b.length < 2) {
-    return null
-  }
-  let ancestor = [] as string[]
-  for (let i = 0; i < Math.min(a.length, b.length) - 1 && a[i] === b[i]; i++) {
-    ancestor.push(a[i]!)
-  }
-  if (ancestor.length === 0) {
-    return null
-  }
-  return ancestor.join('.') as E
-}
-
-/**
- * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
- * going up from parent to the root
- */
-export function ancestorsFqn<Id extends string>(fqn: Id): Id[] {
-  const path = fqn.split('.') as Id[]
-  path.pop()
-  if (path.length === 0) {
-    return []
-  }
-  return path.reduce((acc, part, idx) => {
-    if (idx === 0) {
-      acc.push(part)
-      return acc
-    }
-    acc.unshift(`${acc[0]}.${part}` as Id)
-    return acc
-  }, [] as 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.
- */
-export function compareFqnHierarchically<T extends string = string>(a: T, b: T): -1 | 0 | 1 {
-  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<T extends { id: string }>(a: T, b: T): -1 | 0 | 1 {
-  return compareFqnHierarchically(a.id, b.id)
-}
-
-/**
- * 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" }
- * // ]
- * ```
- */
-export function sortByFqnHierarchically<T extends { id: string }, A extends IterableContainer<T>>(
-  array: A,
-): ReorderedArray<A> {
-  return array
-    .map(item => ({ item, fqn: item.id.split('.') }))
-    .sort((a, b) => {
-      return a.fqn.length - b.fqn.length
-    })
-    .map(({ item }) => item) as ReorderedArray<A>
-}
-
-function findTopAncestor<T extends { id: string }>(items: T[], item: T): T | null {
-  let parent = item
-  for (const e of items) {
-    if (isAncestor(e, parent)) {
-      parent = e
-    }
-  }
-  return parent !== item ? parent : null
-}
-
-/**
- * Keeps initial order of the elements, but ensures that parents are before children
- */
-export function sortParentsFirst<T extends { id: string }, A extends IterableContainer<T>>(
-  array: A,
-): ReorderedArray<A> {
-  const result = [] as T[]
-  const items = [...array]
-  let item
-  while ((item = items.shift())) {
-    let parent
-    while ((parent = findTopAncestor(items, item))) {
-      result.push(items.splice(items.indexOf(parent), 1)[0]!)
-    }
-    result.push(item)
-  }
-  return result as 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');
- */
-export function sortNaturalByFqn(
-  sort?: 'asc' | 'desc',
-): <I extends WithId<string>, A extends IterableContainer<I>>(array: A) => ReorderedArray<A>
-export function sortNaturalByFqn<A extends IterableContainer<WithId>>(
-  array: A,
-  sort?: 'asc' | 'desc',
-): ReorderedArray<A>
-export function sortNaturalByFqn<A extends IterableContainer<WithId>>(
-  array?: A | 'asc' | 'desc',
-  sort?: 'asc' | 'desc',
-) {
-  if (!array || isString(array)) {
-    const dir = array ?? 'asc'
-    return (arr: A) => sortNaturalByFqn(arr, dir)
-  }
-  const dir = sort === 'desc' ? -1 : 1
-  return array
-    .map(item => ({ item, fqn: item.id.split('.') }))
-    .sort((a, b) => {
-      if (a.fqn.length !== b.fqn.length) {
-        return (a.fqn.length - b.fqn.length) * dir
-      }
-      for (let i = 0; i < a.fqn.length; i++) {
-        const compare = compareNatural(a.fqn[i], b.fqn[i])
-        if (compare !== 0) {
-          return compare
-        }
-      }
-      return 0
-    })
-    .map(({ item }) => item) as ReorderedArray<A>
-}

package/src/utils/getOrCreate.ts

@@ -1,8 +0,0 @@
-export function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V {
-  let entry = map.get(key)
-  if (!entry) {
-    entry = create(key)
-    map.set(key, entry)
-  }
-  return entry
-}

package/src/utils/guards.ts

@@ -1,9 +0,0 @@
-import type { NonEmptyArray } from '../types'
-
-export function isString(value: unknown): value is string {
-  return value != null && typeof value === 'string'
-}
-
-export function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A> {
-  return !!arr && Array.isArray(arr) && arr.length > 0
-}

package/src/utils/index.ts

@@ -1,68 +0,0 @@
-export {
-  BiMap,
-  DefaultMap,
-  DefaultWeakMap,
-  LinkedList,
-  MultiMap,
-  Queue,
-  Stack,
-} from './mnemonist'
-
-export { invariant, nonexhaustive, nonNullable } from './invariant'
-
-export { commonHead } from './common-head'
-export { compareNatural, compareNaturalHierarchically } from './compare-natural'
-export {
-  ancestorsFqn,
-  commonAncestor,
-  compareByFqnHierarchically,
-  compareFqnHierarchically,
-  hierarchyDistance,
-  hierarchyLevel,
-  isAncestor,
-  isDescendantOf,
-  isSameHierarchy,
-  nameFromFqn,
-  parentFqn,
-  sortByFqnHierarchically,
-  sortNaturalByFqn,
-  sortParentsFirst,
-} from './fqn'
-
-export { getOrCreate } from './getOrCreate'
-
-export {
-  isNonEmptyArray,
-  isString,
-} from './guards'
-export {
-  ifilter,
-  ifind,
-  ifirst,
-  iflat,
-  ihead,
-  imap,
-  ireduce,
-  isIterable,
-  isome,
-  iunique,
-  toArray,
-  toSet,
-} from './iterable'
-export { memoizeProp } from './memoize-prop'
-export { delay, promiseNextTick } from './promises'
-
-export { compareRelations } from './relations'
-
-export {
-  difference,
-  equals as equalsSet,
-  intersection,
-  symmetricDifference,
-  union,
-} from './set'
-
-export { objectHash } from './object-hash'
-export { stringHash } from './string-hash'
-
-export { markdownToHtml, markdownToText } from './markdown'

package/src/utils/invariant.ts

@@ -1,29 +0,0 @@
-// Ensure that the value is NonNullable
-// Mostly as safer `value!`
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function nonNullable<T>(value: T, message?: string | (() => string)): NonNullable<T> {
-  if (typeof value === 'undefined' || value == null) {
-    const msg = typeof message === 'function' ? message() : message
-    throw new Error(msg ?? `Expected defined value, but received ${value}`)
-  }
-  return value
-}
-
-// Throw an error if the condition fails
-// > Not providing an inline default argument for message as the result is smaller
-export function invariant(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  condition: any,
-  // Can provide a string, or a function that returns a string for cases where
-  // the message takes a fair amount of effort to compute
-  message?: string,
-): asserts condition {
-  if (condition) {
-    return
-  }
-  throw new Error(message ?? 'Invariant failed')
-}
-
-export function nonexhaustive(value: never): never {
-  throw new Error(`NonExhaustive value: ${value}`)
-}

package/src/utils/iterable/_types.ts

@@ -1,5 +0,0 @@
-import { isNonNullish } from 'remeda'
-
-export function isIterable<T, I extends Iterable<T>>(something: I | unknown): something is Iterable<T> {
-  return isNonNullish(something) && typeof something === 'object' && Symbol.iterator in something
-}

package/src/utils/iterable/filter.ts

@@ -1,55 +0,0 @@
-import { isFunction } from 'remeda'
-import type { IteratorLike } from '../../types'
-import { invariant } from '../../utils/invariant'
-
-/**
- * Filters an iterable based on a predicate.
- * Composabel first version of `ifilter`.
- * @signature
- *    ifilter(predicate)(data)
- */
-export function ifilter<T, S extends T>(
-  predicate: (v: T) => v is S,
-): (iterable: Iterable<T>) => IteratorLike<S>
-export function ifilter<T>(
-  predicate: (v: T) => boolean,
-): (iterable: Iterable<T>) => IteratorLike<T>
-
-/**
- * Filters an iterable based on a predicate.
- * Data first version of `ifilter`.
- * @signature
- *    ifilter(data, predicate)
- * @example
- *    ifilter(new Set([1, 2, 3]), x => x % 2 === 1) // => Iterable<[1, 3]>
- */
-export function ifilter<T, S extends T>(
-  iterable: Iterable<T>,
-  predicate: (v: T) => v is S,
-): IteratorLike<S>
-export function ifilter<T>(
-  iterable: Iterable<T>,
-  predicate: (v: T) => boolean,
-): IteratorLike<T>
-
-export function ifilter(
-  arg1: unknown,
-  arg2?: unknown,
-): IteratorLike<unknown> | ((it: Iterable<unknown>) => IteratorLike<unknown>) {
-  const pred = (arg2 ?? arg1) as (v: any) => boolean
-  invariant(isFunction(pred))
-
-  function* _filter(iter: Iterable<unknown>): IteratorLike<unknown> {
-    for (const value of iter) {
-      if (pred(value)) {
-        yield value
-      }
-    }
-    return
-  }
-
-  if (!arg2) {
-    return _filter
-  }
-  return _filter(arg1 as Iterable<unknown>)
-}

package/src/utils/iterable/find.ts

@@ -1,38 +0,0 @@
-import { isFunction } from 'remeda'
-import { invariant } from '../../utils/invariant'
-
-/**
- * Finds the first element in the iterable that satisfies the predicate.
- * Composable first version of `find`.
- * @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.
- * Data first version of `find`.
- * @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) {
-  const pred = (arg2 ?? arg1) as (v: any) => boolean
-  invariant(isFunction(pred))
-
-  function _find(iter: Iterable<unknown>) {
-    for (const value of iter) {
-      if (pred(value)) {
-        return value
-      }
-    }
-    return
-  }
-
-  if (!arg2) {
-    return _find
-  }
-  return _find(arg1 as Iterable<unknown>)
-}

package/src/utils/iterable/first.ts

@@ -1,48 +0,0 @@
-import type { IteratorLike } from '../../types'
-import { invariant } from '../../utils/invariant'
-
-/**
- * Takes the first N elements from an iterable.
- * Composable first version of `ifirst`.
- * @signature
- *   ifirst(count)(data)
- */
-export function ifirst<T>(count: number): (iterable: Iterable<T>) => IteratorLike<T>
-
-/**
- * Takes the first N elements from an iterable.
- * Data first version of `ifirst`.
- * @signature
- *   ifirst(data, count)
- * @example
- *   ifirst([1, 2, 3, 4, 5], 3) // => Iterable<[1, 2, 3]>
- */
-export function ifirst<T>(iterable: Iterable<T>, count: number): IteratorLike<T>
-
-export function ifirst(
-  arg1: unknown,
-  arg2?: unknown,
-): IteratorLike<unknown> | ((it: Iterable<unknown>) => IteratorLike<unknown>) {
-  const count = (arg2 ?? arg1) as number
-  invariant(typeof count === 'number' && count >= 0, 'Count must be a non-negative number')
-
-  function* _first(iter: Iterable<unknown>): IteratorLike<unknown> {
-    let taken = 0
-    for (const value of iter) {
-      if (taken >= count) {
-        break
-      }
-      yield value
-      taken++
-    }
-    return
-  }
-
-  if (arg2 === undefined) {
-    // Composable version: ifirst(count)(iterable)
-    return (iterable: Iterable<unknown>) => _first(iterable)
-  }
-
-  // Data-first version: ifirst(iterable, count)
-  return _first(arg1 as Iterable<unknown>)
-}

package/src/utils/iterable/flat.ts

@@ -1,17 +0,0 @@
-import type { IteratorLike } from '../../types'
-
-export function iflat(): <T>(iterable: Iterable<IteratorLike<T>>) => IteratorLike<T>
-export function iflat<T>(iterable: Iterable<IteratorLike<T>>): IteratorLike<T>
-
-export function iflat<T>(
-  iterable?: Iterable<IteratorLike<T>>,
-): IteratorLike<T> | ((iterable: Iterable<IteratorLike<T>>) => IteratorLike<T>) {
-  return iterable ? _iflat(iterable) : _iflat
-}
-
-function* _iflat<T>(iterable: Iterable<IteratorLike<T>>): IteratorLike<T> {
-  for (const inner of iterable) {
-    yield* inner
-  }
-  return
-}

package/src/utils/iterable/head.ts

@@ -1,22 +0,0 @@
-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

@@ -1,15 +0,0 @@
-export { isIterable } from './_types'
-
-/**
- * operators
- */
-export { ifilter } from './filter'
-export { ifind } from './find'
-export { ifirst } from './first'
-export { iflat } from './flat'
-export { ihead } from './head'
-export { imap } from './map'
-export { ireduce } from './reduce'
-export { isome } from './some'
-export { toArray, toSet } from './to'
-export { iunique } from './unique'

package/src/utils/iterable/map.ts

@@ -1,40 +0,0 @@
-import { isFunction } from 'remeda'
-import type { IteratorLike } from '../../types'
-import { invariant } from '../../utils/invariant'
-
-type MapFunction<T, S> = (item: T) => S
-
-/**
- * Maps an iterable using a mapper function.
- * Composable first version of `imap`.
- * @signature
- *   imap(mapper)(data)
- */
-export function imap<T, S>(mapper: MapFunction<T, S>): (iterable: Iterable<T>) => IteratorLike<S>
-/**
- * Maps an iterable using a mapper function.
- * Data first version of `imap`.
- * @signature
- *   imap(data, mapper)
- */
-export function imap<T, S>(iterable: Iterable<T>, mapper: MapFunction<T, S>): IteratorLike<S>
-
-export function imap(
-  arg1: unknown,
-  arg2?: unknown,
-): IteratorLike<unknown> | ((it: Iterable<unknown>) => IteratorLike<unknown>) {
-  const mapper = (arg2 ?? arg1) as MapFunction<any, any>
-  invariant(isFunction(mapper))
-
-  function* _map(iter: Iterable<unknown>): IteratorLike<unknown> {
-    for (const value of iter) {
-      yield mapper(value)
-    }
-    return
-  }
-
-  if (!arg2) {
-    return _map
-  }
-  return _map(arg1 as Iterable<unknown>)
-}

package/src/utils/iterable/reduce.ts

@@ -1,24 +0,0 @@
-import { isDefined, isFunction } from 'remeda'
-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
-export function ireduce<T, R>(
-  arg1: unknown,
-  arg2: unknown,
-  arg3?: unknown,
-): R | ((iterable: Iterable<T>) => R) {
-  const reducer = (isDefined(arg3) ? arg2 : arg1) as (acc: R, item: T) => R
-  const initialValue = arg3 ?? arg2
-  invariant(isFunction(reducer))
-
-  function _reduce(iter: Iterable<T>): R {
-    let acc = initialValue as R
-    for (const value of iter) {
-      acc = reducer(acc, value)
-    }
-    return acc
-  }
-
-  return isDefined(arg3) ? _reduce(arg1 as Iterable<T>) : _reduce
-}