treege 3.0.0-beta.9 → 3.0.0-beta40

package/dist/renderer/features/TreegeRenderer/web/components/inputs/DefaultTimeInput.d.ts

@@ -1,3 +1,3 @@
 import { InputRenderProps } from '../../../../../types/renderer';
-declare const DefaultTimeInput: ({ node, value, setValue, error, label, placeholder, helperText }: InputRenderProps<"time">) => import("react/jsx-runtime").JSX.Element;
+declare const DefaultTimeInput: ({ node, value, setValue, error, label, placeholder, helperText, name, id }: InputRenderProps<"time">) => import("react/jsx-runtime").JSX.Element;
 export default DefaultTimeInput;

package/dist/renderer/features/TreegeRenderer/web/components/inputs/DefaultTimeRangeInput.d.ts

@@ -1,3 +1,3 @@
 import { InputRenderProps } from '../../../../../types/renderer';
-declare const DefaultTimeRangeInput: ({ node, value, setValue, error, label, helperText }: InputRenderProps<"timerange">) => import("react/jsx-runtime").JSX.Element;
+declare const DefaultTimeRangeInput: ({ node, value, setValue, error, label, helperText, id, name }: InputRenderProps<"timerange">) => import("react/jsx-runtime").JSX.Element;
 export default DefaultTimeRangeInput;

package/dist/renderer/hooks/useRenderNode.d.ts

@@ -0,0 +1,55 @@
+import { Node } from '@xyflow/react';
+import { ComponentType, ReactNode } from 'react';
+import { FormValues, InputRenderers, TreegeRendererComponents } from '../types/renderer';
+import { TreegeNodeData } from '../../shared/types/node';
+type AnyComponent = ComponentType<any>;
+type UseRenderNodeParams = {
+    config: {
+        components: TreegeRendererComponents;
+        language: string;
+    };
+    DefaultFormWrapper: AnyComponent;
+    DefaultGroup: AnyComponent;
+    DefaultSubmitButton: AnyComponent;
+    DefaultSubmitButtonWrapper?: AnyComponent;
+    defaultInputRenderers: InputRenderers;
+    defaultUI: Record<string, AnyComponent>;
+    formErrors: Record<string, string>;
+    formValues: FormValues;
+    missingRequiredFields: string[];
+    setFieldValue: (fieldId: string, value: unknown) => void;
+    visibleNodes: Node<TreegeNodeData>[];
+};
+/**
+ * Hook that returns rendering utilities for TreegeRenderer
+ * Shared between web and native TreegeRenderer
+ *
+ * Returns:
+ * - renderNode: Function to render individual nodes
+ * - FormWrapper: Form wrapper component with fallback
+ * - SubmitButton: Submit button component with fallback
+ * - SubmitButtonWrapper: Submit button wrapper component with fallback (web only, undefined for native)
+ */
+export declare const useRenderNode: ({ DefaultFormWrapper, DefaultGroup, DefaultSubmitButton, DefaultSubmitButtonWrapper, config, defaultInputRenderers, defaultUI, formErrors, formValues, missingRequiredFields, setFieldValue, visibleNodes, }: UseRenderNodeParams) => {
+    FormWrapper: ((props: {
+        children: ReactNode;
+        onSubmit: (e: import('react').FormEvent) => void;
+    }) => ReactNode) | AnyComponent;
+    renderNode: (node: Node<TreegeNodeData>) => ReactNode;
+    SubmitButton: ((props: {
+        label?: string;
+        disabled?: boolean;
+        [key: string]: unknown;
+    } | {
+        children?: ReactNode;
+        disabled?: boolean;
+        isSubmitting?: boolean;
+        onPress?: () => void;
+        [key: string]: unknown;
+    }) => ReactNode) | AnyComponent;
+    SubmitButtonWrapper: ((props: {
+        children: ReactNode;
+        missingFields?: string[];
+    }) => ReactNode) | AnyComponent;
+};
+export {};

