@umodeapporg/ui 0.22.2 → 0.23.0

package/dist/components/UI/Flow/flowGraph.d.ts

@@ -0,0 +1,32 @@
+import { IFlowBlockRegistry } from './flowBlockRegistry';
+import { IFlowGraph, IFlowIssue, IFlowNode, IFlowPosition, TFlowPortId } from './flowTypes';
+/** The flow reads left to right: one level per column, siblings stacked in the column. */
+export declare const FLOW_LEVEL_GAP = 336;
+export declare const FLOW_SIBLING_GAP = 176;
+export declare const triggerNodesOf: (graph: IFlowGraph, registry: IFlowBlockRegistry) => Array<IFlowNode>;
+/** Node ids reachable from `startNodeId` following edges, the start included. */
+export declare const reachableFrom: (graph: IFlowGraph, startNodeId: string) => Set<string>;
+/** The node ids of the first cycle found, in order, or null when the graph has none. */
+export declare const findCycle: (graph: IFlowGraph) => Array<string> | null;
+export interface IFlowConnectionCandidate {
+    source: string;
+    sourcePort: TFlowPortId;
+    target: string;
+}
+/**
+ * The V0 shape is a tree with no fan-out: one input per block, one edge per output
+ * port, no edge into a trigger and no cycle. Keeping this rule here lets the canvas
+ * refuse a bad connection while it is being drawn, not only when publishing.
+ */
+export declare const canConnect: (graph: IFlowGraph, registry: IFlowBlockRegistry, candidate: IFlowConnectionCandidate) => boolean;
+/** The structural rules of the V0 shape, plus each block's own `validate`. */
+export declare const validateFlowGraph: (graph: IFlowGraph, registry: IFlowBlockRegistry) => Array<IFlowIssue>;
+export declare const hasBlockingIssues: (issues: Array<IFlowIssue>) => boolean;
+/**
+ * Lays the tree out by levels from the trigger: each level one column to the right,
+ * siblings stacked in the column. Used only for a flow with no saved positions (one born from a rule) or when
+ * the user asks for it; a position the user arranged is data and is never overwritten
+ * implicitly.
+ */
+export declare const layoutFlowByLevels: (graph: IFlowGraph, registry: IFlowBlockRegistry) => Record<string, IFlowPosition>;
+export declare const hasSavedPositions: (graph: IFlowGraph) => boolean;

package/dist/components/UI/Flow/flowGraph.js

