pyview-web 0.3.0__py3-none-any.whl → 0.8.0a2__py3-none-any.whl

pyview/__init__.py

@@ -1,13 +1,15 @@
-from pyview.live_view import LiveView
+from pyview.components import ComponentMeta, ComponentsManager, ComponentSocket, LiveComponent
+from pyview.js import JsCommand
 from pyview.live_socket import (
-    LiveViewSocket,
-    is_connected,
     ConnectedLiveViewSocket,
+    LiveViewSocket,
     UnconnectedSocket,
+    is_connected,
 )
-from pyview.pyview import PyView, defaultRootTemplate
-from pyview.js import JsCommand
-from pyview.pyview import RootTemplateContext, RootTemplate
+from pyview.live_view import LiveView
+from pyview.playground import playground
+from pyview.pyview import PyView, RootTemplate, RootTemplateContext, defaultRootTemplate
+from pyview.stream import Stream
 
 __all__ = [
     "LiveView",
@@ -19,4 +21,12 @@ __all__ = [
     "RootTemplate",
     "is_connected",
     "ConnectedLiveViewSocket",
+    "UnconnectedSocket",
+    "playground",
+    "Stream",
+    # Components
+    "LiveComponent",
+    "ComponentMeta",
+    "ComponentSocket",
+    "ComponentsManager",
 ]

pyview/assets/js/app.js

@@ -61,6 +61,7 @@ let csrfToken = document
 let liveSocket = new LiveSocket("/live", Socket, {
   hooks: Hooks,
   params: { _csrf_token: csrfToken },
+  uploaders: window.Uploaders || {},
 });
 
 // Show progress bar on live navigation and form submits

pyview/assets/js/uploaders.js

@@ -0,0 +1,221 @@
+/**
+ * PyView External S3 Uploaders
+ *
+ * Client-side uploaders for external S3 uploads.
+ *
+ * Available uploaders:
+ * - S3: Simple POST upload to S3 using presigned POST URLs
+ * - S3Multipart: Multipart upload for large files (>5GB)
+ */
+
+window.Uploaders = window.Uploaders || {};
+
+// S3 Simple POST uploader
+// Uses presigned POST URLs for direct upload to S3
+// Works for files up to ~5GB
+if (!window.Uploaders.S3) {
+  window.Uploaders.S3 = function (entries, onViewError) {
+    entries.forEach((entry) => {
+      let formData = new FormData();
+      let { url, fields } = entry.meta;
+
+      // Add all fields from presigned POST
+      Object.entries(fields).forEach(([key, val]) =>
+        formData.append(key, val)
+      );
+      formData.append("file", entry.file);
+
+      let xhr = new XMLHttpRequest();
+      onViewError(() => xhr.abort());
+
+      xhr.onload = () => {
+        if (xhr.status === 204 || xhr.status === 200) {
+          entry.progress(100);
+        } else {
+          entry.error(`S3 upload failed with status ${xhr.status}`);
+        }
+      };
+      xhr.onerror = () => entry.error("Network error during upload");
+
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable) {
+          let percent = Math.round((event.loaded / event.total) * 100);
+          if (percent < 100) {
+            entry.progress(percent);
+          }
+        }
+      });
+
+      xhr.open("POST", url, true);
+      xhr.send(formData);
+    });
+  };
+}
+
+// S3 Multipart uploader for large files
+// Uploads file in chunks with retry logic and concurrency control
+//
+// - Exponential backoff retry (max 3 attempts per part)
+// - Concurrency limit (max 6 parallel uploads)
+// - Automatic cleanup on fatal errors
+//
+// Based on AWS best practices:
+// https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html
+//
+// Server must:
+// 1. Return metadata with: uploader="S3Multipart", upload_id, part_urls, chunk_size
+// 2. Provide entry_complete callback to finalize the upload
+if (!window.Uploaders.S3Multipart) {
+  window.Uploaders.S3Multipart = function (entries, onViewError) {
+    entries.forEach((entry) => {
+      const { upload_id, part_urls, chunk_size, key } = entry.meta;
+      const file = entry.file;
+      const parts = []; // Store {PartNumber, ETag} for each uploaded part
+
+      const MAX_RETRIES = 3;
+      const MAX_CONCURRENT = 6;
+      let uploadedParts = 0;
+      let activeUploads = 0;
+      let partIndex = 0;
+      let hasError = false;
+      const totalParts = part_urls.length;
+
+      console.log(`[S3Multipart] Starting upload for ${entry.file.name}`);
+      console.log(`[S3Multipart] Total parts: ${totalParts}, chunk size: ${chunk_size}`);
+      console.log(`[S3Multipart] Max concurrent uploads: ${MAX_CONCURRENT}, max retries: ${MAX_RETRIES}`);
+
+      // Add a custom method to send completion data directly
+      // This bypasses entry.progress() which only handles numbers
+      entry.complete = function(completionData) {
+        console.log(`[S3Multipart] Calling entry.complete with:`, completionData);
+        // Call pushFileProgress directly with the completion data
+        entry.view.pushFileProgress(entry.fileEl, entry.ref, completionData);
+      };
+
+      // Upload a single part with retry logic
+      const uploadPart = (index, retryCount = 0) => {
+        if (hasError) return;  // Stop if we've hit a fatal error
+
+        const partNumber = index + 1;
+        const url = part_urls[index];
+        const start = index * chunk_size;
+        const end = Math.min(start + chunk_size, file.size);
+        const chunk = file.slice(start, end);
+
+        console.log(`[S3Multipart] Starting part ${partNumber}/${totalParts}, size: ${chunk.size} bytes, attempt ${retryCount + 1}`);
+
+        const xhr = new XMLHttpRequest();
+        onViewError(() => xhr.abort());
+
+        // Track upload progress within this chunk
+        xhr.upload.addEventListener("progress", (event) => {
+          if (event.lengthComputable) {
+            // Calculate overall progress: completed parts + current part's progress
+            const completedBytes = uploadedParts * chunk_size;
+            const currentPartBytes = event.loaded;
+            const totalBytes = file.size;
+            const overallPercent = Math.round(((completedBytes + currentPartBytes) / totalBytes) * 100);
+
+            // Don't report 100% until all parts complete and we send completion data
+            if (overallPercent < 100) {
+              entry.progress(overallPercent);
+            }
+          }
+        });
+
+        xhr.onload = () => {
+          activeUploads--;
+
+          if (xhr.status === 200) {
+            const etag = xhr.getResponseHeader('ETag');
+            console.log(`[S3Multipart] Part ${partNumber} succeeded, ETag: ${etag}`);
+
+            if (!etag) {
+              console.error(`[S3Multipart] Part ${partNumber} missing ETag!`);
+              entry.error(`Part ${partNumber} upload succeeded but no ETag returned`);
+              hasError = true;
+              return;
+            }
+
+            // Store the part with its ETag
+            parts.push({
+              PartNumber: partNumber,
+              ETag: etag.replace(/"/g, '')
+            });
+            uploadedParts++;
+
+            // Update progress
+            const progressPercent = Math.round((uploadedParts / totalParts) * 100);
+            console.log(`[S3Multipart] Progress: ${uploadedParts}/${totalParts} parts (${progressPercent}%)`);
+
+            if (uploadedParts < totalParts) {
+              entry.progress(progressPercent < 100 ? progressPercent : 99);
+              uploadNextPart();  // Start next part
+            } else {
+              // All parts complete!
+              const completionData = {
+                complete: true,
+                upload_id: upload_id,
+                key: key,
+                parts: parts.sort((a, b) => a.PartNumber - b.PartNumber)
+              };
+              console.log(`[S3Multipart] All parts complete! Sending completion data`);
+              entry.complete(completionData);
+            }
+          } else {
+            // Upload failed - retry with exponential backoff
+            console.error(`[S3Multipart] Part ${partNumber} failed with status ${xhr.status}, attempt ${retryCount + 1}`);
+
+            if (retryCount < MAX_RETRIES) {
+              // Exponential backoff: 1s, 2s, 4s, max 10s
+              const delay = Math.min(1000 * (2 ** retryCount), 10000);
+              console.log(`[S3Multipart] Retrying part ${partNumber} in ${delay}ms...`);
+
+              setTimeout(() => {
+                uploadPart(index, retryCount + 1);
+              }, delay);
+            } else {
+              // Max retries exceeded - fatal error
+              console.error(`[S3Multipart] Part ${partNumber} failed after ${MAX_RETRIES} retries, aborting upload`);
+              entry.error(`Part ${partNumber} failed after ${MAX_RETRIES} attempts. Upload aborted.`);
+              hasError = true;
+            }
+          }
+        };
+
+        xhr.onerror = () => {
+          activeUploads--;
+          console.error(`[S3Multipart] Network error on part ${partNumber}, attempt ${retryCount + 1}`);
+
+          if (retryCount < MAX_RETRIES) {
+            const delay = Math.min(1000 * (2 ** retryCount), 10000);
+            console.log(`[S3Multipart] Retrying part ${partNumber} after network error in ${delay}ms...`);
+
+            setTimeout(() => {
+              uploadPart(index, retryCount + 1);
+            }, delay);
+          } else {
+            console.error(`[S3Multipart] Part ${partNumber} network error after ${MAX_RETRIES} retries, aborting upload`);
+            entry.error(`Part ${partNumber} network error after ${MAX_RETRIES} attempts. Upload aborted.`);
+            hasError = true;
+          }
+        };
+
+        xhr.open('PUT', url, true);
+        xhr.send(chunk);
+        activeUploads++;
+      };
+
+      // Upload next part if we haven't hit the concurrency limit
+      const uploadNextPart = () => {
+        while (partIndex < totalParts && activeUploads < MAX_CONCURRENT && !hasError) {
+          uploadPart(partIndex);
+          partIndex++;
+        }
+      };
+
+      // Start initial batch of uploads
+      uploadNextPart();
+    });
+  };
+}

pyview/assets/package-lock.json

@@ -6,9 +6,9 @@
     "": {
       "dependencies": {
         "nprogress": "^0.2.0",
-        "phoenix": "^1.7.0-rc.2",
+        "phoenix": "^1.7.0",
         "phoenix_html": "^3.2.0",
-        "phoenix_live_view": "^0.18.11"
+        "phoenix_live_view": "^0.20.17"
       }
     },
     "node_modules/nprogress": {
@@ -17,9 +17,10 @@
       "integrity": "sha512-I19aIingLgR1fmhftnbWWO3dXc0hSxqHQHQb3H8m+K3TnEn/iSeTZZOyvKXWqQESMwuUVnatlCnZdLBZZt2VSA=="
     },
     "node_modules/phoenix": {
-      "version": "1.7.0-rc.2",
-      "resolved": "https://registry.npmjs.org/phoenix/-/phoenix-1.7.0-rc.2.tgz",
-      "integrity": "sha512-05DaSo/ws2VtieY3Z6CJVx36DyhTil6/KesK1a4JlQPxYgNHZn7swv7R/R7etoN8SGtEjMV/a9HBkPS5wF/Xdg=="
+      "version": "1.8.3",
+      "resolved": "https://registry.npmjs.org/phoenix/-/phoenix-1.8.3.tgz",
+      "integrity": "sha512-5bMYQI30wl3erxbHnXMdt1xuQeRTeEOpQrakf3yqj/1HRHl7Gj4Cdk2NKXkUcCD5WpbxrilvZEMexM1VhWbnDg==",
+      "license": "MIT"
     },
     "node_modules/phoenix_html": {
       "version": "3.2.0",
@@ -27,9 +28,10 @@
       "integrity": "sha512-zv7PIZk0MPkF0ax8n465Q6w86+sGAy5cTem6KcbkUbdgxGc0y3WZmzkM2bSlYdSGbLEZfjXxos1G72xXsha6xA=="
     },
     "node_modules/phoenix_live_view": {
-      "version": "0.18.11",
-      "resolved": "https://registry.npmjs.org/phoenix_live_view/-/phoenix_live_view-0.18.11.tgz",
-      "integrity": "sha512-p/mBu/O3iVLvAreUoDeSZ4/myQJJeR8BH7Yu9LVCMI2xe2IZ2mffxtDGJb0mxnJrUQa7p03HHNlKGXj7LSJDdg=="
+      "version": "0.20.17",
+      "resolved": "https://registry.npmjs.org/phoenix_live_view/-/phoenix_live_view-0.20.17.tgz",
+      "integrity": "sha512-qGT3Jtj2wUawOaMrE8NKXmkexfaUn6bx5PuPMxWMzYuyp6Qv9i4xRZ2T3U6avC5Kf+oJEiBVIiWrODooC0vpQw==",
+      "license": "MIT"
     }
   },
   "dependencies": {
@@ -39,9 +41,9 @@
       "integrity": "sha512-I19aIingLgR1fmhftnbWWO3dXc0hSxqHQHQb3H8m+K3TnEn/iSeTZZOyvKXWqQESMwuUVnatlCnZdLBZZt2VSA=="
     },
     "phoenix": {
-      "version": "1.7.0-rc.2",
-      "resolved": "https://registry.npmjs.org/phoenix/-/phoenix-1.7.0-rc.2.tgz",
-      "integrity": "sha512-05DaSo/ws2VtieY3Z6CJVx36DyhTil6/KesK1a4JlQPxYgNHZn7swv7R/R7etoN8SGtEjMV/a9HBkPS5wF/Xdg=="
+      "version": "1.8.3",
+      "resolved": "https://registry.npmjs.org/phoenix/-/phoenix-1.8.3.tgz",
+      "integrity": "sha512-5bMYQI30wl3erxbHnXMdt1xuQeRTeEOpQrakf3yqj/1HRHl7Gj4Cdk2NKXkUcCD5WpbxrilvZEMexM1VhWbnDg=="
     },
     "phoenix_html": {
       "version": "3.2.0",
@@ -49,9 +51,9 @@
       "integrity": "sha512-zv7PIZk0MPkF0ax8n465Q6w86+sGAy5cTem6KcbkUbdgxGc0y3WZmzkM2bSlYdSGbLEZfjXxos1G72xXsha6xA=="
     },
     "phoenix_live_view": {
-      "version": "0.18.11",
-      "resolved": "https://registry.npmjs.org/phoenix_live_view/-/phoenix_live_view-0.18.11.tgz",
-      "integrity": "sha512-p/mBu/O3iVLvAreUoDeSZ4/myQJJeR8BH7Yu9LVCMI2xe2IZ2mffxtDGJb0mxnJrUQa7p03HHNlKGXj7LSJDdg=="
+      "version": "0.20.17",
+      "resolved": "https://registry.npmjs.org/phoenix_live_view/-/phoenix_live_view-0.20.17.tgz",
+      "integrity": "sha512-qGT3Jtj2wUawOaMrE8NKXmkexfaUn6bx5PuPMxWMzYuyp6Qv9i4xRZ2T3U6avC5Kf+oJEiBVIiWrODooC0vpQw=="
     }
   }
 }

