create-prisma-php-app 2.1.3 → 2.1.4

package/dist/settings/class-imports.ts

@@ -20,17 +20,12 @@ export const SRC_DIR = path.join(PROJECT_ROOT, "src");
 const IMPORTS_FILE = path.join(PROJECT_ROOT, "settings/class-imports.json");
 const CLASS_LOG_FILE = path.join(PROJECT_ROOT, "settings/class-log.json");
 
-async function loadImportsData(): Promise<Record<string, string>> {
-  try {
-    const content = await fs.readFile(IMPORTS_FILE, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
 
 async function saveImportsData(
-  data: Record<string, { className: string; filePath: string }>
+  data: Record<
+    string,
+    Array<{ className: string; filePath: string; importer: string }>
+  >
 ) {
   await fs.writeFile(IMPORTS_FILE, JSON.stringify(data, null, 2), "utf-8");
 }
@@ -86,16 +81,14 @@ export async function analyzeImportsInFile(
       } else {
         // Handle grouped `use` statements
         if (node.kind === "usegroup" && node.name) {
-          baseNamespace = node.name.name || node.name; // Set base namespace
+          baseNamespace = node.name.name || node.name;
           for (const useItem of node.items || []) {
             if (useItem.kind === "useitem" && useItem.name) {
-              const subNamespace = useItem.name.name || useItem.name; // Sub-namespace
-              const fqn = combineNamespaces(baseNamespace, subNamespace); // Fully Qualified Namespace
-              const alias = useItem.alias ? useItem.alias.name : subNamespace; // Alias or default to subNamespace
+              const subNamespace = useItem.name.name || useItem.name;
+              const fqn = combineNamespaces(baseNamespace, subNamespace);
+              const alias = useItem.alias ? useItem.alias.name : subNamespace;
               if (!imports[alias]) {
-                // Prevent overwriting
-                imports[alias] = fqn; // Map alias to FQN
-                // console.log(`🚀 Adding import: ${alias} -> ${fqn}`);
+                imports[alias] = fqn;
               }
             }
           }
@@ -103,12 +96,11 @@ export async function analyzeImportsInFile(
 
         // Handle non-grouped `use` statements
         if (node.kind === "useitem" && node.name) {
-          const fqn = node.name.name || node.name; // Fully Qualified Namespace
+          const fqn = node.name.name || node.name;
           const alias = node.alias
             ? node.alias.name
             : path.basename(fqn.replace(/\\/g, "/"));
           if (!imports[alias]) {
-            // Prevent overwriting
             imports[alias] = fqn;
           }
         }
@@ -129,38 +121,56 @@ export async function analyzeImportsInFile(
 }
 
 export async function updateComponentImports() {
-  // Load existing imports (if any)
-  const allImports = await loadImportsData();
-
   // Analyze all PHP files for use statements
   const phpFiles = await getAllPhpFiles(SRC_DIR);
+  // Build a mapping: alias -> array of { fqn, importer }
+  const allImports: Record<
+    string,
+    Array<{ fqn: string; importer: string }>
+  > = {};
+
   for (const file of phpFiles) {
     const fileImports = await analyzeImportsInFile(file);
-    // Merge fileImports into allImports
-    Object.assign(allImports, fileImports);
+    for (const [alias, fqn] of Object.entries(fileImports)) {
+      if (allImports[alias]) {
+        // Check both fqn and importer to avoid duplicates
+        if (
+          !allImports[alias].some(
+            (entry) => entry.fqn === fqn && entry.importer === file
+          )
+        ) {
+          allImports[alias].push({ fqn, importer: file });
+        }
+      } else {
+        allImports[alias] = [{ fqn, importer: file }];
+      }
+    }
   }
 
-  // Now filter using class-log.json
+  // Load the class log to filter valid imports
   const classLog = await loadClassLogData();
-
   const filteredImports: Record<
     string,
-    { className: string; filePath: string }
+    Array<{ className: string; filePath: string; importer: string }>
   > = {};
-  for (const [alias, fqn] of Object.entries(allImports)) {
-    if (classLog[fqn]) {
-      // console.log(`Including: ${alias} -> ${fqn}`);
-      filteredImports[alias] = {
-        className: fqn,
-        filePath: classLog[fqn].filePath,
-      };
-    } else {
-      // console.log(`Excluding: ${alias} -> ${fqn}`);
+
+  for (const [alias, entries] of Object.entries(allImports)) {
+    for (const entry of entries) {
+      if (classLog[entry.fqn]) {
+        const importEntry = {
+          className: entry.fqn,
+          filePath: classLog[entry.fqn].filePath,
+          importer: entry.importer,
+        };
+        if (filteredImports[alias]) {
+          filteredImports[alias].push(importEntry);
+        } else {
+          filteredImports[alias] = [importEntry];
+        }
+      }
     }
   }
 
   await saveImportsData(filteredImports);
-  // console.log(
-  //   "component_imports.json updated with IPHPX/PHPX components only."
-  // );
+  // console.log("component_imports.json updated with importer file path included.");
 }

package/dist/settings/component-import-checker.ts

@@ -26,12 +26,49 @@ function findComponentsInFile(code: string): string[] {
 
 export async function checkComponentImports(
   filePath: string,
-  fileImports: Record<string, string>
+  fileImports: Record<
+    string,
+    | Array<{ className: string; filePath: string; importer?: string }>
+    | { className: string; filePath: string; importer?: string }
+  >
 ) {
   const code = await fs.readFile(filePath, "utf-8");
   const usedComponents = findComponentsInFile(code);
+  // Normalize the current file path: replace backslashes, trim, remove trailing slash, and lower-case.
+  const normalizedFilePath = filePath
+    .replace(/\\/g, "/")
+    .trim()
+    .replace(/\/+$/, "")
+    .toLowerCase();
+
   usedComponents.forEach((component) => {
-    if (!fileImports[component]) {
+    const rawMapping = fileImports[component];
+    // Normalize rawMapping to an array
+    let mappings: Array<{
+      className: string;
+      filePath: string;
+      importer?: string;
+    }> = [];
+    if (Array.isArray(rawMapping)) {
+      mappings = rawMapping;
+    } else if (rawMapping) {
+      mappings = [rawMapping];
+    }
+
+    // Check if any mapping's importer matches the current file.
+    const found = mappings.some((mapping) => {
+      const normalizedImporter = (mapping.importer || "")
+        .replace(/\\/g, "/")
+        .trim()
+        .replace(/\/+$/, "")
+        .toLowerCase();
+      // Either exact match or the current file path ends with the importer.
+      return (
+        normalizedFilePath === normalizedImporter ||
+        normalizedFilePath.endsWith(normalizedImporter)
+      );
+    });
+    if (!found) {
       console.warn(
         chalk.yellow("Warning: ") +
           chalk.white("Component ") +

package/dist/src/Lib/Auth/Auth.php

@@ -35,7 +35,7 @@ class Auth
      */
     private function __construct()
     {
-        $this->secretKey = $_ENV['AUTH_SECRET'];
+        $this->secretKey = $_ENV['AUTH_SECRET'] ?? 'CD24eEv4qbsC5LOzqeaWbcr58mBMSvA4Mkii8GjRiHkt';
         self::$cookieName = self::getCookieName();
     }
 

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

@@ -16,7 +16,7 @@ class PHPX implements IPHPX
     /**
      * @var mixed The children elements or content to be rendered within the component.
      */
-    protected mixed $children;
+    public mixed $children;
 
     /**
      * @var string The CSS class for custom styling.

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

@@ -11,6 +11,7 @@ use DOMElement;
 use DOMComment;
 use DOMNode;
 use RuntimeException;
+use Bootstrap;
 
 class TemplateCompiler
 {
@@ -40,6 +41,7 @@ class TemplateCompiler
             self::initializeClassMappings();
         }
 
+
         $templateContent = self::preprocessBindings($templateContent);
 
         $dom = self::convertToXml($templateContent);
@@ -71,7 +73,6 @@ class TemplateCompiler
                 $expression    = $matches[3];
                 $afterBinding  = $matches[4];
 
-                // Escape the binding expression for attributes.
                 $escapedExpression = htmlspecialchars($expression, ENT_QUOTES, 'UTF-8');
                 $placeholder       = '%%ATTR_BIND_' . count($attributePlaceholders) . '%%';
 
@@ -81,17 +82,14 @@ class TemplateCompiler
             $templateContent
         );
 
-        // Process text {{ ... }} bindings, but skip ones inside attribute values.
         $textBindingPattern = '/(?:"[^"]*"|\'[^\']*\')(*SKIP)(*FAIL)|{{\s*(.+?)\s*}}/u';
         $templateContent = preg_replace_callback(
             $textBindingPattern,
             function ($matches) {
                 $expr = $matches[1];
-                // If the expression is a simple word/dot path, use a simple binding.
                 if (preg_match('/^[\w.]+$/u', $expr)) {
                     return "<span pp-bind=\"{$expr}\"></span>";
                 } else {
-                    // Otherwise, encode the expression and use an expression binding.
                     $encodedExpr = htmlspecialchars($expr, ENT_QUOTES, 'UTF-8');
                     return "<span pp-bind-expr=\"{$encodedExpr}\"></span>";
                 }
@@ -219,56 +217,97 @@ class TemplateCompiler
         if ($node instanceof DOMElement) {
             $componentName = $node->nodeName;
             $attributes = [];
-
             foreach ($node->attributes as $attr) {
                 $attributes[$attr->name] = $attr->value;
             }
 
-            $childOutput = [];
-            foreach ($node->childNodes as $child) {
-                $childOutput[] = self::processNode($child);
-            }
-            $innerContent = implode('', $childOutput);
+            if (isset(self::$classMappings[$componentName])) {
+                $componentInstance = self::initializeComponentInstance($componentName, $attributes);
 
-            $attributes['children'] = $innerContent;
+                $childOutput = [];
+                foreach ($node->childNodes as $child) {
+                    $childOutput[] = self::processNode($child);
+                }
+                $componentInstance->children = implode('', $childOutput);
 
-            return self::processComponent($componentName, $attributes);
+                $renderedContent = $componentInstance->render();
+                if (self::hasComponentTag($renderedContent)) {
+                    return self::compile($renderedContent);
+                }
+                return $renderedContent;
+            } else {
+                $childOutput = [];
+                foreach ($node->childNodes as $child) {
+                    $childOutput[] = self::processNode($child);
+                }
+                $attributes['children'] = implode('', $childOutput);
+                return self::renderAsHtml($componentName, $attributes);
+            }
         } elseif ($node instanceof DOMComment) {
             return "<!--{$node->textContent}-->";
         }
-
         return $node->textContent;
     }
 
-    protected static function initializeClassMappings(): void
+    protected static function initializeComponentInstance(string $componentName, array $attributes)
     {
-        foreach (PrismaPHPSettings::$classLogFiles as $tagName => $fullyQualifiedClassName) {
-            self::$classMappings[$tagName] = $fullyQualifiedClassName;
-        }
-    }
+        $importerFile = Bootstrap::$contentToInclude;
+        $normalizedImporterFile = str_replace('\\', '/', $importerFile);
 
-    protected static function processComponent(string $componentName, array $attributes): string
-    {
-        if (isset(self::$classMappings[$componentName])) {
-            $className = self::$classMappings[$componentName]['className'];
-            $filePath = self::$classMappings[$componentName]['filePath'];
+        $srcPathNormalized = str_replace('\\', '/', SRC_PATH);
+        $relativeImporterFile = str_replace($srcPathNormalized . '/', '', $normalizedImporterFile);
 
-            require_once str_replace('\\', '/', SRC_PATH . '/' . $filePath);
+        if (!isset(self::$classMappings[$componentName])) {
+            throw new RuntimeException("Component {$componentName} is not registered.");
+        }
 
-            if (!class_exists($className)) {
-                throw new RuntimeException("Class $className does not exist.");
+        $mappings = self::$classMappings[$componentName];
+        $selectedMapping = null;
+
+        if (is_array($mappings)) {
+            if (isset($mappings[0]) && is_array($mappings[0])) {
+                foreach ($mappings as $entry) {
+                    $entryImporter = isset($entry['importer']) ? str_replace('\\', '/', $entry['importer']) : '';
+                    $relativeEntryImporter = str_replace($srcPathNormalized . '/', '', $entryImporter);
+                    if ($relativeEntryImporter === $relativeImporterFile) {
+                        $selectedMapping = $entry;
+                        break;
+                    }
+                }
+                if ($selectedMapping === null) {
+                    $selectedMapping = $mappings[0];
+                }
+            } else {
+                $selectedMapping = $mappings;
             }
+        }
 
-            $componentInstance = new $className($attributes);
-            $renderedContent = $componentInstance->render();
+        if (!isset($selectedMapping['className']) || !isset($selectedMapping['filePath'])) {
+            throw new RuntimeException("Invalid component mapping for {$componentName}.");
+        }
 
-            if (strpos($renderedContent, '<') !== false) {
-                return self::compile($renderedContent);
-            }
-            return $renderedContent;
+        $className = $selectedMapping['className'];
+        $filePath = $selectedMapping['filePath'];
+
+        require_once str_replace('\\', '/', SRC_PATH . '/' . $filePath);
+
+        if (!class_exists($className)) {
+            throw new RuntimeException("Class {$className} does not exist.");
+        }
+
+        return new $className($attributes);
+    }
+
+    protected static function initializeClassMappings(): void
+    {
+        foreach (PrismaPHPSettings::$classLogFiles as $tagName => $fullyQualifiedClassName) {
+            self::$classMappings[$tagName] = $fullyQualifiedClassName;
         }
+    }
 
-        return self::renderAsHtml($componentName, $attributes);
+    protected static function hasComponentTag(string $templateContent): bool
+    {
+        return preg_match('/<\/*[A-Z][\w-]*/u', $templateContent) === 1;
     }
 
     protected static function renderAsHtml(string $tagName, array $attributes): string

package/package.json

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