v4, beta5 (#20)

Reviewed-on: #20

README.md

@@ -10,11 +10,11 @@ htmx uses attributes and HTTP headers to attain its interactivity; the libraries
 
 `Giraffe.Htmx` provides extensions that facilitate using htmx on the server side, primarily reading and setting headers. `Giraffe.ViewEngine.Htmx` provides attributes and helpers to produce views that utilize htmx. Both can be installed from NuGet via standard methods.
 
-| Server Side | View Engine |
+| Server Side                                                                                                            | View Engine                                                                                                                                  |
-|---|---|
+|------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------|
-|[![Nuget](https://img.shields.io/nuget/v/Giraffe.Htmx?style=plastic)](https://www.nuget.org/packages/Giraffe.Htmx/)|[![Nuget](https://img.shields.io/nuget/v/Giraffe.ViewEngine.Htmx?style=plastic)](https://www.nuget.org/packages/Giraffe.ViewEngine.Htmx/)|
+| [![Nuget](https://img.shields.io/nuget/vpre/Giraffe.Htmx?style=plastic)](https://www.nuget.org/packages/Giraffe.Htmx/) | [![Nuget](https://img.shields.io/nuget/vpre/Giraffe.ViewEngine.Htmx?style=plastic)](https://www.nuget.org/packages/Giraffe.ViewEngine.Htmx/) |
 
-Both of these packages will also install `Giraffe.Htmx.Common`, which has some common definitions and provides a local-to-your-project version of the htmx JavaScript _(as of v2.0.8)_.
+Both of these packages will also install `Giraffe.Htmx.Common`, which has some common definitions and provides a local-to-your-project version of the htmx JavaScript _(as of v2.0.8)_ and htmax htmx-plus-extensions bundle _(as of v4.0.0-beta4)_.
 
 ## Server Side (`Giraffe.Htmx`)
 
@@ -74,7 +74,7 @@ If you want to use the package-provided htmx library, `Htmx.Script.local` will c
 
 ## Feedback / Help
 
-The author hangs out in the #dotnet-htmx channel (and most others) of the [htmx Discord server](https://htmx.org/discord) and the #web channel of the [F# Software Foundation's Slack server](https://fsharp.org/guides/slack/).
+The author hangs out in the #dotnet-htmx channel (and most others) of the [htmx Discord server](https://htmx.org/discord) and the #web channel (and most others) of the [F# Community Discord server](https://discord.gg/R6n7c54).
 
 ## Thanks
 |[<img src="https://giraffe.wiki/giraffe.png" alt="Giraffe logo" width="200">](https://giraffe.wiki)| [<img src="https://bitbadger.solutions/upload/bit-badger/2024/01/htmx-black-transparent.svg" alt="htmx logo" width="200">](https://htmx.org) |[<img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.png" alt="JetBrains Logo (Main)" width="200">](https://jb.gg/OpenSource)|

src/Common/Common.fs

@@ -1,97 +1,113 @@
-/// <summary>Common definitions shared between attribute values and response headers</summary>
+/// <summary>Common definitions shared between attribute values and response headers</summary>
-[<AutoOpen>]
+[<AutoOpen>]
-module Giraffe.Htmx.Common
+module Giraffe.Htmx.Common
-
+
-/// <summary>The version of htmx embedded in the package</summary>
+/// <summary>The version of htmx embedded in the package</summary>
-let HtmxVersion = "4.0.0-alpha6"
+let HtmxVersion = "4.0.0-beta5"
-
+
-/// <summary>The path for the provided htmx script</summary>
+/// <summary>URLs for the included htmx library static web assets</summary>
-let internal htmxLocalScript = $"/_content/Giraffe.Htmx.Common/htmx.min.js?ver={HtmxVersion}"
+module StaticAssetUrl =
-
+    /// <summary>The path for the provided htmx script</summary>
-/// <summary>Serialize a list of key/value pairs to JSON (very rudimentary)</summary>
+    let htmx = $"/_content/Giraffe.Htmx.Common/htmx.min.js?ver={HtmxVersion}"
-/// <param name="pairs">The key/value pairs to be serialized to JSON</param>
+
-/// <returns>A string with the key/value pairs serialized to JSON</returns>
+    /// <summary>The path for the provided htmax script</summary>
-let internal toJson (pairs: (string * string) list) =
+    let htmax = $"/_content/Giraffe.Htmx.Common/htmax.min.js?ver={HtmxVersion}"
-    pairs
+
-    |> List.map (fun pair -> sprintf "\"%s\": \"%s\"" (fst pair) ((snd pair).Replace ("\"", "\\\"")))
+/// <summary>Serialize a list of key/value pairs to JSON (very rudimentary)</summary>
-    |> String.concat ", "
+/// <param name="pairs">The key/value pairs to be serialized to JSON</param>
-    |> sprintf "{ %s }"
+/// <returns>A string with the key/value pairs serialized to JSON</returns>
-
+let internal toJson (pairs: (string * string) list) =
-/// <summary>Convert a boolean to lowercase "true" or "false"</summary>
+    pairs
-/// <param name="boolValue">The boolean value to convert</param>
+    |> List.map (fun pair -> sprintf "\"%s\": \"%s\"" (fst pair) ((snd pair).Replace ("\"", "\\\"")))
-/// <returns>"true" for <c>true</c>, "false" for <c>false</c></returns>
+    |> String.concat ", "
-let internal toLowerBool (boolValue: bool) =
+    |> sprintf "{ %s }"
-    (string boolValue).ToLowerInvariant()
+
-
+/// <summary>Convert a boolean to lowercase "true" or "false"</summary>
-
+/// <param name="boolValue">The boolean value to convert</param>
-/// <summary>Valid values for the <c>hx-swap</c> attribute / <c>HX-Reswap</c> header</summary>
+/// <returns>"true" for <c>true</c>, "false" for <c>false</c></returns>
-/// <remarks>May be combined with <c>swap</c> / <c>scroll</c> / <c>show</c> config)</remarks>
+let internal toLowerBool (boolValue: bool) =
-/// <seealso href="https://four.htmx.org/attributes/hx-swap/">Documentation</seealso>
+    (string boolValue).ToLowerInvariant()
-[<RequireQualifiedAccess>]
+
-module HxSwap =
+
-    
+/// <summary>Valid values for the <c>hx-swap</c> attribute / <c>HX-Reswap</c> header</summary>
-    /// <summary>The default, replace the inner HTML of the target element</summary>
+/// <remarks>May be combined with <c>swap</c> / <c>scroll</c> / <c>show</c> config)</remarks>
-    [<Literal>]
+/// <seealso href="https://four.htmx.org/attributes/hx-swap/">Documentation</seealso>
-    let InnerHtml = "innerHTML"
+[<RequireQualifiedAccess>]
-    
+module HxSwap =
-    /// <summary>Replace the entire target element with the response</summary>
+
-    [<Literal>]
+    /// <summary>The default, replace the inner HTML of the target element</summary>
-    let OuterHtml = "outerHTML"
+    [<Literal>]
-    
+    let InnerHtml = "innerHTML"
-    /// <summary>Morph the inner HTML of the target to the new content</summary>
+
-    [<Literal>]
+    /// <summary>Replace the entire target element with the response</summary>
-    let InnerMorph = "innerMorph"
+    [<Literal>]
-    
+    let OuterHtml = "outerHTML"
-    /// <summary>Morph the outer HTML of the target to the new content</summary>
+
-    [<Literal>]
+    /// <summary>Morph the inner HTML of the target to the new content</summary>
-    let OuterMorph = "innerMorph"
+    [<Literal>]
-    
+    let InnerMorph = "innerMorph"
-    /// <summary>Replace the text content of the target without parsing the response as HTML</summary>
+
-    [<Literal>]
+    /// <summary>Morph the outer HTML of the target to the new content</summary>
-    let TextContent = "textContent"
+    [<Literal>]
-    
+    let OuterMorph = "outerMorph"
-    /// <summary>Insert the response before the target element</summary>
+
-    [<Literal>]
+    /// <summary>Morph the outer HTML of the target to the new content, recreating all children</summary>
-    let Before = "before"
+    /// <remarks>This is used internally by the new history extension, but can be used by others if desired</remarks>
-    
+    [<Literal>]
-    /// <summary>Insert the response before the target element (pre-v4 name)</summary>
+    let OuterSync = "outerSync"
-    [<Literal>]
+
-    let BeforeBegin = Before
+    /// <summary>Replace the text content of the target without parsing the response as HTML</summary>
-    
+    [<Literal>]
-    /// <summary>Insert the response before the first child of the target element</summary>
+    let TextContent = "textContent"
-    [<Literal>]
+
-    let Prepend = "prepend"
+    /// <summary>Insert the response before the target element</summary>
-    
+    [<Literal>]
-    /// <summary>Insert the response before the first child of the target element (pre-v4 name)</summary>
+    let Before = "before"
-    [<Literal>]
+
-    let AfterBegin = Prepend
+    /// <summary>Insert the response before the target element (pre-v4 name)</summary>
-    
+    [<Literal>]
-    /// <summary>Insert the response after the last child of the target element</summary>
+    let BeforeBegin = Before
-    [<Literal>]
+
-    let Append = "append"
+    /// <summary>Insert the response before the first child of the target element</summary>
-    
+    [<Literal>]
-    /// <summary>Insert the response after the last child of the target element (pre-v4 name)</summary>
+    let Prepend = "prepend"
-    [<Literal>]
+
-    let BeforeEnd = Append
+    /// <summary>Insert the response before the first child of the target element (pre-v4 name)</summary>
-    
+    [<Literal>]
-    /// <summary>Insert the response after the target element</summary>
+    let AfterBegin = Prepend
-    [<Literal>]
+
-    let After = "after"
+    /// <summary>Insert the response after the last child of the target element</summary>
-
+    [<Literal>]
-    /// <summary>Insert the response after the target element (pre-v4 name)</summary>
+    let Append = "append"
-    [<Literal>]
+
-    let AfterEnd = After
+    /// <summary>Insert the response after the last child of the target element (pre-v4 name)</summary>
-    
+    [<Literal>]
-    /// <summary>Delete the target element regardless of response</summary>
+    let BeforeEnd = Append
-    [<Literal>]
+
-    let Delete = "delete"
+    /// <summary>Insert the response after the target element</summary>
-
+    [<Literal>]
-    /// <summary>Does not append content from response (out of band items will still be processed)</summary>
+    let After = "after"
-    [<Literal>]
+
-    let None = "none"
+    /// <summary>Insert the response after the target element (pre-v4 name)</summary>
-
+    [<Literal>]
-    /// <summary>Update existing elements by <c>id</c> and add new ones</summary>
+    let AfterEnd = After
-    /// <remarks>This requires the <c>upsert</c> extension</remarks>
+
-    /// <seealso href="https://four.htmx.org/extensions/upsert">Extension</seealso>
+    /// <summary>Delete the target element regardless of response</summary>
-    [<Literal>]
+    [<Literal>]
-    let Upsert = "upsert"
+    let Delete = "delete"
+
+    /// <summary>Does not append content from response (out of band items will still be processed)</summary>
+    [<Literal>]
+    let None = "none"
+
+    /// <summary>Update existing elements by <c>id</c> and add new ones</summary>
+    /// <remarks>This requires the <c>upsert</c> extension</remarks>
+    /// <seealso href="https://four.htmx.org/extensions/upsert">Extension</seealso>
+    [<Literal>]
+    let Upsert = "upsert"
+
+    /// <summary>Specify that the target of the htmx request should be downloaded</summary>
+    /// <remarks>This requires the <c>hx-download</c> extension (included in the htmax bundle)</remarks>
+    /// <seealso href="https://four.htmx.org/extensions/hx-download#explicit-swap-style">Documentation</seealso>
+    [<Literal>]
+    let Download = "download"

src/Common/Giraffe.Htmx.Common.fsproj

@@ -14,7 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Update="FSharp.Core" Version="6.0.0" />
+    <PackageReference Include="FSharp.Core" />
   </ItemGroup>
   
   <ItemGroup>

src/Common/README.md

@@ -1,7 +1,7 @@
 ## Giraffe.Htmx.Common
 
-This package contains common code shared between [`Giraffe.Htmx`](https://www.nuget.org/packages/Giraffe.Htmx) and [`Giraffe.ViewEngine.Htmx`](https://www.nuget.org/packages/Giraffe.ViewEngine.Htmx), and will be automatically installed when you install either one. It also contains htmx as a static web asset, allowing it to be loaded from your local (or published) project.
+This package contains common code shared between [`Giraffe.Htmx`](https://www.nuget.org/packages/Giraffe.Htmx) and [`Giraffe.ViewEngine.Htmx`](https://www.nuget.org/packages/Giraffe.ViewEngine.Htmx), and will be automatically installed when you install either one. It also contains htmx and htmax as static web assets, allowing them to be loaded from your local (or published) project.
 
-**htmx version: 4.0.0-alpha6**
+**htmx version: 4.0.0-beta5**
 
 _**NOTE:** Pay special attention to breaking changes highlighted in the packages listed above._

src/Directory.Build.props

@@ -3,15 +3,16 @@
     <PropertyGroup>
         <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
         <VersionPrefix>4.0.0</VersionPrefix>
-        <VersionSuffix>alpha6a</VersionSuffix>
+        <VersionSuffix>beta5</VersionSuffix>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
-        <PackageReleaseNotes>First htmx 4 alpha release of these libraries 
+        <PackageReleaseNotes>Update htmx 4 to beta5
-- [Server] Marked removed headers as obsolete; added new HX-Source header
+- [Common] Update provided htmx/htmax 4 to 4.0.0-beta5
-- [View Engine] Marked removed attributes as obsolete
+- [Common] Add StaticAssetUrl module with static asset paths for htmx and htmax
-- [View Engine] Added new attributes, modifiers, and support for new hx-partial tag
+- [Server] Unobsolete HX-Prompt header, note that it requires hx-prompt extension
-- Updated script tags to pull htmx 4.0.0-alpha6
+- [View Engine] Unobsolete hx-prompt attribute, note that it requires hx-prompt extension
+- [View Engine] Updated CDN script tags to pull htmx / htmax 4.0.0-beta5
 
-See package READMEs; this is not an update-and-forget-it release
+See package and prior alpha release READMEs; v2 to v4 is not an update-and-forget-it release
         </PackageReleaseNotes>
         <Authors>danieljsummers</Authors>
         <Company>Bit Badger Solutions</Company>

src/Directory.Packages.props

@@ -0,0 +1,13 @@
+<Project>
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageVersion Include="Expecto" Version="11.0.0" />
+    <PackageVersion Include="Giraffe" Version="8.2.0" />
+    <PackageVersion Include="Giraffe.ViewEngine" Version="1.4.0" />
+    <PackageVersion Include="NSubstitute" Version="5.3.0" />
+    <PackageVersion Include="FSharp.Core" Version="10.1.301" />
+    <!-- <PackageVersion Update="FSharp.Core" Version="10.0.0" /> -->
+  </ItemGroup>
+</Project>

src/Giraffe.Htmx.sln

@@ -1,40 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30114.105
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Giraffe.Htmx", "Htmx\Giraffe.Htmx.fsproj", "{8AB3085C-5236-485A-8565-A09106E72E1E}"
-EndProject
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Giraffe.ViewEngine.Htmx", "ViewEngine.Htmx\Giraffe.ViewEngine.Htmx.fsproj", "{F718B3C1-EE01-4F04-ABCE-BF2AE700FDA9}"
-EndProject
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Giraffe.Htmx.Common", "Common\Giraffe.Htmx.Common.fsproj", "{75D66845-F93A-4463-AD29-A8B16E4D4BA9}"
-EndProject
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Tests", "Tests\Tests.fsproj", "{39823773-4311-4E79-9CA0-F9DDC40CAF6A}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{8AB3085C-5236-485A-8565-A09106E72E1E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{8AB3085C-5236-485A-8565-A09106E72E1E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{8AB3085C-5236-485A-8565-A09106E72E1E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{8AB3085C-5236-485A-8565-A09106E72E1E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F718B3C1-EE01-4F04-ABCE-BF2AE700FDA9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F718B3C1-EE01-4F04-ABCE-BF2AE700FDA9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F718B3C1-EE01-4F04-ABCE-BF2AE700FDA9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F718B3C1-EE01-4F04-ABCE-BF2AE700FDA9}.Release|Any CPU.Build.0 = Release|Any CPU
-		{75D66845-F93A-4463-AD29-A8B16E4D4BA9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{75D66845-F93A-4463-AD29-A8B16E4D4BA9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{75D66845-F93A-4463-AD29-A8B16E4D4BA9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{75D66845-F93A-4463-AD29-A8B16E4D4BA9}.Release|Any CPU.Build.0 = Release|Any CPU
-		{39823773-4311-4E79-9CA0-F9DDC40CAF6A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{39823773-4311-4E79-9CA0-F9DDC40CAF6A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{39823773-4311-4E79-9CA0-F9DDC40CAF6A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{39823773-4311-4E79-9CA0-F9DDC40CAF6A}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-EndGlobal

src/Giraffe.Htmx.slnx

@@ -0,0 +1,6 @@
+<Solution>
+  <Project Path="Common/Giraffe.Htmx.Common.fsproj" />
+  <Project Path="Htmx/Giraffe.Htmx.fsproj" />
+  <Project Path="Tests/Tests.fsproj" />
+  <Project Path="ViewEngine.Htmx/Giraffe.ViewEngine.Htmx.fsproj" />
+</Solution>

src/Htmx/Giraffe.Htmx.fsproj

@@ -14,8 +14,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Giraffe" Version="6.4.0" />
+    <PackageReference Include="Giraffe" />
-    <PackageReference Update="FSharp.Core" Version="6.0.0" />
+    <PackageReference Include="FSharp.Core" />
   </ItemGroup>
 
   <ItemGroup>

src/Htmx/Htmx.fs

@@ -4,27 +4,40 @@ open Microsoft.AspNetCore.Http
 open Microsoft.Extensions.Primitives
 open System
 
+/// <summary>The request types which may be set in the <c>HX-Request</c> header</summary>
+type HxRequestTypes =
+    /// <summary>A request targeting the <c>body</c> tag or using an <c>hx-select</c> attribute</summary>
+    | HxFullRequest
+
+    /// <summary>A request for partial content</summary>
+    | HxPartialRequest
+
 /// Determine if the given header is present
 let private hdr (headers : IHeaderDictionary) hdr =
     match headers[hdr] with it when it = StringValues.Empty -> None | it -> Some it[0]
 
 /// Extensions to the header dictionary
 type IHeaderDictionary with
-  
+
     /// <summary>Indicates that the request is via an element using <c>hx-boost</c></summary>
     member this.HxBoosted
         with get () = hdr this "HX-Boosted" |> Option.map bool.Parse
-    
+
     /// <summary>The current URL of the browser <em>(note that this does not update until after settle)</em></summary>
     member this.HxCurrentUrl
         with get () = hdr this "HX-Current-URL" |> Option.map Uri
-    
+
     /// <summary><c>true</c> if the request is for history restoration after a miss in the local history cache</summary>
     member this.HxHistoryRestoreRequest
         with get () = hdr this "HX-History-Restore-Request" |> Option.map bool.Parse
-    
+
+    /// <summary><c>true</c> if the request has been fired by the preload extension</summary>
+    /// <remarks><c>preload</c> is part of the htmax htmx-plus-extensions bundle</remarks>
+    member this.HxPreloaded
+        with get () = hdr this "HX-Preloaded" |> Option.map bool.Parse
+
     /// <summary>The user response to an <c>hx-prompt</c></summary>
-    [<Obsolete "hx-prompt is removed in v4">]
+    /// <remarks><b>NEW IN v4:</b> This functionality is dependent on the hx-prompt extension being loaded</remarks>
     member this.HxPrompt
         with get () = hdr this "HX-Prompt"
 
@@ -32,6 +45,21 @@ type IHeaderDictionary with
     member this.HxRequest
         with get () = hdr this "HX-Request" |> Option.map bool.Parse
 
+    /// <summary>The ID of the request (WebSocket extension requests only)</summary>
+    /// <remarks><c>hx-ws</c> is part of the htmax htmx-plus-extensions bundle</remarks>
+    member this.HxRequestId
+        with get () = hdr this "HX-Request-ID"
+
+    /// <summary>The request type sent by htmx</summary>
+    /// <seealso cref="HxRequestTypes" />
+    member this.HxRequestType
+        with get () =
+            match hdr this "HX-Request-Type" with
+            | Some typ when typ = "full" -> Some HxFullRequest
+            | Some typ when typ = "partial" -> Some HxPartialRequest
+            | Some _ -> None
+            | None -> None
+
     /// <summary>The tag name (fst) and <c>id</c> attribute (snd) of the element triggering this request</summary>
     member this.HxSource
         with get () =
@@ -45,8 +73,23 @@ type IHeaderDictionary with
             | None -> None
 
     /// <summary>The <c>id</c> attribute of the target element if it exists</summary>
+    /// <remarks>
+    /// In v4, this changed to tag name (fst) and <c>id</c> (snd); to resolve build errors, and restore the prior
+    /// behavior of <c>[id] option</c>, replace
+    /// <code>ctx.HxTarget</code>
+    /// with
+    /// <code>ctx.HxTarget |> Option.iter snd</code>
+    /// </remarks>
     member this.HxTarget
-        with get () = hdr this "HX-Target"
+        with get () =
+            match hdr this "HX-Target" with
+            | Some src ->
+                let parts = src.Split "#"
+                if parts.Length = 1 then
+                    Some (parts[0], None)
+                else
+                    Some (parts[0], if parts[1] <> "" then Some parts[1] else None)
+            | None -> None
 
     /// <summary>The <c>id</c> attribute of the triggered element if it exists</summary>
     [<Obsolete "HX-Trigger is removed in v4; use the second item of HX-Source">]
@@ -76,14 +119,22 @@ type HttpRequest with
 module Handlers =
 
     open Giraffe.Htmx.Common
-    
+
+    /// <summary>Instruct htmx to download a response from another path / URL</summary>
+    /// <param name="path">The path or URL where the downloadable content is found</param>
+    /// <returns>An HTTP handler with the <c>HX-Download</c> header set</returns>
+    /// <remarks>This requires the client-side <c>hx-download</c> extension (included in the htmax bundle)</remarks>
+    /// <seealso href="https://four.htmx.org/extensions/hx-download#hx-download-header">Documentation</seealso>
+    let withHxDownload (path: string) : HttpHandler =
+        setHttpHeader "HX-Download" path
+
     /// <summary>Instruct htmx to perform a client-side redirect for content</summary>
     /// <param name="path">The path where the content should be found</param>
     /// <returns>An HTTP handler with the <c>HX-Location</c> header set</returns>
     /// <seealso href="https://htmx.org/headers/hx-location/">Documentation</seealso>
     let withHxLocation (path: string) : HttpHandler =
         setHttpHeader "HX-Location" path
-    
+
     /// <summary>Pushes a new url into the history stack</summary>
     /// <param name="url">The URL to be pushed</param>
     /// <returns>An HTTP handler with the <c>HX-Push-Url</c> header set</returns>
@@ -97,7 +148,7 @@ module Handlers =
     /// <seealso href="https://htmx.org/headers/hx-push-url/">Documentation</seealso>
     let withHxNoPushUrl : HttpHandler =
         toLowerBool false |> withHxPushUrl
-      
+
     /// <summary>Can be used to do a client-side redirect to a new location</summary>
     /// <param name="url">The URL to which the client should be redirected</param>
     /// <returns>An HTTP handler with the <c>HX-Redirect</c> header set</returns>
@@ -124,13 +175,13 @@ module Handlers =
     /// <seealso href="https://htmx.org/headers/hx-replace-url/">Documentation</seealso>
     let withHxNoReplaceUrl : HttpHandler =
         toLowerBool false |> withHxReplaceUrl
-    
+
     /// <summary>Override which portion of the response will be swapped into the target document</summary>
     /// <param name="target">The selector for the new response target</param>
     /// <returns>An HTTP handler with the <c>HX-Reselect</c> header set</returns>
     let withHxReselect (target: string) : HttpHandler =
         setHttpHeader "HX-Reselect" target
-    
+
     /// <summary>Override the <c>hx-swap</c> attribute from the initiating element</summary>
     /// <param name="swap">The swap value to override</param>
     /// <returns>An HTTP handler with the <c>HX-Reswap</c> header set</returns>
@@ -162,38 +213,44 @@ module Handlers =
     /// <param name="evt">The call to the event that should be triggered</param>
     /// <returns>An HTTP handler with the <c>HX-Trigger-After-Settle</c> header set</returns>
     /// <seealso href="https://htmx.org/headers/hx-trigger/">Documentation</seealso>
+    [<Obsolete "Removed in v4; use withHxTrigger">]
     let withHxTriggerAfterSettle (evt: string) : HttpHandler =
-        setHttpHeader "HX-Trigger-After-Settle" evt
+        setHttpHeader "HX-Trigger" evt
 
     /// <summary>Allows you to trigger multiple client side events after changes have settled</summary>
     /// <param name="evts">The calls to events that should be triggered</param>
     /// <returns>An HTTP handler with the <c>HX-Trigger-After-Settle</c> header set for all given events</returns>
     /// <seealso href="https://htmx.org/headers/hx-trigger/">Documentation</seealso>
+    [<Obsolete "Removed in v4; use withHxTrigger">]
     let withHxTriggerManyAfterSettle evts : HttpHandler =
-        toJson evts |> setHttpHeader "HX-Trigger-After-Settle"
+        toJson evts |> setHttpHeader "HX-Trigger"
 
     /// <summary>Allows you to trigger a single client side event after DOM swapping occurs</summary>
     /// <param name="evt">The call to the event that should be triggered</param>
     /// <returns>An HTTP handler with the <c>HX-Trigger-After-Swap</c> header set</returns>
     /// <seealso href="https://htmx.org/headers/hx-trigger/">Documentation</seealso>
+    [<Obsolete "Removed in v4; use withHxTrigger">]
     let withHxTriggerAfterSwap (evt: string) : HttpHandler =
-        setHttpHeader "HX-Trigger-After-Swap" evt
+        setHttpHeader "HX-Trigger" evt
 
     /// <summary>Allows you to trigger multiple client side events after DOM swapping occurs</summary>
     /// <param name="evts">The calls to events that should be triggered</param>
     /// <returns>An HTTP handler with the <c>HX-Trigger-After-Swap</c> header set for all given events</returns>
     /// <seealso href="https://htmx.org/headers/hx-trigger/">Documentation</seealso>
+    [<Obsolete "Removed in v4; use withHxTrigger">]
     let withHxTriggerManyAfterSwap evts : HttpHandler =
-        toJson evts |> setHttpHeader "HX-Trigger-After-Swap"
+        toJson evts |> setHttpHeader "HX-Trigger"
 
 
 /// <summary>Load the package-provided version of the htmx script</summary>
 [<RequireQualifiedAccess>]
 module HtmxScript =
-    
+
     open Giraffe.Htmx.Common
     open Microsoft.AspNetCore.Html
 
     /// <summary><c>script</c> tag to load the package-provided version of the htmx script</summary>
-    let local = HtmlString $"""<script src="{htmxLocalScript}"></script>"""
+    let local = HtmlString $"""<script src="{StaticAssetUrl.htmx}"></script>"""
-    
+
+    /// <summary><c>script</c> tag to load the package-provided version of the htmax script</summary>
+    let localMax = HtmlString $"""<script src="{StaticAssetUrl.htmax}"></script>"""

src/Htmx/README.md

@@ -2,9 +2,9 @@
 
 This package enables server-side support for [htmx](https://htmx.org) within [Giraffe](https://giraffe.wiki) and ASP.NET's `HttpContext`.
 
-**htmx version: 4.0.0-alpha6**
+**htmx version: 4.0.0-beta5**
 
-_Upgrading from v2.x: the [migration guide](https://four.htmx.org/migration-guide-htmx-4/) lists changes for v4. For this package, the `HX-Trigger` and `HX-Trigger-Name` headers are marked obsolete. They are replaced by `HX-Source`, which provides the triggering tag name and `id` attribute. The `HX-Prompt` header has also been marked as obsolete, as the `hx-prompt` attribute which generated its content has been removed._
+_Upgrading from v2.x: the [migration guide](https://four.htmx.org/docs/get-started/migration) lists changes for v4. For this package, the `HX-Trigger` and `HX-Trigger-Name` headers are marked obsolete. They are replaced by `HX-Source`, which provides the triggering tag name and `id` attribute. The `HX-Prompt` header has also been marked as obsolete, as the `hx-prompt` attribute which generated its content has been removed._
 
 _Obsolete elements will be removed in the first production v4 release._
 
@@ -36,7 +36,7 @@ let myHandler : HttpHander =
 
 The `HxSwap` module has constants to use for the `HX-Reswap` header. These may be extended with settle, show, and other qualifiers; see the htmx documentation for the `hx-swap` attribute for more information.
 
-To load the package-provided htmx library without using Giraffe.ViewEngine, use `HtmxScript.local`.
+To load the package-provided htmx library without using Giraffe.ViewEngine, use `HtmxScript.local`; to load the htmax bundle, use `HtmxScript.localMax`.
 
 ### Learn
 

src/Tests/Common.fs

@@ -6,9 +6,25 @@ open Giraffe.Htmx
 /// Test to ensure the version was updated
 let version =
     test "HtmxVersion is correct" {
-        Expect.equal HtmxVersion "4.0.0-alpha6" "htmx version incorrect"
+        Expect.equal HtmxVersion "4.0.0-beta5" "htmx version incorrect"
     }
 
+let staticAssetUrl =
+    testList "StaticAssetUrl" [
+        test "htmx is correct" {
+            Expect.equal
+                StaticAssetUrl.htmx
+                $"/_content/Giraffe.Htmx.Common/htmx.min.js?ver={HtmxVersion}"
+                "Static htmx URL incorrect"
+        }
+        test "htmax is correct" {
+            Expect.equal
+                StaticAssetUrl.htmax
+                $"/_content/Giraffe.Htmx.Common/htmax.min.js?ver={HtmxVersion}"
+                "Static htmx URL incorrect"
+        }
+    ]
+
 /// Tests for the HxSwap module
 let swap =
     testList "HxSwap" [
@@ -22,7 +38,10 @@ let swap =
             Expect.equal HxSwap.InnerMorph "innerMorph" "Inner Morph swap value incorrect"
         }
         test "OuterMorph is correct" {
-            Expect.equal HxSwap.OuterMorph "innerMorph" "Outer Morph swap value incorrect"
+            Expect.equal HxSwap.OuterMorph "outerMorph" "Outer Morph swap value incorrect"
+        }
+        test "OuterSync is correct" {
+            Expect.equal HxSwap.OuterSync "outerSync" "Outer Sync swap value incorrect"
         }
         test "TextContent is correct" {
             Expect.equal HxSwap.TextContent "textContent" "Text Content swap value incorrect"
@@ -60,7 +79,10 @@ let swap =
         test "Upsert is correct" {
             Expect.equal HxSwap.Upsert "upsert" "Upsert swap value incorrect"
         }
+        test "Download is correct" {
+            Expect.equal HxSwap.Download "download" "Download swap value incorrect"
+        }
     ]
 
 /// All tests for this module
-let allTests = testList "Htmx.Common" [ version; swap ]
+let allTests = testList "Htmx.Common" [ version; staticAssetUrl; swap ]

src/Tests/Htmx.fs

@@ -73,6 +73,45 @@ let dictExtensions =
                     ctx.Request.Headers.HxHistoryRestoreRequest.Value "The header should have been false"
             }
         ]
+        testList "HxPreloaded" [
+            test "succeeds when the header is not present" {
+                let ctx = Substitute.For<HttpContext>()
+                ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
+                Expect.isNone ctx.Request.Headers.HxPreloaded "There should not have been a header returned"
+            }
+            test "succeeds when the header is present and true" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Preloaded", "true")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                Expect.isSome ctx.Request.Headers.HxPreloaded "There should be a header present"
+                Expect.isTrue ctx.Request.Headers.HxPreloaded.Value "The header should have been true"
+            }
+            // This is not a condition fired by the extension; the header will be either absent or true
+            test "succeeds when the header is present and false" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Preloaded", "false")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                Expect.isSome ctx.Request.Headers.HxPreloaded "There should be a header present"
+                Expect.isFalse ctx.Request.Headers.HxPreloaded.Value "The header should have been false"
+            }
+        ]
+        testList "HxPrompt" [
+            test "succeeds when the header is not present" {
+                let ctx = Substitute.For<HttpContext>()
+                ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
+                Expect.isNone ctx.Request.Headers.HxPrompt "There should not have been a header returned"
+            }
+            test "succeeds when the header is present" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Prompt", "of course")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                Expect.isSome ctx.Request.Headers.HxPrompt "There should be a header present"
+                Expect.equal ctx.Request.Headers.HxPrompt.Value "of course" "The header value was incorrect"
+            }
+        ]
         testList "HxRequest" [
             test "succeeds when the header is not present" {
                 let ctx = Substitute.For<HttpContext>()
@@ -96,6 +135,51 @@ let dictExtensions =
                 Expect.isFalse ctx.Request.Headers.HxRequest.Value "The header should have been false"
             }
         ]
+        testList "HxRequestId" [
+            test "succeeds when the header is not present" {
+                let ctx = Substitute.For<HttpContext>()
+                ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
+                Expect.isNone ctx.Request.Headers.HxRequestId "There should not have been a header returned"
+            }
+            test "succeeds when the header is present" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Request-ID", "abcd1234")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                Expect.isSome ctx.Request.Headers.HxRequestId "There should be a header present"
+                Expect.equal ctx.Request.Headers.HxRequestId.Value "abcd1234" "The header value was incorrect"
+            }
+        ]
+        testList "HxRequestType" [
+            test "succeeds when the header is not present" {
+                let ctx = Substitute.For<HttpContext>()
+                ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
+                Expect.isNone ctx.Request.Headers.HxRequestType "There should not have been a header returned"
+            }
+            test "succeeds when the header is invalid" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Request-Type", "relaxed")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                Expect.isNone ctx.Request.Headers.HxRequestType "There should not have been a header returned"
+            }
+            test "succeeds for a full request" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Request-Type", "full")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                Expect.isSome ctx.Request.Headers.HxRequestType "There have been a header returned"
+                Expect.equal ctx.Request.Headers.HxRequestType.Value HxFullRequest "The header value is incorrect"
+            }
+            test "succeeds for a partial request" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Request-Type", "partial")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                Expect.isSome ctx.Request.Headers.HxRequestType "There have been a header returned"
+                Expect.equal ctx.Request.Headers.HxRequestType.Value HxPartialRequest "The header value is incorrect"
+            }
+        ]
         testList "HxSource" [
             test "succeeds when the header is not present" {
                 let ctx = Substitute.For<HttpContext>()
@@ -140,13 +224,36 @@ let dictExtensions =
                 ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
                 Expect.isNone ctx.Request.Headers.HxTarget "There should not have been a header returned"
             }
-            test "succeeds when the header is present" {
+            test "succeeds when the header is present and both parts exist" {
                 let ctx = Substitute.For<HttpContext>()
                 let dic = HeaderDictionary()
-                dic.Add("HX-Target", "#leItem")
+                dic.Add("HX-Target", "div#leItem")
                 ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
-                Expect.isSome ctx.Request.Headers.HxTarget "There should be a header present"
+                let hdr = ctx.Request.Headers.HxTarget
-                Expect.equal ctx.Request.Headers.HxTarget.Value "#leItem" "The header value was incorrect"
+                Expect.isSome hdr "There should be a header present"
+                Expect.equal (fst hdr.Value) "div" "The target tag was incorrect"
+                Expect.isSome (snd hdr.Value) "There should be a target ID present"
+                Expect.equal (snd hdr.Value).Value "leItem" "The header value was incorrect"
+            }
+            test "succeeds when the header is present and ID is blank" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Target", "span#")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                let hdr = ctx.Request.Headers.HxTarget
+                Expect.isSome hdr "There should be a header present"
+                Expect.equal (fst hdr.Value) "span" "The target tag was incorrect"
+                Expect.isNone (snd hdr.Value) "There should not be a target ID present"
+            }
+            test "succeeds when the header is present and ID is missing" {
+                let ctx = Substitute.For<HttpContext>()
+                let dic = HeaderDictionary()
+                dic.Add("HX-Target", "aside")
+                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
+                let hdr = ctx.Request.Headers.HxTarget
+                Expect.isSome hdr "There should be a header present"
+                Expect.equal (fst hdr.Value) "aside" "The target tag was incorrect"
+                Expect.isNone (snd hdr.Value) "There should not be a target ID present"
             }
         ]
     ]
@@ -159,7 +266,7 @@ let reqExtensions =
                 let ctx = Substitute.For<HttpContext>()
                 ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
                 Expect.isFalse ctx.Request.IsHtmx "The request should not be an htmx request"
-            }    
+            }
             test "succeeds when request is from htmx" {
                 let ctx = Substitute.For<HttpContext>()
                 let dic = HeaderDictionary()
@@ -196,10 +303,18 @@ open System.Threading.Tasks
 
 /// Dummy "next" parameter to get the pipeline to execute/terminate
 let next (ctx: HttpContext) = Task.FromResult(Some ctx)
-        
+
 /// Tests for the HttpHandler functions provided in the Handlers module
 let handlers =
     testList "HandlerTests" [
+        testTask "withHxDownload succeeds" {
+            let ctx = Substitute.For<HttpContext>()
+            let dic = HeaderDictionary()
+            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
+            let! _ = withHxDownload "/files/stuff.pdf" next ctx
+            Expect.isTrue (dic.ContainsKey "HX-Download") "The HX-Download header should be present"
+            Expect.equal dic["HX-Download"].[0] "/files/stuff.pdf" "The HX-Download value was incorrect"
+        }
         testTask "withHxLocation succeeds" {
             let ctx = Substitute.For<HttpContext>()
             let dic = HeaderDictionary()
@@ -273,7 +388,7 @@ let handlers =
             let! _ = withHxReselect "#test" next ctx
             Expect.isTrue (dic.ContainsKey "HX-Reselect") "The HX-Reselect header should be present"
             Expect.equal dic["HX-Reselect"].[0] "#test" "The HX-Reselect value was incorrect"
-        } 
+        }
         testTask "withHxReswap succeeds" {
             let ctx = Substitute.For<HttpContext>()
             let dic = HeaderDictionary()
@@ -281,7 +396,7 @@ let handlers =
             let! _ = withHxReswap HxSwap.BeforeEnd next ctx
             Expect.isTrue (dic.ContainsKey "HX-Reswap") "The HX-Reswap header should be present"
             Expect.equal dic["HX-Reswap"].[0] HxSwap.BeforeEnd "The HX-Reswap value was incorrect"
-        } 
+        }
         testTask "withHxRetarget succeeds" {
             let ctx = Substitute.For<HttpContext>()
             let dic = HeaderDictionary()
@@ -307,44 +422,6 @@ let handlers =
             Expect.equal
                 dic["HX-Trigger"].[0] """{ "blah": "foo", "bleh": "bar" }""" "The HX-Trigger value was incorrect"
         }
-        testTask "withHxTriggerAfterSettle succeeds" {
-            let ctx = Substitute.For<HttpContext>()
-            let dic = HeaderDictionary()
-            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
-            let! _ = withHxTriggerAfterSettle "byTheWay" next ctx
-            Expect.isTrue
-                (dic.ContainsKey "HX-Trigger-After-Settle") "The HX-Trigger-After-Settle header should be present"
-            Expect.equal dic["HX-Trigger-After-Settle"].[0] "byTheWay" "The HX-Trigger-After-Settle value was incorrect"
-        }
-        testTask "withHxTriggerManyAfterSettle succeeds" {
-            let ctx = Substitute.For<HttpContext>()
-            let dic = HeaderDictionary()
-            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
-            let! _ = withHxTriggerManyAfterSettle [ "oof", "ouch"; "hmm", "uh" ] next ctx
-            Expect.isTrue
-                (dic.ContainsKey "HX-Trigger-After-Settle") "The HX-Trigger-After-Settle header should be present"
-            Expect.equal
-                dic["HX-Trigger-After-Settle"].[0] """{ "oof": "ouch", "hmm": "uh" }"""
-                "The HX-Trigger-After-Settle value was incorrect"
-        }
-        testTask "withHxTriggerAfterSwap succeeds" {
-            let ctx = Substitute.For<HttpContext>()
-            let dic = HeaderDictionary()
-            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
-            let! _ = withHxTriggerAfterSwap "justASec" next ctx
-            Expect.isTrue (dic.ContainsKey "HX-Trigger-After-Swap") "The HX-Trigger-After-Swap header should be present"
-            Expect.equal dic["HX-Trigger-After-Swap"].[0] "justASec" "The HX-Trigger-After-Swap value was incorrect"
-        }
-        testTask "withHxTriggerManyAfterSwap succeeds" {
-            let ctx = Substitute.For<HttpContext>()
-            let dic = HeaderDictionary()
-            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
-            let! _ = withHxTriggerManyAfterSwap [ "this", "1"; "that", "2" ] next ctx
-            Expect.isTrue (dic.ContainsKey "HX-Trigger-After-Swap") "The HX-Trigger-After-Swap header should be present"
-            Expect.equal
-                dic["HX-Trigger-After-Swap"].[0] """{ "this": "1", "that": "2" }"""
-                "The HX-Trigger-After-Swap value was incorrect"
-        }
     ]
 
 /// Tests for the HtmxScript module
@@ -356,26 +433,17 @@ let script =
                 $"""<script src="/_content/Giraffe.Htmx.Common/htmx.min.js?ver={HtmxVersion}"></script>"""
                 "htmx script link is incorrect"
         }
+        test "localMax generates correct link" {
+            Expect.equal
+                (string HtmxScript.localMax)
+                $"""<script src="/_content/Giraffe.Htmx.Common/htmax.min.js?ver={HtmxVersion}"></script>"""
+                "htmx script link is incorrect"
+        }
     ]
 
 #nowarn 44 // Obsolete items still have tests
 let dictExtensionsObs =
     testList "IHeaderDictionaryExtensions (Obsolete)" [
-        testList "HxPrompt" [
-            test "succeeds when the header is not present" {
-                let ctx = Substitute.For<HttpContext>()
-                ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
-                Expect.isNone ctx.Request.Headers.HxPrompt "There should not have been a header returned"
-            }
-            test "succeeds when the header is present" {
-                let ctx = Substitute.For<HttpContext>()
-                let dic = HeaderDictionary()
-                dic.Add("HX-Prompt", "of course")
-                ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
-                Expect.isSome ctx.Request.Headers.HxPrompt "There should be a header present"
-                Expect.equal ctx.Request.Headers.HxPrompt.Value "of course" "The header value was incorrect"
-            }
-        ]
         testList "HxTrigger" [
             test "succeeds when the header is not present" {
                 let ctx = Substitute.For<HttpContext>()
@@ -408,5 +476,41 @@ let dictExtensionsObs =
         ]
     ]
 
+let handlerObs =
+    testList "Handler Tests (Obsolete)" [
+        testTask "withHxTriggerAfterSettle succeeds" {
+            let ctx = Substitute.For<HttpContext>()
+            let dic = HeaderDictionary()
+            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
+            let! _ = withHxTriggerAfterSettle "byTheWay" next ctx
+            Expect.isTrue (dic.ContainsKey "HX-Trigger") "The HX-Trigger header should be present"
+            Expect.equal dic["HX-Trigger"].[0] "byTheWay" "The HX-Trigger value was incorrect"
+        }
+        testTask "withHxTriggerManyAfterSettle succeeds" {
+            let ctx = Substitute.For<HttpContext>()
+            let dic = HeaderDictionary()
+            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
+            let! _ = withHxTriggerManyAfterSettle [ "oof", "ouch"; "hmm", "uh" ] next ctx
+            Expect.isTrue (dic.ContainsKey "HX-Trigger") "The HX-Trigger header should be present"
+            Expect.equal dic["HX-Trigger"].[0] """{ "oof": "ouch", "hmm": "uh" }""" "The HX-Trigger value was incorrect"
+        }
+        testTask "withHxTriggerAfterSwap succeeds" {
+            let ctx = Substitute.For<HttpContext>()
+            let dic = HeaderDictionary()
+            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
+            let! _ = withHxTriggerAfterSwap "justASec" next ctx
+            Expect.isTrue (dic.ContainsKey "HX-Trigger") "The HX-Trigger header should be present"
+            Expect.equal dic["HX-Trigger"].[0] "justASec" "The HX-Trigger value was incorrect"
+        }
+        testTask "withHxTriggerManyAfterSwap succeeds" {
+            let ctx = Substitute.For<HttpContext>()
+            let dic = HeaderDictionary()
+            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
+            let! _ = withHxTriggerManyAfterSwap [ "this", "1"; "that", "2" ] next ctx
+            Expect.isTrue (dic.ContainsKey "HX-Trigger") "The HX-Trigger header should be present"
+            Expect.equal dic["HX-Trigger"].[0] """{ "this": "1", "that": "2" }""" "The HX-Trigger value was incorrect"
+        }
+    ]
+
 /// All tests for this module
-let allTests = testList "Htmx" [ dictExtensions; reqExtensions; handlers; script; dictExtensionsObs ]
+let allTests = testList "Htmx" [ dictExtensions; reqExtensions; handlers; script; dictExtensionsObs; handlerObs ]

src/Tests/Program.fs

@@ -1,6 +1,6 @@
 open Expecto
 
-let allTests = testList "Giraffe" [ Common.allTests; Htmx.allTests; ViewEngine.allTests ]
+let allTests = testList "Giraffe" [ Common.allTests; Htmx.allTests; ViewEngine.allTests; ViewEngineMax.allTests ]
 
 [<EntryPoint>]
 let main args = runTestsWithCLIArgs [] args allTests

src/Tests/Tests.fsproj

@@ -8,6 +8,7 @@
     <Compile Include="Common.fs" />
     <Compile Include="Htmx.fs" />
     <Compile Include="ViewEngine.fs" />
+    <Compile Include="ViewEngineMax.fs" />
     <Compile Include="Program.fs" />
   </ItemGroup>
 
@@ -18,9 +19,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Expecto" Version="10.2.1" />
+    <PackageReference Include="Expecto" />
-    <PackageReference Include="NSubstitute" Version="5.1.0" />
+    <PackageReference Include="NSubstitute" />
-    <PackageReference Update="FSharp.Core" Version="8.0.300" />
+    <PackageReference Include="FSharp.Core" />
   </ItemGroup>
 
 </Project>

src/Tests/ViewEngine.fs

@@ -1,6 +1,7 @@
 module ViewEngine
 
 open Expecto
+open Giraffe.Htmx
 open Giraffe.ViewEngine
 open Giraffe.ViewEngine.Htmx
 
@@ -129,22 +130,12 @@ let hxEvent =
                 Expect.equal (AfterRequest.ToHxOnString()) "after:request" "AfterRequest hx-on event name not correct"
             }
         ]
-        testList "AfterSseMessage" [
+        testList "AfterSettle" [
             test "ToString succeeds" {
-                Expect.equal (string AfterSseMessage) "afterSseMessage" "AfterSseMessage event name not correct"
+                Expect.equal (string AfterSettle) "afterSettle" "AfterSettle event name not correct"
             }
             test "ToHxOnString succeeds" {
-                Expect.equal
+                Expect.equal (AfterSettle.ToHxOnString()) "after:settle" "AfterSettle hx-on event name not correct"
-                    (AfterSseMessage.ToHxOnString()) "after:sse:message" "AfterSseMessage hx-on event name not correct"
-            }
-        ]
-        testList "AfterSseStream" [
-            test "ToString succeeds" {
-                Expect.equal (string AfterSseStream) "afterSseStream" "AfterSseStream event name not correct"
-            }
-            test "ToHxOnString succeeds" {
-                Expect.equal
-                    (AfterSseStream.ToHxOnString()) "after:sse:stream" "AfterSseStream hx-on event name not correct"
             }
         ]
         testList "AfterSwap" [
@@ -184,6 +175,15 @@ let hxEvent =
                 Expect.equal (BeforeInit.ToHxOnString()) "before:init" "BeforeInit hx-on event name not correct"
             }
         ]
+        testList "BeforeProcess" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeProcess) "beforeProcess" "BeforeProcess event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeProcess.ToHxOnString()) "before:process" "BeforeProcess hx-on event name not correct"
+            }
+        ]
         testList "BeforeRestoreHistory" [
             test "ToString succeeds" {
                 Expect.equal
@@ -205,36 +205,13 @@ let hxEvent =
                     (BeforeRequest.ToHxOnString()) "before:request" "BeforeRequest hx-on event name not correct"
             }
         ]
-        testList "BeforeSseMessage" [
+        testList "BeforeResponse" [
             test "ToString succeeds" {
-                Expect.equal (string BeforeSseMessage) "beforeSseMessage" "BeforeSseMessage event name not correct"
+                Expect.equal (string BeforeResponse) "beforeResponse" "BeforeResponse event name not correct"
             }
             test "ToHxOnString succeeds" {
                 Expect.equal
-                    (BeforeSseMessage.ToHxOnString())
+                    (BeforeResponse.ToHxOnString()) "before:response" "BeforeResponse hx-on event name not correct"
-                    "before:sse:message"
-                    "BeforeSseMessage hx-on event name not correct"
-            }
-        ]
-        testList "BeforeSseReconnect" [
-            test "ToString succeeds" {
-                Expect.equal
-                    (string BeforeSseReconnect) "beforeSseReconnect" "BeforeSseReconnect event name not correct"
-            }
-            test "ToHxOnString succeeds" {
-                Expect.equal
-                    (BeforeSseReconnect.ToHxOnString())
-                    "before:sse:reconnect"
-                    "BeforeSseReconnect hx-on event name not correct"
-            }
-        ]
-        testList "BeforeSseStream" [
-            test "ToString succeeds" {
-                Expect.equal (string BeforeSseStream) "beforeSseStream" "BeforeSseStream event name not correct"
-            }
-            test "ToHxOnString succeeds" {
-                Expect.equal
-                    (BeforeSseStream.ToHxOnString()) "before:sse:stream" "BeforeSseStream hx-on event name not correct"
             }
         ]
         testList "BeforeSwap" [
@@ -279,6 +256,15 @@ let hxEvent =
                     (FinallyRequest.ToHxOnString()) "finally:request" "FinallyRequest hx-on event name not correct"
             }
         ]
+        testList "ResponseError" [
+            test "ToString succeeds" {
+                Expect.equal (string ResponseError) "responseError" "ResponseError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (ResponseError.ToHxOnString()) "response:error" "ResponseError hx-on event name not correct"
+            }
+        ]
     ]
 
 /// Tests for the HxHeaders module
