@metadev/daga 1.0.0

package/lib/interfaces/canvas.d.ts

@@ -0,0 +1,203 @@
+import { Subject } from 'rxjs';
+import { ActionQueue } from '../diagram-editor/diagram/diagram-action';
+import { DiagramConnectionType } from '../diagram-editor/diagram/diagram-connection';
+import { DiagramElement } from '../diagram-editor/diagram/diagram-element';
+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';
+/**
+ * Provides the functionality for the visual representation of the elements of a model.
+ */
+export interface Canvas {
+    /**
+     * Parent component of the diagram.
+     */
+    parentComponent: DiagramEditor;
+    /**
+     * Object that contains the data of the elements of the diagram.
+     */
+    model: DiagramModel;
+    /**
+     * Background color of the diagram.
+     */
+    color: string;
+    /**
+     * Distance between the grid points of the diagram.
+     */
+    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.
+     */
+    snapToGrid: boolean;
+    /**
+     * If true, new connections should have the type that makes most sense even if it's not the currently chosen type.
+     */
+    guessConnectionType: boolean;
+    /**
+     * When a new connection is made, it should have this type.
+     */
+    connectionType?: DiagramConnectionType;
+    /**
+     * Elements below the priority threshold shouldn't be displayed.
+     */
+    priorityThreshold?: number;
+    /**
+     * Possible values that the priority threshold can take.
+     */
+    priorityThresholds: number[];
+    /**
+     * Identifier of the current layout format used by the diagram.
+     */
+    layoutFormat?: string;
+    /**
+     * The list of validators used to check for errors in this canvas.
+     */
+    validators: DiagramValidator[];
+    /**
+     * The queue of actions used to keep track of what actions can be undone or redone.
+     */
+    actionQueue: ActionQueue;
+    /**
+     * Subject for tracking when the canvas' view is initialized.
+     */
+    viewInitialized$: Subject<void>;
+    /**
+     * Subject for tracking when validators are added to the canvas.
+     */
+    validatorChanges$: Subject<void>;
+    /**
+     * Subject for tracking changes in the diagram.
+     * Used to detect if there have been changes over a period of time.
+     */
+    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.
+     */
+    diagramImportantChanges$: Subject<void>;
+    /**
+     * Initializes the view of the diagram.
+     */
+    initView(appendTo: HTMLElement): void;
+    /**
+     * Increases the zoom level by the given factor.
+     * @param zoom A factor of zoom.
+     */
+    zoomBy(zoom: number): void;
+    /**
+     * Changes the zoom level to a given level.
+     * @param zoom A level of zoom.
+     */
+    zoomTo(zoom: number): void;
+    /**
+     * Translates the view by the given amount.
+     * @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.
+     * @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.
+     */
+    center(): void;
+    /**
+     * Get the closest grid point to the given point.
+     * @param point A point.
+     */
+    getClosestGridPoint(point: Point): Point;
+    /**
+     * Get the location of the pointer in the given event relative to the canvas.
+     * @param event A MouseEvent.
+     */
+    getPointerLocationRelativeToCanvas(event: MouseEvent): Point;
+    /**
+     * Get the location of the pointer in the given event relative to the body.
+     * @param event A MouseEvent.
+     */
+    getPointerLocationRelativeToBody(event: MouseEvent): Point;
+    /**
+     * Adds a validator to the list of validators of the diagram.
+     */
+    addValidator(validator: DiagramValidator): void;
+    /**
+     * Removes a validator from the list of validators of the diagram.
+     */
+    removeValidator(validator: DiagramValidator): void;
+    /**
+     * Update the view of the canvas to show the current state of the model.
+     */
+    updateModelInView(): void;
+    /**
+     * Update the view of the canvas to show the current state of the nodes.
+     */
+    updateNodesInView(...ids: string[]): void;
+    /**
+     * Update the view of the canvas to show the current state of the sections.
+     */
+    updateSectionsInView(...ids: string[]): void;
+    /**
+     * Update the view of the canvas to show the current state of the ports.
+     */
+    updatePortsInView(...ids: string[]): void;
+    /**
+     * Update the view of the canvas to show the current state of the connections.
+     */
+    updateConnectionsInView(...ids: string[]): void;
+    /**
+     * Update the view of the canvas to show the current state of the fields.
+     */
+    updateFieldsInView(...ids: string[]): void;
+    /**
+     * Get the d3 Selection containing the view of all the elements in the canvas.
+     */
+    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.
+     * @param element A diagram element.
+     */
+    highlight(element: DiagramElement): void;
+    /**
+     * Unhighlights all diagram elements.
+     */
+    unhighlight(): void;
+    /**
+     * Checks if the given diagram element is in the current user selection.
+     * @param selection A diagram element.
+     */
+    isInUserSelection(selection: DiagramElement): boolean;
+    /**
+     * Adds the given diagram element to the current user selection.
+     * @param selection A diagram element.
+     */
+    addToUserSelection(selection: DiagramElement): void;
+    /**
+     * Removes the given diagram element from the current user selection.
+     * @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.
+     * @param selection A diagram element.
+     */
+    toggleUserSelection(selection: DiagramElement): void;
+    /**
+     * Removes all elements from the current user selection.
+     */
+    clearUserSelection(): void;
+    /**
+     * Stops all unfinished user actions to ensure there are no unfinished actions before performing a different action.
+     */
+    cancelAllUserActions(): void;
+    /**
+     * Sets the diagram element whose ValueSet is being displayed in the value set editor.
+     */
+    setPropertyEditorSelection(selection?: DiagramElement): void;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * General canvas commands for zooming and filtering used by the buttons of the diagram's user interface.
+ */
+export interface DiagramButtons {
+    /**
+     * Increase the zoom level of the diagram by this component's zoom rate.
+     */
+    zoomIn(): void;
+    /**
+     * Decrease the zoom level of the diagram by this component's zoom rate.
+     */
+    zoomOut(): void;
+    /**
+     * Center the view of the diagram.
+     */
+    center(): void;
+    /**
+     * Apply the diagram's current layout if applicable.
+     */
+    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.
+     */
+    filter(): void;
+    /**
+     * Undo the latest user change in the diagram.
+     */
+    undo(): void;
+    /**
+     * Redo the latest undone user change in the diagram.
+     */
+    redo(): void;
+}

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

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

package/lib/interfaces/palette.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Exposes the commands of the palette component.
+ */
+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.
+     */
+    refreshPalette(): void;
+}

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

@@ -0,0 +1,19 @@
+import { ValueSet } from '../diagram-editor/diagram/diagram-property';
+/**
+ * Exposes the commands of the property editor component.
+ */
+export interface PropertyEditor {
+    /**
+     * Title of the ValueSet displayed in the UI.
+     */
+    title?: string;
+    /**
+     * ValueSet being edited in this component by the user.
+     */
+    valueSet?: ValueSet;
+    /**
+     * Highlight the property given by the list of keys it can be found under.
+     * @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

@@ -0,0 +1,25 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { RadioItem } from '@metadev/lux';
+import { Property, Type, ValueSet } from '../diagram-editor/diagram/diagram-property';
+import { Canvas } from '../interfaces/canvas';
+import { CanvasProviderService } from '../services/canvas-provider.service';
+import * as i0 from "@angular/core";
+export declare class ObjectEditorComponent {
+    private cdr;
+    private canvasProvider;
+    get canvas(): Canvas;
+    _valueSet?: ValueSet;
+    get valueSet(): ValueSet | undefined;
+    set valueSet(valueSet: ValueSet | undefined);
+    /** How many object-editors are parents of this object-editor */
+    depth: number;
+    Type: typeof Type;
+    booleanRadioItems: RadioItem[];
+    constructor(cdr: ChangeDetectorRef, canvasProvider: CanvasProviderService);
+    displayProperty(property: Property | Event | string | undefined): void;
+    hideProperty(property: Property | Event | string | undefined): void;
+    setValue(property: Property, value: unknown): void;
+    convertDate(date: string | number | Date): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectEditorComponent, "daga-object-editor", never, { "valueSet": { "alias": "valueSet"; "required": false; }; "depth": { "alias": "depth"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,31 @@
+import { AfterContentInit, AfterViewInit, ElementRef } from '@angular/core';
+import * as d3 from 'd3';
+import { PaletteConfig } from '../diagram-editor/diagram/diagram-config';
+import { Canvas } from '../interfaces/canvas';
+import { Palette } from '../interfaces/palette';
+import { CanvasProviderService } from '../services/canvas-provider.service';
+import { Corner } from '../util/svg-util';
+import * as i0 from "@angular/core";
+export declare class PaletteComponent implements AfterContentInit, AfterViewInit, Palette {
+    private canvasProvider;
+    get canvas(): Canvas;
+    panel: ElementRef<HTMLDivElement>;
+    palettes: PaletteConfig[];
+    currentPalette: PaletteConfig;
+    currentCategory: string;
+    location: Corner;
+    private priorityThreshold?;
+    constructor(canvasProvider: CanvasProviderService);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    refreshPalette(): void;
+    switchPalette(palette: PaletteConfig): void;
+    selectPanel(): d3.Selection<HTMLDivElement, unknown, null, undefined>;
+    selectPalette(): d3.Selection<HTMLDivElement, unknown, null, undefined>;
+    private appendCategories;
+    private appendTemplate;
+    private appendNodeTemplate;
+    private appendConnectionTemplate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaletteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaletteComponent, "daga-palette", never, { "palettes": { "alias": "palettes"; "required": false; }; "currentPalette": { "alias": "currentPalette"; "required": false; }; "currentCategory": { "alias": "currentCategory"; "required": false; }; "location": { "alias": "location"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,18 @@
+import { ChangeDetectorRef, ElementRef } from '@angular/core';
+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";
+export declare class PropertyEditorComponent implements PropertyEditor {
+    private cdr;
+    panel: ElementRef<HTMLDivElement>;
+    location: Corner;
+    title?: string;
+    _valueSet: ValueSet | undefined;
+    get valueSet(): ValueSet | undefined;
+    set valueSet(valueSet: ValueSet | undefined);
+    constructor(cdr: ChangeDetectorRef);
+    highlightProperty(...propertyNames: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PropertyEditorComponent, "daga-property-editor", never, { "location": { "alias": "location"; "required": false; }; "valueSet": { "alias": "valueSet"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,15 @@
+import { DiagramConfig } from '../diagram-editor/diagram/diagram-config';
+import { Canvas } from '../interfaces/canvas';
+import { DiagramEditor } from '../interfaces/diagram-editor';
+import * as i0 from "@angular/core";
+/**
+ * A provider for the {@link Canvas} associated with a {@link DiagramComponent} context.
+ */
+export declare class CanvasProviderService {
+    private _canvas;
+    initCanvas(parentComponent: DiagramEditor, config: DiagramConfig): void;
+    initCanvasView(appendTo: HTMLElement): void;
+    getCanvas(): Canvas;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanvasProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CanvasProviderService>;
+}

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

@@ -0,0 +1,12 @@
+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.
+ */
+export declare class DagaConfigurationService {
+    private _config;
+    init(config: DiagramConfig): void;
+    getConfig(): DiagramConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DagaConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DagaConfigurationService>;
+}

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

@@ -0,0 +1,20 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TextListEditorComponent {
+    private cdr;
+    private _value;
+    set value(val: string[]);
+    get value(): string[];
+    valueInput: string;
+    disabled: boolean;
+    valueChange: EventEmitter<string[]>;
+    constructor(cdr: ChangeDetectorRef);
+    getValueFromEvent(event: Event): string;
+    removeFromValue(index: number): void;
+    editFromValue(item: string, index: number): void;
+    addToValue(): void;
+    clearInput(): void;
+    onKeyUp(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextListEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextListEditorComponent, "daga-text-list-editor", never, { "value": { "alias": "value"; "required": false; }; "valueInput": { "alias": "valueInput"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,29 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TextMapEditorComponent {
+    private cdr;
+    private _value;
+    set value(val: {
+        [name: string]: string;
+    });
+    get value(): {
+        [name: string]: string;
+    };
+    keyInput: string;
+    valueInput: string;
+    disabled: boolean;
+    valueChange: EventEmitter<{
+        [name: string]: string;
+    }>;
+    constructor(cdr: ChangeDetectorRef);
+    getValueFromEvent(event: Event): string;
+    removeFromValue(key: string): void;
+    editKey(oldKey: string, newKey: string): void;
+    editValue(key: string, value: string): void;
+    addToValue(): void;
+    clearKeyInput(): void;
+    clearValueInput(): void;
+    onKeyUp(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextMapEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextMapEditorComponent, "daga-text-map-editor", never, { "value": { "alias": "value"; "required": false; }; "keyInput": { "alias": "keyInput"; "required": false; }; "valueInput": { "alias": "valueInput"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,16 @@
+import { Side } from './svg-util';
+export type Point = [number, number];
+export type Line = [Point, Point];
+export type Rectangle = [Point, Point];
+export declare const roundPoint: (point: Point) => Point;
+export declare const between: (coordinate: number, start: number, end: number) => boolean;
+export declare const translateCoordinate: (oldCoordinate: number, oldCoordinates: [number, number], newCoordinates: [number, number]) => number;
+export declare const translatePoint: (oldPoint: Point, oldCoordsX: [number, number], oldCoordsY: [number, number], newCoordsX: [number, number], newCoordsY: [number, number]) => Point;
+export declare const movePoint: (point: Point, direction: Side, distance: number) => Point;
+export declare const equals: (point1: Point, point2: Point) => boolean;
+export declare const distanceBetweenPoints: (point1: Point, point2: Point) => number;
+export declare const lineContainsPoint: (line: Line, point: Point) => boolean;
+export declare const rectangleContainsPoint: (rectangle: Rectangle, point: Point) => boolean;
+export declare const linesIntersect: (line1: Line, line2: Line) => boolean;
+export declare const linesOverlap: (line1: Line, line2: Line) => boolean;
+export declare const lineIntersectsRectangle: (line: Line, rectangle: Rectangle) => boolean;

package/lib/util/events.d.ts

@@ -0,0 +1,53 @@
+/**
+ * User events
+ */
+export declare enum Events {
+    Blur = "blur",
+    Change = "change",
+    Click = "click",
+    DoubleClick = "dblclick",
+    Input = "input",
+    KeyUp = "keyup",
+    MouseMove = "mousemove",
+    MouseOut = "mouseout",
+    MouseOver = "mouseover"
+}
+/**
+ * Keys in keyboard events
+ */
+export declare enum Keys {
+    Alt = "Alt",
+    AltGraph = "AltGraph",
+    ArrowDown = "ArrowDown",
+    ArrowLeft = "ArrowLeft",
+    ArrowRight = "ArrowRight",
+    ArrowUp = "ArrowUp",
+    Backspace = "Backspace",
+    Control = "Control",
+    Delete = "Delete",
+    End = "End",
+    Enter = "Enter",
+    Escape = "Escape",
+    Home = "Home",
+    OS = "OS",
+    PageDown = "PageDown",
+    PageUp = "PageUp",
+    Shift = "Shift",
+    Tab = "Tab"
+}
+/**
+ * Types of events used by D3's drag functionality
+ */
+export declare enum DragEvents {
+    Drag = "drag",
+    Start = "start",
+    End = "end"
+}
+/**
+ * Types of events used by D3's zoom functionality
+ */
+export declare enum ZoomEvents {
+    Zoom = "zoom",
+    Start = "start",
+    End = "end"
+}

package/lib/util/grid.d.ts

@@ -0,0 +1,19 @@
+import { Point } from './canvas-util';
+export declare class Grid<T> {
+    grid: (T | undefined)[][];
+    offsetX: number;
+    offsetY: number;
+    minX(): number;
+    maxX(): number;
+    minY(): number;
+    maxY(): number;
+    width(): number;
+    height(): number;
+    addColumnLeft(): void;
+    addColumnRight(): void;
+    addRowTop(): void;
+    addRowBottom(): void;
+    get(coords: Point): T | undefined;
+    set(coords: Point, value: T | undefined): void;
+    getClosestEmptyCoordinate(coords: Point): [number, number];
+}

package/lib/util/line.d.ts

@@ -0,0 +1,15 @@
+import { Point } from './canvas-util';
+import { Side } from './svg-util';
+export declare enum LineShape {
+    Straight = "straight",
+    Bezier = "bezier",
+    Square = "square"
+}
+export declare enum LineStyle {
+    Solid = "solid",
+    Dashed = "dashed",
+    GappedDashes = "gapped-dashes",
+    Dotted = "dotted"
+}
+export declare const linePath: (shape: LineShape, points: Point[], startDirection?: Side | undefined, endDirection?: Side | undefined, minimumDistanceBeforeTurn?: number) => string;
+export declare const lineStyleDasharray: (style: LineStyle, width: number) => string;

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

@@ -0,0 +1,2 @@
+export declare const removeIfExists: <T>(arr: T[], obj: T) => T[];
+export declare const addIfNotExists: <T>(arr: T[], obj: T) => T[];

package/lib/util/shape.d.ts

@@ -0,0 +1,23 @@
+export declare enum ClosedShape {
+    Ellipse = "ellipse",
+    Empty = "empty",
+    Folder = "folder",
+    Hexagon = "hexagon",
+    Octagon = "octagon",
+    Pill = "pill",
+    Rectangle = "rectangle",
+    Rhombus = "rhombus",
+    RoundedRectangle = "rounded-rectangle",
+    StickyNote = "sticky-note"
+}
+export declare const generalClosedPath: (shape: ClosedShape, x: number, y: number, width: number, height: number) => string;
+export declare const ellipsePath: (x: number, y: number, width: number, height: number) => string;
+export declare const emptyPath: () => string;
+export declare const folderPath: (x: number, y: number, width: number, height: number) => string;
+export declare const hexagonPath: (x: number, y: number, width: number, height: number) => string;
+export declare const octagonPath: (x: number, y: number, width: number, height: number) => string;
+export declare const pillPath: (x: number, y: number, width: number, height: number) => string;
+export declare const rectanglePath: (x: number, y: number, width: number, height: number) => string;
+export declare const rhombusPath: (x: number, y: number, width: number, height: number) => string;
+export declare const roundedRectanglePath: (x: number, y: number, width: number, height: number) => string;
+export declare const stickyNotePath: (x: number, y: number, width: number, height: number) => string;

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

@@ -0,0 +1,22 @@
+export declare enum Side {
+    Bottom = "bottom",
+    Left = "left",
+    Right = "right",
+    Top = "top"
+}
+export declare enum Corner {
+    BottomLeft = "bottom-left",
+    BottomRight = "bottom-right",
+    TopLeft = "top-left",
+    TopRight = "top-right"
+}
+export declare enum VerticalAlign {
+    Top = "top",
+    Center = "center",
+    Bottom = "bottom"
+}
+export declare enum HorizontalAlign {
+    Left = "left",
+    Center = "center",
+    Right = "right"
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@metadev/daga",
+  "description": "Diagramming engine for editing models on the Web. Made by Metadev.",
+  "version": "1.0.0",
+  "author": "Metadev (https://metadev.pro)",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": "git+https://github.com/metadevpro/daga-tutorial.git",
+  "homepage": "https://metadev.pro/products/daga/",
+  "keywords": [
+    "diagramming",
+    "models",
+    "dsl",
+    "mde",
+    "nocode",
+    "lowcode",
+    "visual-editor",
+    "daga",
+    "angular"
+  ],
+  "peerDependencies": {
+    "@angular/common": "^17.0.0",
+    "@angular/core": "^17.0.0",
+    "@angular/forms": "^17.0.0",
+    "@metadev/lux": "^0.28.0",
+    "d3": "^7.8.5",
+    "rxjs": "~7.8.1"
+  },
+  "sideEffects": false,
+  "files": [
+    "/assets",
+    "/fesm2022",
+    "/lib",
+    "index.d.ts",
+    "package.json",
+    "README.md",
+    "LICENSE.md",
+    "Changelog.md"
+  ],
+  "module": "fesm2022/metadev-daga.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/metadev-daga.mjs",
+      "esm": "./esm2022/metadev-daga.mjs",
+      "default": "./fesm2022/metadev-daga.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}