@flowuent-org/diagramming-core 1.0.5

package/packages/diagrams/src/lib/types/system-flow-types.ts

@@ -0,0 +1,129 @@
+import { Node, Edge, NodeProps } from '@xyflow/react';
+
+// System Flow Node Types - only one type
+export type SystemFlowNodeType = 'SystemNode' | 'TreeSystemNode' | 'bendpoint';
+
+// System Flow Edge Types
+export type SystemFlowEdgeType = 'floatingEdge' | 'twoWayEdge' | 'customEdge';
+
+// Base System Flow Node Data
+export interface SystemFlowNodeData {
+  label?: string;
+  color?: string;
+  onResize?: (id: string, width: number, height: number) => void;
+  // Tree structure properties
+  isTreeStructure?: boolean;
+  structureId?: string;
+  nodeType?: 'root' | 'child';
+  relativePosition?: { x: number; y: number };
+  structureType?: 'structure1' | 'structure2' | 'structure3'; // New: Different SVG line designs
+  // Multi-level tree structure properties
+  parentId?: string; // ID of parent node
+  level?: number; // Level in tree hierarchy (0 for root, 1 for first level children, etc.)
+  // Root node editing properties
+  isRootBeingEdited?: boolean;
+  autoCenterRootNode?: () => void;
+  forceLayoutRecalculation?: () => void;
+  lastLayoutUpdate?: number;
+  [key: string]: unknown;
+}
+
+// System Flow Node
+export interface SystemFlowNode extends Node<SystemFlowNodeData> {
+  type: SystemFlowNodeType;
+  data: SystemFlowNodeData;
+}
+
+// Props for node components
+export interface SystemFlowNodeProps extends NodeProps {
+  data: SystemFlowNodeData;
+}
+
+// System Flow Edge Data
+export interface SystemFlowEdgeData {
+  color?: string;
+  isTwoWay?: boolean;
+  reverseEdgeId?: string; // ID of the reverse edge for two-way connections
+  arrowHeadLeft?: 'none' | 'v';
+  arrowHeadRight?: 'none' | 'v';
+  [key: string]: unknown;
+}
+
+// System Flow Edge
+export interface SystemFlowEdge extends Edge<SystemFlowEdgeData> {
+  type: SystemFlowEdgeType;
+  data: SystemFlowEdgeData;
+}
+
+// Node Type Map
+export interface NodeTypeMap {
+  [key: string]: {
+    type: SystemFlowNodeType;
+    data?: SystemFlowNodeData;
+  };
+}
+
+// Node Selection Context
+export interface NodeSelectionContextType {
+  selectedNodeType: string | null;
+  setSelectedNodeType: (type: string | null) => void;
+  addNodeAtCenter?: (nodeTypeId: string) => void;
+}
+
+// Settings State
+export interface SystemFlowNodeSettingsState {
+  id: string | null;
+}
+
+export interface SystemFlowEdgeSettingsState {
+  id: string | null;
+}
+
+// History State
+export interface HistoryState {
+  nodes: SystemFlowNode[];
+  edges: SystemFlowEdge[];
+}
+
+// Editing State
+export interface EditingState {
+  nodeId?: string | null;
+  edgeId?: string | null;
+  label?: string;
+  type?: 'node' | 'edge';
+}
+
+// Layout Direction
+export type LayoutDirection = 'DOWN' | 'RIGHT';
+
+// Update Function Types
+export type UpdateFunction = (updates: Record<string, unknown>) => void;
+export type CloseFunction = () => void;
+export type DeleteFunction = () => void;
+
+// Node Type for Controls
+export interface NodeType {
+  id: string;
+  name: string;
+  icon: React.ReactNode;
+}
+
+// Diagram Controls Props
+export interface DiagramControlsProps {
+  onAddEntity: (nodeTypeId?: string) => void;
+  onUndo: () => void;
+  onRedo: () => void;
+  canUndo: boolean;
+  canRedo: boolean;
+  onLoadTemplate: (templateType: string) => void;
+  edges: SystemFlowEdge[];
+  nodes: SystemFlowNode[];
+  onEditEdge: (edge: SystemFlowEdge) => void;
+}
+
+// Tab Panel Props
+export interface TabPanelProps {
+  children?: React.ReactNode;
+  index: number;
+  value: number;
+}