@@ -409,7 +395,7 @@ let hxTrigger =
         testList "FromDocument" [
             test "succeeds when it is the first modifier" {
                 Expect.equal (HxTrigger.FromDocument "") "from:document" "FromDocument modifier incorrect"
-            } 
+            }
             test "succeeds when it is not the first modifier" {
                 Expect.equal (HxTrigger.FromDocument "click") "click from:document" "FromDocument modifier incorrect"
             }
@@ -514,7 +500,7 @@ let hxVals =
         ]
     ]
 
-/// Pipe-able assertion for a rendered node 
+/// Pipe-able assertion for a rendered node
 let shouldRender expected node =
     Expect.equal (RenderView.AsString.htmlNode node) expected "Rendered HTML incorrect"
 
@@ -572,7 +558,7 @@ let attributes =
         }
         test "_hxOnHxEvent succeeds" {
             strong [ _hxOnHxEvent BeforeSwap "changeStuff()" ] []
-            |> shouldRender """<strong hx-on::before:swap="changeStuff()"></strong>"""
+            |> shouldRender """<strong hx-on:htmx:before:swap="changeStuff()"></strong>"""
         }
         test "_hxPatch succeeds" {
             div [ _hxPatch "/arrrgh" ] [] |> shouldRender """<div hx-patch="/arrrgh"></div>"""
@@ -583,6 +569,10 @@ let attributes =
         test "_hxPreserve succeeds" {
             img [ _hxPreserve ] |> shouldRender """<img hx-preserve>"""
         }
+        test "_hxPrompt succeeds" {
+            strong [ _hxPrompt "Who goes there?" ] []
+            |> shouldRender """<strong hx-prompt="Who goes there?"></strong>"""
+        }
         test "_hxPushUrl succeeds" {
             dl [ _hxPushUrl "/a-b-c" ] [] |> shouldRender """<dl hx-push-url="/a-b-c"></dl>"""
         }
@@ -598,6 +588,18 @@ let attributes =
         test "_hxSelectOob succeeds" {
             section [ _hxSelectOob "#oob" ] [] |> shouldRender """<section hx-select-oob="#oob"></section>"""
         }
+        testList "_hxStatus" [
+            test "succeeds for a full code with no action" {
+                div [ _hxStatus "403" HxSwap.After "" ] [] |> shouldRender """<div hx-status:403="swap:after"></div>"""
+            }
+            test "succeeds for a two-digit range with action" {
+                span [ _hxStatus "41" HxSwap.Before "target:main" ] []
+                |> shouldRender """<span hx-status:41x="swap:before target:main"></span>"""
+            }
+            test "succeeds for a one-digit range with no action" {
+                p [ _hxStatus "5" HxSwap.None "" ] [] |> shouldRender """<p hx-status:5xx="swap:none"></p>"""
+            }
+        ]
         test "_hxSwap succeeds" {
             del [ _hxSwap "innerHTML" ] [] |> shouldRender """<del hx-swap="innerHTML"></del>"""
         }
@@ -625,12 +627,6 @@ let attributes =
             dt [ _hxVals """{ "extra": "values" }""" ] []
             |> shouldRender """<dt hx-vals="{ &quot;extra&quot;: &quot;values&quot; }"></dt>"""
         }