@@ -0,0 +1,156 @@
+const FLOW_LEVEL_GAP = 336;
+const FLOW_SIBLING_GAP = 176;
+const nodesOf = (graph) => Array.isArray(graph?.nodes) ? graph.nodes : [];
+const edgesOf = (graph) => Array.isArray(graph?.edges) ? graph.edges : [];
+const outgoingByNode = (graph) => {
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const edge of edgesOf(graph)) {
+    outgoing.set(edge.source, [...outgoing.get(edge.source) ?? [], edge]);
+  }
+  return outgoing;
+};
+const triggerNodesOf = (graph, registry) => nodesOf(graph).filter((node) => registry.get(node.type)?.category === "trigger");
+const reachableFrom = (graph, startNodeId) => {
+  const outgoing = outgoingByNode(graph);
+  const visited = /* @__PURE__ */ new Set();
+  const pending = [startNodeId];
+  while (pending.length > 0) {
+    const nodeId = pending.pop();
+    if (nodeId === void 0 || visited.has(nodeId)) continue;
+    visited.add(nodeId);
+    for (const edge of outgoing.get(nodeId) ?? []) pending.push(edge.target);
+  }
+  return visited;
+};
+const findCycle = (graph) => {
+  const outgoing = outgoingByNode(graph);
+  const state = /* @__PURE__ */ new Map();
+  const path = [];
+  const visit = (nodeId) => {
+    state.set(nodeId, "visiting");
+    path.push(nodeId);
+    for (const edge of outgoing.get(nodeId) ?? []) {
+      const targetState = state.get(edge.target);
+      if (targetState === "visiting") return path.slice(path.indexOf(edge.target));
+      if (targetState === void 0) {
+        const cycle = visit(edge.target);
+        if (cycle) return cycle;
+      }
+    }
+    path.pop();
+    state.set(nodeId, "done");
+    return null;
+  };
+  for (const node of nodesOf(graph)) {
+    if (state.has(node.nodeId)) continue;
+    const cycle = visit(node.nodeId);
+    if (cycle) return cycle;
+  }
+  return null;
+};
+const canConnect = (graph, registry, candidate) => {
+  const { source, sourcePort, target } = candidate;
+  if (!source || !target || source === target) return false;
+  const nodes = nodesOf(graph);
+  const sourceNode = nodes.find((node) => node.nodeId === source);
+  const targetNode = nodes.find((node) => node.nodeId === target);
+  if (!sourceNode || !targetNode) return false;
+  const sourceDefinition = registry.get(sourceNode.type);
+  const targetDefinition = registry.get(targetNode.type);
+  if (!sourceDefinition?.outputs.includes(sourcePort)) return false;
+  if (!targetDefinition || targetDefinition.category === "trigger") return false;
+  const edges = edgesOf(graph);
+  if (edges.some((edge) => edge.source === source && edge.sourcePort === sourcePort)) return false;
+  if (edges.some((edge) => edge.target === target)) return false;
+  return !reachableFrom(graph, target).has(source);
+};
+const validateFlowGraph = (graph, registry) => {
+  const issues = [];
+  const nodes = nodesOf(graph);
+  const edges = edgesOf(graph);
+  for (const node of nodes) {
+    const definition = registry.get(node.type);
+    if (!definition) {
+      issues.push({ code: "unknownBlock", severity: "error", nodeId: node.nodeId });
+      continue;
+    }
+    for (const blockIssue of definition.validate(node.config) ?? []) {
+      issues.push({ ...blockIssue, nodeId: node.nodeId });
+    }
+  }
+  const triggers = triggerNodesOf(graph, registry);
+  if (triggers.length === 0) issues.push({ code: "missingTrigger", severity: "error" });
+  triggers.slice(1).forEach((trigger) => {
+    issues.push({ code: "multipleTriggers", severity: "error", nodeId: trigger.nodeId });
+  });
+  const firstTrigger = triggers[0];
+  if (firstTrigger) {
+    const reachable = reachableFrom(graph, firstTrigger.nodeId);
+    nodes.filter((node) => !reachable.has(node.nodeId) && registry.get(node.type)?.category !== "trigger").forEach((node) => issues.push({ code: "unreachableNode", severity: "error", nodeId: node.nodeId }));
+  }
+  const inputCount = /* @__PURE__ */ new Map();
+  const portCount = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    inputCount.set(edge.target, (inputCount.get(edge.target) ?? 0) + 1);
+    const portKey = `${edge.source}|${edge.sourcePort}`;
+    portCount.set(portKey, (portCount.get(portKey) ?? 0) + 1);
+  }
+  inputCount.forEach((count, nodeId) => {
+    if (count > 1) issues.push({ code: "multipleInputs", severity: "error", nodeId });
+  });
+  edges.filter((edge) => (portCount.get(`${edge.source}|${edge.sourcePort}`) ?? 0) > 1).forEach(
+    (edge) => issues.push({ code: "portFanOut", severity: "error", edgeId: edge.edgeId, nodeId: edge.source })
+  );
+  const cycle = findCycle(graph);
+  if (cycle) cycle.forEach((nodeId) => issues.push({ code: "cycle", severity: "error", nodeId }));
+  nodes.filter((node) => registry.get(node.type)?.outputs.includes("true")).filter((node) => !edges.some((edge) => edge.source === node.nodeId && edge.sourcePort === "true")).forEach((node) => issues.push({ code: "missingTrueBranch", severity: "warning", nodeId: node.nodeId }));
+  return issues;
+};
+const hasBlockingIssues = (issues) => (issues ?? []).some((issue) => issue.severity === "error");
+const layoutFlowByLevels = (graph, registry) => {
+  const nodes = nodesOf(graph);
+  const outgoing = outgoingByNode(graph);
+  const levelOf = /* @__PURE__ */ new Map();
+  const roots = triggerNodesOf(graph, registry);
+  const queue = roots.map((root) => root.nodeId);
+  roots.forEach((root) => levelOf.set(root.nodeId, 0));
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    if (nodeId === void 0) continue;
+    const level = levelOf.get(nodeId) ?? 0;
+    for (const edge of outgoing.get(nodeId) ?? []) {
+      if (levelOf.has(edge.target)) continue;
+      levelOf.set(edge.target, level + 1);
+      queue.push(edge.target);
+    }
+  }
+  const deepestLevel = Math.max(-1, ...Array.from(levelOf.values()));
+  nodes.filter((node) => !levelOf.has(node.nodeId)).forEach((node) => levelOf.set(node.nodeId, deepestLevel + 1));
+  const nodesByLevel = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => {
+    const level = levelOf.get(node.nodeId) ?? 0;
+    nodesByLevel.set(level, [...nodesByLevel.get(level) ?? [], node.nodeId]);
+  });
+  const positions = {};
+  nodesByLevel.forEach((nodeIds, level) => {
+    const columnHeight = (nodeIds.length - 1) * FLOW_SIBLING_GAP;
+    nodeIds.forEach((nodeId, index) => {
+      positions[nodeId] = { x: level * FLOW_LEVEL_GAP, y: index * FLOW_SIBLING_GAP - columnHeight / 2 };
+    });
+  });
+  return positions;
+};
+const hasSavedPositions = (graph) => nodesOf(graph).some((node) => node.position && (node.position.x !== 0 || node.position.y !== 0));
+export {
+  FLOW_LEVEL_GAP,
+  FLOW_SIBLING_GAP,
+  canConnect,
+  findCycle,
+  hasBlockingIssues,
+  hasSavedPositions,
+  layoutFlowByLevels,
+  reachableFrom,
+  triggerNodesOf,
+  validateFlowGraph
+};
+//# sourceMappingURL=flowGraph.js.map

