drf-to-mkdoc 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/field-sections-loader.js

@@ -0,0 +1,29 @@
+// Loader script for field sections functionality
+document.addEventListener('DOMContentLoaded', function() {
+    // Load CSS
+    function loadCSS(url) {
+        const link = document.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = url;
+        document.head.appendChild(link);
+    }
+    
+    // Load JavaScript
+    function loadScript(url, callback) {
+        const script = document.createElement('script');
+        script.src = url;
+        script.onload = callback || function() {};
+        document.body.appendChild(script);
+    }
+    
+    // Base URL for static files
+    const baseUrl = document.querySelector('meta[name="static-url"]')?.getAttribute('content') || '';
+    
+    // Load CSS file
+    loadCSS(baseUrl + '/static/drf-to-mkdoc/stylesheets/field-sections.css');
+    
+    // Load field extractor script
+    loadScript(baseUrl + '/static/drf-to-mkdoc/javascripts/try-out/field-extractor.js');
+    
+    console.log('Field sections functionality loaded');
+});

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/query-parameters-loader.js

@@ -0,0 +1,16 @@
+// Query parameters loader script
+document.addEventListener('DOMContentLoaded', function() {
+    // Load JavaScript
+    function loadScript(url, callback) {
+        const script = document.createElement('script');
+        script.src = url;
+        script.onload = callback || function() {};
+        document.body.appendChild(script);
+    }
+    
+    // Base URL for static files
+    const baseUrl = document.querySelector('meta[name="static-url"]')?.getAttribute('content') || '';
+    
+    // Load query parameters extractor script
+    loadScript(baseUrl + '/static/drf-to-mkdoc/javascripts/try-out/query-parameters-extractor.js');
+});

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/field-extractor.js

