@uipath/apollo-wind 2.58.0 → 2.60.0

package/dist/components/ui/quick-form-field/types.d.ts

@@ -0,0 +1,245 @@
+import { type LucideIcon } from 'lucide-react';
+import type { AriaAttributes, ReactNode } from 'react';
+import type { ValueMode } from '../field-addons/value-mode-strings';
+export type QuickFormFieldMode = ValueMode;
+export type QuickFieldType = 'string' | 'integer' | 'double' | 'date' | 'datetime' | 'boolean' | 'single-select' | 'multi-select' | 'array' | 'file' | 'object';
+interface FieldTypeMeta {
+    label: string;
+    icon: LucideIcon;
+    supportsExpression: boolean;
+    fixedLabel: string;
+    fixedDescription: string;
+}
+export declare const FIELD_TYPE_META: Record<QuickFieldType, FieldTypeMeta>;
+export declare const FIELD_TYPE_ORDER: QuickFieldType[];
+/**
+ * Every piece of user-visible text the component renders. The component owns no
+ * translation catalog, so a localized consumer supplies its own words; the
+ * defaults are English.
+ *
+ * Type labels live here rather than in FIELD_TYPE_META: the meta table defines
+ * the vocabulary, these are display strings.
+ */
+export interface QuickFormFieldStrings {
+    fieldTypeTooltip: string;
+    fieldTypeAriaLabel: string;
+    typeLabels: Partial<Record<QuickFieldType, string>>;
+    /** The literal mode item's label per type; falls back to FIELD_TYPE_META's `fixedLabel`. */
+    literalLabels: Partial<Record<QuickFieldType, string>>;
+    /** The literal mode item's description per type; falls back to FIELD_TYPE_META's `fixedDescription`. */
+    literalDescriptions: Partial<Record<QuickFieldType, string>>;
+    /** The computed field name in literal mode, from the (localized) type label. */
+    valueFieldLabel: (typeLabel: string) => string;
+    /** The computed field name in expression mode, from the (localized) type label. */
+    expressionFieldLabel: (typeLabel: string) => string;
+    /** A locked boolean's displayed text. */
+    trueLabel: string;
+    falseLabel: string;
+    requiredTooltip: string;
+    requiredAriaLabel: string;
+    optionalAriaLabel: string;
+    insertLabel: string;
+    insertAriaLabel: string;
+    /** The variable picker's search box. */
+    insertSearchPlaceholder: string;
+    /** The variable picker with nothing to show. */
+    insertEmpty: string;
+    valueModeAriaLabel: string;
+    expressionLabel: string;
+    expressionDescription: string;
+    pickDate: string;
+    selectOption: string;
+    selectOptions: string;
+    moreActionsAriaLabel: string;
+    clearValue: string;
+    forceRefresh: string;
+    aiAssistAriaLabel: string;
+    aiAssistTooltip: string;
+    aiPromptLabel: string;
+    aiPromptPlaceholder: string;
+    aiGenerate: string;
+    /** Replaces `aiGenerate` while a returned promise is pending. */
+    aiGenerating: string;
+    /** Shown when a returned promise rejects. */
+    aiError: string;
+    /** What the AI produces for the field, from the (localized) type label. */
+    aiOutputLabel: (typeLabel: string, isExpression: boolean) => string;
+    aiOutputHint: (output: string) => string;
+    lockedLabel: string;
+    unlockedLabel: string;
+    lockedHint: string;
+    unlockedHint: string;
+}
+export declare const DEFAULT_QUICK_FORM_FIELD_STRINGS: QuickFormFieldStrings;
+export interface QuickFormFieldOption {
+    label: string;
+    value: string;
+    /**
+     * Nested entries for the Insert-variable tree, rendered as supplied. Only the
+     * consumer knows whether the path a grouping implies is real, so the tree
+     * invents neither a root nor a type.
+     */
+    children?: QuickFormFieldOption[];
+    /** Type badge shown against the entry. */
+    type?: string;
+}
+export interface QuickFormFieldMoreActions {
+    onClear?: () => void;
+    onRefresh?: () => void;
+}
+/**
+ * Where the caret was when a variable was chosen, so the consumer can splice
+ * rather than append. The component tracks it because it owns the input;
+ * `caret` is null when the author has not placed one, which means "append".
+ */
+export interface VariableInsertContext {
+    value: string;
+    caret: {
+        start: number;
+        end: number;
+    } | null;
+}
+export interface QuickFormFieldProps {
+    /** Current field value. Encoding depends on fieldType (e.g. multi-select is a JSON array string). */
+    value?: string;
+    /** Called when the user edits the value (only fires while unlocked). */
+    onValueChange?: (value: string) => void;
+    /** Called when the active value control loses focus. */
+    onValueBlur?: () => void;
+    /** Whether the field is read-only. Defaults to true. */
+    locked?: boolean;
+    /** Called when the user toggles the lock. */
+    onLockedChange?: (locked: boolean) => void;
+    /** Whether the built-in lock control renders. Defaults to true. */
+    showLock?: boolean;
+    /**
+     * Replaces the leading lock toggle with a semantic prefix such as `=`.
+     * Pass `null` to suppress the built-in toggle; omitting the prop preserves it.
+     */
+    leadingAddon?: ReactNode;
+    /**
+     * Replaces the trailing fixed/expression menu with a consumer-provided action
+     * for expression-capable field types. Pass `null` to suppress the built-in
+     * menu; omitting the prop preserves it.
+     */
+    trailingAddon?: ReactNode;
+    /** Adds a field-level overflow menu beside the value control. */
+    more?: QuickFormFieldMoreActions;
+    /** How the value is expressed. Defaults to 'literal'; `expression` falls back to `literal` for types that cannot hold one. */
+    mode?: QuickFormFieldMode;
+    /** Called when the user switches modes. */
+    onModeChange?: (mode: QuickFormFieldMode) => void;
+    /**
+     * Optional expression editor used in place of the built-in monospace input.
+     * Consumers can use this to supply a syntax-aware editor such as Monaco.
+     *
+     * Superseded by `renderModeControl`, which covers every mode. Kept for
+     * existing callers; `renderModeControl` wins when both are supplied and it
+     * returns something for `expression`.
+     */
+    renderExpressionEditor?: (props: {
+        id: string;
+        value: string;
+        onValueChange?: (value: string) => void;
+        onBlur?: () => void;
+        readOnly: boolean;
+        placeholder: string;
+        fieldType: QuickFieldType;
+        'aria-invalid'?: AriaAttributes['aria-invalid'];
+        'aria-describedby'?: string;
+        'aria-errormessage'?: string;
+        'data-slot'?: string;
+    }) => ReactNode;
+    /**
+     * Renders the value control for a given mode, replacing the built-in one.
+     * `variable` and `prompt` have no built-in editor, and a surface that authors
+     * its own choices can replace the `literal` control too.
+     *
+     * Returning nothing (or omitting this) falls back to the built-in control
+     * for the field's type, so an unhandled mode degrades to the literal editor
+     * rather than rendering an empty row.
+     */
+    renderModeControl?: (mode: QuickFormFieldMode, props: {
+        id: string;
+        value: string;
+        onValueChange?: (value: string) => void;
+        onBlur?: () => void;
+        readOnly: boolean;
+        placeholder: string;
+        fieldType: QuickFieldType;
+        'aria-invalid'?: AriaAttributes['aria-invalid'];
+        'aria-describedby'?: string;
+        'aria-errormessage'?: string;
+        'data-slot'?: string;
+    }) => ReactNode;
+    /**
+     * Takes over what choosing a variable does to the value. The component owns
+     * the picker and hands back the chosen entry exactly as supplied in
+     * `variables`, with the caret.
+     *
+     * A value that is one reference must be replaced rather than appended, and a
+     * variable may carry its type onto the field, so the consumer decides. Omit
+     * to splice at the caret, or append when no caret has been placed.
+     */
+    onInsertVariable?: (variable: QuickFormFieldOption, 
+    /**
+     * Where the caret was, so the consumer can splice rather than append.
+     * The component tracks this because it owns the input; `caret` is null
+     * when the author has not placed one, which means "append".
+     */
+    context: VariableInsertContext) => void;
+    /** The field's data type. Defaults to 'string'. Determines which control renders the value. */
+    fieldType?: QuickFieldType;
+    /**
+     * Which types the picker offers, in display order. Defaults to
+     * `FIELD_TYPE_ORDER`, every type the component can render; a surface with a
+     * narrower vocabulary of its own offers fewer.
+     */
+    fieldTypes?: readonly QuickFieldType[];
+    /** Called when the user switches the field type. */
+    onFieldTypeChange?: (fieldType: QuickFieldType) => void;
+    /** Shows a required-field asterisk next to the default label. Ignored when `label` is provided. */
+    required?: boolean;
+    /** Called when the user toggles required/optional. Renders the Required switch when provided. */
+    onRequiredChange?: (required: boolean) => void;
+    /** Overrides the default mode-based label (e.g. a field name instead of "String value"). */
+    label?: ReactNode;
+    /**
+     * Overrides the placeholder on the value control. The computed default names
+     * only the type; the accessible label still falls back to it.
+     */
+    placeholder?: string;
+    /** Overrides for any subset of the user-visible text; see QuickFormFieldStrings. */
+    strings?: Partial<QuickFormFieldStrings>;
+    /** Field-specific validation feedback rendered immediately below the active control. */
+    error?: ReactNode;
+    /** Optional id for the inline validation message. */
+    errorId?: string;
+    /** Content rendered below the value control, such as a related checkbox or help text. */
+    belowValue?: ReactNode;
+    /** Accessible name for the file-upload dropzone. Defaults to a string `label`, then the computed field label. */
+    fileUploadAriaLabel?: string;
+    /** Extra content rendered after the built-in AI assist / Insert variable buttons (e.g. a delete button). */
+    headerActions?: ReactNode;
+    /** Forces the header row into its narrow-container icon-only layout, regardless of actual width. For demos/comparisons. */
+    compact?: boolean;
+    /** Whether the AI-assist and Insert-variable actions render at all. Set to false for read-only reviewer contexts where field configuration isn't editable. Defaults to true. */
+    showFieldActions?: boolean;
+    /** Options for 'single-select' / 'multi-select' field types. Defaults to a small set of demo options. */
+    options?: QuickFormFieldOption[];
+    /**
+     * Called with the entered prompt when the user clicks Generate.
+     *
+     * Its presence also decides whether the AI-assist button renders: without a
+     * handler the button would have nothing to do.
+     */
+    onGenerateWithAi?: (prompt: string) => void;
+    /**
+     * Variables offered by the "Insert variable" popover; clicking one appends its value to the
+     * current value. The button is disabled when this is empty (the default).
+     */
+    variables?: QuickFormFieldOption[];
+    id?: string;
+    className?: string;
+}
+export {};

