@metadev/daga 1.2.0 → 1.3.1

package/fesm2022/metadev-daga.mjs

@@ -9,33 +9,109 @@ import * as i3 from '@metadev/lux';
 import { LuxModule } from '@metadev/lux';
 import { Subject, combineLatest, delay, map } from 'rxjs';
 
+/**
+ * An enumeration of the possible sides of a rectangle and directions parallel to the axes of coordinates.
+ * @public
+ */
 var Side;
 (function (Side) {
+    /**
+     * Bottom side or direction.
+     * @public
+     */
     Side["Bottom"] = "bottom";
+    /**
+     * Left side or direction.
+     * @public
+     */
     Side["Left"] = "left";
+    /**
+     * Right side or direction.
+     * @public
+     */
     Side["Right"] = "right";
+    /**
+     * Top side or direction.
+     * @public
+     */
     Side["Top"] = "top";
 })(Side || (Side = {}));
+/**
+ * An enumeration of the possible corners of a rectangle.
+ * @public
+ */
 var Corner;
 (function (Corner) {
+    /**
+     * Bottom left corner.
+     * @public
+     */
     Corner["BottomLeft"] = "bottom-left";
+    /**
+     * Bottom right corner.
+     * @public
+     */
     Corner["BottomRight"] = "bottom-right";
+    /**
+     * Top left corner.
+     * @public
+     */
     Corner["TopLeft"] = "top-left";
+    /**
+     * Top right corner.
+     * @public
+     */
     Corner["TopRight"] = "top-right";
 })(Corner || (Corner = {}));
-var VerticalAlign;
-(function (VerticalAlign) {
-    VerticalAlign["Top"] = "top";
-    VerticalAlign["Center"] = "center";
-    VerticalAlign["Bottom"] = "bottom";
-})(VerticalAlign || (VerticalAlign = {}));
+/**
+ * An enumeration of the possible horizontal alignments within a horizontal range of coordinates.
+ * @public
+ */
 var HorizontalAlign;
 (function (HorizontalAlign) {
+    /**
+     * Start of an horizontal range of coordinates.
+     * @public
+     */
     HorizontalAlign["Left"] = "left";
+    /**
+     * Middle of an horizontal range of coordinates.
+     * @public
+     */
     HorizontalAlign["Center"] = "center";
+    /**
+     * End of an horizontal range of coordinates.
+     * @public
+     */
     HorizontalAlign["Right"] = "right";
 })(HorizontalAlign || (HorizontalAlign = {}));
+/**
+ * An enumeration of the possible vertical alignments within a vertical range of coordinates.
+ * @public
+ */
+var VerticalAlign;
+(function (VerticalAlign) {
+    /**
+     * Start of a vertical range of coordinates.
+     * @public
+     */
+    VerticalAlign["Top"] = "top";
+    /**
+     * Middle of a vertical range of coordinates.
+     * @public
+     */
+    VerticalAlign["Center"] = "center";
+    /**
+     * End of a vertical range of coordinates.
+     * @public
+     */
+    VerticalAlign["Bottom"] = "bottom";
+})(VerticalAlign || (VerticalAlign = {}));
 
+/**
+ * Button used to collapse components that implement it.
+ * @private
+ */
 class CollapseButtonComponent {
     constructor() {
         this.collapsed = false;
@@ -139,41 +215,72 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                 type: Input
             }] } });
 
