@metadev/daga 1.1.0 → 1.3.0

package/lib/diagram-editor/diagram-editor.component.d.ts

@@ -9,6 +9,10 @@ import { CanvasProviderService } from '../services/canvas-provider.service';
 import { DagaConfigurationService } from '../services/daga-configuration.service';
 import { Corner } from '../util/svg-util';
 import * as i0 from "@angular/core";
+/**
+ * A diagram's user interface editor.
+ * @private
+ */
 export declare class DiagramEditorComponent implements AfterViewInit, DiagramEditor, OnInit {
     private configurationService;
     private canvasProvider;

package/lib/errors/diagram-error.d.ts

@@ -1,5 +1,24 @@
+/**
+ * An error in a diagram detected by a diagram validator.
+ * @see DiagramValidator
+ * @public
+ */
 export interface DiagramError {
+    /**
+     * Error message to be displayed to the user.
+     * @public
+     */
     message: string;
+    /**
+     * If applicable, id of the diagram element which contains this error.
+     * @see DiagramElement
+     * @public
+     */
     elementId?: string;
+    /**
+     * If applicable, list of keys under which to find the property which contains this error in the value set which contains this error.
+     * @see ValueSet
+     * @public
+     */
     propertyNames?: string[];
 }

package/lib/errors/diagram-validator.d.ts

@@ -1,8 +1,13 @@
 import { DiagramModel } from '../diagram-editor/diagram/diagram-model';
 import { DiagramError } from './diagram-error';
+/**
+ * A validator that checks for specific types of errors in a diagram.
+ * @public
+ */
 export interface DiagramValidator {
     /**
-     * Checks the model and returns any list of errors the diagram has.
+     * Checks a diagram model and returns the list of errors detected.
+     * @public
      */
     validate(model: DiagramModel): DiagramError[];
 }

package/lib/errors/errors.component.d.ts

@@ -5,6 +5,11 @@ import { CanvasProviderService } from '../services/canvas-provider.service';
 import { Side } from '../util/svg-util';
 import { DiagramError } from './diagram-error';
 import * as i0 from "@angular/core";
+/**
+ * Displays the errors detected by a diagram's validators.
+ * @see DiagramValidator
+ * @private
+ */
 export declare class ErrorsComponent implements AfterViewInit {
     private canvasProvider;
     get canvas(): Canvas;

package/lib/interfaces/canvas.d.ts

@@ -6,198 +6,248 @@ import { DiagramModel } from '../diagram-editor/diagram/diagram-model';
 import { DiagramValidator } from '../errors/diagram-validator';
 import { Point } from '../util/canvas-util';
 import { DiagramEditor } from './diagram-editor';
+import { UserActionConfig } from '../diagram-editor/diagram/diagram-config';
 /**
  * Provides the functionality for the visual representation of the elements of a model.
+ * @public
  */
 export interface Canvas {
     /**
      * Parent component of the diagram.
+     * @private
      */
     parentComponent: DiagramEditor;
     /**
      * Object that contains the data of the elements of the diagram.
+     * @public
      */
     model: DiagramModel;
     /**
      * Background color of the diagram.
+     * @public
      */
     color: string;
     /**
      * Distance between the grid points of the diagram.
+     * @public
      */
     gridSize: number;
     /**
      * If true, elements moved by the user should be placed on the closest grid point rather than the exact point where they were placed.
+     * @public
      */
     snapToGrid: boolean;
     /**
      * If true, new connections should have the type that makes most sense even if it's not the currently chosen type.
+     * @public
      */
     guessConnectionType: boolean;
     /**
      * When a new connection is made, it should have this type.
+     * @public
      */
     connectionType?: DiagramConnectionType;
     /**
      * Elements below the priority threshold shouldn't be displayed.
+     * @public
      */
     priorityThreshold?: number;
     /**
      * Possible values that the priority threshold can take.
+     * @public
      */
     priorityThresholds: number[];
     /**
      * Identifier of the current layout format used by the diagram.
+     * @public
      */
     layoutFormat?: string;
+    /**
+     * Mapping of what actions the user is allowed to perform. Absent values are assumed to be `true`.
+     * @public
+     */
+    userActions: UserActionConfig;
     /**
      * The list of validators used to check for errors in this canvas.
+     * @private
      */
     validators: DiagramValidator[];
     /**
      * The queue of actions used to keep track of what actions can be undone or redone.
+     * @private
      */
     actionQueue: ActionQueue;
     /**
      * Subject for tracking when the canvas' view is initialized.
+     * @public
      */
     viewInitialized$: Subject<void>;
     /**
      * Subject for tracking when validators are added to the canvas.
+     * @public
      */
     validatorChanges$: Subject<void>;
     /**
      * Subject for tracking changes in the diagram.
      * Used to detect if there have been changes over a period of time.
+     * @public
      */
     diagramChanges$: Subject<number>;
     /**
      * Subject for tracking the presence of important changes in the diagram.
      * Used to detect if there are any changes that require an immediate reaction.
+     * @public
      */
     diagramImportantChanges$: Subject<void>;
     /**
      * Initializes the view of the diagram.
+     * @private
      */
     initView(appendTo: HTMLElement): void;
     /**
      * Increases the zoom level by the given factor.
+     * @public
      * @param zoom A factor of zoom.
      */
     zoomBy(zoom: number): void;
     /**
      * Changes the zoom level to a given level.
+     * @public
      * @param zoom A level of zoom.
      */
     zoomTo(zoom: number): void;
     /**
      * Translates the view by the given amount.
+     * @public
      * @param x A distance along the x axis.
      * @param y A distance along the y axis.
      */
     translateBy(x: number, y: number): void;
     /**
      * Translates the view to the given point.
+     * @public
      * @param x A coordinate along the x axis.
      * @param y A coordinate along the y axis.
      */
     translateTo(x: number, y: number): void;
     /**
      * Centers by zooming and translating the view such that every element fits in the view.
+     * @public
      */
     center(): void;
     /**
      * Get the closest grid point to the given point.
+     * @public
      * @param point A point.
      */
     getClosestGridPoint(point: Point): Point;
     /**
      * Get the location of the pointer in the given event relative to the canvas.
+     * @private
      * @param event A MouseEvent.
      */
     getPointerLocationRelativeToCanvas(event: MouseEvent): Point;
     /**
      * Get the location of the pointer in the given event relative to the body.
+     * @private
      * @param event A MouseEvent.
      */
     getPointerLocationRelativeToBody(event: MouseEvent): Point;
     /**
      * Adds a validator to the list of validators of the diagram.
+     * @public
      */
     addValidator(validator: DiagramValidator): void;
     /**
      * Removes a validator from the list of validators of the diagram.
+     * @public
      */
     removeValidator(validator: DiagramValidator): void;
     /**
      * Update the view of the canvas to show the current state of the model.
+     * @public
      */
     updateModelInView(): void;
     /**
      * Update the view of the canvas to show the current state of the nodes.
+     * @public
      */
     updateNodesInView(...ids: string[]): void;
     /**
      * Update the view of the canvas to show the current state of the sections.
+     * @public
      */
     updateSectionsInView(...ids: string[]): void;
     /**
      * Update the view of the canvas to show the current state of the ports.
+     * @public
      */
     updatePortsInView(...ids: string[]): void;
     /**
      * Update the view of the canvas to show the current state of the connections.
+     * @public
      */
     updateConnectionsInView(...ids: string[]): void;
     /**
      * Update the view of the canvas to show the current state of the fields.
+     * @public
      */
     updateFieldsInView(...ids: string[]): void;
     /**
      * Get the d3 Selection containing the view of all the elements in the canvas.
+     * @private
      */
     selectCanvasView(): d3.Selection<SVGGElement, unknown, null, unknown>;
     /**
      * Highlight the given diagram element in the canvas view and all the elements which depend on it.
      * Highlighting an element unhighlights the previously highlighted elements.
+     * @private
      * @param element A diagram element.
      */
     highlight(element: DiagramElement): void;
     /**
      * Unhighlights all diagram elements.
+     * @private
      */
     unhighlight(): void;
     /**
      * Checks if the given diagram element is in the current user selection.
+     * @private
      * @param selection A diagram element.
      */
     isInUserSelection(selection: DiagramElement): boolean;
     /**
      * Adds the given diagram element to the current user selection.
+     * @private
      * @param selection A diagram element.
      */
     addToUserSelection(selection: DiagramElement): void;
     /**
      * Removes the given diagram element from the current user selection.
+     * @private
      * @param selection A diagram element.
      */
     removeFromUserSelection(selection: DiagramElement): void;
     /**
      * Adds the given diagram element to the current user selection if it's not in the current user selection.
      * If it is part of the current user selection, removes it from the current user selection.
+     * @private
      * @param selection A diagram element.
      */
     toggleUserSelection(selection: DiagramElement): void;
     /**
      * Removes all elements from the current user selection.
+     * @private
      */
     clearUserSelection(): void;
     /**
      * Stops all unfinished user actions to ensure there are no unfinished actions before performing a different action.
+     * @public
      */
     cancelAllUserActions(): void;
     /**
      * Sets the diagram element whose ValueSet is being displayed in the value set editor.
+     * @private
      */
     setPropertyEditorSelection(selection?: DiagramElement): void;
 }

package/lib/interfaces/diagram-buttons.d.ts

@@ -1,33 +1,41 @@
 /**
  * General canvas commands for zooming and filtering used by the buttons of the diagram's user interface.
+ * @private
  */
 export interface DiagramButtons {
     /**
      * Increase the zoom level of the diagram by this component's zoom rate.
+     * @private
      */
     zoomIn(): void;
     /**
      * Decrease the zoom level of the diagram by this component's zoom rate.
+     * @private
      */
     zoomOut(): void;
     /**
      * Center the view of the diagram.
+     * @private
      */
     center(): void;
     /**
      * Apply the diagram's current layout if applicable.
+     * @private
      */
     layout(): void;
     /**
      * Change the current priority threshold of the canvas, hide any nodes with a priority below the threshold and recalculate the diagram's layout.
+     * @private
      */
     filter(): void;
     /**
      * Undo the latest user change in the diagram.
+     * @private
      */
     undo(): void;
     /**
      * Redo the latest undone user change in the diagram.
+     * @private
      */
     redo(): void;
 }

package/lib/interfaces/diagram-editor.d.ts

@@ -3,18 +3,22 @@ import { Palette } from './palette';
 import { PropertyEditor } from './property-editor';
 /**
  * Exposes the components of the diagram editor.
+ * @private
  */
 export interface DiagramEditor {
     /**
      * Diagram buttons component of the diagram editor.
+     * @private
      */
     diagramButtons: DiagramButtons;
     /**
      * Palette component of the diagram editor.
+     * @private
      */
     palette: Palette;
     /**
      * Property editor component of the diagram editor.
+     * @private
      */
     propertyEditor: PropertyEditor;
 }

package/lib/interfaces/palette.d.ts

@@ -1,10 +1,12 @@
 /**
  * Exposes the commands of the palette component.
+ * @private
  */
 export interface Palette {
     /**
      * Refresh the current items being displayed in the palette.
      * Used when it is necessary to update the contents of the palette but the state of the palette doesn't change.
+     * @private
      */
     refreshPalette(): void;
 }

package/lib/interfaces/property-editor.d.ts

@@ -1,18 +1,22 @@
 import { ValueSet } from '../diagram-editor/diagram/diagram-property';
 /**
  * Exposes the commands of the property editor component.
+ * @private
  */
 export interface PropertyEditor {
     /**
      * Title of the ValueSet displayed in the UI.
+     * @private
      */
     title?: string;
     /**
      * ValueSet being edited in this component by the user.
+     * @private
      */
     valueSet?: ValueSet;
     /**
      * Highlight the property given by the list of keys it can be found under.
+     * @private
      * @param propertyNames The keys under which a property can be found in the ValueSet being edited in this component.
      */
     highlightProperty(...propertyNames: string[]): void;

package/lib/object-editor/object-editor.component.d.ts

@@ -4,14 +4,21 @@ import { Property, Type, ValueSet } from '../diagram-editor/diagram/diagram-prop
 import { Canvas } from '../interfaces/canvas';
 import { CanvasProviderService } from '../services/canvas-provider.service';
 import * as i0 from "@angular/core";
+/**
+ * Editor of a value set within a property editor.
+ * @see PropertyEditor
+ * @see ValueSet
+ * @private
+ */
 export declare class ObjectEditorComponent {
     private cdr;
     private canvasProvider;
     get canvas(): Canvas;
+    get userCanEdit(): boolean;
     _valueSet?: ValueSet;
     get valueSet(): ValueSet | undefined;
     set valueSet(valueSet: ValueSet | undefined);
-    /** How many object-editors are parents of this object-editor */
+    /** How many object-editors are parents of this object-editor. @private */
     depth: number;
     Type: typeof Type;
     booleanRadioItems: RadioItem[];

package/lib/palette/palette.component.d.ts

@@ -6,6 +6,12 @@ import { Palette } from '../interfaces/palette';
 import { CanvasProviderService } from '../services/canvas-provider.service';
 import { Corner } from '../util/svg-util';
 import * as i0 from "@angular/core";
+/**
+ * Palette that the user can drag and drop nodes from.
+ * @see DiagramConfig
+ * @see DiagramNode
+ * @private
+ */
 export declare class PaletteComponent implements AfterContentInit, AfterViewInit, Palette {
     private canvasProvider;
     get canvas(): Canvas;

package/lib/property-editor/property-editor.component.d.ts

@@ -3,6 +3,11 @@ import { ValueSet } from '../diagram-editor/diagram/diagram-property';
 import { PropertyEditor } from '../interfaces/property-editor';
 import { Corner } from '../util/svg-util';
 import * as i0 from "@angular/core";
+/**
+ * Editor of the values of a value set.
+ * @see ValueSet
+ * @private
+ */
 export declare class PropertyEditorComponent implements PropertyEditor {
     private cdr;
     panel: ElementRef<HTMLDivElement>;

package/lib/services/canvas-provider.service.d.ts

@@ -4,11 +4,28 @@ import { DiagramEditor } from '../interfaces/diagram-editor';
 import * as i0 from "@angular/core";
 /**
  * A provider for the {@link Canvas} associated with a {@link DiagramComponent} context.
+ * @public
  */
 export declare class CanvasProviderService {
     private _canvas;
+    /**
+     * Initialize the diagram canvas object of this context.
+     * @private
+     * @param parentComponent A diagram editor.
+     * @param config A diagram configuration.
+     */
     initCanvas(parentComponent: DiagramEditor, config: DiagramConfig): void;
+    /**
+     * Attach the canvas of this context to an HTML Element to render it there.
+     * @private
+     * @param appendTo An HTML Element.
+     */
     initCanvasView(appendTo: HTMLElement): void;
+    /**
+     * Get the diagram canvas of this context.
+     * @public
+     * @returns A diagram canvas.
+     */
     getCanvas(): Canvas;
     static ɵfac: i0.ɵɵFactoryDeclaration<CanvasProviderService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CanvasProviderService>;

package/lib/services/daga-configuration.service.d.ts

@@ -2,10 +2,21 @@ import { DiagramConfig } from '../diagram-editor/diagram/diagram-config';
 import * as i0 from "@angular/core";
 /**
  * A provider for the {@link DiagramConfig} associated with a {@link DiagramComponent} context.
+ * @public
  */
 export declare class DagaConfigurationService {
     private _config;
+    /**
+     * Set the diagram configuration of this context.
+     * @private
+     * @param config A diagram configuration.
+     */
     init(config: DiagramConfig): void;
+    /**
+     * Get the diagram configuration of this context.
+     * @public
+     * @returns A diagram configuration.
+     */
     getConfig(): DiagramConfig;
     static ɵfac: i0.ɵɵFactoryDeclaration<DagaConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DagaConfigurationService>;

package/lib/text-list-editor/text-list-editor.component.d.ts

@@ -1,5 +1,12 @@
 import { ChangeDetectorRef, EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Editor of a property of text list type within a property editor.
+ * @see TextList
+ * @see PropertyEditor
+ * @see ValueSet
+ * @private
+ */
 export declare class TextListEditorComponent {
     private cdr;
     private _value;

package/lib/text-map-editor/text-map-editor.component.d.ts

@@ -1,5 +1,12 @@
 import { ChangeDetectorRef, EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Editor of a property of text map type within a property editor.
+ * @see TextMap
+ * @see PropertyEditor
+ * @see ValueSet
+ * @private
+ */
 export declare class TextMapEditorComponent {
     private cdr;
     private _value;

package/lib/util/canvas-util.d.ts

@@ -1,16 +1,120 @@
 import { Side } from './svg-util';
+/**
+ * A point on a canvas defined as its coordinates along the x and y axes.
+ * @see DiagramCanvas
+ * @public
+ */
 export type Point = [number, number];
+/**
+ * A line on a canvas defined as its start point and end point.
+ * @see DiagramCanvas
+ * @public
+ */
 export type Line = [Point, Point];
+/**
+ * A rectangle on a canvas defined as the points of its opposite corners.
+ * @see DiagramCanvas
+ * @public
+ */
 export type Rectangle = [Point, Point];
+/**
+ * Round the coordinates of the given point to the nearest whole number.
+ * @public
+ * @param point A point.
+ * @returns A new point with whole coordinates.
+ */
 export declare const roundPoint: (point: Point) => Point;
+/**
+ * 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.
+ */
 export declare const between: (coordinate: number, start: number, end: number) => boolean;
+/**
+ * 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.
+ */
 export declare const translateCoordinate: (oldCoordinate: number, oldCoordinates: [number, number], newCoordinates: [number, number]) => number;
+/**
+ * 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.
+ */
 export declare const translatePoint: (oldPoint: Point, oldCoordsX: [number, number], oldCoordsY: [number, number], newCoordsX: [number, number], newCoordsY: [number, number]) => Point;
+/**
+ * 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.
+ */
 export declare const movePoint: (point: Point, direction: Side, distance: number) => Point;
+/**
+ * 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.
+ */
 export declare const equals: (point1: Point, point2: Point) => boolean;
+/**
+ * Calculates the euclidean distance between two points.
+ * @public
+ * @param point1 A point.
+ * @param point2 A point.
+ * @returns The euclidean distance between the given points.
+ */
 export declare const distanceBetweenPoints: (point1: Point, point2: Point) => number;
+/**
+ * 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.
+ */
 export declare const lineContainsPoint: (line: Line, point: Point) => boolean;
+/**
+ * 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.
+ */
 export declare const rectangleContainsPoint: (rectangle: Rectangle, point: Point) => boolean;
+/**
+ * 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.
+ */
 export declare const linesIntersect: (line1: Line, line2: Line) => boolean;
+/**
+ * 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.
+ */
 export declare const linesOverlap: (line1: Line, line2: Line) => boolean;
+/**
+ * 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.
+ */
 export declare const lineIntersectsRectangle: (line: Line, rectangle: Rectangle) => boolean;