@flowuent-org/diagramming-core 1.0.7 → 1.1.0

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

@@ -0,0 +1,140 @@
+export type NodeForm = FunctionNodeForm | IfNodeForm | DoNodeForm | LetNodeForm | LoopNodeForm | SetNodeForm | ReturnNodeForm | SwitchNodeForm | ForLoopNodeForm | CallNodeForm | TryCatchNodeForm | ApiNodeForm | GraphQLNodeForm;
+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;
+    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[];
+}

package/dist/packages/diagrams/src/lib/utils/AutomationExecutionEngine.d.ts

@@ -0,0 +1,46 @@
+import { Node, Edge } from '@xyflow/react';
+export interface AutomationContext {
+    runId: string;
+    startTime: Date;
+    variables: Record<string, string | number | boolean | object | null>;
+    logs: AutomationLog[];
+}
+export interface AutomationLog {
+    timestamp: Date;
+    nodeId: string;
+    nodeType: string;
+    level: 'info' | 'warning' | 'error' | 'success';
+    message: string;
+    data?: string | number | boolean | object | null;
+}
+export interface AutomationResult {
+    success: boolean;
+    context: AutomationContext;
+    finalOutput?: string | number | boolean | object | null;
+    error?: string;
+}
+export declare class AutomationExecutionEngine {
+    private nodes;
+    private edges;
+    private context;
+    private onNodeUpdate?;
+    private onLog?;
+    constructor(nodes: Node[], edges: Edge[], onNodeUpdate?: (nodeId: string, updatedData: any) => void, onLog?: (log: AutomationLog) => void);
+    private generateRunId;
+    private storeExecutionResult;
+    private log;
+    private getNextNodes;
+    private executeStartNode;
+    private executeApiNode;
+    private executeFormattingNode;
+    private callAiApi;
+    private basicFormatting;
+    private executeSheetsNode;
+    private getNestedValue;
+    private formatValueForSheets;
+    private executeEndNode;
+    private executeNode;
+    executeWorkflow(): Promise<AutomationResult>;
+    getLogs(): AutomationLog[];
+    getContext(): AutomationContext;
+}

package/dist/packages/diagrams/src/lib/utils/add-new-block.d.ts

@@ -0,0 +1,6 @@
+import { IBlock, ICardNode } from '../types/card-node';
+import { GenerateNewNodeProps } from './helpers.types';
+export declare function generateNewNodes({ title, color, data, nodes, type, }: GenerateNewNodeProps): {
+    newBLock: IBlock;
+    newNodes: ICardNode[];
+};

package/dist/packages/diagrams/src/lib/utils/add-new-node.d.ts

@@ -0,0 +1,17 @@
+import { Node } from '@xyflow/react';
+import { ICardNode } from '../types/card-node';
+import { EdgeTypes } from '../organisms/CustomEdge/custom-edge.type';
+export declare function getNewNodeEdge({ pos, curr }: Args): {
+    node: ICardNode;
+    edge: {
+        id: string;
+        source: string;
+        target: string;
+        type: EdgeTypes;
+    };
+};
+interface Args {
+    curr: Node;
+    pos: 'bottom' | 'right';
+}
+export {};

package/dist/packages/diagrams/src/lib/utils/addToHistory.d.ts

@@ -0,0 +1,2 @@
+import { DiagramStore, HistoryEvent } from '../contexts/diagramStoreTypes';
+export default function addToHistory(state: DiagramStore, events: HistoryEvent[]): DiagramStore;

package/dist/packages/diagrams/src/lib/utils/automation-flow-processor.d.ts

