treege 3.0.0-beta.54 → 3.0.0-beta.56

package/dist/editor/constants/edgeTypes.d.ts

@@ -1,4 +1,4 @@
 export declare const EDGE_TYPES: {
     conditional: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: import('../features/TreegeEditor/edges/ConditionalEdge').ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
-    default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, }: import('@xyflow/react').EdgeProps) => import("react/jsx-runtime").JSX.Element>;
+    default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, }: import('@xyflow/react').EdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
 };

package/dist/editor/features/TreegeEditor/edges/DefaultEdge.d.ts

@@ -1,3 +1,3 @@
 import { EdgeProps } from '@xyflow/react';
-declare const _default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, }: EdgeProps) => import("react/jsx-runtime").JSX.Element>;
+declare const _default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, }: EdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
 export default _default;

package/dist/editor/features/TreegeEditor/forms/OptionsMappingFields.d.ts

@@ -0,0 +1,34 @@
+import { HttpHeader, OptionsSourceMapping, QueryParam } from '../../../../shared/types/node';
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+export interface OptionsMappingRequest {
+    url?: string;
+    method?: HttpMethod;
+    headers?: HttpHeader[];
+    queryParams?: QueryParam[];
+    body?: string;
+    responsePath?: string;
+}
+interface OptionsMappingFieldsProps {
+    /** Request config used by the "Detect fields" button to call the API. */
+    request: OptionsMappingRequest;
+    /** Current field-to-property mapping. */
+    mapping: Partial<OptionsSourceMapping>;
+    /** Called with a partial patch whenever a mapping field changes. */
+    onMappingChange: (patch: Partial<OptionsSourceMapping>) => void;
+    /** When true, also exposes the optional description/image mappings. */
+    showOptionalFields?: boolean;
+}
+/**
+ * Walks the first array item to enumerate field paths usable as mapping keys.
+ * Includes top-level keys and one level of nested object dot-paths.
+ */
+export declare const detectFieldPaths: (response: unknown, responsePath: string) => string[];
+/**
+ * Shared "map response to options" UI: a "Detect fields" button that probes
+ * the configured endpoint to enumerate response field paths, plus the
+ * value/label (and optionally description/image) mapping inputs. Once fields
+ * are detected the inputs become dropdowns of the detected paths. Used by both
+ * the HTTP input config and the dynamic options source so they stay identical.
+ */
+declare const OptionsMappingFields: ({ request, mapping, onMappingChange, showOptionalFields }: OptionsMappingFieldsProps) => import("react/jsx-runtime").JSX.Element;
+export default OptionsMappingFields;

package/dist/editor/features/TreegeEditor/nodes/components/BottomHandleDropdown.d.ts

@@ -1,9 +1,25 @@
 interface BottomHandleDropdownProps {
     nodeId: string;
     isConnectable?: boolean;
+    /** Submit nodes / multi-selection: the handle stays in the DOM so edges keep an anchor, but it is invisible and non-interactive. */
     hidden?: boolean;
-    /** Whether branching (forking into two nodes) is allowed — only for input nodes. */
+    /** Whether branching (a second outgoing path) is allowed — only for input nodes. */
     canBranch?: boolean;
+    /**
+     * True when the node sits before a linear successor (stack first/middle). The
+     * controls then reveal on hover (the bottom border overlaps the next node) and
+     * offer "insert between". On a tail (last/single) the controls stay visible.
+     */
+    isJunction?: boolean;
 }
-declare const BottomHandleDropdown: ({ nodeId, isConnectable, hidden, canBranch }: BottomHandleDropdownProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Bottom-of-node controls anchored on the node's bottom border.
+ *
+ * The branch/add affordance is a real React Flow source `Handle`, so dragging it
+ * goes through the native connection system (cursor line, target snapping, leaf
+ * convergence, `isValidConnection`) — both for adding a child on a tail node and
+ * for branching a new path on a junction node. On junctions an extra "insert
+ * between" button splices a node before the existing successor.
+ */
+declare const BottomHandleDropdown: ({ nodeId, isConnectable, hidden, canBranch, isJunction }: BottomHandleDropdownProps) => import("react/jsx-runtime").JSX.Element;
 export default BottomHandleDropdown;

package/dist/editor/features/TreegeEditor/nodes/components/NodeTypePickerMenuContent.d.ts

@@ -0,0 +1,12 @@
+import { NodeInit } from '../../../../hooks/useFlowConnections';
+interface NodeTypePickerMenuContentProps {
+    /** Called with the picked node type. */
+    onSelect: (nodeInit: NodeInit) => void;
+}
+/**
+ * Shared dropdown body listing every creatable node type (inputs + UI). Used by
+ * the bottom handle (add child / branch) and the junction insert button so the
+ * picker stays identical across affordances.
+ */
+declare const NodeTypePickerMenuContent: ({ onSelect }: NodeTypePickerMenuContentProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeTypePickerMenuContent;

package/dist/editor/utils/edge.d.ts

@@ -1,4 +1,39 @@
-import { Edge } from '@xyflow/react';
+import { Edge, Node } from '@xyflow/react';
+/**
+ * Whether an edge from `source` to `target` already exists in the set.
+ * Used to reject duplicate connections.
+ */
+export declare const edgeExists: (edges: Edge[], source: string, target: string) => boolean;
+type LeafNode = Pick<Node, "id" | "position" | "parentId">;
+interface BuildConvergenceOptions {
+    /** ID for the new common node. */
+    commonNodeId: string;
+    /** Base node template the common node is spread from (e.g. DEFAULT_NODE). */
+    baseNode: Partial<Node>;
+    /** Measured node height, used to place the common node below both leaves. */
+    nodeHeight: number;
+    /** Vertical gap between the leaves and the common node. */
+    verticalSpacing: number;
+}
+/**
+ * Build the common node that converges two leaves, plus the two edges wiring
+ * each leaf to it (`source → common`, `target → common`). The node is centered
+ * horizontally between the leaves and placed one row below the lower one. It
+ * inherits the group only when both leaves share the same `parentId`.
+ *
+ * Pure and deterministic — the caller supplies the new node id, base template
+ * and measured dimensions — so it can be unit-tested without React Flow.
+ */
+export declare const buildConvergence: (sourceNode: LeafNode, targetNode: LeafNode, { commonNodeId, baseNode, nodeHeight, verticalSpacing }: BuildConvergenceOptions) => {
+    node: Node;
+    edges: Edge[];
+};
+/**
+ * Whether adding an edge `source` → `target` would introduce a cycle, i.e.
+ * `target` can already reach `source` by following outgoing edges. BFS from
+ * `target` over the existing edges; returns true as soon as `source` is found.
+ */
+export declare const wouldCreateCycle: (edges: Edge[], source: string, target: string) => boolean;
 /**
  * Re-normalize outgoing edges from a set of affected parent nodes: if a parent
  * now has a single remaining child, convert its outgoing edge back to a
@@ -12,3 +47,4 @@ import { Edge } from '@xyflow/react';
  * @returns A new edges array with affected edges normalized
  */
 export declare const normalizeConditionalEdges: (edges: Edge[], affectedParents: Set<string>) => Edge[];
+export {};