-        test "_sseConnect succeeds" {
-            div [ _sseConnect "/gps/sse" ] [] |> shouldRender """<div sse-connect="/gps/sse"></div>"""
-        }
-        test "_sseSwap succeeds" {
-            ul [ _sseSwap "sseMessageName" ] [] |> shouldRender """<ul sse-swap="sseMessageName"></ul>"""
-        }
     ]
 
 /// Tests for the HxModifiers module
@@ -671,8 +667,6 @@ let hxTags =
         }
     ]
 
-open Giraffe.Htmx.Common
-
 /// Tests for the Script module
 let script =
     testList "Script" [
@@ -687,16 +681,39 @@ let script =
             let html = RenderView.AsString.htmlNode Script.cdnMinified
             Expect.equal
                 html
-                $"""<script src="https://cdn.jsdelivr.net/npm/htmx.org@{HtmxVersion}/dist/htmx.min.js" integrity="sha384-/5n21KGM472oBhvzUrvju8FRDq/4WNMS3TGw5RWFkZR/kq+sCevqNXFcakqRtaHu" crossorigin="anonymous"></script>"""
+                $"""<script src="https://cdn.jsdelivr.net/npm/htmx.org@{HtmxVersion}/dist/htmx.min.js" integrity="sha384-5dnhUXCt1hXGvYrjAnKwgNX3I8xtIJiW6eIHIbeo7oWyXv2XpWYC/rl+ZiWfuYO5" crossorigin="anonymous"></script>"""
                 "CDN minified script tag is incorrect"
         }
         test "cdnUnminified succeeds" {
             let html = RenderView.AsString.htmlNode Script.cdnUnminified
             Expect.equal
                 html
-                $"""<script src="https://cdn.jsdelivr.net/npm/htmx.org@{HtmxVersion}/dist/htmx.js" integrity="sha384-I3uRy2RjSNcS8Oi2SNWZD9IrafyrrrBb4QaHNA9pWVWfJuKtL0p8qAwHSrEyXoKh" crossorigin="anonymous"></script>"""
+                $"""<script src="https://cdn.jsdelivr.net/npm/htmx.org@{HtmxVersion}/dist/htmx.js" integrity="sha384-RZoQSZlu2BAuZMuM5lTKAWXXSKC+7X6eVzP1pwkUBcyfPmOswexqVOsUqQMKbAFA" crossorigin="anonymous"></script>"""
                 "CDN unminified script tag is incorrect"
         }
