@likec4/core 1.18.0 → 1.19.1

package/src/model/connection/ops.ts

@@ -0,0 +1,274 @@
+import { map, pipe, prop } from 'remeda'
+import { isString } from '../../utils'
+import {
+  type IterableContainer,
+  type ReorderedArray,
+  isAncestor,
+  isDescendantOf,
+  sortNaturalByFqn,
+} from '../../utils/fqn'
+import type { Connection } from './Connection'
+
+/**
+ * Check if connection is nested inside another connection
+ * (i.e. between descendants)
+ */
+export function isNestedConnection<T extends { id: string }>(
+  parent: WithSourceTarget<NoInfer<T>>,
+): (nested: WithSourceTarget<T>) => boolean
+export function isNestedConnection<T extends { id: string }>(
+  nested: WithSourceTarget<T>,
+  parent: WithSourceTarget<T>,
+): boolean
+export function isNestedConnection<T extends { id: string }>(
+  nested: WithSourceTarget<T>,
+  parent?: WithSourceTarget<T>,
+) {
+  if (!parent) {
+    const p = nested
+    return (n: WithSourceTarget<T>) => isNestedConnection(n, p)
+  }
+  const isSameSource = nested.source === parent.source
+  const isSameTarget = nested.target === parent.target
+  if (isSameSource && isSameTarget) {
+    return false
+  }
+  const isSourceNested = isAncestor(parent.source.id, nested.source.id)
+  const isTargetNested = isAncestor(parent.target.id, nested.target.id)
+  return (
+    (isSourceNested && isTargetNested)
+    || (isSameSource && isTargetNested)
+    || (isSameTarget && isSourceNested)
+  )
+}
+
+type ConnectionElemId = Connection<{ readonly id: string }, any>
+
+export function findDeepestNestedConnection<C extends ConnectionElemId>(
+  connections: ReadonlyArray<C>,
+  connection: C,
+): C | null {
+  let deepest = connection
+  for (const c of connections) {
+    if (isNestedConnection(c, deepest)) {
+      deepest = c
+    }
+  }
+  return deepest !== connection ? deepest : null
+}
+
+export function sortDeepestFirst<C extends ConnectionElemId>(
+  connections: ReadonlyArray<C>,
+): C[] {
+  const sorted = [] as C[]
+  const unsorted = connections.slice()
+  let next
+  while (next = unsorted.shift()) {
+    let deepest
+    while (deepest = findDeepestNestedConnection(unsorted, next)) {
+      const index = unsorted.indexOf(deepest)
+      sorted.push(unsorted.splice(index, 1)[0]!)
+    }
+    sorted.push(next)
+  }
+  return sorted
+}
+
+/**
+ * To make {@link sortConnectionsByBoundaryHierarchy} work correctly we add '.' to boundary
+ * Othwerwise connection without boundary will be considered same level as connection with top-level boundary
+ */
+export const boundaryHierarchy = <C extends WithBoundary>(conn: C) => conn.boundary?.id ? `.${conn.boundary.id}` : ''
+
+type WithBoundary = {
+  boundary: null | { id: string }
+}
+export function sortConnectionsByBoundaryHierarchy(
+  sort?: 'asc' | 'desc',
+): <T extends WithBoundary, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>
+export function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(
+  array: A,
+  sort?: 'asc' | 'desc',
+): ReorderedArray<A>
+export function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(
+  connections?: A | 'asc' | 'desc',
+  sort?: 'asc' | 'desc',
+) {
+  if (!connections || isString(connections)) {
+    const dir = connections ?? 'asc'
+    return (arr: A) => _sortByBoundary(arr, dir)
+  }
+  return _sortByBoundary(connections, sort ?? 'asc')
+}
+
+function _sortByBoundary<C extends WithBoundary>(
+  connections: ReadonlyArray<C>,
+  order: 'asc' | 'desc',
+): C[] {
+  return pipe(
+    connections,
+    map(conn => ({
+      id: boundaryHierarchy(conn),
+      conn,
+    })),
+    sortNaturalByFqn(order),
+    map(prop('conn')),
+  )
+}
+
+/**
+ * Find connections that includes given connection (i.e between it's ancestors)
+ */
+export function findAscendingConnections<C extends ConnectionElemId>(
+  connections: ReadonlyArray<C>,
+  connection: C,
+): Array<C> {
+  return connections.filter(c => isNestedConnection(connection, c))
+}
+
+/**
+ * Find connections that includes given connection (i.e between it's descendants)
+ */
+export function findDescendantConnections<C extends ConnectionElemId>(
+  connections: ReadonlyArray<C>,
+  connection: C,
+): Array<C> {
+  return connections.filter(isNestedConnection(connection))
+}
+
+export function mergeConnections<C extends Connection>(
+  connections: ReadonlyArray<C>,
+): C[] {
+  const map = new Map<C['id'], C>()
+  for (const conn of connections) {
+    const existing = map.get(conn.id)
+    if (existing) {
+      map.set(conn.id, conn.mergeWith(existing) as C)
+    } else {
+      map.set(conn.id, conn)
+    }
+  }
+  return [...map.values()]
+}
+
+/**
+ * Excludes the values existing in `other` array.
+ * The output maintains the same order as the input.
+ */
+export function differenceConnections<C extends Connection>(
+  source: Iterable<C>,
+  exclude: Iterable<C>,
+): C[] {
+  const minus = new Map([...exclude].map(c => [c.id, c]))
+  return [...source].reduce((acc, c) => {
+    const other = minus.get(c.id)
+    if (!other) {
+      acc.push(c)
+      return acc
+    }
+    const updated = c.difference(other) as C
+    if (updated.nonEmpty()) {
+      acc.push(updated)
+    }
+    return acc
+  }, [] as C[])
+}
+
+type WithSourceTarget<T = unknown> = {
+  source: T
+  target: T
+}
+
+export function hasSameSourceTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
+export function hasSameSourceTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
+export function hasSameSourceTarget(a: WithSourceTarget, b?: WithSourceTarget) {
+  if (b) {
+    return a.source === b.source && a.target === b.target
+  }
+  return (b: WithSourceTarget) => a.source === b.source && a.target === b.target
+}
+
+export function hasSameSource<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
+export function hasSameSource<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
+export function hasSameSource(a: WithSourceTarget, b?: WithSourceTarget) {
+  if (b) {
+    return a.source === b.source
+  }
+  return (b: WithSourceTarget) => a.source === b.source
+}
+
+export function hasSameTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
+export function hasSameTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
+export function hasSameTarget(a: WithSourceTarget, b?: WithSourceTarget) {
+  if (b) {
+    return a.target === b.target
+  }
+  return (b: WithSourceTarget) => a.target === b.target
+}
+
+type WithId<T> = {
+  id: T
+}
+export function isOutgoing<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
+export function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
+export function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
+  if (!source) {
+    const _source = a as WithId<T>
+    return (b: WithSourceTarget<WithId<T>>) => isOutgoing(b, _source)
+  }
+  const at = a as WithSourceTarget<WithId<T>>
+  return isDescendantOf(at.source, source) && !isDescendantOf(at.target, source)
+}
+
+export function isIncoming<T extends string>(target: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
+export function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>>, target: WithId<T>): boolean
+export function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, target?: WithId<T>) {
+  if (!target) {
+    const _target = a as WithId<T>
+    return (b: WithSourceTarget<WithId<T>>) => isIncoming(b, _target)
+  }
+  const at = a as WithSourceTarget<WithId<T>>
+  return isDescendantOf(at.target, target) && !isDescendantOf(at.source, target)
+}
+
+export function isAnyInOut<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
+export function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
+export function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
+  if (!source) {
+    const _source = a as WithId<T>
+    return (b: WithSourceTarget<WithId<T>>) => isAnyInOut(b, _source)
+  }
+  const at = a as WithSourceTarget<WithId<T>>
+  return isDescendantOf(at.source, source) !== isDescendantOf(at.target, source)
+}
+
+export function isInside<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
+export function isInside<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
+export function isInside<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
+  if (!source) {
+    const _source = a as WithId<T>
+    return (b: WithSourceTarget<WithId<T>>) => isInside(b, _source)
+  }
+  const at = a as WithSourceTarget<WithId<T>>
+  return isDescendantOf(at.source, source) && isDescendantOf(at.target, source)
+}
+
+// export function isIncoming<T>(target: NoInfer<T>): (a: WithSourceTarget<T>) => boolean
+// export function isIncoming<T>(a: WithSourceTarget<T>, target: T): boolean
+// export function isIncoming<T = unknown>(a: WithSourceTarget<T> | T, target?: T) {
+//   if (target) {
+//     return (a as WithSourceTarget<T>).target === target
+//   }
+//   const _target = a as T
+//   return (b: WithSourceTarget) => b.target === _target
+// }
+
+// export function isAnyInOut<T>(source: NoInfer<T>): (a: WithSourceTarget<T>) => boolean
+// export function isAnyInOut<T>(a: WithSourceTarget<T>, source: T): boolean
+// export function isAnyInOut<T = unknown>(a: WithSourceTarget<T> | T, source?: T) {
+//   if (source) {
+//     return hasSameSource(a as WithSourceTarget<T>, source) || hasSameTarget(a as WithSourceTarget<T>, source)
+//   }
+//   const _source = a as T
+//   return (b: WithSourceTarget) => hasSameSource(b, _source) || hasSameTarget(b, _source)
+// }