pyview/assets/package.json

@@ -1,8 +1,8 @@
 {
   "dependencies": {
     "nprogress": "^0.2.0",
-    "phoenix": "^1.7.0-rc.2",
+    "phoenix": "^1.7.0",
     "phoenix_html": "^3.2.0",
-    "phoenix_live_view": "^0.18.11"
+    "phoenix_live_view": "^0.20.17"
   }
 }

pyview/async_stream_runner.py

@@ -1,7 +1,8 @@
 import asyncio
-import uuid
 import logging
+import uuid
 from typing import Any, AsyncGenerator, Callable, Optional
+
 from pyview.events.info_event import InfoEvent, InfoEventScheduler
 
 

pyview/auth/__init__.py

@@ -1,2 +1,4 @@
+from .provider import AllowAllAuthProvider, AuthProvider, AuthProviderFactory
 from .required import requires
-from .provider import AuthProvider, AllowAllAuthProvider, AuthProviderFactory
+
+__all__ = ["AllowAllAuthProvider", "AuthProvider", "AuthProviderFactory", "requires"]

pyview/auth/provider.py

@@ -1,16 +1,16 @@
-from typing import Protocol, TypeVar, Callable
+from typing import Callable, Protocol, TypeVar
+
 from starlette.websockets import WebSocket
