feat: add ws_protocol option

CHANGELOG.md

@@ -9,6 +9,7 @@ Subheadings to categorize changes are `added, changed, deprecated, removed, fixe
 - Added `data-target-path` to `copy-dir`.
 - Allow processing `<script>` tags with the asset pipeline.
 - Added `data-loader-shim` to workers to create shim script.
+- Added `--ws-protocol` cli option and `ws_protocol` config option to specify the WebSockets protocol used for auto-reload.
 ### changed
 - Updated gloo-worker example to use gloo-worker crate v2.1.
 - Our website (trunkrs.dev) now only updates on new releases.

Trunk.toml

@@ -27,6 +27,8 @@ port = 8080
 open = false
 # Disable auto-reload of the web app.
 no_autoreload = false
+# Protocol used for autoreload WebSockets connection.
+ws_protocol = "ws"
 
 [clean]
 # The output dir for all final assets.

src/autoreload.js

@@ -1,5 +1,11 @@
 (function () {
-    var protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    var protocol = '{{protocol}}'
+    protocol =
+        protocol === 'auto'
+            ? window.location.protocol === 'https:'
+                ? 'wss:'
+                : 'ws:'
+            : protocol
     var url = protocol + '//' + window.location.host + '/_trunk/ws';
     var poll_interval = 5000;
     var reload_upon_connect = () => {

src/build.rs

@@ -34,8 +34,13 @@ impl BuildSystem {
     pub async fn new(
         cfg: Arc<RtcBuild>,
         ignore_chan: Option<mpsc::Sender<PathBuf>>,
+        ws_protocol: Option<String>,
     ) -> Result<Self> {
-        let html_pipeline = Arc::new(HtmlPipeline::new(cfg.clone(), ignore_chan)?);
+        let html_pipeline = Arc::new(HtmlPipeline::new(
+            cfg.clone(),
+            ignore_chan,
+            ws_protocol,
+        )?);
         Ok(Self { cfg, html_pipeline })
     }
 

src/cmd/build.rs

@@ -18,7 +18,7 @@ impl Build {
     #[tracing::instrument(level = "trace", skip(self, config))]
     pub async fn run(self, config: Option<PathBuf>) -> Result<()> {
         let cfg = ConfigOpts::rtc_build(self.build, config)?;
-        let mut system = BuildSystem::new(cfg, None).await?;
+        let mut system = BuildSystem::new(cfg, None, None).await?;
         system.build().await?;
         Ok(())
     }

src/cmd/watch.rs

@@ -22,7 +22,7 @@ impl Watch {
     pub async fn run(self, config: Option<PathBuf>) -> Result<()> {
         let (shutdown_tx, _shutdown_rx) = broadcast::channel(1);
         let cfg = ConfigOpts::rtc_watch(self.build, self.watch, config)?;
-        let mut system = WatchSystem::new(cfg, shutdown_tx.clone(), None).await?;
+        let mut system = WatchSystem::new(cfg, shutdown_tx.clone(), None, None).await?;
 
         system.build().await.ok();
         let system_handle = tokio::spawn(system.run());

src/config/models.rs

@@ -126,6 +126,9 @@ pub struct ConfigOptsServe {
     #[arg(long = "no-autoreload")]
     #[serde(default)]
     pub no_autoreload: bool,
+    /// Protocol used for autoreload WebSockets connection.
+    #[arg(long = "ws-protocol")]
+    pub ws_protocol: Option<String>,
 }
 
 /// Config options for the serve system.
@@ -335,6 +338,7 @@ impl ConfigOpts {
             proxy_insecure: cli.proxy_insecure,
             proxy_ws: cli.proxy_ws,
             no_autoreload: cli.no_autoreload,
+            ws_protocol: cli.ws_protocol,
         };
         let cfg = ConfigOpts {
             build: None,
@@ -501,6 +505,7 @@ impl ConfigOpts {
                 g.address = g.address.or(l.address);
                 g.port = g.port.or(l.port);
                 g.proxy_ws = g.proxy_ws || l.proxy_ws;
+                g.ws_protocol = g.ws_protocol.or(l.ws_protocol);
                 // NOTE: this can not be disabled in the cascade.
                 if l.no_autoreload {
                     g.no_autoreload = true;

src/config/rt.rs

@@ -218,6 +218,8 @@ pub struct RtcServe {
     pub proxies: Option<Vec<ConfigOptsProxy>>,
     /// Whether to disable auto-reload of the web page when a build completes.
     pub no_autoreload: bool,
+    /// Protocol used for autoreload WebSockets connection.
+    pub ws_protocol: Option<String>,
 }
 
 impl RtcServe {
@@ -247,6 +249,7 @@ impl RtcServe {
             proxy_ws: opts.proxy_ws,
             proxies,
             no_autoreload: opts.no_autoreload,
+            ws_protocol: opts.ws_protocol,
         })
     }
 }

src/pipelines/html.rs

@@ -36,11 +36,17 @@ pub struct HtmlPipeline {
     target_html_dir: Arc<PathBuf>,
     /// An optional channel to be used to communicate ignore paths to the watcher.
     ignore_chan: Option<mpsc::Sender<PathBuf>>,
+    /// Protocol used for autoreload WebSockets connection.
+    pub ws_protocol: Option<String>,
 }
 
 impl HtmlPipeline {
     /// Create a new instance.
-    pub fn new(cfg: Arc<RtcBuild>, ignore_chan: Option<mpsc::Sender<PathBuf>>) -> Result<Self> {
+    pub fn new(
+        cfg: Arc<RtcBuild>,
+        ignore_chan: Option<mpsc::Sender<PathBuf>>,
+        ws_protocol: Option<String>,
+    ) -> Result<Self> {
         let target_html_path = cfg
             .target
             .canonicalize()
@@ -57,6 +63,7 @@ impl HtmlPipeline {
             target_html_path,
             target_html_dir,
             ignore_chan,
+            ws_protocol,
         })
     }
 
@@ -204,9 +211,13 @@ impl HtmlPipeline {
 
         // Inject the WebSocket autoloader.
         if self.cfg.inject_autoloader {
-            target_html
-                .select("body")
-                .append_html(format!("<script>{}</script>", RELOAD_SCRIPT));
+            target_html.select("body").append_html(format!(
+                "<script>{}</script>",
+                RELOAD_SCRIPT.replace(
+                    "{{protocol}}",
+                    &self.ws_protocol.clone().unwrap_or_else(|| "auto".into())
+                )
+            ));
         }
     }
 }

src/serve.rs

@@ -39,6 +39,7 @@ impl ServeSystem {
             cfg.watch.clone(),
             shutdown.clone(),
             Some(build_done_chan.clone()),
+            cfg.ws_protocol.clone(),
         )
         .await?;
         let http_addr = format!(

src/watch.rs

@@ -38,6 +38,7 @@ impl WatchSystem {
         cfg: Arc<RtcWatch>,
         shutdown: broadcast::Sender<()>,
         build_done_tx: Option<broadcast::Sender<()>>,
+        ws_protocol: Option<String>,
     ) -> Result<Self> {
         // Create a channel for being able to listen for new paths to ignore while running.
         let (watch_tx, watch_rx) = mpsc::channel(1);
@@ -47,7 +48,7 @@ impl WatchSystem {
         let _watcher = build_watcher(watch_tx, cfg.paths.clone())?;
 
         // Build dependencies.
-        let build = BuildSystem::new(cfg.build.clone(), Some(build_tx)).await?;
+        let build = BuildSystem::new(cfg.build.clone(), Some(build_tx), ws_protocol).await?;
         Ok(Self {
             build,
             ignored_paths: cfg.ignored_paths.clone(),