treege 3.0.0-beta.44 → 3.0.0-beta.45

package/dist/editor/context/OpenApiContext.d.ts

@@ -0,0 +1,79 @@
+import { ReactNode } from 'react';
+import { ApiRoute, OpenApiDocument } from '../types/openapi';
+/**
+ * The exact input the user fed to the OpenAPI dialog last time it loaded
+ * successfully. Kept around so re-opening the dialog can pre-fill the field
+ * (the user may want to tweak/re-load the same source).
+ */
+export type OpenApiSourceInput = {
+    mode: "url";
+    value: string;
+} | {
+    mode: "json";
+    value: string;
+};
+interface OpenApiContextValue {
+    /**
+     * The currently loaded OpenAPI document, or `null` when none is set.
+     */
+    document: OpenApiDocument | null;
+    /**
+     * Memoized flat list of routes derived from `document`.
+     */
+    routes: ApiRoute[];
+    /**
+     * User-provided base URL that overrides the document's `servers[0].url`.
+     * Useful when the OpenAPI spec points at a different environment than the
+     * one the user wants to call (e.g. staging vs prod). Empty string means
+     * "no override — use the document's declared server".
+     */
+    baseUrlOverride: string;
+    /**
+     * Effective base URL: the override when non-empty, otherwise the document's
+     * first declared server. Trailing slash trimmed.
+     */
+    baseUrl: string;
+    /**
+     * Last source input (URL or pasted JSON) used to load the document. `null`
+     * before the user has loaded anything.
+     */
+    lastSourceInput: OpenApiSourceInput | null;
+    /**
+     * Replace the loaded document. Pass `null` to clear.
+     */
+    setDocument: (next: OpenApiDocument | null) => void;
+    /**
+     * Replace the base URL override. Pass `""` to clear.
+     */
+    setBaseUrlOverride: (next: string) => void;
+    /**
+     * Record the last source input the user used to load the document.
+     */
+    setLastSourceInput: (next: OpenApiSourceInput | null) => void;
+}
+interface OpenApiProviderProps {
+    children: ReactNode;
+    /**
+     * Initial OpenAPI source. Accepts either a pre-parsed document or a URL
+     * string — when a URL is given, the provider fetches it on mount and
+     * toasts on failure (matching the runtime behavior of the dialog).
+     */
+    initialDocument?: OpenApiDocument | string | null;
+    /**
+     * Initial base URL. When set, takes precedence over the document's
+     * `servers[0].url`. Empty string means "no override".
+     */
+    initialBaseUrl?: string;
+}
+/**
+ * Holds the current OpenAPI document at editor scope. The document is
+ * editor-local state (not persisted in the flow JSON), so reloading the
+ * editor with a different consumer-supplied initial document is supported.
+ */
+export declare const OpenApiProvider: ({ children, initialDocument, initialBaseUrl }: OpenApiProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Read the OpenAPI context. Returns a no-op default outside of the provider
+ * so consumers (e.g., URL combobox) don't have to null-check.
+ */
+export declare const useOpenApi: () => OpenApiContextValue;
+export {};

package/dist/editor/context/TreegeEditorContext.d.ts

@@ -1,5 +1,6 @@
 import { PropsWithChildren } from 'react';
 import { AIConfig } from '../types/ai';
+import { HttpHeader } from '../../shared/types/node';
 export interface TreegeEditorContextValue {
     /**
      * Current language
@@ -9,6 +10,12 @@ export interface TreegeEditorContextValue {
      * Current flow ID
      */
     flowId?: string;
+    /**
+     * Global HTTP headers used by editor-time HTTP calls (e.g. the
+     * "Detect fields" button). Forwarded by the consumer; same shape and
+     * semantics as `TreegeRenderer`'s `headers`.
+     */
+    headers?: HttpHeader[];
     /**
      * Function to set the current flow ID
      * @param flow

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 }: TreegeEditorProps) => import("react/jsx-runtime").JSX.Element;
+declare const TreegeEditor: ({ flow, onExportJson, onSave, theme, language, aiConfig, extraMenuItems, openApi, openApiBaseUrl, onAuthorize, headers, onHeadersChange, }: TreegeEditorProps) => import("react/jsx-runtime").JSX.Element;
 export default TreegeEditor;

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

@@ -0,0 +1,20 @@
+import { HttpHeader } from '../../../../shared/types/node';
+interface AuthorizeDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onAuthorize?: (headers: HttpHeader[]) => void;
+}
+/**
+ * Reads supported security schemes from the loaded OpenAPI document and
+ * collects credentials from the user (Bearer token, API key value, or
+ * OAuth2 password grant). On submit, exchanges OAuth2 credentials at the
+ * token endpoint, builds the resulting `HttpHeader[]`, and calls
+ * `onAuthorize` so the consumer can forward them to the renderer's
+ * global `headers`.
+ *
+ * Inspired by Swagger UI's "Authorize" modal. OAuth2 flows other than
+ * `password` (auth_code, client_credentials, implicit) are out of scope —
+ * they require browser redirects, server-side state, or PKCE.
+ */
+declare const AuthorizeDialog: ({ open, onOpenChange, onAuthorize }: AuthorizeDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default AuthorizeDialog;

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

@@ -0,0 +1,19 @@
+import { HttpHeader } from '../../../../shared/types/node';
+interface HeadersDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    headers: HttpHeader[];
+    onChange: (headers: HttpHeader[]) => void;
+}
+/**
+ * Edit the editor's "global headers" — forwarded to every HTTP request the
+ * runtime form issues (HTTP inputs, submit buttons, options-source fetches).
+ * Field-level headers configured on individual nodes override these on key
+ * collision (case-insensitive).
+ *
+ * The dialog is fully controlled: the parent owns the headers list and
+ * receives every mutation via `onChange`, so the same value can be forwarded
+ * to `TreegeRenderer` without any state duplication.
+ */
+declare const HeadersDialog: ({ open, onOpenChange, headers, onChange }: HeadersDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default HeadersDialog;

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

@@ -0,0 +1,6 @@
+interface OpenApiDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+declare const OpenApiDialog: ({ open, onOpenChange }: OpenApiDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default OpenApiDialog;

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

@@ -0,0 +1,7 @@
+import { OptionsSource } from '../../../../shared/types/node';
+interface OptionsSourceFormProps {
+    value: OptionsSource | undefined;
+    onChange: (value: OptionsSource | undefined) => void;
+}
+declare const OptionsSourceForm: ({ value, onChange }: OptionsSourceFormProps) => import("react/jsx-runtime").JSX.Element;
+export default OptionsSourceForm;

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

@@ -0,0 +1,30 @@
+import { ComponentProps, ReactNode } from 'react';
+import { ApiRouteMethod } from '../../../types/openapi';
+import { Input } from '../../../../shared/components/ui/input';
+interface ApiUrlComboboxProps extends Omit<ComponentProps<typeof Input>, "onChange" | "value" | "children"> {
+    value: string;
+    /**
+     * Called whenever the URL changes. When `method` is set, the user picked
+     * a route from the OpenAPI document — callers should also update their
+     * HTTP method state accordingly.
+     */
+    onChange: (url: string, method?: ApiRouteMethod) => void;
+    /**
+     * Optional trailing adornments rendered next to the input (e.g. a variable
+     * picker). Always rendered, regardless of whether an OpenAPI document is
+     * loaded.
+     */
+    children?: ReactNode;
+}
+/**
+ * URL field that augments a regular `<Input>` with a Popover suggesting
+ * routes from the editor-loaded OpenAPI document. The user can either type
+ * a custom URL freely (current behavior preserved) or click the Globe icon
+ * to pick a route — selecting one resolves the URL with the document's
+ * server and emits the route's HTTP method back to the caller.
+ *
+ * When no OpenAPI document is loaded, the Globe trigger is hidden and the
+ * component is functionally identical to a plain `<Input>`.
+ */
+declare const ApiUrlCombobox: ({ value, onChange, placeholder, children, ...inputProps }: ApiUrlComboboxProps) => import("react/jsx-runtime").JSX.Element;
+export default ApiUrlCombobox;

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

@@ -1,6 +1,5 @@
 import { Node, NodeProps } from '@xyflow/react';
 import { FlowNodeData, InputNodeData, UINodeData } from '../../../../shared/types/node';
-export type TreegeNodeType = Node<FlowNodeData, "flow"> | Node<InputNodeData, "input"> | Node<UINodeData, "ui">;
 export type TreegeNodeProps = NodeProps<Node<FlowNodeData, "flow">> | NodeProps<Node<InputNodeData, "input">> | NodeProps<Node<UINodeData, "ui">>;
 declare const _default: import('react').MemoExoticComponent<(props: TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
 export default _default;

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

@@ -0,0 +1,5 @@
+interface NodeImageProps {
+    image?: string;
+}
+declare const NodeImage: ({ image }: NodeImageProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeImage;

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

@@ -0,0 +1,6 @@
+interface NodeImageButtonProps {
+    nodeId: string;
+    image?: string;
+}
+declare const NodeImageButton: ({ nodeId, image }: NodeImageButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeImageButton;

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

@@ -0,0 +1,12 @@
+import { FlowNodeData, InputNodeData, UINodeData } from '../../../../../shared/types/node';
+interface NodeOptionsProps {
+    nodeId: string;
+    data?: FlowNodeData | InputNodeData | UINodeData;
+    /**
+     * When true, hovering an option row reveals edit/delete icons. We gate the
+     * icons on selection so unselected nodes stay visually clean.
+     */
+    selected?: boolean;
+}
+declare const NodeOptions: ({ nodeId, data, selected }: NodeOptionsProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeOptions;

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

@@ -0,0 +1,6 @@
+interface NodeRequiredButtonProps {
+    nodeId: string;
+    required?: boolean;
+}
+declare const NodeRequiredButton: ({ nodeId, required }: NodeRequiredButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeRequiredButton;

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

@@ -1,9 +1,12 @@
 import { ExtraMenuItem } from '../../../types/editor';
-import { Flow } from '../../../../shared/types/node';
+import { Flow, HttpHeader } from '../../../../shared/types/node';
 export interface ActionsPanelProps {
     onExportJson?: (data: Flow) => void;
     onSave?: (data: Flow) => void;
     extraMenuItems?: ExtraMenuItem[];
+    onAuthorize?: (headers: HttpHeader[]) => void;
+    headers?: HttpHeader[];
+    onHeadersChange?: (headers: HttpHeader[]) => void;
 }
-declare const ActionsPanel: ({ onExportJson, onSave, extraMenuItems }: ActionsPanelProps) => import("react/jsx-runtime").JSX.Element;
+declare const ActionsPanel: ({ onExportJson, onSave, extraMenuItems, onAuthorize, headers, onHeadersChange }: ActionsPanelProps) => import("react/jsx-runtime").JSX.Element;
 export default ActionsPanel;

package/dist/editor/types/editor.d.ts

@@ -1,7 +1,8 @@
 import { Edge, Node } from '@xyflow/react';
 import { ReactNode } from 'react';
 import { AIConfig } from './ai';
-import { Flow } from '../../shared/types/node';
+import { OpenApiDocument } from './openapi';
+import { Flow, HttpHeader } from '../../shared/types/node';
 export interface ExtraMenuItem {
     /**
      * Label displayed in the menu item.
@@ -58,4 +59,41 @@ export interface TreegeEditorProps {
      * Extra menu items to append to the "more" dropdown of the actions panel.
      */
     extraMenuItems?: ExtraMenuItem[];
+    /**
+     * OpenAPI 3.x source used to power URL/route suggestions inside HTTP and
+     * Options-source forms, and to drive the Authorize flow. Accepts either:
+     * - a pre-parsed `OpenApiDocument` object
+     * - a URL string (the editor fetches it on mount and toasts on failure)
+     *
+     * Users can still load one at runtime via the editor's "OpenAPI" button.
+     */
+    openApi?: OpenApiDocument | string;
+    /**
+     * Base URL used for OpenAPI route resolution. When set, it takes precedence
+     * over the document's `servers[0].url` — useful when the spec points at a
+     * different environment than the one to call (e.g. staging vs prod).
+     */
+    openApiBaseUrl?: string;
+    /**
+     * Global HTTP headers applied to in-editor requests (e.g. the "Detect
+     * fields" button in `OptionsSourceForm`). Pass the same value you give to
+     * `TreegeRenderer` so editor-time previews use the same auth and headers
+     * that the runtime form will use.
+     */
+    headers?: HttpHeader[];
+    /**
+     * Called when the user submits the Authorize dialog. Receives the resulting
+     * HTTP headers (`Authorization`, API key headers…). The consumer is expected
+     * to forward those headers to `TreegeRenderer` (or `TreegeConfigProvider`)
+     * via its `headers` prop so every request issued by the form is authenticated.
+     */
+    onAuthorize?: (headers: HttpHeader[]) => void;
+    /**
+     * Called whenever the user edits the global headers via the editor's
+     * built-in "Global headers" dialog. The component is controlled — the
+     * parent is expected to update its `headers` state in response and pass
+     * the new list back via the `headers` prop, so every editor-time and
+     * runtime request reflects the change.
+     */
+    onHeadersChange?: (headers: HttpHeader[]) => void;
 }

package/dist/editor/types/openapi.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Minimal OpenAPI 3.x types — only what the editor needs to suggest API
+ * routes and authenticate against an API. Not a full OpenAPI definition.
+ *
+ * Swagger 2.0 (`swagger: "2.0"`) is intentionally not supported.
+ */
+export interface OpenApiDocument {
+    openapi: string;
+    info?: {
+        title?: string;
+        version?: string;
+        description?: string;
+    };
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    paths: Record<string, OpenApiPathItem | undefined>;
+    components?: {
+        securitySchemes?: Record<string, OpenApiSecurityScheme | undefined>;
+    };
+}
+export interface OpenApiPathItem {
+    get?: OpenApiOperation;
+    put?: OpenApiOperation;
+    post?: OpenApiOperation;
+    delete?: OpenApiOperation;
+    patch?: OpenApiOperation;
+}
+export interface OpenApiOperation {
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    operationId?: string;
+}
+/** HTTP Bearer auth scheme. */
+export interface OpenApiHttpBearerScheme {
+    type: "http";
+    scheme: "bearer";
+    bearerFormat?: string;
+    description?: string;
+}
+/** Header-based API key auth scheme. */
+export interface OpenApiApiKeyHeaderScheme {
+    type: "apiKey";
+    in: "header";
+    name: string;
+    description?: string;
+}
+/**
+ * OAuth2 with the `password` grant. The user provides username + password
+ * directly, the editor exchanges them at `tokenUrl` and uses the returned
+ * access token as a Bearer header.
+ *
+ * Other OAuth2 flows (`authorization_code`, `client_credentials`, `implicit`)
+ * are out of scope — they require browser redirects, server-side state, or
+ * PKCE.
+ */
+export interface OpenApiOAuth2PasswordScheme {
+    type: "oauth2";
+    /** Resolved against `servers[0].url` when the spec uses a relative path. */
+    tokenUrl: string;
+    description?: string;
+}
+/**
+ * Security schemes the editor supports today. Other schemes (OAuth2 flows
+ * other than password, cookie/query API keys, openIdConnect) are filtered
+ * out at extraction time.
+ */
+export type OpenApiSecurityScheme = OpenApiHttpBearerScheme | OpenApiApiKeyHeaderScheme | OpenApiOAuth2PasswordScheme;
+export type ApiRouteMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+/**
+ * One operation extracted from an OpenAPI document, flattened to a single
+ * (method, path) record for easy listing.
+ */
+export interface ApiRoute {
+    method: ApiRouteMethod;
+    path: string;
+    summary?: string;
+    operationId?: string;
+}

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

@@ -0,0 +1,35 @@
+import { ApiRoute, OpenApiDocument, OpenApiSecurityScheme } from '../types/openapi';
+/**
+ * Type guard validating that `value` is a usable OpenAPI 3.x document.
+ * Rejects 2.0 (Swagger) since we don't support it.
+ */
+export declare const isOpenApi3Document: (value: unknown) => value is OpenApiDocument;
+/**
+ * Load an OpenAPI document from either a remote URL or a raw JSON string.
+ * Throws when the input is empty, unreachable, malformed JSON, or not an
+ * OpenAPI 3.x document.
+ */
+export declare const loadOpenApiDocument: (input: string) => Promise<OpenApiDocument>;
+/**
+ * Flatten every (method, path) tuple defined in the document, preserving
+ * the path declaration order.
+ */
+export declare const extractApiRoutes: (doc: OpenApiDocument) => ApiRoute[];
+/** Returns the first declared server URL (with any trailing slash trimmed). */
+export declare const getBaseUrl: (doc: OpenApiDocument) => string;
+/** Resolve a path to a full URL using the document's first server. */
+export declare const resolveRouteUrl: (doc: OpenApiDocument, path: string) => string;
+/**
+ * Extract every supported security scheme from the document. Schemes other
+ * than `http+bearer` and `apiKey-in-header` are silently dropped — they're
+ * out of MVP scope.
+ */
+export declare const extractSecuritySchemes: (doc: OpenApiDocument) => Array<{
+    name: string;
+    scheme: OpenApiSecurityScheme;
+}>;
+/**
+ * Resolve a `tokenUrl` (which the OpenAPI spec sometimes leaves relative)
+ * against the document's first declared server URL.
+ */
+export declare const resolveTokenUrl: (tokenUrl: string, doc: OpenApiDocument) => string;