package/dist/components/ui/quick-form-field/types.js

@@ -0,0 +1,137 @@
+import { ALargeSmall, Braces, Brackets, Calendar, CalendarClock, File, Hash, List, ListChecks, Sigma, ToggleLeft } from "lucide-react";
+const FIELD_TYPE_META = {
+    string: {
+        label: 'String',
+        icon: ALargeSmall,
+        supportsExpression: true,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Use a literal string value'
+    },
+    integer: {
+        label: 'Integer',
+        icon: Hash,
+        supportsExpression: true,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Use a literal number value'
+    },
+    double: {
+        label: 'Decimal number',
+        icon: Sigma,
+        supportsExpression: true,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Use a literal decimal value'
+    },
+    date: {
+        label: 'Date',
+        icon: Calendar,
+        supportsExpression: true,
+        fixedLabel: 'Fixed date',
+        fixedDescription: 'Use a literal date value'
+    },
+    datetime: {
+        label: 'Date and time',
+        icon: CalendarClock,
+        supportsExpression: true,
+        fixedLabel: 'Fixed date and time',
+        fixedDescription: 'Use a literal date and time value'
+    },
+    boolean: {
+        label: 'Boolean',
+        icon: ToggleLeft,
+        supportsExpression: true,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Use a literal true or false value'
+    },
+    'single-select': {
+        label: 'Single select',
+        icon: List,
+        supportsExpression: false,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Choose one option'
+    },
+    'multi-select': {
+        label: 'Multi select',
+        icon: ListChecks,
+        supportsExpression: false,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Choose one or more options'
+    },
+    array: {
+        label: 'Array',
+        icon: Brackets,
+        supportsExpression: true,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Use a literal JSON array'
+    },
+    file: {
+        label: 'File',
+        icon: File,
+        supportsExpression: true,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Upload a file'
+    },
+    object: {
+        label: 'Object',
+        icon: Braces,
+        supportsExpression: true,
+        fixedLabel: 'Fixed value',
+        fixedDescription: 'Use a literal object value'
+    }
+};
+const FIELD_TYPE_ORDER = [
+    'string',
+    'integer',
+    'double',
+    'date',
+    'datetime',
+    'boolean',
+    'single-select',
+    'multi-select',
+    'array',
+    'file',
+    'object'
+];
+const DEFAULT_QUICK_FORM_FIELD_STRINGS = {
+    fieldTypeTooltip: 'Type',
+    fieldTypeAriaLabel: 'Field type',
+    typeLabels: {},
+    literalLabels: {},
+    literalDescriptions: {},
+    valueFieldLabel: (typeLabel)=>`${typeLabel} value`,
+    expressionFieldLabel: (typeLabel)=>{
+        const type = typeLabel.toLowerCase();
+        return `Write ${/^[aeiou]/.test(type) ? 'an' : 'a'} ${type} expression`;
+    },
+    trueLabel: 'True',
+    falseLabel: 'False',
+    requiredTooltip: 'Required',
+    requiredAriaLabel: 'Required field',
+    optionalAriaLabel: 'Optional field',
+    insertLabel: 'Insert',
+    insertAriaLabel: 'Insert variable',
+    insertSearchPlaceholder: 'Search variables...',
+    insertEmpty: 'No variables found.',
+    valueModeAriaLabel: 'Choose value mode',
+    expressionLabel: 'Expression',
+    expressionDescription: 'Use a JS expression',
+    pickDate: 'Pick a date',
+    selectOption: 'Select an option',
+    selectOptions: 'Select options...',
+    moreActionsAriaLabel: 'More value actions',
+    clearValue: 'Clear value',
+    forceRefresh: 'Force refresh',
+    aiAssistAriaLabel: 'AI assist',
+    aiAssistTooltip: 'Generate with AI',
+    aiPromptLabel: 'Describe what you want',
+    aiPromptPlaceholder: 'Display a value from the previous step',
+    aiGenerate: 'Generate',
+    aiGenerating: 'Generating',
+    aiError: 'Could not generate a value. Try again.',
+    aiOutputLabel: (typeLabel, isExpression)=>`${typeLabel} ${isExpression ? 'expression' : 'value'}`,
+    aiOutputHint: (output)=>`Output: ${output}`,
+    lockedLabel: 'Read-only',
+    unlockedLabel: 'Editable',
+    lockedHint: 'Read-only. Click to make editable.',
+    unlockedHint: 'Editable. Click to make read-only.'
+};
+export { DEFAULT_QUICK_FORM_FIELD_STRINGS, FIELD_TYPE_META, FIELD_TYPE_ORDER };