package/dist/components/UI/Flow/flowGraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowGraph.js","sources":["../../../../src/components/UI/Flow/flowGraph.ts"],"sourcesContent":["import type { IFlowBlockRegistry } from './flowBlockRegistry';\nimport type { IFlowEdge, IFlowGraph, IFlowIssue, IFlowNode, IFlowPosition, TFlowPortId } from './flowTypes';\n\n/** The flow reads left to right: one level per column, siblings stacked in the column. */\nexport const FLOW_LEVEL_GAP = 336;\nexport const FLOW_SIBLING_GAP = 176;\n\nconst nodesOf = (graph: IFlowGraph): Array<IFlowNode> => (Array.isArray(graph?.nodes) ? graph.nodes : []);\nconst edgesOf = (graph: IFlowGraph): Array<IFlowEdge> => (Array.isArray(graph?.edges) ? graph.edges : []);\n\nconst outgoingByNode = (graph: IFlowGraph): Map<string, Array<IFlowEdge>> => {\n  const outgoing = new Map<string, Array<IFlowEdge>>();\n  for (const edge of edgesOf(graph)) {\n    outgoing.set(edge.source, [...(outgoing.get(edge.source) ?? []), edge]);\n  }\n  return outgoing;\n};\n\nexport const triggerNodesOf = (graph: IFlowGraph, registry: IFlowBlockRegistry): Array<IFlowNode> =>\n  nodesOf(graph).filter((node) => registry.get(node.type)?.category === 'trigger');\n\n/** Node ids reachable from `startNodeId` following edges, the start included. */\nexport const reachableFrom = (graph: IFlowGraph, startNodeId: string): Set<string> => {\n  const outgoing = outgoingByNode(graph);\n  const visited = new Set<string>();\n  const pending = [startNodeId];\n  while (pending.length > 0) {\n    const nodeId = pending.pop();\n    if (nodeId === undefined || visited.has(nodeId)) continue;\n    visited.add(nodeId);\n    for (const edge of outgoing.get(nodeId) ?? []) pending.push(edge.target);\n  }\n  return visited;\n};\n\n/** The node ids of the first cycle found, in order, or null when the graph has none. */\nexport const findCycle = (graph: IFlowGraph): Array<string> | null => {\n  const outgoing = outgoingByNode(graph);\n  const state = new Map<string, 'visiting' | 'done'>();\n  const path: Array<string> = [];\n\n  const visit = (nodeId: string): Array<string> | null => {\n    state.set(nodeId, 'visiting');\n    path.push(nodeId);\n    for (const edge of outgoing.get(nodeId) ?? []) {\n      const targetState = state.get(edge.target);\n      if (targetState === 'visiting') return path.slice(path.indexOf(edge.target));\n      if (targetState === undefined) {\n        const cycle = visit(edge.target);\n        if (cycle) return cycle;\n      }\n    }\n    path.pop();\n    state.set(nodeId, 'done');\n    return null;\n  };\n\n  for (const node of nodesOf(graph)) {\n    if (state.has(node.nodeId)) continue;\n    const cycle = visit(node.nodeId);\n    if (cycle) return cycle;\n  }\n  return null;\n};\n\nexport interface IFlowConnectionCandidate {\n  source: string;\n  sourcePort: TFlowPortId;\n  target: string;\n}\n\n/**\n * The V0 shape is a tree with no fan-out: one input per block, one edge per output\n * port, no edge into a trigger and no cycle. Keeping this rule here lets the canvas\n * refuse a bad connection while it is being drawn, not only when publishing.\n */\nexport const canConnect = (\n  graph: IFlowGraph,\n  registry: IFlowBlockRegistry,\n  candidate: IFlowConnectionCandidate,\n): boolean => {\n  const { source, sourcePort, target } = candidate;\n  if (!source || !target || source === target) return false;\n\n  const nodes = nodesOf(graph);\n  const sourceNode = nodes.find((node) => node.nodeId === source);\n  const targetNode = nodes.find((node) => node.nodeId === target);\n  if (!sourceNode || !targetNode) return false;\n\n  const sourceDefinition = registry.get(sourceNode.type);\n  const targetDefinition = registry.get(targetNode.type);\n  if (!sourceDefinition?.outputs.includes(sourcePort)) return false;\n  if (!targetDefinition || targetDefinition.category === 'trigger') return false;\n\n  const edges = edgesOf(graph);\n  if (edges.some((edge) => edge.source === source && edge.sourcePort === sourcePort)) return false;\n  if (edges.some((edge) => edge.target === target)) return false;\n\n  return !reachableFrom(graph, target).has(source);\n};\n\n/** The structural rules of the V0 shape, plus each block's own `validate`. */\nexport const validateFlowGraph = (graph: IFlowGraph, registry: IFlowBlockRegistry): Array<IFlowIssue> => {\n  const issues: Array<IFlowIssue> = [];\n  const nodes = nodesOf(graph);\n  const edges = edgesOf(graph);\n\n  for (const node of nodes) {\n    const definition = registry.get(node.type);\n    if (!definition) {\n      issues.push({ code: 'unknownBlock', severity: 'error', nodeId: node.nodeId });\n      continue;\n    }\n    for (const blockIssue of definition.validate(node.config) ?? []) {\n      issues.push({ ...blockIssue, nodeId: node.nodeId });\n    }\n  }\n\n  const triggers = triggerNodesOf(graph, registry);\n  if (triggers.length === 0) issues.push({ code: 'missingTrigger', severity: 'error' });\n  triggers.slice(1).forEach((trigger) => {\n    issues.push({ code: 'multipleTriggers', severity: 'error', nodeId: trigger.nodeId });\n  });\n\n  const firstTrigger = triggers[0];\n  if (firstTrigger) {\n    const reachable = reachableFrom(graph, firstTrigger.nodeId);\n    nodes\n      .filter((node) => !reachable.has(node.nodeId) && registry.get(node.type)?.category !== 'trigger')\n      .forEach((node) => issues.push({ code: 'unreachableNode', severity: 'error', nodeId: node.nodeId }));\n  }\n\n  const inputCount = new Map<string, number>();\n  const portCount = new Map<string, number>();\n  for (const edge of edges) {\n    inputCount.set(edge.target, (inputCount.get(edge.target) ?? 0) + 1);\n    const portKey = `${edge.source}|${edge.sourcePort}`;\n    portCount.set(portKey, (portCount.get(portKey) ?? 0) + 1);\n  }\n  inputCount.forEach((count, nodeId) => {\n    if (count > 1) issues.push({ code: 'multipleInputs', severity: 'error', nodeId });\n  });\n  edges\n    .filter((edge) => (portCount.get(`${edge.source}|${edge.sourcePort}`) ?? 0) > 1)\n    .forEach((edge) =>\n      issues.push({ code: 'portFanOut', severity: 'error', edgeId: edge.edgeId, nodeId: edge.source }),\n    );\n\n  const cycle = findCycle(graph);\n  if (cycle) cycle.forEach((nodeId) => issues.push({ code: 'cycle', severity: 'error', nodeId }));\n\n  nodes\n    .filter((node) => registry.get(node.type)?.outputs.includes('true'))\n    .filter((node) => !edges.some((edge) => edge.source === node.nodeId && edge.sourcePort === 'true'))\n    .forEach((node) => issues.push({ code: 'missingTrueBranch', severity: 'warning', nodeId: node.nodeId }));\n\n  return issues;\n};\n\nexport const hasBlockingIssues = (issues: Array<IFlowIssue>): boolean =>\n  (issues ?? []).some((issue) => issue.severity === 'error');\n\n/**\n * Lays the tree out by levels from the trigger: each level one column to the right,\n * siblings stacked in the column. Used only for a flow with no saved positions (one born from a rule) or when\n * the user asks for it; a position the user arranged is data and is never overwritten\n * implicitly.\n */\nexport const layoutFlowByLevels = (graph: IFlowGraph, registry: IFlowBlockRegistry): Record<string, IFlowPosition> => {\n  const nodes = nodesOf(graph);\n  const outgoing = outgoingByNode(graph);\n  const levelOf = new Map<string, number>();\n  const roots = triggerNodesOf(graph, registry);\n  const queue: Array<string> = roots.map((root) => root.nodeId);\n  roots.forEach((root) => levelOf.set(root.nodeId, 0));\n\n  while (queue.length > 0) {\n    const nodeId = queue.shift();\n    if (nodeId === undefined) continue;\n    const level = levelOf.get(nodeId) ?? 0;\n    for (const edge of outgoing.get(nodeId) ?? []) {\n      if (levelOf.has(edge.target)) continue;\n      levelOf.set(edge.target, level + 1);\n      queue.push(edge.target);\n    }\n  }\n\n  const deepestLevel = Math.max(-1, ...Array.from(levelOf.values()));\n  nodes.filter((node) => !levelOf.has(node.nodeId)).forEach((node) => levelOf.set(node.nodeId, deepestLevel + 1));\n\n  const nodesByLevel = new Map<number, Array<string>>();\n  nodes.forEach((node) => {\n    const level = levelOf.get(node.nodeId) ?? 0;\n    nodesByLevel.set(level, [...(nodesByLevel.get(level) ?? []), node.nodeId]);\n  });\n\n  const positions: Record<string, IFlowPosition> = {};\n  nodesByLevel.forEach((nodeIds, level) => {\n    const columnHeight = (nodeIds.length - 1) * FLOW_SIBLING_GAP;\n    nodeIds.forEach((nodeId, index) => {\n      positions[nodeId] = { x: level * FLOW_LEVEL_GAP, y: index * FLOW_SIBLING_GAP - columnHeight / 2 };\n    });\n  });\n  return positions;\n};\n\nexport const hasSavedPositions = (graph: IFlowGraph): boolean =>\n  nodesOf(graph).some((node) => node.position && (node.position.x !== 0 || node.position.y !== 0));\n"],"names":[],"mappings":"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"}