package/dist/renderer/hooks/useSubmitHandler.d.ts

@@ -0,0 +1,34 @@
+import { Node } from '@xyflow/react';
+import { FormValues } from '../types/renderer';
+import { SubmitResult } from '../utils/submit';
+import { InputNodeData, TreegeNodeData } from '../../shared/types/node';
+/**
+ * Hook for handling form submission with submit button configuration
+ *
+ * This hook provides:
+ * - Submit button node detection
+ * - HTTP submission handling
+ * - Loading state management
+ * - Success/error message handling
+ * - Redirect handling
+ *
+ * @param visibleNodes - Currently visible nodes in the form
+ * @param formValues - Current form values
+ * @param language - Current language for translations
+ * @param inputNodes - All input nodes for form data conversion
+ * @returns Submit handler state and functions
+ */
+export declare const useSubmitHandler: (visibleNodes: Node<TreegeNodeData>[], formValues: FormValues, language: string, inputNodes: Node<InputNodeData>[]) => {
+    clearSubmitMessage: () => void;
+    handleSubmitWithConfig: (onSuccess?: (data: unknown) => void) => Promise<SubmitResult | null>;
+    hasSubmitConfig: boolean;
+    isSubmitting: boolean;
+    submitButtonNode: {
+        id: string;
+        data: InputNodeData;
+    } | null;
+    submitMessage: {
+        type: "success" | "error";
+        message: string;
+    } | null;
+};

package/dist/renderer/hooks/useTranslate.d.ts

@@ -1,10 +1,12 @@
+import { Translatable } from '../../shared/types/translate';
 /**
  * Hook for translating text in the renderer with context-aware language preference.
  *
  * This hook uses the language from TreegeRendererContext (or explicit override) and delegates to the shared useTranslate hook.
+ * All translations are automatically sanitized to prevent XSS attacks.
  *
  * @param language - Optional language override. If not provided, uses language from context.
- * @returns A function that translates either a translation key or a Translatable object
+ * @returns A function that translates either a translation key or a Translatable object (with XSS protection)
  *
  * @example
  * // Static translation (from translation files)
@@ -12,13 +14,13 @@
  * const errorMsg = t("validation.required"); // "This field is required"
  *
  * @example
- * // Dynamic translation (from node data)
+ * // Dynamic translation (from node data) - automatically sanitized
  * const t = useTranslate();
- * const label = t(node.data.label); // Translates user-defined content
+ * const label = t(node.data.label); // Translates and sanitizes user-defined content
  *
  * @example
  * // With explicit language
  * const t = useTranslate("fr");
  * const errorMsg = t("validation.required"); // "Ce champ est requis"
  */
-export declare const useTranslate: (language?: string) => (key?: import('../../main').Translatable | import('../../main').TranslationKey | string) => string;
+export declare const useTranslate: (language?: string) => (key?: Translatable | string) => string;

package/dist/renderer/index.d.ts

@@ -1,4 +1,5 @@
 export { TreegeConfigProvider, useTreegeConfig } from './context/TreegeConfigContext';
+export type { UseTreegeRendererReturn } from './features/TreegeRenderer/useTreegeRenderer';
 export { useTreegeRenderer } from './features/TreegeRenderer/useTreegeRenderer';
 export * from './features/TreegeRenderer/web/components/DefaultFormWrapper';
 export * from './features/TreegeRenderer/web/components/DefaultGroup';
@@ -13,5 +14,6 @@ export * from './utils/conditions';
 export * from './utils/file';
 export * from './utils/flow';
 export * from './utils/form';
+export * from './utils/sanitize';
 export { ThemeProvider, useTheme } from '../shared/context/ThemeContext';
 export { getTranslatedText } from '../shared/utils/translations';

package/dist/renderer/index.native.d.ts

