treege 3.0.0-beta.2 → 3.0.0-beta.21

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

@@ -13,5 +13,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/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,20 +29,35 @@ 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
  */
 export type InputRenderProps<T extends InputType = InputType> = {
+    /**
+     * The node data for this input field
+     */
     node: Node<InputNodeData>;
     /**
      * 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)
@@ -51,6 +67,26 @@ export type InputRenderProps<T extends InputType = InputType> = {
      * Validation error message for this field (if any)
      */
     error?: string;
+    /**
+     * Translated label (already processed with current language)
+     */
+    label?: string;
+    /**
+     * Translated placeholder (already processed with current language)
+     */
+    placeholder?: string;
+    /**
+     * 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>;
@@ -169,8 +205,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"

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,17 @@ 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;
 /**
  * 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/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 sendFormData 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.js

@@ -1,45 +1,49 @@
-import { c as t, d as s, e as u, f as l, g as r, h as n, D as i, i as o, j as f, k as d, l as p, m as D, n as I, o as T, p as m, q as g, r as F, s as c, v, w as x, T as R, b as S, J as b, K as h, t as C, x as w, y as z, z as A, A as H, C as N, F as k, G as P, I as y, E, H as G, B as V, u as j, a as q } from "./TreegeRenderer-D3EvsEfJ.js";
-import { T as J, g as K, u as U } from "./ThemeContext-BIvs8Kw-.js";
+import { c as t, d as s, e as u, f as l, g as n, h as r, D as i, i as o, j as f, k as p, l as d, m as D, n as I, o as T, p as m, q as g, r as c, s as F, v as R, w as v, T as x, b as S, L as b, M as h, J as z, K as C, t as w, x as H, y as N, z as A, A as k, C as y, F as P, G as E, I as G, E as U, H as V, N as j, O as q, B, u as J, a as K } from "./TreegeRenderer-Ci_Ym86Y.js";
+import { T as M, g as O, u as Q } from "./ThemeContext-BIT4DHqC.js";
 export {
   t as DefaultAddressInput,
   s as DefaultAutocompleteInput,
   u as DefaultCheckboxInput,
   l as DefaultDateInput,
-  r as DefaultDateRangeInput,
-  n as DefaultFileInput,
+  n as DefaultDateRangeInput,
+  r as DefaultFileInput,
   i as DefaultGroup,
   o as DefaultHiddenInput,
   f as DefaultHttpInput,
-  d as DefaultNumberInput,
-  p as DefaultPasswordInput,
+  p as DefaultNumberInput,
+  d as DefaultPasswordInput,
   D as DefaultRadioInput,
   I as DefaultSelectInput,
   T as DefaultSwitchInput,
   m as DefaultTextAreaInput,
   g as DefaultTextInput,
-  F as DefaultTimeInput,
-  c as DefaultTimeRangeInput,
-  v as Divider,
-  J as ThemeProvider,
-  x as Title,
-  R as TreegeConfigProvider,
+  c as DefaultTimeInput,
+  F as DefaultTimeRangeInput,
+  R as Divider,
+  M as ThemeProvider,
+  v as Title,
+  x as TreegeConfigProvider,
   S as TreegeRenderer,
-  b as checkFormFieldHasValue,
-  h as convertFormValuesToNamedFormat,
-  C as defaultInputRenderers,
-  w as defaultUI,
-  z as evaluateCondition,
+  b as applyReferenceTransformation,
+  h as calculateReferenceFieldUpdates,
+  z as checkFormFieldHasValue,
+  C as convertFormValuesToNamedFormat,
+  w as defaultInputRenderers,
+  H as defaultUI,
+  N as evaluateCondition,
   A as evaluateConditions,
-  H as fileToSerializable,
-  N as filesToSerializable,
-  k as findStartNode,
-  P as getFlowRenderState,
-  K as getTranslatedText,
-  y as isFieldEmpty,
-  E as isStartNode,
-  G as mergeFlows,
-  V as serializableToFile,
-  U as useTheme,
-  j as useTreegeConfig,
-  q as useTreegeRenderer
+  k as fileToSerializable,
+  y as filesToSerializable,
+  P as findStartNode,
+  E as getFlowRenderState,
+  O as getTranslatedText,
+  G as isFieldEmpty,
+  U as isStartNode,
+  V as mergeFlows,
+  j as sanitize,
+  q as sanitizeHttpResponse,
+  B as serializableToFile,
+  Q as useTheme,
+  J as useTreegeConfig,
+  K as useTreegeRenderer
 };

package/dist/shared/components/ui/alert-dialog.d.ts

@@ -0,0 +1,14 @@
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+import * as React from "react";
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogPortal({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogContent({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogAction({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogCancel({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel>): import("react/jsx-runtime").JSX.Element;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/shared/components/ui/badge.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from "react";
 declare const badgeVariants: (props?: ({
-    variant?: "default" | "destructive" | "outline" | "secondary" | "purple" | null | undefined;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "blue" | "purple" | null | undefined;
 } & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
 declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
     asChild?: boolean;

package/dist/shared/components/ui/popover.d.ts

@@ -2,6 +2,8 @@ import * as PopoverPrimitive from "@radix-ui/react-popover";
 import * as React from "react";
 declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
-declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, disablePortal, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content> & {
+    disablePortal?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
 declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): import("react/jsx-runtime").JSX.Element;
 export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

package/dist/shared/components/ui/select.d.ts

@@ -7,7 +7,9 @@ declare const SelectTrigger: ({ className, size, children, ...props }: React.Com
     size?: "sm" | "default";
 }) => import("react/jsx-runtime").JSX.Element;
 declare const SelectContent: ({ className, children, position, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>) => import("react/jsx-runtime").JSX.Element;
-declare const SelectLabel: ({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>) => import("react/jsx-runtime").JSX.Element;
+declare const SelectLabel: ({ className, htmlFor, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Label> & {
+    htmlFor?: string;
+}) => import("react/jsx-runtime").JSX.Element;
 declare const SelectItem: ({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>) => import("react/jsx-runtime").JSX.Element;
 declare const SelectSeparator: ({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>) => import("react/jsx-runtime").JSX.Element;
 declare const SelectScrollUpButton: ({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/constants/inputType.d.ts

@@ -11,6 +11,7 @@ export declare const INPUT_TYPE: {
     readonly password: "password";
     readonly radio: "radio";
     readonly select: "select";
+    readonly submit: "submit";
     readonly switch: "switch";
     readonly text: "text";
     readonly textarea: "textarea";