@jqhtml/core 2.2.222

package/laravel-bridge/src/JqhtmlServiceProvider.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Jqhtml\LaravelBridge;
+
+use Illuminate\Support\ServiceProvider;
+use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
+
+class JqhtmlServiceProvider extends ServiceProvider
+{
+    /**
+     * Register any application services.
+     */
+    public function register()
+    {
+        // Register the error formatter as a singleton
+        $this->app->singleton(JqhtmlErrorFormatter::class, function ($app) {
+            return new JqhtmlErrorFormatter(
+                $app['config']->get('jqhtml.source_maps_path', storage_path('jqhtml-sourcemaps')),
+                $app['config']->get('jqhtml.show_source_context', true)
+            );
+        });
+
+        // Register the exception renderer
+        $this->app->singleton(JqhtmlExceptionRenderer::class, function ($app) {
+            return new JqhtmlExceptionRenderer(
+                $app->make(JqhtmlErrorFormatter::class)
+            );
+        });
+    }
+
+    /**
+     * Bootstrap any application services.
+     */
+    public function boot()
+    {
+        // Publish configuration
+        $this->publishes([
+            __DIR__ . '/../config/jqhtml.php' => config_path('jqhtml.php'),
+        ], 'jqhtml-config');
+
+        // Extend Laravel's exception handler
+        $this->extendExceptionHandler();
+    }
+
+    /**
+     * Extend Laravel's exception handler to handle JQHTML exceptions
+     */
+    protected function extendExceptionHandler()
+    {
+        $this->app->extend(ExceptionHandler::class, function ($handler, $app) {
+            // Hook into the exception rendering process
+            $handler->reportable(function (JqhtmlException $e) {
+                // Custom reporting logic if needed
+            });
+
+            $handler->renderable(function (JqhtmlException $e, $request) use ($app) {
+                if ($request->expectsJson()) {
+                    return response()->json(
+                        $app->make(JqhtmlErrorFormatter::class)->formatForJson($e),
+                        500
+                    );
+                }
+
+                // For web requests, let Laravel's default HTML handler display it
+                // with our enhanced error information
+                return null;
+            });
+
+            return $handler;
+        });
+    }
+}

package/laravel-bridge/src/Middleware/JqhtmlErrorMiddleware.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace Jqhtml\LaravelBridge\Middleware;
+
+use Closure;
+use Illuminate\Http\Request;
+use Jqhtml\LaravelBridge\JqhtmlErrorFormatter;
+use Jqhtml\LaravelBridge\JqhtmlException;
+use Throwable;
+
+class JqhtmlErrorMiddleware
+{
+    protected $formatter;
+
+    public function __construct(JqhtmlErrorFormatter $formatter)
+    {
+        $this->formatter = $formatter;
+    }
+
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle(Request $request, Closure $next)
+    {
+        try {
+            return $next($request);
+        } catch (Throwable $exception) {
+            // Check if this might be a JQHTML error
+            if ($this->isJqhtmlError($exception)) {
+                // Wrap it in our exception type for better handling
+                $wrapped = $this->formatter->wrapException($exception);
+
+                if ($wrapped instanceof JqhtmlException) {
+                    // Add request context
+                    $wrapped->setCompiledFile(
+                        $this->getCompiledFileFromRequest($request)
+                    );
+
+                    throw $wrapped;
+                }
+            }
+
+            // Not a JQHTML error, rethrow as-is
+            throw $exception;
+        }
+    }
+
+    /**
+     * Check if an exception appears to be JQHTML-related
+     */
+    protected function isJqhtmlError(Throwable $exception): bool
+    {
+        $message = $exception->getMessage();
+
+        return strpos($message, 'JQHTML') !== false ||
+               strpos($message, 'jqhtml') !== false ||
+               strpos($message, 'at line') !== false && strpos($message, 'column') !== false ||
+               strpos($message, 'Unclosed component') !== false ||
+               strpos($message, 'Mismatched tags') !== false;
+    }
+
+    /**
+     * Try to determine the compiled file from the request
+     */
+    protected function getCompiledFileFromRequest(Request $request): ?string
+    {
+        // Check if the request has a reference to a compiled template
+        $route = $request->route();
+
+        if ($route && method_exists($route, 'getAction')) {
+            $action = $route->getAction();
+
+            // Look for JQHTML template reference in route action
+            if (isset($action['jqhtml_template'])) {
+                return $action['jqhtml_template'];
+            }
+        }
+
+        // Check request attributes
+        if ($request->has('_jqhtml_compiled')) {
+            return $request->get('_jqhtml_compiled');
+        }
+
+        return null;
+    }
+}