+
 from pyview import LiveView
 
 _CallableType = TypeVar("_CallableType", bound=Callable)
 
 
 class AuthProvider(Protocol):
-    async def has_required_auth(self, websocket: WebSocket) -> bool:
-        ...
+    async def has_required_auth(self, websocket: WebSocket) -> bool: ...
 
-    def wrap(self, func: _CallableType) -> _CallableType:
-        ...
+    def wrap(self, func: _CallableType) -> _CallableType: ...
 
 
 class AllowAllAuthProvider(AuthProvider):
@@ -28,5 +28,5 @@ class AuthProviderFactory:
 
     @classmethod
     def set(cls, lv: type[LiveView], auth_provider: AuthProvider) -> type[LiveView]:
-        setattr(lv, "__pyview_auth_provider__", auth_provider)
+        setattr(lv, "__pyview_auth_provider__", auth_provider)  # noqa: B010
         return lv

pyview/auth/required.py

@@ -1,15 +1,14 @@
 import typing
 from dataclasses import dataclass
+from typing import ParamSpec
+
+from starlette.authentication import has_required_scope
+from starlette.authentication import requires as starlette_requires
 from starlette.websockets import WebSocket
-from starlette.authentication import requires as starlette_requires, has_required_scope
-from .provider import AuthProvider, AuthProviderFactory
+
 from pyview import LiveView