package/dist/components/UI/Flow/flowTypes.d.ts

@@ -0,0 +1,74 @@
+import { ComponentType, ReactNode } from 'react';
+import { SymbolCodepoints } from '../MaterialSymbol';
+export type TFlowPortId = 'next' | 'true' | 'false' | 'error';
+export type TFlowBlockCategory = 'trigger' | 'condition' | 'action';
+export interface IFlowPosition {
+    x: number;
+    y: number;
+}
+export interface IFlowNode<TConfig = unknown> {
+    nodeId: string;
+    type: string;
+    typeVersion: number;
+    config: TConfig;
+    position: IFlowPosition;
+    label?: string;
+    disabled?: boolean;
+}
+export interface IFlowEdge {
+    edgeId: string;
+    source: string;
+    sourcePort: TFlowPortId;
+    target: string;
+}
+export interface IFlowGraph {
+    nodes: Array<IFlowNode>;
+    edges: Array<IFlowEdge>;
+}
+export type TFlowIssueSeverity = 'error' | 'warning';
+export type TFlowGraphIssueCode = 'missingTrigger' | 'multipleTriggers' | 'unknownBlock' | 'unreachableNode' | 'multipleInputs' | 'portFanOut' | 'cycle' | 'missingTrueBranch';
+export interface IFlowIssue {
+    /** A graph rule from `TFlowGraphIssueCode`, or a block-specific code from its `validate`. */
+    code: string;
+    severity: TFlowIssueSeverity;
+    /** Already translated by the block. Graph issues leave it empty and the UI names them. */
+    message?: string;
+    nodeId?: string;
+    edgeId?: string;
+}
+export type TFlowRunStepStatus = 'passed' | 'failed' | 'skipped' | 'wouldRun' | 'error' | 'blocked';
+/** The result of one run (real or simulated) painted over the canvas. */
+export interface IFlowRunOverlay {
+    steps: Record<string, TFlowRunStepStatus>;
+    traversedEdgeIds: Array<string>;
+}
+export interface IFlowBlockConfigPanelProps<TConfig> {
+    config: TConfig;
+    onChange: (next: TConfig) => void;
+    readOnly?: boolean;
+}
+export type TFlowBlockIssue = Omit<IFlowIssue, 'nodeId' | 'edgeId'>;
+export interface IFlowBlockDefinition<TConfig = unknown> {
+    /** Namespaced and stable: `trigger.recordEvent`, `action.moveWorkflowCard`. */
+    type: string;
+    typeVersion: number;
+    category: TFlowBlockCategory;
+    icon: SymbolCodepoints;
+    /** Translated by the host. */
+    label: string;
+    description?: string;
+    outputs: Array<TFlowPortId>;
+    /** How many of this block a flow may hold; omit for no limit. */
+    maxInstances?: number;
+    createDefaultConfig: () => TConfig;
+    migrateConfig?: (config: unknown, fromVersion: number) => TConfig;
+    ConfigPanel: ComponentType<IFlowBlockConfigPanelProps<TConfig>>;
+    /** When one block stands for several kinds (chosen inside it), the icon and name of the chosen kind. */
+    resolveIcon?: (config: TConfig) => SymbolCodepoints | undefined;
+    resolveLabel?: (config: TConfig) => string | undefined;
+    /** One line inside the block on the canvas. */
+    renderSummary: (config: TConfig) => ReactNode;
+    /** This block's piece of the "When..., if..., then..." sentence. */
+    describe: (config: TConfig) => string;
+    validate: (config: TConfig) => Array<TFlowBlockIssue>;
+}

