verben-workflow-ui 0.2.2 → 0.2.4

package/lib/components/designer/models/types.d.ts

@@ -48,7 +48,7 @@ export interface Stage extends WorkflowObject {
     isEntryPoint?: boolean;
     isExitPoint?: boolean;
     tags?: Tag[];
-    forms?: string[];
+    form?: string;
     allowMultiSubProcess?: boolean;
     assignmentType?: string;
     subWorkflow?: string;

package/lib/components/workflow-designer/conditions-popup/conditions-popup.component.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from '@angular/core';
+import { WorkflowDesignerState } from '../workflow-designer.state';
+import * as i0 from "@angular/core";
+interface ConnectionCondition {
+    connectionId: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    targetNodeName: string;
+    condition: string;
+    isActive: boolean;
+}
+export declare class ConditionsPopupComponent {
+    private state;
+    visible: boolean;
+    decisionNodeId: string;
+    newConnectionId: string;
+    popupX: number;
+    popupY: number;
+    closed: EventEmitter<any>;
+    saved: EventEmitter<{
+        connectionId: string;
+        condition: string;
+    }>;
+    connectionConditions: ConnectionCondition[];
+    currentCondition: string;
+    constructor(state: WorkflowDesignerState);
+    ngOnInit(): void;
+    loadConnectionConditions(): void;
+    saveCondition(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionsPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConditionsPopupComponent, "lib-conditions-popup", never, { "visible": { "alias": "visible"; "required": false; }; "decisionNodeId": { "alias": "decisionNodeId"; "required": false; }; "newConnectionId": { "alias": "newConnectionId"; "required": false; }; "popupX": { "alias": "popupX"; "required": false; }; "popupY": { "alias": "popupY"; "required": false; }; }, { "closed": "closed"; "saved": "saved"; }, never, never, false, never>;
+}
+export {};

package/lib/components/workflow-designer/decision-popup/decision-popup.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from '@angular/core';
+import { WorkflowDesignerState } from '../workflow-designer.state';
+import * as i0 from "@angular/core";
+interface ConnectionCondition {
+    connectionId: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    condition: string;
+}
+export declare class DecisionPopupComponent {
+    private state;
+    visible: boolean;
+    decisionNodeId: string;
+    popupX: number;
+    popupY: number;
+    closed: EventEmitter<any>;
+    showDuration: boolean;
+    constructor(state: WorkflowDesignerState);
+    getConnectionConditions(): ConnectionCondition[];
+    getTargetNodeName(nodeId: string): string;
+    getDuration(): number;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DecisionPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DecisionPopupComponent, "lib-decision-popup", never, { "visible": { "alias": "visible"; "required": false; }; "decisionNodeId": { "alias": "decisionNodeId"; "required": false; }; "popupX": { "alias": "popupX"; "required": false; }; "popupY": { "alias": "popupY"; "required": false; }; }, { "closed": "closed"; }, never, never, false, never>;
+}
+export {};

package/lib/components/workflow-designer/designer-canvas/designer-canvas.component.d.ts

@@ -23,6 +23,12 @@ export declare class DesignerCanvasComponent implements OnInit {
     showStageDialog: EventEmitter<{
         position: any;
         isFromConnection: boolean;
+        isFromDecision?: boolean;
+        nodeId: string;
+    }>;
+    stagePropertiesUpdated: EventEmitter<{
+        nodeId: string;
+        stageData: Partial<WorkflowStage>;
     }>;
     canvasRef: ElementRef<SVGElement>;
     onWindowMouseUp(event: MouseEvent): void;
@@ -50,11 +56,31 @@ export declare class DesignerCanvasComponent implements OnInit {
         x: number;
         y: number;
     } | null;
+    pendingDecisionConnection: {
+        decisionNodeId: string;
+        swimlaneIndex: number;
+        x: number;
+        y: number;
+    } | null;
     pendingConnectionSourcePoint: ConnectionPoint | null;
     pendingConnectionSourceSwimlaneIndex: number | null;
+    showDecisionConditionDialog: boolean;
+    showConditionsDialog: boolean;
+    activeDecisionNodeId: string;
+    activeConnectionId: string;
+    decisionConditionPopupX: number;
+    decisionConditionPopupY: number;
+    isCreatingStageFromDecision: boolean;
+    pendingDecisionCondition: string;
+    activeStageId: string | null;
+    showStageDialogLocal: boolean;
+    activeStageData: Partial<WorkflowStage>;
     constructor(state: WorkflowDesignerState, dataService: WorkflowDataService);
     ngOnInit(): void;
     onCanvasClick(event: MouseEvent): void;
+    onShowShieldDialog(stageId: string): void;
+    onStageDialogClosed(): void;
+    onStageDialogSaved(stageData: Partial<WorkflowStage>): void;
     updateCanvasSize(): void;
     private getMousePosition;
     showConnectionPoints(nodeId: string, swimlaneIndex: number): void;
@@ -69,12 +95,18 @@ export declare class DesignerCanvasComponent implements OnInit {
     isConnectionPointVisible(nodeId: string): boolean;
     startConnectionDrag(event: MouseEvent, point: ConnectionPoint, swimlaneIndex: number): void;
     onMouseMove: (event: MouseEvent) => void;
+    updateConnectionDrag(currentX: number, currentY: number): void;
     onMouseUp: (event: MouseEvent) => void;
     isPositionInsideSwimlane(y: number): boolean;
     showConnectionPopup(x: number, y: number): void;
     hideConnectionPopup(): void;
     onDocumentClick(event: MouseEvent): void;
     createNodeConnection(nodeType: string): void;
+    onDecisionConditionSaved(event: {
+        connectionId: string;
+        condition: string;
+    }): void;
+    onDecisionConditionCancelled(): void;
     getConnectionPath(): string;
     getConnectionPathForSavedConnection(connection: Connection): string;
     getOrthogonalPath(startX: number, startY: number, endX: number, endY: number, pointType: 'top' | 'right' | 'bottom' | 'left'): string;
@@ -89,6 +121,8 @@ export declare class DesignerCanvasComponent implements OnInit {
     selectStartNodeForm(form: FormEntity | null): void;
     showSubflowSelectionPopup(x: number, y: number, swimlaneIndex: number): void;
     selectSubflowWorkflow(workflow: Workflow): void;
+    showDecisionConditionsPopup(event: MouseEvent, node: WFNode, swimlaneIndex: number): void;
+    ensureSwimlaneInView(swimlaneIndex: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DesignerCanvasComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DesignerCanvasComponent, "lib-designer-canvas", never, { "selectedTool": { "alias": "selectedTool"; "required": false; }; }, { "clickedPosition": "clickedPosition"; "subflowSelected": "subflowSelected"; "showStageDialog": "showStageDialog"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DesignerCanvasComponent, "lib-designer-canvas", never, { "selectedTool": { "alias": "selectedTool"; "required": false; }; }, { "clickedPosition": "clickedPosition"; "subflowSelected": "subflowSelected"; "showStageDialog": "showStageDialog"; "stagePropertiesUpdated": "stagePropertiesUpdated"; }, never, never, false, never>;
 }

package/lib/components/workflow-designer/designer-toolbar/designer-toolbar.component.d.ts

@@ -1,18 +1,29 @@
 import { EventEmitter } from '@angular/core';
 import { ToolType } from '../workflow-designer.types';
 import { ToolbarItem } from './designer-toolbar.types';
-import { WorkflowDesignerState } from '../workflow-designer.state';
+import { NodeManagementService } from '../services/node-management.service';
+import { SwimlaneService } from '../services/swimlane.service';
 import * as i0 from "@angular/core";
 export declare class DesignerToolbarComponent {
-    private state;
+    private nodeService;
+    private swimlaneService;
     selectedTool: ToolType;
     isSaving: boolean;
     toolSelected: EventEmitter<ToolType>;
     saveWorkflow: EventEmitter<void>;
     toolbarItems: ToolbarItem[];
-    constructor(state: WorkflowDesignerState);
+    constructor(nodeService: NodeManagementService, swimlaneService: SwimlaneService);
+    /**
+     * Handle tool button click
+     */
     onToolClick(tool: ToolType): void;
+    /**
+     * Check if a tool should be enabled
+     */
     isEnabled(type: ToolType): boolean;
+    /**
+     * Handle save button click
+     */
     onSaveClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DesignerToolbarComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DesignerToolbarComponent, "lib-designer-toolbar", never, { "selectedTool": { "alias": "selectedTool"; "required": false; }; "isSaving": { "alias": "isSaving"; "required": false; }; }, { "toolSelected": "toolSelected"; "saveWorkflow": "saveWorkflow"; }, never, never, false, never>;

package/lib/components/workflow-designer/services/connection.service.d.ts

@@ -0,0 +1,85 @@
+import { Connection, ConnectionPoint } from '../workflow-designer.types';
+import { WorkflowDesignerState } from '../workflow-designer.state';
+import { NodeManagementService } from './node-management.service';
+import * as i0 from "@angular/core";
+export declare class ConnectionService {
+    private state;
+    private nodeService;
+    private draggingConnectionData;
+    private readonly connectionRules;
+    constructor(state: WorkflowDesignerState, nodeService: NodeManagementService);
+    /**
+     * Start a new connection drag operation
+     */
+    startConnectionDrag(point: ConnectionPoint, swimlaneIndex: number, globalX: number, globalY: number): void;
+    /**
+     * Update the position of the dragging connection
+     */
+    updateConnectionDrag(currentX: number, currentY: number): void;
+    /**
+     * End the current connection drag operation
+     */
+    endConnectionDrag(): void;
+    /**
+     * Check if a connection drag is in progress
+     */
+    isConnectionDragging(): boolean;
+    /**
+     * Get the current connection path data for rendering
+     */
+    getConnectionPathData(): {
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+        sourceSwimlaneIndex: number;
+    } | null;
+    /**
+     * Create a new connection between nodes
+     */
+    createConnection(targetNodeId: string, targetPointId: string, targetSwimlaneIndex: number): Connection | null;
+    /**
+     * Get the path data for rendering a saved connection
+     */
+    getConnectionData(connection: Connection): {
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+        sourceSwimlaneIndex: number;
+        targetSwimlaneIndex: number;
+    } | null;
+    /**
+     * Calculate a path for orthogonal connection rendering
+     */
+    getOrthogonalPath(startX: number, startY: number, endX: number, endY: number, pointType: 'top' | 'right' | 'bottom' | 'left'): string;
+    /**
+     * Check if a connection is allowed between node types
+     */
+    canConnect(sourceNodeType: string, targetNodeType: string): boolean;
+    /**
+     * Get allowed node types for the current dragging connection
+     */
+    getAllowedTargetNodeTypes(): string[];
+    /**
+     * Delete a connection by ID
+     */
+    deleteConnection(connectionId: string): boolean;
+    /**
+     * Delete all connections associated with a node
+     */
+    deleteConnectionsForNode(nodeId: string): void;
+    /**
+     * Get the current connection drag data
+     */
+    getConnectionDragData(): {
+        sourcePoint?: ConnectionPoint;
+        sourceSwimlaneIndex?: number;
+        startX?: number;
+        startY?: number;
+        currentX?: number;
+        currentY?: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionService>;
+}

package/lib/components/workflow-designer/services/node-management.service.d.ts

@@ -0,0 +1,52 @@
+import { Node, ToolType, ConnectionPoint } from '../workflow-designer.types';
+import { WorkflowStage } from '../../../models/WorkflowStage';
+import { WorkflowDesignerState } from '../workflow-designer.state';
+import * as i0 from "@angular/core";
+export declare class NodeManagementService {
+    private state;
+    constructor(state: WorkflowDesignerState);
+    /**
+     * Adds a new node to the specified swimlane
+     */
+    addNode(swimlaneIndex: number, type: ToolType, x: number, y: number, stageData?: Partial<WorkflowStage>, workflowData?: {
+        id: string;
+        name: string;
+    }): Node | null;
+    /**
+     * Gets the total count of nodes across all swimlanes
+     */
+    getNodeCount(): number;
+    /**
+     * Find a node by ID
+     */
+    findNodeById(id: string): {
+        node: Node;
+        swimlaneIndex: number;
+    } | null;
+    /**
+     * Generate connection points for a node
+     */
+    generateConnectionPoints(node: Node): ConnectionPoint[];
+    /**
+     * Update node properties
+     */
+    updateNodeProperties(nodeId: string, properties: Partial<Node>): boolean;
+    /**
+     * Update stage data for a node
+     */
+    updateStageData(nodeId: string, stageData: Partial<WorkflowStage>): boolean;
+    /**
+     * Set a node as a start node
+     */
+    setAsStartNode(nodeId: string): boolean;
+    /**
+     * Delete a node
+     */
+    deleteNode(nodeId: string): boolean;
+    /**
+     * Check if a node has outgoing connections
+     */
+    hasOutgoingConnections(nodeId: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeManagementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeManagementService>;
+}

package/lib/components/workflow-designer/services/popup.service.d.ts

@@ -0,0 +1,139 @@
+import { FormEntity } from '../../../models/FormEntity';
+import { Workflow } from '../../../models/Workflow';
+import { ConnectionPoint } from '../workflow-designer.types';
+import { WorkflowDataService } from '../workflow-data.service';
+import * as i0 from "@angular/core";
+/**
+ * Service for managing various popups in the workflow designer
+ */
+export declare class PopupService {
+    private dataService;
+    private _connectionPopupVisible;
+    private _connectionPopupPosition;
+    private _allowedNodeTypes;
+    private _formPopupVisible;
+    private _formPopupPosition;
+    private _formsList;
+    private _isLoadingForms;
+    private _selectedNodeForForm;
+    private _startNodeFormPopupVisible;
+    private _startNodeFormPopupPosition;
+    private _subflowPopupVisible;
+    private _subflowPopupPosition;
+    private _workflowsList;
+    private _isLoadingWorkflows;
+    private _pendingSubflowPosition;
+    private _pendingConnectionSourcePoint;
+    private _pendingConnectionSourceSwimlaneIndex;
+    constructor(dataService: WorkflowDataService);
+    get connectionPopupVisible(): import("rxjs").Observable<boolean>;
+    get connectionPopupPosition(): import("rxjs").Observable<{
+        x: number;
+        y: number;
+    }>;
+    get allowedNodeTypes(): import("rxjs").Observable<string[]>;
+    get formPopupVisible(): import("rxjs").Observable<boolean>;
+    get formPopupPosition(): import("rxjs").Observable<{
+        x: number;
+        y: number;
+    }>;
+    get formsList(): import("rxjs").Observable<FormEntity[]>;
+    get isLoadingForms(): import("rxjs").Observable<boolean>;
+    get selectedNodeForForm(): import("rxjs").Observable<string | null>;
+    get startNodeFormPopupVisible(): import("rxjs").Observable<boolean>;
+    get startNodeFormPopupPosition(): import("rxjs").Observable<{
+        x: number;
+        y: number;
+    }>;
+    get subflowPopupVisible(): import("rxjs").Observable<boolean>;
+    get subflowPopupPosition(): import("rxjs").Observable<{
+        x: number;
+        y: number;
+    }>;
+    get workflowsList(): import("rxjs").Observable<Workflow[]>;
+    get isLoadingWorkflows(): import("rxjs").Observable<boolean>;
+    get pendingSubflowPosition(): import("rxjs").Observable<{
+        swimlaneIndex: number;
+        x: number;
+        y: number;
+    } | null>;
+    get pendingConnectionSourcePoint(): import("rxjs").Observable<ConnectionPoint | null>;
+    get pendingConnectionSourceSwimlaneIndex(): import("rxjs").Observable<number | null>;
+    /**
+     * Show connection creation popup
+     */
+    showConnectionPopup(x: number, y: number, allowedNodeTypes: string[]): void;
+    /**
+     * Hide connection creation popup
+     */
+    hideConnectionPopup(): void;
+    /**
+     * Store connection source data for use in other popups
+     */
+    storeConnectionSourceData(point: ConnectionPoint, swimlaneIndex: number): void;
+    /**
+     * Clear connection source data
+     */
+    clearConnectionSourceData(): void;
+    /**
+     * Show form selection popup for a stage
+     */
+    showFormPopup(x: number, y: number, nodeId: string): Promise<void>;
+    /**
+     * Hide form selection popup
+     */
+    hideFormPopup(): void;
+    /**
+     * Show workflow form selection popup for start node
+     */
+    showStartNodeFormPopup(x: number, y: number): Promise<void>;
+    /**
+     * Hide workflow form selection popup
+     */
+    hideStartNodeFormPopup(): void;
+    /**
+     * Show subflow selection popup
+     */
+    showSubflowPopup(x: number, y: number, swimlaneIndex: number): Promise<void>;
+    /**
+     * Hide subflow selection popup
+     */
+    hideSubflowPopup(): void;
+    getCurrentValues(): {
+        connectionPopupVisible: boolean;
+        connectionPopupPosition: {
+            x: number;
+            y: number;
+        };
+        allowedNodeTypes: string[];
+        formPopupVisible: boolean;
+        formPopupPosition: {
+            x: number;
+            y: number;
+        };
+        formsList: FormEntity[];
+        isLoadingForms: boolean;
+        selectedNodeForForm: string | null;
+        startNodeFormPopupVisible: boolean;
+        startNodeFormPopupPosition: {
+            x: number;
+            y: number;
+        };
+        subflowPopupVisible: boolean;
+        subflowPopupPosition: {
+            x: number;
+            y: number;
+        };
+        workflowsList: Workflow[];
+        isLoadingWorkflows: boolean;
+        pendingSubflowPosition: {
+            swimlaneIndex: number;
+            x: number;
+            y: number;
+        } | null;
+        pendingConnectionSourcePoint: ConnectionPoint | null;
+        pendingConnectionSourceSwimlaneIndex: number | null;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PopupService>;
+}

package/lib/components/workflow-designer/services/swimlane.service.d.ts

@@ -0,0 +1,51 @@
+import { SwimlaneItem } from '../workflow-designer.types';
+import { Tag } from '../../../models/Tag';
+import { WorkflowDesignerState } from '../workflow-designer.state';
+import * as i0 from "@angular/core";
+export declare class SwimlaneService {
+    private state;
+    readonly swimlaneHeight = 263;
+    constructor(state: WorkflowDesignerState);
+    /**
+     * Add a new swimlane
+     */
+    addSwimlane(name: string, tags: Tag[]): SwimlaneItem;
+    /**
+     * Update an existing swimlane
+     */
+    updateSwimlane(index: number, name: string, tags: Tag[]): boolean;
+    /**
+     * Reorder swimlanes (move a swimlane up or down in the list)
+     */
+    reorderSwimlane(fromIndex: number, toIndex: number): boolean;
+    /**
+     * Delete a swimlane by index
+     */
+    deleteSwimlane(index: number): boolean;
+    /**
+     * Get all swimlanes
+     */
+    getSwimlanes(): SwimlaneItem[];
+    /**
+     * Get swimlane by index
+     */
+    getSwimlane(index: number): SwimlaneItem | null;
+    /**
+     * Calculate total canvas height needed for all swimlanes
+     */
+    calculateCanvasHeight(minHeight?: number): number;
+    /**
+     * Check if a Y position is within any swimlane
+     */
+    isPositionInsideSwimlane(y: number): boolean;
+    /**
+     * Calculate swimlane index from Y position
+     */
+    getSwimlaneIndexFromPosition(y: number): number;
+    /**
+     * Find swimlane index by Lane ID
+     */
+    findSwimlaneIndexByLaneId(laneId: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwimlaneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwimlaneService>;
+}

package/lib/components/workflow-designer/services/transformer.service.d.ts

@@ -0,0 +1,36 @@
+import { WorkflowDesignerState } from '../workflow-designer.state';
+import { Workflow } from '../../../models/Workflow';
+import { SwimlaneService } from './swimlane.service';
+import { NodeManagementService } from './node-management.service';
+import { ConnectionService } from './connection.service';
+import * as i0 from "@angular/core";
+export declare class TransformerService {
+    private state;
+    private swimlaneService;
+    private nodeService;
+    private connectionService;
+    private loadedObjectIds;
+    constructor(state: WorkflowDesignerState, swimlaneService: SwimlaneService, nodeService: NodeManagementService, connectionService: ConnectionService);
+    /**
+     * Transform the UI model to a Workflow API model
+     */
+    transformToWorkflowModel(): Workflow;
+    /**
+     * Parse API workflow model and convert to UI model
+     */
+    parseWorkflowData(workflow: Workflow): void;
+    /**
+     * Register a loaded object from the API
+     */
+    registerLoadedObject(id: string, code: string): void;
+    /**
+     * Check if an object was loaded from API
+     */
+    wasLoadedFromApi(id: string): boolean;
+    /**
+     * Get the code for a loaded object
+     */
+    getCodeForObject(id: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TransformerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TransformerService>;
+}

package/lib/components/workflow-designer/stage-dialog/stage-dialog.component.d.ts

@@ -1,13 +1,17 @@
-import { EventEmitter, OnInit } from '@angular/core';
+import { EventEmitter, OnInit, SimpleChanges } from '@angular/core';
 import { FormBuilder, FormGroup } from '@angular/forms';
 import { Tag } from '../../../models/Tag';
 import { WorkflowStage } from '../../../models/WorkflowStage';
 import { StageActorRule } from '../../../models/StageActorRule';
 import { WorkflowDataService } from '../workflow-data.service';
+import { NodeManagementService } from '../services/node-management.service';
+import { PopupService } from '../services/popup.service';
 import * as i0 from "@angular/core";
 export declare class StageDialogComponent implements OnInit {
     private fb;
     private dataService;
+    private nodeService;
+    private popupService;
     visible: import("@angular/core").InputSignal<boolean>;
     stageData: Partial<WorkflowStage>;
     closed: EventEmitter<any>;
@@ -16,8 +20,19 @@ export declare class StageDialogComponent implements OnInit {
     tags: Tag[];
     actorRules: StageActorRule[];
     selectedTagIds: string[];
-    constructor(fb: FormBuilder, dataService: WorkflowDataService);
+    hasOutgoingConnections: boolean;
+    constructor(fb: FormBuilder, dataService: WorkflowDataService, nodeService: NodeManagementService, popupService: PopupService);
     ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Load tags from data service
+     */
+    private loadTags;
+    /**
+     * Initialize form with stage data if provided
+     */
+    private initFormWithStageData;
+    private checkOutgoingConnections;
     onDialogClose(event: any): void;
     saveStage(): void;
     toggleTagSelection(tagId: string): void;

package/lib/components/workflow-designer/stage-node/stage-node.component.d.ts

@@ -19,8 +19,8 @@ export declare class StageNodeComponent {
         sourceNodeId: string;
         isParallel: boolean;
     }>;
+    showShieldDialog: EventEmitter<string>;
     showFormPopup: boolean;
-    showShieldPopup: boolean;
     showTimerPopup: boolean;
     showActionPopupLeft: boolean;
     showActionPopupRight: boolean;
@@ -43,5 +43,5 @@ export declare class StageNodeComponent {
     refreshState(): void;
     onStagePropertiesSaved(stageData: Partial<WorkflowStage>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<StageNodeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<StageNodeComponent, "svg:g[lib-stage-node]", never, { "node": { "alias": "node"; "required": false; }; "isStartNode": { "alias": "isStartNode"; "required": false; }; "stageData": { "alias": "stageData"; "required": false; }; }, { "stagePropertiesUpdated": "stagePropertiesUpdated"; "parallelExecutionToggled": "parallelExecutionToggled"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StageNodeComponent, "svg:g[lib-stage-node]", never, { "node": { "alias": "node"; "required": false; }; "isStartNode": { "alias": "isStartNode"; "required": false; }; "stageData": { "alias": "stageData"; "required": false; }; }, { "stagePropertiesUpdated": "stagePropertiesUpdated"; "parallelExecutionToggled": "parallelExecutionToggled"; "showShieldDialog": "showShieldDialog"; }, never, never, false, never>;
 }

package/lib/components/workflow-designer/swimlane-dialog/swimlane-dialog.component.d.ts

@@ -1,9 +1,11 @@
 import { EventEmitter, OnInit } from '@angular/core';
 import { Tag } from '../../../models/Tag';
 import { WorkflowDataService } from '../workflow-data.service';
+import { SwimlaneService } from '../services/swimlane.service';
 import * as i0 from "@angular/core";
 export declare class SwimlaneDialogComponent implements OnInit {
     private dataService;
+    private swimlaneService;
     visible: boolean;
     swimlaneData: {
         name: string;
@@ -18,8 +20,12 @@ export declare class SwimlaneDialogComponent implements OnInit {
     workflowName: string;
     selectedTagNames: string[];
     tags: Tag[];
-    constructor(dataService: WorkflowDataService);
+    constructor(dataService: WorkflowDataService, swimlaneService: SwimlaneService);
     ngOnInit(): void;
+    /**
+     * Load tags from the data service
+     */
+    private loadTags;
     get allSelected(): boolean;
     set allSelected(value: boolean);
     get filteredTags(): Tag[];

package/lib/components/workflow-designer/workflow-designer.component.d.ts

@@ -4,6 +4,7 @@ import { Tag } from '../../models/Tag';
 import { WorkflowStage } from '../../models/WorkflowStage';
 import { DesignerCanvasComponent } from './designer-canvas/designer-canvas.component';
 import { WorkflowDataService } from './workflow-data.service';
+import { Workflow } from '../../models/Workflow';
 import * as i0 from "@angular/core";
 export declare class WorkflowDesignerComponent {
     state: WorkflowDesignerState;
@@ -29,7 +30,7 @@ export declare class WorkflowDesignerComponent {
     ngOnInit(): void;
     saveWorkflow(): void;
     loadWorkflow(code: string): void;
-    parseWorkflowData(workflow: any): void;
+    parseWorkflowData(workflow: Workflow): void;
     findSwimlaneIndexByLaneId(laneId: string): number;
     onToolSelected(tool: ToolType): void;
     openSwimlaneDialog(): void;

package/lib/components/workflow-designer/workflow-designer.module.d.ts

@@ -5,11 +5,13 @@ import * as i3 from "./designer-canvas/designer-canvas.component";
 import * as i4 from "./swimlane-dialog/swimlane-dialog.component";
 import * as i5 from "./stage-node/stage-node.component";
 import * as i6 from "./stage-dialog/stage-dialog.component";
-import * as i7 from "@angular/common";
-import * as i8 from "verben-ng-ui";
-import * as i9 from "@angular/forms";
+import * as i7 from "./conditions-popup/conditions-popup.component";
+import * as i8 from "./decision-popup/decision-popup.component";
+import * as i9 from "@angular/common";
+import * as i10 from "verben-ng-ui";
+import * as i11 from "@angular/forms";
 export declare class WorkflowDesignerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<WorkflowDesignerModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<WorkflowDesignerModule, [typeof i1.WorkflowDesignerComponent, typeof i2.DesignerToolbarComponent, typeof i3.DesignerCanvasComponent, typeof i4.SwimlaneDialogComponent, typeof i5.StageNodeComponent, typeof i6.StageDialogComponent], [typeof i7.CommonModule, typeof i8.VerbenDialogueModule, typeof i9.FormsModule, typeof i9.ReactiveFormsModule, typeof i8.VerbenPopUpModule], [typeof i1.WorkflowDesignerComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<WorkflowDesignerModule, [typeof i1.WorkflowDesignerComponent, typeof i2.DesignerToolbarComponent, typeof i3.DesignerCanvasComponent, typeof i4.SwimlaneDialogComponent, typeof i5.StageNodeComponent, typeof i6.StageDialogComponent, typeof i7.ConditionsPopupComponent, typeof i8.DecisionPopupComponent], [typeof i9.CommonModule, typeof i10.VerbenDialogueModule, typeof i11.FormsModule, typeof i11.ReactiveFormsModule, typeof i10.VerbenPopUpModule], [typeof i1.WorkflowDesignerComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<WorkflowDesignerModule>;
 }