create-prisma-php-app 1.26.526 → 1.26.527

package/dist/src/Lib/MainLayout.php

@@ -12,7 +12,9 @@ class MainLayout
     public static string $childLayoutChildren = '';
 
     private static array $headScripts = [];
+    private static array $headScriptsMap = [];
     private static array $footerScripts = [];
+    private static array $footerScriptsMap = [];
     private static array $customMetadata = [];
 
     /**
@@ -24,8 +26,9 @@ class MainLayout
     public static function addHeadScript(string ...$scripts): void
     {
         foreach ($scripts as $script) {
-            if (!in_array($script, self::$headScripts)) {
+            if (!isset(self::$headScriptsMap[$script])) {
                 self::$headScripts[] = $script;
+                self::$headScriptsMap[$script] = true;
             }
         }
     }
@@ -43,8 +46,9 @@ class MainLayout
     public static function addFooterScript(string ...$scripts): void
     {
         foreach ($scripts as $script) {
-            if (!in_array($script, self::$footerScripts)) {
+            if (!isset(self::$footerScriptsMap[$script])) {
                 self::$footerScripts[] = $script;
+                self::$footerScriptsMap[$script] = true;
             }
         }
     }

package/dist/src/Lib/PHPX/IPHPX.php

@@ -8,7 +8,8 @@ namespace Lib\PHPX;
  * The interface for the PHPX component classes.
  */
 
-interface IPHPX {
+interface IPHPX
+{
     /**
      * Constructor to initialize the component with the given properties.
      * 
@@ -18,8 +19,10 @@ interface IPHPX {
 
     /**
      * Registers or initializes any necessary components or settings. (Placeholder method).
+     * 
+     * @param array<string, mixed> $props Optional properties to customize the component.
      */
-    public static function init(): void;
+    public static function init(array $props = []): void;
 
     /**
      * Renders the component with the given properties and children.
@@ -27,4 +30,4 @@ interface IPHPX {
      * @return string The rendered HTML content.
      */
     public function render(): string;
-}
+}

package/dist/src/Lib/PHPX/PHPX.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace Lib\PHPX;
+
+use Lib\PHPX\IPHPX;
+use Lib\PHPX\TwMerge;
+
+class PHPX implements IPHPX
+{
+    /**
+     * @var array<string, mixed> The properties or attributes passed to the component.
+     */
+    protected array $props;
+
+    /**
+     * @var mixed The children elements or content to be rendered within the component.
+     */
+    protected mixed $children;
+
+    /**
+     * @var string The CSS class for custom styling.
+     */
+    protected string $class;
+
+    /**
+     * Constructor to initialize the component with the given properties.
+     * 
+     * @param array<string, mixed> $props Optional properties to customize the component.
+     */
+    public function __construct(array $props = [])
+    {
+        $this->props = $props;
+        $this->children = $props['children'] ?? '';
+        $this->class = $props['class'] ?? '';
+    }
+
+    /**
+     * Registers or initializes any necessary components or settings. (Placeholder method).
+     * 
+     * @param array<string, mixed> $props Optional properties to customize the initialization.
+     */
+    public static function init(array $props = []): void
+    {
+        // Register the component or any necessary initialization
+    }
+
+    /**
+     * Combines and returns the CSS classes for the component.
+     *
+     * This method merges the optional base CSS class with additional classes
+     * defined in the component's `$class` property. If no base class is provided,
+     * only the component's `$class` property will be used. It ensures that there 
+     * are no duplicate classes and the classes are properly formatted.
+     *
+     * @param string|null $baseClass The optional base CSS class to be merged. Defaults to `null`.
+     * @return string The merged CSS class string.
+     */
+    protected function getMergeClasses(?string $baseClass = null): string
+    {
+        return TwMerge::mergeClasses($baseClass, $this->class);
+    }
+
+    /**
+     * Generates and returns a string of HTML attributes from the provided props.
+     * Excludes 'class' and 'children' props from being added as attributes.
+     * 
+     * @return string The generated HTML attributes.
+     */
+    protected function getAttributes(): string
+    {
+        // Filter out 'class' and 'children' props
+        $filteredProps = array_filter($this->props, function ($key) {
+            return !in_array($key, ['class', 'children']);
+        }, ARRAY_FILTER_USE_KEY);
+
+        // Build attributes string by escaping keys and values
+        $attributes = [];
+        foreach ($filteredProps as $key => $value) {
+            $escapedKey = htmlspecialchars($key, ENT_QUOTES, 'UTF-8');
+            $escapedValue = htmlspecialchars((string) $value, ENT_QUOTES, 'UTF-8');
+            $attributes[] = "$escapedKey='$escapedValue'";
+        }
+
+        return implode(' ', $attributes);
+    }
+
+    /**
+     * Renders the component as an HTML string with the appropriate classes and attributes.
+     * Also, allows for dynamic children rendering if a callable is passed.
+     * 
+     * @return string The final rendered HTML of the component.
+     */
+    public function render(): string
+    {
+        $attributes = $this->getAttributes();
+        $class = $this->getMergeClasses();
+
+        return <<<HTML
+        <div class="$class" $attributes>{$this->children}</div>
+        HTML;
+    }
+
+    /**
+     * Converts the object to its string representation by rendering the component.
+     *
+     * This method allows the object to be used directly in string contexts, such as
+     * when echoing or concatenating, by automatically invoking the `render()` method.
+     * If an exception occurs during rendering, it safely returns an empty string
+     * to prevent runtime errors, ensuring robustness in all scenarios.
+     *
+     * @return string The rendered HTML output of the component, or an empty string if rendering fails.
+     */
+    public function __toString(): string
+    {
+        try {
+            return $this->render();
+        } catch (\Exception) {
+            return ''; // Return an empty string or a fallback message in case of errors
+        }
+    }
+}