-import sys
 
-if sys.version_info >= (3, 10):  # pragma: no cover
-    from typing import ParamSpec
-else:  # pragma: no cover
-    from typing_extensions import ParamSpec
+from .provider import AuthProvider, AuthProviderFactory
 
 _P = ParamSpec("_P")
 
@@ -20,9 +19,7 @@ class RequiredScopeAuthProvider(AuthProvider):
     status_code: int = 403
     redirect: typing.Optional[str] = None
 
-    def wrap(
-        self, func: typing.Callable[_P, typing.Any]
-    ) -> typing.Callable[_P, typing.Any]:
+    def wrap(self, func: typing.Callable[_P, typing.Any]) -> typing.Callable[_P, typing.Any]:
         return starlette_requires(self.scopes, self.status_code, self.redirect)(func)
 
     async def has_required_auth(self, websocket: WebSocket) -> bool:

pyview/binding/__init__.py

@@ -0,0 +1,47 @@
+"""Parameter binding for pyview handlers.
+
+This module provides signature-driven parameter binding, allowing handlers to
+declare typed parameters that are automatically converted from request data.
+
+Example:
+    # Old style (manual extraction):
+    async def handle_params(self, url, params, socket):
+        page = int(params["page"][0]) if "page" in params else 1
+
+    # New style (typed binding):
+    async def handle_params(self, socket: LiveViewSocket[MyContext], page: int = 1):
+        # page is already an int!
+        pass
+
+Reserved parameter names (injected from context, not from URL params):
+    - socket: The LiveViewSocket instance
+    - url: The parsed URL
+    - event: The event name (for event handlers)
+    - payload: The event payload dict (for event handlers)
+
+Type-based injection:
+    - params: Params  -> injects Params container
+    - params: dict    -> injects params as dict
+    - params: str     -> treats "params" as a URL param name (not injected)
+"""
+
+from .binder import Binder
+from .context import BindContext
+from .converters import ConversionError, ConverterRegistry
+from .helpers import call_handle_event, call_handle_params
+from .injectables import InjectableRegistry
+from .params import Params
+from .result import BindResult, ParamError
+
+__all__ = [
+    "Params",
+    "BindContext",
+    "BindResult",
+    "ParamError",
+    "ConverterRegistry",
+    "ConversionError",
+    "InjectableRegistry",
+    "Binder",
+    "call_handle_event",
+    "call_handle_params",
+]