@@ -0,0 +1,19 @@
+export { TreegeConfigProvider, useTreegeConfig } from './context/TreegeConfigContext';
+export * from './features/TreegeRenderer/native/components/DefaultFormWrapper';
+export * from './features/TreegeRenderer/native/components/DefaultGroup';
+export * from './features/TreegeRenderer/native/components/DefaultInputs';
+export * from './features/TreegeRenderer/native/components/DefaultSubmitButton';
+export * from './features/TreegeRenderer/native/components/DefaultSubmitButtonWrapper';
+export * from './features/TreegeRenderer/native/components/DefaultUI';
+export type { TreegeRendererNativeProps } from './features/TreegeRenderer/native/TreegeRenderer';
+export { default as TreegeRenderer } from './features/TreegeRenderer/native/TreegeRenderer';
+export type { UseTreegeRendererReturn } from './features/TreegeRenderer/useTreegeRenderer';
+export { useTreegeRenderer } from './features/TreegeRenderer/useTreegeRenderer';
+export type { TreegeRendererConfig } from './types/renderer';
+export * from './types/renderer';
+export * from './utils/conditions';
+export * from './utils/file';
+export * from './utils/flow';
+export * from './utils/form';
+export * from './utils/sanitize.native';
+export { getTranslatedText } from '../shared/utils/translations';

package/dist/renderer/types/renderer.d.ts