package/dist/src/Lib/PHPX/TemplateCompiler.php

@@ -12,6 +12,24 @@ use DOMComment;
 class TemplateCompiler
 {
     protected static $classMappings = [];
+    protected static $selfClosingTags = [
+        'area',
+        'base',
+        'br',
+        'col',
+        'command',
+        'embed',
+        'hr',
+        'img',
+        'input',
+        'keygen',
+        'link',
+        'meta',
+        'param',
+        'source',
+        'track',
+        'wbr'
+    ];
 
     public static function compile(string $templateContent): string
     {
@@ -26,12 +44,14 @@ class TemplateCompiler
 
         if (!$dom->loadXML($wrappedContent)) {
             $errors = self::getXmlErrors();
-            throw new \RuntimeException('XML Parsing Failed: ' . implode('; ', $errors));
+            throw new \RuntimeException(
+                "XML Parsing Failed: " . implode("; ", $errors)
+            );
         }
         libxml_clear_errors();
 
         $root = $dom->documentElement;
-        $output = '';
+        $output = "";
         foreach ($root->childNodes as $child) {
             $output .= self::processNode($child);
         }
@@ -55,21 +75,21 @@ class TemplateCompiler
     protected static function formatLibxmlError(\LibXMLError $error): string
     {
         $errorType = match ($error->level) {
-            LIBXML_ERR_WARNING => 'Warning',
-            LIBXML_ERR_ERROR => 'Error',
-            LIBXML_ERR_FATAL => 'Fatal',
-            default => 'Unknown',
+            LIBXML_ERR_WARNING => "Warning",
+            LIBXML_ERR_ERROR => "Error",
+            LIBXML_ERR_FATAL => "Fatal",
+            default => "Unknown",
         };
 
         // Highlight the tag name in the error message
         $message = trim($error->message);
-        if (preg_match('/tag (.*?) /', $message, $matches)) {
+        if (preg_match("/tag (.*?) /", $message, $matches)) {
             $tag = $matches[1];
             $message = str_replace($tag, "`{$tag}`", $message);
         }
 
         return sprintf(
-            '[%s] Line %d, Column %d: %s',
+            "[%s] Line %d, Column %d: %s",
             $errorType,
             $error->line,
             $error->column,
@@ -79,7 +99,7 @@ class TemplateCompiler
 
     protected static function processNode($node): string
     {
-        $output = '';
+        $output = "";
 
         if ($node instanceof DOMElement) {
             $componentName = $node->nodeName;
@@ -91,7 +111,7 @@ class TemplateCompiler
             }
 
             // Process child nodes
-            $innerContent = '';
+            $innerContent = "";
             if ($node->hasChildNodes()) {
                 foreach ($node->childNodes as $child) {
                     $innerContent .= self::processNode($child);
@@ -100,11 +120,15 @@ class TemplateCompiler
 
             // Include inner content as 'children' if it's not empty
             if (trim($innerContent)) {
-                $attributes['children'] = $innerContent;
+                $attributes["children"] = $innerContent;
             }
 
-            $output .= self::processComponent($componentName, $attributes, $innerContent);
-        } else if ($node instanceof DOMComment) {
+            $output .= self::processComponent(
+                $componentName,
+                $attributes,
+                $innerContent
+            );
+        } elseif ($node instanceof DOMComment) {
             $output .= "<!--{$node->textContent}-->";
         } else {
             // For text nodes and others
@@ -114,30 +138,38 @@ class TemplateCompiler
         return $output;
     }
 
-    protected static function initializeClassMappings()
+    protected static function initializeClassMappings(): void
     {
-        // Assuming PrismaPHPSettings::$classLogFiles is an associative array
-        // with class names as keys and class paths as values
-        foreach (PrismaPHPSettings::$classLogFiles as $classPath => $classInfo) {
-            $className = pathinfo($classPath, PATHINFO_FILENAME);
+        foreach (
+            PrismaPHPSettings::$classLogFiles
+            as $classPath => $classInfo
+        ) {
+            $normalizedClassPath = str_replace("\\", "/", $classPath);
+            $className = pathinfo($normalizedClassPath, PATHINFO_FILENAME);
             self::$classMappings[$className] = $classPath;
         }
     }
 
-    protected static function processComponent(string $componentName, array $attributes, string $innerContent): string
-    {
+    protected static function processComponent(
+        string $componentName,
+        array $attributes,
+        string $innerContent
+    ): string {
         // Check if the component class exists in the mappings
-        if (isset(self::$classMappings[$componentName]) && class_exists(self::$classMappings[$componentName])) {
+        if (
+            isset(self::$classMappings[$componentName]) &&
+            class_exists(self::$classMappings[$componentName])
+        ) {
             $classPath = self::$classMappings[$componentName];
             // Instantiate the component
             $componentInstance = new $classPath($attributes);
             return $componentInstance->render();
         } else {
-            // Render as an XML tag
+            // Render as an HTML tag
             $attributesString = self::renderAttributes($attributes);
 
-            // Self-closing tag if no inner content
-            if (empty($innerContent)) {
+            // Determine if the tag should be self-closing
+            if (in_array(strtolower($componentName), self::$selfClosingTags)) {
                 return "<$componentName $attributesString />";
             } else {
                 return "<$componentName $attributesString>$innerContent</$componentName>";
@@ -148,16 +180,16 @@ class TemplateCompiler
     protected static function renderAttributes(array $attributes): string
     {
         if (empty($attributes)) {
-            return '';
+            return "";
         }
 
         $attrArray = [];
         foreach ($attributes as $key => $value) {
-            if ($key !== 'children') {
+            if ($key !== "children") {
                 $attrArray[] = "{$key}=\"{$value}\"";
             }
         }
 
-        return ' ' . implode(' ', $attrArray);
+        return " " . implode(" ", $attrArray);
     }
 }

package/dist/src/Lib/PHPX/TwMerge.php

@@ -0,0 +1,214 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib\PHPX;
+
+class TwMerge
+{
+    private static $classGroupPatterns = [
+        // **General Padding classes**
+        "p" => "/^p-/",
+
+        // **Specific Padding classes**
+        "pt" => "/^pt-/",
+        "pr" => "/^pr-/",
+        "pb" => "/^pb-/",
+        "pl" => "/^pl-/",
+        "px" => "/^px-/",
+        "py" => "/^py-/",
+
+        // **Margin classes (similar logic)**
+        "m" => "/^m-/",
+        "mt" => "/^mt-/",
+        "mr" => "/^mr-/",
+        "mb" => "/^mb-/",
+        "ml" => "/^ml-/",
+        "mx" => "/^mx-/",
+        "my" => "/^my-/",
+
+        // **Background color classes**
+        "bg" => "/^bg-/",
+
+        // **Text size classes**
+        "text-size" => '/^text-(xs|sm|base|lg|xl|[2-9]xl)$/',
+
+        // **Text color classes**
+        "text-color" => '/^text-(?!xs$|sm$|base$|lg$|xl$|[2-9]xl$).+$/',
+
+        // **Text alignment classes**
+        "text-alignment" => '/^text-(left|center|right|justify)$/',
+
+        // **Text transform classes**
+        "text-transform" =>
+        '/^text-(uppercase|lowercase|capitalize|normal-case)$/',
+
+        // **Text decoration classes**
+        "text-decoration" => '/^text-(underline|line-through|no-underline)$/',
+
+        // **Border width classes**
+        "border-width" => '/^border(-[0-9]+)?$/',
+
+        // **Border color classes**
+        "border-color" => "/^border-(?![0-9])/",
+
+        // **Border radius classes**
+        "rounded" => '/^rounded(-.*)?$/',
+
+        // **Font weight classes**
+        "font" =>
+        '/^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/',
+
+        // **Hover background color classes**
+        "hover:bg" => "/^hover:bg-/",
+
+        // **Hover text color classes**
+        "hover:text" => "/^hover:text-/",
+
+        // **Transition classes**
+        "transition" => '/^transition(-[a-z]+)?$/',
+
+        // **Opacity classes
+        "opacity" => '/^opacity(-[0-9]+)?$/',
+
+        // **Other utility classes can be added here**
+    ];
+
+    private static $conflictGroups = [
+        // **Padding conflict groups**
+        "p" => ["p", "px", "py", "pt", "pr", "pb", "pl"],
+        "px" => ["px", "pl", "pr"],
+        "py" => ["py", "pt", "pb"],
+        "pt" => ["pt"],
+        "pr" => ["pr"],
+        "pb" => ["pb"],
+        "pl" => ["pl"],
+
+        // **Margin conflict groups**
+        "m" => ["m", "mx", "my", "mt", "mr", "mb", "ml"],
+        "mx" => ["mx", "ml", "mr"],
+        "my" => ["my", "mt", "mb"],
+        "mt" => ["mt"],
+        "mr" => ["mr"],
+        "mb" => ["mb"],
+        "ml" => ["ml"],
+
+        // **Border width conflict group**
+        "border-width" => ["border-width"],
+
+        // **Border color conflict group**
+        "border-color" => ["border-color"],
+
+        // **Text size conflict group**
+        "text-size" => ["text-size"],
+
+        // **Text color conflict group**
+        "text-color" => ["text-color"],
+
+        // **Text alignment conflict group**
+        "text-alignment" => ["text-alignment"],
+
+        // **Text transform conflict group**
+        "text-transform" => ["text-transform"],
+
+        // **Text decoration conflict group**
+        "text-decoration" => ["text-decoration"],
+
+        // **Opacity conflict group
+        "opacity" => ["opacity"],
+
+        // **Add other conflict groups as needed**
+    ];
+
+    /**
+     * Merges multiple CSS class strings or arrays of CSS class strings into a single, optimized CSS class string.
+     *
+     * This method processes the provided classes, which can be either strings or arrays of strings, removes
+     * duplicate or conflicting classes, and prioritizes the last occurrence of a class. It splits class strings
+     * by whitespace, handles conflicting class groups, and ensures a clean and well-formatted output.
+     *
+     * ### Features:
+     * - Accepts individual class strings or arrays of class strings.
+     * - Automatically handles arrays by flattening them into individual strings.
+     * - Removes duplicate or conflicting classes based on class groups.
+     * - Combines all classes into a single string, properly formatted and optimized.
+     *
+     * @param string|array ...$classes The CSS classes to be merged. Each argument can be a string or an array of strings.
+     * @return string A single CSS class string with duplicates and conflicts resolved.
+     */
+    public static function mergeClasses(string|array ...$classes): string
+    {
+        $classArray = [];
+
+        foreach ($classes as $class) {
+            // Handle arrays by flattening them into strings
+            $classList = is_array($class) ? $class : [$class];
+            foreach ($classList as $item) {
+                if (!empty(trim($item))) {
+                    // Split the classes by any whitespace characters
+                    $splitClasses = preg_split("/\s+/", $item);
+                    foreach ($splitClasses as $individualClass) {
+                        $classKey = self::getClassGroup($individualClass);
+                        $conflictingKeys = self::getConflictingKeys($classKey);
+
+                        // Remove any conflicting classes
+                        foreach ($conflictingKeys as $key) {
+                            unset($classArray[$key]);
+                        }
+
+                        // Update the array, prioritizing the last occurrence
+                        $classArray[$classKey] = $individualClass;
+                    }
+                }
+            }
+        }
+
+        // Combine the final classes into a single string
+        return implode(" ", array_values($classArray));
+    }
+
+    private static function getClassGroup($class)
+    {
+        // Match optional prefixes (responsive and variants)
+        $pattern = '/^((?:[a-z-]+:)*)(.+)$/';
+
+        if (preg_match($pattern, $class, $matches)) {
+            $prefixes = $matches[1]; // Includes responsive and variant prefixes
+            $utilityClass = $matches[2]; // The utility class
+
+            // Now match utilityClass against patterns
+            foreach (self::$classGroupPatterns as $groupKey => $regex) {
+                if (preg_match($regex, $utilityClass)) {
+                    return $prefixes . $groupKey;
+                }
+            }
+
+            // If no match, use the full class
+            return $prefixes . $utilityClass;
+        }
+
+        // For classes without a recognizable prefix, return the class itself
+        return $class;
+    }
+
+    private static function getConflictingKeys($classKey)
+    {
+        // Remove any responsive or variant prefixes
+        $baseClassKey = preg_replace("/^(?:[a-z-]+:)+/", "", $classKey);
+
+        // Check for conflicts
+        if (isset(self::$conflictGroups[$baseClassKey])) {
+            // Add responsive and variant prefixes back to the conflicting keys
+            $prefix = preg_replace(
+                "/" . preg_quote($baseClassKey, "/") . '$/',
+                "",
+                $classKey
+            );
+            return array_map(function ($conflict) use ($prefix) {
+                return $prefix . $conflict;
+            }, self::$conflictGroups[$baseClassKey]);
+        }
+
+        return [$classKey];
+    }
+}