package/packages/diagrams/src/lib/types/usecase-types.ts

@@ -0,0 +1,84 @@
+import { Edge, Node } from '@xyflow/react';
+
+export interface UseCaseDiagramProps {
+  caseNodes: Node[];
+  caseEdges: Edge[];
+}
+
+export interface UseCaseNodeData {
+  label: string;
+  description?: string;
+  business?: boolean;
+  sourcePosition?: 'left' | 'right';
+  targetPosition?: 'left' | 'right';
+  color?: string;
+  width?: number;
+  height?: number;
+  [key: string]: unknown;
+}
+
+export interface PackageNodeData {
+  label: string;
+  description?: string;
+  children?: string[]; // IDs of child nodes for nesting
+  sourcePosition?: 'left' | 'right';
+  targetPosition?: 'left' | 'right';
+  width?: number;
+  height?: number;
+  color?: string;
+  [key: string]: unknown;
+}
+
+export type UseCaseEdgeType = 'association' | 'include' | 'extend';
+
+export interface UseCaseEdgeData {
+  type: UseCaseEdgeType;
+  label?: string;
+  stereotype?: string;
+  color?: string;
+  style?: 'solid' | 'dashed' | 'dotted' | 'bold';
+  arrowHead?: 'none' | 'triangle' | 'v';
+  arrowHeadSource?: 'none' | 'triangle' | 'v';
+  arrowHeadTarget?: 'none' | 'triangle' | 'v';
+  [key: string]: unknown;
+}
+
+// Type for the createNode function parameters
+export interface CreateNodeParams {
+  type: 'actor' | 'usecase' | 'package';
+  label?: string;
+  data?: Partial<UseCaseNodeData | PackageNodeData>;
+  style?: 'stickman' | 'business';
+  business?: boolean;
+  parentNode?: string;
+  width?: number;
+  height?: number;
+}
+
+// Type for node creation result
+export interface CreateNodeResult {
+  id: string;
+  type: string;
+  position: { x: number; y: number };
+  data: UseCaseNodeData | PackageNodeData;
+  parentNode?: string;
+  extent?: 'parent';
+  draggable?: boolean;
+}
+
+// Type for history state
+export interface HistoryState {
+  nodes: Node[];
+  edges: Edge[];
+}
+
+// Type for relationship dialog state
+export interface RelationshipDialogState {
+  relationshipDialogOpen: boolean;
+  pendingRelationshipType: UseCaseEdgeType | null;
+  pendingSourceId: string | null;
+  pendingTargetId: string | null;
+  pendingSourceHandle: string | null;
+  pendingTargetHandle: string | null;
+  editingEdge: Edge<UseCaseEdgeData> | null;
+}

package/packages/diagrams/src/lib/types/validation-types.ts

