@dmitryvim/form-builder 0.1.5 → 0.1.7

package/dist/README.md

@@ -64,19 +64,40 @@ Renders a form in the specified container.
 **Parameters:**
 - `schema` - JSON schema object (v0.3)
 - `container` - DOM element to render form in
-- `options` - Configuration object
+- `options` - Configuration object (optional)
 
 **Options:**
 - `prefill` - Object with prefilled values
-- `readonly` - Boolean, renders form in read-only mode
-- `onSubmit` - Callback for form submission
-- `onDraft` - Callback for draft saving
-- `onError` - Callback for validation errors
+- `readonly` - Boolean, renders form in read-only mode (hides buttons)
+- `debug` - Boolean, enables debug logging to console
+- `onSubmit` - Callback for form submission `(data) => {}`
+- `onDraft` - Callback for draft saving `(data) => {}`  
+- `onError` - Callback for validation errors `(errors) => {}`
+- `buttons` - Custom button text: `{ submit: "Start Workflow", draft: "Save Progress" }`
+
+**Important:** Upload handlers must return a **string** resourceId, not an object.
 
 ### FormBuilder.validateSchema(schema)
 
 Validates a JSON schema and returns array of errors.
 
+**Returns:** `string[]` - Array of error messages (empty if valid)
+
+### FormBuilder.collectAndValidate(schema, formElement, skipValidation)
+
+⚠️ **Direct API for advanced users only**
+
+Collects form data and validates it. Most users should use `onSubmit`/`onDraft` callbacks instead.
+
+**Parameters:**
+- `schema` - The form schema
+- `formElement` - The form DOM element
+- `skipValidation` - Boolean, skip validation (for drafts)
+
+**Returns:** `{ result: object, errors: string[] }`
+
+**Important:** This is the correct destructuring format - there is no `.valid` or `.data` property.
+
 ### FormBuilder.setUploadHandler(uploadFn)
 
 Sets custom file upload handler:
@@ -109,47 +130,117 @@ FormBuilder.setDownloadHandler(async (resourceId, fileName) => {
 - `select` - Dropdown selection
 - `file` - Single file upload
 - `files` - Multiple file upload
-- `group` - Nested objects with optional repeat
+- `group` - Nested objects with optional repeat and custom element titles
+
+## Troubleshooting Common Issues
+
+### ❌ Upload Handler Returns Object
+```javascript
+// Wrong - causes "resourceId.slice is not a function"
+FormBuilder.setUploadHandler(async (file) => {
+  const response = await uploadFile(file);
+  return { reference: response.id, name: file.name }; // ❌ Object
+});
+
+// Correct - return string only
+FormBuilder.setUploadHandler(async (file) => {
+  const response = await uploadFile(file);
+  return response.id; // ✅ String resourceId
+});
+```
+
+### ❌ Wrong API Usage
+```javascript
+// Wrong - no .valid or .data properties
+const result = FormBuilder.collectAndValidate(schema, form);
+if (result.valid) { // ❌ Property doesn't exist
+  console.log(result.data); // ❌ Property doesn't exist
+}
+
+// Correct - use destructuring
+const { result, errors } = FormBuilder.collectAndValidate(schema, form);
+if (errors.length === 0) { // ✅ Check errors array
+  console.log(result); // ✅ Data is in result
+}
+```
+
+### ❌ Group Elements Missing Elements Array
+```javascript
+// Wrong - causes "group.elements must be array"
+{
+  type: 'group',
+  key: 'address',
+  // Missing elements array ❌
+}
+
+// Correct - always include elements
+{
+  type: 'group', 
+  key: 'address',
+  label: 'Address Information',
+  element_label: 'Address #$index', // ✅ Optional custom title
+  elements: [ // ✅ Required array
+    { type: 'text', key: 'street', label: 'Street' }
+  ]
+}
+```
+
+### ❌ Readonly Mode Confusion
+```javascript
+// This only hides the default buttons, fields remain editable
+FormBuilder.renderForm(schema, container, { readonly: true });
+
+// For true read-only, you need to disable inputs manually or use a different approach
+```
 
 ## Complete Example
 
 ```javascript
 const schema = {
   "version": "0.3",
-  "title": "Product Form",
+  "title": "Video Cover Generation",
   "elements": [
-    {
-      "type": "file",
-      "key": "cover",
-      "label": "Cover Image",
-      "required": true,
-      "accept": {
-        "extensions": ["jpg", "png"],
-        "mime": ["image/jpeg", "image/png"]
-      },
-      "maxSizeMB": 5
-    },
     {
       "type": "text",
-      "key": "title", 
-      "label": "Product Title",
-      "required": true,
-      "maxLength": 100
+      "key": "concept",
+      "label": "Animation Concept (Optional)",
+      "required": false,
+      "maxLength": 100,
+      "placeholder": "e.g., fun, elegant, dynamic, cozy..."
     },
     {
       "type": "group",
-      "key": "features",
-      "label": "Features",
+      "key": "slides_input",
+      "label": "Video Slides",
+      "element_label": "Slide $index", // 🆕 Custom title for each item
       "repeat": {
         "min": 1,
-        "max": 5
+        "max": 10
       },
       "elements": [
         {
-          "type": "text",
-          "key": "name",
-          "label": "Feature Name",
-          "required": true
+          "type": "file",
+          "key": "main_image",
+          "label": "Main Image",
+          "required": true,
+          "accept": {
+            "extensions": ["png", "jpg", "jpeg", "webp"],
+            "mime": ["image/png", "image/jpeg", "image/webp"]
+          },
+          "maxSizeMB": 25
+        },
+        {
+          "type": "files",
+          "key": "elements",
+          "label": "Element Images (Optional)",
+          "required": false,
+          "accept": {
+            "extensions": ["png", "jpg", "jpeg", "webp"],
+            "mime": ["image/png", "image/jpeg", "image/webp"]
+          },
+          "minCount": 0,
+          "maxCount": 10,
+          "maxSizeMB": 10
         }
       ]
     }

package/dist/example.html

@@ -23,54 +23,54 @@
 
     <script src="form-builder.js"></script>
     <script>
-        // Example schema
+        // Example schema demonstrating element_label feature
         const schema = {
             "version": "0.3",
-            "title": "Contact Form",
+            "title": "Video Cover Generation",
             "elements": [
                 {
                     "type": "text",
-                    "key": "name",
-                    "label": "Full Name",
-                    "required": true,
-                    "minLength": 2,
-                    "maxLength": 50
-                },
-                {
-                    "type": "text",
-                    "key": "email", 
-                    "label": "Email Address",
-                    "required": true,
-                    "pattern": "^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$"
-                },
-                {
-                    "type": "select",
-                    "key": "category",
-                    "label": "Category",
-                    "required": true,
-                    "options": [
-                        { "value": "general", "label": "General Inquiry" },
-                        { "value": "support", "label": "Technical Support" },
-                        { "value": "billing", "label": "Billing Question" }
-                    ]
-                },
-                {
-                    "type": "textarea",
-                    "key": "message",
-                    "label": "Message",
-                    "required": true,
-                    "maxLength": 1000
+                    "key": "concept",
+                    "label": "Animation Concept (Optional)",
+                    "required": false,
+                    "maxLength": 100,
+                    "placeholder": "e.g., fun, elegant, dynamic, cozy..."
                 },
                 {
-                    "type": "file",
-                    "key": "attachment",
-                    "label": "Attachment (Optional)",
-                    "required": false,
-                    "accept": {
-                        "extensions": ["pdf", "doc", "docx", "txt"],
-                        "mime": ["application/pdf", "application/msword", "text/plain"]
+                    "type": "group",
+                    "key": "slides_input",
+                    "label": "Video Slides",
+                    "element_label": "Slide $index",
+                    "repeat": {
+                        "min": 1,
+                        "max": 5
                     },
-                    "maxSizeMB": 5
+                    "elements": [
+                        {
+                            "type": "file",
+                            "key": "main_image",
+                            "label": "Main Image",
+                            "required": true,
+                            "accept": {
+                                "extensions": ["png", "jpg", "jpeg", "webp"],
+                                "mime": ["image/png", "image/jpeg", "image/webp"]
+                            },
+                            "maxSizeMB": 25
+                        },
+                        {
+                            "type": "files",
+                            "key": "elements",
+                            "label": "Element Images (Optional)",
+                            "required": false,
+                            "accept": {
+                                "extensions": ["png", "jpg", "jpeg", "webp"],
+                                "mime": ["image/png", "image/jpeg", "image/webp"]
+                            },
+                            "minCount": 0,
+                            "maxCount": 5,
+                            "maxSizeMB": 10
+                        }
+                    ]
                 }
             ]
         };

package/dist/form-builder.js

@@ -71,7 +71,7 @@
                     if (seen.has(el.key)) errors.push(`${path}: duplicate key "${el.key}"`);
                     seen.add(el.key);
                 }
-                if (el.default !== undefined && (el.type === 'file' || el.type === 'files')) {
+                if (el.default !== undefined && (el.type === 'file' || el.type === 'files' || el.type === 'videos')) {
                     errors.push(`${here}: default forbidden for "${el.type}"`);
                 }
                 
@@ -112,6 +112,11 @@
                         errors.push(`${here}: minCount > maxCount`);
                     }
                 }
+                if (el.type === 'videos') {
+                    if (el.minCount != null && el.maxCount != null && el.minCount > el.maxCount) {
+                        errors.push(`${here}: minCount > maxCount`);
+                    }
+                }
                 if (el.type === 'group') {
                     if (!Array.isArray(el.elements)) errors.push(`${here}: group.elements must be array`);
                     if (el.repeat) {
@@ -119,6 +124,10 @@
                             errors.push(`${here}: repeat.min > repeat.max`);
                         }
                     }
+                    // Validate element_label if provided (optional)
+                    if (el.element_label != null && typeof el.element_label !== 'string') {
+                        errors.push(`${here}: element_label must be a string`);
+                    }
                     if (Array.isArray(el.elements)) validateElements(el.elements, pathJoin(path, el.key));
                 }
             });
@@ -220,6 +229,10 @@
             if (element.minCount != null) bits.push(`minCount=${element.minCount}`);
             if (element.maxCount != null) bits.push(`maxCount=${element.maxCount}`);
         }
+        if (element.type === 'videos') {
+            if (element.minCount != null) bits.push(`minCount=${element.minCount}`);
+            if (element.maxCount != null) bits.push(`maxCount=${element.maxCount}`);
+        }
         
         hint.textContent = [bits.join(' • '), extra].filter(Boolean).join(' | ');
         return hint;
@@ -585,16 +598,137 @@
                 wrapper.appendChild(makeFieldHint(element, 'Multiple files return resource ID array'));
                 break;
             }
+            case 'videos': {
+                const hid = document.createElement('input');
+                hid.type = 'hidden';
+                hid.name = pathKey;
+                hid.dataset.type = 'videos';
+                
+                const list = document.createElement('div');
+                list.className = 'flex flex-col gap-3 mt-2';
+                
+                const picker = document.createElement('input');
+                picker.type = 'file';
+                picker.multiple = true;
+                {
+                    const acc = [];
+                    if (element.accept?.mime && Array.isArray(element.accept.mime) && element.accept.mime.length) {
+                        acc.push(...element.accept.mime);
+                    }
+                    if (element.accept?.extensions && Array.isArray(element.accept.extensions) && element.accept.extensions.length) {
+                        acc.push(...element.accept.extensions.map(ext => `.${ext}`));
+                    }
+                    picker.accept = acc.length ? acc.join(',') : 'video/*';
+                }
+                
+                const renderVideos = (rids) => {
+                    list.innerHTML = '';
+                    rids.forEach(rid => {
+                        const meta = resourceIndex.get(rid) || {};
+                        const row = document.createElement('div');
+                        row.className = 'flex items-start gap-3';
+                        const video = document.createElement('video');
+                        video.controls = true;
+                        video.className = 'w-48 max-w-full rounded border border-gray-300';
+                        // Use thumbnail as poster instead of loading video src
+                        if (config.getThumbnail) {
+                            Promise.resolve(config.getThumbnail(rid)).then(url => {
+                                if (url) {
+                                    video.poster = url;
+                                }
+                            }).catch(() => {});
+                        }
+                        const info = document.createElement('div');
+                        info.className = 'flex-1 text-sm text-gray-700';
+                        info.textContent = `${meta.name || 'video'} (${formatFileSize(meta.size || 0)})`;
+                        const actions = document.createElement('div');
+                        actions.className = 'flex items-center gap-2';
+                        const downloadBtn = document.createElement('button');
+                        downloadBtn.type = 'button';
+                        downloadBtn.className = 'px-2 py-1 text-xs bg-gray-100 hover:bg-gray-200 rounded';
+                        downloadBtn.textContent = 'Download';
+                        downloadBtn.addEventListener('click', async () => {
+                            if (config.downloadFile && typeof config.downloadFile === 'function') {
+                                try { await config.downloadFile(rid, meta.name || 'video'); } catch(_) {}
+                            } else {
+                                console.log('Download simulated:', rid, meta.name || 'video');
+                            }
+                        });
+                        const remove = document.createElement('button');
+                        remove.type = 'button';
+                        remove.className = 'px-2 py-1 text-xs bg-red-500 hover:bg-red-600 text-white rounded';
+                        remove.textContent = 'Remove';
+                        remove.addEventListener('click', () => {
+                            const arr = parseJSONSafe(hid.value, []);
+                            const next = Array.isArray(arr) ? arr.filter(x => x !== rid) : [];
+                            hid.value = JSON.stringify(next);
+                            renderVideos(next);
+                        });
+                        row.appendChild(video);
+                        row.appendChild(info);
+                        actions.appendChild(downloadBtn);
+                        actions.appendChild(remove);
+                        row.appendChild(actions);
+                        list.appendChild(row);
+                    });
+                };
+                
+                picker.addEventListener('change', async () => {
+                    let arr = parseJSONSafe(hid.value, []);
+                    if (!Array.isArray(arr)) arr = [];
+                    if (picker.files && picker.files.length) {
+                        for (const file of picker.files) {
+                            const err = fileValidationError(element, file);
+                            if (err) {
+                                markValidity(picker, err);
+                                return;
+                            }
+                            // additionally ensure it's a video
+                            if (!file.type.startsWith('video/')) {
+                                markValidity(picker, 'mime not allowed: ' + file.type);
+                                return;
+                            }
+                        }
+                        for (const file of picker.files) {
+                            const rid = await makeResourceIdFromFile(file);
+                            resourceIndex.set(rid, { name: file.name, type: file.type, size: file.size });
+                            arr.push(rid);
+                        }
+                        hid.value = JSON.stringify(arr);
+                        renderVideos(arr);
+                        markValidity(picker, null);
+                    }
+                });
+                
+                const pv = ctx.prefill && ctx.prefill[element.key];
+                let initial = Array.isArray(pv) ? pv.filter(Boolean) : [];
+                if (initial.length) {
+                    hid.value = JSON.stringify(initial);
+                    renderVideos(initial);
+                }
+                
+                wrapper.appendChild(picker);
+                wrapper.appendChild(list);
+                wrapper.appendChild(hid);
+                wrapper.appendChild(makeFieldHint(element, 'Multiple videos return resource ID array'));
+                break;
+            }
             case 'group': {
                 wrapper.dataset.group = element.key;
                 wrapper.dataset.groupPath = pathKey;
                 
                 const groupWrap = document.createElement('div');
+                
+                // Group title (above the whole group)
+                const groupTitle = document.createElement('div');
+                groupTitle.className = 'text-lg font-semibold text-gray-900 mb-4';
+                groupTitle.textContent = element.label || element.key;
+                groupWrap.appendChild(groupTitle);
+                
                 const header = document.createElement('div');
                 header.className = 'flex items-center justify-between my-2 pb-2 border-b border-gray-200';
                 
                 const left = document.createElement('div');
-                left.innerHTML = `<span>${element.label || element.key}</span>`;
                 header.appendChild(left);
                 
                 const right = document.createElement('div');
@@ -619,18 +753,48 @@
                     const refreshControls = () => {
                         const n = countItems();
                         addBtn.disabled = n >= max;
-                        left.innerHTML = `<span>${element.label || element.key}</span> <span class="text-gray-500 text-xs">[${n} / ${max === Infinity ? '∞' : max}, min=${min}]</span>`;
+                        left.innerHTML = `<span class="text-sm text-gray-600">Items: ${n} / ${max === Infinity ? '∞' : max} (min: ${min})</span>`;
+                    };
+
+                    const updateItemIndexes = () => {
+                        const items = itemsWrap.querySelectorAll(':scope > .groupItem');
+                        items.forEach((item, index) => {
+                            const titleElement = item.querySelector('h4');
+                            if (titleElement) {
+                                let labelText;
+                                if (element.element_label) {
+                                    labelText = element.element_label.replace('$index', index + 1);
+                                } else {
+                                    labelText = `${element.label || element.key} #${index + 1}`;
+                                }
+                                titleElement.textContent = labelText;
+                            }
+                        });
                     };
 
                     const addItem = (prefillObj) => {
+                        const itemIndex = countItems() + 1;
                         const item = document.createElement('div');
-                        item.className = 'groupItem border border-dashed border-gray-300 rounded-lg p-3 mb-3 bg-blue-50/30';
-                        const subCtx = { 
-                            path: pathJoin(ctx.path, element.key + `[${countItems()}]`), 
-                            prefill: prefillObj || {} 
-                        };
-                        element.elements.forEach(child => item.appendChild(renderElement(child, subCtx, options)));
+                        item.className = 'groupItem border border-dashed border-gray-300 rounded-lg p-4 mb-3 bg-blue-50/30';
+                        
+                        // Individual item title with index
+                        const itemTitle = document.createElement('div');
+                        itemTitle.className = 'flex items-center justify-between mb-4 pb-2 border-b border-gray-300';
                         
+                        const itemLabel = document.createElement('h4');
+                        itemLabel.className = 'text-md font-medium text-gray-800';
+                        
+                        // Use element_label if provided, with $index placeholder support
+                        let labelText;
+                        if (element.element_label) {
+                            labelText = element.element_label.replace('$index', itemIndex);
+                        } else {
+                            labelText = `${element.label || element.key} #${itemIndex}`;
+                        }
+                        itemLabel.textContent = labelText;
+                        itemTitle.appendChild(itemLabel);
+                        
+                        // Add remove button to title
                         const rem = document.createElement('button');
                         rem.type = 'button';
                         rem.className = 'bg-red-500 hover:bg-red-600 text-white px-2 py-1 rounded text-xs font-medium transition-colors';
@@ -639,8 +803,18 @@
                             if (countItems() <= (element.repeat.min ?? 0)) return;
                             itemsWrap.removeChild(item);
                             refreshControls();
+                            // Re-index remaining items
+                            updateItemIndexes();
                         });