package/src/model/guards.ts

@@ -0,0 +1,9 @@
+import type { DeployedInstanceModel, DeploymentElementModel, DeploymentNodeModel } from './DeploymentElementModel'
+
+export function isDeploymentNode(model: DeploymentElementModel): model is DeploymentNodeModel {
+  return model.isDeploymentNode()
+}
+
+export function isDeployedInstance(model: DeploymentElementModel): model is DeployedInstanceModel {
+  return model.isInstance()
+}

package/src/model/index.ts

@@ -1,5 +1,47 @@
-export { LikeC4DeploymentModel } from './DeploymentModel'
+export { ElementModel } from './ElementModel'
 export { LikeC4Model } from './LikeC4Model'
-export type * from './LikeC4Model'
-export type { Aux as LikeC4ModelAux } from './types'
+export { RelationshipModel } from './RelationModel'
+
+export {
+  Connection,
+  ConnectionModel,
+  deployment as deploymentConnection,
+  DeploymentConnectionModel,
+  differenceConnections,
+  findAscendingConnections,
+  findDeepestNestedConnection,
+  findDescendantConnections,
+  hasSameSource,
+  hasSameSourceTarget,
+  hasSameTarget,
+  isAnyInOut,
+  isIncoming,
+  isNestedConnection,
+  isOutgoing,
+  mergeConnections,
+  model as modelConnection,
+  sortConnectionsByBoundaryHierarchy,
+  sortDeepestFirst,
+} from './connection'
+
+export {
+  DeployedInstanceModel,
+  type DeploymentElementModel,
+  DeploymentNodeModel,
+  DeploymentRelationModel,
+} from './DeploymentElementModel'
+export { LikeC4DeploymentModel } from './DeploymentModel'
+
+export { EdgeModel } from './view/EdgeModel'
 export { LikeC4ViewModel } from './view/LikeC4ViewModel'