package/dist/components/UI/Flow/flowTypes.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=flowTypes.js.map

package/dist/components/UI/Flow/flowTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowTypes.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/components/UI/Flow/index.d.ts

@@ -0,0 +1,14 @@
+export { createFlowBlockRegistry, defineFlowBlock, type IFlowBlockRegistry } from './flowBlockRegistry';
+export { default as FlowCanvas, type IFlowCanvasProps } from './FlowCanvas';
+export { FLOW_BLOCK_DRAG_TYPE } from './flowConstants';
+export { default as FlowEditorProvider, useFlowBlockRegistry, useFlowEditor, useFlowEditorStore, } from './FlowEditorProvider';
+export { createFlowEditorStore, type IFlowEditorState, type TFlowEditorStore } from './flowEditorStore';
+export { canConnect, findCycle, FLOW_LEVEL_GAP, FLOW_SIBLING_GAP, hasBlockingIssues, hasSavedPositions, layoutFlowByLevels, reachableFrom, triggerNodesOf, validateFlowGraph, } from './flowGraph';
+export { default as FlowInspector } from './FlowInspector';
+export { default as FlowIssueList } from './FlowIssueList';
+export { default as FlowLaneMap, type IFlowArc, type IFlowLane, type TFlowArcTone } from './FlowLaneMap';
+export { default as FlowNodeShell, type IFlowNodeShellProps } from './FlowNodeShell';
+export { default as FlowPalette } from './FlowPalette';
+export { default as FlowResizablePanel, type IFlowResizablePanelProps } from './FlowResizablePanel';
+export type * from './flowTypes';
+export { FLOW_RUN_STATUS_TONE, useFlowLabels } from './useFlowLabels';

package/dist/components/UI/Flow/index.js

@@ -0,0 +1,43 @@
+import { createFlowBlockRegistry, defineFlowBlock } from "./flowBlockRegistry.js";
+import { default as default2 } from "./FlowCanvas.js";
+import { FLOW_BLOCK_DRAG_TYPE } from "./flowConstants.js";
+import { default as default3, useFlowBlockRegistry, useFlowEditor, useFlowEditorStore } from "./FlowEditorProvider.js";
+import { createFlowEditorStore } from "./flowEditorStore.js";
+import { FLOW_LEVEL_GAP, FLOW_SIBLING_GAP, canConnect, findCycle, hasBlockingIssues, hasSavedPositions, layoutFlowByLevels, reachableFrom, triggerNodesOf, validateFlowGraph } from "./flowGraph.js";
+import { default as default4 } from "./FlowInspector.js";
+import { default as default5 } from "./FlowIssueList.js";
+import { default as default6 } from "./FlowLaneMap.js";
+import { default as default7 } from "./FlowNodeShell.js";
+import { default as default8 } from "./FlowPalette.js";
+import { default as default9 } from "./FlowResizablePanel.js";
+import { FLOW_RUN_STATUS_TONE, useFlowLabels } from "./useFlowLabels.js";
+export {
+  FLOW_BLOCK_DRAG_TYPE,
+  FLOW_LEVEL_GAP,
+  FLOW_RUN_STATUS_TONE,
+  FLOW_SIBLING_GAP,
+  default2 as FlowCanvas,
+  default3 as FlowEditorProvider,
+  default4 as FlowInspector,
+  default5 as FlowIssueList,
+  default6 as FlowLaneMap,
+  default7 as FlowNodeShell,
+  default8 as FlowPalette,
+  default9 as FlowResizablePanel,
+  canConnect,
+  createFlowBlockRegistry,
+  createFlowEditorStore,
+  defineFlowBlock,
+  findCycle,
+  hasBlockingIssues,
+  hasSavedPositions,
+  layoutFlowByLevels,
+  reachableFrom,
+  triggerNodesOf,
+  useFlowBlockRegistry,
+  useFlowEditor,
+  useFlowEditorStore,
+  useFlowLabels,
+  validateFlowGraph
+};
+//# sourceMappingURL=index.js.map

package/dist/components/UI/Flow/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/dist/components/UI/Flow/useFlowLabels.d.ts