package/laravel-bridge/tests/ExceptionFormattingTest.php

@@ -0,0 +1,219 @@
+<?php
+
+namespace Jqhtml\LaravelBridge\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Jqhtml\LaravelBridge\JqhtmlException;
+use Jqhtml\LaravelBridge\JqhtmlErrorFormatter;
+
+class ExceptionFormattingTest extends TestCase
+{
+    protected $formatter;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->formatter = new JqhtmlErrorFormatter();
+    }
+
+    public function testBasicExceptionCreation()
+    {
+        $exception = new JqhtmlException(
+            'Unclosed component definition',
+            'templates/test.jqhtml',
+            10,
+            15
+        );
+
+        $this->assertEquals('Unclosed component definition', $exception->getMessage());
+        $this->assertEquals('templates/test.jqhtml', $exception->getTemplateFile());
+        $this->assertEquals(10, $exception->getTemplateLine());
+        $this->assertEquals(15, $exception->getTemplateColumn());
+    }
+
+    public function testExceptionWithSuggestion()
+    {
+        $exception = new JqhtmlException(
+            'Unclosed component definition',
+            'templates/test.jqhtml',
+            10,
+            15,
+            null,
+            'Did you forget </Define:ComponentName>?'
+        );
+
+        $this->assertEquals('Did you forget </Define:ComponentName>?', $exception->getSuggestion());
+
+        $formatted = $exception->getFormattedMessage();
+        $this->assertStringContainsString('Did you forget', $formatted);
+    }
+
+    public function testExceptionFromJsError()
+    {
+        $jsError = [
+            'message' => 'Syntax error: unexpected token',
+            'filename' => 'app.jqhtml',
+            'line' => 42,
+            'column' => 8,
+            'suggestion' => 'Check for missing closing tags',
+            'severity' => 'error'
+        ];
+
+        $exception = JqhtmlException::createFromJsError($jsError);
+
+        $this->assertEquals('Syntax error: unexpected token', $exception->getMessage());
+        $this->assertEquals('app.jqhtml', $exception->getTemplateFile());
+        $this->assertEquals(42, $exception->getTemplateLine());
+        $this->assertEquals(8, $exception->getTemplateColumn());
+        $this->assertEquals('Check for missing closing tags', $exception->getSuggestion());
+    }
+
+    public function testExceptionFromJsonString()
+    {
+        $json = json_encode([
+            'message' => 'Parse error',
+            'templateFile' => 'template.jqhtml',
+            'line' => 5,
+            'column' => 10
+        ]);
+
+        $exception = JqhtmlException::createFromJsError($json);
+
+        $this->assertEquals('Parse error', $exception->getMessage());
+        $this->assertEquals('template.jqhtml', $exception->getTemplateFile());
+        $this->assertEquals(5, $exception->getTemplateLine());
+        $this->assertEquals(10, $exception->getTemplateColumn());
+    }
+
+    public function testFormatterBasicFormat()
+    {
+        $exception = new JqhtmlException(
+            'Test error',
+            'test.jqhtml',
+            20,
+            5
+        );
+
+        $formatted = $this->formatter->format($exception);
+
+        $this->assertArrayHasKey('message', $formatted);
+        $this->assertArrayHasKey('file', $formatted);
+        $this->assertArrayHasKey('line', $formatted);
+        $this->assertArrayHasKey('column', $formatted);
+        $this->assertArrayHasKey('error_type', $formatted);
+
+        $this->assertEquals('Test error', $formatted['message']);
+        $this->assertEquals('test.jqhtml', $formatted['file']);
+        $this->assertEquals(20, $formatted['line']);
+        $this->assertEquals(5, $formatted['column']);
+    }
+
+    public function testFormatterWithSourceContext()
+    {
+        $sourceCode = "line 1\nline 2\nline 3 with error\nline 4\nline 5";
+
+        $exception = new JqhtmlException(
+            'Error on line 3',
+            'test.jqhtml',
+            3,
+            10,
+            $sourceCode
+        );
+
+        $formatter = new JqhtmlErrorFormatter(null, true);
+        $formatted = $formatter->format($exception);
+
+        $this->assertArrayHasKey('source_context', $formatted);
+
+        $context = $formatted['source_context'];
+        $this->assertIsArray($context);
+
+        // Find the error line in context
+        $errorLine = null;
+        foreach ($context as $line) {
+            if ($line['is_error_line']) {
+                $errorLine = $line;
+                break;
+            }
+        }
+
+        $this->assertNotNull($errorLine);
+        $this->assertEquals(3, $errorLine['line_number']);
+        $this->assertEquals('line 3 with error', $errorLine['content']);
+        $this->assertEquals(10, $errorLine['error_column']);
+    }
+
+    public function testFormatterJsonFormat()
+    {
+        $exception = new JqhtmlException('JSON test error');
+
+        $json = $this->formatter->formatForJson($exception);
+
+        $this->assertArrayHasKey('error', $json);
+        $this->assertArrayHasKey('type', $json);
+        $this->assertArrayHasKey('message', $json);
+        $this->assertArrayHasKey('details', $json);
+
+        $this->assertTrue($json['error']);
+        $this->assertEquals('jqhtml_error', $json['type']);
+        $this->assertEquals('JSON test error', $json['message']);
+    }
+
+    public function testWrapGenericException()
+    {
+        $genericException = new \Exception(
+            'JQHTMLParseError: Unclosed tag at line 10, column 5'
+        );
+
+        $wrapped = $this->formatter->wrapException($genericException);
+
+        $this->assertInstanceOf(JqhtmlException::class, $wrapped);
+        $this->assertEquals(10, $wrapped->getTemplateLine());
+        $this->assertEquals(5, $wrapped->getTemplateColumn());
+    }
+
+    public function testWrapExceptionWithFilename()
+    {
+        $genericException = new \Exception(
+            'Error at component.jqhtml:15:20 - syntax error'
+        );
+
+        $wrapped = $this->formatter->wrapException($genericException);
+
+        $this->assertInstanceOf(JqhtmlException::class, $wrapped);
+        $this->assertEquals('component.jqhtml', $wrapped->getTemplateFile());
+        $this->assertEquals(15, $wrapped->getTemplateLine());
+        $this->assertEquals(20, $wrapped->getTemplateColumn());
+    }
+
+    public function testCodeSnippetGeneration()
+    {
+        $source = implode("\n", [
+            'line 1',
+            'line 2',
+            'line 3',
+            'error is here', // line 4
+            'line 5',
+            'line 6',
+            'line 7'
+        ]);
+
+        $exception = new JqhtmlException(
+            'Error message',
+            'test.jqhtml',
+            4,
+            8,
+            $source
+        );
+
+        $formatted = $exception->getFormattedMessage();
+
+        // Should show context lines
+        $this->assertStringContainsString('line 3', $formatted);
+        $this->assertStringContainsString('error is here', $formatted);
+        $this->assertStringContainsString('line 5', $formatted);
+
+        // Should have error pointer
+        $this->assertStringContainsString('^', $formatted);
+    }
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@jqhtml/core",
+  "version": "2.2.222",
+  "description": "Core runtime library for JQHTML",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./debug": {
+      "import": "./dist/jqhtml-debug.esm.js",
+      "types": "./dist/debug.d.ts"
+    },
+    "./bundle": {
+      "import": "./dist/jqhtml-core.esm.js"
+    }
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "build:tsc": "tsc",
+    "watch": "rollup -c -w",
+    "test": "jest",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "jquery": "^3.7.0"
+  },
+  "browser": true,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "laravel-bridge",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "jquery",
+    "components",
+    "framework",
+    "jqhtml",
+    "templating"
+  ],
+  "author": "JQHTML Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jqhtml/jqhtml.git",
+    "directory": "packages/core"
+  },
+  "dependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-replace": "^6.0.2",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@types/jest": "^29.5.14",
+    "@types/jquery": "^3.5.32",
+    "esbuild": "^0.25.9",
+    "jest": "^29.5.0",
+    "jsdom": "^26.1.0",
+    "playwright": "^1.53.2",
+    "rollup": "^4.49.0",
+    "rollup-plugin-dts": "^6.2.3",
+    "ts-jest": "^29.1.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.2"
+  },
+  "devDependencies": null
+}