+export { NodeModel } from './view/NodeModel'
+
+export type {
+  AnyAux,
+  Aux,
+} from './types'
+
+export {
+  isDeployedInstance,
+  isDeploymentNode,
+} from './guards'

package/src/model/types.ts

@@ -1,16 +1,18 @@
-import type { IsLiteral, LiteralUnion, Simplify } from 'type-fest'
+import type { IsStringLiteral, LiteralUnion, Simplify } from 'type-fest'
 import type {
-  AnyLikeC4Model,
   ComputedView,
   DiagramView,
   EdgeId,
   Fqn,
+  GenericLikeC4Model,
+  IteratorLike,
   KeysOf,
   LayoutedLikeC4Model,
+  LikeC4ModelDump,
   NodeId,
-  ParsedLikeC4ModelDump,
+  ParsedLikeC4Model,
   RelationId,
-  ViewId
+  ViewId,
 } from '../types'
 import { isString } from '../utils/guards'
 
@@ -24,8 +26,6 @@ export function getId<Id extends string>(element: string | { id: Id }): Id {
   return isString(element) ? element as Id : element.id
 }
 
-export type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>
-
 type WithId<Id> = { id: Id }
 
 type WithViews<Id extends string, ViewType> = { views: Record<Id, ViewType> }
@@ -36,22 +36,25 @@ type WithViews<Id extends string, ViewType> = { views: Record<Id, ViewType> }
 export interface Aux<
   Element extends string,
   Deployment extends string,
