v2.0.8 (#16)

- Embed htmx library to `Giraffe.Htmx.Common`, add links to load package-provided script
- Update CDN links for v2.0.8
- Add .NET 10 support

Reviewed-on: #16

.github/workflows/ci.yml

@@ -2,9 +2,10 @@ name: CI
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "htmx-version-2" ]
   pull_request:
     branches: [ "main" ]
+  workflow_dispatch:
 
 jobs:
   build-and-test:
@@ -13,12 +14,12 @@ jobs:
     
     strategy:
       matrix:
-        dotnet-version: [ "6.0", "7.0" ]
+        dotnet-version: [ "6.0", "7.0", "8.0" ]
     
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Setup .NET ${{ matrix.dotnet-version }}.x
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
         dotnet-version: ${{ matrix.dotnet-version }}.x
     - name: Restore dependencies
@@ -31,11 +32,11 @@ jobs:
     runs-on: ubuntu-latest
     needs: build-and-test
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: "7.0"
+        dotnet-version: "8.0"
     - name: Package Common library
       run: dotnet pack src/Common/Giraffe.Htmx.Common.fsproj -c Release
     - name: Move Common package
@@ -49,7 +50,7 @@ jobs:
     - name: Move View Engine package
       run: cp src/ViewEngine.Htmx/bin/Release/Giraffe.ViewEngine.Htmx.*.nupkg .
     - name: Save Packages
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: packages
         path: |

.gitignore

@@ -6,3 +6,6 @@
 .idea
 *.user
 .vscode