-                        item.appendChild(rem);
+                        itemTitle.appendChild(rem);
+                        
+                        const subCtx = { 
+                            path: pathJoin(ctx.path, element.key + `[${countItems()}]`), 
+                            prefill: prefillObj || {} 
+                        };
+                        
+                        item.appendChild(itemTitle);
+                        element.elements.forEach(child => item.appendChild(renderElement(child, subCtx, options)));
                         itemsWrap.appendChild(item);
                         refreshControls();
                     };
@@ -681,8 +855,9 @@
     function collectAndValidate(schema, formRoot, skipValidation = false) {
         const errors = [];
 
-        function collectElement(element, scopeRoot) {
+        function collectElement(element, scopeRoot, elementPath = '') {
             const key = element.key;
+            const fullPath = elementPath ? `${elementPath}.${key}` : key;
             
             switch (element.type) {
                 case 'text':
@@ -690,26 +865,26 @@
                     const input = scopeRoot.querySelector(`[name$="${key}"]`);
                     const val = (input?.value ?? '').trim();
                     if (!skipValidation && element.required && val === '') {
-                        errors.push(`${key}: required`);
+                        errors.push(`Field "${fullPath}" is required`);
                         markValidity(input, 'required');
                     } else if (!skipValidation && val !== '') {
                         if (element.minLength != null && val.length < element.minLength) {
-                            errors.push(`${key}: minLength=${element.minLength}`);
+                            errors.push(`Field "${fullPath}" must be at least ${element.minLength} characters`);
                             markValidity(input, `minLength=${element.minLength}`);
                         }
                         if (element.maxLength != null && val.length > element.maxLength) {
-                            errors.push(`${key}: maxLength=${element.maxLength}`);
+                            errors.push(`Field "${fullPath}" must be at most ${element.maxLength} characters`);
                             markValidity(input, `maxLength=${element.maxLength}`);
                         }
                         if (element.pattern) {
                             try {
                                 const re = new RegExp(element.pattern);
                                 if (!re.test(val)) {
-                                    errors.push(`${key}: pattern mismatch`);
+                                    errors.push(`Field "${fullPath}" does not match required format`);
                                     markValidity(input, 'pattern mismatch');
                                 }
                             } catch {
-                                errors.push(`${key}: invalid pattern`);
+                                errors.push(`Field "${fullPath}" has invalid validation pattern`);
                                 markValidity(input, 'invalid pattern');
                             }
                         }
@@ -795,6 +970,20 @@
                     if (hid?.previousElementSibling) markValidity(hid.previousElementSibling, null);
                     return Array.isArray(arr) ? arr : [];
                 }
+                case 'videos': {
+                    const hid = scopeRoot.querySelector(`input[type="hidden"][name$="${key}"]`);
+                    const arr = parseJSONSafe(hid?.value ?? '[]', []);
+                    const count = Array.isArray(arr) ? arr.length : 0;
+                    if (!skipValidation && !Array.isArray(arr)) errors.push(`${key}: internal value corrupted`);
+                    if (!skipValidation && element.minCount != null && count < element.minCount) {
+                        errors.push(`${key}: < minCount=${element.minCount}`);
+                    }
+                    if (!skipValidation && element.maxCount != null && count > element.maxCount) {
+                        errors.push(`${key}: > maxCount=${element.maxCount}`);
+                    }
+                    if (hid?.previousElementSibling) markValidity(hid.previousElementSibling, null);
+                    return Array.isArray(arr) ? arr : [];
+                }
                 case 'group': {
                     const groupWrapper = scopeRoot.querySelector(`[data-group="${key}"]`);
                     if (!groupWrapper) {
@@ -815,10 +1004,10 @@
                         const max = element.repeat.max ?? Infinity;
                         if (!skipValidation && n < min) errors.push(`${key}: count < min=${min}`);
                         if (!skipValidation && n > max) errors.push(`${key}: count > max=${max}`);
-                        items.forEach(item => {
+                        items.forEach((item, index) => {
                             const obj = {};
                             element.elements.forEach(child => {
-                                obj[child.key] = collectElement(child, item);
+                                obj[child.key] = collectElement(child, item, `${fullPath}[${index}]`);
                             });
                             out.push(obj);
                         });
@@ -826,7 +1015,7 @@
                     } else {
                         const obj = {};
                         element.elements.forEach(child => {
-                            obj[child.key] = collectElement(child, itemsWrap);
+                            obj[child.key] = collectElement(child, itemsWrap, fullPath);
                         });
                         return obj;
                     }
@@ -839,7 +1028,7 @@
 
         const result = {};
         schema.elements.forEach(element => {
-            result[element.key] = collectElement(element, formRoot);
+            result[element.key] = collectElement(element, formRoot, '');
         });
         
         return { result, errors };
@@ -847,7 +1036,20 @@
 
     // Main form rendering function
     function renderForm(schema, container, options = {}) {
-        const { prefill = {}, readonly = false, onSubmit, onDraft, onError } = options;
+        const { 
+            prefill = {}, 
+            readonly = false, 
+            debug = false,
+            onSubmit, 
+            onDraft, 
+            onError,
+            buttons = {}
+        } = options;
+        
+        if (debug) {
+            console.log('[FormBuilder Debug] Rendering form with schema:', schema);
+            console.log('[FormBuilder Debug] Options:', options);
+        }
         
         // Validate schema first
         const schemaErrors = validateSchema(schema);
@@ -877,9 +1079,11 @@
             const submitBtn = document.createElement('button');
             submitBtn.type = 'button';
             submitBtn.className = 'bg-blue-600 text-white px-4 py-2 rounded-lg hover:bg-blue-700 transition-colors';
-            submitBtn.textContent = 'Submit Form';
+            submitBtn.textContent = buttons.submit || 'Submit Form';
             submitBtn.addEventListener('click', () => {
+                if (debug) console.log('[FormBuilder Debug] Submit button clicked');
                 const { result, errors } = collectAndValidate(schema, formEl, false);
+                if (debug) console.log('[FormBuilder Debug] Validation result:', { result, errors });
                 if (errors.length > 0) {
                     if (onError) onError(errors);
                 } else {
@@ -890,9 +1094,11 @@
             const draftBtn = document.createElement('button');
             draftBtn.type = 'button';
             draftBtn.className = 'bg-gray-600 text-white px-4 py-2 rounded-lg hover:bg-gray-700 transition-colors';
-            draftBtn.textContent = 'Save Draft';
+            draftBtn.textContent = buttons.draft || 'Save Draft';
             draftBtn.addEventListener('click', () => {
+                if (debug) console.log('[FormBuilder Debug] Draft button clicked');
                 const { result } = collectAndValidate(schema, formEl, true); // Skip validation for drafts
+                if (debug) console.log('[FormBuilder Debug] Draft result:', result);
                 if (onDraft) onDraft(result);
             });
             
@@ -940,6 +1146,9 @@
                     case 'files':
                         obj[el.key] = [];
                         break;
+                    case 'videos':
+                        obj[el.key] = [];
+                        break;
                     case 'group':
                         if (el.repeat && isPlainObject(el.repeat)) {
                             const sample = walk(el.elements);
@@ -967,6 +1176,6 @@
     exports.setUploadHandler = setUploadHandler;
     exports.setDownloadHandler = setDownloadHandler;
     exports.setThumbnailHandler = setThumbnailHandler;
-    exports.version = '0.1.4';
+    exports.version = '0.1.5';
 
 }));

package/dist/index.html

@@ -1,4 +1,4 @@
-<!doctype html>
+I <!doctype html>
 <html lang="en">
 <head>
     <meta charset="utf-8" />

package/docs/schema.md

@@ -175,27 +175,28 @@ Nested object structure with optional repetition.
 }
 ```
 
-**With Repetition:**
+**With Repetition and Custom Element Titles:**
 ```json
 {
   "type": "group",
-  "key": "contacts",
-  "label": "Contacts",
+  "key": "slides",
+  "label": "Video Slides",
+  "element_label": "Slide $index",
   "repeat": {
     "min": 1,
     "max": 5
   },
   "elements": [
     {
-      "type": "text",
-      "key": "name",
-      "label": "Contact Name",
+      "type": "file",
+      "key": "image",
+      "label": "Slide Image",
       "required": true
     },
     {
       "type": "text",
-      "key": "email", 
-      "label": "Email",
+      "key": "title", 
+      "label": "Slide Title",
       "required": true
     }
   ]
@@ -204,6 +205,7 @@ Nested object structure with optional repetition.
 
 **Properties:**
 - `elements` - Array of nested form elements
+- `element_label` - Optional custom title for each group item (supports `$index` placeholder)
 - `repeat.min` - Minimum number of repetitions
 - `repeat.max` - Maximum number of repetitions
 

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A reusable JSON schema form builder library",
   "main": "dist/form-builder.js",
   "files": [