@likec4/core 1.19.1 → 1.20.0

package/src/types/expression-v2.ts

@@ -2,6 +2,7 @@ import { invariant } from '../errors'
 import type { ExclusiveUnion } from './_common'
 import type { DeploymentRef as DeploymentModelRef, PredicateSelector } from './deployments'
 import type { Fqn } from './element'
+import type { WhereOperator } from './operators'
 
 export namespace FqnRef {
   /**
@@ -131,6 +132,15 @@ export namespace RelationExpr {
   export const isInOut = (expr: ExpressionV2): expr is InOut => {
     return 'inout' in expr
   }
+  export type Where<D = Fqn, M = Fqn> = {
+    where: {
+      expr: ExpressionV2<D, M>
+      condition: WhereOperator<string, string>
+    }
+  }
+  export const isWhere = (expr: ExpressionV2): expr is Where => {
+    return 'where' in expr
+  }
 }
 
 export type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
@@ -138,6 +148,7 @@ export type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Incoming: RelationExpr.Incoming<D, M>
   Outgoing: RelationExpr.Outgoing<D, M>
   InOut: RelationExpr.InOut<D, M>
+  Where: RelationExpr.Where<D, M>
 }>
 
 /**
@@ -154,6 +165,7 @@ export type ExpressionV2<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Incoming: RelationExpr.Incoming<D, M>
   Outgoing: RelationExpr.Outgoing<D, M>
   InOut: RelationExpr.InOut<D, M>
+  RelationPredicateOrWhere: RelationExpr.Where<D, M>
 }>
 
 export namespace ExpressionV2 {

package/src/types/index.ts

@@ -121,6 +121,7 @@ export type {
   Filterable,
   KindEqual,
   NotOperator,
+  OperatorPredicate,
   OrOperator,
   TagEqual,
   WhereOperator,

package/src/types/operators.ts

@@ -16,6 +16,7 @@ type AllNever = {
   or?: never
   tag?: never
   kind?: never
+  participant?: never
 }
 
 export type TagEqual<Tag> = Omit<AllNever, 'tag'> & {
@@ -32,6 +33,17 @@ export const isKindEqual = <Kind>(operator: WhereOperator<any, Kind>): operator
   return 'kind' in operator
 }
 
+export type Participant = 'source' | 'target'
+export type ParticipantOperator<Tag, Kind> = Omit<AllNever, 'participant'> & {
+  participant: Participant
+  operator: KindEqual<Kind> | TagEqual<Tag>
+}
+export const isParticipantOperator = <Tag, Kind>(
+  operator: WhereOperator<Tag, any>,
+): operator is ParticipantOperator<Tag, Kind> => {
+  return 'participant' in operator
+}
+
 export type NotOperator<Tag, Kind> = Omit<AllNever, 'not'> & {
   not: WhereOperator<Tag, Kind>
 }
@@ -56,25 +68,34 @@ export const isOrOperator = <Tag, Kind>(operator: WhereOperator<Tag, Kind>): ope
 export type WhereOperator<Tag, Kind> =
   | TagEqual<Tag>
   | KindEqual<Kind>
+  | ParticipantOperator<Tag, Kind>
   | NotOperator<Tag, Kind>
   | AndOperator<Tag, Kind>
   | OrOperator<Tag, Kind>
 
 export type Filterable<
-  FTag extends string = string,
-  FKind extends string = string
+  FTag extends string | null = string | null,
+  FKind extends string | null = string | null,
 > = {
   tags?: readonly FTag[] | null
   kind?: FKind
+  source?: Filterable<FTag, FKind>
+  target?: Filterable<FTag, FKind>
 }
 
-type OperatorPredicate<V extends Filterable> = (value: V) => boolean
+export type OperatorPredicate<V extends Filterable> = (value: V) => boolean
 
 export function whereOperatorAsPredicate<
-  FTag extends string = string,
-  FKind extends string = string
->(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>> {
+  FTag extends string | null = string | null,
+  FKind extends string | null = string | null,
+>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable> {
   switch (true) {
+    case isParticipantOperator(operator): {
+      const participant = operator.participant
+      const participantPredicate = whereOperatorAsPredicate(operator.operator)
+
+      return participantIs(participant, participantPredicate)
+    }
     case isTagEqual(operator): {
       if ('eq' in operator.tag) {
         const tag = operator.tag.eq
@@ -115,3 +136,22 @@ export function whereOperatorAsPredicate<
       nonexhaustive(operator)
   }
 }
+
+function participantIs<FTag extends string | null, FKind extends string | null>(
+  participant: Participant,
+  predicate: OperatorPredicate<Filterable<FTag, FKind>>,
+): OperatorPredicate<Filterable<FTag, FKind>> {
+  return (value) => {
+    if (!value.source || !value.target) {
+      return false
+    }
+    switch (participant) {
+      case 'source': {
+        return predicate(value.source)
+      }
+      case 'target': {
+        return predicate(value.target)
+      }
+    }
+  }
+}

package/src/types/view.ts

@@ -3,12 +3,12 @@ import type { Tagged } from 'type-fest'
 import type { IconUrl, NonEmptyArray, Point, XYPoint } from './_common'
 import {
   type BorderStyle,
-  ElementKind,
   type ElementShape,
   type ElementStyle,
   type Fqn,
   type Link,
   type Tag,
+  ElementKind,
 } from './element'
 import type { ElementExpression, ElementPredicateExpression, Expression } from './expression'
 import type { ExpressionV2, FqnExpr } from './expression-v2'
@@ -335,7 +335,7 @@ export interface ComputedNode {
    */
   icon?: IconUrl
   style: ElementStyle
-  navigateTo?: ViewId
+  navigateTo?: ViewId | null
   level: number
   // For compound nodes, the max depth of nested nodes
   depth?: number

package/src/utils/index.ts

@@ -1,8 +1,3 @@
-import DefaultMap from 'mnemonist/default-map'
-import LinkedList from 'mnemonist/linked-list'
-
-export { DefaultMap, LinkedList }
-
 export {
   commonHead,
 } from './common-head'

package/src/utils/iterable/unique.ts

@@ -8,13 +8,7 @@ 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
+  return iterable ? _iunique(iterable) : _iunique
 }
 
 function* _iunique<T>(iterable: Iterable<T>): IteratorLike<T> {

package/dist/model/index.js

@@ -1 +0,0 @@
-export { C as Connection, f as ConnectionModel, F as DeployedInstanceModel, D as DeploymentConnectionModel, H as DeploymentNodeModel, I as DeploymentRelationModel, J as EdgeModel, E as ElementModel, b as LikeC4DeploymentModel, L as LikeC4Model, e as LikeC4ViewModel, N as NodeModel, R as RelationshipModel, g as deploymentConnection, h as differenceConnections, j as findAscendingConnections, k as findDeepestNestedConnection, m as findDescendantConnections, n as hasSameSource, o as hasSameSourceTarget, p as hasSameTarget, q as isAnyInOut, K as isDeployedInstance, M as isDeploymentNode, s as isIncoming, v as isNestedConnection, x as isOutgoing, y as mergeConnections, z as modelConnection, A as sortConnectionsByBoundaryHierarchy, B as sortDeepestFirst } from '../shared/index.DafVOuVd.js';

package/dist/utils/index.js

@@ -1,347 +0,0 @@
-import { T as requireIterator, S as requireForeach, R as getDefaultExportFromCjs, b as t, W as n, f as commonAncestor, h as compareFqnHierarchically } from '../shared/object_hash.CE_oF3I3.js';
-export { D as DefaultMap, e as ancestorsFqn, c as commonHead, g as compareByFqnHierarchically, d as compareNatural, H as difference, I as equalsSet, v as getOrCreate, i as hasAtLeast, j as hierarchyDistance, k as hierarchyLevel, y as ifilter, z as iflat, A as imap, J as intersection, o as isAncestor, q as isDescendantOf, B as isIterable, w as isNonEmptyArray, a as isSameHierarchy, x as isString, C as isome, E as iunique, n as nameFromFqn, N as objectHash, p as parentFqn, s as sortByFqnHierarchically, r as sortNaturalByFqn, u as sortParentsFirst, M as stringHash, K as symmetricDifference, F as toArray, G as toSet, L as union } from '../shared/object_hash.CE_oF3I3.js';
-import { i as invariant } from '../shared/chunk-RAAYCPUM.M-JWF7SS.js';
-
-function o(r,n){let e=Math.ceil(r),t=Math.floor(n);if(t<e)throw new RangeError(`randomInteger: The range [${r.toString()},${n.toString()}] contains no integer`);return Math.floor(Math.random()*(t-e+1)+e)}
-
-/**
- * Mnemonist Linked List
- * ======================
- *
- * Singly linked list implementation. Uses raw JavaScript objects as nodes
- * as benchmarks proved it was the fastest thing to do.
- */
-
-var linkedList$1;
-var hasRequiredLinkedList;
-
-function requireLinkedList () {
-	if (hasRequiredLinkedList) return linkedList$1;
-	hasRequiredLinkedList = 1;
-	var Iterator = requireIterator(),
-	    forEach = requireForeach();
-
-	/**
-	 * Linked List.
-	 *
-	 * @constructor
-	 */
-	function LinkedList() {
-	  this.clear();
-	}
-
-	/**
-	 * Method used to clear the list.
-	 *
-	 * @return {undefined}
-	 */
-	LinkedList.prototype.clear = function() {
-
-	  // Properties
-	  this.head = null;
-	  this.tail = null;
-	  this.size = 0;
-	};
-
-	/**
-	 * Method used to get the first item of the list.
-	 *
-	 * @return {any}
-	 */
-	LinkedList.prototype.first = function() {
-	  return this.head ? this.head.item : undefined;
-	};
-	LinkedList.prototype.peek = LinkedList.prototype.first;
-
-	/**
-	 * Method used to get the last item of the list.
-	 *
-	 * @return {any}
-	 */
-	LinkedList.prototype.last = function() {
-	  return this.tail ? this.tail.item : undefined;
-	};
-
-	/**
-	 * Method used to add an item at the end of the list.
-	 *
-	 * @param  {any}    item - The item to add.
-	 * @return {number}
-	 */
-	LinkedList.prototype.push = function(item) {
-	  var node = {item: item, next: null};
-
-	  if (!this.head) {
-	    this.head = node;
-	    this.tail = node;
-	  }
-	  else {
-	    this.tail.next = node;
-	    this.tail = node;
-	  }
-
-	  this.size++;
-
-	  return this.size;
-	};
-
-	/**
-	 * Method used to add an item at the beginning of the list.
-	 *
-	 * @param  {any}    item - The item to add.
-	 * @return {number}
-	 */
-	LinkedList.prototype.unshift = function(item) {
-	  var node = {item: item, next: null};
-
-	  if (!this.head) {
-	    this.head = node;
-	    this.tail = node;
-	  }
-	  else {
-	    if (!this.head.next)
-	      this.tail = this.head;
-	    node.next = this.head;
-	    this.head = node;
-	  }
-
-	  this.size++;
-
-	  return this.size;
-	};
-
-	/**
-	 * Method used to retrieve & remove the first item of the list.
-	 *
-	 * @return {any}
-	 */
-	LinkedList.prototype.shift = function() {
-	  if (!this.size)
-	    return undefined;
-
-	  var node = this.head;
-
-	  this.head = node.next;
-	  this.size--;
-
-	  return node.item;
-	};
-
-	/**
-	 * Method used to iterate over the list.
-	 *
-	 * @param  {function}  callback - Function to call for each item.
-	 * @param  {object}    scope    - Optional scope.
-	 * @return {undefined}
-	 */
-	LinkedList.prototype.forEach = function(callback, scope) {
-	  if (!this.size)
-	    return;
-
-	  scope = arguments.length > 1 ? scope : this;
-
-	  var n = this.head,
-	      i = 0;
-
-	  while (n) {
-	    callback.call(scope, n.item, i, this);
-	    n = n.next;
-	    i++;
-	  }
-	};
-
-	/**
-	 * Method used to convert the list into an array.
-	 *
-	 * @return {array}
-	 */
-	LinkedList.prototype.toArray = function() {
-	  if (!this.size)
-	    return [];
-
-	  var array = new Array(this.size);
-
-	  for (var i = 0, l = this.size, n = this.head; i < l; i++) {
-	    array[i] = n.item;
-	    n = n.next;
-	  }
-
-	  return array;
-	};
-
-	/**
-	 * Method used to create an iterator over a list's values.
-	 *
-	 * @return {Iterator}
-	 */
-	LinkedList.prototype.values = function() {
-	  var n = this.head;
-
-	  return new Iterator(function() {
-	    if (!n)
-	      return {
-	        done: true
-	      };
-
-	    var value = n.item;
-	    n = n.next;
-
-	    return {
-	      value: value,
-	      done: false
-	    };
-	  });
-	};
-
-	/**
-	 * Method used to create an iterator over a list's entries.
-	 *
-	 * @return {Iterator}
-	 */
-	LinkedList.prototype.entries = function() {
-	  var n = this.head,
-	      i = 0;
-
-	  return new Iterator(function() {
-	    if (!n)
-	      return {
-	        done: true
-	      };
-
-	    var value = n.item;
-	    n = n.next;
-	    i++;
-
-	    return {
-	      value: [i - 1, value],
-	      done: false
-	    };
-	  });
-	};
-
-	/**
-	 * Attaching the #.values method to Symbol.iterator if possible.
-	 */
-	if (typeof Symbol !== 'undefined')
-	  LinkedList.prototype[Symbol.iterator] = LinkedList.prototype.values;
-
-	/**
-	 * Convenience known methods.
-	 */
-	LinkedList.prototype.toString = function() {
-	  return this.toArray().join(',');
-	};
-
-	LinkedList.prototype.toJSON = function() {
-	  return this.toArray();
-	};
-
-	LinkedList.prototype.inspect = function() {
-	  var array = this.toArray();
-
-	  // Trick so that node displays the name of the constructor
-	  Object.defineProperty(array, 'constructor', {
-	    value: LinkedList,
-	    enumerable: false
-	  });
-
-	  return array;
-	};
-
-	if (typeof Symbol !== 'undefined')
-	  LinkedList.prototype[Symbol.for('nodejs.util.inspect.custom')] = LinkedList.prototype.inspect;
-
-	/**
-	 * Static @.from function taking an arbitrary iterable & converting it into
-	 * a list.
-	 *
-	 * @param  {Iterable} iterable   - Target iterable.
-	 * @return {LinkedList}
-	 */
-	LinkedList.from = function(iterable) {
-	  var list = new LinkedList();
-
-	  forEach(iterable, function(value) {
-	    list.push(value);
-	  });
-
-	  return list;
-	};
-
-	/**
-	 * Exporting.
-	 */
-	linkedList$1 = LinkedList;
-	return linkedList$1;
-}
-
-var linkedListExports = requireLinkedList();
-const linkedList = /*@__PURE__*/getDefaultExportFromCjs(linkedListExports);
-
-function ifind(arg1, arg2) {
-  const pred = arg2 ?? arg1;
-  invariant(t(pred));
-  function _find(iter) {
-    for (const value of iter) {
-      if (pred(value)) {
-        return value;
-      }
-    }
-    return;
-  }
-  if (!arg2) {
-    return _find;
-  }
-  return _find(arg1);
-}
-
-function ireduce(arg1, arg2, arg3) {
-  const reducer = n(arg3) ? arg2 : arg1;
-  const initialValue = arg3 ?? arg2;
-  invariant(t(reducer));
-  function _reduce(iter) {
-    let acc = initialValue;
-    for (const value of iter) {
-      acc = reducer(acc, value);
-    }
-    return acc;
-  }
-  return n(arg3) ? _reduce(arg1) : _reduce;
-}
-
-const DELAY = "LIKEC4_DELAY";
-function delay(...args) {
-  let ms = 100;
-  if (args.length === 2) {
-    ms = o(args[0], args[1]);
-  } else if (args.length === 1) {
-    ms = args[0];
-  }
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(DELAY);
-    }, ms ?? 100);
-  });
-}
-
-const compareRelations = (a, b) => {
-  const parentA = commonAncestor(a.source, a.target);
-  const parentB = commonAncestor(b.source, b.target);
-  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, b.source);
-  if (compareSource !== 0) {
-    return compareSource;
-  }
-  return compareFqnHierarchically(a.target, b.target);
-};
-
-export { linkedList as LinkedList, commonAncestor, compareFqnHierarchically, compareRelations, delay, ifind, ireduce };