create-prisma-php-app 1.13.1 → 1.13.3

package/dist/bootstrap.php

@@ -181,9 +181,10 @@ function dynamicRoute($uri)
             $segmentMatch = singleDynamicRoute($uriSegments, $routeSegments);
             if (!empty($segmentMatch)) {
                 $trimSegmentMatch = trim($segmentMatch, '[]');
-                $dynamicRouteParams = [$trimSegmentMatch => $uriSegments[array_search($segmentMatch, $routeSegments)]];
+                $dynamicRouteParams = new \ArrayObject([$trimSegmentMatch => $uriSegments[array_search($segmentMatch, $routeSegments)]], \ArrayObject::ARRAY_AS_PROPS);
 
-                $dynamicRouteUri = str_replace($segmentMatch, $uriSegments[array_search($segmentMatch, $routeSegments)], $normalizedRoute);                $dynamicRouteUriDirname = dirname($dynamicRouteUri);
+                $dynamicRouteUri = str_replace($segmentMatch, $uriSegments[array_search($segmentMatch, $routeSegments)], $normalizedRoute);
+                $dynamicRouteUriDirname = dirname($dynamicRouteUri);
                 $dynamicRouteUriDirname = rtrim($dynamicRouteUriDirname, '/');
 
                 $expectedUri = '/src/app/' . $normalizedUri;
@@ -206,7 +207,7 @@ function dynamicRoute($uri)
                 $pattern = '/\[\.\.\.(.*?)\]/';
                 if (preg_match($pattern, $normalizedRoute, $matches)) {
                     $contentWithinBrackets = $matches[1];
-                    $dynamicRouteParams = [$contentWithinBrackets => $explodedNormalizedUri];
+                    $dynamicRouteParams = new \ArrayObject([$contentWithinBrackets => $explodedNormalizedUri], \ArrayObject::ARRAY_AS_PROPS);
                 }
                 if (strpos($normalizedRoute, 'route.php') !== false) {
                     $uriMatch = $normalizedRoute;

package/dist/settings/public-functions.php

@@ -5,3 +5,42 @@ function redirect(string $url): void
     header("Location: $url");
     exit;
 }
+
+function isAjaxRequest()
+{
+    $isAjax = false;
+
+    // Check for standard AJAX header
+    if (!empty($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) === 'xmlhttprequest') {
+        $isAjax = true;
+    }
+
+    // Check for HTMX request header
+    if (!empty($_SERVER['HTTP_HX_REQUEST'])) {
+        $isAjax = true;
+    }
+
+    // Check for common AJAX content types
+    if (!empty($_SERVER['CONTENT_TYPE'])) {
+        $ajaxContentTypes = [
+            'application/json',
+            'application/x-www-form-urlencoded',
+            'multipart/form-data',
+        ];
+
+        foreach ($ajaxContentTypes as $contentType) {
+            if (strpos($_SERVER['CONTENT_TYPE'], $contentType) !== false) {
+                $isAjax = true;
+                break;
+            }
+        }
+    }
+
+    // Check for common AJAX request methods
+    $ajaxMethods = ['POST', 'PUT', 'PATCH', 'DELETE'];
+    if (in_array(strtoupper($_SERVER['REQUEST_METHOD']), $ajaxMethods)) {
+        $isAjax = true;
+    }
+
+    return $isAjax;
+}

package/dist/settings/request-methods.php

@@ -22,6 +22,8 @@ $isDelete = $requestMethod === 'DELETE';
 $isPatch = $requestMethod === 'PATCH';
 $isHead = $requestMethod === 'HEAD';
 $isOptions = $requestMethod === 'OPTIONS';
+$isAjax = isAjaxRequest();
+$isHtmx = !empty($_SERVER['HTTP_HX_REQUEST']) && strtolower($_SERVER['HTTP_HX_REQUEST']) === 'true';
 $contentType = $_SERVER['CONTENT_TYPE'] ?? '';
 $requestedWith = $_SERVER['HTTP_X_REQUESTED_WITH'] ?? '';
 $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off' || $_SERVER['SERVER_PORT'] == 443) ? "https://" : "http://";

package/dist/src/Lib/FormHandler.php

@@ -189,6 +189,11 @@ class FormHandler
     public function validateField($field, $rules)
     {
         $value = Validator::validateString($this->data[$field] ?? null);
+
+        if (!isset($rules['required']) && empty($value)) {
+            return;
+        }
+
         foreach ($rules as $rule => $options) {
             $ruleValue = $options;
             $customMessage = null;
@@ -415,177 +420,190 @@ class FormHandler
 ?>
 
 <script>
-    class FormHandler {
-        constructor() {
-            this.errors = [];
-            this.dataRulesElements = document.querySelectorAll('[data-rules]');
-            this.init();
-        }
-
-        init() {
-            this.dataRulesElements.forEach(fieldElement => {
-                this.initializeFieldFromDOM(fieldElement);
-            });
-        }
+    if (typeof FormHandler === 'undefined') {
+        class FormHandler {
+            constructor() {
+                this.errors = [];
+                this.dataRulesElements = document.querySelectorAll('[data-rules]');
+                this.init();
+            }
 
-        initializeFieldFromDOM(fieldElement) {
-            if (!fieldElement) {
-                // console.error('Element not found for field:', fieldElement);
-                return;
+            init() {
+                this.dataRulesElements.forEach(fieldElement => {
+                    this.initializeFieldFromDOM(fieldElement);
+                });
             }
 
-            const fieldName = fieldElement.name;
-            const rules = JSON.parse(fieldElement.getAttribute('data-rules') || '{}');
+            initializeFieldFromDOM(fieldElement) {
+                if (!fieldElement) return;
 
-            const immediateObserver = (e) => {
-                const target = e.target;
-                this.watch(target);
+                const fieldName = fieldElement.name;
+                const rules = JSON.parse(fieldElement.getAttribute('data-rules') || '{}');
 
-                const errors = this.validateField(target, target.value, rules);
-                const errorContainer = document.getElementById(`fh-error-${target.name}`);
+                const errors = this.validateField(fieldElement, fieldElement.value, rules);
+                const errorContainer = document.getElementById(`fh-error-${fieldElement.name}`);
                 if (errorContainer) {
-                    errorContainer.textContent = errors.join(', ');
+                    if (errorContainer.dataset.errorMessage) {
+                        errorContainer.textContent = errors.join(', ');
+                    }
                 }
-            };
 
-            fieldElement.addEventListener('input', immediateObserver);
-        }
+                const immediateObserver = (e) => {
+                    const target = e.target;
+                    this.watch(target);
+
+                    const errors = this.validateField(target, target.value, rules);
+                    const errorContainer = document.getElementById(`fh-error-${target.name}`);
+                    if (errorContainer) {
+                        errorContainer.textContent = errors.join(', ');
+                    }
+                };
+
+                fieldElement.addEventListener('input', immediateObserver);
+            }
 
-        updateElementDisplay(displayElement, field) {
-            const tagName = field.tagName.toUpperCase();
-            if (tagName === 'INPUT' || tagName === 'TEXTAREA') {
-                if (displayElement.tagName === 'INPUT' || displayElement.tagName === 'TEXTAREA') {
-                    displayElement.value = field.value;
+            updateElementDisplay(displayElement, field) {
+                const tagName = field.tagName.toUpperCase();
+                if (tagName === 'INPUT' || tagName === 'TEXTAREA') {
+                    if (displayElement.tagName === 'INPUT' || displayElement.tagName === 'TEXTAREA') {
+                        displayElement.value = field.value;
+                    } else {
+                        displayElement.dataset.watchValue = field.value;
+                        displayElement.textContent = field.value;
+                    }
                 } else {
-                    displayElement.dataset.watchValue = field.value;
-                    displayElement.textContent = field.value;
+                    displayElement.textContent = field.textContent;
                 }
-            } else {
-                displayElement.textContent = field.textContent;
             }
-        }
 
-        watch(field) {
-            if (!field) return;
+            watch(field) {
+                if (!field) return;
 
-            const watchElement = document.getElementById(`fh-watch-${field.name}`);
-            if (watchElement) {
-                this.updateElementDisplay(watchElement, field);
+                const watchElement = document.getElementById(`fh-watch-${field.name}`);
+                if (watchElement) {
+                    this.updateElementDisplay(watchElement, field);
+                }
             }
-        }
 
-        clearErrors() {
-            const errorElements = document.querySelectorAll('[id^="fh-error-"]');
-            errorElements.forEach(element => {
-                element.textContent = '';
-            });
+            clearErrors() {
+                const errorElements = document.querySelectorAll('[id^="fh-error-"]');
+                errorElements.forEach(element => {
+                    element.textContent = '';
+                });
 
-            this.errors = [];
-        }
-
-        getErrors(field) {
-            if (field) {
-                return document.getElementById(`fh-error-${field}`).textContent;
-            } else {
-                return this.errors;
+                this.errors = [];
             }
-        }
 
-        validateField(field, value, rules) {
-            if (!rules) return [];
-            this.errors = [];
-
-            for (const [rule, options] of Object.entries(rules)) {
-                let ruleValue = options;
-                let customMessage = null;
-
-                if (typeof options === 'object') {
-                    ruleValue = options.value;
-                    customMessage = options.message || null;
+            getErrors(field) {
+                if (field) {
+                    return document.getElementById(`fh-error-${field}`).textContent;
+                } else {
+                    return this.errors;
                 }
+            }
 
-                switch (rule) {
-                    case 'text':
-                    case 'search':
-                        if (typeof value !== 'string') {
-                            this.errors.push(customMessage || 'Must be a string.');
-                        }
-                        break;
-                    case 'email':
-                        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
-                            this.errors.push(customMessage || 'Invalid email format.');
-                        }
-                        break;
-                    case 'number':
-                        if (isNaN(value)) {
-                            this.errors.push(customMessage || 'Must be a number.');
-                        }
-                        break;
-                    case 'date':
-                        if (isNaN(Date.parse(value))) {
-                            this.errors.push(customMessage || 'Invalid date format.');
-                        }
-                        break;
-                    case 'range':
-                        const [min, max] = ruleValue;
-                        if (isNaN(value) || value < min || value > max) {
-                            this.errors.push(customMessage || `Must be between ${min} and ${max}.`);
-                        }
-                        break;
-                    case 'url':
-                        try {
-                            new URL(value);
-                        } catch (e) {
-                            this.errors.push(customMessage || 'Invalid URL format.');
-                        }
-                        break;
-                    case 'required':
-                        if (!value) {
-                            this.errors.push(customMessage || 'This field is required.');
-                        }
-                        break;
-                    case 'min':
-                        if (Number(value) < ruleValue) {
-                            this.errors.push(customMessage || `Must be at least ${ruleValue}.`);
-                        }
-                        break;
-                    case 'max':
-                        if (Number(value) > ruleValue) {
-                            this.errors.push(customMessage || `Must be at most ${ruleValue}.`);
-                        }
-                        break;
-                    case 'minLength':
-                        if (value.length < ruleValue) {
-                            this.errors.push(customMessage || `Must be at least ${ruleValue} characters.`);
-                        }
-                        break;
-                    case 'maxLength':
-                        if (value.length > ruleValue) {
-                            this.errors.push(customMessage || `Must be at most ${ruleValue} characters.`);
-                        }
-                        break;
-                    case 'pattern':
-                        if (!new RegExp(ruleValue).test(value)) {
-                            this.errors.push(customMessage || 'Invalid format.');
-                        }
-                        break;
-                    case 'accept':
-                        if (!ruleValue.split(',').includes(value)) {
-                            this.errors.push(customMessage || 'Invalid file format.');
-                        }
-                        break;
-                    default:
-                        // Optionally handle unknown rules or log them
-                        break;
+            validateField(field, value, rules) {
+                if (!rules) return [];
+                this.errors = [];
+
+                for (const [rule, options] of Object.entries(rules)) {
+                    let ruleValue = options;
+                    let customMessage = null;
+
+                    if (typeof options === 'object') {
+                        ruleValue = options.value;
+                        customMessage = options.message || null;
+                    }
+
+                    switch (rule) {
+                        case 'text':
+                        case 'search':
+                            if (typeof value !== 'string') {
+                                this.errors.push(customMessage || 'Must be a string.');
+                            }
+                            break;
+                        case 'email':
+                            if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+                                this.errors.push(customMessage || 'Invalid email format.');
+                            }
+                            break;
+                        case 'number':
+                            if (isNaN(value)) {
+                                this.errors.push(customMessage || 'Must be a number.');
+                            }
+                            break;
+                        case 'date':
+                            if (isNaN(Date.parse(value))) {
+                                this.errors.push(customMessage || 'Invalid date format.');
+                            }
+                            break;
+                        case 'range':
+                            const [min, max] = ruleValue;
+                            if (isNaN(value) || value < min || value > max) {
+                                this.errors.push(customMessage || `Must be between ${min} and ${max}.`);
+                            }
+                            break;
+                        case 'url':
+                            try {
+                                new URL(value);
+                            } catch (e) {
+                                this.errors.push(customMessage || 'Invalid URL format.');
+                            }
+                            break;
+                        case 'required':
+                            if (!value) {
+                                this.errors.push(customMessage || 'This field is required.');
+                            }
+                            break;
+                        case 'min':
+                            if (Number(value) < ruleValue) {
+                                this.errors.push(customMessage || `Must be at least ${ruleValue}.`);
+                            }
+                            break;
+                        case 'max':
+                            if (Number(value) > ruleValue) {
+                                this.errors.push(customMessage || `Must be at most ${ruleValue}.`);
+                            }
+                            break;
+                        case 'minLength':
+                            if (value.length < ruleValue) {
+                                this.errors.push(customMessage || `Must be at least ${ruleValue} characters.`);
+                            }
+                            break;
+                        case 'maxLength':
+                            if (value.length > ruleValue) {
+                                this.errors.push(customMessage || `Must be at most ${ruleValue} characters.`);
+                            }
+                            break;
+                        case 'pattern':
+                            if (!new RegExp(ruleValue).test(value)) {
+                                this.errors.push(customMessage || 'Invalid format.');
+                            }
+                            break;
+                        case 'accept':
+                            if (!ruleValue.split(',').includes(value)) {
+                                this.errors.push(customMessage || 'Invalid file format.');
+                            }
+                            break;
+                        default:
+                            // Optionally handle unknown rules or log them
+                            break;
+                    }
                 }
-            }
 
-            return this.errors;
+                return this.errors;
+            }
         }
-    }
 
-    let formHandler = null;
-    document.addEventListener('DOMContentLoaded', function() {
-        formHandler = new FormHandler();
-    });
+        let formHandler = null;
+        // Initialize FormHandler on initial page load
+        document.addEventListener('DOMContentLoaded', function() {
+            formHandler = new FormHandler();
+        });
+
+        // Reinitialize FormHandler when HTMX swaps content
+        document.body.addEventListener('htmx:afterOnLoad', function() {
+            formHandler = new FormHandler();
+        });
+    }
 </script>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma-php-app",
-  "version": "1.13.1",
+  "version": "1.13.3",
   "description": "Prisma-PHP: A Revolutionary Library Bridging PHP with Prisma ORM",
   "main": "dist/index.js",
   "type": "module",