@likec4/core 1.19.1 → 1.20.0

package/dist/{index.js → index.mjs}

@@ -1,9 +1,514 @@
-export { i as invariant, a as nonNullable, n as nonexhaustive } from './shared/chunk-RAAYCPUM.M-JWF7SS.js';
-export { A as AsFqn, B as BorderStyles, Q as ComputedNode, S as ComputedView, N as DefaultArrowType, e as DefaultElementShape, O as DefaultLineStyle, P as DefaultRelationshipColor, d as DefaultThemeColor, D as DeploymentElement, T as DiagramNode, E as ElementKind, g as ElementShapes, f as Expr, C as ExpressionV2, F as FqnExpr, G as FqnRef, R as RelationExpr, U as extractStep, V as getBBoxCenter, W as getParallelStepsPrefix, H as isAndOperator, X as isAutoLayoutDirection, h as isCustomElement, j as isCustomRelationExpr, Y as isDeploymentView, Z as isDynamicView, _ as isDynamicViewParallelSteps, k as isElement, l as isElementKindExpr, b as isElementPredicateExpr, m as isElementRef, p as isElementTagExpr, a as isElementView, q as isElementWhere, r as isExpandedElementExpr, i as isExtendsElementView, t as isInOut, s as isIncoming, I as isKindEqual, J as isNotOperator, K as isOrOperator, u as isOutgoing, v as isRelation, w as isRelationExpression, x as isRelationPredicateExpr, y as isRelationWhere, c as isScopedElementView, $ as isStepEdgeId, L as isTagEqual, a0 as isViewRuleAutoLayout, a1 as isViewRuleGlobalPredicateRef, a2 as isViewRuleGlobalStyle, a3 as isViewRuleGroup, a4 as isViewRulePredicate, a5 as isViewRuleStyle, z as isWildcard, a6 as stepEdgeId, M as whereOperatorAsPredicate } from './shared/view.CyZrG8BJ.js';
-export { b as LikeC4DeploymentModel, L as LikeC4Model, e as LikeC4ViewModel } from './shared/index.DafVOuVd.js';
-export { isThemeColor } from './types/index.js';
-export { D as DefaultMap, e as ancestorsFqn, f as commonAncestor, c as commonHead, g as compareByFqnHierarchically, h as compareFqnHierarchically, 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';
-export { LinkedList, compareRelations, delay, ifind, ireduce } from './utils/index.js';
+import { b as requireIterator, e as requireForeach } from './shared/core.CqCTxzMY.mjs';
+export { D as DefaultMap, f as LikeC4DeploymentModel, L as LikeC4Model, g as LikeC4ViewModel, S as Stack, c as computeView, a as computeViews, u as unsafeComputeView } from './shared/core.CqCTxzMY.mjs';
+import { g as getDefaultExportFromCjs } from './shared/core.BxvDITEI.mjs';
+export { h as ancestorsFqn, j as commonAncestor, e as commonHead, k as compareByFqnHierarchically, o as compareFqnHierarchically, f as compareNatural, I as difference, J as equalsSet, y as getOrCreate, a as hasAtLeast, q as hierarchyDistance, r as hierarchyLevel, B as ifilter, i as ifind, C as iflat, D as imap, K as intersection, s as isAncestor, u as isDescendantOf, E as isIterable, z as isNonEmptyArray, c as isSameHierarchy, A as isString, F as isome, G as iunique, n as nameFromFqn, O as objectHash, p as parentFqn, v as sortByFqnHierarchically, w as sortNaturalByFqn, x as sortParentsFirst, N as stringHash, L as symmetricDifference, H as toArray, t as toSet, M as union } from './shared/core.BxvDITEI.mjs';
+export { i as invariant, a as nonNullable, n as nonexhaustive } from './shared/core.M-JWF7SS.mjs';
+export { A as AsFqn, B as BorderStyles, Q as ComputedNode, S as ComputedView, N as DefaultArrowType, e as DefaultElementShape, O as DefaultLineStyle, P as DefaultRelationshipColor, d as DefaultThemeColor, D as DeploymentElement, T as DiagramNode, E as ElementKind, g as ElementShapes, f as Expr, C as ExpressionV2, F as FqnExpr, G as FqnRef, R as RelationExpr, U as extractStep, V as getBBoxCenter, W as getParallelStepsPrefix, H as isAndOperator, X as isAutoLayoutDirection, h as isCustomElement, j as isCustomRelationExpr, Y as isDeploymentView, Z as isDynamicView, _ as isDynamicViewParallelSteps, k as isElement, l as isElementKindExpr, b as isElementPredicateExpr, m as isElementRef, p as isElementTagExpr, a as isElementView, q as isElementWhere, r as isExpandedElementExpr, i as isExtendsElementView, t as isInOut, s as isIncoming, I as isKindEqual, J as isNotOperator, K as isOrOperator, u as isOutgoing, v as isRelation, w as isRelationExpression, x as isRelationPredicateExpr, y as isRelationWhere, c as isScopedElementView, $ as isStepEdgeId, L as isTagEqual, a0 as isViewRuleAutoLayout, a1 as isViewRuleGlobalPredicateRef, a2 as isViewRuleGlobalStyle, a3 as isViewRuleGroup, a4 as isViewRulePredicate, a5 as isViewRuleStyle, z as isWildcard, a6 as stepEdgeId, M as whereOperatorAsPredicate } from './shared/core.DunIMHRf.mjs';
+export { c as computeRelationshipsView } from './shared/core.m3rCQAv6.mjs';
+export { isThemeColor } from './types/index.mjs';
+export { compareRelations, delay, ireduce } from './utils/index.mjs';
+
+/**
+ * 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);
+
+/**
+ * Mnemonist Queue
+ * ================
+ *
+ * Queue implementation based on the ideas of Queue.js that seems to beat
+ * a LinkedList one in performance.
+ */
+
+var queue$1;
+var hasRequiredQueue;
+
+function requireQueue () {
+	if (hasRequiredQueue) return queue$1;
+	hasRequiredQueue = 1;
+	var Iterator = requireIterator(),
+	    forEach = requireForeach();
+
+	/**
+	 * Queue
+	 *
+	 * @constructor
+	 */
+	function Queue() {
+	  this.clear();
+	}
+
+	/**
+	 * Method used to clear the queue.
+	 *
+	 * @return {undefined}
+	 */
+	Queue.prototype.clear = function() {
+
+	  // Properties
+	  this.items = [];
+	  this.offset = 0;
+	  this.size = 0;
+	};
+
+	/**
+	 * Method used to add an item to the queue.
+	 *
+	 * @param  {any}    item - Item to enqueue.
+	 * @return {number}
+	 */
+	Queue.prototype.enqueue = function(item) {
+
+	  this.items.push(item);
+	  return ++this.size;
+	};
+
+	/**
+	 * Method used to retrieve & remove the first item of the queue.
+	 *
+	 * @return {any}
+	 */
+	Queue.prototype.dequeue = function() {
+	  if (!this.size)
+	    return;
+
+	  var item = this.items[this.offset];
+
+	  if (++this.offset * 2 >= this.items.length) {
+	    this.items = this.items.slice(this.offset);
+	    this.offset = 0;
+	  }
+
+	  this.size--;
+
+	  return item;
+	};
+
+	/**
+	 * Method used to retrieve the first item of the queue.
+	 *
+	 * @return {any}
+	 */
+	Queue.prototype.peek = function() {
+	  if (!this.size)
+	    return;
+
+	  return this.items[this.offset];
+	};
+
+	/**
+	 * Method used to iterate over the queue.
+	 *
+	 * @param  {function}  callback - Function to call for each item.
+	 * @param  {object}    scope    - Optional scope.
+	 * @return {undefined}
+	 */
+	Queue.prototype.forEach = function(callback, scope) {
+	  scope = arguments.length > 1 ? scope : this;
+
+	  for (var i = this.offset, j = 0, l = this.items.length; i < l; i++, j++)
+	    callback.call(scope, this.items[i], j, this);
+	};
+
+	/*
+	 * Method used to convert the queue to a JavaScript array.
+	 *
+	 * @return {array}
+	 */
+	Queue.prototype.toArray = function() {
+	  return this.items.slice(this.offset);
+	};
+
+	/**
+	 * Method used to create an iterator over a queue's values.
+	 *
+	 * @return {Iterator}
+	 */
+	Queue.prototype.values = function() {
+	  var items = this.items,
+	      i = this.offset;
+
+	  return new Iterator(function() {
+	    if (i >= items.length)
+	      return {
+	        done: true
+	      };
+
+	    var value = items[i];
+	    i++;
+
+	    return {
+	      value: value,
+	      done: false
+	    };
+	  });
+	};
+
+	/**
+	 * Method used to create an iterator over a queue's entries.
+	 *
+	 * @return {Iterator}
+	 */
+	Queue.prototype.entries = function() {
+	  var items = this.items,
+	      i = this.offset,
+	      j = 0;
+
+	  return new Iterator(function() {
+	    if (i >= items.length)
+	      return {
+	        done: true
+	      };
+
+	    var value = items[i];
+	    i++;
+
+	    return {
+	      value: [j++, value],
+	      done: false
+	    };
+	  });
+	};
+
+	/**
+	 * Attaching the #.values method to Symbol.iterator if possible.
+	 */
+	if (typeof Symbol !== 'undefined')
+	  Queue.prototype[Symbol.iterator] = Queue.prototype.values;
+
+	/**
+	 * Convenience known methods.
+	 */
+	Queue.prototype.toString = function() {
+	  return this.toArray().join(',');
+	};
+
+	Queue.prototype.toJSON = function() {
+	  return this.toArray();
+	};
+
+	Queue.prototype.inspect = function() {
+	  var array = this.toArray();
+
+	  // Trick so that node displays the name of the constructor
+	  Object.defineProperty(array, 'constructor', {
+	    value: Queue,
+	    enumerable: false
+	  });
+
+	  return array;
+	};
+
+	if (typeof Symbol !== 'undefined')
+	  Queue.prototype[Symbol.for('nodejs.util.inspect.custom')] = Queue.prototype.inspect;
+
+	/**
+	 * Static @.from function taking an arbitrary iterable & converting it into
+	 * a queue.
+	 *
+	 * @param  {Iterable} iterable   - Target iterable.
+	 * @return {Queue}
+	 */
+	Queue.from = function(iterable) {
+	  var queue = new Queue();
+
+	  forEach(iterable, function(value) {
+	    queue.enqueue(value);
+	  });
+
+	  return queue;
+	};
+
+	/**
+	 * Static @.of function taking an arbitrary number of arguments & converting it
+	 * into a queue.
+	 *
+	 * @param  {...any} args
+	 * @return {Queue}
+	 */
+	Queue.of = function() {
+	  return Queue.from(arguments);
+	};
+
+	/**
+	 * Exporting.
+	 */
+	queue$1 = Queue;
+	return queue$1;
+}
+
+var queueExports = requireQueue();
+const queue = /*@__PURE__*/getDefaultExportFromCjs(queueExports);
 
 const { min: min$4, max: max$4 } = Math;
 
@@ -3669,4 +4174,4 @@ function computeColorValues(color) {
   }
 }
 