package/dist/components/ui/{lockable-value-field → quick-form-field}/utils.cjs

@@ -25,6 +25,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     DEFAULT_SELECT_OPTIONS: ()=>DEFAULT_SELECT_OPTIONS,
+    formatDateTimeValue: ()=>formatDateTimeValue,
     formatDateValue: ()=>formatDateValue,
     getLockedDisplayValue: ()=>getLockedDisplayValue,
     parseDateValue: ()=>parseDateValue,
@@ -78,14 +79,29 @@ function formatDateValue(value) {
         day: 'numeric'
     }) : value;
 }
-function getLockedDisplayValue(fieldType, value, options) {
+function formatDateTimeValue(value) {
+    const date = parseDateValue(value);
+    return date ? date.toLocaleString(void 0, {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit'
+    }) : value;
+}
+function getLockedDisplayValue(fieldType, value, options, booleanLabels = {
+    trueLabel: 'True',
+    falseLabel: 'False'
+}) {
     switch(fieldType){
         case 'boolean':
-            if ('true' === value) return 'True';
-            if ('false' === value) return 'False';
+            if ('true' === value) return booleanLabels.trueLabel;
+            if ('false' === value) return booleanLabels.falseLabel;
             return '';
         case 'date':
             return value ? formatDateValue(value) : '';
+        case 'datetime':
+            return value ? formatDateTimeValue(value) : '';
         case 'single-select':
             return options.find((option)=>option.value === value)?.label ?? value;
         case 'multi-select':
@@ -99,6 +115,7 @@ function getLockedDisplayValue(fieldType, value, options) {
     }
 }
 exports.DEFAULT_SELECT_OPTIONS = __webpack_exports__.DEFAULT_SELECT_OPTIONS;
+exports.formatDateTimeValue = __webpack_exports__.formatDateTimeValue;
 exports.formatDateValue = __webpack_exports__.formatDateValue;
 exports.getLockedDisplayValue = __webpack_exports__.getLockedDisplayValue;
 exports.parseDateValue = __webpack_exports__.parseDateValue;
@@ -106,6 +123,7 @@ exports.parseListValue = __webpack_exports__.parseListValue;
 exports.toDateOnlyString = __webpack_exports__.toDateOnlyString;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "DEFAULT_SELECT_OPTIONS",
+    "formatDateTimeValue",
     "formatDateValue",
     "getLockedDisplayValue",
     "parseDateValue",

package/dist/components/ui/{lockable-value-field → quick-form-field}/utils.d.ts

@@ -1,5 +1,5 @@
-import type { LockableFieldType, LockableValueFieldOption } from './types';
-export declare const DEFAULT_SELECT_OPTIONS: LockableValueFieldOption[];
+import type { QuickFieldType, QuickFormFieldOption } from './types';
+export declare const DEFAULT_SELECT_OPTIONS: QuickFormFieldOption[];
 export declare function parseListValue(value: string): string[];
 /**
  * Parses a date field's stored value, returning undefined for empty or invalid input.
@@ -15,10 +15,15 @@ export declare function parseDateValue(value: string): Date | undefined;
 export declare function toDateOnlyString(date: Date): string;
 /** Formats a date field's value for display, falling back to the raw value if it isn't a valid date. */
 export declare function formatDateValue(value: string): string;
+/** Formats a datetime field's value, falling back to the raw value when unparseable. */
+export declare function formatDateTimeValue(value: string): string;
 /**
  * Computes the plain-text shown in place of the real control once a field is locked.
  * Boolean/single-select/multi-select resolve their stored value to a display label;
  * everything else (including an invalid date, so the component never throws on
  * external input) falls back to the raw value.
  */
-export declare function getLockedDisplayValue(fieldType: LockableFieldType, value: string, options: LockableValueFieldOption[]): string;
+export declare function getLockedDisplayValue(fieldType: QuickFieldType, value: string, options: QuickFormFieldOption[], booleanLabels?: {
+    trueLabel: string;
+    falseLabel: string;
+}): string;

package/dist/components/ui/{lockable-value-field → quick-form-field}/utils.js

@@ -45,14 +45,29 @@ function formatDateValue(value) {
         day: 'numeric'
     }) : value;
 }