@@ -0,0 +1,200 @@
+// Field extractor for documentation content
+document.addEventListener('DOMContentLoaded', function() {
+    // Extract filter fields and pagination fields from documentation
+    const FieldExtractor = {
+        init: function() {
+            // Extract fields from documentation
+            const fields = this.extractFieldsFromDocumentation();
+            
+            // Make fields available for suggestions
+            if (fields && (fields.filter_fields.length > 0 || fields.pagination_fields.length > 0)) {
+                window.queryParametersData = window.queryParametersData || {};
+                
+                // Add filter fields
+                if (fields.filter_fields.length > 0) {
+                    window.queryParametersData.filter_fields = fields.filter_fields;
+                }
+                
+                // Add pagination fields
+                if (fields.pagination_fields.length > 0) {
+                    window.queryParametersData.pagination_fields = fields.pagination_fields;
+                }
+                
+                // Initialize suggestions if TryOutSuggestions is available
+                if (window.TryOutSuggestions) {
+                    window.TryOutSuggestions.init();
+                }
+            }
+        },
+        
+        extractFieldsFromDocumentation: function() {
+            const result = {
+                filter_fields: [],
+                pagination_fields: []
+            };
+            
+            // Look for filter fields section
+            const filterFieldsHeading = document.querySelector('h3#filter-fields');
+            if (filterFieldsHeading) {
+                const filterFieldsList = filterFieldsHeading.nextElementSibling;
+                if (filterFieldsList && filterFieldsList.tagName === 'UL') {
+                    const filterFields = Array.from(filterFieldsList.querySelectorAll('li code'))
+                        .map(code => code.textContent.trim());
+                    
+                    if (filterFields.length > 0) {
+                        result.filter_fields = filterFields;
+                    }
+                }
+            }
+            
+            // Look for pagination fields section
+            const paginationFieldsHeading = document.querySelector('h3#pagination-fields');
+            if (paginationFieldsHeading) {
+                const paginationFieldsList = paginationFieldsHeading.nextElementSibling;
+                if (paginationFieldsList && paginationFieldsList.tagName === 'UL') {
+                    const paginationFields = Array.from(paginationFieldsList.querySelectorAll('li code'))
+                        .map(code => code.textContent.trim());
+                    
+                    if (paginationFields.length > 0) {
+                        result.pagination_fields = paginationFields;
+                    }
+                }
+            }
+            
+            return result;
+        },
+        
+        formatDocumentation: function() {
+            // Format filter fields section
+            this.formatSection('filter-fields', 'Filter Fields');
+            
+            // Format pagination fields section
+            this.formatSection('pagination-fields', 'Pagination Fields');
+        },
+        
+        formatSection: function(sectionId, title) {
+            const heading = document.querySelector(`h3#${sectionId}`);
+            if (!heading) return;
+            
+            const list = heading.nextElementSibling;
+            if (!list || list.tagName !== 'UL') return;
+            
+            // Create a new container div
+            const container = document.createElement('div');
+            container.className = 'api-parameters-section';
+            container.id = `${sectionId}-container`;
+            
+            // Create a new heading
+            const newHeading = document.createElement('h3');
+            newHeading.id = sectionId;
+            newHeading.innerHTML = heading.innerHTML;
+            
+            // Create a new list container
+            const listContainer = document.createElement('div');
+            listContainer.className = 'parameters-list';
+            
+            // Create a description paragraph
+            const description = document.createElement('p');
+            description.className = 'parameters-description';
+            
+            if (sectionId === 'filter-fields') {
+                description.textContent = 'These fields can be used to filter the API results. Add them as query parameters to your request.';
+            } else if (sectionId === 'pagination-fields') {
+                description.textContent = 'These fields control pagination of the API results.';
+            }
+            
+            // Process the list items to enhance them
+            const enhancedList = this.enhanceParametersList(list);
+            
+            // Move the list into the container
+            listContainer.appendChild(enhancedList);
+            
+            // Add elements to the container
+            container.appendChild(newHeading);
+            container.appendChild(description);
+            container.appendChild(listContainer);
+            
+            // Replace the old elements with the new container
+            heading.parentNode.insertBefore(container, heading);
+            list.parentNode.removeChild(list);
+            heading.parentNode.removeChild(heading);
+            
+            // Add try-it buttons
+            this.addTryItButtons(container, sectionId);
+        },
+        
+        enhanceParametersList: function(list) {
+            // Clone the list
+            const enhancedList = list.cloneNode(true);
+            
+            // Process each list item
+            Array.from(enhancedList.querySelectorAll('li')).forEach(li => {
+                const code = li.querySelector('code');
+                if (code) {
+                    // Create a button to try this parameter
+                    const tryButton = document.createElement('button');
+                    tryButton.className = 'try-param-btn';
+                    tryButton.textContent = 'Try it';
+                    tryButton.dataset.param = code.textContent.trim();
+                    tryButton.addEventListener('click', (e) => {
+                        e.preventDefault();
+                        this.addParameterToTryOut(e.target.dataset.param);
+                    });
+                    
+                    li.appendChild(tryButton);
+                }
+            });
+            
+            return enhancedList;
+        },
+        
+        addTryItButtons: function(container, sectionId) {
+            // Create a button to try all parameters in this section
+            const tryAllButton = document.createElement('button');
+            tryAllButton.className = 'try-all-params-btn';
+            tryAllButton.textContent = 'Try All Parameters';
+            
+            tryAllButton.addEventListener('click', (e) => {
+                e.preventDefault();
+                
+                // Get all parameters in this section
+                const params = Array.from(container.querySelectorAll('code'))
+                    .map(code => code.textContent.trim());
+                
+                // Add all parameters to try-out form
+                params.forEach(param => this.addParameterToTryOut(param));
+            });
+            
+            // Add the button to the container
+            container.appendChild(tryAllButton);
+        },
+        
+        addParameterToTryOut: function(paramName) {
+            // Find the try-out modal or form
+            const tryOutModal = document.getElementById('tryOutModal');
+            if (!tryOutModal) return;
+            
+            // Show the modal if it's not already visible
+            if (tryOutModal.style.display !== 'flex') {
+                if (window.ModalManager && window.ModalManager.openTryOut) {
+                    window.ModalManager.openTryOut();
+                } else {
+                    tryOutModal.style.display = 'flex';
+                }
+            }
+            
+            // Add the parameter to the query parameters
+            if (window.TryOutSidebar && window.TryOutSidebar.addQueryParam) {
+                window.TryOutSidebar.addQueryParam(paramName);
+            } else if (window.FormManager && window.FormManager.addQueryParam) {
+                window.FormManager.addQueryParam(paramName);
+            }
+        }
+    };
+    
+    // Initialize field extractor
+    FieldExtractor.init();
+    
+    // Format documentation sections
+    FieldExtractor.formatDocumentation();
+});

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/form-manager.js