@@ -0,0 +1,10 @@
+import { TChipTone } from '../Chips/chipTones';
+import { IFlowIssue, TFlowBlockCategory, TFlowPortId, TFlowRunStepStatus } from './flowTypes';
+export declare const FLOW_RUN_STATUS_TONE: Record<TFlowRunStepStatus, TChipTone>;
+/** Every label the flow UI shows, spelled as literal keys so the translation tooling can read them. */
+export declare const useFlowLabels: () => {
+    ports: Record<TFlowPortId, string>;
+    categories: Record<TFlowBlockCategory, string>;
+    runStatus: Record<TFlowRunStepStatus, string>;
+    issueMessage: (issue: IFlowIssue) => string;
+};

package/dist/components/UI/Flow/useFlowLabels.js

@@ -0,0 +1,51 @@
+import { useMemo } from "react";
+import { useTranslation } from "react-i18next";
+const FLOW_RUN_STATUS_TONE = {
+  passed: "success",
+  wouldRun: "info",
+  skipped: "neutral",
+  blocked: "warning",
+  failed: "danger",
+  error: "danger"
+};
+const useFlowLabels = () => {
+  const { t } = useTranslation("ui");
+  return useMemo(() => {
+    const ports = {
+      next: t("flow.ports.next"),
+      true: t("flow.ports.true"),
+      false: t("flow.ports.false"),
+      error: t("flow.ports.error")
+    };
+    const categories = {
+      trigger: t("flow.categories.trigger"),
+      condition: t("flow.categories.condition"),
+      action: t("flow.categories.action")
+    };
+    const runStatus = {
+      passed: t("flow.run.passed"),
+      failed: t("flow.run.failed"),
+      skipped: t("flow.run.skipped"),
+      wouldRun: t("flow.run.wouldRun"),
+      error: t("flow.run.error"),
+      blocked: t("flow.run.blocked")
+    };
+    const graphIssues = {
+      missingTrigger: t("flow.issues.missingTrigger"),
+      multipleTriggers: t("flow.issues.multipleTriggers"),
+      unknownBlock: t("flow.issues.unknownBlock"),
+      unreachableNode: t("flow.issues.unreachableNode"),
+      multipleInputs: t("flow.issues.multipleInputs"),
+      portFanOut: t("flow.issues.portFanOut"),
+      cycle: t("flow.issues.cycle"),
+      missingTrueBranch: t("flow.issues.missingTrueBranch")
+    };
+    const issueMessage = (issue) => issue.message ?? graphIssues[issue.code] ?? issue.code;
+    return { ports, categories, runStatus, issueMessage };
+  }, [t]);
+};
+export {
+  FLOW_RUN_STATUS_TONE,
+  useFlowLabels
+};
+//# sourceMappingURL=useFlowLabels.js.map

package/dist/components/UI/Flow/useFlowLabels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFlowLabels.js","sources":["../../../../src/components/UI/Flow/useFlowLabels.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { useTranslation } from 'react-i18next';\n\nimport type { TChipTone } from '@/components/UI/Chips/chipTones';\n\nimport type { IFlowIssue, TFlowBlockCategory, TFlowGraphIssueCode, TFlowPortId, TFlowRunStepStatus } from './flowTypes';\n\nexport const FLOW_RUN_STATUS_TONE: Record<TFlowRunStepStatus, TChipTone> = {\n  passed: 'success',\n  wouldRun: 'info',\n  skipped: 'neutral',\n  blocked: 'warning',\n  failed: 'danger',\n  error: 'danger',\n};\n\n/** Every label the flow UI shows, spelled as literal keys so the translation tooling can read them. */\nexport const useFlowLabels = () => {\n  const { t } = useTranslation('ui');\n\n  return useMemo(() => {\n    const ports: Record<TFlowPortId, string> = {\n      next: t('flow.ports.next'),\n      true: t('flow.ports.true'),\n      false: t('flow.ports.false'),\n      error: t('flow.ports.error'),\n    };\n    const categories: Record<TFlowBlockCategory, string> = {\n      trigger: t('flow.categories.trigger'),\n      condition: t('flow.categories.condition'),\n      action: t('flow.categories.action'),\n    };\n    const runStatus: Record<TFlowRunStepStatus, string> = {\n      passed: t('flow.run.passed'),\n      failed: t('flow.run.failed'),\n      skipped: t('flow.run.skipped'),\n      wouldRun: t('flow.run.wouldRun'),\n      error: t('flow.run.error'),\n      blocked: t('flow.run.blocked'),\n    };\n    const graphIssues: Record<TFlowGraphIssueCode, string> = {\n      missingTrigger: t('flow.issues.missingTrigger'),\n      multipleTriggers: t('flow.issues.multipleTriggers'),\n      unknownBlock: t('flow.issues.unknownBlock'),\n      unreachableNode: t('flow.issues.unreachableNode'),\n      multipleInputs: t('flow.issues.multipleInputs'),\n      portFanOut: t('flow.issues.portFanOut'),\n      cycle: t('flow.issues.cycle'),\n      missingTrueBranch: t('flow.issues.missingTrueBranch'),\n    };\n    const issueMessage = (issue: IFlowIssue): string =>\n      issue.message ?? graphIssues[issue.code as TFlowGraphIssueCode] ?? issue.code;\n\n    return { ports, categories, runStatus, issueMessage };\n  }, [t]);\n};\n"],"names":[],"mappings":";;AAOO,MAAM,uBAA8D;AAAA,EACzE,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,SAAS;AAAA,EACT,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,OAAO;AACT;AAGO,MAAM,gBAAgB,MAAM;AACjC,QAAM,EAAE,EAAA,IAAM,eAAe,IAAI;AAEjC,SAAO,QAAQ,MAAM;AACnB,UAAM,QAAqC;AAAA,MACzC,MAAM,EAAE,iBAAiB;AAAA,MACzB,MAAM,EAAE,iBAAiB;AAAA,MACzB,OAAO,EAAE,kBAAkB;AAAA,MAC3B,OAAO,EAAE,kBAAkB;AAAA,IAAA;AAE7B,UAAM,aAAiD;AAAA,MACrD,SAAS,EAAE,yBAAyB;AAAA,MACpC,WAAW,EAAE,2BAA2B;AAAA,MACxC,QAAQ,EAAE,wBAAwB;AAAA,IAAA;AAEpC,UAAM,YAAgD;AAAA,MACpD,QAAQ,EAAE,iBAAiB;AAAA,MAC3B,QAAQ,EAAE,iBAAiB;AAAA,MAC3B,SAAS,EAAE,kBAAkB;AAAA,MAC7B,UAAU,EAAE,mBAAmB;AAAA,MAC/B,OAAO,EAAE,gBAAgB;AAAA,MACzB,SAAS,EAAE,kBAAkB;AAAA,IAAA;AAE/B,UAAM,cAAmD;AAAA,MACvD,gBAAgB,EAAE,4BAA4B;AAAA,MAC9C,kBAAkB,EAAE,8BAA8B;AAAA,MAClD,cAAc,EAAE,0BAA0B;AAAA,MAC1C,iBAAiB,EAAE,6BAA6B;AAAA,MAChD,gBAAgB,EAAE,4BAA4B;AAAA,MAC9C,YAAY,EAAE,wBAAwB;AAAA,MACtC,OAAO,EAAE,mBAAmB;AAAA,MAC5B,mBAAmB,EAAE,+BAA+B;AAAA,IAAA;AAEtD,UAAM,eAAe,CAAC,UACpB,MAAM,WAAW,YAAY,MAAM,IAA2B,KAAK,MAAM;AAE3E,WAAO,EAAE,OAAO,YAAY,WAAW,aAAA;AAAA,EACzC,GAAG,CAAC,CAAC,CAAC;AACR;"}