+        testList "Max" [
+            test "localMax succeeds" {
+                let html = RenderView.AsString.htmlNode Script.Max.local
+                Expect.equal
+                    html
+                    $"""<script src="/_content/Giraffe.Htmx.Common/htmax.min.js?ver={HtmxVersion}"></script>"""
+                    "Local script tag is incorrect"
+            }
+            test "cdnMaxMinified succeeds" {
+                let html = RenderView.AsString.htmlNode Script.Max.cdnMinified
+                Expect.equal
+                    html
+                    $"""<script src="https://cdn.jsdelivr.net/npm/htmx.org@{HtmxVersion}/dist/htmax.min.js" integrity="sha384-VVbrNR6a+H8puV17ZlJ8aUUMTgbcDiqM1vlLYEmaaU4oFANllvTK2pLynNonElP+" crossorigin="anonymous"></script>"""
+                    "CDN minified script tag is incorrect"
+            }
+            test "cdnMaxUnminified succeeds" {
+                let html = RenderView.AsString.htmlNode Script.Max.cdnUnminified
+                Expect.equal
+                    html
+                    $"""<script src="https://cdn.jsdelivr.net/npm/htmx.org@{HtmxVersion}/dist/htmax.js" integrity="sha384-kjhVuvnX3/TsR1qH4JaIcHR6muh/WLMU5CTQRacCQZERzQlP4/r9p/TK7ucFwqvV" crossorigin="anonymous"></script>"""
+                    "CDN unminified script tag is incorrect"
+            }
+        ]
     ]
 
 open System.Text