@@ -0,0 +1,134 @@
+export type SeverityLevel = 'error' | 'warning' | 'info';
+
+export interface ValidationRule {
+  enabled: boolean;
+  message: string;
+  severity: SeverityLevel;
+  value?: any;
+  min?: number | null;
+  max?: number | null;
+  pattern?: string;
+}
+
+export interface ValidationResult {
+  field: string;
+  message: string;
+  severity: SeverityLevel;
+  rule: string;
+  context?: any;
+}
+
+export interface DataTypeValidation {
+  required?: ValidationRule;
+  numeric?: ValidationRule;
+  integer?: ValidationRule;
+  boolean?: ValidationRule;
+  json?: ValidationRule;
+  minLength?: ValidationRule;
+  maxLength?: ValidationRule;
+  range?: ValidationRule;
+}
+
+export interface DataTypeConfig {
+  validation: DataTypeValidation;
+}
+
+export interface OperandValidation {
+  required?: ValidationRule;
+  typeMismatch?: ValidationRule;
+}
+
+export interface OperationValidation {
+  operands: OperandValidation;
+}
+
+export interface ExpressionValidation {
+  primitive: {
+    validation: {
+      required?: ValidationRule;
+    };
+  };
+  operation: {
+    validation: OperationValidation;
+  };
+}
+
+export interface NodeTypeValidation {
+  name?: {
+    required?: ValidationRule;
+    identifier?: ValidationRule;
+  };
+  parameters?: {
+    required?: ValidationRule;
+    identifier?: ValidationRule;
+  };
+  condition?: {
+    required?: ValidationRule;
+  };
+  bindings?: {
+    required?: ValidationRule;
+    identifier?: ValidationRule;
+  };
+  variable?: {
+    required?: ValidationRule;
+    identifier?: ValidationRule;
+  };
+  value?: {
+    required?: ValidationRule;
+  };
+}
+
+export interface IdentifierValidation {
+  required?: ValidationRule;
+  format?: ValidationRule;
+  noSpaces?: ValidationRule;
+}
+
+export interface GlobalSettings {
+  defaultSeverity: SeverityLevel;
+  showWarnings: boolean;
+  strictMode: boolean;
+}
+
+export interface CustomMessages {
+  emptyValue: string;
+  invalidFormat: string;
+  typeMismatch: string;
+  validationFailed: string;
+}
+
+export interface ValidationSchema {
+  version: string;
+  description: string;
+  globalSettings: GlobalSettings;
+  dataTypes: Record<string, DataTypeConfig>;
+  expressions: ExpressionValidation;
+  nodeTypes: Record<string, NodeTypeValidation>;
+  identifiers: {
+    validation: IdentifierValidation;
+  };
+  messages: {
+    custom: CustomMessages;
+  };
+}
+
+export interface ValidationConfig {
+  schema: ValidationSchema;
+  customRules?: Record<string, ValidationRule>;
+  overrides?: Partial<ValidationSchema>;
+}
+
+export interface ValidationContext {
+  nodeType?: string;
+  fieldPath?: string;
+  dataType?: string;
+  isRequired?: boolean;
+  customRules?: ValidationRule[];
+}
+
+export interface ValidationOptions {
+  strict?: boolean;
+  showWarnings?: boolean;
+  customMessages?: Record<string, string>;
+  context?: ValidationContext;
+}

package/packages/diagrams/src/lib/types/workflow-content-dynamic-form-type.ts

@@ -0,0 +1,23 @@
+// formData.ts
+
+// Define types for the form element and its properties
+export type FormElementType = 'Form' | 'TextField' | 'Switch' | 'Select';
+
+export type FormElementValue = string | number | boolean | null;
+
+export interface FormElementBase {
+  type: FormElementType;
+  props: {
+    name?: string; // Name of the form element (optional for Form)
+    label?: string; // Label for the form element (optional for Form)
+    value?: FormElementValue; // Current value (optional)
+    title?: string; // Title for the Form (optional)
+    type?: string; // Input type (optional for TextField)
+    options?: {
+      // Options for Select (optional)
+      value: string;
+      label: string;
+    }[];
+    children?: FormElementBase[]; // Children elements (optional)
+  };
+}

package/packages/diagrams/src/lib/types/workflow-node-data-types.ts