@@ -1,33 +1,231 @@
 // Form management functionality
 const FormManager = {
-    addQueryParam: function() {
-        const container = document.getElementById('queryParams');
+    // Initialize form functionality
+    init: function() {
+        this.setupEventListeners();
+        this.setupFormValidation();
+        this.initializeRequestBody();
+    },
+
+    initializeRequestBody: function() {
+        const requestExample = document.querySelector('.request-example');
+        const requestBody = document.getElementById('requestBody');
+        let example = null;
+        if (requestExample && requestBody) {
+            try {
+                example = requestExample.getAttribute('data-example');
+                if (example) {
+                    // Remove markdown code block syntax if present
+                    example = example.replace(/^```json\n/, '').replace(/```$/, '');
+                    // Remove any leading/trailing whitespace
+                    example = example.trim();
+                    
+                    // Try to parse and format the JSON
+                    const formattedJson = JSON.stringify(JSON.parse(example), null, 2);
+                    requestBody.value = formattedJson;
+                    
+                    // Validate the JSON after setting it
+                    if (window.RequestExecutor) {
+                        window.RequestExecutor.validateJson();
+                    }
+                }
+            } catch (e) {
+                console.warn('Failed to parse request example:', e);
+                // If parsing fails, try to at least show the raw example
+                if (example) {
+                    requestBody.value = example;
+                }
+            }
+        }
+    },
+
+    setupEventListeners: function() {
+        // Form reset functionality
+        const resetButtons = document.querySelectorAll('[data-action="reset"], .secondary-btn, .secondary-button');
+        resetButtons.forEach(btn => {
+            if (btn.textContent.toLowerCase().includes('reset')) {
+                btn.addEventListener('click', (e) => {
+                    e.preventDefault();
+                    this.resetForm();
+                });
+            }
+        });
+
+        // Parameter filtering
+        const searchInput = document.querySelector('.parameter-search');
+        if (searchInput) {
+            searchInput.addEventListener('input', this.debounce((e) => {
+                this.filterParameters(e.target.value);
+            }, 300));
+        }
+
+        // Copy URL functionality
+        const copyBtn = document.querySelector('.copy-btn');
+        if (copyBtn) {
+            copyBtn.addEventListener('click', () => this.copyToClipboard());
+        }
+
+        // JSON validation on input
+        const editor = document.getElementById('requestBody');
+        if (editor) {
+            editor.addEventListener('input', this.debounce(() => {
+                if (window.RequestExecutor) {
+                    window.RequestExecutor.validateJson();
+                }
+            }, 500));
+        }
+
+        // Format and validate buttons
+        const formatBtn = document.querySelector('.format-btn');
+        const validateBtn = document.querySelector('.validate-btn');
+        
+        if (formatBtn) {
+            formatBtn.addEventListener('click', () => {
+                if (window.RequestExecutor) {
+                    window.RequestExecutor.formatJson();
+                }
+            });
+        }
+        if (validateBtn) {
+            validateBtn.addEventListener('click', () => {
+                if (window.RequestExecutor) {
+                    window.RequestExecutor.validateJson();
+                }
+            });
+        }
+    },
+
+    setupFormValidation: function() {
+        // Add validation to required inputs
+        const requiredInputs = document.querySelectorAll('input[required]');
+        requiredInputs.forEach(input => {
+            input.addEventListener('blur', () => {
+                if (window.RequestExecutor) {
+                    window.RequestExecutor.validateInput(input);
+                }
+            });
+            input.addEventListener('input', () => this.clearValidationError(input));
+        });
+    },
+
+    clearValidationError: function(input) {
+        input.classList.remove('error');
+        const validationMessage = input.parentElement.querySelector('.validation-message');
+        if (validationMessage) {
+            validationMessage.textContent = '';
+            validationMessage.style.display = 'none';
+        }
+    },
+
+    // Debounce utility function
+    debounce: function(func, wait) {
+        let timeout;
+        return function executedFunction(...args) {
+            const later = () => {
+                clearTimeout(timeout);
+                func(...args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    },
+    addQueryParam: function(paramName) {
+        const container = document.querySelector('#queryParams .parameter-list');
         if (!container) return;
 
-        const kvItem = this.createKvItem('Parameter name', 'Parameter value', true);
-        container.appendChild(kvItem);
+        const paramItem = this.createParameterItem();
+        container.appendChild(paramItem);
         
-        // Focus on the first input
-        const firstInput = kvItem.querySelector('input');
-        if (firstInput) {
-            firstInput.focus();
+        // If a parameter name was provided, set it
+        const nameInput = paramItem.querySelector('.name-input');
+        if (nameInput && paramName) {
+            nameInput.value = paramName;
+            
+            // Focus on the value input instead
+            const valueInput = paramItem.querySelector('.value-input');
+            if (valueInput) {
+                valueInput.focus();
+            }
+        } else if (nameInput) {
+            // Otherwise focus on the name input
+            nameInput.focus();
+        }
+
+        // Setup suggestions for new input if available
+        if (window.TryOutSuggestions) {
+            setTimeout(() => {
+                window.TryOutSuggestions.setupExistingInputs();
+            }, 10);
         }
+        
+        return paramItem;
+    },
+
+    createParameterItem: function() {
+        const paramItem = document.createElement('div');
+        paramItem.className = 'parameter-item';
+        
+        paramItem.innerHTML = `
+            <div class="parameter-inputs">
+                <input type="text" 
+                       class="modern-input name-input" 
+                       placeholder="Parameter name"
+                       list="paramSuggestions">
+                <input type="text" 
+                       class="modern-input value-input" 
+                       placeholder="Value">
+                <button class="remove-btn" 
+                        onclick="FormManager.removeKvItem(this)"
+                        aria-label="Remove parameter">
+                    <span class="icon">✕</span>
+                </button>
+            </div>
+        `;
+        
+        return paramItem;
     },
 
     addHeader: function() {
-        const container = document.getElementById('requestHeaders');
+        const container = document.querySelector('#requestHeaders .header-list');
         if (!container) return;
 
-        const kvItem = this.createKvItem('Header name', 'Header value', true);
-        container.appendChild(kvItem);
+        const headerItem = this.createHeaderItem();
+        container.appendChild(headerItem);
         
         // Focus on the first input
-        const firstInput = kvItem.querySelector('input');
+        const firstInput = headerItem.querySelector('.name-input');
         if (firstInput) {
             firstInput.focus();
         }
     },
 
+    createHeaderItem: function() {
+        const headerItem = document.createElement('div');
+        headerItem.className = 'header-item';
+        
+        headerItem.innerHTML = `
+            <div class="header-inputs">
+                <input type="text" 
+                       class="modern-input name-input" 
+                       placeholder="Header name"
+                       list="headerSuggestions">
+                <input type="text" 
+                       class="modern-input value-input" 
+                       placeholder="Header value">
+                <button class="remove-btn" 
+                        aria-label="Remove header">
+                    <span class="icon">✕</span>
+                </button>
+            </div>
+        `;
+        
+        // Attach the removal handler programmatically
+        const removeBtn = headerItem.querySelector('.remove-btn');
+        removeBtn.addEventListener('click', (e) => FormManager.removeKvItem(e.currentTarget));
+        
+        return headerItem;
+    },
+
     createKvItem: function(namePlaceholder, valuePlaceholder, removable = true) {
         const kvItem = document.createElement('div');
         kvItem.className = 'kv-item';
@@ -55,8 +253,8 @@ const FormManager = {
     },
 
     removeKvItem: function(button) {
-        if (button && button.parentElement) {
-            button.parentElement.remove();
+        if (button && button.closest('.parameter-item, .header-item')) {
+            button.closest('.parameter-item, .header-item').remove();
         }
     },
 
@@ -165,8 +363,103 @@ const FormManager = {
             }
         }
         return null;
+    },
+
+    // Form reset functionality
+    resetForm: function() {
+        const form = document.querySelector('.try-out-form');
+        if (form) {
+            // Reset text inputs except base URL
+            form.querySelectorAll('input[type="text"], textarea').forEach(input => {
+                if (!input.id || input.id !== 'baseUrl') {
+                    input.value = '';
+                }
+            });
+
+            // Reset validation states
+            form.querySelectorAll('.error').forEach(el => {
+                el.classList.remove('error');
+            });
+
+            form.querySelectorAll('.validation-message').forEach(msg => {
+                msg.textContent = '';
+                msg.style.display = 'none';
+            });
+
+            // Reset JSON editor
+            const editor = document.getElementById('requestBody');
+            if (editor) {
+                editor.value = '';
+            }
+
+            // Reset validation status
+            const status = document.querySelector('.validation-status');
+            if (status) {
+                status.textContent = '';
+                status.className = 'validation-status';
+            }
+
+            // Reset to first tab
+            const firstTab = document.querySelector('.tab');
+            if (firstTab && window.TabManager) {
+                window.TabManager.switchTab(firstTab);
+            }
+
+            // Clear any error messages
+            if (window.RequestExecutor) {
+                window.RequestExecutor.clearValidationErrors();
+            }
+        }
+    },
+
+    // Parameter filtering
+    filterParameters: function(query) {
+        const items = document.querySelectorAll('.parameter-item');
+        query = query.toLowerCase();
+
+        items.forEach(item => {
+            const nameInput = item.querySelector('.name-input');
+            const name = nameInput?.value.toLowerCase() || '';
+
+            if (name.includes(query) || query === '') {
+                item.style.display = '';
+            } else {
+                item.style.display = 'none';
+            }
+        });
+    },
+
+    // Copy URL to clipboard
+    copyToClipboard: function() {
+        const baseUrl = document.getElementById('baseUrl')?.value || '';
+        const pathDisplay = document.querySelector('.path-display')?.textContent || '';
+        const url = baseUrl + pathDisplay;
+
+        navigator.clipboard.writeText(url).then(() => {
+            // Show copy success in the URL preview
+            const copyBtn = document.querySelector('.copy-btn');
+            if (copyBtn) {
+                const originalText = copyBtn.innerHTML;
+                copyBtn.innerHTML = '<span class="icon">✓</span>';
+                setTimeout(() => {
+                    copyBtn.innerHTML = originalText;
+                }, 2000);
+            }
+        }).catch(() => {
+            console.error('Failed to copy URL');
+        });
     }
 };
 
+// Initialize when DOM is loaded
+document.addEventListener('DOMContentLoaded', function() {
+    FormManager.init();
+});
+
+// Global functions for backward compatibility
+window.resetForm = () => FormManager.resetForm();
+window.filterParameters = (query) => FormManager.filterParameters(query);
+window.copyToClipboard = () => FormManager.copyToClipboard();
+
 // Export for global access
 window.FormManager = FormManager;

drf_to_mkdoc/static/drf-to-mkdoc/javascripts/try-out/main.js

@@ -1,22 +1,50 @@
 // Main try-out functionality - combines all components
 document.addEventListener('DOMContentLoaded', function() {
-    // Initialize tabs
-    TabManager.init();
+    // Initialize all components
+    if (window.TabManager) {
+        TabManager.init();
+    }
+    
+    if (window.FormManager) {
+        FormManager.init();
+    }
     
-    // Initialize suggestions if available
     if (window.TryOutSuggestions) {
         TryOutSuggestions.init();
     }
+    
+    // Initialize modal functionality
+    if (window.ModalManager) {
+        // Modal is already initialized through its own file
+        console.log('Try-out modal functionality loaded');
+    }
+    
+    // Initialize request executor
+    if (window.RequestExecutor) {
+        console.log('Try-out request executor loaded');
+    }
+    
+    console.log('Try-out functionality fully initialized');
 });
 
 // Legacy compatibility - maintain old interface
 window.TryOutSidebar = {
-    openTryOut: () => ModalManager.openTryOut(),
-    closeTryOut: () => ModalManager.closeTryOut(),
-    closeResponseModal: () => ModalManager.closeResponseModal(),
-    showResponseModal: (status, responseText, responseTime) => ModalManager.showResponseModal(status, responseText, responseTime),
-    addQueryParam: () => FormManager.addQueryParam(),
-    addHeader: () => FormManager.addHeader(),
-    removeKvItem: (button) => FormManager.removeKvItem(button),
-    validateRequiredParams: () => FormManager.validateRequiredParams()
+    openTryOut: () => window.ModalManager?.openTryOut(),
+    closeTryOut: () => window.ModalManager?.closeTryOut(),
+    closeResponseModal: () => window.ModalManager?.closeResponseModal(),
+    showResponseModal: (status, responseText, responseTime) => window.ModalManager?.showResponseModal(status, responseText, responseTime),
+    addQueryParam: () => window.FormManager?.addQueryParam(),
+    addHeader: () => window.FormManager?.addHeader(),
+    removeKvItem: (button) => window.FormManager?.removeKvItem(button),
+    validateRequiredParams: () => window.FormManager?.validateRequiredParams()
 };
+
+// Additional global functions for HTML onclick handlers
+window.TryOutForm = {
+    resetForm: () => window.FormManager?.resetForm(),
+    sendRequest: () => window.RequestExecutor?.executeRequest()
+};
+
+// Global proxy functions for template onclick handlers
+window.resetForm = () => window.TryOutForm?.resetForm?.();
+window.executeRequest = () => window.TryOutForm?.sendRequest?.();