-function getLockedDisplayValue(fieldType, value, options) {
+function formatDateTimeValue(value) {
+    const date = parseDateValue(value);
+    return date ? date.toLocaleString(void 0, {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit'
+    }) : value;
+}
+function getLockedDisplayValue(fieldType, value, options, booleanLabels = {
+    trueLabel: 'True',
+    falseLabel: 'False'
+}) {
     switch(fieldType){
         case 'boolean':
-            if ('true' === value) return 'True';
-            if ('false' === value) return 'False';
+            if ('true' === value) return booleanLabels.trueLabel;
+            if ('false' === value) return booleanLabels.falseLabel;
             return '';
         case 'date':
             return value ? formatDateValue(value) : '';
+        case 'datetime':
+            return value ? formatDateTimeValue(value) : '';
         case 'single-select':
             return options.find((option)=>option.value === value)?.label ?? value;
         case 'multi-select':
@@ -65,4 +80,4 @@ function getLockedDisplayValue(fieldType, value, options) {
             return value;
     }
 }
-export { DEFAULT_SELECT_OPTIONS, formatDateValue, getLockedDisplayValue, parseDateValue, parseListValue, toDateOnlyString };
+export { DEFAULT_SELECT_OPTIONS, formatDateTimeValue, formatDateValue, getLockedDisplayValue, parseDateValue, parseListValue, toDateOnlyString };

package/dist/components/ui/tree-view.cjs

@@ -25,6 +25,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    TreeView: ()=>TreeView,
     default: ()=>tree_view
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
@@ -758,7 +759,7 @@ function TreeItem({ item, depth = 0, selectedIds, lastSelectedId, onSelect, expa
         ]
     });
 }