+src/*.nupkg
+src/tests*.txt
+

README.md

@@ -14,6 +14,8 @@ htmx uses attributes and HTTP headers to attain its interactivity; the libraries
 |---|---|
 |[![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/)|
 
+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)_.
+
 ## Server Side (`Giraffe.Htmx`)
 
 In addition to the regular HTTP request payloads, htmx sets [one or more headers](https://htmx.org/docs/#request_headers) along with the request. Once `Giraffe.Htmx` is opened, these are available as properties on `HttpContext.Request.Headers`. These consist of the header name, translated to a .NET name (ex. `HX-Current-URL` becomes `HxCurrentUrl`), and a strongly-typed property based on the expected value of that header. Additionally, they are all exposed as `Option`s, as they may or may not be present for any given request.
@@ -25,9 +27,10 @@ A server may want to respond to a request that originated from htmx differently
 // "view" can be whatever your view engine needs for the body of the page
 let result view : HttpHandler =
     fun next ctx ->
-      match ctx.Request.IsHtmx && not ctx.Request.IsHtmxRefresh with
+        if ctx.Request.IsHtmx && not ctx.Request.IsHtmxRefresh then
-      | true -> partial view
+            partial view
-      | false -> full view
+        else
+            full view
 ```
 
 htmx also utilizes [response headers](https://htmx.org/docs/#response_headers) to affect client-side behavior. For each of these, this library provides `HttpHandler`s that can be chained along with the response. As an example, if the server returns a redirect response (301, 302, 303, 307), the `XMLHttpRequest` handler on the client will follow the redirection before htmx can do anything with it. To redirect to a new page, you would return an OK (200) response with an `HX-Redirect` header set in the response.
@@ -41,6 +44,8 @@ htmx also utilizes [response headers](https://htmx.org/docs/#response_headers) t
 
 Of note is that the `HX-Trigger` headers can take either one or more events. For a single event with no parameters, use `withHxTrigger`; for a single event with parameters, or multiple events, use `withHxTriggerMany`. Both these have `AfterSettle` and `AfterSwap` versions as well.
 
+`HtmxScript.local` provides an `HtmlString` with a script tag to load the package-provided htmx library. This can be used in code, Razor templates, etc. (If you're using Giraffe.ViewEngine, see below.)
+
 ## View Engine (`Giraffe.ViewEngine.Htmx`)
 
 As htmx uses [attributes](https://htmx.org/docs/#attributes) to extend HTML, the primary part of this library defines attributes that can be used within Giraffe views. Simply open `Giraffe.ViewEngine.Htmx`, and these attributes, along with support modules, will be visible.
@@ -49,7 +54,9 @@ As an example, creating a `div` that loads data once the HTML is rendered:
 
 ```fsharp
 let autoload =
-    div [ _hxGet "/lazy-load-data"; _hxTrigger "load" ] [ str "Loading..." ]
+    div [ _hxGet "/lazy-load-data"; _hxTrigger HxTrigger.Load ] [
+        str "Loading..."
+    ]
 ```
 
 _(As `hx-boost="true"` is the usual desire for boosting, `_hxBoost` implies true. To disable it for an element, use `_hxNoBoost` instead.)_
@@ -63,14 +70,14 @@ Some attributes have known values, such as `hx-trigger` and `hx-swap`; for these
     ]
 ```
 
-If you want to load htmx from unpkg, `Htmx.Script.minified` or `Htmx.Script.unminified` can be used to load the script in your HTML trees.
+If you want to use the package-provided htmx library, `Htmx.Script.local` will create the `script` tag for you. To load htmx from jsDelivr, `Htmx.Script.cdnMinified` or `Htmx.Script.cdnUnminified` can be used to load the script in your HTML trees. In this case, if you are using a Content Security Policy (CSP) header, `cdn.jsdelivr.net` will need to be added to the `script-src` list.
 
 ## Feedback / Help
 
-The author hangs out in the #htmx-general channel 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 of the [F# Software Foundation's Slack server](https://fsharp.org/guides/slack/).
 
 ## Thanks
-|[<img src="https://giraffe.wiki/giraffe.png" alt="Giraffe logo" width="200">](https://giraffe.wiki)|[<img src="https://bitbadger.solutions/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)|
+|[<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)|
-| :---: | :---: | :---: |
+| :---: |:------------------------------------------------------------------------------------------------------------------------------------:| :---: |
 |for making ASP.NET Core functional|                                                      for making HTML cool again                                                      |for licensing their tools to this project|
 

src/Common/Common.fs

@@ -1,28 +1,59 @@
-/// Common definitions shared between attribute values and response headers
+/// <summary>Common definitions shared between attribute values and response headers</summary>
 [<AutoOpen>]
 module Giraffe.Htmx.Common
 
-/// Valid values for the `hx-swap` attribute / `HX-Reswap` header (may be combined with swap/settle/scroll/show config)
+/// <summary>The version of htmx embedded in the package</summary>
+let HtmxVersion = "2.0.8"
+
+/// <summary>The path for the provided htmx script</summary>
+let internal htmxLocalScript = $"/_content/Giraffe.Htmx.Common/htmx.min.js?ver={HtmxVersion}"
+
+/// <summary>Serialize a list of key/value pairs to JSON (very rudimentary)</summary>
+/// <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>
+let internal toJson (pairs: (string * string) list) =
+    pairs
+    |> List.map (fun pair -> sprintf "\"%s\": \"%s\"" (fst pair) ((snd pair).Replace ("\"", "\\\"")))
+    |> String.concat ", "
+    |> sprintf "{ %s }"
+
+/// <summary>Convert a boolean to lowercase "true" or "false"</summary>
+/// <param name="boolValue">The boolean value to convert</param>
+/// <returns>"true" for <c>true</c>, "false" for <c>false</c></returns>
+let internal toLowerBool (boolValue: bool) =
+    (string boolValue).ToLowerInvariant()
+
+
+/// <summary>Valid values for the <c>hx-swap</c> attribute / <c>HX-Reswap</c> header</summary>
+/// <remarks>May be combined with <c>swap</c> / <c>settle</c> / <c>scroll</c> / <c>show</c> config)</remarks>
+/// <seealso href="https://htmx.org/attributes/hx-swap/">Documentation</seealso>
 [<RequireQualifiedAccess>]
 module HxSwap =
     
-    /// The default, replace the inner html of the target element
+    /// <summary>The default, replace the inner HTML of the target element</summary>
+    [<Literal>]
     let InnerHtml = "innerHTML"
     
-    /// Replace the entire target element with the response
+    /// <summary>Replace the entire target element with the response</summary>
+    [<Literal>]
     let OuterHtml = "outerHTML"
     
-    /// Insert the response before the target element
+    /// <summary>Insert the response before the target element</summary>
+    [<Literal>]
     let BeforeBegin = "beforebegin"
     
-    /// Insert the response before the first child of the target element
+    /// <summary>Insert the response before the first child of the target element</summary>
+    [<Literal>]
     let AfterBegin = "afterbegin"
     
-    /// Insert the response after the last child of the target element
+    /// <summary>Insert the response after the last child of the target element</summary>
+    [<Literal>]
     let BeforeEnd = "beforeend"
     
-    /// Insert the response after the target element
+    /// <summary>Insert the response after the target element</summary>
+    [<Literal>]
     let AfterEnd = "afterend"
     
-    /// Does not append content from response (out of band items will still be processed).
+    /// <summary>Does not append content from response (out of band items will still be processed).</summary>
+    [<Literal>]
     let None = "none"

src/Common/Giraffe.Htmx.Common.fsproj

@@ -1,14 +1,24 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.Razor">
 
   <PropertyGroup>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Description>Common definitions for Giraffe.Htmx</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
+    <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
   </PropertyGroup>
 
   <ItemGroup>
     <Compile Include="Common.fs" />
     <None Include="README.md" Pack="true" PackagePath="\" />
+    <None Include="..\icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Update="FSharp.Core" Version="6.0.0" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <InternalsVisibleTo Include="Giraffe.Htmx" />
+    <InternalsVisibleTo Include="Giraffe.ViewEngine.Htmx" />
+  </ItemGroup>
 </Project>

src/Common/README.md

@@ -1,5 +1,5 @@
 ## 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.
+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.
 
-**htmx version: 1.9.4**
+**htmx version: 2.0.8**

src/Directory.Build.props

@@ -1,14 +1,23 @@
 <?xml version="1.0" encoding="utf-8" standalone="no"?>
 <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
     <PropertyGroup>
-        <TargetFrameworks>net6.0;net7.0</TargetFrameworks>
+        <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
-        <VersionPrefix>1.9.4</VersionPrefix>
+        <VersionPrefix>2.0.8</VersionPrefix>
-        <PackageReleaseNotes>Update script tags to pull htmx 1.9.4</PackageReleaseNotes>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <PackageReleaseNotes>- Adds package-provided script (available via Giraffe.Htmx.Common); use app.MapStaticAssets() for publish support, use builder.UseStaticWebAssets() for non-development/non-published execution
+- [View Engine] Deprecates Script.minified and Script.unminified (use Script.cdnMinified and Script.cdnUnminified instead)
+- Updates script tags to pull htmx 2.0.8 (no header or attribute changes)
+- Adds .NET 10 support
+
+See full release notes, including more info about the package-provided script, at https://git.bitbadger.solutions/bit-badger/Giraffe.Htmx/releases/tag/v2.0.8
+
+NOTE: As of 2.0.6, the CDN for htmx changed from unpkg.com to cdn.jsdelivr.net; sites with Content-Security-Policy headers will want to update their allowed script-src domains accordingly
+        </PackageReleaseNotes>
         <Authors>danieljsummers</Authors>
         <Company>Bit Badger Solutions</Company>
-        <PackageProjectUrl>https://github.com/bit-badger/Giraffe.Htmx</PackageProjectUrl>
+        <PackageProjectUrl>https://git.bitbadger.solutions/bit-badger/Giraffe.Htmx</PackageProjectUrl>
         <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-        <RepositoryUrl>https://github.com/bit-badger/Giraffe.Htmx</RepositoryUrl>
+        <RepositoryUrl>https://git.bitbadger.solutions/bit-badger/Giraffe.Htmx</RepositoryUrl>
         <RepositoryType>Git</RepositoryType>
         <Copyright>MIT License</Copyright>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>

src/Htmx/Giraffe.Htmx.fsproj

@@ -4,15 +4,18 @@
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Description>htmx header extensions and helpers for Giraffe</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
+    <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
   </PropertyGroup>
 
   <ItemGroup>
     <Compile Include="Htmx.fs" />
     <None Include="README.md" Pack="true" PackagePath="\" />
+    <None Include="..\icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Giraffe" Version="5.0.0" />
+    <PackageReference Include="Giraffe" Version="6.4.0" />
+    <PackageReference Update="FSharp.Core" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Htmx/Htmx.fs

@@ -11,121 +11,174 @@ let private hdr (headers : IHeaderDictionary) hdr =
 /// Extensions to the header dictionary
 type IHeaderDictionary with
   
-    /// Indicates that the request is via an element using `hx-boost`
+    /// <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
+    member this.HxBoosted
+        with get () = hdr this "HX-Boosted" |> Option.map bool.Parse
     
-    /// The current URL of the browser _(note that this does not update until after settle)_
+    /// <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
+    member this.HxCurrentUrl
+        with get () = hdr this "HX-Current-URL" |> Option.map Uri
     
-    /// `true` if the request is for history restoration after a miss in the local history cache
+    /// <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
+    member this.HxHistoryRestoreRequest
+        with get () = hdr this "HX-History-Restore-Request" |> Option.map bool.Parse
     
-    /// The user response to an `hx-prompt`
+    /// <summary>The user response to an <c>hx-prompt</c></summary>
-    member this.HxPrompt with get () = hdr this "HX-Prompt"
+    member this.HxPrompt
+        with get () = hdr this "HX-Prompt"
 
-    /// `true` if the request came from HTMX
+    /// <summary><c>true</c> if the request came from htmx</summary>
-    member this.HxRequest with get () = hdr this "HX-Request" |> Option.map bool.Parse
+    member this.HxRequest
+        with get () = hdr this "HX-Request" |> Option.map bool.Parse
 
-    /// The `id` of the target element if it exists
+    /// <summary>The <c>id</c> attribute of the target element if it exists</summary>
-    member this.HxTarget with get () = hdr this "HX-Target"
+    member this.HxTarget
+        with get () = hdr this "HX-Target"
 
-    /// The `id` of the triggered element if it exists
+    /// <summary>The <c>id</c> attribute of the triggered element if it exists</summary>
-    member this.HxTrigger with get () = hdr this "HX-Trigger"
+    member this.HxTrigger
+        with get () = hdr this "HX-Trigger"
 
-    /// The `name` of the triggered element if it exists
+    /// <summary>The <c>name</c> attribute of the triggered element if it exists</summary>
-    member this.HxTriggerName with get () = hdr this "HX-Trigger-Name"
+    member this.HxTriggerName
+        with get () = hdr this "HX-Trigger-Name"
 
 
 /// Extensions for the request object
 type HttpRequest with
 
-    /// Whether this request was initiated from htmx
+    /// <summary>Whether this request was initiated from htmx</summary>
-    member this.IsHtmx with get () = this.Headers.HxRequest |> Option.defaultValue false
+    member this.IsHtmx
+        with get () = this.Headers.HxRequest |> Option.defaultValue false
 
-    /// Whether this request is an htmx history-miss refresh request
+    /// <summary>Whether this request is an htmx history-miss refresh request</summary>
-    member this.IsHtmxRefresh with get () =
+    member this.IsHtmxRefresh
-        this.IsHtmx && (this.Headers.HxHistoryRestoreRequest |> Option.defaultValue false)
+        with get () = this.IsHtmx && (this.Headers.HxHistoryRestoreRequest |> Option.defaultValue false)
 
 
-/// HTTP handlers for setting output headers
+/// <summary>HTTP handlers for setting output headers</summary>
 [<AutoOpen>]
 module Handlers =
 
-    /// Convert a boolean to lowercase `true` or `false`
+    open Giraffe.Htmx.Common
-    let private toLowerBool (trueOrFalse : bool) =
-        (string trueOrFalse).ToLowerInvariant ()
     
-    /// Serialize a list of key/value pairs to JSON (very rudimentary)
+    /// <summary>Instruct htmx to perform a client-side redirect for content</summary>
-    let private toJson (evts : (string * string) list) =
+    /// <param name="path">The path where the content should be found</param>
-        evts
+    /// <returns>An HTTP handler with the <c>HX-Location</c> header set</returns>
-        |> List.map (fun evt -> sprintf "\"%s\": \"%s\"" (fst evt) ((snd evt).Replace ("\"", "\\\"")))
+    /// <seealso href="https://htmx.org/headers/hx-location/">Documentation</seealso>
-        |> String.concat ", "
+    let withHxLocation (path: string) : HttpHandler =
-        |> sprintf "{ %s }"
+        setHttpHeader "HX-Location" path
     
-    /// Pushes a new url into the history stack
+    /// <summary>Pushes a new url into the history stack</summary>
-    let withHxPushUrl : string -> HttpHandler =
+    /// <param name="url">The URL to be pushed</param>
-        setHttpHeader "HX-Push-Url"
+    /// <returns>An HTTP handler with the <c>HX-Push-Url</c> header set</returns>
+    /// <remarks>Use <see cref="withHxNoPushUrl" /> to explicitly not push a new URL</remarks>
+    /// <seealso href="https://htmx.org/headers/hx-push-url/">Documentation</seealso>
+    let withHxPushUrl (url: string) : HttpHandler =
+        setHttpHeader "HX-Push-Url" url
 
-    /// Explicitly do not push a new URL into the history stack
+    /// <summary>Explicitly do not push a new URL into the history stack</summary>
+    /// <returns>An HTTP handler with the <c>HX-Push-Url</c> header set to <c>false</c></returns>
+    /// <seealso href="https://htmx.org/headers/hx-push-url/">Documentation</seealso>
     let withHxNoPushUrl : HttpHandler =
         toLowerBool false |> withHxPushUrl
       
-    /// Pushes a new url into the history stack
+    /// <summary>Can be used to do a client-side redirect to a new location</summary>
-    [<Obsolete "Use withHxPushUrl; HX-Push was replaced by HX-Push-Url in v1.8.0">]
+    /// <param name="url">The URL to which the client should be redirected</param>
-    let withHxPush = withHxPushUrl
+    /// <returns>An HTTP handler with the <c>HX-Redirect</c> header set</returns>
+    /// <seealso href="https://htmx.org/headers/hx-redirect/">Documentation</seealso>
+    let withHxRedirect (url: string) : HttpHandler =
+        setHttpHeader "HX-Redirect" url
 
-    /// Explicitly do not push a new URL into the history stack
+    /// <summary>If set to <c>true</c> the client side will do a full refresh of the page</summary>
-    [<Obsolete "Use withHxNoPushUrl; HX-Push was replaced by HX-Push-Url in v1.8.0">]
+    /// <param name="shouldRefresh">Whether the client should refresh their page</param>
-    let withHxNoPush = withHxNoPushUrl
+    /// <returns>An HTTP handler with the <c>HX-Refresh</c> header set</returns>
+    let withHxRefresh shouldRefresh : HttpHandler =
+        (toLowerBool >> setHttpHeader "HX-Refresh") shouldRefresh
 
-    /// Can be used to do a client-side redirect to a new location
+    /// <summary>Replaces the current URL in the history stack</summary>
-    let withHxRedirect : string -> HttpHandler =
+    /// <param name="url">The URL to place in the history stack in place of the current one</param>
-        setHttpHeader "HX-Redirect"
+    /// <returns>An HTTP handler with the <c>HX-Replace-URL</c> header set</returns>
+    /// <remarks>Use <see cref="withHxNoRelaceUrl" /> to explicitly not replace the current URL</remarks>
+    /// <seealso href="https://htmx.org/headers/hx-replace-url/">Documentation</seealso>
+    let withHxReplaceUrl url : HttpHandler =
+        setHttpHeader "HX-Replace-Url" url
 
-    /// If set to `true` the client side will do a a full refresh of the page
+    /// <summary>Explicitly do not replace the current URL in the history stack</summary>
-    let withHxRefresh : bool -> HttpHandler =
+    /// <returns>An HTTP handler with the <c>HX-Replace-URL</c> header set to <c>false</c></returns>
-        toLowerBool >> setHttpHeader "HX-Refresh"
+    /// <seealso href="https://htmx.org/headers/hx-replace-url/">Documentation</seealso>
-
-    /// Replaces the current URL in the history stack
-    let withHxReplaceUrl : string -> HttpHandler =
-        setHttpHeader "HX-Replace-Url"
-
-    /// Explicitly do not replace the current URL in the history stack
     let withHxNoReplaceUrl : HttpHandler =
         toLowerBool false |> withHxReplaceUrl
     
-    /// Override which portion of the response will be swapped into the target document
+    /// <summary>Override which portion of the response will be swapped into the target document</summary>
-    let withHxReselect : string -> HttpHandler =
+    /// <param name="target">The selector for the new response target</param>
-        setHttpHeader "HX-Reselect"
+    /// <returns>An HTTP handler with the <c>HX-Reselect</c> header set</returns>
+    let withHxReselect (target: string) : HttpHandler =
+        setHttpHeader "HX-Reselect" target
     
-    /// Override the `hx-swap` attribute from the initiating element
+    /// <summary>Override the <c>hx-swap</c> attribute from the initiating element</summary>
-    let withHxReswap : string -> HttpHandler =
+    /// <param name="swap">The swap value to override</param>
-        setHttpHeader "HX-Reswap"
+    /// <returns>An HTTP handler with the <c>HX-Reswap</c> header set</returns>
+    /// <remarks>Use <see cref="T:Giraffe.Htmx.Common.HxSwap">HxSwap</see> constants for best results</remarks>
+    let withHxReswap (swap: string) : HttpHandler =
+        setHttpHeader "HX-Reswap" swap
 
-    /// Allows you to override the `hx-target` attribute
+    /// <summary>Allows you to override the <c>hx-target</c> attribute</summary>
-    let withHxRetarget : string -> HttpHandler =
+    /// <param name="target">The new target for the response</param>
-        setHttpHeader "HX-Retarget"
+    /// <returns>An HTTP handler with the <c>HX-Retarget</c> header set</returns>
+    let withHxRetarget (target: string) : HttpHandler =
+        setHttpHeader "HX-Retarget" target
 
-    /// Allows you to trigger a single client side event
+    /// <summary>Allows you to trigger a single client side event</summary>
-    let withHxTrigger : string -> HttpHandler =
+    /// <param name="evt">The call to the event that should be triggered</param>
-        setHttpHeader "HX-Trigger"
+    /// <returns>An HTTP handler with the <c>HX-Trigger</c> header set</returns>
+    /// <seealso href="https://htmx.org/headers/hx-trigger/">Documentation</seealso>
+    let withHxTrigger (evt: string) : HttpHandler =
+        setHttpHeader "HX-Trigger" evt
 
-    /// Allows you to trigger multiple client side events
+    /// <summary>Allows you to trigger multiple client side events</summary>
+    /// <param name="evts">The calls to events that should be triggered</param>
+    /// <returns>An HTTP handler with the <c>HX-Trigger</c> header set for all given events</returns>
+    /// <seealso href="https://htmx.org/headers/hx-trigger/">Documentation</seealso>
     let withHxTriggerMany evts : HttpHandler =
         toJson evts |> setHttpHeader "HX-Trigger"
 
-    /// Allows you to trigger a single client side event after changes have settled
+    /// <summary>Allows you to trigger a single client side event after changes have settled</summary>
-    let withHxTriggerAfterSettle : string -> HttpHandler =
+    /// <param name="evt">The call to the event that should be triggered</param>
-        setHttpHeader "HX-Trigger-After-Settle"
+    /// <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>
+    let withHxTriggerAfterSettle (evt: string) : HttpHandler =
+        setHttpHeader "HX-Trigger-After-Settle" evt
 
-    /// Allows you to trigger multiple client side events after changes have settled
+    /// <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>
     let withHxTriggerManyAfterSettle evts : HttpHandler =
         toJson evts |> setHttpHeader "HX-Trigger-After-Settle"
 
-    /// Allows you to trigger a single client side event after DOM swapping occurs
+    /// <summary>Allows you to trigger a single client side event after DOM swapping occurs</summary>
-    let withHxTriggerAfterSwap : string -> HttpHandler =
+    /// <param name="evt">The call to the event that should be triggered</param>
-        setHttpHeader "HX-Trigger-After-Swap"
+    /// <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>
+    let withHxTriggerAfterSwap (evt: string) : HttpHandler =
+        setHttpHeader "HX-Trigger-After-Swap" evt
 
-    /// Allows you to trigger multiple client side events after DOM swapping occurs
+    /// <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>
     let withHxTriggerManyAfterSwap evts : HttpHandler =
         toJson evts |> setHttpHeader "HX-Trigger-After-Swap"
+
+
+/// <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>"""
+    

src/Htmx/README.md

@@ -2,7 +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: 1.9.4**
+**htmx version: 2.0.8**
+
+_Upgrading from v1.x: the [migration guide](https://htmx.org/migration-guide-htmx-1/) does not currently specify any request or response header changes. This means that there are no required code changes in moving from v1.* to v2.*._
 
 ### Setup
 
@@ -32,6 +34,8 @@ To set a response header:
 
 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`.
+
 ### Learn
 
 The naming conventions of this library were selected to mirror those provided by htmx. The header properties become `Hx*` on the `ctx.Request.Headers` object, and the response handlers are `withHx*` based on the header being set. The only part that does not line up is `withHxTrigger*` and `withHxTriggerMany`; the former set work with a single string (to trigger a single event with no arguments), while the latter set supports both arguments and multiple events.

src/Tests/Common.fs

@@ -3,6 +3,12 @@ module Common
 open Expecto
 open Giraffe.Htmx
 
+/// Test to ensure the version was updated
+let version =
+    test "HtmxVersion is correct" {
+        Expect.equal HtmxVersion "2.0.8" "htmx version incorrect"
+    }
+
 /// Tests for the HxSwap module
 let swap =
     testList "HxSwap" [
@@ -30,4 +36,4 @@ let swap =
     ]
 
 /// All tests for this module
-let allTests = testList "Htmx.Common" [ swap ]
+let allTests = testList "Htmx.Common" [ version; swap ]

src/Tests/Htmx.fs

@@ -3,6 +3,7 @@ module Htmx
 open System
 open Expecto
 open Giraffe.Htmx
+open Microsoft.AspNetCore.Html
 open Microsoft.AspNetCore.Http
 open NSubstitute
 
@@ -207,6 +208,14 @@ let next (ctx : HttpContext) = Task.FromResult (Some ctx)
 /// Tests for the HttpHandler functions provided in the Handlers module
 let handlers =
     testList "HandlerTests" [
+        testTask "withHxLocation succeeds" {
+            let ctx = Substitute.For<HttpContext>()
+            let dic = HeaderDictionary()
+            ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
+            let! _ = withHxLocation "/pagina-otro.html" next ctx
+            Expect.isTrue (dic.ContainsKey "HX-Location") "The HX-Location header should be present"
+            Expect.equal dic["HX-Location"].[0] "/pagina-otro.html" "The HX-Location value was incorrect"
+        }
         testTask "withHxPushUrl succeeds" {
             let ctx = Substitute.For<HttpContext>()
             let dic = HeaderDictionary()
@@ -346,5 +355,16 @@ let handlers =
         }
     ]
 
+/// Tests for the HtmxScript module
+let script =
+    testList "HtmxScript" [
+        test "local generates correct link" {
+            Expect.equal
+                (string HtmxScript.local)
+                $"""<script src="/_content/Giraffe.Htmx.Common/htmx.min.js?ver={HtmxVersion}"></script>"""
+                "htmx script link is incorrect"
+        }
+    ]
+
 /// All tests for this module
-let allTests = testList "Htmx" [ dictExtensions; reqExtensions; handlers ]
+let allTests = testList "Htmx" [ dictExtensions; reqExtensions; handlers; script ]

src/Tests/Program.fs

@@ -3,4 +3,4 @@ open Expecto
 let allTests = testList "Giraffe" [ Common.allTests; Htmx.allTests; ViewEngine.allTests ]
 
 [<EntryPoint>]
-let main args = runTestsWithArgs defaultConfig args allTests
+let main args = runTestsWithCLIArgs [] args allTests

src/Tests/Tests.fsproj

@@ -18,8 +18,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Expecto" Version="9.0.4" />
+    <PackageReference Include="Expecto" Version="10.2.1" />
-    <PackageReference Include="NSubstitute" Version="5.0.0" />
+    <PackageReference Include="NSubstitute" Version="5.1.0" />
+    <PackageReference Update="FSharp.Core" Version="8.0.300" />
   </ItemGroup>
 
 </Project>

src/Tests/ViewEngine.fs

@@ -15,6 +15,399 @@ let hxEncoding =
         }
     ]
 
+let hxEvent =
+    testList "HxEvent" [
+        testList "Abort" [
+            test "ToString succeeds" {
+                Expect.equal (string Abort) "abort" "Abort event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (Abort.ToHxOnString()) "abort" "Abort hx-on event name not correct"
+            }
+        ]
+        testList "AfterOnLoad" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterOnLoad) "afterOnLoad" "AfterOnLoad event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (AfterOnLoad.ToHxOnString()) "after-on-load" "AfterOnLoad hx-on event name not correct"
+            }
+        ]
+        testList "AfterProcessNode" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterProcessNode) "afterProcessNode" "AfterProcessNode event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (AfterProcessNode.ToHxOnString())
+                    "after-process-node"
+                    "AfterProcessNode hx-on event name not correct"
+            }
+        ]
+        testList "AfterRequest" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterRequest) "afterRequest" "AfterRequest event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (AfterRequest.ToHxOnString()) "after-request" "AfterRequest hx-on event name not correct"
+            }
+        ]
+        testList "AfterSettle" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterSettle) "afterSettle" "AfterSettle event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (AfterSettle.ToHxOnString()) "after-settle" "AfterSettle hx-on event name not correct"
+            }
+        ]
+        testList "AfterSwap" [
+            test "ToString succeeds" {
+                Expect.equal (string AfterSwap) "afterSwap" "AfterSwap event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (AfterSwap.ToHxOnString()) "after-swap" "AfterSwap hx-on event name not correct"
+            }
+        ]
+        testList "BeforeCleanupElement" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string BeforeCleanupElement) "beforeCleanupElement" "BeforeCleanupElement event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeCleanupElement.ToHxOnString())
+                    "before-cleanup-element"
+                    "BeforeCleanupElement hx-on event name not correct"
+            }
+        ]
+        testList "BeforeOnLoad" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeOnLoad) "beforeOnLoad" "BeforeOnLoad event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (BeforeOnLoad.ToHxOnString()) "before-on-load" "BeforeOnLoad hx-on event name not correct"
+            }
+        ]
+        testList "BeforeProcessNode" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeProcessNode) "beforeProcessNode" "BeforeProcessNode event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeProcessNode.ToHxOnString())
+                    "before-process-node"
+                    "BeforeProcessNode hx-on event name not correct"
+            }
+        ]
+        testList "BeforeRequest" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeRequest) "beforeRequest" "BeforeRequest event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeRequest.ToHxOnString()) "before-request" "BeforeRequest hx-on event name not correct"
+            }
+        ]
+        testList "BeforeSwap" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeSwap) "beforeSwap" "BeforeSwap event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (BeforeSwap.ToHxOnString()) "before-swap" "BeforeSwap hx-on event name not correct"
+            }
+        ]
+        testList "BeforeSend" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeSend) "beforeSend" "BeforeSend event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (BeforeSend.ToHxOnString()) "before-send" "BeforeSend hx-on event name not correct"
+            }
+        ]
+        testList "ConfigRequest" [
+            test "ToString succeeds" {
+                Expect.equal (string ConfigRequest) "configRequest" "ConfigRequest event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (ConfigRequest.ToHxOnString()) "config-request" "ConfigRequest hx-on event name not correct"
+            }
+        ]
+        testList "Confirm" [
+            test "ToString succeeds" {
+                Expect.equal (string Confirm) "confirm" "Confirm event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (Confirm.ToHxOnString()) "confirm" "Confirm hx-on event name not correct"
+            }
+        ]
+        testList "HistoryCacheError" [
+            test "ToString succeeds" {
+                Expect.equal (string HistoryCacheError) "historyCacheError" "HistoryCacheError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (HistoryCacheError.ToHxOnString())
+                    "history-cache-error"
+                    "HistoryCacheError hx-on event name not correct"
+            }
+        ]
+        testList "HistoryCacheMiss" [
+            test "ToString succeeds" {
+                Expect.equal (string HistoryCacheMiss) "historyCacheMiss" "HistoryCacheMiss event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (HistoryCacheMiss.ToHxOnString())
+                    "history-cache-miss"
+                    "HistoryCacheMiss hx-on event name not correct"
+            }
+        ]
+        testList "HistoryCacheMissError" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string HistoryCacheMissError)
+                    "historyCacheMissError"
+                    "HistoryCacheMissError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (HistoryCacheMissError.ToHxOnString())
+                    "history-cache-miss-error"
+                    "HistoryCacheMissError hx-on event name not correct"
+            }
+        ]
+        testList "HistoryCacheMissLoad" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string HistoryCacheMissLoad) "historyCacheMissLoad" "HistoryCacheMissLoad event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (HistoryCacheMissLoad.ToHxOnString())
+                    "history-cache-miss-load"
+                    "HistoryCacheMissLoad hx-on event name not correct"
+            }
+        ]
+        testList "HistoryRestore" [
+            test "ToString succeeds" {
+                Expect.equal (string HistoryRestore) "historyRestore" "HistoryRestore event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (HistoryRestore.ToHxOnString()) "history-restore" "HistoryRestore hx-on event name not correct"
+            }
+        ]
+        testList "BeforeHistorySave" [
+            test "ToString succeeds" {
+                Expect.equal (string BeforeHistorySave) "beforeHistorySave" "BeforeHistorySave event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (BeforeHistorySave.ToHxOnString())
+                    "before-history-save"
+                    "BeforeHistorySave hx-on event name not correct"
+            }
+        ]
+        testList "Load" [
+            test "ToString succeeds" {
+                Expect.equal (string Load) "load" "Load event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (Load.ToHxOnString()) "load" "Load hx-on event name not correct"
+            }
+        ]
+        testList "NoSseSourceError" [
+            test "ToString succeeds" {
+                Expect.equal (string NoSseSourceError) "noSSESourceError" "NoSseSourceError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (NoSseSourceError.ToHxOnString())
+                    "no-sse-source-error"
+                    "NoSseSourceError hx-on event name not correct"
+            }
+        ]
+        testList "OnLoadError" [
+            test "ToString succeeds" {
+                Expect.equal (string OnLoadError) "onLoadError" "OnLoadError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (OnLoadError.ToHxOnString()) "on-load-error" "OnLoadError hx-on event name not correct"
+            }
+        ]
+        testList "OobAfterSwap" [
+            test "ToString succeeds" {
+                Expect.equal (string OobAfterSwap) "oobAfterSwap" "OobAfterSwap event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (OobAfterSwap.ToHxOnString()) "oob-after-swap" "OobAfterSwap hx-on event name not correct"
+            }
+        ]
+        testList "OobBeforeSwap" [
+            test "ToString succeeds" {
+                Expect.equal (string OobBeforeSwap) "oobBeforeSwap" "OobBeforeSwap event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (OobBeforeSwap.ToHxOnString()) "oob-before-swap" "OobBeforeSwap hx-on event name not correct"
+            }
+        ]
+        testList "OobErrorNoTarget" [
+            test "ToString succeeds" {
+                Expect.equal (string OobErrorNoTarget) "oobErrorNoTarget" "OobErrorNoTarget event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (OobErrorNoTarget.ToHxOnString())
+                    "oob-error-no-target"
+                    "OobErrorNoTarget hx-on event name not correct"
+            }
+        ]
+        testList "Prompt" [
+            test "ToString succeeds" {
+                Expect.equal (string Prompt) "prompt" "Prompt event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (Prompt.ToHxOnString()) "prompt" "Prompt hx-on event name not correct"
+            }
+        ]
+        testList "PushedIntoHistory" [
+            test "ToString succeeds" {
+                Expect.equal (string PushedIntoHistory) "pushedIntoHistory" "PushedIntoHistory event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (PushedIntoHistory.ToHxOnString())
+                    "pushed-into-history"
+                    "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()) "response-error" "ResponseError hx-on event name not correct"
+            }
+        ]
+        testList "SendError" [
+            test "ToString succeeds" {
+                Expect.equal (string SendError) "sendError" "SendError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (SendError.ToHxOnString()) "send-error" "SendError 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"
+            }
+        ]
+        testList "SseOpen" [
+            test "ToString succeeds" {
+                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"
+            }
+        ]
+        testList "SwapError" [
+            test "ToString succeeds" {
+                Expect.equal (string SwapError) "swapError" "SwapError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (SwapError.ToHxOnString()) "swap-error" "SwapError hx-on event name not correct"
+            }
+        ]
+        testList "TargetError" [
+            test "ToString succeeds" {
+                Expect.equal (string TargetError) "targetError" "TargetError event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (TargetError.ToHxOnString()) "target-error" "TargetError hx-on event name not correct"
+            }
+        ]
+        testList "Timeout" [
+            test "ToString succeeds" {
+                Expect.equal (string Timeout) "timeout" "Timeout event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (Timeout.ToHxOnString()) "timeout" "Timeout hx-on event name not correct"
+            }
+        ]
+        testList "ValidationValidate" [
+            test "ToString succeeds" {
+                Expect.equal
+                    (string ValidationValidate) "validation:validate" "ValidationValidate event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (ValidationValidate.ToHxOnString())
+                    "validation:validate"
+                    "ValidationValidate hx-on event name not correct"
+            }
+        ]
+        testList "ValidationFailed" [
+            test "ToString succeeds" {
+                Expect.equal (string ValidationFailed) "validation:failed" "ValidationFailed event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (ValidationFailed.ToHxOnString())
+                    "validation:failed"
+                    "ValidationFailed hx-on event name not correct"
+            }
+        ]
+        testList "ValidationHalted" [
+            test "ToString succeeds" {
+                Expect.equal (string ValidationHalted) "validation:halted" "ValidationHalted event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal
+                    (ValidationHalted.ToHxOnString())
+                    "validation:halted"
+                    "ValidationHalted hx-on event name not correct"
+            }
+        ]
+        testList "XhrAbort" [
+            test "ToString succeeds" {
+                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"
+            }
+        ]
+        testList "XhrLoadEnd" [
+            test "ToString succeeds" {
+                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"
+            }
+        ]
+        testList "XhrLoadStart" [
+            test "ToString succeeds" {
+                Expect.equal (string XhrLoadStart) "xhr:loadstart" "XhrLoadStart event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (XhrLoadStart.ToHxOnString()) "xhr:loadstart" "XhrLoadStart hx-on event name not correct"
+            }
+        ]
+        testList "XhrProgress" [
+            test "ToString succeeds" {
+                Expect.equal (string XhrProgress) "xhr:progress" "XhrProgress event name not correct"
+            }
+            test "ToHxOnString succeeds" {
+                Expect.equal (XhrProgress.ToHxOnString()) "xhr:progress" "XhrProgress hx-on event name not correct"
+            }
+        ]
+    ]
+
 /// Tests for the HxHeaders module
 let hxHeaders =
     testList "HxHeaders" [
@@ -104,6 +497,32 @@ let hxRequest =
         ]
     ]
 
+/// Tests for the HxSync module
+let hxSync =
+    testList "HxSync" [
+        test "Drop is correct" {
+            Expect.equal HxSync.Drop "drop" "Drop is incorrect"
+        }
+        test "Abort is correct" {
+            Expect.equal HxSync.Abort "abort" "Abort is incorrect"
+        }
+        test "Replace is correct" {
+            Expect.equal HxSync.Replace "replace" "Replace is incorrect"
+        }
+        test "Queue is correct" {
+            Expect.equal HxSync.Queue "queue" "Queue is incorrect"
+        }
+        test "QueueFirst is correct" {
+            Expect.equal HxSync.QueueFirst "queue first" "QueueFirst is incorrect"
+        }
+        test "QueueLast is correct" {
+            Expect.equal HxSync.QueueLast "queue last" "QueueLast is incorrect"
+        }
+        test "QueueAll is correct" {
+            Expect.equal HxSync.QueueAll "queue all" "QueueAll is incorrect"
+        }
+    ]
+
 /// Tests for the HxTrigger module
 let hxTrigger =
     testList "HxTrigger" [
@@ -243,6 +662,9 @@ let hxTrigger =
             test "succeeds when it is not the first modifier" {
                 Expect.equal (HxTrigger.Queue "def" "click") "click queue:def" "Queue modifier incorrect"
             }
+            test "succeeds when no type of queueing is given" {
+                Expect.equal (HxTrigger.Queue "" "blur") "blur queue" "Queue modifier incorrect"
+            }
         ]
         testList "QueueFirst" [
             test "succeeds when it is the first modifier" {
@@ -293,14 +715,14 @@ let hxVals =
         ]
     ]
 
-/// Tests for the HtmxAttrs module
-let attributes =
-    testList "Attributes" [
-
 /// Pipe-able assertion for a rendered node 
 let shouldRender expected node =
     Expect.equal (RenderView.AsString.htmlNode node) expected "Rendered HTML incorrect"
 
+/// Tests for the HtmxAttrs module
+let attributes =
+    testList "Attributes" [
+
         test "_hxBoost succeeds" {
             div [ _hxBoost ] [] |> shouldRender """<div hx-boost="true"></div>"""
         }
@@ -313,6 +735,9 @@ let attributes =
         test "_hxDisable succeeds" {
             p [ _hxDisable ] [] |> shouldRender """<p hx-disable></p>"""
         }
+        test "_hxDisabledElt succeeds" {
+            button [ _hxDisabledElt "this" ] [] |> shouldRender """<button hx-disabled-elt="this"></button>"""
+        }
         test "_hxDisinherit succeeds" {
             strong [ _hxDisinherit "*" ] [] |> shouldRender """<strong hx-disinherit="*"></strong>"""
         }
@@ -330,7 +755,7 @@ let attributes =
             |> shouldRender """<figure hx-headers="{ &quot;X-Special-Header&quot;: &quot;some-header&quot; }"></figure>"""
         }
         test "_hxHistory succeeds" {
-            span [ _hxHistory "false" ] [] |> shouldRender """<span hx-history="false"></span>"""
+            span [ _hxHistory false ] [] |> shouldRender """<span hx-history="false"></span>"""
         }
         test "_hxHistoryElt succeeds" {
             table [ _hxHistoryElt ] [] |> shouldRender """<table hx-history-elt></table>"""
@@ -344,10 +769,12 @@ let attributes =
         test "_hxNoBoost succeeds" {
             td [ _hxNoBoost ] [] |> shouldRender """<td hx-boost="false"></td>"""
         }
-        test "_hxOn succeeds" {
+        test "_hxOnEvent succeeds" {
-            let newLine = "\n"
+            a [ _hxOnEvent "click" "doThis()" ] [] |> shouldRender """<a hx-on:click="doThis()"></a>"""
-            strong [ _hxOn "submit: alert('oops')\nclick: alert('howdy!')" ] []
+        }
-            |> shouldRender $"""<strong hx-on="submit: alert(&#39;oops&#39;){newLine}click: alert(&#39;howdy!&#39;)"></strong>"""
+        test "_hxOnHxEvent succeeds" {
+            strong [ _hxOnHxEvent BeforeSwap "changeStuff()" ] []
+            |> shouldRender """<strong hx-on::before-swap="changeStuff()"></strong>"""
         }
         test "_hxParams succeeds" {
             br [ _hxParams "[p1,p2]" ] |> shouldRender """<br hx-params="[p1,p2]">"""
@@ -359,7 +786,7 @@ let attributes =
             hr [ _hxPost "/hear-ye-hear-ye" ] |> shouldRender """<hr hx-post="/hear-ye-hear-ye">"""
         }
         test "_hxPreserve succeeds" {
-            img [ _hxPreserve ] |> shouldRender """<img hx-preserve="true">"""
+            img [ _hxPreserve ] |> shouldRender """<img hx-preserve>"""
         }
         test "_hxPrompt succeeds" {
             strong [ _hxPrompt "Who goes there?" ] []
@@ -383,10 +810,6 @@ let attributes =
         test "_hxSelectOob succeeds" {
             section [ _hxSelectOob "#oob" ] [] |> shouldRender """<section hx-select-oob="#oob"></section>"""
         }
-        test "_hxSse succeeds" {
-            footer [ _hxSse "connect:/my-events" ] []
-            |> shouldRender """<footer hx-sse="connect:/my-events"></footer>"""
-        }
         test "_hxSwap succeeds" {
             del [ _hxSwap "innerHTML" ] [] |> shouldRender """<del hx-swap="innerHTML"></del>"""
         }
@@ -398,7 +821,8 @@ let attributes =
             li [ _hxSwapOob "true" ] [] |> shouldRender """<li hx-swap-oob="true"></li>"""
         }
         test "_hxSync succeeds" {
-            nav [ _hxSync "closest form:abort" ] [] |> shouldRender """<nav hx-sync="closest form:abort"></nav>"""
+            nav [ _hxSync "closest form" HxSync.Abort ] []
+            |> shouldRender """<nav hx-sync="closest form:abort"></nav>"""
         }
         test "_hxTarget succeeds" {
             header [ _hxTarget "#somewhereElse" ] [] |> shouldRender """<header hx-target="#somewhereElse"></header>"""
@@ -410,27 +834,39 @@ let attributes =
             dt [ _hxVals """{ "extra": "values" }""" ] []
             |> shouldRender """<dt hx-vals="{ &quot;extra&quot;: &quot;values&quot; }"></dt>"""
         }
-        test "_hxWs succeeds" {
+        test "_sseSwap succeeds" {
-            ul [ _hxWs "connect:/web-socket" ] [] |> shouldRender """<ul hx-ws="connect:/web-socket"></ul>"""
+            ul [ _sseSwap "sseMessageName" ] [] |> shouldRender """<ul sse-swap="sseMessageName"></ul>"""
+        }
+        test "_sseConnect succeeds" {
+            div [ _sseConnect "/gps/sse" ] [] |> shouldRender """<div sse-connect="/gps/sse"></div>"""
         }
     ]
 
+open Giraffe.Htmx.Common
+
 /// Tests for the Script module
 let script =
     testList "Script" [
-        test "minified succeeds" {
+        test "local succeeds" {
-            let html = RenderView.AsString.htmlNode Script.minified
+            let html = RenderView.AsString.htmlNode Script.local
             Expect.equal
                 html
-                """<script src="https://unpkg.com/htmx.org@1.9.4" integrity="sha384-zUfuhFKKZCbHTY6aRR46gxiqszMk5tcHjsVFxnUo8VMus4kHGVdIYVbOYYNlKmHV" crossorigin="anonymous"></script>"""
+                $"""<script src="/_content/Giraffe.Htmx.Common/htmx.min.js?ver={HtmxVersion}"></script>"""
-                "Minified script tag is incorrect"
+                "Local script tag is incorrect"
         }
-        test "unminified succeeds" {
+        test "cdnMinified succeeds" {
-            let html = RenderView.AsString.htmlNode Script.unminified
+            let html = RenderView.AsString.htmlNode Script.cdnMinified
             Expect.equal
                 html
-                """<script src="https://unpkg.com/htmx.org@1.9.4/dist/htmx.js" integrity="sha384-2caa3Jf+wayjuHAc9J3mR3xz191GzmIDNYVBsE8LetbkJn4wjLrO6Ht9rRMuEjIo" crossorigin="anonymous"></script>"""
+                $"""<script src="https://cdn.jsdelivr.net/npm/htmx.org@{HtmxVersion}/dist/htmx.min.js" integrity="sha256-Iig+9oy3VFkU8KiKG97cclanA9HVgMHSVSF9ClDTExM=" crossorigin="anonymous"></script>"""
-                "Unminified script tag is incorrect"
+                "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="sha256-upUwYnay6R+DA68rROTAP+EdfO3NvOqtE513PgDyAYM=" crossorigin="anonymous"></script>"""
+                "CDN unminified script tag is incorrect"
         }
     ]
 
@@ -583,5 +1019,16 @@ let renderFragment =
 
 /// All tests in this module
 let allTests =
-    testList "ViewEngine.Htmx"
+    testList "ViewEngine.Htmx" [
-             [ hxEncoding; hxHeaders; hxParams; hxRequest; hxTrigger; hxVals; attributes; script; renderFragment ]
+        hxEncoding
+        hxEvent
+        hxHeaders
+        hxParams
+        hxRequest
+        hxSync
+        hxTrigger
+        hxVals
+        attributes
+        script
+        renderFragment
+    ]

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

@@ -4,15 +4,18 @@
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Description>Extensions to Giraffe View Engine to support htmx attributes and their values</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
+    <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
   </PropertyGroup>
 
   <ItemGroup>
     <Compile Include="Htmx.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 Update="FSharp.Core" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>

src/ViewEngine.Htmx/README.md

@@ -2,7 +2,9 @@
 
 This package enables [htmx](https://htmx.org) support within the [Giraffe](https://giraffe.wiki) view engine.
 
-**htmx version: 1.9.4**
+**htmx version: 2.0.8**
+
+_Upgrading from v1.x: see [the migration guide](https://htmx.org/migration-guide-htmx-1/) for changes_
 
 ### Setup
 
@@ -27,7 +29,7 @@ Support modules include:
 - `HxTrigger`
 - `HxVals`
 
-There are two `XmlNode`s that will load the htmx script from unpkg; `Htmx.Script.minified` loads the minified version, and `Htmx.Script.unminified` loads the unminified version (useful for debugging).
+`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`.
 
 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).
 

src/pack.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+dotnet pack Common/Giraffe.Htmx.Common.fsproj -c Release
+dotnet pack Htmx/Giraffe.Htmx.fsproj -c Release
+dotnet pack ViewEngine.Htmx/Giraffe.ViewEngine.Htmx.fsproj -c Release
+cp Common/bin/Release/Giraffe.Htmx.Common.*.nupkg .
+cp Htmx/bin/Release/Giraffe.Htmx.*.nupkg .
+cp ViewEngine.Htmx/bin/Release/Giraffe.ViewEngine.Htmx.*.nupkg .