@@ -704,11 +721,11 @@ open System.Text
 /// Tests for the RenderFragment module
 let renderFragment =
     testList "RenderFragment" [
-        
+
         /// Validate that the two object references are the same object
         let isSame obj1 obj2 message =
             Expect.isTrue (obj.ReferenceEquals(obj1, obj2)) message
-        
+
         testList "findIdNode" [
             test "fails with a Text node" {
                 Expect.isNone (RenderFragment.findIdNode "blue" (Text "")) "There should not have been a node found"
@@ -774,7 +791,7 @@ let renderFragment =
             ]
         ]
         testList "AsBytes" [
-            
+
             /// Alias for UTF-8 encoding
             let utf8 = Encoding.UTF8
 
@@ -864,15 +881,25 @@ let hxEventObs =
             }
             test "ToHxOnString succeeds" {
                 Expect.equal
-                    (AfterProcessNode.ToHxOnString()) "after:init" "AfterProcessNode hx-on event name not correct"
+                    (AfterProcessNode.ToHxOnString()) "after:process" "AfterProcessNode hx-on event name not correct"
             }
         ]
-        testList "AfterSettle" [
+        testList "AfterSseMessage" [
             test "ToString succeeds" {
-                Expect.equal (string AfterSettle) "afterSettle" "AfterSettle event name not correct"
+                Expect.equal (string AfterSseMessage) "afterSseMessage" "AfterSseMessage event name not correct"
             }
             test "ToHxOnString succeeds" {
-                Expect.equal (AfterSettle.ToHxOnString()) "after:swap" "AfterSettle hx-on event name not correct"
+                Expect.equal
+                    (AfterSseMessage.ToHxOnString()) "after:sse:message" "AfterSseMessage hx-on event name not correct"
+            }
+        ]
+        testList "AfterSseStream" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterSseStream) "afterSseStream" "AfterSseStream event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (AfterSseStream.ToHxOnString()) "after:sse:stream" "AfterSseStream hx-on event name not correct"
             }
         ]
         testList "BeforeCleanupElement" [
@@ -912,7 +939,7 @@ let hxEventObs =
             }
             test "ToHxOnString succeeds" {
                 Expect.equal
-                    (BeforeProcessNode.ToHxOnString()) "before:init" "BeforeProcessNode hx-on event name not correct"
+                    (BeforeProcessNode.ToHxOnString()) "before:process" "BeforeProcessNode hx-on event name not correct"
             }
         ]
         testList "BeforeSend" [
@@ -923,6 +950,38 @@ let hxEventObs =
                 Expect.equal (BeforeSend.ToHxOnString()) "before:request" "BeforeSend hx-on event name not correct"
             }
         ]