-  Views extends string,
-  ViewType
+  View extends string,
+  ViewType,
 > {
-  // Model: Model
+  Element: Element
+  Deployment: Deployment
+  View: View
 
+  // Wrapped Element
   // If Fqn is just a string, then we use generic Fqn to have better hints in the editor
-  Fqn: IsLiteral<Element> extends true ? Fqn<Element> : Fqn
-  Element: Element
+  Fqn: IsStringLiteral<Element> extends true ? Fqn<Element> : Fqn
   ElementOrFqn: Element | WithId<this['Fqn']>
 
-  DeploymentFqn: IsLiteral<Deployment> extends true ? Fqn<Deployment> : Fqn
-  Deployment: Deployment
+  // Wrapped Deployment
+  DeploymentFqn: IsStringLiteral<Deployment> extends true ? Fqn<Deployment> : Fqn
   DeploymentOrFqn: Deployment | WithId<this['DeploymentFqn']>
 
-  ViewId: IsLiteral<Views> extends true ? ViewId<Views> : ViewId
-  ViewIdLiteral: Views
+  // Wrapped View
+  ViewId: IsStringLiteral<View> extends true ? ViewId<View> : ViewId
+
   ViewType: ViewType
 
   RelationId: RelationId
@@ -63,7 +66,7 @@ export interface Aux<
   NodeOrId: LiteralUnion<this['NodeIdLiteral'], string> | WithId<this['NodeId']>
   EdgeOrId: LiteralUnion<this['EdgeIdLiteral'], string> | WithId<this['EdgeId']>
 
-  Model: Simplify<Omit<AnyLikeC4Model, 'views'> & WithViews<this['ViewId'], ViewType>>
+  Model: Simplify<Omit<GenericLikeC4Model, 'views'> & WithViews<this['ViewId'], ViewType>>
 }
 
 export type AnyAux = Aux<
@@ -73,8 +76,22 @@ export type AnyAux = Aux<
   any
 >
 
