ngx-workflow 0.0.1

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "ngx-workflow",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": ">=17.0.0",
+    "@angular/core": ">=17.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0",
+    "elkjs": "^0.9.2",
+    "uuid": "^9.0.1"
+  },
+  "keywords": [
+    "angular",
+    "flow",
+    "diagram",
+    "flowchart",
+    "node-based",
+    "editor",
+    "svg",
+    "signals",
+    "react-flow",
+    "ngx"
+  ],
+  "author": "Abdul Kyume",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/abdulkyume/ngx-workflow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/abdulkyume/ngx-workflowflow/issues"
+  },
+  "homepage": "https://github.com/abdulkyume/ngx-workflow#readme",
+  "module": "fesm2022/ngx-workflow.mjs",
+  "typings": "types/ngx-workflow.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/ngx-workflow.d.ts",
+      "default": "./fesm2022/ngx-workflow.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/types/ngx-workflow.d.ts

@@ -0,0 +1,482 @@
+import * as i0 from '@angular/core';
+import { WritableSignal, ElementRef, EventEmitter, Type, OnInit, OnDestroy, OnChanges, Signal, Renderer2, NgZone, ChangeDetectorRef, SimpleChanges, InjectionToken } from '@angular/core';
+import * as i1 from '@angular/common';
+
+interface XYPosition {
+    x: number;
+    y: number;
+}
+interface Dimensions {
+    width: number;
+    height: number;
+}
+interface Node<T = any> {
+    id: string;
+    position: XYPosition;
+    data?: T;
+    type?: string;
+    width?: number;
+    height?: number;
+    selected?: boolean;
+    dragging?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    class?: string;
+    style?: Record<string, string>;
+    parentId?: string;
+    expanded?: boolean;
+    extent?: 'parent';
+    label?: string;
+    highlighted?: boolean;
+    dimmed?: boolean;
+}
+
+type MarkerType = 'arrow' | 'arrowclosed' | 'dot';
+interface Edge<T = any> {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+    type?: 'bezier' | 'straight' | 'step' | 'smoothstep' | 'smart';
+    animated?: boolean;
+    style?: {
+        [key: string]: any;
+    };
+    selected?: boolean;
+    label?: string;
+    labelStyle?: {
+        [key: string]: any;
+    };
+    labelBgStyle?: {
+        [key: string]: any;
+    };
+    labelBgPadding?: [number, number];
+    labelBgBorderRadius?: number;
+    markerStart?: MarkerType | string;
+    markerEnd?: MarkerType | string;
+    data?: T;
+}
+interface TempEdge$1 extends Edge {
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+}
+
+interface Viewport {
+    x: number;
+    y: number;
+    zoom: number;
+}
+
+interface DiagramState {
+    nodes: Node[];
+    edges: Edge[];
+    viewport: Viewport;
+}
+interface AlignmentGuide {
+    type: 'horizontal' | 'vertical';
+    position: number;
+    start: number;
+    end: number;
+}
+
+declare class UndoRedoService {
+    private undoStack;
+    private redoStack;
+    constructor();
+    saveState(currentState: DiagramState): void;
+    undo(currentState: DiagramState): DiagramState | undefined;
+    redo(currentState: DiagramState): DiagramState | undefined;
+    canUndo: i0.Signal<boolean>;
+    canRedo: i0.Signal<boolean>;
+    clearStacks(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UndoRedoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UndoRedoService>;
+}
+
+interface Connection {
+    source: string;
+    sourceHandle?: string;
+    target: string;
+    targetHandle?: string;
+}
+interface TempEdge extends Edge {
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+}
+declare class DiagramStateService {
+    private undoRedoService;
+    readonly nodes: WritableSignal<Node[]>;
+    readonly edges: WritableSignal<Edge[]>;
+    readonly tempEdges: WritableSignal<TempEdge[]>;
+    readonly viewport: WritableSignal<Viewport>;
+    readonly alignmentGuides: WritableSignal<AlignmentGuide[]>;
+    readonly searchQuery: WritableSignal<string>;
+    readonly filterType: WritableSignal<string | null>;
+    readonly containerDimensions: WritableSignal<{
+        width: number;
+        height: number;
+    }>;
+    readonly selectedNodes: i0.Signal<Node<any>[]>;
+    readonly selectedEdges: i0.Signal<Edge<any>[]>;
+    readonly viewNodes: i0.Signal<{
+        highlighted: any;
+        dimmed: boolean;
+        id: string;
+        position: XYPosition;
+        data?: any;
+        type?: string;
+        width?: number;
+        height?: number;
+        selected?: boolean;
+        dragging?: boolean;
+        draggable?: boolean;
+        resizable?: boolean;
+        minWidth?: number;
+        minHeight?: number;
+        maxWidth?: number;
+        maxHeight?: number;
+        class?: string;
+        style?: Record<string, string>;
+        parentId?: string;
+        expanded?: boolean;
+        extent?: "parent";
+        label?: string;
+    }[]>;
+    readonly visibleNodes: i0.Signal<{
+        highlighted: any;
+        dimmed: boolean;
+        id: string;
+        position: XYPosition;
+        data?: any;
+        type?: string;
+        width?: number;
+        height?: number;
+        selected?: boolean;
+        dragging?: boolean;
+        draggable?: boolean;
+        resizable?: boolean;
+        minWidth?: number;
+        minHeight?: number;
+        maxWidth?: number;
+        maxHeight?: number;
+        class?: string;
+        style?: Record<string, string>;
+        parentId?: string;
+        expanded?: boolean;
+        extent?: "parent";
+        label?: string;
+    }[]>;
+    readonly lodLevel: i0.Signal<"low" | "medium" | "high">;
+    el: ElementRef<HTMLElement | SVGSVGElement> | undefined;
+    readonly dragEnd: EventEmitter<Node<any>>;
+    readonly nodesChange: EventEmitter<Node<any>[]>;
+    readonly edgesChange: EventEmitter<Edge<any>[]>;
+    readonly viewportChange: EventEmitter<Viewport>;
+    readonly nodeClick: EventEmitter<Node<any>>;
+    readonly edgeClick: EventEmitter<Edge<any>>;
+    readonly connect: EventEmitter<Connection>;
+    readonly dragStart: EventEmitter<Node<any>>;
+    private nodeUpdates$;
+    private edgeUpdates$;
+    private viewportUpdates$;
+    constructor(undoRedoService: UndoRedoService);
+    private getCurrentState;
+    getDiagramState(): DiagramState;
+    /**
+     * Replace the entire diagram state (nodes, edges, viewport) with the given state.
+     * Used for importing diagram JSON.
+     */
+    setDiagramState(state: DiagramState): void;
+    private applyState;
+    undo(): void;
+    redo(): void;
+    onResizeStart(node: Node): void;
+    onResizeEnd(node: Node): void;
+    addEdge(edge: Edge): void;
+    updateEdge(id: string, changes: Partial<Edge>): void;
+    removeEdge(id: string): void;
+    addTempEdge(edge: TempEdge): void;
+    updateTempEdgeTarget(id: string, targetPosition: XYPosition): void;
+    setViewport(viewport: Partial<Viewport>): void;
+    selectNodes(nodeIds: string[], multi?: boolean): void;
+    clearSelection(): void;
+    selectAll(): void;
+    multiSelect(nodeId: string): void;
+    deleteSelectedElements(): void;
+    alignNodes(alignment: 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom'): void;
+    distributeNodes(distribution: 'horizontal' | 'vertical'): void;
+    batchUpdateNodes(updatedNodes: Node[]): void;
+    batchUpdateEdges(updatedEdges: Edge[]): void;
+    batchUpdateViewport(updatedViewport: Viewport): void;
+    onNodeClick(node: Node): void;
+    onEdgeClick(edge: Edge): void;
+    onDragStart(node: Node): void;
+    onDragEnd(node: Node): void;
+    private clipboard;
+    copy(): void;
+    paste(): void;
+    cut(): void;
+    duplicate(): void;
+    groupNodes(nodeIds: string[]): void;
+    ungroupNodes(groupId: string): void;
+    addNode(node: Node): void;
+    removeNode(id: string): void;
+    updateNode(id: string, changes: Partial<Node>): void;
+    resizeNode(id: string, width: number, height: number, position?: XYPosition): void;
+    toggleGroup(groupId: string): void;
+    moveNode(id: string, newPosition: XYPosition): void;
+    private moveChildren;
+    moveNodes(moves: {
+        id: string;
+        position: XYPosition;
+    }[]): void;
+    setSearchQuery(query: string): void;
+    setFilterType(type: string | null): void;
+    setZoom(zoom: number): void;
+    setContainerDimensions(dimensions: {
+        width: number;
+        height: number;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiagramStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DiagramStateService>;
+}
+
+type NodeComponentType = Type<{
+    node: Node;
+}>;
+type EdgeComponentType = Type<{
+    edge: Edge;
+}>;
+
+declare class DiagramComponent implements OnInit, OnDestroy, OnChanges {
+    el: ElementRef<HTMLElement>;
+    private renderer;
+    private ngZone;
+    private cdRef;
+    diagramStateService: DiagramStateService;
+    nodeTypes: Record<string, NodeComponentType> | null;
+    svgRef: ElementRef<SVGSVGElement>;
+    initialNodes: Node[];
+    initialEdges: Edge[];
+    initialViewport?: Viewport;
+    showZoomControls: boolean;
+    showMinimap: boolean;
+    showBackground: boolean;
+    backgroundVariant: 'dots' | 'lines' | 'cross';
+    backgroundGap: number;
+    backgroundSize: number;
+    backgroundColor: string;
+    backgroundBgColor: string;
+    nodeClick: EventEmitter<Node<any>>;
+    edgeClick: EventEmitter<Edge<any>>;
+    connect: EventEmitter<{
+        source: string;
+        sourceHandle?: string;
+        target: string;
+        targetHandle?: string;
+    }>;
+    nodesChange: EventEmitter<Node<any>[]>;
+    edgesChange: EventEmitter<Edge<any>[]>;
+    nodeDoubleClick: EventEmitter<Node<any>>;
+    selectedNodeForEditing: Node | null;
+    viewport: WritableSignal<Viewport>;
+    nodes: WritableSignal<Node[]>;
+    viewNodes: Signal<Node[]>;
+    filteredNodes: Signal<Node[]>;
+    edges: WritableSignal<Edge[]>;
+    tempEdges: WritableSignal<TempEdge$1[]>;
+    alignmentGuides: Signal<AlignmentGuide[]>;
+    Math: Math;
+    private _pathFinder;
+    private pathCache;
+    private dragAnimationFrameId;
+    private unlistenPointerMove;
+    private unlistenPointerUp;
+    private unlistenPointerLeave;
+    private pathPointsCache;
+    private isPanning;
+    private lastPanPosition;
+    private subscriptions;
+    isSelecting: boolean;
+    selectionStart: XYPosition;
+    selectionEnd: XYPosition;
+    private isDraggingNode;
+    private draggingNode;
+    private draggingNodes;
+    private startNodePosition;
+    private startNodePositions;
+    private startPointerPosition;
+    private isConnecting;
+    private currentPreviewEdgeId;
+    private currentTargetHandle;
+    private connectingSourceNodeId;
+    private connectingSourceHandleId;
+    private isResizing;
+    private resizingNode;
+    private resizeHandle;
+    private startResizePosition;
+    private startNodeDimensions;
+    private isUpdatingEdge;
+    private updatingEdge;
+    private updatingEdgeHandle;
+    editingEdgeId: string | null;
+    private updatePathFinder;
+    onEdgeDoubleClick(event: MouseEvent, edge: Edge): void;
+    onNodeDoubleClick(event: MouseEvent, node: Node): void;
+    onDiagramDoubleClick(event: MouseEvent): void;
+    closeSidebar(): void;
+    onPropertiesChange(changes: Partial<Node>): void;
+    updateEdgeLabel(edge: Edge, newLabel: string): void;
+    onEdgeLabelBlur(): void;
+    defaultNodeWidth: number;
+    defaultNodeHeight: number;
+    connectionValidator?: (sourceNodeId: string, targetNodeId: string) => boolean;
+    nodesResizable: boolean;
+    private isValidConnection;
+    constructor(el: ElementRef<HTMLElement>, // Host element
+    renderer: Renderer2, ngZone: NgZone, cdRef: ChangeDetectorRef, diagramStateService: DiagramStateService, nodeTypes: Record<string, NodeComponentType> | null);
+    get nodeTypeKeys(): string[];
+    private nodes$;
+    private resizeObserver;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get lodLevel(): string;
+    ngOnChanges(changes: SimpleChanges): void;
+    get transform(): string;
+    trackByNodeId(index: number, node: Node): string;
+    trackByEdgeId(index: number, edge: Edge): string;
+    onDeleteKeyPress(event: any): void;
+    onUndoKeyPress(event: any): void;
+    onRedoKeyPress(event: any): void;
+    onCopyKeyPress(event: any): void;
+    onPasteKeyPress(event: any): void;
+    onCutKeyPress(event: any): void;
+    onDuplicateKeyPress(event: any): void;
+    onGroupKeyPress(event: any): void;
+    onUngroupKeyPress(event: any): void;
+    toggleGroup(event: Event, node: Node): void;
+    private isInputActive;
+    onWheel(event: WheelEvent): void;
+    onPointerDown(event: PointerEvent): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerUp(event: PointerEvent): void;
+    onPointerLeave(event: PointerEvent): void;
+    private startConnecting;
+    private updateConnection;
+    private finishConnecting;
+    private clearTargetHandleHighlight;
+    private startDraggingNode;
+    private dragNode;
+    private stopDraggingNode;
+    private startResizing;
+    private resize;
+    private stopResizing;
+    startUpdatingEdge(event: PointerEvent, edge: Edge, handleType: 'source' | 'target'): void;
+    private updateEdge;
+    private stopUpdatingEdge;
+    private startPanning;
+    private pan;
+    private stopPanning;
+    private startSelecting;
+    private updateSelection;
+    private stopSelecting;
+    private getDiagramCoordinates;
+    private performLassoSelection;
+    getEdgePath(edge: Edge | TempEdge$1, isTemporary?: boolean): string;
+    getMarkerUrl(marker: string | undefined): string | null;
+    getEdgeLabelPosition(edge: Edge): XYPosition;
+    onEdgeClick(event: MouseEvent, edge: Edge): void;
+    getCustomNodeComponent(type: string | undefined): NodeComponentType | null;
+    zoomIn(): void;
+    zoomOut(): void;
+    resetZoom(): void;
+    fitView(): void;
+    /**
+     * Returns the current state of the diagram (nodes, edges, viewport).
+     */
+    getDiagramState(): DiagramState;
+    /**
+     * Sets the state of the diagram.
+     */
+    setDiagramState(state: DiagramState): void;
+    /**
+     * Exports the diagram as an SVG file.
+     * @param fileName The name of the file to download (default: 'diagram.svg')
+     * @param download Whether to trigger a download (default: true)
+     * @returns The SVG string
+     */
+    exportToSVG(fileName?: string, download?: boolean): string;
+    /**
+     * Exports the diagram as a PNG image.
+     * @param fileName The name of the file to download (default: 'diagram.png')
+     * @param download Whether to trigger a download (default: true)
+     * @returns A promise that resolves to the data URL of the PNG
+     */
+    exportToPNG(fileName?: string, download?: boolean): Promise<string>;
+    /**
+     * Exports the diagram state as a JSON file.
+     * @param fileName The name of the file to download (default: 'diagram.json')
+     */
+    exportToJSON(fileName?: string): void;
+    /**
+     * Triggers the file input to select a JSON file for import.
+     */
+    triggerImport(): void;
+    /**
+     * Handles the file selection for import.
+     */
+    onFileSelected(event: Event): void;
+    private downloadFile;
+    onSearch(event: Event): void;
+    onFilterType(event: Event): void;
+    onZoomChange(zoom: number): void;
+    onMinimapViewportChange(viewport: Viewport): void;
+    getEdgeHandlePosition(edge: Edge, type: 'source' | 'target'): XYPosition;
+    onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiagramComponent, [null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DiagramComponent, "ngx-workflow-diagram", never, { "initialNodes": { "alias": "initialNodes"; "required": false; }; "initialEdges": { "alias": "initialEdges"; "required": false; }; "initialViewport": { "alias": "initialViewport"; "required": false; }; "showZoomControls": { "alias": "showZoomControls"; "required": false; }; "showMinimap": { "alias": "showMinimap"; "required": false; }; "showBackground": { "alias": "showBackground"; "required": false; }; "backgroundVariant": { "alias": "backgroundVariant"; "required": false; }; "backgroundGap": { "alias": "backgroundGap"; "required": false; }; "backgroundSize": { "alias": "backgroundSize"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "backgroundBgColor": { "alias": "backgroundBgColor"; "required": false; }; "connectionValidator": { "alias": "connectionValidator"; "required": false; }; "nodesResizable": { "alias": "nodesResizable"; "required": false; }; }, { "nodeClick": "nodeClick"; "edgeClick": "edgeClick"; "connect": "connect"; "nodesChange": "nodesChange"; "edgesChange": "edgesChange"; "nodeDoubleClick": "nodeDoubleClick"; }, never, never, true, never>;
+}
+
+declare class RoundedRectNodeComponent {
+    node: Node;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoundedRectNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RoundedRectNodeComponent, "ngx-workflow-rounded-rect-node", never, { "node": { "alias": "node"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgxWorkflowModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxWorkflowModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxWorkflowModule, never, [typeof i1.CommonModule, typeof DiagramComponent, typeof RoundedRectNodeComponent], [typeof DiagramComponent, typeof RoundedRectNodeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxWorkflowModule>;
+}
+
+declare class LayoutService {
+    private elk;
+    constructor();
+    applyElkLayout(nodes: Node[], edges: Edge[], options?: any): Promise<Node[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutService>;
+}
+
+declare const NGX_WORKFLOW_NODE_TYPES: InjectionToken<Record<string, NodeComponentType>>;
+
+declare const NGX_WORKFLOW_EDGE_TYPES: InjectionToken<Record<string, EdgeComponentType>>;
+
+declare function getStraightPath(source: XYPosition, target: XYPosition): string;
+declare function getBezierPath(source: XYPosition, target: XYPosition): string;
+declare function getStepPath(source: XYPosition, target: XYPosition): string;
+declare function getSelfLoopPath(source: XYPosition, handle?: string, offset?: number): string;
+declare function getSmartEdgePath(path: XYPosition[]): string;
+declare function getPolylineMidpoint(points: XYPosition[]): XYPosition;
+
+export { DiagramComponent, DiagramStateService, LayoutService, NGX_WORKFLOW_EDGE_TYPES, NGX_WORKFLOW_NODE_TYPES, NgxWorkflowModule, RoundedRectNodeComponent, UndoRedoService, getBezierPath, getPolylineMidpoint, getSelfLoopPath, getSmartEdgePath, getStepPath, getStraightPath };
+export type { AlignmentGuide, DiagramState, Dimensions, Edge, EdgeComponentType, MarkerType, Node, NodeComponentType, TempEdge$1 as TempEdge, Viewport, XYPosition };
+//# sourceMappingURL=ngx-workflow.d.ts.map

package/types/ngx-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngx-workflow.d.ts","sources":["../../../libs/ngx-workflow/src/lib/models/node.model.ts","../../../libs/ngx-workflow/src/lib/models/edge.model.ts","../../../libs/ngx-workflow/src/lib/models/viewport.model.ts","../../../libs/ngx-workflow/src/lib/models/diagram.model.ts","../../../libs/ngx-workflow/src/lib/services/undo-redo.service.ts","../../../libs/ngx-workflow/src/lib/services/diagram-state.service.ts","../../../libs/ngx-workflow/src/lib/types/component-types.ts","../../../libs/ngx-workflow/src/lib/components/diagram/diagram.component.ts","../../../libs/ngx-workflow/src/lib/components/custom-node/rounded-rect-node.component.ts","../../../libs/ngx-workflow/src/lib/ngx-workflow.module.ts","../../../libs/ngx-workflow/src/lib/services/layout.service.ts","../../../libs/ngx-workflow/src/lib/injection-tokens/node-types.token.ts","../../../libs/ngx-workflow/src/lib/injection-tokens/edge-types.token.ts","../../../libs/ngx-workflow/src/lib/utils/path-getters.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":["TempEdge","_angular_core"],"mappings":"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"}