+        testList "BeforeSseMessage" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeSseMessage) "beforeSseMessage" "BeforeSseMessage event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeSseMessage.ToHxOnString())
+                    "before:sse:message"
+                    "BeforeSseMessage hx-on event name not correct"
+            }
+        ]
+        testList "BeforeSseReconnect" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string BeforeSseReconnect) "beforeSseReconnect" "BeforeSseReconnect event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeSseReconnect.ToHxOnString())
+                    "before:sse:reconnect"
+                    "BeforeSseReconnect hx-on event name not correct"
+            }
+        ]
+        testList "BeforeSseStream" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeSseStream) "beforeSseStream" "BeforeSseStream event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeSseStream.ToHxOnString()) "before:sse:stream" "BeforeSseStream hx-on event name not correct"
+            }
+        ]
         testList "HistoryCacheError" [
             test "ToString succeeds" {
                 Expect.equal (string HistoryCacheError) "historyCacheError" "HistoryCacheError event name not correct"
@@ -1049,14 +1108,6 @@ let hxEventObs =
                     "PushedIntoHistory hx-on event name not correct"
             }
         ]
-        testList "ResponseError" [
-            test "ToString succeeds" {
-                Expect.equal (string ResponseError) "responseError" "ResponseError event name not correct"
-            }
-            test "ToHxOnString succeeds" {
-                Expect.equal (ResponseError.ToHxOnString()) "error" "ResponseError hx-on event name not correct"
-            }
-        ]
         testList "SendError" [
             test "ToString succeeds" {
                 Expect.equal (string SendError) "sendError" "SendError event name not correct"
@@ -1070,7 +1121,7 @@ let hxEventObs =
                 Expect.equal (string SseError) "sseError" "SseError event name not correct"
             }
             test "ToHxOnString succeeds" {
-                Expect.equal (SseError.ToHxOnString()) "error" "SseError hx-on event name not correct"
+                Expect.equal (SseError.ToHxOnString()) "sse:error" "SseError hx-on event name not correct"
             }
         ]
         testList "SseOpen" [
@@ -1078,7 +1129,7 @@ let hxEventObs =
                 Expect.equal (string SseOpen) "sseOpen" "SseOpen event name not correct"
             }
             test "ToHxOnString succeeds" {
-                Expect.equal (SseOpen.ToHxOnString()) "sse-open" "SseOpen hx-on event name not correct"
+                Expect.equal (SseOpen.ToHxOnString()) "after:sse:connection" "SseOpen hx-on event name not correct"
             }
         ]
         testList "SwapError" [
@@ -1144,7 +1195,7 @@ let hxEventObs =
                 Expect.equal (string XhrAbort) "xhr:abort" "XhrAbort event name not correct"
             }
             test "ToHxOnString succeeds" {
-                Expect.equal (XhrAbort.ToHxOnString()) "xhr:abort" "XhrAbort hx-on event name not correct"
+                Expect.equal (XhrAbort.ToHxOnString()) "error" "XhrAbort hx-on event name not correct"
             }
         ]
         testList "XhrLoadEnd" [
@@ -1152,7 +1203,7 @@ let hxEventObs =
                 Expect.equal (string XhrLoadEnd) "xhr:loadend" "XhrLoadEnd event name not correct"
             }
             test "ToHxOnString succeeds" {
-                Expect.equal (XhrLoadEnd.ToHxOnString()) "xhr:loadend" "XhrLoadEnd hx-on event name not correct"
+                Expect.equal (XhrLoadEnd.ToHxOnString()) "finally:request" "XhrLoadEnd hx-on event name not correct"
             }
         ]
         testList "XhrLoadStart" [
@@ -1267,13 +1318,15 @@ let attributesObs =
         test "_hxParams succeeds" {
             br [ _hxParams "[p1,p2]" ] |> shouldRender """<br hx-params="[p1,p2]">"""
         }
-        test "_hxPrompt succeeds" {
-            strong [ _hxPrompt "Who goes there?" ] []
-            |> shouldRender """<strong hx-prompt="Who goes there?"></strong>"""
-        }
         test "_hxRequest succeeds" {
             u [ _hxRequest "noHeaders" ] [] |> shouldRender """<u hx-request="noHeaders"></u>"""
         }
+        test "_sseConnect succeeds" {
+            div [ _sseConnect "/gps/sse" ] [] |> shouldRender """<div sse-connect="/gps/sse"></div>"""
+        }
+        test "_sseSwap succeeds" {
+            ul [ _sseSwap "sseMessageName" ] [] |> shouldRender """<ul sse-swap="sseMessageName"></ul>"""
+        }
     ]
 
 let obsolete = testList "Obsolete" [ hxEventObs; hxParamsObs; hxRequestObs; attributesObs ]

src/Tests/ViewEngineMax.fs