-export { ElementColors, RelationshipColors, computeColorValues, defaultTheme };
+export { ElementColors, linkedList as LinkedList, queue as Queue, RelationshipColors, computeColorValues, defaultTheme };

package/dist/model/index.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+const model_index = require('../shared/core.BGus30EM.cjs');
+
+
+
+Object.defineProperty(exports, "Connection", {
+	enumerable: true,
+	get: function () { return model_index.Connection; }
+});
+exports.ConnectionModel = model_index.ConnectionModel;
+exports.DeployedInstanceModel = model_index.DeployedInstanceModel;
+exports.DeploymentConnectionModel = model_index.DeploymentConnectionModel;
+exports.DeploymentNodeModel = model_index.DeploymentNodeModel;
+exports.DeploymentRelationModel = model_index.DeploymentRelationModel;
+exports.EdgeModel = model_index.EdgeModel;
+exports.ElementModel = model_index.ElementModel;
+exports.LikeC4DeploymentModel = model_index.LikeC4DeploymentModel;
+exports.LikeC4Model = model_index.LikeC4Model;
+exports.LikeC4ViewModel = model_index.LikeC4ViewModel;
+exports.NodeModel = model_index.NodeModel;
+exports.RelationshipModel = model_index.RelationshipModel;
+exports.deploymentConnection = model_index.find;
+exports.differenceConnections = model_index.differenceConnections;
+exports.findAscendingConnections = model_index.findAscendingConnections;
+exports.findDeepestNestedConnection = model_index.findDeepestNestedConnection;
+exports.findDescendantConnections = model_index.findDescendantConnections;
+exports.hasSameSource = model_index.hasSameSource;
+exports.hasSameSourceTarget = model_index.hasSameSourceTarget;
+exports.hasSameTarget = model_index.hasSameTarget;
+exports.isAnyInOut = model_index.isAnyInOut;
+exports.isDeployedInstance = model_index.isDeployedInstance;
+exports.isDeploymentNode = model_index.isDeploymentNode;
+exports.isIncoming = model_index.isIncoming;
+exports.isNestedConnection = model_index.isNestedConnection;
+exports.isOutgoing = model_index.isOutgoing;
+exports.mergeConnections = model_index.mergeConnections;
+exports.modelConnection = model_index.find$1;
+exports.sortConnectionsByBoundaryHierarchy = model_index.sortConnectionsByBoundaryHierarchy;
+exports.sortDeepestFirst = model_index.sortDeepestFirst;