package/dist/locales/en/ui.json.d.ts

@@ -216,6 +216,73 @@ declare const _default: {
     "keepEditing": "Keep editing",
     "discard": "Discard"
   },
+  "flow": {
+    "canvas": "Flow editor",
+    "resizePanel": "Drag to adjust the width. Double click resets",
+    "ports": {
+      "next": "Next",
+      "true": "Yes",
+      "false": "No",
+      "error": "Error"
+    },
+    "categories": {
+      "trigger": "Triggers",
+      "condition": "Conditions",
+      "action": "Actions"
+    },
+    "palette": {
+      "title": "Blocks",
+      "search": "Search block",
+      "empty": "No block found",
+      "limitReached": "This flow already has the maximum of this block"
+    },
+    "inspector": {
+      "title": "Block settings",
+      "empty": "Select a block to configure it",
+      "label": "Block name",
+      "delete": "Delete block",
+      "duplicate": "Duplicate block",
+      "unknownBlock": "This block type no longer exists",
+      "close": "Close"
+    },
+    "issues": {
+      "title": "Issues",
+      "none": "No issues",
+      "missingTrigger": "The flow needs a trigger",
+      "multipleTriggers": "A flow can have only one trigger",
+      "unknownBlock": "Block of a type that no longer exists",
+      "unreachableNode": "Loose block: no path from the trigger reaches it",
+      "multipleInputs": "Block with more than one input",
+      "portFanOut": "An output can connect to one block only",
+      "cycle": "The blocks form a cycle",
+      "missingTrueBranch": "The condition has no yes path"
+    },
+    "run": {
+      "passed": "Passed",
+      "failed": "Did not pass",
+      "skipped": "Skipped",
+      "wouldRun": "Would run",
+      "error": "Error",
+      "blocked": "Blocked"
+    },
+    "controls": {
+      "zoomIn": "Zoom in",
+      "zoomOut": "Zoom out",
+      "fitView": "Fit view",
+      "undo": "Undo",
+      "redo": "Redo",
+      "layout": "Arrange blocks"
+    },
+    "node": {
+      "disabled": "Disabled",
+      "addBlock": "Add the next block",
+      "issueCount_one": "{{count}} issue",
+      "issueCount_other": "{{count}} issues"
+    },
+    "laneMap": {
+      "label": "Flow map"
+    }
+  },
   "followUp": {
     "messages": "Messages",
     "chat": {

package/dist/locales/en/ui.json.js

@@ -12,6 +12,7 @@ const detailsTable = { "size": "Size", "quantity": "Qty" };
 const errorPage = { "message": "This screen could not load", "headline": "Something unexpected happened while building the page. Refreshing usually fixes it. If it happens again, contact support and tell them what you were doing.", "backToStart": "Back to start" };
 const filters = { "activeFilters": "Applied filters", "appliedCount_one": "{{count}} filter applied", "appliedCount_other": "{{count}} filters applied", "clearAll": "Clear all", "noFields": "No filters available for this list.", "noOptions": "No options found.", "optionsError": "Could not load the options for {{field}}.", "rangeMax": "Maximum", "rangeMin": "Minimum", "rangeSeparator": "to", "searchOptions": "Search options" };
 const filtersDrawer = { "selectedFilters": "Selected filters:", "pendingChanges": "Pending changes", "discardChangesTitle": "Discard changes?", "discardChangesMessage": "You have unapplied filter changes. Discard them?", "keepEditing": "Keep editing", "discard": "Discard" };
+const flow = { "canvas": "Flow editor", "resizePanel": "Drag to adjust the width. Double click resets", "ports": { "next": "Next", "true": "Yes", "false": "No", "error": "Error" }, "categories": { "trigger": "Triggers", "condition": "Conditions", "action": "Actions" }, "palette": { "title": "Blocks", "search": "Search block", "empty": "No block found", "limitReached": "This flow already has the maximum of this block" }, "inspector": { "title": "Block settings", "empty": "Select a block to configure it", "label": "Block name", "delete": "Delete block", "duplicate": "Duplicate block", "unknownBlock": "This block type no longer exists", "close": "Close" }, "issues": { "title": "Issues", "none": "No issues", "missingTrigger": "The flow needs a trigger", "multipleTriggers": "A flow can have only one trigger", "unknownBlock": "Block of a type that no longer exists", "unreachableNode": "Loose block: no path from the trigger reaches it", "multipleInputs": "Block with more than one input", "portFanOut": "An output can connect to one block only", "cycle": "The blocks form a cycle", "missingTrueBranch": "The condition has no yes path" }, "run": { "passed": "Passed", "failed": "Did not pass", "skipped": "Skipped", "wouldRun": "Would run", "error": "Error", "blocked": "Blocked" }, "controls": { "zoomIn": "Zoom in", "zoomOut": "Zoom out", "fitView": "Fit view", "undo": "Undo", "redo": "Redo", "layout": "Arrange blocks" }, "node": { "disabled": "Disabled", "addBlock": "Add the next block", "issueCount_one": "{{count}} issue", "issueCount_other": "{{count}} issues" }, "laneMap": { "label": "Flow map" } };
 const followUp = { "messages": "Messages", "chat": { "loadingMessages": "Loading messages", "placeholder": "Write a message...", "invalidMessage": "Please enter a valid message", "noMessagesYet": "No messages yet", "startConversation": "Start a conversation by adding the first message", "loadError": "Messages could not be loaded", "sendFailed": "The message could not be sent. Try again.", "sendFailedInline": "Failed to send", "resend": "Resend", "discard": "Discard", "today": "Today", "yesterday": "Yesterday", "typingOne": "{{name}} is typing...", "typingMany": "{{count}} people are typing...", "someone": "Someone", "you": "You", "newMessages": "New messages", "backToLatest": "Back to latest", "deletedMessage": "Message deleted", "edited": "edited", "readBy": "Read by {{names}}", "copied": "Message copied", "replyingTo": "Replying to {{name}}", "attachmentFallback": "Attachment", "editTitle": "Edit message", "deleteTitle": "Delete message?", "deleteSubtitle": "The message will be shown as deleted for every participant", "sendHint": "Enter sends, Shift+Enter adds a line break", "formatting": "Formatting" }, "actions": { "reply": "Reply", "copy": "Copy text", "edit": "Edit", "delete": "Delete" }, "attachments": { "attach": "Attach", "pickFile": "File", "pickImage": "Image", "takePhoto": "Take photo", "dropHere": "Drop files to attach", "tooMany": "Limit of {{max}} attachments per message", "tooLarge": "The file {{name}} exceeds the 50 MB limit", "uploadFailed": "Upload failed", "uploading": "Uploading attachments...", "imagePreview": "Preview image", "showTranscript": "Show transcript", "hideTranscript": "Hide transcript" }, "voice": { "record": "Record audio", "recording": "Recording", "stop": "Finish recording", "cancel": "Cancel recording", "rerecord": "Record again", "attach": "Add to message", "discard": "Discard", "transcriptLabel": "Transcript", "transcriptPlaceholder": "The speech transcript appears here and can be edited" }, "camera": { "title": "Take photo", "unavailable": "Camera unavailable", "unavailableHint": "Check the browser camera permission", "switch": "Switch camera", "capture": "Capture photo" }, "search": { "open": "Search in conversation", "placeholder": "Search messages", "noResults": "No messages found", "error": "Messages could not be searched" } };
 const generatedByAI = { "tooltip": "Generated by AI" };
 const imageAiAdjust = { "action": "Adjust with AI", "title": "Adjust image with AI", "subtitle": "Describe the adjustment. The AI changes only what you ask and preserves the rest of the image.", "original": "Original", "result": "Result", "resultHint": "Describe the adjustment and click Generate to see the result here.", "promptLabel": "Desired adjustment", "promptPlaceholder": "E.g. remove the background and make it white, smooth the sleeve creases, brighten the lighting", "generate": "Generate", "generating": "Generating the image...", "tryAgain": "Generate another", "useResult": "Use this image", "errorGenerate": "Could not adjust the image with AI", "errorSave": "Could not save the adjusted image", "errorRefused": "The AI could not make this adjustment: {{reason}}", "mask": { "start": "Mark the area", "stop": "Use the whole image", "hint": "Paint the area the AI may change. The rest of the image is kept." }, "verification": { "changedMoreThanRequested": "The AI changed more than requested. Check the areas outside the adjustment before using it.", "colorMismatch": "The garment color ({{dominant}}) differs from the requested color ({{target}})." } };
@@ -50,6 +51,7 @@ const en = {
   errorPage,
   filters,
   filtersDrawer,
+  flow,
   followUp,
   generatedByAI,
   imageAiAdjust,
@@ -90,6 +92,7 @@ export {
   errorPage,
   filters,
   filtersDrawer,
+  flow,
   followUp,
   generatedByAI,
   imageAiAdjust,

package/dist/locales/en/ui.json.js.map

@@ -1 +1 @@
-{"version":3,"file":"ui.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"ui.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}