-const tree_view_TreeView = /*#__PURE__*/ external_react_namespaceObject.forwardRef(function({ className, containerClassName, checkboxLabels = {
+const tree_view_FileTreeView = /*#__PURE__*/ external_react_namespaceObject.forwardRef(function({ className, containerClassName, checkboxLabels = {
     check: 'Check',
     uncheck: 'Uncheck'
 }, data, iconMap, searchPlaceholder = 'Search...', selectionText = 'selected', showExpandAll = true, showCheckboxes = false, showSelectionCheckboxes = false, selectionMode = 'multiple', title, getIcon, onSelectionChange, onAction, onCheckChange, menuItems }, ref) {
@@ -1115,9 +1116,12 @@ const tree_view_TreeView = /*#__PURE__*/ external_react_namespaceObject.forwardR
         })
     });
 });
-const tree_view = tree_view_TreeView;
+const tree_view = tree_view_FileTreeView;
+const TreeView = tree_view_FileTreeView;
+exports.TreeView = __webpack_exports__.TreeView;
 exports["default"] = __webpack_exports__["default"];
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TreeView",
     "default"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/components/ui/tree-view.d.ts

@@ -3,7 +3,7 @@ import * as React from 'react';
  * Action shown in the item's dropdown menu (Edit, Delete, etc.).
  * Actions appear as a single "more" icon that opens a dropdown to avoid horizontal overflow.
  */