+/**
+ * A two dimensional array of elements of the given class that can extend infinitely in any direction, both positive and negative.
+ * @private
+ */
 class Grid {
     constructor() {
         this.grid = [[undefined]];
         this.offsetX = 0;
         this.offsetY = 0;
     }
+    /**
+     * Get the minimum x coordinate among the elements in the grid.
+     */
     minX() {
         return -this.offsetX;
     }
+    /**
+     * Get the maximum x coordinate among the elements in the grid.
+     */
     maxX() {
         return this.width() - 1 - this.offsetX;
     }
+    /**
+     * Get the minimum y coordinate among the elements in the grid.
+     */
     minY() {
         return -this.offsetY;
     }
+    /**
+     * Get the maximum y coordinate among the elements in the grid.
+     */
     maxY() {
         return this.height() - 1 - this.offsetY;
     }
+    /**
+     * Get the total extension of the grid along the x axis.
+     */
     width() {
         return this.grid[0].length;
     }
+    /**
+     * Get the total extension of the grid along the y axis.
+     */
     height() {
         return this.grid.length;
     }
+    /**
+     * Add a new column at the start of the x axis.
+     */
     addColumnLeft() {
         for (const row of this.grid) {
             row.splice(0, 0, undefined);
         }
         this.offsetX = this.offsetX + 1;
     }
+    /**
+     * Add a new column at the end of the x axis.
+     */
     addColumnRight() {
         for (const row of this.grid) {
             row.push(undefined);
         }
     }
+    /**
+     * Add a new row at the start of the y axis.
+     */
     addRowTop() {
         const newRow = [];
         for (let i = 0; i < this.grid[0].length; ++i) {
@@ -182,6 +289,9 @@ class Grid {
         this.grid.splice(0, 0, newRow);
         this.offsetY = this.offsetY + 1;
     }
+    /**
+     * Add a new row at the end of the y axis.
+     */
     addRowBottom() {
         const newRow = [];
         for (let i = 0; i < this.grid[0].length; ++i) {
@@ -189,12 +299,18 @@ class Grid {
         }
         this.grid.push(newRow);
     }
+    /**
+     * Get the element at the given coordinates or undefined if there is no element at the given coordinates.
+     */
     get(coords) {
         if (this.grid[coords[1] + this.offsetY]) {
             return this.grid[coords[1] + this.offsetY][coords[0] + this.offsetX];
         }
         return undefined;
     }
+    /**
+     * Set the element at the given coordinates to the given element.
+     */
     set(coords, value) {
         while (coords[0] < -this.offsetX) {
             this.addColumnLeft();
@@ -210,6 +326,9 @@ class Grid {
         }
         this.grid[coords[1] + this.offsetY][coords[0] + this.offsetX] = value;
     }
+    /**
+     * Get the closest coordinates to the given coordinates that are not set to an element.
+     */
     getClosestEmptyCoordinate(coords) {
         if (this.get(coords) === undefined) {
             return coords;
@@ -236,6 +355,13 @@ class Grid {
     }
 }
 
+/**
+ * Removes the given element from the array if it exists within the array.
+ * @private
+ * @param arr An array.
+ * @param obj An element to remove from the array.
+ * @returns The given array without the given element removed if it was found; otherwise the array without modifications.
+ */
 const removeIfExists = (arr, obj) => {
     const index = arr.indexOf(obj);
     if (index >= 0) {
@@ -243,6 +369,13 @@ const removeIfExists = (arr, obj) => {
     }
     return arr;
 };
+/**
+ * Adds the given element to the array if it doesn't exist within the array.
+ * @private
+ * @param arr An array.
+ * @param obj An element to add to the array.
+ * @returns The given array with the given element added it was not found; otherwise the array without modifications.
+ */
 const addIfNotExists = (arr, obj) => {
     if (!arr.includes(obj)) {
         arr.push(obj);
@@ -252,6 +385,7 @@ const addIfNotExists = (arr, obj) => {
 
 /**
  * A layout which places adjacent nodes close by, placing nodes in order according to depth first search.
+ * @public
  */
 class AdjacencyLayout {
     apply(model) {
@@ -298,6 +432,7 @@ const arrangeNode = (node, nodeArrangement, coords, nodesToBeArranged) => {
 
 /**
  * A layout which places adjacent nodes close by, placing nodes in order according to breadth first search.
+ * @public
  */
 class BreadthAdjacencyLayout {
     apply(model) {
@@ -358,8 +493,8 @@ class BreadthAdjacencyLayout {
 }
 
 /**
- * A layout which arranges the nodes by a breadth first search system,
- * according to their distance to the first node in the list.
+ * A layout which arranges the nodes by a breadth first search system according to their distance to the first node in the list.
+ * @public
  */
 class BreadthLayout {
     apply(model) {
@@ -420,9 +555,23 @@ class BreadthLayout {
     }
 }
 
+/**
+ * Round the coordinates of the given point to the nearest whole number.
+ * @public
+ * @param point A point.
+ * @returns A new point with whole coordinates.
+ */
 const roundPoint = (point) => {
     return [Math.round(point[0]), Math.round(point[1])];
 };
+/**
+ * Checks if the given coordinate is in the range given by an starting coordinate and an ending coordinate.
+ * @public
+ * @param coordinate A coordinate to check its presence in the range.
+ * @param start A coordinate determining one of the extremes in the range.
+ * @param end A coordinate determine one of the extremes in the range.
+ * @returns `true` if the given coordinate is in the given range; `false` otherwise.
+ */
 const between = (coordinate, start, end) => {
     if (start < end) {
         return start <= coordinate && coordinate <= end;
@@ -431,18 +580,44 @@ const between = (coordinate, start, end) => {
         return end <= coordinate && coordinate <= start;
     }
 };
+/**
+ * Moves the given coordinate according to the given changes in coordinates.
+ * @public
+ * @param oldCoordinate A coordinate.
+ * @param oldCoordinates A range of coordinates.
+ * @param newCoordinates A range of coordinates.
+ * @returns A new coordinate.
+ */
 const translateCoordinate = (oldCoordinate, oldCoordinates, newCoordinates) => {
     return (((oldCoordinate - oldCoordinates[0]) /
         (oldCoordinates[1] - oldCoordinates[0])) *
         (newCoordinates[1] - newCoordinates[0]) +
         newCoordinates[0]);
 };
+/**
+ * Moves the coordinates of the given point according to the given changes in coordinates.
+ * @public
+ * @param oldPoint A point.
+ * @param oldCoordsX A range of coordinates along the x axis.
+ * @param oldCoordsY A range of coordinates along the y axis.
+ * @param newCoordsX A range of coordinates along the x axis.
+ * @param newCoordsY A range of coordinates along the y axis.
+ * @returns A new point.
+ */
 const translatePoint = (oldPoint, oldCoordsX, oldCoordsY, newCoordsX, newCoordsY) => {
     return [
         translateCoordinate(oldPoint[0], oldCoordsX, newCoordsX),
         translateCoordinate(oldPoint[1], oldCoordsY, newCoordsY)
     ];
 };
+/**
+ * Calculates the result of moving the given point by the given distance in the given direction.
+ * @public
+ * @param point A point.
+ * @param direction A direction.
+ * @param distance A distance.
+ * @returns A new point which differs from the given point by the given distance in the given direction.
+ */
 const movePoint = (point, direction, distance) => {
     switch (direction) {
         case Side.Right:
@@ -455,12 +630,33 @@ const movePoint = (point, direction, distance) => {
             return [point[0], point[1] - distance];
     }
 };
+/**
+ * Checks whether two given points are the same point, that is, they have the same coordinates and are not NaN.
+ * @public
+ * @param point1 A point.
+ * @param point2 A point.
+ * @returns `true` if the two points have the same coordinates; `false` otherwise.
+ */
 const equals$1 = (point1, point2) => {
     return point1[0] === point2[0] && point1[1] === point2[1];
 };
+/**
+ * Calculates the euclidean distance between two points.
+ * @public
+ * @param point1 A point.
+ * @param point2 A point.
+ * @returns The euclidean distance between the given points.
+ */
 const distanceBetweenPoints = (point1, point2) => {
     return ((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2) ** 0.5;
 };
+/**
+ * Checks whether the given point is inside the given line.
+ * @public
+ * @param line A line.
+ * @param point A point.
+ * @returns `true` if the point is contained within the line; `false` otherwise.
+ */
 const lineContainsPoint = (line, point) => {
     const alphaX = (point[0] - line[0][0]) / (line[1][0] - line[0][0]);
     if (alphaX < 0 || 1 < alphaX) {
@@ -469,10 +665,24 @@ const lineContainsPoint = (line, point) => {
     const alphaY = (point[1] - line[0][1]) / (line[1][1] - line[0][1]);
     return alphaX === alphaY;
 };
+/**
+ * Checks whether the given point is inside the given rectaingle.
+ * @public
+ * @param rectangle A rectangle.
+ * @param point A point.
+ * @returns `true` if the point is contained within the rectangle; `false` otherwise.
+ */
 const rectangleContainsPoint = (rectangle, point) => {
     return (between(point[0], rectangle[0][0], rectangle[1][0]) &&
         between(point[1], rectangle[0][1], rectangle[1][1]));
 };
+/**
+ * Checks whether the two given lines share at least one point.
+ * @public
+ * @param line1 A line.
+ * @param line2 A line.
+ * @returns `true` if the lines intersect; `false` otherwise.
+ */
 const linesIntersect = (line1, line2) => {
     // if both lines are a point, they intersect if they are the same point
     if (equals$1(line1[0], line1[1]) && equals$1(line2[0], line2[1])) {
@@ -503,6 +713,13 @@ const linesIntersect = (line1, line2) => {
     const p3 = dy0 * (line1[1][0] - line2[1][0]) - dx0 * (line1[1][1] - line2[1][1]);
     return p0 * p1 <= 0 && p2 * p3 <= 0;
 };
+/**
+ * Checks whether the two given lines share at least one point and have the same slope.
+ * @public
+ * @param line1 A line.
+ * @param line2 A line.
+ * @returns `true` if the lines overlap; `false` otherwise.
+ */
 const linesOverlap = (line1, line2) => {
     // if both lines are a point, they overlap if they are the same point
     if (equals$1(line1[0], line1[1]) && equals$1(line2[0], line2[1])) {
@@ -522,10 +739,21 @@ const linesOverlap = (line1, line2) => {
         lineContainsPoint(line2, line1[0])) &&
         (lineContainsPoint(line1, line2[1]) || lineContainsPoint(line2, line1[1])));
 };
+/**
+ * Checks whether the given line shares at least one point with the given rectangle.
+ * @public
+ * @param line A line.
+ * @param rectangle A rectangle.
+ * @returns `true` if the line intersects with the rectangle; `false` otherwise.
+ */
 const lineIntersectsRectangle = (line, rectangle) => {
+    // first corner of the rectangle
     const point1 = rectangle[0];
+    // second corner of the rectangle
     const point2 = [rectangle[0][0], rectangle[1][1]];
+    // third corner of the rectangle
     const point3 = rectangle[1];
+    // fourth corner of the rectangle
     const point4 = [rectangle[1][0], rectangle[0][1]];
     return (linesIntersect(line, [point1, point2]) ||
         linesIntersect(line, [point2, point3]) ||
@@ -535,6 +763,7 @@ const lineIntersectsRectangle = (line, rectangle) => {
 
 /**
  * A layout which attracts connected nodes and repels unconnected nodes.
+ * @public
  */
 class ForceLayout {
     apply(model) {
@@ -670,6 +899,7 @@ class ForceLayout {
 
 /**
  * A layout which arranges all the nodes in a horizontal line.
+ * @public
  */
 class HorizontalLayout {
     apply(model) {
@@ -691,6 +921,7 @@ class HorizontalLayout {
 
 /**
  * A layout which arranges the nodes by their priority first.
+ * @public
  */
 class PriorityLayout {
     apply(model) {
@@ -798,6 +1029,7 @@ class PriorityLayout {
 
 /**
  * A layout which arranges all the nodes in a vertical line.
+ * @public
  */
 class VerticalLayout {
     apply(model) {
@@ -817,6 +1049,9 @@ class VerticalLayout {
     }
 }
 
+/**
+ * Mapping of available layout algorithms.
+ */
 const layouts = {
     adjacency: new AdjacencyLayout(),
     breadth: new BreadthLayout(),
@@ -828,7 +1063,8 @@ const layouts = {
 };
 
 /**
- * User events
+ * User events.
+ * @private
  */
 var Events;
 (function (Events) {
@@ -843,7 +1079,8 @@ var Events;
     Events["MouseOver"] = "mouseover";
 })(Events || (Events = {}));
 /**
- * Keys in keyboard events
+ * Keys in keyboard events.
+ * @private
  */
 var Keys;
 (function (Keys) {
@@ -867,7 +1104,8 @@ var Keys;
     Keys["Tab"] = "Tab";
 })(Keys || (Keys = {}));
 /**
- * Types of events used by D3's drag functionality
+ * Types of events used by D3's drag functionality.
+ * @private
  */
 var DragEvents;
 (function (DragEvents) {
@@ -876,7 +1114,8 @@ var DragEvents;
     DragEvents["End"] = "end";
 })(DragEvents || (DragEvents = {}));
 /**
- * Types of events used by D3's zoom functionality
+ * Types of events used by D3's zoom functionality.
+ * @private
  */
 var ZoomEvents;
 (function (ZoomEvents) {
@@ -885,20 +1124,64 @@ var ZoomEvents;
     ZoomEvents["End"] = "end";
 })(ZoomEvents || (ZoomEvents = {}));
 
+/**
+ * An enumeration of the possible shapes of a line.
+ * @public
+ */
 var LineShape;
 (function (LineShape) {
+    /**
+     * A line that goes between its points taking the shortest euclidean distance.
+     * @public
+     */
     LineShape["Straight"] = "straight";
+    /**
+     * A line that goes between its points using bezier splines.
+     * @public
+     */
     LineShape["Bezier"] = "bezier";
+    /**
+     * A line that goes between its points moving parallel to the axes of coordinates.
+     * @public
+     */
     LineShape["Square"] = "square";
 })(LineShape || (LineShape = {}));
+/**
+ * An enumeration of the possible styles of a line.
+ * @public
+ */
 var LineStyle;
 (function (LineStyle) {
+    /**
+     * A solid uninterrupted line.
+     * @public
+     */
     LineStyle["Solid"] = "solid";
+    /**
+     * A dashed line with little separation between the dashes.
+     * @public
+     */
     LineStyle["Dashed"] = "dashed";
+    /**
+     * A dashed line with wide gaps between the dashes.
+     * @public
+     */
     LineStyle["GappedDashes"] = "gapped-dashes";
+    /**
+     * A dotted line.
+     * @public
+     */
     LineStyle["Dotted"] = "dotted";
 })(LineStyle || (LineStyle = {}));
+/**
+ * The default minimum distance before turn used by the linePath function.
+ * @private
+ */
 const MINIMUM_DISTANCE_BEFORE_TURN = 20;
+/**
+ * Calculates the path of an SVG line with the given parameters.
+ * @private
+ */
 const linePath = (shape, points, startDirection, endDirection, minimumDistanceBeforeTurn) => {
     if (points.length === 0) {
         return '';
@@ -1236,6 +1519,10 @@ const linePath = (shape, points, startDirection, endDirection, minimumDistanceBe
         return result;
     }
 };
+/**
+ * Calculates the dasharray property of an SVG line corresponding to the given line style and width.
+ * @private
+ */
 const lineStyleDasharray = (style, width) => {
     switch (style) {
         case LineStyle.Dotted:
@@ -1250,19 +1537,67 @@ const lineStyleDasharray = (style, width) => {
     }
 };
 
+/**
+ * An enumeration of possible closed shapes.
+ * @public
+ */
 var ClosedShape;
 (function (ClosedShape) {
+    /**
+     * An ellipse shape.
+     * @public
+     */
     ClosedShape["Ellipse"] = "ellipse";
+    /**
+     * A nonexistent shape.
+     * @public
+     */
     ClosedShape["Empty"] = "empty";
+    /**
+     * A folder-like shape.
+     * @public
+     */
     ClosedShape["Folder"] = "folder";
+    /**
+     * An hexagon shape.
+     * @public
+     */
     ClosedShape["Hexagon"] = "hexagon";
+    /**
+     * An octagon shape.
+     * @public
+     */
     ClosedShape["Octagon"] = "octagon";
+    /**
+     * A shape delimited by curves with a fixed radius, with differences in dimensions supplemented by straight lines.
+     * @public
+     */
     ClosedShape["Pill"] = "pill";
+    /**
+     * A rectangle shape.
+     * @public
+     */
     ClosedShape["Rectangle"] = "rectangle";
+    /**
+     * A rhombus shape.
+     * @public
+     */
     ClosedShape["Rhombus"] = "rhombus";
+    /**
+     * A rectangle shape with rounded corners.
+     * @public
+     */
     ClosedShape["RoundedRectangle"] = "rounded-rectangle";
+    /**
+     * A sticky note-like shape.
+     * @public
+     */
     ClosedShape["StickyNote"] = "sticky-note";
 })(ClosedShape || (ClosedShape = {}));
+/**
+ * Get the SVG path of the correspondign closed shape, starting at the given x and y coordinates, with the given width and height.
+ * @private
+ */
 const generalClosedPath = (shape, x, y, width, height) => {
     switch (shape) {
         case ClosedShape.Ellipse:
@@ -1289,21 +1624,51 @@ const generalClosedPath = (shape, x, y, width, height) => {
             return rectanglePath(x, y, width, height);
     }
 };
+/**
+ * Generates an ellipse SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const ellipsePath = (x, y, width, height) => {
     return `M ${x + width / 2} ${y} A ${width / 2} ${height / 2} 0 0 0 ${x + width / 2} ${y + height} A ${width / 2} ${height / 2} 0 1 0 ${x + width / 2} ${y} Z`;
 };
+/**
+ * Generates an empty SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const emptyPath = () => {
     return 'Z';
 };
+/**
+ * Generates a folder SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const folderPath = (x, y, width, height) => {
     return `M ${x} ${y} L ${x + width / 3} ${y} L ${x + width / 2} ${y + height / 6} L ${x + width} ${y + height / 6} L ${x + width} ${y + height} L ${x} ${y + height} Z`;
 };
+/**
+ * Generates an hexagon SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const hexagonPath = (x, y, width, height) => {
     return `M ${x + width / 4} ${y} L ${x + (3 * width) / 4} ${y} L ${x + width} ${y + height / 2} L ${x + (3 * width) / 4} ${y + height} L ${x + width / 4} ${y + height} L ${x} ${y + height / 2} Z`;
 };
+/**
+ * Generates an octagon SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const octagonPath = (x, y, width, height) => {
     return `M ${x + width / 4} ${y} L ${x + (3 * width) / 4} ${y} L ${x + width} ${y + height / 4} L ${x + width} ${y + (3 * height) / 4} L ${x + (3 * width) / 4} ${y + height} L ${x + width / 4} ${y + height} L ${x} ${y + (3 * height) / 4} L ${x} ${y + height / 4} L ${x + width / 4} ${y} Z`;
 };
+/**
+ * Generates a pill SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const pillPath = (x, y, width, height) => {
     if (height < width) {
         return `M ${x + height / 2} ${y} L ${x + width - height / 2} ${y} A ${height / 2} ${height / 2} 0 0 1 ${x + width} ${y + height / 2} A ${height / 2} ${height / 2} 0 0 1 ${x + width - height / 2} ${y + height} L ${x + height / 2} ${y + height} A ${height / 2} ${height / 2} 0 0 1 ${x} ${y + height / 2} A ${height / 2} ${height / 2} 0 0 1 ${x + height / 2} ${y} Z`;
@@ -1315,19 +1680,43 @@ const pillPath = (x, y, width, height) => {
         return ellipsePath(x, y, width, height);
     }
 };
+/**
+ * Generates a rectangle SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const rectanglePath = (x, y, width, height) => {
     return `M ${x} ${y} L ${x + width} ${y} L ${x + width} ${y + height} L ${x} ${y + height} Z`;
 };
+/**
+ * Generates a rhombus SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const rhombusPath = (x, y, width, height) => {
     return `M ${x + width / 2} ${y} L ${x + width} ${y + height / 2} L ${x + width / 2} ${y + height} L ${x} ${y + height / 2} Z`;
 };
+/**
+ * Generates a rounded rectangle SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const roundedRectanglePath = (x, y, width, height) => {
     return `M ${x + width / 4} ${y} L ${x + (3 * width) / 4} ${y} A ${width / 4} ${height / 4} 0 0 1 ${x + width} ${y + height / 4} L ${x + width} ${y + (3 * height) / 4} A ${width / 4} ${height / 4} 0 0 1 ${x + (3 * width) / 4} ${y + height} L ${x + width / 4} ${y + height} A ${width / 4} ${height / 4} 0 0 1 ${x} ${y + (3 * height) / 4} L ${x} ${y + height / 4} A ${width / 4} ${height / 4} 0 0 1 ${x + width / 4} ${y} Z`;
 };
+/**
+ * Generates a sticky note SVG path.
+ * @see ClosedShape
+ * @private
+ */
 const stickyNotePath = (x, y, width, height) => {
     return `M ${x} ${y} L ${x + (3 * width) / 4} ${y} L ${x + (3 * width) / 4} ${y + height / 4} L ${x + (3 * width) / 4} ${y} L ${x + width} ${y + height / 4} L ${x + (3 * width) / 4} ${y + height / 4} L ${x + width} ${y + height / 4} L ${x + width} ${y + height} L ${x} ${y + height} Z`;
 };
 
+/**
+ * A queue of recent actions taken by the user that can be undone and redone.
+ * @private
+ */
 class ActionQueue {
     constructor(maximum) {
         this.maximum = maximum;
@@ -1336,6 +1725,7 @@ class ActionQueue {
     }
     /**
      * Adds an action to the history.
+     * @private
      */
     add(action) {
         if (this.index < this.history.length) {
@@ -1352,6 +1742,7 @@ class ActionQueue {
     }
     /**
      * Undoes the last action in the history, not counting undone actions.
+     * @private
      */
     undo() {
         if (this.index > 0) {
@@ -1361,6 +1752,7 @@ class ActionQueue {
     }
     /**
      * Redoes the last undone action in the history.
+     * @private
      */
     redo() {
         if (this.index < this.history.length) {
@@ -1369,6 +1761,10 @@ class ActionQueue {
         }
     }
 }
+/**
+ * Enum listing the actions that can be taken by the user.
+ * @private
+ */
 var DiagramActions;
 (function (DiagramActions) {
     DiagramActions["AddConnectionAction"] = "add-connection";
@@ -1380,6 +1776,11 @@ var DiagramActions;
     DiagramActions["StretchSectionAction"] = "stretch-section";
     DiagramActions["UpdateValuesAction"] = "update-values";
 })(DiagramActions || (DiagramActions = {}));
+/**
+ * Action which consists of adding a node.
+ * @see DiagramNode
+ * @private
+ */
 class AddNodeAction {
     constructor(canvas, type, coords, label, values, id) {
         this.canvas = canvas;
@@ -1416,6 +1817,11 @@ class AddNodeAction {
         this.labelId = node.label?.id;
     }
 }
+/**
+ * Action which consists of moving a node.
+ * @see DiagramNode
+ * @private
+ */
 class MoveNodeAction {
     constructor(canvas, nodeId, from, to) {
         this.canvas = canvas;
@@ -1430,6 +1836,11 @@ class MoveNodeAction {
         this.canvas.model.nodes.get(this.nodeId)?.move(this.to);
     }
 }
+/**
+ * Action which consists of changing the dimensions of a node in a given direction.
+ * @see DiagramNode
+ * @private
+ */
 class StretchNodeAction {
     constructor(canvas, nodeId, direction, from, to) {
         this.canvas = canvas;
@@ -1449,6 +1860,11 @@ class StretchNodeAction {
             ?.stretch(this.direction, this.to - this.from);
     }
 }
+/**
+ * Action which consists of changing the dimensions of a section in a given direction.
+ * @see DiagramSection
+ * @private
+ */
 class StretchSectionAction {
     constructor(canvas, sectionId, direction, from, to) {
         this.canvas = canvas;
@@ -1472,6 +1888,11 @@ class StretchSectionAction {
         }
     }
 }
+/**
+ * Action which consists of adding a connection.
+ * @see DiagramConnection
+ * @private
+ */
 class AddConnectionAction {
     constructor(canvas, type, startId, endId, id) {
         this.canvas = canvas;
@@ -1495,6 +1916,11 @@ class AddConnectionAction {
         }
     }
 }
+/**
+ * Action which consists of editing the text of a field.
+ * @see DiagramField
+ * @private
+ */
 class EditFieldAction {
     constructor(canvas, fieldId, from, to) {
         this.canvas = canvas;
@@ -1517,6 +1943,11 @@ class EditFieldAction {
         }
     }
 }
+/**
+ * Action which consists of editing the values of a value set.
+ * @see ValueSet
+ * @private
+ */
 class UpdateValuesAction {
     constructor(model, id, from, to) {
         this.model = model;
@@ -1539,6 +1970,10 @@ class UpdateValuesAction {
         this.getValueSet()?.setValues(this.to);
     }
 }
+/**
+ * Action which consists of removing elements from a diagram.
+ * @private
+ */
 class RemoveAction {
     constructor(model, nodes, sections, ports, connections, fields) {
         this.nodes = [];
@@ -1590,11 +2025,11 @@ class RemoveAction {
                 addIfNotExists(this.connections, connection);
             }
         }
-        this.nodeIds = this.nodes.map((n) => n._id);
-        this.sectionIds = this.sections.map((s) => s._id);
-        this.portIds = this.ports.map((p) => p._id);
-        this.connectionIds = this.connections.map((c) => c._id);
-        this.fieldIds = this.fields.map((f) => f._id);
+        this.nodeIds = this.nodes.map((n) => n.id);
+        this.sectionIds = this.sections.map((s) => s.id);
+        this.portIds = this.ports.map((p) => p.id);
+        this.connectionIds = this.connections.map((c) => c.id);
+        this.fieldIds = this.fields.map((f) => f.id);
     }
     undo() {
         for (const node of this.nodes) {
@@ -1614,14 +2049,14 @@ class RemoveAction {
         }
         for (const node of this.nodes) {
             if (node.label) {
-                const label = this.model.fields.get(node.label._id);
+                const label = this.model.fields.get(node.label.id);
                 if (label) {
                     node.label = label;
                 }
             }
             const ports = [];
             for (const nodePort of node.ports) {
-                const port = this.model.ports.get(nodePort._id);
+                const port = this.model.ports.get(nodePort.id);
                 if (port) {
                     ports.push(port);
                 }
@@ -1629,7 +2064,7 @@ class RemoveAction {
             node.ports = ports;
             const sections = [];
             for (const nodeSection of node.sections) {
-                const section = this.model.sections.get(nodeSection._id);
+                const section = this.model.sections.get(nodeSection.id);
                 if (section) {
                     sections.push(section);
                 }
@@ -1638,20 +2073,20 @@ class RemoveAction {
         }
         for (const section of this.sections) {
             if (section.node) {
-                const node = this.model.nodes.get(section.node._id);
+                const node = this.model.nodes.get(section.node.id);
                 if (node) {
                     section.node = node;
                 }
             }
             if (section.label) {
-                const label = this.model.fields.get(section.label._id);
+                const label = this.model.fields.get(section.label.id);
                 if (label) {
                     section.label = label;
                 }
             }
             const ports = [];
             for (const sectionPort of section.ports) {
-                const port = this.model.ports.get(sectionPort._id);
+                const port = this.model.ports.get(sectionPort.id);
                 if (port) {
                     ports.push(port);
                 }
@@ -1660,21 +2095,21 @@ class RemoveAction {
         }
         for (const port of this.ports) {
             if (port.rootElement) {
-                const rootElement = this.model.nodes.get(port.rootElement._id) ||
-                    this.model.sections.get(port.rootElement._id);
+                const rootElement = this.model.nodes.get(port.rootElement.id) ||
+                    this.model.sections.get(port.rootElement.id);
                 if (rootElement) {
                     port.rootElement = rootElement;
                 }
             }
             if (port.label) {
-                const label = this.model.fields.get(port.label._id);
+                const label = this.model.fields.get(port.label.id);
                 if (label) {
                     port.label = label;
                 }
             }
             const outgoingConnections = [];
             for (const portOutgoingConnection of port.outgoingConnections) {
-                const connection = this.model.connections.get(portOutgoingConnection._id);
+                const connection = this.model.connections.get(portOutgoingConnection.id);
                 if (connection) {
                     outgoingConnections.push(connection);
                 }
@@ -1682,7 +2117,7 @@ class RemoveAction {
             port.outgoingConnections = outgoingConnections;
             const incomingConnections = [];
             for (const portIncomingConnection of port.incomingConnections) {
-                const connection = this.model.connections.get(portIncomingConnection._id);
+                const connection = this.model.connections.get(portIncomingConnection.id);
                 if (connection) {
                     incomingConnections.push(connection);
                 }
@@ -1691,13 +2126,13 @@ class RemoveAction {
         }
         for (const connection of this.connections) {
             if (connection.start) {
-                const start = this.model.ports.get(connection.start._id);
+                const start = this.model.ports.get(connection.start.id);
                 if (start) {
                     connection.setStart(start);
                 }
             }
             if (connection.end) {
-                const end = this.model.ports.get(connection.end._id);
+                const end = this.model.ports.get(connection.end.id);
                 if (end) {
                     connection.setEnd(end);
                 }
@@ -1705,9 +2140,9 @@ class RemoveAction {
         }
         for (const field of this.fields) {
             if (field.rootElement) {
-                const rootElement = this.model.nodes.get(field.rootElement._id) ||
-                    this.model.sections.get(field.rootElement._id) ||
-                    this.model.ports.get(field.rootElement._id);
+                const rootElement = this.model.nodes.get(field.rootElement.id) ||
+                    this.model.sections.get(field.rootElement.id) ||
+                    this.model.ports.get(field.rootElement.id);
                 if (rootElement) {
                     field.rootElement = rootElement;
                 }
@@ -1811,6 +2246,7 @@ const clone = (obj) => {
 
 /**
  * Represents an object which exists as part of a specific diagram model and has a visual representation in a diagram canvas.
+ * @public
  * @see DiagramModel
  * @see DiagramCanvas
  */
@@ -1818,18 +2254,23 @@ class DiagramElement {
     get id() {
         return this._id;
     }
-    set id(value) {
-        this.select()?.attr('id', value);
-        this._id = value;
-    }
     constructor(model, id) {
+        /**
+         * Whether this diagram element is currently highlighted by the user.
+         * @private
+         */
         this.highlighted = false;
+        /**
+         * Whether this diagram element is currently selected by the user.
+         * @private
+         */
         this.selected = false;
         this.model = model;
         this._id = id;
     }
     /**
      * Obtain the selection of this element.
+     * @private
      */
     select() {
         return this.model.canvas?.selectCanvasView()?.select(`g#${this.id}`);
@@ -1837,6 +2278,7 @@ class DiagramElement {
 }
 /**
  * Represents a collection of diagram entities of a type that exists as part of a diagram model.
+ * @public
  * @see DiagramEntity
  * @see DiagramModel
  */
@@ -1844,21 +2286,25 @@ class DiagramEntitySet {
     constructor() {
         /**
          * The list of entities contained in this set.
+         * @private
          */
         this.entities = [];
         /**
          * A mapping of entity ids to their corresponding entity in this set for quickly fetching entities based on their id.
+         * @private
          */
         this.entityMap = {};
     }
     /**
      * The number of entities of this set.
+     * @public
      */
     get length() {
         return this.entities.length;
     }
     /**
      * Gets all of the entities of this set.
+     * @public
      * @returns An array containing all of the entities of this set.
      */
     all() {
@@ -1867,6 +2313,7 @@ class DiagramEntitySet {
     /**
      * Adds an entity to this set if there are no entities with the same id. Has no effect if there already exists an entity with the same id as the given entity.
      * For creating entities with relationships with other entities, the new() method should be used instead. The add() method adds an entity but doesn't take care of setting that entity's relationships with other entities.
+     * @private
      * @param entity An entity to be added to this set.
      */
     add(entity) {
@@ -1877,6 +2324,7 @@ class DiagramEntitySet {
     }
     /**
      * Removes all the entities in this set.
+     * @public
      */
     clear() {
         // remove each entity individually in case classes that extend this implement their own specific cleanup
@@ -1886,6 +2334,7 @@ class DiagramEntitySet {
     }
     /**
      * Checks if this set contains an entity with the given id.
+     * @public
      * @param id An id.
      * @returns `true` if this set contains an entity with the given id, `false` otherwise.
      */
@@ -1894,6 +2343,7 @@ class DiagramEntitySet {
     }
     /**
      * Gets all of the entities of this set filtered following given criteria.
+     * @public
      * @returns An array containing the entities of this set that meet the given criteria.
      */
     filter() {
@@ -1901,6 +2351,7 @@ class DiagramEntitySet {
     }
     /**
      * Gets an entity of this set matching specific criteria.
+     * @public
      * @returns An entity of this set.
      */
     find() {
@@ -1908,6 +2359,7 @@ class DiagramEntitySet {
     }
     /**
      * Gets an entity from this set.
+     * @public
      * @param id An id.
      * @returns An entity with the given id, or `undefined` if there are no entities with the given id.
      */
@@ -1916,6 +2368,7 @@ class DiagramEntitySet {
     }
     /**
      * Attempts to find and remove an entity with the given id. Has no effect if there are no entities with the given id.
+     * @public
      * @param id An id.
      */
     remove(id) {
@@ -1925,6 +2378,10 @@ class DiagramEntitySet {
             removeIfExists(this.entities, entity);
         }
     }
+    /**
+     * Iterator to iterate over the entities of this set.
+     * @public
+     */
     *[Symbol.iterator]() {
         let counter = 0;
         while (counter < this.entities.length) {
@@ -1934,6 +2391,12 @@ class DiagramEntitySet {
     }
 }
 
+/**
+ * A property which is part of a property set and defines what values a value in a value set can take.
+ * @see PropertySet
+ * @see ValueSet
+ * @private
+ */
 class Property {
     constructor(name, type, defaultValue, basic, editable, rootAttribute) {
         this.name = name;
@@ -1946,6 +2409,11 @@ class Property {
         this.properties = undefined;
     }
 }
+/**
+ * The type that a property can hvae..
+ * @see Property
+ * @private
+ */
 var Type;
 (function (Type) {
     /**
@@ -2001,6 +2469,12 @@ var Type;
      */
     Type["Url"] = "url";
 })(Type || (Type = {}));
+/**
+ * A set of properties based on which a set of values of those properties can be created.
+ * @see Property
+ * @see ValueSet
+ * @private
+ */
 class PropertySet {
     constructor(properties = []) {
         this.propertyList = properties;
@@ -2016,6 +2490,11 @@ class PropertySet {
         return this.propertyList.length > 0;
     }
 }
+/**
+ * A set of values corresponding to a set of properties.
+ * @see PropertySet
+ * @private
+ */
 class ValueSet {
     constructor(propertySet, rootElement) {
         this.displayedProperties = [];
@@ -2207,6 +2686,11 @@ const equals = (a, b) => {
 };
 
 let idTicker$4 = 0;
+/**
+ * Default values of the parameters of a diagram connection.
+ * @see DiagramConnection
+ * @private
+ */
 const DIAGRAM_CONNECTION_TYPE_DEFAULTS = {
     name: '',
     width: 1,
@@ -2221,6 +2705,11 @@ const DIAGRAM_CONNECTION_TYPE_DEFAULTS = {
     selectedColor: '#000000',
     properties: []
 };
+/**
+ * A connection type, which holds properties that connections of this type share in common.
+ * @see ConnectionTypeConfig
+ * @public
+ */
 class DiagramConnectionType {
     constructor(options) {
         const values = {
@@ -2248,7 +2737,16 @@ class DiagramConnectionType {
         return this.endTypes.indexOf(type) >= 0;
     }
 }
+/**
+ * A connection which goes from one port to another.
+ * @see DiagramPort
+ * @public
+ */
 class DiagramConnection extends DiagramElement {
+    /**
+     * Name of this connection. Alias for this connection's middle label.
+     * @public
+     */
     get name() {
         return this.middleLabel;
     }
@@ -2266,11 +2764,35 @@ class DiagramConnection extends DiagramElement {
             } while (model.connections.get(uniqueId) !== undefined);
         }
         super(model, uniqueId);
+        /**
+         * Coordinates of the start point of this connection.
+         * @public
+         */
         this.startCoords = [0, 0];
+        /**
+         * Coordinates of the end point of this connection.
+         * @public
+         */
         this.endCoords = [0, 0];
+        /**
+         * Text at the start of this connection, or `''` if no text.
+         * @public
+         */
         this.startLabel = '';
+        /**
+         * Text at the middle of this connection, or `''` if no text.
+         * @public
+         */
         this.middleLabel = '';
+        /**
+         * Text at the end of this connection, or `''` if no text.
+         * @public
+         */
         this.endLabel = '';
+        /**
+         * Points that this connection passes through.
+         * @public
+         */
         this.points = [];
         this.type = type;
         this.valueSet = new ValueSet(type.propertySet, this);
@@ -2286,24 +2808,36 @@ class DiagramConnection extends DiagramElement {
         }
     }
     setStart(start) {
-        if (this.start !== undefined) {
-            removeIfExists(this.start.outgoingConnections, this);
+        if (this.start !== start) {
+            if (this.start !== undefined) {
+                removeIfExists(this.start.outgoingConnections, this);
+            }
+            this.start = start;
+            if (start !== undefined) {
+                start.outgoingConnections.push(this);
+                this.startDirection = start?.direction;
+                this.startCoords = start?.coords || [0, 0];
+            }
         }
-        this.start = start;
-        if (start !== undefined) {
-            start.outgoingConnections.push(this);
+        else {
             this.startDirection = start?.direction;
             this.startCoords = start?.coords || [0, 0];
         }
         this.updateInView();
     }
     setEnd(end) {
-        if (this.end !== undefined) {
-            removeIfExists(this.end.incomingConnections, this);
+        if (this.end !== end) {
+            if (this.end !== undefined) {
+                removeIfExists(this.end.incomingConnections, this);
+            }
+            this.end = end;
+            if (end !== undefined) {
+                end.incomingConnections.push(this);
+                this.endDirection = end?.direction;
+                this.endCoords = end?.coords || [0, 0];
+            }
         }
-        this.end = end;
-        if (end !== undefined) {
-            end.incomingConnections.push(this);
+        else {
             this.endDirection = end?.direction;
             this.endCoords = end?.coords || [0, 0];
         }
@@ -2372,6 +2906,11 @@ class DiagramConnectionSet extends DiagramEntitySet {
 }
 
 let idTicker$3 = 0;
+/**
+ * Default values of the look of a diagram section.
+ * @see DIAGRAM_SECTION_DEFAULTS
+ * @private
+ */
 const DIAGRAM_SECTION_LOOK_DEFAULTS = {
     lookType: 'shaped-look',
     shape: ClosedShape.Rectangle,
@@ -2380,6 +2919,11 @@ const DIAGRAM_SECTION_LOOK_DEFAULTS = {
     selectedColor: '#FFFFFF',
     selectedBorderColor: '#000000'
 };
+/**
+ * Default values of the parameters of a diagram section.
+ * @see DiagramSection
+ * @private
+ */
 const DIAGRAM_SECTION_DEFAULTS = {
     sectionsX: 1,
     sectionsY: 1,
@@ -2390,7 +2934,18 @@ const DIAGRAM_SECTION_DEFAULTS = {
     ports: [],
     look: DIAGRAM_SECTION_LOOK_DEFAULTS
 };
+/**
+ * A section of a node which can have connections and display a property of the node.
+ * @see DiagramConnection
+ * @see DiagramNode
+ * @see DiagramPort
+ * @public
+ */
 class DiagramSection extends DiagramElement {
+    /**
+     * Name of this section. Alias for this section's label's text.
+     * @public
+     */
     get name() {
         return this.label?.text || '';
     }
@@ -2411,6 +2966,10 @@ class DiagramSection extends DiagramElement {
             } while (model.sections.get(uniqueId) !== undefined);
         }
         super(model, uniqueId);
+        /**
+         * Ports of this section.
+         * @public
+         */
         this.ports = [];
         this.node = node;
         this.coords = coords;
@@ -2677,6 +3236,11 @@ class DiagramSectionSet extends DiagramEntitySet {
 }
 
 let idTicker$2 = 0;
+/**
+ * Default values of the look of a diagram node.
+ * @see DIAGRAM_NODE_TYPE_DEFAULTS
+ * @private
+ */
 const DIAGRAM_NODE_LOOK_DEFAULTS = {
     lookType: 'shaped-look',
     shape: ClosedShape.Rectangle,
@@ -2685,6 +3249,11 @@ const DIAGRAM_NODE_LOOK_DEFAULTS = {
     selectedColor: '#FFFFFF',
     selectedBorderColor: '#000000'
 };
+/**
+ * Default values of the parameters of a diagram node.
+ * @see DiagramNode
+ * @private
+ */
 const DIAGRAM_NODE_TYPE_DEFAULTS = {
     name: '',
     defaultWidth: 0,
@@ -2701,6 +3270,11 @@ const DIAGRAM_NODE_TYPE_DEFAULTS = {
     priority: 0,
     properties: []
 };
+/**
+ * A node type, which holds properties that nodes of this type share in common.
+ * @see NodeTypeConfig
+ * @public
+ */
 class DiagramNodeType {
     constructor(options) {
         const values = {
@@ -2724,7 +3298,18 @@ class DiagramNodeType {
         this.propertySet = new PropertySet(options?.properties || []);
     }
 }
+/**
+ * A node, the most basic element of a diagram, which can have connections to other nodes through its ports or be divided into sections.
+ * @see DiagramConnection
+ * @see DiagramPort
+ * @see DiagramSection
+ * @public
+ */
 class DiagramNode extends DiagramElement {
+    /**
+     * Name of this node. Alias for this node's label's text.
+     * @public
+     */
     get name() {
         return this.label?.text || '';
     }
@@ -2745,7 +3330,15 @@ class DiagramNode extends DiagramElement {
             } while (model.nodes.get(uniqueId) !== undefined);
         }
         super(model, uniqueId);
+        /**
+         * Sections of this node.
+         * @public
+         */
         this.sections = [];
+        /**
+         * Ports of this node.
+         * @public
+         */
         this.ports = [];
         this.type = type;
         this.valueSet = new ValueSet(type.propertySet, this);
@@ -3075,11 +3668,23 @@ class DiagramNodeSet extends DiagramEntitySet {
 }
 
 let idTicker$1 = 0;
+/**
+ * Default values of the parameters of a diagram port.
+ * @see DiagramPort
+ * @private
+ */
 const DIAGRAM_PORT_DEFAULTS = {
     radius: 12,
     highlightedColor: 'cyan',
     selectedColor: 'violet'
 };
+/**
+ * A port which is part of a node or section and at which connections can start or end.
+ * @see DiagramConnection
+ * @see DiagramNode
+ * @see DiagramSection
+ * @public
+ */
 class DiagramPort extends DiagramElement {
     constructor(model, rootElement, coords, direction, id) {
         let uniqueId;
@@ -3092,7 +3697,15 @@ class DiagramPort extends DiagramElement {
             } while (model.ports.get(uniqueId) !== undefined);
         }
         super(model, uniqueId);
+        /**
+         * Connections that start at this port.
+         * @public
+         */
         this.outgoingConnections = [];
+        /**
+         * Connections that end at this port.
+         * @public
+         */
         this.incomingConnections = [];
         this.rootElement = rootElement;
         this.coords = coords;
@@ -3209,6 +3822,11 @@ class DiagramPortSet extends DiagramEntitySet {
 }
 
 let idTicker = 0;
+/**
+ * Default values of the parameters of a diagram field.
+ * @see DiagramField
+ * @private
+ */
 const DIAGRAM_FIELD_DEFAULTS = {
     editable: true,
     fontSize: 0,
@@ -3220,7 +3838,18 @@ const DIAGRAM_FIELD_DEFAULTS = {
     horizontalAlign: HorizontalAlign.Center,
     verticalAlign: VerticalAlign.Center
 };
+/**
+ * A field which displays text and is part of a diagram element.
+ * @see DiagramNode
+ * @see DiagramPort
+ * @see DiagramSection
+ * @public
+ */
 class DiagramField extends DiagramElement {
+    /**
+     * Text contents of this field.
+     * @public
+     */
     get text() {
         return this._text;
     }
@@ -3330,23 +3959,46 @@ class DiagramFieldSet extends DiagramEntitySet {
     }
 }
 
+/**
+ * Stores the data of a diagram.
+ * @public
+ */
 class DiagramModel {
-    // canvas attribute accesors
-    // added so that the valueSet can access canvas attributes and change them
-    get layoutFormat() {
-        return this.canvas?.layoutFormat;
-    }
-    set layoutFormat(value) {
-        if (this.canvas) {
-            this.canvas.layoutFormat = value;
-        }
-    }
     constructor(canvas, id, name, description, type, properties = []) {
+        /**
+         * Whether changes to this model are updated in the canvas in real time.
+         * @private
+         */
         this.renderToCanvas = true;
+        /**
+         * Nodes of this model.
+         * @see DiagramNode
+         * @public
+         */
         this.nodes = new DiagramNodeSet(this);
+        /**
+         * Sections of this model.
+         * @see DiagramSection
+         * @public
+         */
         this.sections = new DiagramSectionSet(this);
+        /**
+         * Ports of this model.
+         * @see DiagramPort
+         * @public
+         */
         this.ports = new DiagramPortSet(this);
+        /**
+         * Connections of this model.
+         * @see DiagramConnection
+         * @public
+         */
         this.connections = new DiagramConnectionSet(this);
+        /**
+         * Fields of this model.
+         * @see DiagramField
+         * @public
+         */
         this.fields = new DiagramFieldSet(this);
         this.canvas = canvas;
         this.id = id;
@@ -3357,15 +4009,25 @@ class DiagramModel {
         this.updatedAt = new Date();
         this.valueSet = new ValueSet(new PropertySet(properties), this);
     }
+    /**
+     * Enables rendering to canvas in real time and updates the view of this model in the canvas.
+     * @public
+     */
     enableRenderToCanvas() {
         this.renderToCanvas = true;
         this.canvas?.updateModelInView();
     }
+    /**
+     * Disables rendering to canvas in real time.
+     * Used to perform batches of changes to the model without the computational cost of rendering each change to the canvas individually.
+     * @public
+     */
     disableRenderToCanvas() {
         this.renderToCanvas = false;
     }
     /**
      * Deletes everything in this diagram.
+     * @public
      */
     clear() {
         this.id = undefined;
@@ -3388,20 +4050,24 @@ class DiagramModel {
 
 /**
  * Thickness of the invisible path around a connection used to make it easier to click on, in pixels.
+ * @private
  */
 const CONNECTION_PATH_BOX_THICKNESS = 12;
 /**
  * Thickness of the resizer line used to resize nodes and sections on drag, in pixels.
+ * @private
  */
 const RESIZER_THICKNESS = 6;
 /**
  * Text to display as the title of the property editor when editing this diagram's properties.
  * @see PropertyEditorComponent
+ * @private
  */
 const DIAGRAM_PROPERTIES_TEXT = 'Diagram properties';
 /**
  * Maximum number of user actions that can be recorded in the user action queue.
  * @see ActionQueue
+ * @private
  */
 const ACTION_QUEUE_SIZE = 25;
 class DiagramCanvas {
@@ -5507,6 +6173,11 @@ class DiagramCanvas {
         this.inputFieldContainer = undefined;
     }
 }
+/**
+ * Get the SVG path of a diagram connection.
+ * @see linePath
+ * @private
+ */
 const getConnectionPath = (connection) => {
     return linePath(connection.type.shape, [connection.startCoords, connection.endCoords], connection.startDirection, connection.endDirection, Math.max(
     // reasonable value for the minimumDistanceBeforeTurn relative to the line width
@@ -5515,14 +6186,31 @@ const getConnectionPath = (connection) => {
 
 /**
  * A provider for the {@link Canvas} associated with a {@link DiagramComponent} context.
+ * @public
  */
 class CanvasProviderService {
+    /**
+     * Initialize the diagram canvas object of this context.
+     * @private
+     * @param parentComponent A diagram editor.
+     * @param config A diagram configuration.
+     */
     initCanvas(parentComponent, config) {
         this._canvas = new DiagramCanvas(parentComponent, config);
     }
+    /**
+     * Attach the canvas of this context to an HTML Element to render it there.
+     * @private
+     * @param appendTo An HTML Element.
+     */
     initCanvasView(appendTo) {
         this._canvas.initView(appendTo);
     }
+    /**
+     * Get the diagram canvas of this context.
+     * @public
+     * @returns A diagram canvas.
+     */
     getCanvas() {
         return this._canvas;
     }
@@ -5533,6 +6221,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
             type: Injectable
         }] });
 
+/**
+ * Buttons used to trigger diagram functionalities by the user.
+ * @private
+ */
 class DiagramButtonsComponent {
     get canvas() {
         return this.canvasProvider.getCanvas();
@@ -5634,6 +6326,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                 type: Input
             }] } });
 
+/**
+ * Displays the errors detected by a diagram's validators.
+ * @see DiagramValidator
+ * @private
+ */
 class ErrorsComponent {
     get canvas() {
         return this.canvasProvider.getCanvas();
@@ -5683,6 +6380,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                 args: ['errors']
             }] } });
 
+/**
+ * Palette that the user can drag and drop nodes from.
+ * @see DiagramConfig
+ * @see DiagramNode
+ * @private
+ */
 class PaletteComponent {
     get canvas() {
         return this.canvasProvider.getCanvas();
@@ -6050,6 +6753,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                 type: Input
             }] } });
 
+/**
+ * Editor of a property of text list type within a property editor.
+ * @see TextList
+ * @see PropertyEditor
+ * @see ValueSet
+ * @private
+ */
 class TextListEditorComponent {
     set value(val) {
         if (val === this._value) {
@@ -6120,6 +6830,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                 type: Output
             }] } });
 
+/**
+ * Editor of a property of text map type within a property editor.
+ * @see TextMap
+ * @see PropertyEditor
+ * @see ValueSet
+ * @private
+ */
 class TextMapEditorComponent {
     set value(val) {
         if (val === this._value) {
@@ -6198,6 +6915,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                 type: Output
             }] } });
 
+/**
+ * Editor of a value set within a property editor.
+ * @see PropertyEditor
+ * @see ValueSet
+ * @private
+ */
 class ObjectEditorComponent {
     get canvas() {
         return this.canvasProvider.getCanvas();
@@ -6216,7 +6939,7 @@ class ObjectEditorComponent {
     constructor(cdr, canvasProvider) {
         this.cdr = cdr;
         this.canvasProvider = canvasProvider;
-        /** How many object-editors are parents of this object-editor */
+        /** How many object-editors are parents of this object-editor. @private */
         this.depth = 0;
         // Attributes for the template
         this.Type = Type;
@@ -6299,6 +7022,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
                 type: Input
             }] } });
 
+/**
+ * Editor of the values of a value set.
+ * @see ValueSet
+ * @private
+ */
 class PropertyEditorComponent {
     get valueSet() {
         return this._valueSet;
@@ -6347,11 +7075,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
 
 /**
  * A provider for the {@link DiagramConfig} associated with a {@link DiagramComponent} context.
+ * @public
  */
 class DagaConfigurationService {
+    /**
+     * Set the diagram configuration of this context.
+     * @private
+     * @param config A diagram configuration.
+     */
     init(config) {
         this._config = config;
     }
+    /**
+     * Get the diagram configuration of this context.
+     * @public
+     * @returns A diagram configuration.
+     */
     getConfig() {
         return this._config;
     }
@@ -6362,6 +7101,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
             type: Injectable
         }] });
 
+/**
+ * A diagram's user interface editor.
+ * @private
+ */
 class DiagramEditorComponent {
     get config() {
         return this.configurationService.getConfig();
@@ -6409,6 +7152,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
 /**
  * The context of a diagram. Every separate diagram must be contained within its own {@link DiagramComponent} and every {@link DiagramComponent} must contain its own {@link DiagramEditorComponent}.
  * This component defines a {@link DagaConfigurationService} and a {@link CanvasProviderService}, which is shared by all the components within and allows accessing the configuration and the canvas of this component's diagram, respectively.
+ * @public
  */
 class DiagramComponent {
     constructor(configurationService, canvasProvider) {
@@ -6487,6 +7231,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
 
 const DAGA_FILE_VERSION = 1;
 
+/**
+ * Importer which exports a diagram to its daga model representation.
+ * @public
+ */
 class DagaExporter {
     export(model) {
         const result = {
@@ -6563,6 +7311,10 @@ class DagaExporter {
     }
 }
 
+/**
+ * Importer which imports a diagram from its daga model representation.
+ * @public
+ */
 class DagaImporter {
     import(model, data) {
         // clear the model beforehand