@metadev/daga 1.0.0

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

@@ -0,0 +1,37 @@
+import { Point } from '../../util/canvas-util';
+import { HorizontalAlign, VerticalAlign } from '../../util/svg-util';
+import { DiagramElement } from './diagram-element';
+import { DiagramModel } from './diagram-model';
+import { DiagramNode } from './diagram-node';
+export declare const DIAGRAM_FIELD_DEFAULTS: {
+    editable: boolean;
+    fontSize: number;
+    margin: number;
+    padding: number;
+    fontFamily: null;
+    color: string;
+    selectedColor: string;
+    horizontalAlign: HorizontalAlign;
+    verticalAlign: VerticalAlign;
+};
+export declare class DiagramField extends DiagramElement {
+    rootElement?: DiagramElement;
+    coords: Point;
+    width: number;
+    height: number;
+    fontSize: number;
+    fontFamily: string | null;
+    color: string;
+    selectedColor: string;
+    horizontalAlign: HorizontalAlign;
+    verticalAlign: VerticalAlign;
+    private _text;
+    defaultText: string;
+    get text(): string;
+    set text(value: string);
+    editable: boolean;
+    constructor(model: DiagramModel, rootElement: DiagramElement | undefined, coords: Point, width: number, height: number, fontSize: number, fontFamily: string | null, color: string, selectedColor: string, horizontalAlign: HorizontalAlign, verticalAlign: VerticalAlign, text: string, editable: boolean, id?: string);
+    updateInView(): void;
+    move(coords: Point): void;
+    getClosestNode(): DiagramNode | undefined;
+}

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

@@ -0,0 +1,64 @@
+import { Canvas } from '../../interfaces/canvas';
+import { Point } from '../../util/canvas-util';
+import { HorizontalAlign, Side, VerticalAlign } from '../../util/svg-util';
+import { DiagramConnection, DiagramConnectionType } from './diagram-connection';
+import { DiagramElement } from './diagram-element';
+import { DiagramField } from './diagram-field';
+import { DiagramNode, DiagramNodeType } from './diagram-node';
+import { DiagramPort } from './diagram-port';
+import { Property, ValueSet } from './diagram-property';
+import { DiagramSection } from './diagram-section';
+export declare class DiagramModel {
+    canvas?: Canvas;
+    renderToCanvas: boolean;
+    nodeTypes: DiagramNodeType[];
+    connectionTypes: DiagramConnectionType[];
+    nodes: DiagramNode[];
+    sections: DiagramSection[];
+    ports: DiagramPort[];
+    connections: DiagramConnection[];
+    fields: DiagramField[];
+    id: string | undefined;
+    name: string;
+    description?: string;
+    type: string;
+    createdAt: Date;
+    updatedAt: Date;
+    valueSet: ValueSet;
+    get layoutFormat(): string | undefined;
+    set layoutFormat(value: string | undefined);
+    constructor(canvas: Canvas | undefined, id: string | undefined, name: string, description: string | undefined, type: string, properties?: Property[]);
+    enableRenderToCanvas(): void;
+    disableRenderToCanvas(): void;
+    /**
+     * Deletes everything in this diagram.
+     */
+    clear(): void;
+    getElement(id: string): DiagramElement | undefined;
+    deleteElement(element: DiagramElement): void;
+    getNodeType(name: string): DiagramNodeType | undefined;
+    getConnectionType(name: string): DiagramConnectionType | undefined;
+    getNode(id: string): DiagramNode | undefined;
+    getNodes(threshold?: number): DiagramNode[];
+    getNodesOfType(type: string): DiagramNode[];
+    addNode(type: DiagramNodeType, coords: Point, id?: string | undefined, sectionIds?: (string | undefined)[], sectionPortIds?: (string | undefined)[][], sectionPortLabelIds?: (string | undefined)[][], portIds?: (string | undefined)[], portLabelIds?: (string | undefined)[], labelId?: string | undefined): DiagramNode;
+    deleteNode(node: DiagramNode): void;
+    hasNodeOfType(type: string): boolean;
+    getSection(id: string): DiagramSection | undefined;
+    getSections(threshold?: number): DiagramSection[];
+    addSection(node: DiagramNode, coords: Point, width: number, height: number, id?: string | undefined, portIds?: (string | undefined)[], portLabelIds?: (string | undefined)[]): DiagramSection;
+    deleteSection(section: DiagramSection): void;
+    getPort(id: string): DiagramPort | undefined;
+    getPorts(threshold?: number): DiagramPort[];
+    addPort(rootElement: DiagramElement | undefined, coords: Point, direction: Side, id?: string | undefined): DiagramPort;
+    deletePort(port: DiagramPort): void;
+    getConnection(id: string): DiagramConnection | undefined;
+    getConnections(threshold?: number): DiagramConnection[];
+    getConnectionsOfType(type: string): DiagramConnection[];
+    addConnection(type: DiagramConnectionType, start?: DiagramPort, end?: DiagramPort, id?: string | undefined): DiagramConnection;
+    deleteConnection(connection: DiagramConnection): void;
+    getField(id: string): DiagramField | undefined;
+    getFields(threshold?: number): DiagramField[];
+    addField(rootElement: DiagramElement | undefined, coords: Point, fontSize: number, fontFamily: string | null, color: string, selectedColor: string, width: number, height: number, horizontalAlign: HorizontalAlign, verticalAlign: VerticalAlign, text: string, editable: boolean, id?: string | undefined): DiagramField;
+    deleteField(field: DiagramField): void;
+}

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

@@ -0,0 +1,68 @@
+import { Point } from '../../util/canvas-util';
+import { Side } from '../../util/svg-util';
+import { FieldConfig, NodeImageLook, NodeShapedLook, NodeStretchableImageLook, NodeTypeConfig, PortConfig, SectionConfig } from './diagram-config';
+import { DiagramConnection } from './diagram-connection';
+import { DiagramElement } from './diagram-element';
+import { DiagramField } from './diagram-field';
+import { DiagramModel } from './diagram-model';
+import { DiagramPort } from './diagram-port';
+import { PropertySet, ValueSet } from './diagram-property';
+import { DiagramSection } from './diagram-section';
+export declare const DIAGRAM_LOOK_DEFAULTS: NodeShapedLook;
+export declare const DIAGRAM_NODE_TYPE_DEFAULTS: {
+    name: string;
+    defaultWidth: number;
+    defaultHeight: number;
+    minWidth: number;
+    minHeight: number;
+    resizableX: boolean;
+    resizableY: boolean;
+    label: null;
+    ports: never[];
+    sections: null;
+    look: NodeShapedLook;
+    isUnique: boolean;
+    priority: number;
+    properties: never[];
+};
+export declare class DiagramNodeType {
+    id: string;
+    name: string;
+    defaultWidth: number;
+    defaultHeight: number;
+    minWidth: number;
+    minHeight: number;
+    resizableX: boolean;
+    resizableY: boolean;
+    label: FieldConfig | null;
+    ports: PortConfig[];
+    sections: SectionConfig | null;
+    look: NodeShapedLook | NodeImageLook | NodeStretchableImageLook;
+    isUnique: boolean;
+    priority: number;
+    propertySet: PropertySet;
+    constructor(options: NodeTypeConfig);
+}
+export declare class DiagramNode extends DiagramElement {
+    type: DiagramNodeType;
+    valueSet: ValueSet;
+    originalData: unknown;
+    label?: DiagramField;
+    sections: DiagramSection[];
+    ports: DiagramPort[];
+    coords: Point;
+    width: number;
+    height: number;
+    get name(): string;
+    set name(name: string);
+    constructor(model: DiagramModel, type: DiagramNodeType, coords?: Point, id?: string);
+    updateInView(): void;
+    getClosestPortToPoint(coords: Point): DiagramPort | undefined;
+    getIncomingConnections(): DiagramConnection[];
+    getOutgoingConnections(): DiagramConnection[];
+    getConnections(): DiagramConnection[];
+    getAdjacentNodes(): DiagramNode[];
+    move(coords: Point): void;
+    stretch(direction: Side, distance: number): void;
+    stretchSections(direction: Side, distance: number, point: Point): void;
+}

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

@@ -0,0 +1,27 @@
+import { Point } from '../../util/canvas-util';
+import { Side } from '../../util/svg-util';
+import { DiagramConnection } from './diagram-connection';
+import { DiagramElement } from './diagram-element';
+import { DiagramField } from './diagram-field';
+import { DiagramModel } from './diagram-model';
+import { DiagramNode } from './diagram-node';
+export declare const DIAGRAM_PORT_DEFAULTS: {
+    radius: number;
+    highlightedColor: string;
+    selectedColor: string;
+};
+export declare class DiagramPort extends DiagramElement {
+    rootElement?: DiagramElement;
+    label?: DiagramField;
+    direction: Side;
+    coords: Point;
+    outgoingConnections: DiagramConnection[];
+    incomingConnections: DiagramConnection[];
+    constructor(model: DiagramModel, rootElement: DiagramElement | undefined, coords: Point, direction: Side, id?: string);
+    updateInView(): void;
+    startConnection(connection: DiagramConnection): void;
+    finishConnection(connection: DiagramConnection): void;
+    getNode(): DiagramNode | undefined;
+    move(coords: Point): void;
+    distanceTo(coords: Point): number;
+}

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

@@ -0,0 +1,141 @@
+import { DataSource } from '@metadev/lux';
+export declare class Property {
+    /**
+     * The name of this property. Used to distinguish this property from others.
+     */
+    name: string;
+    /**
+     * The type of this property, which indicates the possible values that this property can have.
+     */
+    type: Type;
+    /**
+     * The default value of this property.
+     */
+    defaultValue: unknown;
+    /**
+     * Whether this property should always appear in the property editor component.
+     * @see PropertyEditorComponent
+     */
+    basic: boolean;
+    /**
+     * Whether the value of this property can be edited.
+     */
+    editable: boolean;
+    /**
+     * Which attribute of the parent component the value of this property is linked to. Null if none.
+     */
+    rootAttribute: string[] | string | null;
+    /**
+     * The list of possible values if the value of the property is chosen from a set of possible values. Undefined otherwise.
+     * @default undefined
+     */
+    options?: DataSource<string, string>;
+    /**
+     * The list of properties that are part of this property if the type of this property is 'object'.
+     */
+    properties?: Property[];
+    constructor(name: string, type: Type, defaultValue: unknown, basic: boolean, editable: boolean, rootAttribute: string[] | string | null);
+}
+export declare enum Type {
+    /**
+     * A type whose value must be a boolean.
+     */
+    Boolean = "boolean",
+    /**
+     * A type whose value must be a string representing a valid HTML color code.
+     */
+    Color = "color",
+    /**
+     * A type whose value must be a date.
+     */
+    Date = "date",
+    /**
+     * A type whose value must be a number.
+     */
+    Number = "number",
+    /**
+     * A type whose value must be an object.
+     */
+    Object = "object",
+    /**
+     * A type whose value must be one of a set of options.
+     */
+    Option = "option",
+    /**
+     * A type whose value must be a list of values picked from a set of options.
+     */
+    OptionList = "option-list",
+    /**
+     * A type whose value must be a string without newline characters.
+     */
+    Text = "text",
+    /**
+     * A type whose value must be a string with newline characters.
+     */
+    TextArea = "text-area",
+    /**
+     * A type whose value must be a list of strings.
+     */
+    TextList = "text-list",
+    /**
+     * A type whose value must be a map with string keys and values.
+     */
+    TextMap = "text-map",
+    /**
+     * A type whose value must be a time of day.
+     */
+    Time = "time",
+    /**
+     * A type whose value must be a valid URL.
+     */
+    Url = "url"
+}
+export declare class PropertySet {
+    propertyMap: {
+        [key: string]: Property;
+    };
+    propertyList: Property[];
+    constructor(properties?: Property[]);
+    getProperty(key: string): Property;
+    hasProperties(): boolean;
+}
+export declare class ValueSet {
+    rootElement: {
+        [key: string]: unknown;
+    };
+    propertySet: PropertySet;
+    displayedProperties: Property[];
+    hiddenProperties: Property[];
+    values: {
+        [key: string]: unknown;
+    };
+    valueSets: {
+        [key: string]: ValueSet;
+    };
+    constructor(propertySet: PropertySet, rootElement: unknown);
+    getRootElementValue(rootAttribute: string[] | string | null): unknown;
+    setRootElementValue(rootAttribute: string[] | string | null, value: unknown): void;
+    getValue(key: string): any;
+    getValues(): {
+        [key: string]: unknown;
+    };
+    hasValue(key: string): boolean;
+    hasSetValue(key: string): boolean;
+    hasAnySetValue(): boolean;
+    hasAnySetValueExcept(keys: string[]): boolean;
+    setValue(key: string, value: unknown): void;
+    setValues(values: {
+        [key: string]: unknown;
+    }): void;
+    hasValues(): boolean;
+    resetValues(): void;
+    displayProperty(property: Property): void;
+    hideProperty(property: Property): void;
+    /**
+     * Constructs a ValueSet with its corresponding PropertySet representing the values of the object.
+     */
+    constructSubValueSet(key: string): ValueSet;
+    getSubValueSet(key: string): ValueSet;
+}
+export declare const empty: (a: unknown) => boolean;
+export declare const equals: (a: unknown, b: unknown) => boolean;

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

@@ -0,0 +1,36 @@
+import { Point } from '../../util/canvas-util';
+import { Side } from '../../util/svg-util';
+import { DiagramConnection } from './diagram-connection';
+import { DiagramElement } from './diagram-element';
+import { DiagramField } from './diagram-field';
+import { DiagramModel } from './diagram-model';
+import { DiagramNode } from './diagram-node';
+import { DiagramPort } from './diagram-port';
+export declare const DIAGRAM_SECTION_DEFAULTS: {
+    sectionsX: number;
+    sectionsY: number;
+    minWidth: number;
+    minHeight: number;
+    margin: number;
+    label: null;
+    ports: never[];
+    look: import("./diagram-config").NodeShapedLook;
+};
+export declare class DiagramSection extends DiagramElement {
+    node?: DiagramNode;
+    label?: DiagramField;
+    ports: DiagramPort[];
+    coords: Point;
+    width: number;
+    height: number;
+    get name(): string;
+    set name(name: string);
+    constructor(model: DiagramModel, node: DiagramNode | undefined, coords: Point, width: number, height: number, id?: string);
+    updateInView(): void;
+    getClosestPortToPoint(coords: Point): DiagramPort | undefined;
+    getIncomingConnections(): DiagramConnection[];
+    getOutgoingConnections(): DiagramConnection[];
+    getConnections(): DiagramConnection[];
+    move(coords: Point): void;
+    stretch(direction: Side, distance: number): void;
+}

package/lib/diagram-editor/diagram/layout/adjacency-layout.d.ts

@@ -0,0 +1,8 @@
+import { DiagramModel } from '../diagram-model';
+import { DiagramLayout } from './diagram-layout';
+/**
+ * A layout which places adjacent nodes close by, placing nodes in order according to depth first search.
+ */
+export declare class AdjacencyLayout implements DiagramLayout {
+    apply(model: DiagramModel): DiagramModel;
+}

package/lib/diagram-editor/diagram/layout/breadth-adjacency-layout.d.ts

@@ -0,0 +1,8 @@
+import { DiagramModel } from '../diagram-model';
+import { DiagramLayout } from './diagram-layout';
+/**
+ * A layout which places adjacent nodes close by, placing nodes in order according to breadth first search.
+ */
+export declare class BreadthAdjacencyLayout implements DiagramLayout {
+    apply(model: DiagramModel): DiagramModel;
+}

package/lib/diagram-editor/diagram/layout/breadth-layout.d.ts

@@ -0,0 +1,9 @@
+import { DiagramModel } from '../diagram-model';
+import { DiagramLayout } from './diagram-layout';
+/**
+ * A layout which arranges the nodes by a breadth first search system,
+ * according to their distance to the first node in the list.
+ */
+export declare class BreadthLayout implements DiagramLayout {
+    apply(model: DiagramModel): DiagramModel;
+}

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

@@ -0,0 +1,10 @@
+import { DiagramModel } from '../diagram-model';
+export interface DiagramLayout {
+    /**
+     * Rearranges the diagram elements of the given model according to a layout algorithm.
+     */
+    apply(model: DiagramModel): DiagramModel;
+}
+export declare const layouts: {
+    [key: string]: DiagramLayout;
+};

package/lib/diagram-editor/diagram/layout/force-layout.d.ts

@@ -0,0 +1,8 @@
+import { DiagramModel } from '../diagram-model';
+import { DiagramLayout } from './diagram-layout';
+/**
+ * A layout which attracts connected nodes and repels unconnected nodes.
+ */
+export declare class ForceLayout implements DiagramLayout {
+    apply(model: DiagramModel): DiagramModel;
+}

package/lib/diagram-editor/diagram/layout/horizontal-layout.d.ts

@@ -0,0 +1,8 @@
+import { DiagramModel } from '../diagram-model';
+import { DiagramLayout } from './diagram-layout';
+/**
+ * A layout which arranges all the nodes in a horizontal line.
+ */
+export declare class HorizontalLayout implements DiagramLayout {
+    apply(model: DiagramModel): DiagramModel;
+}

package/lib/diagram-editor/diagram/layout/priority-layout.d.ts

@@ -0,0 +1,8 @@
+import { DiagramModel } from '../diagram-model';
+import { DiagramLayout } from './diagram-layout';
+/**
+ * A layout which arranges the nodes by their priority first.
+ */
+export declare class PriorityLayout implements DiagramLayout {
+    apply(model: DiagramModel): DiagramModel;
+}

package/lib/diagram-editor/diagram/layout/vertical-layout.d.ts

@@ -0,0 +1,8 @@
+import { DiagramModel } from '../diagram-model';
+import { DiagramLayout } from './diagram-layout';
+/**
+ * A layout which arranges all the nodes in a vertical line.
+ */
+export declare class VerticalLayout implements DiagramLayout {
+    apply(model: DiagramModel): DiagramModel;
+}

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

@@ -0,0 +1,27 @@
+import { AfterViewInit, ElementRef, OnInit } from '@angular/core';
+import { DiagramButtonsComponent } from '../diagram-buttons/diagram-buttons.component';
+import { DiagramConfig } from '../diagram-editor/diagram/diagram-config';
+import { Canvas } from '../interfaces/canvas';
+import { DiagramEditor } from '../interfaces/diagram-editor';
+import { PaletteComponent } from '../palette/palette.component';
+import { PropertyEditorComponent } from '../property-editor/property-editor.component';
+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";
+export declare class DiagramEditorComponent implements AfterViewInit, DiagramEditor, OnInit {
+    private configurationService;
+    private canvasProvider;
+    appendTo: ElementRef<HTMLDivElement>;
+    diagramButtons: DiagramButtonsComponent;
+    palette: PaletteComponent;
+    propertyEditor: PropertyEditorComponent;
+    get config(): DiagramConfig;
+    get canvas(): Canvas;
+    Corner: typeof Corner;
+    constructor(configurationService: DagaConfigurationService, canvasProvider: CanvasProviderService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiagramEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DiagramEditorComponent, "daga-diagram-editor", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,5 @@
+export interface DiagramError {
+    message: string;
+    elementId?: string;
+    propertyNames?: string[];
+}

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

@@ -0,0 +1,8 @@
+import { DiagramModel } from '../diagram-editor/diagram/diagram-model';
+import { DiagramError } from './diagram-error';
+export interface DiagramValidator {
+    /**
+     * Checks the model and returns any list of errors the diagram has.
+     */
+    validate(model: DiagramModel): DiagramError[];
+}

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

@@ -0,0 +1,21 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import * as d3 from 'd3';
+import { Canvas } from '../interfaces/canvas';
+import { CanvasProviderService } from '../services/canvas-provider.service';
+import { Side } from '../util/svg-util';
+import { DiagramError } from './diagram-error';
+import * as i0 from "@angular/core";
+export declare class ErrorsComponent implements AfterViewInit {
+    private canvasProvider;
+    get canvas(): Canvas;
+    errorsContainer: ElementRef<HTMLDivElement>;
+    errors: DiagramError[];
+    Side: typeof Side;
+    constructor(canvasProvider: CanvasProviderService);
+    ngAfterViewInit(): void;
+    selectPanel(): d3.Selection<d3.BaseType, unknown, null, unknown>;
+    validate(): void;
+    showError(error: DiagramError): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorsComponent, "daga-errors", never, {}, {}, never, never, true, never>;
+}