+export namespace Strict {
+  export type Fqn<A extends AnyAux> = A['Element']
+  export type Deployment<A extends AnyAux> = A['Deployment']
+  export type ViewId<A extends AnyAux> = A['View']
+}
+
 export namespace Aux {
-  export type FromModel<M> = M extends AnyLikeC4Model ? Aux<
+  export type FromParsed<M> = M extends ParsedLikeC4Model ? Aux<
+      KeysOf<M['elements']>,
+      KeysOf<M['deployments']['elements']>,
+      KeysOf<M['views']>,
+      ComputedView<ViewId<KeysOf<M['views']>>, string>
+    >
+    : never
+
+  export type FromModel<M> = M extends GenericLikeC4Model ? Aux<
       KeysOf<M['elements']>,
       KeysOf<M['deployments']['elements']>,
       KeysOf<M['views']>,
@@ -83,7 +100,7 @@ export namespace Aux {
     >
     : never
 
-  export type FromDump<M> = M extends ParsedLikeC4ModelDump ? Aux<
+  export type FromDump<M> = M extends LikeC4ModelDump ? Aux<
       KeysOf<M['elements']>,
       KeysOf<M['deployments']['elements']>,
       KeysOf<M['views']>,

package/src/model/view/EdgeModel.ts

@@ -4,16 +4,17 @@ import {
   type ComputedDynamicView,
   type ComputedView,
   type DiagramView,
-  extractStep,
-  isStepEdgeId,
+  type IteratorLike,
   type RelationId as C4RelationID,
   type StepEdgeId,
-  type Tag as C4Tag
+  type Tag as C4Tag,
+  extractStep,
+  isStepEdgeId,
 } from '../../types'
 import type { DeploymentRelationModel } from '../DeploymentElementModel'
 import type { LikeC4Model } from '../LikeC4Model'
 import type { RelationshipModel } from '../RelationModel'
-import type { AnyAux, IteratorLike } from '../types'
+import type { AnyAux } from '../types'
 import type { LikeC4ViewModel } from './LikeC4ViewModel'
 import type { NodeModel } from './NodeModel'
 
@@ -24,7 +25,7 @@ export class EdgeModel<M extends AnyAux, V extends ComputedView | DiagramView =
     public readonly view: LikeC4ViewModel<M, V>,
     public readonly $edge: V['edges'][number],
     public readonly source: NodeModel<M, V>,
-    public readonly target: NodeModel<M, V>
+    public readonly target: NodeModel<M, V>,
   ) {
   }
 
@@ -75,7 +76,6 @@ export class EdgeModel<M extends AnyAux, V extends ComputedView | DiagramView =
     for (const id of this.$edge.relations) {
       // if type is provided, then we need to filter relationships
       if (type) {
-        yield this.view.$model.relationship(id, type)
         const rel = this.view.$model.findRelationship(id, type)
         if (rel) {
           yield rel

package/src/model/view/LikeC4ViewModel.ts

@@ -1,5 +1,6 @@
 import { sort } from 'remeda'
 import { nonNullable } from '../../errors'
+import type { IteratorLike } from '../../types'
 import type { Link, Tag } from '../../types/element'
 import {
   type ComputedDeploymentView,
@@ -8,19 +9,19 @@ import {
   type ComputedView,
   type DiagramView,
   type EdgeId as C4EdgeId,
+  type LikeC4View,
+  type NodeId as C4NodeId,
   isDeploymentView,
   isDynamicView,
   isElementView,
   isScopedElementView,
-  type LikeC4View,
-  type NodeId as C4NodeId
 } from '../../types/view'
 import { compareByFqnHierarchically, getOrCreate } from '../../utils'
 import type { ElementModel } from '../ElementModel'
 import type { LikeC4Model } from '../LikeC4Model'
-import { type AnyAux, getId, type IteratorLike } from '../types'
-import { EdgeModel, type EdgesIterator } from './EdgeModel'
-import { NodeModel, type NodesIterator } from './NodeModel'
+import { type AnyAux, getId } from '../types'
+import { type EdgesIterator, EdgeModel } from './EdgeModel'
+import { type NodesIterator, NodeModel } from './NodeModel'
 
 export type ViewsIterator<M extends AnyAux> = IteratorLike<LikeC4ViewModel<M>>
 
@@ -35,10 +36,10 @@ export class LikeC4ViewModel<M extends AnyAux, V extends ComputedView | DiagramV
 
   constructor(
     public readonly $model: LikeC4Model<M>,
-    public readonly $view: V
+    public readonly $view: V,
   ) {
     for (const node of sort($view.nodes, compareByFqnHierarchically)) {
-      const el = new NodeModel(this, node)
+      const el = new NodeModel(this, Object.freeze(node))
       this.#nodes.set(node.id, el)
       if (!node.parent) {
         this.#rootnodes.add(el)
@@ -55,7 +56,12 @@ export class LikeC4ViewModel<M extends AnyAux, V extends ComputedView | DiagramV
     }
 
     for (const edge of $view.edges) {
-      const edgeModel = new EdgeModel(this, edge, this.node(edge.source), this.node(edge.target))
+      const edgeModel = new EdgeModel(
+        this,
+        Object.freeze(edge),
+        this.node(edge.source),
+        this.node(edge.target),
+      )
       for (const tag of edgeModel.tags) {
         getOrCreate(this.#allTags, tag, () => new Set()).add(edgeModel)
       }

package/src/model/view/NodeModel.ts

@@ -1,18 +1,19 @@
 import {
   type Color as C4Color,
-  ComputedNode,
   type ComputedView,
   type DeploymentNodeKind,
   type DiagramView,
-  ElementKind,
   type ElementShape as C4ElementShape,
+  type IteratorLike,
   type Link,
   type NodeId,
-  type Tag as C4Tag
+  type Tag as C4Tag,
+  ComputedNode,
+  ElementKind,
 } from '../../types'
 import type { DeployedInstanceModel, DeploymentElementModel } from '../DeploymentElementModel'
 import type { ElementModel } from '../ElementModel'
-import type { AnyAux, IncomingFilter, IteratorLike, OutgoingFilter } from '../types'
+import type { AnyAux, IncomingFilter, OutgoingFilter } from '../types'
 import type { EdgesIterator } from './EdgeModel'
 import type { LikeC4ViewModel } from './LikeC4ViewModel'
 
@@ -50,7 +51,7 @@ export namespace NodeModel {
 export class NodeModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
   constructor(
     public readonly $view: LikeC4ViewModel<M, V>,
-    public readonly $node: V['nodes'][number]
+    public readonly $node: V['nodes'][number],
   ) {
   }
 

package/src/types/_common.ts

@@ -1,4 +1,4 @@
-import type { Tagged } from 'type-fest'
+import type { Simplify, Tagged, UnionToIntersection } from 'type-fest'
 
 export type NonEmptyArray<T> = [T, ...T[]]
 
@@ -16,3 +16,55 @@ export interface XYPoint {
 }
 
 export type KeysOf<T> = keyof T extends infer K extends string ? K : never
+
+type AllNever<Expressions> = UnionToIntersection<
+  {
+    [Name in keyof Expressions]: {
+      -readonly [Key in keyof Expressions[Name]]?: never
+    }
+  }[keyof Expressions]
+>
+
+/**
+ * @example
+ *   type Variant1 = {
+ *     a: string
+ *   }
+ *   type Variant2 = {
+ *     b: number
+ *   }
+ *
+ *   type Variants = ExclusiveUnion<{
+ *     Variant1: Variant1,
+ *     Variant2: Variant2
+ *   }>
+ *
+ *   Fail here
+ *   const variant1: Variants = {
+ *      a: 'one',
+ *      b: 1
+ *   }
+ */
+
+export type ExclusiveUnion<Expressions> = Expressions extends object ? {
+    [Name in keyof Expressions]: Simplify<Omit<AllNever<Expressions>, keyof Expressions[Name]> & Expressions[Name]>
+  }[keyof Expressions]
+  : Expressions
+
+/**
+ * Copy from https://github.com/remeda/remeda/blob/main/src/internal/types/NTuple.ts
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+export type NTuple<
+  T,
+  N extends number,
+  Result extends Array<unknown> = [],
+> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>
+
+export type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>
+
+export type Predicate<T> = (x: T) => boolean