@likec4/core 1.40.0 → 1.42.0

package/src/utils/iterable/some.ts

@@ -1,36 +0,0 @@
-import { isFunction } from 'remeda'
-import { invariant } from '../../utils/invariant'
-
-/**
- * Checks if at least one element in the iterable satisfies the predicate.
- * Composable first version of `some`.
- * @signature
- *   isome(predicate)(data)
- */
-export function isome<T>(predicate: (item: T) => boolean): (iterable: Iterable<T>) => boolean
-/**
- * Checks if at least one element in the iterable satisfies the predicate.
- * Data first version of `some`.
- * @signature
- *  isome(data, predicate)
- */
-export function isome<T>(iterable: Iterable<T>, predicate: (item: T) => boolean): boolean
-
-export function isome<T>(arg1: unknown, arg2?: unknown): boolean | ((iterable: Iterable<T>) => boolean) {
-  const pred = (arg2 ?? arg1) as (v: any) => boolean
-  invariant(isFunction(pred))
-
-  function _some(iter: Iterable<unknown>): boolean {
-    for (const value of iter) {
-      if (pred(value)) {
-        return true
-      }
-    }
-    return false
-  }
-
-  if (!arg2) {
-    return _some
-  }
-  return _some(arg1 as Iterable<unknown>)
-}

package/src/utils/iterable/to.ts

@@ -1,19 +0,0 @@
-export function toArray(): <T>(iterable: Iterable<T> | ArrayLike<T>) => T[]
-export function toArray<T>(iterable: Iterable<T> | ArrayLike<T>): T[]
-export function toArray<T>(
-  iterable?: Iterable<T> | ArrayLike<T>
-): T[] | (<T>(iterable: Iterable<T> | ArrayLike<T>) => T[]) {
-  if (iterable) {
-    return Array.from(iterable)
-  }
-  return (it) => Array.from(it)
-}
-
-export function toSet(): <T>(iterable: Iterable<T>) => Set<T>
-export function toSet<T>(iterable: Iterable<T>): Set<T>
-export function toSet<T>(iterable?: Iterable<T>): Set<T> | ((iterable: Iterable<T>) => Set<T>) {
-  if (iterable) {
-    return new Set(iterable)
-  }
-  return (it) => new Set(it)
-}

package/src/utils/iterable/unique.ts

@@ -1,23 +0,0 @@
-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>) {
-  return iterable ? _iunique(iterable) : _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/markdown/index.ts

@@ -1,2 +0,0 @@
-export { markdownToHtml } from './to-html'
-export { markdownToText } from './to-text'

package/src/utils/markdown/to-html.ts

@@ -1,32 +0,0 @@
-import rehypeRaw from 'rehype-raw'
-import rehypeSanitize from 'rehype-sanitize'
-import rehypeStringify from 'rehype-stringify'
-import remarkGfm from 'remark-gfm'
-import remarkParse from 'remark-parse'
-import remarkRehype from 'remark-rehype'
-import { unified } from 'unified'
-
-// let _remark
-function remark() {
-  return unified()
-    .use(remarkParse)
-    .use(remarkGfm)
-    .use(remarkRehype, {
-      // Tight paragraphs prevent extra newlines
-      allowDangerousHtml: true,
-      clobberPrefix: '',
-      tableCellPadding: false,
-      tight: true,
-    })
-    .use(rehypeRaw)
-    .use(rehypeSanitize)
-    .use(rehypeStringify, {
-      // Prevent extra closing newlines
-      closeSelfClosing: true,
-      tightSelfClosing: true,
-    })
-}
-
-export function markdownToHtml(markdown: string): string {
-  return String(remark().processSync(markdown.trim())).trim()
-}

package/src/utils/markdown/to-text.ts

@@ -1,14 +0,0 @@
-import { fromMarkdown } from 'mdast-util-from-markdown'
-import { toString } from 'mdast-util-to-string'
-
-/**
- * Converts markdown to plain text, removing any markdown formatting.
- * @param markdown - The markdown to convert.
- * @returns The plain text.
- */
-export function markdownToText(markdown: string): string {
-  return toString(fromMarkdown(markdown), {
-    includeHtml: false,
-    includeImageAlt: false,
-  })
-}

package/src/utils/memoize-prop.ts

@@ -1,30 +0,0 @@
-/**
- * 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/mnemonist.ts

@@ -1,9 +0,0 @@
-export {
-  BiMap,
-  DefaultMap,
-  DefaultWeakMap,
-  LinkedList,
-  MultiMap,
-  Queue,
-  Stack,
-} from 'mnemonist/patch'

package/src/utils/object-hash.ts

@@ -1,14 +0,0 @@
-import objecthash from 'object-hash'
-import { isNonNullish } from 'remeda'
-import { invariant } from '../utils/invariant'
-
-export function objectHash(value: any): string {
-  invariant(
-    typeof value === 'object' && isNonNullish(value),
-    'objectHash: value must be an object',
-  )
-  return objecthash(value, {
-    ignoreUnknown: true,
-    respectType: false,
-  })
-}

package/src/utils/promises.ts

@@ -1,24 +0,0 @@
-import { randomInteger } from 'remeda'
-
-const DELAY = 'LIKEC4_DELAY'
-
-export function delay(): Promise<string>
-export function delay(ms: number): Promise<string>
-export function delay(randomFrom: number, randomTo: number): Promise<string>
-export function delay(...args: number[]): Promise<string> {
-  let ms = 100
-  if (args.length === 2) {
-    ms = randomInteger(args[0]!, args[1]!)
-  } else if (args.length === 1) {
-    ms = args[0]!
-  }
-  return new Promise(resolve => {
-    setTimeout(() => {
-      resolve(DELAY)
-    }, ms ?? 100)
-  })
-}
-
-export function promiseNextTick(): Promise<void> {
-  return Promise.resolve().then(() => void 0)
-}

package/src/utils/relations.ts

@@ -1,36 +0,0 @@
-import { commonAncestor, compareFqnHierarchically } from './fqn'
-
-export type RelationshipLike = {
-  source: {
-    model: string
-  }
-  target: {
-    model: string
-  }
-}
-
-export type RelationPredicate = (rel: RelationshipLike) => boolean
-
-/**
- * Compares two relations hierarchically.
- * From the most general (implicit) to the most specific.
- */
-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
-  }
-  if (!parentA && parentB) {
-    return -1
-  }
-  const compareParents = parentA && parentB ? compareFqnHierarchically(parentA, parentB) : 0
-  if (compareParents !== 0) {
-    return compareParents
-  }
-  const compareSource = compareFqnHierarchically(a.source.model, b.source.model)
-  if (compareSource !== 0) {
-    return compareSource
-  }
-  return compareFqnHierarchically(a.target.model, b.target.model)
-}

package/src/utils/set.ts

@@ -1,83 +0,0 @@
-import {
-  intersection as _intersection,
-  symmetricDifference as _symmetricDifference,
-} from 'mnemonist/patch'
-
-import { hasAtLeast } from 'remeda'
-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 = hasAtLeast(sets, 2) ? _intersection(...sets) : 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

@@ -1,16 +0,0 @@
-import { invariant } from '../utils/invariant'
-
-/**
- * @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)
-}