@@ -0,0 +1,335 @@
+module ViewEngineMax
+
+open Expecto
+open Giraffe.ViewEngine.Htmax
+
+/// Tests for the HxBrowserIndicatorConfigItem type
+let hxBrowserIndicatorConfigItem =
+    testList "HxBrowserIndicatorConfigItem" [
+        testList "ToHcon" [
+            test "succeeds for BoostBrowserIndicator" {
+                Expect.equal
+                    ((BoostBrowserIndicator false).ToHcon())
+                    "boostBrowserIndicator:false"
+                    "The HCON value was incorrect"
+            }
+        ]
+    ]
+
+/// Tests for the HxPreloadConfigItem type
+let hxPreloadConfigItem =
+    testList "HxPreloadConfigItem" [
+        testList "ToHcon" [
+            test "succeeds for AutoBoost" {
+                Expect.equal ((AutoBoost false).ToHcon()) "autoBoost:false" "The HCON value was incorrect"
+            }
+            test "succeeds for BoostEvent" {
+                Expect.equal ((BoostEvent "mouseover").ToHcon()) "boostEvent:mouseover" "The HCON value was incorrect"
+            }
+            test "succeeds for BoostTimeout" {
+                Expect.equal ((BoostTimeout 30_000).ToHcon()) "boostTimeout:30000" "The HCON value was incorrect"
+            }
+        ]
+    ]
+
+/// Tests for the HxSseWsConfigItem type
+let hxSseWsConfigItem =
+    testList "HxSseWsConfigItem" [
+        testList "ToHcon" [
+            test "succeeds for Reconnect" {
+                Expect.equal ((Reconnect true).ToHcon()) "reconnect:true" "The HCON value was incorrect"
+            }
+            testList "ReconnectDelay" [
+                test "succeeds for numeric value" {
+                    Expect.equal ((ReconnectDelay "3000").ToHcon()) "reconnectDelay:3000" "The HCON value was incorrect"
+                }
+                test "succeeds for value with units" {
+                    Expect.equal ((ReconnectDelay "3s").ToHcon()) "reconnectDelay:3s" "The HCON value was incorrect"
+                }
+            ]
+            testList "ReconnectMaxDelay" [
+                test "succeeds for numeric value" {
+                    Expect.equal
+                        ((ReconnectMaxDelay "30000").ToHcon()) "reconnectMaxDelay:30000" "The HCON value was incorrect"
+                }
+                test "succeeds for value with units" {
+                    Expect.equal
+                        ((ReconnectMaxDelay "50s").ToHcon()) "reconnectMaxDelay:50s" "The HCON value was incorrect"
+                }
+            ]
+            testList "ReconnectMaxAttempts" [
+                test "succeeds for negative 1" {
+                    Expect.equal
+                        ((ReconnectMaxAttempts -1).ToHcon())
+                        "reconnectMaxAttempts:Infinity"
+                        "The HCON value was incorrect"
+                }
+                test "succeeds for zero" {
+                    Expect.equal
+                        ((ReconnectMaxAttempts 0).ToHcon()) "reconnectMaxAttempts:0" "The HCON value was incorrect"
+                }
+                test "succeeds for positive number" {
+                    Expect.equal
+                        ((ReconnectMaxAttempts 7).ToHcon()) "reconnectMaxAttempts:7" "The HCON value was incorrect"
+                }
+            ]
+            test "succeeds for ReconnectJitter" {
+                Expect.equal ((ReconnectJitter 0.7).ToHcon()) "reconnectJitter:0.7" "The HCON value was incorrect"
+            }
+            test "succeeds for PauseOnBackground" {
+                Expect.equal
+                    ((PauseOnBackground false).ToHcon()) "pauseOnBackground:false" "The HCON value was incorrect"
+            }
+            test "succeeds for PendingRequestTtl" {
+                Expect.equal ((PendingRequestTtl 5000).ToHcon()) "pendingRequestTTL:5000" "The HCON value was incorrect"
+            }
+        ]
+    ]
+
+/// Tests for the HxConfig module
+let hxConfig =
+    testList "HxConfig" [
+        test "hxBrowserIndicatorConfig succeeds" {
+            Expect.equal
+                (hxBrowserIndicatorConfig [ BoostBrowserIndicator true ])
+                "browser-indicator.boostBrowserIndicator:true"
+                "Config settings not correct"
+        }
+        test "hxPreloadConfig succeeds" {
+            Expect.equal
+                (hxPreloadConfig [ AutoBoost true; BoostTimeout 3_000 ])
+                "preload.autoBoost:true preload.boostTimeout:3000"
+                "Config settings not correct"
+        }
+        test "hxSseConfig succeeds" {
+            Expect.equal
+                (hxSseConfig [ ReconnectDelay "5s"; PauseOnBackground false ])
+                "sse.reconnectDelay:5s sse.pauseOnBackground:false"
+                "Config settings not correct"
+        }
+        test "hxWsConfig succeeds" {
+            Expect.equal
+                (hxWsConfig [ Reconnect false; PendingRequestTtl 40_000 ])
+                "ws.reconnect:false ws.pendingRequestTTL:40000"
+                "Config settings not correct"
+        }
+    ]
+    
+/// Tests for the HxEvent module
+let hxEvent =
+    testList "HxEvent" [
+        testList "AfterSseConnection" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string AfterSseConnection) "afterSseConnection" "AfterSseConnection event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (AfterSseConnection.ToHxOnString())
+                    "after:sse:connection"
+                    "AfterSseConnection hx-on event name not correct"
+            }
+        ]
+        testList "AfterSseMessage" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterSseMessage) "afterSseMessage" "AfterSseMessage event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (AfterSseMessage.ToHxOnString()) "after:sse:message" "AfterSseMessage hx-on event name not correct"
+            }
+        ]
+        testList "AfterWsConnection" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string AfterWsConnection) "afterWsConnection" "AfterWsConnection event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (AfterWsConnection.ToHxOnString())
+                    "after:ws:connection"
+                    "AfterWsConnection hx-on event name not correct"
+            }
+        ]
+        testList "AfterWsMessage" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterWsMessage) "afterWsMessage" "AfterWsMessage event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (AfterWsMessage.ToHxOnString()) "after:ws:message" "AfterWsMessage hx-on event name not correct"
+            }
+        ]
+        testList "AfterWsRequest" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterWsRequest) "afterWsRequest" "AfterWsRequest event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (AfterWsRequest.ToHxOnString()) "after:ws:request" "AfterWsRequest hx-on event name not correct"
+            }
+        ]
+        testList "BeforeSseConnection" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string BeforeSseConnection) "beforeSseConnection" "BeforeSseConnection event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeSseConnection.ToHxOnString())
+                    "before:sse:connection"
+                    "BeforeSseConnection hx-on event name not correct"
+            }
+        ]
+        testList "BeforeSseMessage" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeSseMessage) "beforeSseMessage" "BeforeSseMessage event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeSseMessage.ToHxOnString())
+                    "before:sse:message"
+                    "BeforeSseMessage hx-on event name not correct"
+            }
+        ]
+        testList "BeforeWsConnection" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string BeforeWsConnection) "beforeWsConnection" "BeforeWsConnection event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeWsConnection.ToHxOnString())
+                    "before:ws:connection"
+                    "BeforeWsConnection hx-on event name not correct"
+            }
+        ]
+        testList "BeforeWsMessage" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeWsMessage) "beforeWsMessage" "BeforeWsMessage event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeWsMessage.ToHxOnString()) "before:ws:message" "BeforeWsMessage hx-on event name not correct"
+            }
+        ]
+        testList "BeforeWsRequest" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeWsRequest) "beforeWsRequest" "BeforeWsRequest event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeWsRequest.ToHxOnString()) "before:ws:request" "BeforeWsRequest hx-on event name not correct"
+            }
+        ]
+        testList "DownloadComplete" [
+            test "ToString succeeds" {
+                Expect.equal (string DownloadComplete) "downloadComplete" "DownloadComplete event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (DownloadComplete.ToHxOnString())
+                    "download:complete"
+                    "DownloadComplete hx-on event name not correct"
+            }
+        ]
+        testList "DownloadProgress" [
+            test "ToString succeeds" {
+                Expect.equal (string DownloadProgress) "downloadProgress" "DownloadProgress event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (DownloadProgress.ToHxOnString())
+                    "download:progress"
+                    "DownloadProgress hx-on event name not correct"
+            }
+        ]
+        testList "DownloadStart" [
+            test "ToString succeeds" {
+                Expect.equal (string DownloadStart) "downloadStart" "DownloadStart event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (DownloadStart.ToHxOnString()) "download:start" "DownloadStart hx-on event name not correct"
+            }
+        ]
+        testList "SseClose" [
+            test "ToString succeeds" {
+                Expect.equal (string SseClose) "sseClose" "SseClose event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (SseClose.ToHxOnString()) "sse:close" "SseClose hx-on event name not correct"
+            }
+        ]
+        testList "SseError" [
+            test "ToString succeeds" {
+                Expect.equal (string SseError) "sseError" "SseError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (SseError.ToHxOnString()) "sse:error" "SseError hx-on event name not correct"
+            }
+        ]
+    ]
+
+open Giraffe.ViewEngine
+
+/// Pipe-able assertion for a rendered node 
+let shouldRender expected node =
+    Expect.equal (RenderView.AsString.htmlNode node) expected "Rendered HTML incorrect"
+
+/// Tests for the HtmaxAttrs module
+let attributes =
+    testList "Attributes" [
+
+        test "_hxBrowserIndicator succeeds" {
+            a [ _hxBrowserIndicator ] [] |> shouldRender """<a hx-browser-indicator="true"></a>"""
+        }
+        test "_hxLive succeeds" {
+            main [ _hxLive "q().doStuff()" ] [] |> shouldRender """<main hx-live="q().doStuff()"></main>"""
+        }
+        test "_hxOnMax succeeds" {
+            body [ _hxOnMax SseClose "alert(done)" ] []
+            |> shouldRender """<body hx-on:htmx:sse:close="alert(done)"></body>"""
+        }
+        testList "_hxPreload" [
+            test "succeeds when given an event" {
+                blockquote [ _hxPreload (Some "focus") ] []
+                |> shouldRender """<blockquote hx-preload="focus"></blockquote>"""
+            }
+            test "succeeds when not given an event" {
+                em [ _hxPreload None ] [] |> shouldRender """<em hx-preload></em>"""
+            }
+        ]
+        test "_hxSseClose succeeds" {
+            form [ _hxSseClose "fin" ] [] |> shouldRender """<form hx-sse:close="fin"></form>"""
+        }
+        test "_hxSseConnect succeeds" {
+            div [ _hxSseConnect "/path/to/resource" ] []
+            |> shouldRender """<div hx-sse:connect="/path/to/resource"></div>"""
+        }
+        test "_hxTargets succeeds" {
+            dl [ _hxTargets ".ephemeral" ] [] |> shouldRender """<dl hx-targets=".ephemeral"></dl>"""
+        }
+        test "_hxWsConnect succeeds" {
+            p [ _hxWsConnect "/over/here" ] [] |> shouldRender """<p hx-ws:connect="/over/here"></p>"""
+        }
+        testList "_hxWsSend" [
+            test "succeeds when given a URL" {
+                span [ _hxWsSend (Some "/a/new/place") ] []
+                |> shouldRender """<span hx-ws:send="/a/new/place"></span>"""
+            }
+            test "succeeds when not given a URL" {
+                aside [ _hxWsSend None ] [] |> shouldRender """<aside hx-ws:send></aside>"""
+            }
+        ]
+    ]
+
+let allTests =
+    testList "ViewEngine.Htmax" [
+        hxBrowserIndicatorConfigItem
+        hxPreloadConfigItem
+        hxSseWsConfigItem
+        hxConfig
+        hxEvent
+        attributes
+    ]

src/ViewEngine.Htmx/Giraffe.ViewEngine.Htmx.fsproj

@@ -9,13 +9,14 @@
 
   <ItemGroup>
     <Compile Include="Htmx.fs" />
+    <Compile Include="Htmax.fs" />
     <None Include="README.md" Pack="true" PackagePath="\" />
     <None Include="..\icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Giraffe.ViewEngine" Version="1.4.0" />
+    <PackageReference Include="Giraffe.ViewEngine" />
-    <PackageReference Update="FSharp.Core" Version="6.0.0" />
+    <PackageReference Include="FSharp.Core" />
   </ItemGroup>
 
   <ItemGroup>

src/ViewEngine.Htmx/Htmax.fs

