@vendure/dashboard 3.6.0-minor-202511061555 → 3.6.0-minor-202512161252

package/src/lib/components/data-input/datetime-input.tsx

@@ -185,7 +185,7 @@ function bcpTagToDatePickerLocale(
         case 'pt-BR':
             return module.ptBR;
         default: {
-            const lang = tag.split('-').at(0);
+            const lang = tag.split('-')[0];
             return lang ? module[lang as keyof typeof module] : undefined;
         }
     }

package/src/lib/components/data-input/default-relation-input.tsx

@@ -567,11 +567,11 @@ export function DefaultRelationInput({
     entityType,
 }: Readonly<DefaultRelationInputProps>) {
     const { t } = useLingui();
+    const ENTITY_CONFIGS = useMemo(() => createEntityConfigs(t), [t]);
     if (!fieldDef || (!isRelationCustomFieldConfig(fieldDef) && !entityType)) {
         return null;
     }
     const entityName = entityType ?? (fieldDef as RelationCustomFieldConfig).entity;
-    const ENTITY_CONFIGS = useMemo(() => createEntityConfigs(t), [t]);
     const config = ENTITY_CONFIGS[entityName as keyof typeof ENTITY_CONFIGS];
 
     if (!config) {

package/src/lib/components/data-input/relation-selector.tsx

@@ -28,7 +28,7 @@ export interface RelationSelectorConfig<T = any> {
     /** Number of items to load per page */
     pageSize?: number;
     /** Placeholder text for the search input */
-    placeholder?: React.ReactNode;
+    placeholder?: string;
     /** Whether to enable multi-select mode */
     multiple?: boolean;
     /** Custom filter function for search */

package/src/lib/components/data-input/string-list-input.tsx

@@ -1,13 +1,151 @@
-import { X } from 'lucide-react';
-import { KeyboardEvent, useId, useRef, useState } from 'react';
+import { GripVertical, X } from 'lucide-react';
+import { KeyboardEvent, useEffect, useId, useRef, useState } from 'react';
 
 import { Badge } from '@/vdb/components/ui/badge.js';
 import { Input } from '@/vdb/components/ui/input.js';
 import type { DashboardFormComponentProps } from '@/vdb/framework/form-engine/form-engine-types.js';
 import { isReadonlyField } from '@/vdb/framework/form-engine/utils.js';
 import { cn } from '@/vdb/lib/utils.js';
+import {
+    closestCenter,
+    DndContext,
+    type DragEndEvent,
+    KeyboardSensor,
+    PointerSensor,
+    useSensor,
+    useSensors,
+} from '@dnd-kit/core';
+import {
+    arrayMove,
+    SortableContext,
+    sortableKeyboardCoordinates,
+    useSortable,
+    verticalListSortingStrategy,
+} from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
 import { useLingui } from '@lingui/react';
 
+interface SortableItemProps {
+    id: string;
+    item: string;
+    isDisabled: boolean;
+    isEditing: boolean;
+    onRemove: () => void;
+    onEdit: () => void;
+    onSave: (newValue: string) => void;
+}
+
+function SortableItem({ id, item, isDisabled, isEditing, onRemove, onEdit, onSave }: SortableItemProps) {
+    const [editValue, setEditValue] = useState(item);
+    const inputRef = useRef<HTMLInputElement>(null);
+    const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
+        id,
+    });
+
+    const style = {
+        transform: CSS.Transform.toString(transform),
+        transition,
+    };
+
+    const handleSave = () => {
+        const trimmedValue = editValue.trim();
+        if (trimmedValue && trimmedValue !== item) {
+            onSave(trimmedValue);
+        } else {
+            setEditValue(item);
+            onSave(item);
+        }
+    };
+
+    const handleKeyDown = (e: KeyboardEvent<HTMLInputElement>) => {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            handleSave();
+        } else if (e.key === 'Escape') {
+            setEditValue(item);
+            onSave(item);
+        }
+    };
+
+    // Focus and select input when entering edit mode
+    useEffect(() => {
+        if (isEditing && inputRef.current) {
+            inputRef.current.focus();
+            inputRef.current.select();
+        }
+    }, [isEditing]);
+
+    useEffect(() => {
+        if (item !== editValue) {
+            setEditValue(item);
+        }
+    }, [item]);
+
+    return (
+        <Badge
+            ref={setNodeRef}
+            style={style}
+            variant="secondary"
+            className={cn(
+                isDragging && 'opacity-50',
+                'flex items-center gap-1',
+                isEditing && 'border-muted-foreground/30',
+            )}
+        >
+            {!isDisabled && (
+                <button
+                    type="button"
+                    className={cn(
+                        'cursor-grab active:cursor-grabbing text-muted-foreground',
+                        'hover:bg-muted rounded p-0.5',
+                    )}
+                    {...attributes}
+                    {...listeners}
+                    aria-label={`Drag ${item}`}
+                >
+                    <GripVertical className="h-3 w-3" />
+                </button>
+            )}
+            {isEditing ? (
+                <input
+                    ref={inputRef}
+                    type="text"
+                    value={editValue}
+                    onChange={e => setEditValue(e.target.value)}
+                    onKeyDown={handleKeyDown}
+                    onBlur={handleSave}
+                    className="bg-transparent border-none outline-none focus:ring-0 p-0 h-auto min-w-[60px] w-auto"
+                    style={{ width: `${Math.max(editValue.length * 8, 60)}px` }}
+                />
+            ) : (
+                <button
+                    type="button"
+                    onClick={!isDisabled ? onEdit : undefined}
+                    className={cn(!isDisabled && 'cursor-text hover:underline')}
+                >
+                    {item}
+                </button>
+            )}
+            {!isDisabled && (
+                <button
+                    type="button"
+                    onClick={e => {
+                        e.stopPropagation();
+                        onRemove();
+                    }}
+                    className={cn(
+                        'ml-1 rounded-full outline-none ring-offset-background text-muted-foreground',
+                        'hover:bg-muted focus:ring-2 focus:ring-ring focus:ring-offset-2',
+                    )}
+                    aria-label={`Remove ${item}`}
+                >
+                    <X className="h-3 w-3" />
+                </button>
+            )}
+        </Badge>
+    );
+}
+
 export function StringListInput({
     value,
     onChange,
@@ -17,13 +155,21 @@ export function StringListInput({
     fieldDef,
 }: DashboardFormComponentProps) {
     const [inputValue, setInputValue] = useState('');
+    const [editingIndex, setEditingIndex] = useState<number | null>(null);
     const inputRef = useRef<HTMLInputElement>(null);
     const { i18n } = useLingui();
-    const isDisabled = isReadonlyField(fieldDef) || disabled;
+    const isDisabled = isReadonlyField(fieldDef) || disabled || false;
     const id = useId();
 
     const items = Array.isArray(value) ? value : [];
 
+    const sensors = useSensors(
+        useSensor(PointerSensor),
+        useSensor(KeyboardSensor, {
+            coordinateGetter: sortableKeyboardCoordinates,
+        }),
+    );
+
     const addItem = (item: string) => {
         const trimmedItem = item.trim();
         if (trimmedItem) {
@@ -36,6 +182,24 @@ export function StringListInput({
         onChange(items.filter((_, index) => index !== indexToRemove));
     };
 
+    const editItem = (index: number, newValue: string) => {
+        const newItems = [...items];
+        newItems[index] = newValue;
+        onChange(newItems);
+        setEditingIndex(null);
+    };
+
+    const handleDragEnd = (event: DragEndEvent) => {
+        const { active, over } = event;
+
+        if (over && active.id !== over.id) {
+            const oldIndex = items.findIndex((_, idx) => `${id}-${idx}` === active.id);
+            const newIndex = items.findIndex((_, idx) => `${id}-${idx}` === over.id);
+
+            onChange(arrayMove(items, oldIndex, newIndex));
+        }
+    };
+
     const handleKeyDown = (e: KeyboardEvent<HTMLInputElement>) => {
         if (e.key === 'Enter' || e.key === ',') {
             e.preventDefault();
@@ -74,29 +238,27 @@ export function StringListInput({
                     className="min-w-[120px]"
                 />
             )}
-            <div className="flex flex-wrap gap-1 items-start justify-start">
-                {items.map((item, index) => (
-                    <Badge key={id + index} variant="secondary">
-                        <span>{item}</span>
-                        {!isDisabled && (
-                            <button
-                                type="button"
-                                onClick={e => {
-                                    e.stopPropagation();
-                                    removeItem(index);
-                                }}
-                                className={cn(
-                                    'ml-1 rounded-full outline-none ring-offset-background',
-                                    'hover:bg-muted focus:ring-2 focus:ring-ring focus:ring-offset-2',
-                                )}
-                                aria-label={`Remove ${item}`}
-                            >
-                                <X className="h-3 w-3" />
-                            </button>
-                        )}
-                    </Badge>
-                ))}
-            </div>
+            <DndContext sensors={sensors} collisionDetection={closestCenter} onDragEnd={handleDragEnd}>
+                <SortableContext
+                    items={items.map((_, index) => `${id}-${index}`)}
+                    strategy={verticalListSortingStrategy}
+                >
+                    <div className="flex flex-wrap gap-1 items-start justify-start">
+                        {items.map((item, index) => (
+                            <SortableItem
+                                key={`${id}-${index}`}
+                                id={`${id}-${index}`}
+                                item={item}
+                                isDisabled={isDisabled}
+                                isEditing={editingIndex === index}
+                                onRemove={() => removeItem(index)}
+                                onEdit={() => setEditingIndex(index)}
+                                onSave={newValue => editItem(index, newValue)}
+                            />
+                        ))}
+                    </div>
+                </SortableContext>
+            </DndContext>
         </div>
     );
 }

package/src/lib/components/data-input/struct-form-input.tsx

@@ -20,7 +20,7 @@ import {
     StructCustomFieldConfig,
     StructField,
 } from '@/vdb/framework/form-engine/form-engine-types.js';
-import { isStructFieldConfig } from '@/vdb/framework/form-engine/utils.js';
+import { isReadonlyField, isStructFieldConfig } from '@/vdb/framework/form-engine/utils.js';
 import { useUserSettings } from '@/vdb/hooks/use-user-settings.js';
 import { CustomFieldListInput } from './custom-field-list-input.js';
 import { DateTimeInput } from './datetime-input.js';
@@ -98,185 +98,61 @@ export function StructFormInput({ fieldDef, ...field }: Readonly<DashboardFormCo
         return input?.find(t => t.languageCode === displayLanguage)?.value;
     };
 
-    const isReadonly = fieldDef?.readonly === true;
-
-    // Helper function to render individual struct field inputs
-    const renderStructFieldInput = (
-        structField: StructField,
-        inputField: ControllerRenderProps<any, any>,
-    ) => {
-        const isList = structField.list ?? false;
-
-        // Helper function to render single input for a struct field
-        const renderSingleStructInput = (singleField: ControllerRenderProps<any, any>) => {
-            switch (structField.type) {
-                case 'string': {
-                    // Check if the field has options (dropdown)
-                    const stringField = structField as any; // GraphQL union types need casting
-                    if (stringField.options && stringField.options.length > 0) {
-                        return (
-                            <SelectWithOptions {...singleField} fieldDef={stringField} isListField={false} />
-                        );
-                    }
-                    return (
-                        <Input
-                            value={singleField.value ?? ''}
-                            onChange={e => singleField.onChange(e.target.value)}
-                            onBlur={singleField.onBlur}
-                            name={singleField.name}
-                            disabled={isReadonly}
-                        />
-                    );
-                }
-                case 'int':
-                case 'float': {
-                    const isFloat = structField.type === 'float';
-                    const numericField = structField as any; // GraphQL union types need casting
-                    const min = isFloat ? numericField.floatMin : numericField.intMin;
-                    const max = isFloat ? numericField.floatMax : numericField.intMax;
-                    const step = isFloat ? numericField.floatStep : numericField.intStep;
-
-                    return (
-                        <Input
-                            type="number"
-                            value={singleField.value ?? ''}
-                            onChange={e => {
-                                const value = e.target.valueAsNumber;
-                                singleField.onChange(isNaN(value) ? undefined : value);
-                            }}
-                            onBlur={singleField.onBlur}
-                            name={singleField.name}
-                            disabled={isReadonly}
-                            min={min}
-                            max={max}
-                            step={step}
-                        />
-                    );
-                }
-                case 'boolean':
-                    return (
-                        <Switch
-                            checked={singleField.value}
-                            onCheckedChange={singleField.onChange}
-                            disabled={isReadonly}
-                        />
-                    );
-                case 'datetime':
-                    return <DateTimeInput {...singleField} />;
-                default:
-                    return (
-                        <Input
-                            value={singleField.value ?? ''}
-                            onChange={e => singleField.onChange(e.target.value)}
-                            onBlur={singleField.onBlur}
-                            name={singleField.name}
-                            disabled={isReadonly}
-                        />
-                    );
-            }
-        };
-
-        // Handle string fields with options (dropdown) - already handles list case with multi-select
-        if (structField.type === 'string') {
-            const stringField = structField as any; // GraphQL union types need casting
-            if (stringField.options && stringField.options.length > 0) {
-                return (
-                    <SelectWithOptions
-                        {...inputField}
-                        fieldDef={stringField}
-                        disabled={isReadonly}
-                        isListField={isList}
-                    />
-                );
-            }
-        }
-
-        // For list struct fields, wrap with list input
-        if (isList) {
-            const getDefaultValue = () => {
-                switch (structField.type) {
-                    case 'string':
-                        return '';
-                    case 'int':
-                    case 'float':
-                        return 0;
-                    case 'boolean':
-                        return false;
-                    case 'datetime':
-                        return '';
-                    default:
-                        return '';
-                }
-            };
-
-            // Determine if the field type needs full width
-            const needsFullWidth = structField.type === 'text' || structField.type === 'localeText';
-
-            return (
-                <CustomFieldListInput
-                    {...inputField}
-                    disabled={isReadonly}
-                    renderInput={(index, listItemField) => renderSingleStructInput(listItemField)}
-                    defaultValue={getDefaultValue()}
-                />
-            );
-        }
-
-        // For non-list fields, render directly
-        return renderSingleStructInput(inputField);
-    };
+    const isReadonly = isReadonlyField(fieldDef);
 
     // Edit mode - memoized to prevent focus loss from re-renders
     const EditMode = useMemo(
-        () => (
-            <div className="space-y-4 border rounded-md p-4">
-                {!isReadonly && (
-                    <div className="flex justify-end">
-                        <Button
-                            variant="ghost"
-                            size="sm"
-                            onClick={() => setIsEditing(false)}
-                            className="h-8 w-8 p-0 text-muted-foreground hover:text-foreground"
-                        >
-                            <CheckIcon className="h-4 w-4" />
-                            <span className="sr-only">Done</span>
-                        </Button>
-                    </div>
-                )}
-                {fieldDef?.fields?.map(structField => (
-                    <FormField
-                        key={structField.name}
-                        control={control}
-                        name={`${field.name}.${structField.name}`}
-                        render={({ field: structInputField }) => (
-                            <FormItem>
-                                <div className="flex items-baseline gap-4">
-                                    <div className="flex-1">
-                                        <FormLabel>
-                                            {getTranslation(structField.label) ?? structField.name}
-                                        </FormLabel>
-                                        {getTranslation(structField.description) && (
-                                            <FormDescription>
-                                                {getTranslation(structField.description)}
-                                            </FormDescription>
-                                        )}
+        () =>
+            fieldDef && isStructFieldConfig(fieldDef) ? (
+                <div className="space-y-4 border rounded-md p-4">
+                    {!isReadonly && (
+                        <div className="flex justify-end">
+                            <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setIsEditing(false)}
+                                className="h-8 w-8 p-0 text-muted-foreground hover:text-foreground"
+                            >
+                                <CheckIcon className="h-4 w-4" />
+                                <span className="sr-only">Done</span>
+                            </Button>
+                        </div>
+                    )}
+                    {fieldDef?.fields.map(structField => (
+                        <FormField
+                            key={structField.name}
+                            control={control}
+                            name={`${field.name}.${structField.name}`}
+                            render={({ field: structInputField }) => (
+                                <FormItem>
+                                    <div className="flex items-baseline gap-4">
+                                        <div className="flex-1">
+                                            <FormLabel>
+                                                {getTranslation(structField.label) ?? structField.name}
+                                            </FormLabel>
+                                            {getTranslation(structField.description) && (
+                                                <FormDescription>
+                                                    {getTranslation(structField.description)}
+                                                </FormDescription>
+                                            )}
+                                        </div>
+                                        <div className="flex-[2]">
+                                            <FormControl>
+                                                {renderStructFieldInput(structField, structInputField)}
+                                            </FormControl>
+                                            <FormMessage />
+                                        </div>
                                     </div>
-                                    <div className="flex-[2]">
-                                        <FormControl>
-                                            {renderStructFieldInput(structField, structInputField)}
-                                        </FormControl>
-                                        <FormMessage />
-                                    </div>
-                                </div>
-                            </FormItem>
-                        )}
-                    />
-                ))}
-            </div>
-        ),
-        [fieldDef, control, field.name, getTranslation, renderStructFieldInput, isReadonly],
+                                </FormItem>
+                            )}
+                        />
+                    ))}
+                </div>
+            ) : null,
+        [fieldDef, control, field.name, getTranslation, isReadonly],
     );
 
+    // Early return if not a struct field config
     if (!fieldDef || !isStructFieldConfig(fieldDef)) {
         return null;
     }
@@ -317,3 +193,128 @@ export function StructFormInput({ fieldDef, ...field }: Readonly<DashboardFormCo
         />
     );
 }
+
+// Helper function to render individual struct field inputs
+const renderStructFieldInput = (
+    structField: StructField,
+    inputField: ControllerRenderProps<any, any>,
+    isReadonly: boolean = false,
+) => {
+    const isList = structField.list ?? false;
+
+    // Helper function to render single input for a struct field
+    const renderSingleStructInput = (singleField: ControllerRenderProps<any, any>) => {
+        switch (structField.type) {
+            case 'string': {
+                // Check if the field has options (dropdown)
+                const stringField = structField as any; // GraphQL union types need casting
+                if (stringField.options && stringField.options.length > 0) {
+                    return <SelectWithOptions {...singleField} fieldDef={stringField} isListField={false} />;
+                }
+                return (
+                    <Input
+                        value={singleField.value ?? ''}
+                        onChange={e => singleField.onChange(e.target.value)}
+                        onBlur={singleField.onBlur}
+                        name={singleField.name}
+                        disabled={isReadonly}
+                    />
+                );
+            }
+            case 'int':
+            case 'float': {
+                const isFloat = structField.type === 'float';
+                const numericField = structField as any; // GraphQL union types need casting
+                const min = isFloat ? numericField.floatMin : numericField.intMin;
+                const max = isFloat ? numericField.floatMax : numericField.intMax;
+                const step = isFloat ? numericField.floatStep : numericField.intStep;
+
+                return (
+                    <Input
+                        type="number"
+                        value={singleField.value ?? ''}
+                        onChange={e => {
+                            const value = e.target.valueAsNumber;
+                            singleField.onChange(isNaN(value) ? undefined : value);
+                        }}
+                        onBlur={singleField.onBlur}
+                        name={singleField.name}
+                        disabled={isReadonly}
+                        min={min}
+                        max={max}
+                        step={step}
+                    />
+                );
+            }
+            case 'boolean':
+                return (
+                    <Switch
+                        checked={singleField.value}
+                        onCheckedChange={singleField.onChange}
+                        disabled={isReadonly}
+                    />
+                );
+            case 'datetime':
+                return <DateTimeInput {...singleField} />;
+            default:
+                return (
+                    <Input
+                        value={singleField.value ?? ''}
+                        onChange={e => singleField.onChange(e.target.value)}
+                        onBlur={singleField.onBlur}
+                        name={singleField.name}
+                        disabled={isReadonly}
+                    />
+                );
+        }
+    };
+
+    // Handle string fields with options (dropdown) - already handles list case with multi-select
+    if (structField.type === 'string') {
+        const stringField = structField as any; // GraphQL union types need casting
+        if (stringField.options && stringField.options.length > 0) {
+            return (
+                <SelectWithOptions
+                    {...inputField}
+                    fieldDef={stringField}
+                    disabled={isReadonly}
+                    isListField={isList}
+                />
+            );
+        }
+    }
+
+    // For list struct fields, wrap with list input
+    if (isList) {
+        const getDefaultValue = () => {
+            switch (structField.type) {
+                case 'string':
+                    return '';
+                case 'int':
+                case 'float':
+                    return 0;
+                case 'boolean':
+                    return false;
+                case 'datetime':
+                    return '';
+                default:
+                    return '';
+            }
+        };
+
+        // Determine if the field type needs full width
+        const needsFullWidth = structField.type === 'text' || structField.type === 'localeText';
+
+        return (
+            <CustomFieldListInput
+                {...inputField}
+                disabled={isReadonly}
+                renderInput={(index, listItemField) => renderSingleStructInput(listItemField)}
+                defaultValue={getDefaultValue()}
+            />
+        );
+    }
+
+    // For non-list fields, render directly
+    return renderSingleStructInput(inputField);
+};

package/src/lib/components/data-table/column-header-wrapper.tsx

@@ -72,7 +72,7 @@ export function ColumnHeaderWrapper({ children, columnId }: Readonly<ColumnHeade
                 >
                     <Popover open={isPopoverOpen} onOpenChange={setIsPopoverOpen}>
                         <PopoverTrigger asChild>
-                            <DevModeButton className={`h-5 w-5`} />
+                            <DevModeButton className={`h-5 w-5 end-1 top-1`} />
                         </PopoverTrigger>
                         <PopoverContent className="w-48 p-3">
                             <div className="space-y-2">