pyview/binding/binder.py

@@ -0,0 +1,134 @@
+"""Core binder for signature-driven parameter binding."""
+
+from __future__ import annotations
+
+import dataclasses
+import inspect
+import logging
+from typing import Any, Callable, Generic, TypeVar, get_type_hints
+
+from .context import BindContext
+from .converters import ConversionError, ConverterRegistry
+from .injectables import _NOT_FOUND, InjectableRegistry
+from .result import BindResult, ParamError
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class Binder(Generic[T]):
+    """Binds function parameters from BindContext based on type annotations.
+
+    The binder inspects a function's signature and type hints, then:
+    1. Resolves injectable parameters (socket, event, payload, url, params)
+    2. Pulls values from params or payload for other parameters
+    3. Converts values to the expected types
+    4. Returns a BindResult with bound_args and any errors
+    """
+
+    def __init__(
+        self,
+        converter: ConverterRegistry | None = None,
+        injectables: InjectableRegistry[T] | None = None,
+    ):
+        self.converter = converter or ConverterRegistry()
+        self.injectables = injectables or InjectableRegistry()
+
+    def bind(self, func: Callable[..., Any], ctx: BindContext[T]) -> BindResult:
+        """Bind context values to function signature.
+
+        Args:
+            func: The function to bind parameters for
+            ctx: Binding context with params, payload, socket, etc.
+
+        Returns:
+            BindResult with bound_args dict and any errors
+        """
+        sig = inspect.signature(func)
+
+        # Get type hints, falling back to empty for missing annotations
+        # NameError: forward reference can't be resolved
+        # AttributeError: accessing annotations on some objects
+        # RecursionError: circular type references
+        try:
+            hints = get_type_hints(func)
+        except (NameError, AttributeError, RecursionError) as e:
+            logger.debug("Could not resolve type hints for %s: %s", func.__name__, e)
+            hints = {}
+
+        bound: dict[str, Any] = {}
+        errors: list[ParamError] = []
+
+        for name, param in sig.parameters.items():
+            # Skip 'self' for methods
+            if name == "self":
+                continue
+
+            # Skip *args and **kwargs (VAR_POSITIONAL and VAR_KEYWORD)
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+
+            expected = hints.get(name, Any)
+
+            # 1) Try injectables first
+            injected = self.injectables.resolve(name, expected, ctx)
+            if injected is not _NOT_FOUND:
+                bound[name] = injected
+                continue
+
+            # 2) Check for dataclass parameter - gather fields from params
+            if dataclasses.is_dataclass(expected) and isinstance(expected, type):
+                raw = self._resolve_dataclass_fields(expected, ctx)
+                try:
+                    bound[name] = self.converter.convert(raw, expected)
+                except ConversionError as e:
+                    errors.append(ParamError(name, repr(expected), raw, str(e)))
+                continue
+
+            # 3) Pull raw value from params or payload
+            raw = self._resolve_raw(name, ctx)
+
+            # 4) Handle missing values
+            if raw is None:
+                if param.default is not inspect.Parameter.empty:
+                    bound[name] = param.default
+                    continue
+                if self.converter.is_optional(expected):
+                    bound[name] = None
+                    continue
+                errors.append(ParamError(name, repr(expected), None, "missing required parameter"))
+                continue
+
+            # 5) Convert to expected type
+            try:
+                bound[name] = self.converter.convert(raw, expected)
+            except ConversionError as e:
+                errors.append(ParamError(name, repr(expected), raw, str(e)))
+
+        return BindResult(bound, errors)
+
+    def _resolve_dataclass_fields(self, expected: type, ctx: BindContext[T]) -> dict[str, Any]:
+        """Gather dataclass fields from params."""
+        fields = dataclasses.fields(expected)
+        result: dict[str, Any] = {}
+
+        for field in fields:
+            if ctx.params.has(field.name):
+                result[field.name] = ctx.params.getlist(field.name)
+            elif ctx.payload and field.name in ctx.payload:
+                result[field.name] = ctx.payload[field.name]
+
+        return result
+
+    def _resolve_raw(self, name: str, ctx: BindContext[T]) -> Any | None:
+        """Resolve raw value from params or payload."""
+        # Check params first
+        if ctx.params.has(name):
+            return ctx.params.getlist(name)
+
+        # Check payload
+        if ctx.payload and name in ctx.payload:
+            return ctx.payload[name]
+
+        return None

pyview/binding/context.py

@@ -0,0 +1,33 @@
+"""Binding context for parameter resolution."""
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar
+from urllib.parse import ParseResult
+
+if TYPE_CHECKING:
+    from pyview.live_socket import LiveViewSocket
+
+    from .params import Params
+
+T = TypeVar("T")
+
+
+@dataclass
+class BindContext(Generic[T]):
+    """Context provided to the binder for resolving parameter values.
+
+    Attributes:
+        params: Multi-value parameter container (query/path/form merged)
+        payload: Event payload dict (for handle_event)
+        url: Parsed URL (for handle_params)
+        socket: LiveView socket instance
+        event: Event name (for handle_event)
+        extra: Additional injectable values
+    """
+
+    params: "Params"
+    payload: Optional[dict[str, Any]]
+    url: Optional[ParseResult]
+    socket: Optional["LiveViewSocket[T]"]
+    event: Optional[str]
+    extra: dict[str, Any] = field(default_factory=dict)