@@ -0,0 +1,243 @@
+/// <summary>Types and functions supporting htmax-bundled extension attributes in Giraffe View Engine</summary>
+module Giraffe.ViewEngine.Htmax
+
+/// <summary>Items which can be configured for the <c>hx-browser-indicator</c> extension</summary>
+/// <seealso href="https://four.htmx.org/extensions/hx-browser-indicator#boosted-elements">Documentation</seealso>
+type HxBrowserIndicatorConfigItem =
+    /// <summary>Whether to show the browser's native loading indicator for <c>hx-boost</c>ed links</summary>
+    | BoostBrowserIndicator of bool
+    
+    /// <summary>Get the HCON representation of this configuration value</summary>
+    member this.ToHcon() =
+        match this with
+        | BoostBrowserIndicator it -> "boostBrowserIndicator:" + (string it).ToLowerInvariant()
+
+        
+/// <summary>Items which can be configured for the <c>hx-preload</c> extension</summary>
+/// <seealso href="https://four.htmx.org/extensions/hx-preload#configuration">Documentation</seealso>
+type HxPreloadConfigItem =
+    /// <summary>Whether items subject to <c>hx-boost</c> are automatically preloaded (default <c>true</c>)</summary>
+    | AutoBoost of bool
+    
+    /// <summary>The event to use for <c>hx-boost</c> auto-preloaded content (default "mousedown")</summary>
+    | BoostEvent of string
+    
+    /// <summary>The timeout (in ms) for <c>hx-boost</c> auto-preloaded requests (default 50_000)</summary>
+    | BoostTimeout of int
+    
+    /// <summary>Get the HCON representation of this configuration value</summary>
+    member this.ToHcon() =
+        match this with
+        | AutoBoost it -> "autoBoost:" + (string it).ToLowerInvariant()
+        | BoostEvent it -> $"boostEvent:{it}"
+        | BoostTimeout it -> $"boostTimeout:{it}"
+
+
+/// <summary>Items which can be configured for the <c>hx-sse</c> or <c>hx-ws</c> extensions</summary>
+/// <seealso href="https://four.htmx.org/extensions/hx-sse#configuration">SSE Documentation</seealso>
+/// <seealso href="https://four.htmx.org/extensions/hx-ws#configuration">WebSockets Documentation</seealso>
+type HxSseWsConfigItem =
+    /// <summary>Whether to automatically reconnect on stream end (default <c>true</c>)</summary>
+    | Reconnect of bool
+    
+    /// <summary>Delay for reconnect attempts (ms, or numbers with units "1s", "2m"; default "500")</summary>
+    | ReconnectDelay of string
+    
+    /// <summary>Maximum delay for reconnect attempts (ms, or numbers with units "1s, "2m"; default "60000")</summary>
+    | ReconnectMaxDelay of string
+    
+    /// <summary>Reconnect maximum attempts (use -1 for Infinity; default Infinity)</summary>
+    | ReconnectMaxAttempts of int
+    
+    /// <summary>Jitter to use when reconnecting (decimal between 0.0 and 1.0; default 0.3)</summary>
+    | ReconnectJitter of double
+    
+    /// <summary>Whether to pause when the current tab is in the background (default <c>true</c>)</summary>
+    | PauseOnBackground of bool
+    
+    /// <summary>Time-to-Live (TTL) for pending requests (<c>hx-ws</c> only)</summary>
+    | PendingRequestTtl of int
+
+    /// <summary>Get the HCON representation of this configuration value</summary>
+    member this.ToHcon() =
+        match this with
+        | Reconnect it -> "reconnect:" + (string it).ToLowerInvariant()
+        | ReconnectDelay it -> $"reconnectDelay:{it}"
+        | ReconnectMaxDelay it -> $"reconnectMaxDelay:{it}"
+        | ReconnectMaxAttempts it -> "reconnectMaxAttempts:" + if it = -1 then "Infinity" else string it
+        | ReconnectJitter it -> $"reconnectJitter:{it}"
+        | PauseOnBackground it -> "pauseOnBackground:" + (string it).ToLowerInvariant()
+        | PendingRequestTtl it -> $"pendingRequestTTL:{it}"
+
+
+/// <summary>Helpers for generating extension configuration parameters</summary>
+[<AutoOpen>]
+module HxConfig =
+    
+    /// Create an HCON section suitable for hx-config
+    let private hconSettings title values =
+        values |> Seq.map (sprintf "%s.%s" title) |> String.concat " "
+
+    /// <summary>Generate configuration items for preload suitable for <c>hx-config</c></summary>
+    /// <param name="items">The configuration items</param>
+    let hxBrowserIndicatorConfig (items: HxBrowserIndicatorConfigItem seq) =
+        items |> Seq.map _.ToHcon() |> hconSettings "browser-indicator"
+    
+    /// <summary>Generate configuration items for preload suitable for <c>hx-config</c></summary>
+    /// <param name="items">The configuration items</param>
+    let hxPreloadConfig (items: HxPreloadConfigItem seq) =
+        items |> Seq.map _.ToHcon() |> hconSettings "preload"
+    
+    /// <summary>Generate configuration items for SSE suitable for <c>hx-config</c></summary>
+    /// <param name="items">The configuration items</param>
+    let hxSseConfig (items: HxSseWsConfigItem seq) =
+        items |> Seq.map _.ToHcon() |> hconSettings "sse"
+
+    /// <summary>Generate configuration items for WebSockets suitable for <c>hx-config</c></summary>
+    /// <param name="items">The configuration items</param>
+    let hxWsConfig (items: HxSseWsConfigItem seq) =
+        items |> Seq.map _.ToHcon() |> hconSettings "ws"
+
+    
+/// <summary>The events recognized by htmax-bundled extensions</summary>
+[<Struct>]
+type HxEvent =
+    
+    /// <summary>Fired after an SSE connection is established</summary>
+    | AfterSseConnection
+    
+    /// <summary>Fired after an SSE message is received</summary>
+    | AfterSseMessage
+    
+    /// <summary>Fired after a WebSocket connection is established</summary>
+    | AfterWsConnection
+    
+    /// <summary>Fired after a WebSocket message is received</summary>
+    | AfterWsMessage
+    
+    /// <summary>Fired after a WebSocket request is sent</summary>
+    | AfterWsRequest
+    
+    /// <summary>Fired before an SSE connection is established (cancelable)</summary>
+    | BeforeSseConnection
+    
+    /// <summary>Fired before a received SSE message is processed (cancelable)</summary>
+    | BeforeSseMessage
+    
+    /// <summary>Fired before a WebSocket connection is established (cancelable)</summary>
+    | BeforeWsConnection
+    
+    /// <summary>Fired when a download handled by <c>hx-download</c> is complete</summary>
+    | DownloadComplete
+    
+    /// <summary>Fired when a download handled by <c>hx-download</c> is complete</summary>
+    | DownloadProgress
+    
+    /// <summary>Fired when a chunk is received for a download handled by <c>hx-download</c></summary>
+    | DownloadStart
+    
+    /// <summary>Fired before a received WebSocket message is processed (cancelable)</summary>
+    | BeforeWsMessage
+    
+    /// <summary>Fired before a WebSocket request is sent (cancelable)</summary>
+    | BeforeWsRequest
+    
+    /// <summary>Fired when an SSE connection is closed</summary>
+    | SseClose
+    
+    /// <summary>Fired when an SSE connection errors</summary>
+    | SseError
+
+    /// The htmx event name (fst) and kebab-case name (snd, for use with hx-on)
+    static member private Values = Map [
+        AfterSseConnection, ("afterSseConnection", "after:sse:connection")
+        AfterSseMessage, ("afterSseMessage", "after:sse:message")
+        AfterWsConnection, ("afterWsConnection", "after:ws:connection")
+        AfterWsMessage, ("afterWsMessage", "after:ws:message")
+        AfterWsRequest, ("afterWsRequest", "after:ws:request")
+        BeforeSseConnection, ("beforeSseConnection", "before:sse:connection")
+        BeforeSseMessage, ("beforeSseMessage", "before:sse:message")
+        BeforeWsConnection, ("beforeWsConnection", "before:ws:connection")
+        BeforeWsMessage, ("beforeWsMessage", "before:ws:message")
+        BeforeWsRequest, ("beforeWsRequest", "before:ws:request")
+        DownloadComplete, ("downloadComplete", "download:complete")
+        DownloadProgress, ("downloadProgress", "download:progress")
+        DownloadStart, ("downloadStart", "download:start")
+        SseClose, ("sseClose", "sse:close")
+        SseError, ("sseError", "sse:error")
+    ]
+
+    /// <summary>The htmx event name</summary> 
+    override this.ToString() = fst HxEvent.Values[this]
+    
+    /// <summary>The <c>hx-on</c> variant of the htmx event name</summary>
+    member this.ToHxOnString() = snd HxEvent.Values[this]
+
+
+/// <summary>Attributes and flags for htmax-bundled extensions</summary>
+[<AutoOpen>]
+module HtmaxAttrs =
+    
+    /// <summary>Display the browser's native loading indicator when an htmx request is in flight</summary>
+    /// <returns>A configured <c>hx-browser-indicator</c> attribute</returns>
+    /// <seealso href="https://four.htmx.org/extensions/hx-browser-indicator#usage">Documentation</seealso>
+    let _hxBrowserIndicator =
+        attr "hx-browser-indicator" "true"
+
+    /// <summary>Run script each time the DOM changes</summary>
+    /// <param name="script">The script to be run each time the DOM changes (may use <c>q</c> helper)</param>
+    /// <returns>A configured <c>hx-live</c> attribute</returns>
+    /// <seealso href="https://four.htmx.org/extensions/hx-live#the-hx-live-attribute">Documentation</seealso>
+    let _hxLive script =
+        attr "hx-live" script
+    
+    /// <summary>Generate an <c>hx-on:htmx</c> event for an htmax-bundled extension event</summary>
+    /// <param name="event">The <c>HxEvent</c> to be handled</param>
+    /// <param name="handler">The script to be executed when the event occurs</param>
+    /// <returns>A configured <c>hx-on:htmx:</c> attribute</returns>
+    /// <seealso href="https://htmx.org/attributes/hx-on/">Documentation</seealso>
+    let _hxOnMax (event: HxEvent) handler =
+        Htmx.HtmxAttrs._hxOnEvent $"htmx:{event.ToHxOnString()}" handler
+    
+    /// <summary>Identify a resource as one that should be preloaded</summary>
+    /// <param name="evt">The DOM event or htmx trigger which should cause the preload (optional; default behavior is
+    /// preloading on <c>mousedown</c>)</param>
+    /// <returns>A configured <c>hx-preload</c> attribute</returns>
+    /// <seealso href="https://four.htmx.org/extensions/hx-preload#usage">Documentation</seealso>
+    let _hxPreload evt =
+        match evt with Some it -> attr "hx-preload" it | None -> flag "hx-preload"
+    
+    /// <summary>Define an SSE message which indicates the connection should be closed</summary>
+    /// <param name="message">The text of the message which indicates the SSE connection should be closed</param>
+    /// <returns>A configured <c>hx-sse:close</c> attribute</returns>
+    /// <seealso href="https://four.htmx.org/extensions/hx-sse#hx-sseclose">Documentation</seealso>
+    let _hxSseClose message =
+        attr "hx-sse:close" message
+        
+    /// <summary>Define a URL to which an SSE connection should be established</summary>
+    /// <param name="url">The URL to which an SSE connection should be established</param>
+    /// <returns>A configured <c>hx-sse:connect</c> attribute</returns>
+    /// <seealso href="https://four.htmx.org/extensions/hx-sse#hx-sseconnect">Documentation</seealso>
+    let _hxSseConnect url =
+        attr "hx-sse:connect" url
+    
+    /// <summary>Replace multiple targets with the same content</summary>
+    /// <param name="selector">The CSS selector to identify targets for the replacement</param>
+    /// <returns>A configured <c>hx-targets</c> attribute</returns>
+    /// <seealso href="https://four.htmx.org/extensions/hx-targets#usage">Documentation</seealso>
+    let _hxTargets selector =
+        attr "hx-targets" selector
+    
+    /// <summary>Connect to a WebSocket URL</summary>
+    /// <param name="url">The URL to which a WebSocket connection should be established</param>
+    /// <returns>A configured <c>hx-ws:connect</c> attribute</returns>
+    /// <seealso href="https://four.htmx.org/extensions/hx-ws#usage">Documentation</seealso>
+    let _hxWsConnect url =
+        attr "hx-ws:connect" url
+
+    /// <summary>Send data via a WebSocket connection</summary>
+    /// <param name="url">The URL to which the data should be sent (optional; default is connection URL)</param>
+    /// <returns>A configured <c>hx-ws:send</c> attribute</returns>
+    /// <seealso href="https://four.htmx.org/extensions/hx-ws#usage">Documentation</seealso>
+    let _hxWsSend url =
+        match url with Some it -> attr "hx-ws:send" it | None -> flag "hx-ws:send"

src/ViewEngine.Htmx/README.md

@@ -2,9 +2,9 @@
 
 This package enables [htmx](https://htmx.org) support within the [Giraffe](https://giraffe.wiki) view engine.
 
-**htmx version: 4.0.0-alpha6**
+**htmx version: 4.0.0-beta5**
 
-_Upgrading from v2.x: see [the migration guide](https://four.htmx.org/migration-guide-htmx-4/) for changes, which are plentiful. htmx switches from `XMLHTTPRequest` to `fetch`, and many changes are related to the new event cycle._
+_Upgrading from v2.x: see [the migration guide](https://four.htmx.org/docs/get-started/migration) for changes, which are plentiful. htmx switches from `XMLHTTPRequest` to `fetch`, and many changes are related to the new event cycle._
 
 _Inheritance is now explicit; to have an attribute's value inherited to its children, wrap the attribute in `hxInherited` (ex. `hxInherited (_hxTarget "#main")`). Values can be appended to inherited values as well using the `hxAppend` modifier._
 
@@ -13,7 +13,8 @@ _Several constructs have been marked obsolete in this release, and will be remov
 ### Setup
 
 1. Install the package.
-2. Prior to using the attribute or support modules, `open Giraffe.ViewEngine.Htmx`.
+1. Prior to using the attribute or support modules, `open Giraffe.ViewEngine.Htmx`.
+1. If the client is using the `htmax` bundle, also `open Giraffe.ViewEngine.Htmax`. 
 
 ### Use
 
@@ -34,7 +35,9 @@ Support modules include:
 - `HxTrigger`
 - `HxVals`
 
-`Htmx.Script.local` creates an `XmlNode` to load the package-provided htmx library. There are also two `XmlNode`s that will load the htmx script from jsdelivr; `Htmx.Script.cdnMinified` loads the minified version, and `Htmx.Script.cdnUnminified` loads the unminified version (useful for debugging). When using the CDN nodes and a Content Security Policy (CSP) header, `cdn.jsdelivr.net` needs to be listed as an allowable `script-src`.
+`Htmx.Script.local` creates an `XmlNode` to load the package-provided htmx library. There are also two `XmlNode`s that will load the htmx script from jsdelivr; `Htmx.Script.cdnMinified` loads the minified version, and `Htmx.Script.cdnUnminified` loads the unminified version (useful for debugging). htmx v4 also distributes a "max" bundle which contains some common extensions; these are available with the same names under `Htmx.Script.Max`.
+
+_NOTE: When using the CDN nodes and a Content Security Policy (CSP) header, `cdn.jsdelivr.net` needs to be listed as an allowable `script-src`._
 
 This also supports [fragment rendering](https://bitbadger.solutions/blog/2022/fragment-rendering-in-giraffe-view-engine.html), providing the flexibility to render an entire template, or only a portion of it (based on the element's `id` attribute).
 
@@ -47,10 +50,10 @@ htmx's attributes and these attribute functions map one-to-one. There are two ex
 The htmx `hx-on` attribute supports multiple events if they are separated with a newline (`\n`) character. The value provided to this attribute will be attribute-escaped, but in testing, it was interpreted correctly.
 
 The support modules contain named properties for known values (as illustrated with `HxTrigger.Load` above). A few of the modules are more than collections of names, though:
-- `HxRequest` has a `Configure` function, which takes a list of strings; the other functions in the module allow for configuring the request.
+- `HxConfig` has a `Configure` function, which takes a list of strings; the other functions in the module allow for configuring the request.
 
 ```fsharp
-HxRequest.Configure [ HxRequest.Timeout 500 ] |> _hxRequest 
+HxConfig.Configure [ HxRequest.Timeout 500 ] |> _hxConfig 
 ```
 - `HxTrigger` is _(by far)_ the most complex of these modules. Most uses won't need that complexity; however, complex triggers can be defined by piping into or composing with other functions. For example, to define an event that responds to a shift-click anywhere on the document, with a delay of 3 seconds before firing: