PHPackages tomrf/htmx-message - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [HTTP & Networking](/categories/http) 4. / 5. tomrf/htmx-message ActiveLibrary[HTTP & Networking](/categories/http) tomrf/htmx-message ================== PHP PSR-7 proxy classes with convenience methods for htmx requests and responses 1.2.1(2y ago)12248[1 issues](https://github.com/tomrf/htmx-message/issues)MITPHPPHP ^8.0 Since Jul 10Pushed 2y ago2 watchersCompare [ Source](https://github.com/tomrf/htmx-message)[ Packagist](https://packagist.org/packages/tomrf/htmx-message)[ Docs](http://github.com/tomrf/htmx-message)[ RSS](/packages/tomrf-htmx-message/feed)WikiDiscussions master Synced 1mo ago READMEChangelogDependencies (11)Versions (14)Used By (0) htmx-message - PHP PSR-7 proxy classes with convenience methods for htmx requests and responses =============================================================================================== [](#htmx-message---php-psr-7-proxy-classes-with-convenience-methods-for-htmx-requests-and-responses) [![PHP Version Require](https://camo.githubusercontent.com/1a02a6344f79afe6adfa24a74ee11d72b43bd563d2fab0d2d8c9735484964a21/687474703a2f2f706f7365722e707567782e6f72672f746f6d72662f68746d782d6d6573736167652f726571756972652f7068703f7374796c653d666c61742d737175617265)](https://packagist.org/packages/tomrf/htmx-message) [![Latest Stable Version](https://camo.githubusercontent.com/645395acaeffaff9882cb1852d7f14319dc3d28d187364ecde5c006d60736f3e/687474703a2f2f706f7365722e707567782e6f72672f746f6d72662f68746d782d6d6573736167652f763f7374796c653d666c61742d737175617265)](https://packagist.org/packages/tomrf/htmx-message) [![License](https://camo.githubusercontent.com/e31646d504cef9dad2d63f9407b0501c5fa389bfdcc9019774ac4ee0b140d37c/687474703a2f2f706f7365722e707567782e6f72672f746f6d72662f68746d782d6d6573736167652f6c6963656e73653f7374796c653d666c61742d737175617265)](https://packagist.org/packages/tomrf/htmx-message) PSR-7 `ServerRequestInterface` and `ResponseInterface` proxy classes for [`htmx`](https://htmx.org)with convenience methods for all special htmx headers (`HX-*`) in request and response objects. `HtmxResponse` is a proxy for PSR-7 response objects implementing `\Psr\Http\Message\ResponseInterface`. `HtmxServerRequest` is a proxy for PSR-7 server request objects implementing `\Psr\Http\Message\ServerRequestInterface`. You can safely wrap any `ResponseInterface` or `ServerRequestInterface` object, also those not originating from [`htmx`](htmx.org), without affecting your application. `HtmxResponse` and `HtmxServerRequest` objects retains immutability in the same fashion as one would expect from a PSR-7 `MessageInterface`, returning a new object wrapping a new `ResponseInterface` instance whenever the `HtmxResponse` is changed. Conforms to [`htmx`](https://htmx.org) version 1.9.x (latest) as per 2023-08-01. 📔 [Go to documentation](#documentation) Installation ------------ [](#installation) Installation via composer: ``` composer require tomrf/htmx-message ``` Usage ----- [](#usage) ``` $request = new HtmxRequest($request); // PSR-7 `ServerRequestInterface` if ($request->isHxRequest() && $request->isHxBoosted()) { $layout = 'ajax.layout'; } [...] $response = new HtmxResponse($response); // PSR-7 `ResponseInterface` $response = $response->withHxTrigger('aSimpleTrigger') ->withAddedHxTrigger('triggerWithParams', ['arg' => true, 'arg2' => 7]) ->withTriggerAfterSwap('afterSwap', time()) ->withHxPush($newUrl); // Emit $response as normal [...] ``` Testing ------- [](#testing) ``` composer test ``` License ------- [](#license) This project is released under the MIT License (MIT). See [LICENSE](LICENSE) for more information. Documentation ------------- [](#documentation) - [Tomrf\\HtmxMessage\\HtmxResponse](#-tomrfhtmxmessagehtmxresponseclass) - [getHxPush](#gethxpush) - [getHxRedirect](#gethxredirect) - [getHxRetarget](#gethxretarget) - [getHxTrigger](#gethxtrigger) - [getHxTriggerAfterSettle](#gethxtriggeraftersettle) - [getHxTriggerAfterSwap](#gethxtriggerafterswap) - [hasHxPush](#hashxpush) - [hasHxRedirect](#hashxredirect) - [hasHxRefresh](#hashxrefresh) - [hasHxRetarget](#hashxretarget) - [hasHxTrigger](#hashxtrigger) - [hasHxTriggerAfterSettle](#hashxtriggeraftersettle) - [hasHxTriggerAfterSwap](#hashxtriggerafterswap) - [withAddedHxTrigger](#withaddedhxtrigger) - [withAddedHxTriggerAfterSettle](#withaddedhxtriggeraftersettle) - [withAddedHxTriggerAfterSwap](#withaddedhxtriggerafterswap) - [withHxPush](#withhxpush) - [withHxRedirect](#withhxredirect) - [withHxRefresh](#withhxrefresh) - [withHxRetarget](#withhxretarget) - [withHxTrigger](#withhxtrigger) - [withHxTriggerAfterSettle](#withhxtriggeraftersettle) - [withHxTriggerAfterSwap](#withhxtriggerafterswap) - [withoutHxPush](#withouthxpush) - [withoutHxRedirect](#withouthxredirect) - [withoutHxRefresh](#withouthxrefresh) - [withoutHxRetarget](#withouthxretarget) - [withoutHxTrigger](#withouthxtrigger) - [withoutHxTriggerAfterSettle](#withouthxtriggeraftersettle) - [withoutHxTriggerAfterSwap](#withouthxtriggerafterswap) - [Tomrf\\HtmxMessage\\HtmxServerRequest](#-tomrfhtmxmessagehtmxserverrequestclass) - [getHxCurrentUrl](#gethxcurrenturl) - [getHxPrompt](#gethxprompt) - [getHxTarget](#gethxtarget) - [getHxTrigger](#gethxtrigger) - [getHxTriggerName](#gethxtriggername) - [hasHxPrompt](#hashxprompt) - [hasHxTarget](#hashxtarget) - [hasHxTrigger](#hashxtrigger) - [hasHxTriggerName](#hashxtriggername) - [isHxBoosted](#ishxboosted) - [isHxHistoryRestoreRequest](#ishxhistoryrestorerequest) - [isHxRequest](#ishxrequest) - [\_\_construct](#__construct) --- ### 📂 Tomrf\\HtmxMessage\\HtmxResponse::class [](#-tomrfhtmxmessagehtmxresponseclass) HtmxResponse is a proxy for PSR-7 response objects implementing \\Psr\\Http\\Message\\ResponseInterface. You can safely wrap any ResponseInterface object, also those not responding to a htmx request, without affecting your application. HtmxResponse objects retains immutability in the same fashion as one would expect from a PSR-7 MessageInterface, returning a new object wrapping a new ResponseInterface instance whenever the HtmxResponse is changed. Example: ``` $response = new HtmxResponse($response); $response = $response->withHxTrigger('myTrigger') ->withRedirect('/user/redirected') ->withHxPush(false); // ... ``` #### getHxPush() [](#gethxpush) ``` public function getHxPush(): string ``` #### getHxRedirect() [](#gethxredirect) ``` public function getHxRedirect(): string ``` #### getHxRetarget() [](#gethxretarget) ``` public function getHxRetarget(): string ``` #### getHxTrigger() [](#gethxtrigger) ``` public function getHxTrigger(): array @return array ``` #### getHxTriggerAfterSettle() [](#gethxtriggeraftersettle) ``` public function getHxTriggerAfterSettle(): array @return array ``` #### getHxTriggerAfterSwap() [](#gethxtriggerafterswap) ``` public function getHxTriggerAfterSwap(): array @return array ``` #### hasHxPush() [](#hashxpush) ``` public function hasHxPush(): bool ``` #### hasHxRedirect() [](#hashxredirect) ``` public function hasHxRedirect(): bool ``` #### hasHxRefresh() [](#hashxrefresh) ``` public function hasHxRefresh(): bool ``` #### hasHxRetarget() [](#hashxretarget) ``` public function hasHxRetarget(): bool ``` #### hasHxTrigger() [](#hashxtrigger) ``` public function hasHxTrigger(): bool ``` #### hasHxTriggerAfterSettle() [](#hashxtriggeraftersettle) ``` public function hasHxTriggerAfterSettle(): bool ``` #### hasHxTriggerAfterSwap() [](#hashxtriggerafterswap) ``` public function hasHxTriggerAfterSwap(): bool ``` #### withAddedHxTrigger() [](#withaddedhxtrigger) ``` public function withAddedHxTrigger( string $trigger, mixed $argument = null ): static ``` #### withAddedHxTriggerAfterSettle() [](#withaddedhxtriggeraftersettle) ``` public function withAddedHxTriggerAfterSettle( string $trigger, mixed $argument = null ): static ``` #### withAddedHxTriggerAfterSwap() [](#withaddedhxtriggerafterswap) ``` public function withAddedHxTriggerAfterSwap( string $trigger, mixed $argument = null ): static ``` #### withHxPush() [](#withhxpush) ``` public function withHxPush( string|bool $url ): static ``` #### withHxRedirect() [](#withhxredirect) ``` public function withHxRedirect( string $url ): static ``` #### withHxRefresh() [](#withhxrefresh) ``` public function withHxRefresh(): static ``` #### withHxRetarget() [](#withhxretarget) ``` public function withHxRetarget( string $selector ): static ``` #### withHxTrigger() [](#withhxtrigger) ``` public function withHxTrigger( string $trigger, mixed $argument = null ): static ``` #### withHxTriggerAfterSettle() [](#withhxtriggeraftersettle) ``` public function withHxTriggerAfterSettle( string $trigger, mixed $argument = null ): static ``` #### withHxTriggerAfterSwap() [](#withhxtriggerafterswap) ``` public function withHxTriggerAfterSwap( string $trigger, mixed $argument = null ): static ``` #### withoutHxPush() [](#withouthxpush) ``` public function withoutHxPush(): static ``` #### withoutHxRedirect() [](#withouthxredirect) ``` public function withoutHxRedirect(): static ``` #### withoutHxRefresh() [](#withouthxrefresh) ``` public function withoutHxRefresh(): static ``` #### withoutHxRetarget() [](#withouthxretarget) ``` public function withoutHxRetarget(): static ``` #### withoutHxTrigger() [](#withouthxtrigger) ``` public function withoutHxTrigger(): static ``` #### withoutHxTriggerAfterSettle() [](#withouthxtriggeraftersettle) ``` public function withoutHxTriggerAfterSettle(): static ``` #### withoutHxTriggerAfterSwap() [](#withouthxtriggerafterswap) ``` public function withoutHxTriggerAfterSwap(): static ``` --- ### 📂 Tomrf\\HtmxMessage\\HtmxServerRequest::class [](#-tomrfhtmxmessagehtmxserverrequestclass) HtmxServerRequest is a proxy for PSR-7 server request objects implementing \\Psr\\Http\\Message\\ServerRequestInterface. You can safely wrap any ServerRequestInterface object, also those not originating from htmx, without affecting your application. Check if the request originated from htmx using the isHxRequest() method. HtmxServerRequest objects retains immutability in the same fashion as one would expect from a PSR-7 MessageInterface, returning a new object wrapping a new ServerRequestInterface instance whenever the HtmxServerRequest is changed. Example: ``` $request = new HtmxServerRequest($request); if ($request->isHxRequest() && $request->isHxBoosted()) { // htmx request from boosted client, respond accordingly } $userPrompt = $request->getHxPrompt(); // ... ``` #### getHxCurrentUrl() [](#gethxcurrenturl) ``` public function getHxCurrentUrl(): string ``` #### getHxPrompt() [](#gethxprompt) ``` public function getHxPrompt(): string ``` #### getHxTarget() [](#gethxtarget) ``` public function getHxTarget(): string ``` #### getHxTrigger() [](#gethxtrigger-1) ``` public function getHxTrigger(): string ``` #### getHxTriggerName() [](#gethxtriggername) ``` public function getHxTriggerName(): string ``` #### hasHxPrompt() [](#hashxprompt) ``` public function hasHxPrompt(): bool ``` #### hasHxTarget() [](#hashxtarget) ``` public function hasHxTarget(): bool ``` #### hasHxTrigger() [](#hashxtrigger-1) ``` public function hasHxTrigger(): bool ``` #### hasHxTriggerName() [](#hashxtriggername) ``` public function hasHxTriggerName(): bool ``` #### isHxBoosted() [](#ishxboosted) ``` public function isHxBoosted(): bool ``` #### isHxHistoryRestoreRequest() [](#ishxhistoryrestorerequest) ``` public function isHxHistoryRestoreRequest(): bool ``` #### isHxRequest() [](#ishxrequest) ``` public function isHxRequest(): bool ``` #### \_\_construct() [](#__construct) ``` public function __construct( Psr\Http\Message\ServerRequestInterface $message ): void ``` --- *Generated 2023-08-18T12:46:49+00:00 using 📚[tomrf/readme-gen](https://packagist.org/packages/tomrf/readme-gen)* ### Health Score 29 — LowBetter than 59% of packages Maintenance18 Infrequent updates — may be unmaintained Popularity18 Limited adoption so far Community8 Small or concentrated contributor base Maturity60 Established project with proven stability Bus Factor1 Top contributor holds 100% of commits — single point of failure How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window. **Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores. **Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement. **Maturity (30%)** — Project age, version count, PHP version support, and release stability. ### Release Activity Cadence Every ~40 days Total 13 Last Release 920d ago Major Versions 0.0.3 → 1.0.02022-12-12 ### Community Maintainers ![](https://www.gravatar.com/avatar/c2113e52873316a5ad6f705f08f4218b2ee8c4348b0c693bb87bd9359908d23f?d=identicon)[tom@upnode.no](/maintainers/tom@upnode.no) --- Top Contributors [![tomrf](https://avatars.githubusercontent.com/u/1669009?v=4)](https://github.com/tomrf "tomrf (56 commits)") --- Tags htmxhttp-messagephpphp-htmxpsr-7responseinterfaceserverrequestinterfacepsr-7http-messagehttp requesthtmxhttp-responseserver-request ### Code Quality TestsPHPUnit Static AnalysisPHPStan Code StylePHP CS Fixer Type Coverage Yes ### Embed Badge ![Health badge](/badges/tomrf-htmx-message/health.svg) ``` [![Health](https://phpackages.com/badges/tomrf-htmx-message/health.svg)](https://phpackages.com/packages/tomrf-htmx-message) ``` ### Alternatives [symfony/psr-http-message-bridge PSR HTTP message bridge 1.3k296.6M807](/packages/symfony-psr-http-message-bridge)[httpsoft/http-message Strict and fast implementation of PSR-7 and PSR-17 86874.0k94](/packages/httpsoft-http-message)[phpro/http-tools HTTP tools for developing more consistent HTTP implementations. 28137.8k](/packages/phpro-http-tools)[art4/requests-psr18-adapter Use WordPress/Requests as a PSR-18 HTTP client 153.3k](/packages/art4-requests-psr18-adapter) PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)