@@ -0,0 +1,53 @@
+import { AutomationWorkflowData } from '../types/automation-node-data-types';
+import { Node, Edge } from '@xyflow/react';
+export interface AutomationExecutionContext {
+    variables: Record<string, string | number | boolean | object | null>;
+    logs: Array<{
+        timestamp: string;
+        level: 'info' | 'warn' | 'error' | 'debug';
+        nodeId: string;
+        message: string;
+        data?: string | number | boolean | object | null;
+    }>;
+    errors: Array<{
+        timestamp: string;
+        nodeId: string;
+        error: string;
+        stack?: string;
+    }>;
+}
+export declare class AutomationFlowProcessor {
+    private context;
+    private nodes;
+    private edges;
+    constructor(nodes: Node[], edges: Edge[]);
+    /**
+     * Process automation workflow data similar to workflow system
+     */
+    processWorkflowData(): AutomationWorkflowData;
+    /**
+     * Extract variables from node form data
+     */
+    private extractVariablesFromNode;
+    /**
+     * Generate JavaScript code from automation workflow
+     */
+    generateJavaScriptCode(): string;
+    /**
+     * Generate JavaScript code for a specific node
+     */
+    private generateNodeCode;
+    private generateStartNodeCode;
+    private generateApiNodeCode;
+    private generateFormattingNodeCode;
+    private generateSheetsNodeCode;
+    private generateEndNodeCode;
+    /**
+     * Export workflow data as JSON
+     */
+    exportAsJSON(): string;
+    /**
+     * Import workflow data from JSON
+     */
+    static importFromJSON(jsonString: string): AutomationWorkflowData;
+}

package/dist/packages/diagrams/src/lib/utils/closestPoint.d.ts

@@ -0,0 +1 @@
+export declare function closestPoint(pathNode: SVGPathElement, point: [number, number]): number[];

package/dist/packages/diagrams/src/lib/utils/color-options.d.ts

@@ -0,0 +1,8 @@
+interface ColorMap {
+    [colorName: string]: string;
+}
+export declare const getColorOptions: (colorMap: ColorMap) => {
+    value: string;
+    label: import("react/jsx-runtime").JSX.Element;
+}[];
+export {};

package/dist/packages/diagrams/src/lib/utils/compress-img.d.ts

@@ -0,0 +1,4 @@
+export declare function compressImage(file: File, targetWidth: number, targetHeight: number, quality: number): Promise<{
+    dataUrl: string;
+    blob: Blob;
+}>;

package/dist/packages/diagrams/src/lib/utils/configLoader.d.ts