-export interface TreeViewItemAction {
+export interface FileTreeViewItemAction {
     /** Unique action identifier */
     id: string;
     /** Icon to display in the dropdown menu item */
@@ -11,12 +11,12 @@ export interface TreeViewItemAction {
     /** Accessible label for the action */
     label?: string;
     /** Called when the action is clicked */
-    onClick: (item: TreeViewItem) => void;
+    onClick: (item: FileTreeViewItem) => void;
 }
 /**
  * A single item in the tree. Supports hierarchical structure, selection, and rich metadata.
  */
-export interface TreeViewItem {
+export interface FileTreeViewItem {
     /** Unique identifier (must be unique across the entire tree) */
     id: string;
     /** Display name */
@@ -24,7 +24,7 @@ export interface TreeViewItem {
     /** Type used for icon lookup in iconMap */
     type: string;
     /** Child items for expandable folders */
-    children?: TreeViewItem[];
+    children?: FileTreeViewItem[];
     /** Checked state when using access-rights checkboxes (showCheckboxes) */
     checked?: boolean;
     /** When true, item is greyed out and cannot be selected */
@@ -34,16 +34,16 @@ export interface TreeViewItem {
     /** Secondary metadata shown after the badge (e.g. "Production", "2 workflows") */
     meta?: string | React.ReactNode;
     /** Actions shown in a dropdown menu (Edit, Delete, etc.). Uses a single "more" icon to prevent horizontal scroll. */
-    actions?: TreeViewItemAction[];
+    actions?: FileTreeViewItemAction[];
 }
-export interface TreeViewIconMap {
+export interface FileTreeViewIconMap {
     [key: string]: React.ReactNode | undefined;
 }
-export interface TreeViewMenuItem {
+export interface FileTreeViewMenuItem {
     id: string;
     label: string;
     icon?: React.ReactNode;
-    action: (items: TreeViewItem[]) => void;
+    action: (items: FileTreeViewItem[]) => void;
 }
 /**
  * Controls how items can be selected.
@@ -51,18 +51,18 @@ export interface TreeViewMenuItem {
  * - `"single"`: Only one item can be selected at a time
  * - `"none"`: No selection; expand/collapse only
  */
-export type TreeViewSelectionMode = 'single' | 'multiple' | 'none';
-export interface TreeViewProps {
+export type FileTreeViewSelectionMode = 'single' | 'multiple' | 'none';
+export interface FileTreeViewProps {
     className?: string;
     containerClassName?: string;
-    data: TreeViewItem[];
+    data: FileTreeViewItem[];
     title?: string;
     showExpandAll?: boolean;
     showCheckboxes?: boolean;
     /** Show selection checkboxes on leaf items only (folders do not get checkboxes) */
     showSelectionCheckboxes?: boolean;
     /** Selection behavior: "multiple" (default), "single", or "none" */
-    selectionMode?: TreeViewSelectionMode;
+    selectionMode?: FileTreeViewSelectionMode;
     checkboxPosition?: 'left' | 'right';
     searchPlaceholder?: string;
     selectionText?: string;
@@ -70,15 +70,15 @@ export interface TreeViewProps {
         check: string;
         uncheck: string;
     };
-    getIcon?: (item: TreeViewItem, depth: number) => React.ReactNode;
-    onSelectionChange?: (selectedItems: TreeViewItem[]) => void;
-    onAction?: (action: string, items: TreeViewItem[]) => void;
-    onCheckChange?: (item: TreeViewItem, checked: boolean) => void;
-    iconMap?: TreeViewIconMap;
-    menuItems?: TreeViewMenuItem[];
+    getIcon?: (item: FileTreeViewItem, depth: number) => React.ReactNode;
+    onSelectionChange?: (selectedItems: FileTreeViewItem[]) => void;
+    onAction?: (action: string, items: FileTreeViewItem[]) => void;
+    onCheckChange?: (item: FileTreeViewItem, checked: boolean) => void;
+    iconMap?: FileTreeViewIconMap;
+    menuItems?: FileTreeViewMenuItem[];
 }
 /**
- * TreeView displays hierarchical data with expand/collapse, search, selection, and optional actions.
+ * FileTreeView displays hierarchical data with expand/collapse, search, selection, and optional actions.
  *
  * **Features:**
  * - **Search**: Filters items by name and auto-expands matching branches
@@ -92,5 +92,19 @@ export interface TreeViewProps {
  *
  * **Layout**: Title → Search bar → Expand/Collapse + Selected count + Clear → Tree. No horizontal scroll.
  */
-declare const TreeView: React.ForwardRefExoticComponent<TreeViewProps & React.RefAttributes<HTMLDivElement>>;
-export default TreeView;
+declare const FileTreeView: React.ForwardRefExoticComponent<FileTreeViewProps & React.RefAttributes<HTMLDivElement>>;
+export default FileTreeView;
+/** @deprecated Use `FileTreeView`. */
+export declare const TreeView: React.ForwardRefExoticComponent<FileTreeViewProps & React.RefAttributes<HTMLDivElement>>;
+/** @deprecated Use `FileTreeViewItemAction`. */
+export type TreeViewItemAction = FileTreeViewItemAction;
+/** @deprecated Use `FileTreeViewItem`. */
+export type TreeViewItem = FileTreeViewItem;
+/** @deprecated Use `FileTreeViewIconMap`. */
+export type TreeViewIconMap = FileTreeViewIconMap;
+/** @deprecated Use `FileTreeViewMenuItem`. */
+export type TreeViewMenuItem = FileTreeViewMenuItem;
+/** @deprecated Use `FileTreeViewSelectionMode`. */
+export type TreeViewSelectionMode = FileTreeViewSelectionMode;
+/** @deprecated Use `FileTreeViewProps`. */
+export type TreeViewProps = FileTreeViewProps;

package/dist/components/ui/tree-view.js

@@ -730,7 +730,7 @@ function TreeItem({ item, depth = 0, selectedIds, lastSelectedId, onSelect, expa
         ]
     });
 }
-const tree_view_TreeView = /*#__PURE__*/ forwardRef(function({ className, containerClassName, checkboxLabels = {
+const tree_view_FileTreeView = /*#__PURE__*/ forwardRef(function({ className, containerClassName, checkboxLabels = {
     check: 'Check',
     uncheck: 'Uncheck'
 }, data, iconMap, searchPlaceholder = 'Search...', selectionText = 'selected', showExpandAll = true, showCheckboxes = false, showSelectionCheckboxes = false, selectionMode = 'multiple', title, getIcon, onSelectionChange, onAction, onCheckChange, menuItems }, ref) {
@@ -1087,5 +1087,6 @@ const tree_view_TreeView = /*#__PURE__*/ forwardRef(function({ className, contai
         })
     });
 });
-const tree_view = tree_view_TreeView;
-export { tree_view as default };
+const tree_view = tree_view_FileTreeView;
+const TreeView = tree_view_FileTreeView;
+export { TreeView, tree_view as default };