@@ -18,6 +18,7 @@ export type InputValueTypeMap = {
     password: string;
     radio: string;
     select: string | string[];
+    submit: undefined;
     switch: boolean;
     text: string;
     textarea: string;
@@ -28,10 +29,13 @@ export type InputValueTypeMap = {
  * Form values stored during rendering
  */
 export type FormValues = Record<string, any>;
+export type Meta = {
+    httpResponse?: unknown;
+};
 /**
  * Union of all possible input value types
  */
-export type InputValue = string | number | boolean | string[] | SerializableFile | SerializableFile[] | [string, string] | [string | undefined, string | undefined] | null;
+export type InputValue = string | number | boolean | string[] | SerializableFile | SerializableFile[] | [string, string] | [string | undefined, string | undefined] | null | undefined;
 /**
  * Props for input components with dynamic value typing
  * All form state is provided via props for easier custom component implementation
@@ -45,6 +49,15 @@ export type InputRenderProps<T extends InputType = InputType> = {
      * Current value of the input field (typed based on input type when T is specified)
      */
     value: InputValueTypeMap[T];
+    /**
+     * Unique field ID (nodeId)
+     */
+    id: string;
+    /**
+     * Field name (resolved using priority: name > label > nodeId)
+     * Use this for the name and id attributes of the input element
+     */
+    name: string;
     /**
      * Function to update the input value
      * @param value - The new value (typed based on input type when T is specified)
@@ -66,6 +79,14 @@ export type InputRenderProps<T extends InputType = InputType> = {
      * Translated helper text (already processed with current language)
      */
     helperText?: string;
+    /**
+     * Missing required fields on form submit (for submit inputs)
+     */
+    missingRequiredFields?: string[];
+    /**
+     * Whether the form is currently being submitted (for submit inputs)
+     */
+    isSubmitting?: boolean;
 };
 export type UiRenderProps = {
     node: Node<UINodeData>;
@@ -99,7 +120,9 @@ export type TreegeRendererComponents = {
     /**
      * Custom group container renderer
      */
-    group?: (props: NodeRenderProps) => ReactNode;
+    group?: (props: NodeRenderProps & {
+        children?: ReactNode;
+    }) => ReactNode;
     /**
      * Custom form wrapper
      */
@@ -108,10 +131,20 @@ export type TreegeRendererComponents = {
         onSubmit: (e: FormEvent) => void;
     }) => ReactNode;
     /**
-     * Custom submit button (pure button without wrapper)
+     * Custom submit button (supports both web and native variants)
+     * Web variant: { label?: string; disabled?: boolean; ...otherHTMLAttributes }
+     * Native variant: { children?: ReactNode; disabled?: boolean; isSubmitting?: boolean; onPress?: () => void }
      */
     submitButton?: (props: {
         label?: string;
+        disabled?: boolean;
+        [key: string]: unknown;
+    } | {
+        children?: ReactNode;
+        disabled?: boolean;
+        isSubmitting?: boolean;
+        onPress?: () => void;
+        [key: string]: unknown;
     }) => ReactNode;
     /**
      * Custom submit button wrapper (e.g., for tooltip with missing fields)
@@ -154,7 +187,11 @@ export type TreegeRendererConfig = {
 /**
  * Props for the TreegeRenderer component
  */
-export type TreegeRendererProps = {
+export interface TreegeRendererProps {
+    /**
+     * Additional class name for the renderer container
+     */
+    className?: string;
     /**
      * Custom component renderers
      */
@@ -184,8 +221,10 @@ export type TreegeRendererProps = {
     onChange?: (values: FormValues) => void;
     /**
      * Callback when form is submitted
+     * @param values - Form values (keyed by field name or node ID)
+     * @param meta - Optional metadata about the submission (e.g., HTTP response data)
      */
-    onSubmit?: (values: FormValues) => void;
+    onSubmit?: (values: FormValues, meta?: Meta) => void;
     /**
      * Theme for the renderer
      * @default "dark"
@@ -199,4 +238,4 @@ export type TreegeRendererProps = {
      * Validation mode
      */
     validationMode?: "onChange" | "onSubmit";
-};
+}

package/dist/renderer/utils/form.d.ts

@@ -20,7 +20,27 @@ export declare const checkFormFieldHasValue: (fieldName: string | undefined, for
 /**
  * Convert internal form values (keyed by nodeId) to external format (keyed by name)
  * When multiple nodes share the same name, later values overwrite earlier ones
- * example: convertFormValuesToNamedFormat({ id1: 'Alice', id2: 'Bob' }, [ { id: 'id1', data: { name: 'firstName' } }, { id: 'id2', data: { name: 'lastName' } } ])
- * returns { firstName: 'Alice', lastName: 'Bob' }
+ * Priority for key naming: name > label (en) > nodeId
+ * example: convertFormValuesToNamedFormat({ id1: 'Alice', id2: 'Bob' }, [ { id: 'id1', data: { name: 'firstName' } }, { id: 'id2', data: { label: { en: 'Last Name' } } } ])
+ * returns { firstName: 'Alice', 'Last Name': 'Bob' }
  */
 export declare const convertFormValuesToNamedFormat: (formValues: FormValues, nodes: Node<InputNodeData>[]) => Record<string, unknown>;
+/**
+ * Apply transformation to a reference field value
+ * @param value - The source value to transform
+ * @param transformFunction - The transformation function to apply
+ * @param objectMapping - Optional mapping for toObject transformation
+ * @returns The transformed value
+ */
+export declare const applyReferenceTransformation: (value: unknown, transformFunction: "toString" | "toNumber" | "toBoolean" | "toArray" | "toObject" | null | undefined, objectMapping?: Array<{
+    sourceKey: string;
+    targetKey: string;
+}>) => unknown;
+/**
+ * Calculate updated values for fields with reference defaults
+ * @param inputNodes - Array of input nodes
+ * @param formValues - Current form values
+ * @param prevFormValues - Previous form values (for change detection)
+ * @returns Object containing fields that need to be updated
+ */
+export declare const calculateReferenceFieldUpdates: (inputNodes: Node<InputNodeData>[], formValues: FormValues, prevFormValues: FormValues) => FormValues;

package/dist/renderer/utils/http.d.ts

@@ -0,0 +1,101 @@
+import { FormValues } from '../types/renderer';
+import { HttpHeader } from '../../shared/types/node';
+/**
+ * Result of an HTTP request
+ */
+export interface HttpRequestResult {
+    /**
+     * Whether the request was successful (2xx status code)
+     */
+    success: boolean;
+    /**
+     * Response data (parsed JSON or raw text)
+     */
+    data?: unknown;
+    /**
+     * Error message if request failed
+     */
+    error?: string;
+    /**
+     * HTTP status code
+     */
+    status?: number;
+    /**
+     * HTTP status text
+     */
+    statusText?: string;
+}
+/**
+ * Options for making an HTTP request
+ */
+export interface HttpRequestOptions {
+    /**
+     * The URL to call (should already have variables replaced)
+     */
+    url: string;
+    /**
+     * HTTP method
+     */
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    /**
+     * Request headers
+     */
+    headers?: HttpHeader[];
+    /**
+     * Request body (for POST/PUT/PATCH)
+     */
+    body?: string;
+}
+/**
+ * Make an HTTP request with common error handling and response parsing
+ *
+ * This is a shared utility used by both HTTP inputs and submit buttons
+ * to ensure consistent behavior across the library.
+ *
+ * @param options - Request options
+ * @returns Promise with request result
+ */
+export declare const makeHttpRequest: (options: HttpRequestOptions) => Promise<HttpRequestResult>;
+/**
+ * Replace template variables in a string with actual values from form data
+ *
+ * Uses {{fieldId}} syntax for all replacements (URLs, JSON bodies, etc.)
+ *
+ * Smart JSON handling:
+ * - Strings: automatically wrapped in quotes and escaped
+ * - Numbers/Booleans: converted to JSON-safe format
+ * - Arrays/Objects: JSON.stringify
+ *
+ * @param template - The template string containing variables
+ * @param values - Form values to substitute
+ * @param options - Replacement options
+ * @param options.encode - Whether to URL-encode the replaced values (for URLs)
+ * @param options.json - Whether to use smart JSON handling (for request bodies)
+ * @returns The string with variables replaced
+ *
+ * @example
+ * // For URLs (with encoding)
+ * replaceTemplateVariables("https://api.com/users/{{userId}}", { userId: "john doe" }, { encode: true })
+ * // => "https://api.com/users/john%20doe"
+ *
+ * // For JSON bodies (smart handling)
+ * replaceTemplateVariables('{"name": {{userName}}}', { userName: "John" }, { json: true })
+ * // => '{"name": "John"}'
+ *
+ * replaceTemplateVariables('{"age": {{userAge}}}', { userAge: 25 }, { json: true })
+ * // => '{"age": 25}'
+ */
+export declare const replaceTemplateVariables: (template: string | undefined, values: FormValues, options?: {
+    encode?: boolean;
+    json?: boolean;
+}) => string;
+/**
+ * Replace template variables in response data (for redirect URLs)
+ *
+ * Supports {{response.field}} format to access response data
+ *
+ * @param template - The template string containing variables
+ * @param responseData - Response data object
+ * @returns The string with variables replaced
+ */
+export declare const replaceResponseVariables: (template: string | undefined, responseData: unknown) => string;

package/dist/renderer/utils/node.d.ts

@@ -6,9 +6,26 @@ import { InputNodeData, TreegeNodeData } from '../../shared/types/node';
  * @returns Array of input nodes only
  */
 export declare const getInputNodes: (nodes: Node<TreegeNodeData>[]) => Node<InputNodeData>[];
+/**
+ * Resolve the key name for an input node using priority: name > label (en) > nodeId
+ * This is the single source of truth for key resolution across the application
+ * @param node - The input node
+ * @returns The resolved key (name, label, or node ID)
+ */
+export declare const resolveNodeKey: (node: Node<InputNodeData>) => string;
+/**
+ * Resolve the placeholder text for an input, falling back to the static
+ * "newAnswer" translation for textfield-like types when the user has not
+ * defined a placeholder for the current language.
+ * @param data - The input node data
+ * @param language - The current language code
+ * @returns The resolved placeholder string (empty string if none available)
+ */
+export declare const resolveInputPlaceholder: (data: InputNodeData, language: string) => string;
 /**
  * Get the field name (DOM name attribute) for a given node ID
- * Uses node.data.name if available, otherwise falls back to nodeId
+ * Priority: name > label (en) > nodeId
+ * This must match the logic in convertFormValuesToNamedFormat for consistency
  * @param nodeId - The ID of the input node
  * @param nodes - Array of input nodes
  * @returns The field name to use in the DOM, or undefined if node not found

package/dist/renderer/utils/sanitize.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Configuration for DOMPurify sanitization
+ */
+interface SanitizeOptions {
+    /**
+     * Allow only plain text (strip all HTML tags)
+     * @default true
+     */
+    plainTextOnly?: boolean;
+    /**
+     * Custom allowed tags (when plainTextOnly is false)
+     */
+    allowedTags?: string[];
+    /**
+     * Custom allowed attributes (when plainTextOnly is false)
+     */
+    allowedAttributes?: string[];
+}
+/**
+ * Sanitizes user input to prevent XSS attacks
+ *
+ * This utility wraps DOMPurify and provides secure defaults for the treege library.
+ * It should be used on all user-provided content before rendering, especially:
+ * - Labels from node data
+ * - Helper text
+ * - Placeholder text
+ * - Any content from HTTP responses
+ *
+ * @param input - The string to sanitize
+ * @param options - Sanitization options
+ * @returns Sanitized string safe for rendering
+ *
+ * @example
+ * // Plain text only (default behavior)
+ * sanitize('<script>alert("xss")</script>Hello')
+ * // => 'Hello'
+ *
+ * @example
+ * // Allow safe HTML tags
+ * sanitize('<b>Bold text</b><script>alert("xss")</script>', { plainTextOnly: false })
+ * // => '<b>Bold text</b>'
+ *
+ * @example
+ * // Custom allowed tags
+ * sanitize('<a href="http://example.com">Link</a>', {
+ *   plainTextOnly: false,
+ *   allowedTags: ['a'],
+ *   allowedAttributes: ['href']
+ * })
+ * // => '<a href="http://example.com">Link</a>'
+ */
+export declare const sanitize: (input: string | undefined | null, options?: SanitizeOptions) => string;
+/**
+ * Sanitizes data from HTTP responses
+ *
+ * This function recursively sanitizes all string values in an object or array.
+ * Useful for cleaning data received from external APIs before displaying it.
+ *
+ * Protection against:
+ * - Circular references: Uses WeakSet to detect and handle circular objects
+ * - Deep nesting attacks: Limits recursion depth to prevent DoS
+ * - XSS attacks: Sanitizes all string values
+ *
+ * @param data - The data to sanitize (can be any type)
+ * @param options - Sanitization options
+ * @param depth - Current recursion depth (internal use)
+ * @param seen - WeakSet to track visited objects (internal use)
+ * @returns Sanitized data with same structure
+ *
+ * @example
+ * sanitizeHttpResponse({
+ *   name: 'John <script>xss</script>',
+ *   nested: { title: 'Hello <b>world</b>' }
+ * })
+ * // => { name: 'John ', nested: { title: 'Hello <b>world</b>' } }
+ *
+ * @example
+ * // Handles circular references gracefully
+ * const obj = { name: 'Test' };
+ * obj.self = obj;
+ * sanitizeHttpResponse(obj)
+ * // => { name: 'Test', self: { name: 'Test' } } // circular ref broken
+ */
+export declare const sanitizeHttpResponse: (data: unknown, options?: SanitizeOptions, depth?: number, seen?: WeakSet<object>) => unknown;
+export {};

package/dist/renderer/utils/sanitize.native.d.ts

@@ -0,0 +1,69 @@
+/**
+ * React Native implementation of sanitization utilities
+ * Does not use DOMPurify as it depends on browser DOM
+ */
+/**
+ * Configuration for sanitization
+ */
+interface SanitizeOptions {
+    /**
+     * Allow only plain text (strip all HTML tags)
+     * @default true
+     */
+    plainTextOnly?: boolean;
+    /**
+     * Custom allowed tags (when plainTextOnly is false)
+     * Note: In React Native, HTML tags are always stripped
+     */
+    allowedTags?: string[];
+    /**
+     * Custom allowed attributes (when plainTextOnly is false)
+     * Note: In React Native, attributes are not applicable
+     */
+    allowedAttributes?: string[];
+}
+/**
+ * Sanitizes user input to prevent XSS attacks
+ *
+ * React Native implementation that strips all HTML tags and decodes entities.
+ * Since React Native doesn't render HTML, we focus on cleaning text content.
+ *
+ * @param input - The string to sanitize
+ * @param options - Sanitization options (maintained for API compatibility)
+ * @returns Sanitized string safe for rendering
+ *
+ * @example
+ * sanitize('<script>alert("xss")</script>Hello')
+ * // => 'Hello'
+ *
+ * @example
+ * sanitize('<b>Bold text</b><script>alert("xss")</script>')
+ * // => 'Bold text'
+ */
+export declare const sanitize: (input: string | undefined | null, _options?: SanitizeOptions) => string;
+/**
+ * Sanitizes data from HTTP responses
+ *
+ * This function recursively sanitizes all string values in an object or array.
+ * Useful for cleaning data received from external APIs before displaying it.
+ *
+ * Protection against:
+ * - Circular references: Uses WeakSet to detect and handle circular objects
+ * - Deep nesting attacks: Limits recursion depth to prevent DoS
+ * - XSS attacks: Sanitizes all string values
+ *
+ * @param data - The data to sanitize (can be any type)
+ * @param options - Sanitization options
+ * @param depth - Current recursion depth (internal use)
+ * @param seen - WeakSet to track visited objects (internal use)
+ * @returns Sanitized data with same structure
+ *
+ * @example
+ * sanitizeHttpResponse({
+ *   name: 'John <script>xss</script>',
+ *   nested: { title: 'Hello <b>world</b>' }
+ * })
+ * // => { name: 'John ', nested: { title: 'Hello world' } }
+ */
+export declare const sanitizeHttpResponse: (data: unknown, options?: SanitizeOptions, depth?: number, seen?: WeakSet<object>) => unknown;
+export {};

package/dist/renderer/utils/submit.d.ts

@@ -0,0 +1,47 @@
+import { Node } from '@xyflow/react';
+import { FormValues } from '../types/renderer';
+import { InputNodeData, SubmitConfig } from '../../shared/types/node';
+/**
+ * Result of a form submission
+ */
+export interface SubmitResult {
+    /**
+     * Whether the submission was successful
+     */
+    success: boolean;
+    /**
+     * Response data from the server
+     */
+    data?: unknown;
+    /**
+     * Error message if submission failed
+     */
+    error?: string;
+    /**
+     * URL to redirect to (if configured)
+     */
+    redirectUrl?: string;
+}
+/**
+ * Submit form data using the provided submit configuration
+ *
+ * This function handles:
+ * - Template variable replacement in URL, body, and headers
+ * - HTTP request to the configured endpoint
+ * - Response parsing
+ * - Redirect URL generation with response data
+ *
+ * @param config - Submit configuration from the submit button node
+ * @param formValues - Current form values
+ * @param inputNodes - All input nodes (required when sendAllFormValues is true)
+ * @returns Promise with submission result
+ */
+export declare const submitFormData: (config: SubmitConfig, formValues: FormValues, inputNodes: Node<InputNodeData>[]) => Promise<SubmitResult>;
+/**
+ * Perform redirect to the specified URL
+ *
+ * Handles both relative and absolute URLs
+ *
+ * @param url - The URL to redirect to
+ */
+export declare const redirect: (url: string) => void;

package/dist/renderer-native.d.ts

@@ -0,0 +1,2 @@
+export * from './renderer/index.native'
+export {}