@@ -0,0 +1,66 @@
+import { ValidationSchema } from '../types/validation-types';
+export interface ConfigSource {
+    type: 'local' | 'remote' | 'inline';
+    path?: string;
+    url?: string;
+    data?: ValidationSchema;
+}
+export interface ConfigLoaderOptions {
+    fallbackToDefault?: boolean;
+    cacheEnabled?: boolean;
+    cacheTimeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+export declare class ConfigLoader {
+    private cache;
+    private defaultOptions;
+    constructor(options?: Partial<ConfigLoaderOptions>);
+    /**
+     * Load validation schema from a configuration source
+     */
+    loadValidationSchema(source: ConfigSource, options?: Partial<ConfigLoaderOptions>): Promise<ValidationSchema>;
+    /**
+     * Load schema from local file
+     */
+    private loadLocalSchema;
+    /**
+     * Load schema from remote URL
+     */
+    private loadRemoteSchema;
+    /**
+     * Validate that the loaded data has the correct schema structure
+     */
+    private validateSchemaStructure;
+    /**
+     * Get cache key for a source
+     */
+    private getCacheKey;
+    /**
+     * Delay execution for specified milliseconds
+     */
+    private delay;
+    /**
+     * Get default validation schema
+     */
+    private getDefaultSchema;
+    /**
+     * Clear the configuration cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        entries: Array<{
+            key: string;
+            age: number;
+        }>;
+    };
+}
+export declare const configLoader: ConfigLoader;
+export declare const loadValidationSchema: (source: ConfigSource, options?: Partial<ConfigLoaderOptions>) => Promise<ValidationSchema>;
+export declare const loadLocalValidationSchema: (path: string, options?: Partial<ConfigLoaderOptions>) => Promise<ValidationSchema>;
+export declare const loadRemoteValidationSchema: (url: string, options?: Partial<ConfigLoaderOptions>) => Promise<ValidationSchema>;
+export declare const loadInlineValidationSchema: (data: ValidationSchema, options?: Partial<ConfigLoaderOptions>) => Promise<ValidationSchema>;

package/dist/packages/diagrams/src/lib/utils/constant-lengths.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    CONNECTION_LENGTH: number;
+    SUB_NODE_WIDTH: number;
+    SUB_NODE_HEIGHT: number;
+    SUB_NODE_MARGIN: number;
+    ADD_NODE_WIDTH: number;
+    NODE_TOP_HEIGHT: number;
+};
+export default _default;

package/dist/packages/diagrams/src/lib/utils/create-updated.d.ts

@@ -0,0 +1,4 @@
+import { Edge } from '@xyflow/react';
+import { ICardNode } from '../types/card-node';
+export declare const createUpdatedNodes: (prevNodes: ICardNode[], curNode: ICardNode, newNodes: ICardNode[], isReplacing: boolean) => ICardNode[];
+export declare const createUpdatedEdges: (prevEdges: Edge[], curNode: ICardNode, nodes: ICardNode[], newEdges: Edge[], isReplacing: boolean, addInMiddle: boolean | undefined) => Edge[];

package/dist/packages/diagrams/src/lib/utils/createHistoryChange.d.ts

@@ -0,0 +1,2 @@
+import { UndoRedoChange } from '../contexts/diagramStoreTypes';
+export default function createHistoryChange<T>(change: UndoRedoChange): void;

package/dist/packages/diagrams/src/lib/utils/dividerUtils.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare function getDividerLines({ verticalDividers, horizontalDividers, dividerThickness, dividerColor, width, height, }: {
+    verticalDividers?: number;
+    horizontalDividers?: number;
+    dividerThickness?: number;
+    dividerColor?: string;
+    width?: number;
+    height?: number;
+}): React.ReactNode[];

package/dist/packages/diagrams/src/lib/utils/edge-hooks.d.ts

@@ -0,0 +1,11 @@
+import { Edge, Position } from '@xyflow/react';
+export declare const useDeleteEdge: (id: string) => () => void;
+export type ExtendedEdge = Edge & {
+    sourcePosition: Position;
+    targetPosition: Position;
+};
+export declare const useSelectedMarkers: (edge?: ExtendedEdge) => {
+    selectedEdgeMarkerEnd: import("@xyflow/react").EdgeMarkerType | undefined;
+    selectedEdgeMarkerStart: import("@xyflow/react").EdgeMarkerType | undefined;
+    updateEdgeMarker: (markerOrigin: "markerStart" | "markerEnd", markerId: string) => void;
+};

package/dist/packages/diagrams/src/lib/utils/elkLayout.d.ts

@@ -0,0 +1,3 @@
+export declare const useElk: () => {
+    getLayoutedElements: () => void;
+};

package/dist/packages/diagrams/src/lib/utils/event-hooks.d.ts

@@ -0,0 +1,7 @@
+import { EventHandler } from './event-store';
+export declare const useRegisterEvent: (eventName: string) => {
+    register: (callback: EventHandler) => void;
+    unregister: () => void;
+};
+export declare const useRegisterEventCallback: (eventName: string, callback: EventHandler) => void;
+export declare const useTriggerEvent: (eventName: string) => ((...args: unknown[]) => void);

package/dist/packages/diagrams/src/lib/utils/event-store.d.ts

@@ -0,0 +1,19 @@
+import { Node, Edge } from '@xyflow/react';
+export type NodeMouseHandler = (event: React.MouseEvent, node: Node) => void;
+export type EdgeMouseHandler = (event: React.MouseEvent, edge: Edge) => void;
+export type PaneMouseHandler = (event: React.MouseEvent) => void;
+export type GenericEventHandler = (...args: unknown[]) => void;
+export type EventHandler = NodeMouseHandler | EdgeMouseHandler | PaneMouseHandler | GenericEventHandler;
+interface EventCallbacks {
+    [eventName: string]: EventHandler[];
+}
+interface EventStoreState {
+    events: EventCallbacks;
+}
+interface EventStoreActions {
+    register: (eventName: string, callback: EventHandler) => void;
+    unregister: (eventName: string, callback: EventHandler) => void;
+    trigger: (eventName: string, ...args: unknown[]) => void;
+}
+export declare const useEventStore: import("zustand").UseBoundStore<import("zustand").StoreApi<EventStoreState & EventStoreActions>>;
+export {};

package/dist/packages/diagrams/src/lib/utils/flow-node-hooks.d.ts

@@ -0,0 +1,2 @@
+import { UseAddBlockReturnProps } from '../types/hooks.types';
+export declare const useAddBlock: () => ({ title, type }: UseAddBlockReturnProps) => void;

package/dist/packages/diagrams/src/lib/utils/flow-to-js.d.ts

@@ -0,0 +1,87 @@
+import { Edge } from '@xyflow/react';
+import { ICardNode as _ICardNode } from '../types/card-node';
+import { FunctionParameter } from '../templates/node-forms/FunctionForm';
+import { Expression } from '../types/workflow-node-data-types';
+import { RuleGroup } from '../types/condition-builder';
+type ICardNode = _ICardNode;
+export interface MiddleSchema {
+    id?: string;
+    true?: (MiddleSchema | undefined)[];
+    false?: (MiddleSchema | undefined)[];
+    body?: (MiddleSchema | undefined)[];
+    type: string;
+    variable?: Expression;
+    value?: Expression;
+    condition?: Expression;
+    conditions?: RuleGroup;
+    parameters?: (string | FunctionParameter)[];
+    name?: string;
+    customCode?: string;
+    bindings?: [string, Expression][];
+    mode?: 'simple' | 'object' | 'code';
+    objectDefinition?: any;
+    catchBlock?: MiddleSchema;
+    init?: string;
+    update?: string;
+    switchValue?: string;
+    errorVar?: string;
+    title?: string;
+    dataType?: string;
+    valueDataType?: string;
+    conditionDataType?: string;
+    initDataType?: string;
+    updateDataType?: string;
+    functionName?: string;
+    args?: Array<{
+        name: string;
+        value: string;
+        dataType?: string;
+    }>;
+    returnValueName?: string;
+    returnValueDataType?: string;
+    isFunctionCall?: boolean;
+    method?: string;
+    url?: string;
+    headers?: Array<{
+        key: string;
+        value: string;
+        enabled: boolean;
+    }>;
+    queryParams?: Array<{
+        key: string;
+        value: string;
+        enabled: boolean;
+    }>;
+    requestBody?: string;
+    bodyType?: string;
+    responseVariable?: string;
+    responseDataType?: string;
+    graphqlMode?: string;
+    operationType?: string;
+    operationName?: string;
+    rootField?: string;
+    arguments?: Array<{
+        key: string;
+        value: string;
+    }>;
+    fields?: Array<{
+        name: string;
+        subFields?: Array<{
+            name: string;
+        }>;
+    }>;
+    variables?: Array<{
+        key: string;
+        value: string;
+        type: string;
+    }>;
+    customQuery?: string;
+}
+export declare const flowToCode: (json: {
+    nodes: ICardNode[];
+    edges: Edge[];
+}) => {
+    externalFunctions: string;
+    mainCode: string;
+};
+export {};

package/dist/packages/diagrams/src/lib/utils/functionGenerator.d.ts

@@ -0,0 +1,7 @@
+export interface FunctionArgument {
+    name: string;
+    operator: string;
+}
+declare const ARITHMETIC_OPERATORS: string[];
+export declare const generateFunctionCode: (args: FunctionArgument[]) => string;
+export { ARITHMETIC_OPERATORS };

package/dist/packages/diagrams/src/lib/utils/helpers.types.d.ts

@@ -0,0 +1,9 @@
+import { IBlockType, ICardNode, ICardNodeData } from '../types/card-node';
+import { colorMap } from '../types/colors';
+export interface GenerateNewNodeProps {
+    title: string;
+    color: keyof typeof colorMap;
+    data: ICardNodeData;
+    nodes: ICardNode[];
+    type: IBlockType;
+}

package/dist/packages/diagrams/src/lib/utils/iconMapper.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+declare const iconMap: Record<string, React.ComponentType<any>>;
+/**
+ * Get an icon component by name
+ * @param iconName - The name of the icon to retrieve
+ * @param fallbackIcon - Fallback icon component if iconName is not found
+ * @returns React component for the icon
+ */
+export declare const getIconByName: (iconName: string | undefined, fallbackIcon?: React.ComponentType<any>) => React.ComponentType<any>;
+/**
+ * Get all available icon names
+ * @returns Array of available icon names
+ */
+export declare const getAvailableIconNames: () => string[];
+/**
+ * Check if an icon name exists
+ * @param iconName - The name of the icon to check
+ * @returns True if the icon exists, false otherwise
+ */
+export declare const iconExists: (iconName: string) => boolean;
+/**
+ * Add a custom icon to the icon map
+ * @param iconName - The name to use for the icon
+ * @param iconComponent - The React component for the icon
+ */
+export declare const addCustomIcon: (iconName: string, iconComponent: React.ComponentType<any>) => void;
+/**
+ * Add multiple custom icons to the icon map
+ * @param icons - Object mapping icon names to React components
+ */
+export declare const addCustomIcons: (icons: Record<string, React.ComponentType<any>>) => void;
+/**
+ * Remove a custom icon from the icon map
+ * @param iconName - The name of the icon to remove
+ */
+export declare const removeCustomIcon: (iconName: string) => void;
+export default iconMap;

package/dist/packages/diagrams/src/lib/utils/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: (...params: any[]) => void;

package/dist/packages/diagrams/src/lib/utils/model-hooks.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare const useExportJson: (name?: string) => () => void;
+export declare const useImportJson: () => (e: React.ChangeEvent<HTMLInputElement>) => void;
+export declare const useAttachHistoryKeyEvents: () => void;
+export declare const useDownload: ({ imageWidth, imageHeight, name, }?: {
+    imageWidth?: number | undefined;
+    imageHeight?: number | undefined;
+    name?: string | undefined;
+}) => () => void;

package/dist/packages/diagrams/src/lib/utils/node-hooks.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Node } from '@xyflow/react';
+export declare const useUpdateNode: () => (dataId: string, mutationUpdate: (node: Node) => Partial<Node>) => void;
+export declare const useDeleteNodeByEvent: (nodeId: string) => (e: React.KeyboardEvent<Element>) => void;
+export declare const useDeleteNode: (nodeId: string) => () => void;

package/dist/packages/diagrams/src/lib/utils/nodeutils.d.ts

@@ -0,0 +1,10 @@
+import { Node, Position } from '@xyflow/react';
+import { EdgeTypes } from '../organisms/CustomEdge/custom-edge.type';
+export declare const getEdgeParams: (source: Node, target: Node, edgeType: EdgeTypes | undefined, strokeWidth: number, diagramType: string, nodes: Node[]) => {
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition: Position;
+    targetPosition: Position;
+};

package/dist/packages/diagrams/src/lib/utils/object.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Change key -> value to value -> key pair
+ */
+export declare function reverseObj(originalMap: Record<string, string>): Record<string, string>;

package/dist/packages/diagrams/src/lib/utils/useDebounce.d.ts

@@ -0,0 +1,2 @@
+declare function useDebounce<T>(value: T, delay: number): T;
+export default useDebounce;

package/dist/packages/diagrams/src/lib/utils/utilities.d.ts

@@ -0,0 +1,9 @@
+import { Edge } from '@xyflow/react';
+import { ICardNode } from '../types/card-node';
+export declare const getPreviousNodes: (node: ICardNode, edges: Edge[], nodes: ICardNode[]) => ICardNode[];
+export declare const getMinX: (nodes: ICardNode[]) => number;
+export declare const getMaxX: (nodes: ICardNode[]) => number;
+export declare const getNextNodes: (nodeId: string, nodes: ICardNode[], edges: Edge[]) => ICardNode[];
+export declare const getNodeWidth: (node: ICardNode) => number;
+export declare const getNodeHeight: (node: ICardNode) => number;
+export declare const getNodePositionX: (node: ICardNode) => number;