@@ -0,0 +1,172 @@
+export type NodeForm =
+  | FunctionNodeForm
+  | IfNodeForm
+  | DoNodeForm
+  | LetNodeForm
+  | LoopNodeForm
+  | SetNodeForm
+  | ReturnNodeForm
+  | SwitchNodeForm
+  | ForLoopNodeForm
+  | CallNodeForm
+  | TryCatchNodeForm
+  | ApiNodeForm
+  | GraphQLNodeForm;
+
+// Base interface for common form properties
+export interface BaseNodeForm {
+  childNodesExpanded?: boolean;
+}
+
+export interface FunctionNodeForm extends BaseNodeForm {
+  type: 'function';
+  name: string;
+  parameters: string[];
+  body: NodeForm[];
+  customCode?: string;
+}
+
+export interface IfNodeForm extends BaseNodeForm {
+  type: 'if';
+  condition: Expression;
+  conditionDataType?: string;
+  true: NodeForm;
+  false?: NodeForm;
+}
+
+export interface DoNodeForm extends BaseNodeForm {
+  type: 'do';
+  body: NodeForm[];
+}
+
+export interface LetNodeForm extends BaseNodeForm {
+  type: 'let';
+  mode: 'simple' | 'object' | 'code';
+  bindings: [string, Expression][];
+  objectDefinition?: ObjectDefinition;
+  customCode?: string;
+}
+
+export interface ObjectDefinition {
+  variableName: string;
+  properties: ObjectProperty[];
+}
+
+export interface ObjectProperty {
+  key: string;
+  value: Expression; // Use the Expression type from this file
+  isComputed?: boolean;
+}
+
+export interface LoopNodeForm extends BaseNodeForm {
+  type: 'loop';
+  condition: Expression;
+  conditionDataType?: string;
+  body: NodeForm[];
+}
+
+export interface SetNodeForm extends BaseNodeForm {
+  type: 'set';
+  variable: string;
+  value: Expression;
+  valueDataType?: string;
+}
+
+export interface ReturnNodeForm extends BaseNodeForm {
+  type: 'return';
+  value: Expression;
+  dataType?: string;
+}
+
+export interface SwitchNodeForm extends BaseNodeForm {
+  type: 'switch';
+  switchValue: string;
+  fallbackValue?: string;
+  caseCount?: number;
+}
+
+export interface ForLoopNodeForm extends BaseNodeForm {
+  type: 'forLoop';
+  init: string;
+  condition: string;
+  update: string;
+  initDataType?: string;
+  conditionDataType?: string;
+  updateDataType?: string;
+}
+
+export interface CallNodeForm extends BaseNodeForm {
+  type: 'call';
+  functionId: string | null;
+  args: Array<{
+    name: string;
+    value: string | Expression;
+    dataType?: string;
+  }>;
+  returnValueName: string | Expression;
+  returnValueDataType?: string;
+  code: string;
+  functionName: string;
+}
+
+export interface TryCatchNodeForm extends BaseNodeForm {
+  type: 'tryCatch';
+  try: Expression;
+  catch: Expression;
+}
+
+export interface ApiNodeForm extends BaseNodeForm {
+  type: 'api';
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  url: string;
+  headers: Array<{
+    key: string;
+    value: string;
+  }>;
+  queryParams: Array<{
+    key: string;
+    value: string;
+  }>;
+  body?: string;
+  bodyType: 'json' | 'form-data' | 'x-www-form-urlencoded' | 'raw';
+  responseVariable: string;
+  responseDataType: 'String' | 'Object' | 'Array';
+}
+
+export interface GraphQLNodeForm extends BaseNodeForm {
+  type: 'graphql';
+  mode: 'normal' | 'advanced';
+  operationType: 'query' | 'mutation' | 'subscription';
+  operationName?: string;
+  rootField: string;
+  url: string;
+  headers: Array<{
+    key: string;
+    value: string;
+  }>;
+  arguments: Array<{
+    key: string;
+    value: string;
+  }>;
+  fields: Array<{
+    name: string;
+    subFields?: Array<{
+      name: string;
+    }>;
+  }>;
+  variables: Array<{
+    key: string;
+    value: string;
+    type: string;
+  }>;
+  responseVariable: string;
+  responseDataType: 'String' | 'Object' | 'Array';
+  customQuery?: string;
+}
+
+export type Expression = number | string | OperationExpression;
+
+export interface OperationExpression {
+  operation: string;
+  operands: string[];
+}