@likec4/core 1.17.1 → 1.19.0

package/src/utils/iterable/unique.ts

@@ -0,0 +1,29 @@
+import type { IteratorLike } from '../../types'
+
+/**
+ * Returns an iterable that yields only unique values.
+ * It uses a Set to keep track of the values.
+ */
+export function iunique(): <T>(iterable: Iterable<T>) => IteratorLike<T>
+export function iunique<T>(iterable: Iterable<T>): IteratorLike<T>
+
+export function iunique<T>(iterable?: Iterable<T>): IteratorLike<T> | ((iterable: Iterable<T>) => IteratorLike<T>) {
+  if (iterable) {
+    return (function*(): IteratorLike<T> {
+      yield* _iunique(iterable)
+      return
+    })()
+  }
+  return _iunique
+}
+
+function* _iunique<T>(iterable: Iterable<T>): IteratorLike<T> {
+  const seen = new Set<T>()
+  for (const item of iterable) {
+    if (!seen.has(item)) {
+      seen.add(item)
+      yield item
+    }
+  }
+  return
+}

package/src/utils/object-hash.ts

@@ -0,0 +1,3 @@
+import objectHash from 'object-hash'
+
+export { objectHash }

package/src/utils/relations.ts

@@ -1,18 +1,18 @@
 import type { Fqn } from '../types'
 import { commonAncestor, compareFqnHierarchically, isAncestor } from './fqn'
 
-type Relation = {
+export type Relation = {
   source: string
   target: string
 }
 
-type RelationPredicate = (rel: Relation) => boolean
+export type RelationPredicate = (rel: Relation) => 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) => {
+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)
   if (parentA && !parentB) {
@@ -31,64 +31,3 @@ export const compareRelations = <T extends { source: string; target: string }>(a
   }
   return compareFqnHierarchically(a.target, b.target)
 }
-
-export const isInside = (parent: Fqn): RelationPredicate => {
-  const prefix = parent + '.'
-  return (rel: Relation) => {
-    return rel.source.startsWith(prefix) && rel.target.startsWith(prefix)
-  }
-}
-
-export const isBetween = (source: Fqn, target: Fqn): RelationPredicate => {
-  const sourcePrefix = source + '.'
-  const targetPrefix = target + '.'
-  return (rel: Relation) => {
-    return (
-      (rel.source === source || (rel.source + '.').startsWith(sourcePrefix))
-      && (rel.target === target || (rel.target + '.').startsWith(targetPrefix))
-    )
-  }
-}
-
-export const isAnyBetween = (source: Fqn, target: Fqn): RelationPredicate => {
-  const predicates = [isBetween(source, target), isBetween(target, source)]
-  return (rel) => predicates.some(p => p(rel))
-}
-
-export const isIncoming = (target: Fqn): RelationPredicate => {
-  const targetPrefix = target + '.'
-  return (rel: Relation) => {
-    return (
-      !(rel.source + '.').startsWith(targetPrefix)
-      && (rel.target === target || (rel.target + '.').startsWith(targetPrefix))
-    )
-  }
-}
-
-export const isOutgoing = (source: Fqn): RelationPredicate => {
-  const sourcePrefix = source + '.'
-  return (rel: Relation) => {
-    return (
-      (rel.source === source || (rel.source + '.').startsWith(sourcePrefix))
-      && !(rel.target + '.').startsWith(sourcePrefix)
-    )
-  }
-}
-
-export const isAnyInOut = (source: Fqn): RelationPredicate => {
-  const predicates = [isIncoming(source), isOutgoing(source)]
-  return (rel: Relation) => {
-    return predicates.some(p => p(rel))
-  }
-}
-
-export const hasRelation = <R extends { source: Fqn; target: Fqn }>(rel: R) => {
-  return <E extends { id: Fqn }>(element: E) => {
-    return (
-      rel.source === element.id
-      || rel.target === element.id
-      || isAncestor(element.id, rel.source)
-      || isAncestor(element.id, rel.target)
-    )
-  }
-}

package/src/utils/set.ts

@@ -0,0 +1,78 @@
+import { intersection as _intersection, symmetricDifference as _symmetricDifference } from 'mnemonist/set'
+import type { NonEmptyArray } from '../types/_common'
+
+/**
+ * Returns new set as a union of given sets
+ * Keeps order of elements
+ */
+export function union<T>(...sets: ReadonlySet<T>[]): Set<T> {
+  let result = new Set<T>()
+  for (const set of sets) {
+    for (const value of set) {
+      result.add(value)
+    }
+  }
+  return result
+}
+
+/**
+ * Returns new set as an intersection of all sets
+ * Keeps order from the first set
+ */
+export function intersection<T>(first: ReadonlySet<T>, ...sets: NonEmptyArray<ReadonlySet<NoInfer<T>>>): Set<T> {
+  let result = new Set<T>()
+  // If first set is empty, return empty set
+  if (first.size === 0) {
+    return result
+  }
+  let other = sets.length > 1 ? _intersection(...sets as any) : sets[0]
+  if (other.size === 0) {
+    return result
+  }
+  for (const value of first) {
+    if (other.has(value)) {
+      result.add(value)
+    }
+  }
+  return result
+}
+
+export function difference<T>(a: ReadonlySet<T>, b: ReadonlySet<NoInfer<T>>): Set<T> {
+  if (a.size === 0) {
+    return new Set<T>()
+  }
+  if (b.size === 0) {
+    return new Set(a)
+  }
+  let result = new Set<T>()
+  for (const value of a) {
+    if (!b.has(value)) {
+      result.add(value)
+    }
+  }
+  return result
+}
+
+export function equals<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean {
+  return a.size === b.size && [...a].every(value => b.has(value))
+}
+
+export function symmetricDifference<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T> {
+  return _symmetricDifference(a as Set<T>, b as Set<T>)
+}
+
+export function hasIntersection<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean {
+  if (a.size === 0 || b.size === 0) {
+    return false
+  }
+  // Swap sets to iterate over smaller set
+  if (b.size < a.size) {
+    ;[a, b] = [b, a]
+  }
+  for (const value of a) {
+    if (b.has(value)) {
+      return true
+    }
+  }
+  return false
+}

package/src/utils/string-hash.ts

@@ -0,0 +1,16 @@
+import { invariant } from '../errors'
+
+/**
+ * @see https://gist.github.com/victor-homyakov/bcb7d7911e4a388b1c810f8c3ce17bcf
+ */
+export function stringHash(str: string): string {
+  let hash = 5381
+  const len = str.length
+  invariant(len > 0, 'stringHash: empty string')
+
+  for (let i = 0; i < len; i++) {
+    hash = (hash * 33) ^ str.charCodeAt(i)
+  }
+
+  return (hash >>> 0).toString(36)
+}