treege 3.0.0-beta.55 → 3.0.0-beta.57

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/context/TreegeEditorContext.d.ts

@@ -3,9 +3,16 @@ import { AIConfig } from '../types/ai';
 import { HttpHeader } from '../../shared/types/node';
 export interface TreegeEditorContextValue {
     /**
-     * Current language
+     * Current language of the editor UI. Also used as the default language for
+     * the per-node translation editor in `InputNodeForm`.
      */
     language: string;
+    /**
+     * Set the editor UI language at runtime (driven by the language switcher in
+     * the actions panel). Seeded from the `language` prop, then owned internally;
+     * the consumer can observe changes via `TreegeEditor`'s `onLanguageChange`.
+     */
+    setLanguage: (language: string) => void;
     /**
      * Current flow ID
      */

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

@@ -1,3 +1,3 @@
 import { TreegeEditorProps } from '../../types/editor';
-declare const TreegeEditor: ({ flow, onExportJson, onSave, theme, language, aiConfig, extraMenuItems, openApi, openApiBaseUrl, onAuthorize, headers, onHeadersChange, }: TreegeEditorProps) => import("react/jsx-runtime").JSX.Element;
+declare const TreegeEditor: ({ flow, onExportJson, onSave, theme, language: controlledLanguage, defaultLanguage, onLanguageChange, aiConfig, extraMenuItems, openApi, openApiBaseUrl, onAuthorize, headers, onHeadersChange, }: TreegeEditorProps) => import("react/jsx-runtime").JSX.Element;
 export default TreegeEditor;

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/forms/SensitiveHeaderWarning.d.ts

@@ -0,0 +1,13 @@
+import { HttpHeader } from '../../../../shared/types/node';
+interface SensitiveHeaderWarningProps {
+    headers?: HttpHeader[];
+}
+/**
+ * Inline alert shown when a field-level header carries credentials (e.g. an
+ * `Authorization` bearer or API key). These headers are persisted in the
+ * exported/saved tree, so the user is nudged toward the non-persisted global
+ * headers (Authorize) for authentication. Renders nothing when no sensitive
+ * header is present.
+ */
+declare const SensitiveHeaderWarning: ({ headers }: SensitiveHeaderWarningProps) => import("react/jsx-runtime").JSX.Element | null;
+export default SensitiveHeaderWarning;

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/types/editor.d.ts

@@ -44,9 +44,27 @@ export interface TreegeEditorProps {
      */
     theme?: "dark" | "light";
     /**
-     * Language for the editor interface.
+     * Controlled editor UI language. When provided, the editor runs in controlled
+     * mode: this value always wins and the built-in switcher only fires
+     * `onLanguageChange` — you must update this prop to actually change the
+     * language. Leave undefined to let the editor manage it itself (see
+     * `defaultLanguage`).
      */
     language?: string;
+    /**
+     * Initial editor UI language in uncontrolled mode. The editor seeds its
+     * internal state with this value, then owns it so the user can switch at
+     * runtime via the actions panel. Ignored when `language` is provided.
+     * @default "en"
+     */
+    defaultLanguage?: string;
+    /**
+     * Called whenever the user switches the editor language via the built-in
+     * switcher, with the newly selected language. Required to react to the change
+     * in controlled mode; optional in uncontrolled mode (use it to persist or
+     * sync the choice).
+     */
+    onLanguageChange?: (language: string) => void;
     /**
      * AI configuration for tree generation
      */

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

@@ -0,0 +1,5 @@
+/**
+ * Returns a copy of `data` with config blocks that don't belong to `subType`
+ * removed. Pure — returns the same reference when nothing is dropped.
+ */
+export declare const cleanConfigForSubType: <T extends Record<string, unknown>>(data: T, subType: string) => T;

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 {};

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

@@ -0,0 +1,15 @@
+import { Flow, HttpHeader } from '../../shared/types/node';
+/** True when a header key is known to carry credentials/secrets. */
+export declare const isSensitiveHeaderKey: (key: string) => boolean;
+/** True when the list contains a sensitive header with a non-empty value. */
+export declare const hasSensitiveHeader: (headers?: HttpHeader[]) => boolean;
+/**
+ * Returns a copy of the flow with all credential-bearing field-level headers
+ * removed from every node's httpConfig/optionsSource/submitConfig, plus the
+ * number of headers stripped. The input flow is never mutated, so the live
+ * editor canvas keeps its values — only the exported/saved artifact is cleaned.
+ */
+export declare const stripSensitiveHeadersFromFlow: (flow: Flow) => {
+    flow: Flow;
+    strippedCount: number;
+};