coatless-rpkg
diff --git a/‎NEWS.md‎
Lines changed: 52 additions & 14 deletions b/‎NEWS.md‎
Lines changed: 52 additions & 14 deletions
diff --git a/‎R/app_check.R‎
Lines changed: 53 additions & 35 deletions b/‎R/app_check.R‎
Lines changed: 53 additions & 35 deletions
diff --git a/‎R/build-project.R‎
Lines changed: 15 additions & 2 deletions b/‎R/build-project.R‎
Lines changed: 15 additions & 2 deletions
diff --git a/‎R/build-steps.R‎
Lines changed: 13 additions & 8 deletions b/‎R/build-steps.R‎
Lines changed: 13 additions & 8 deletions
diff --git a/‎R/build.R‎
Lines changed: 19 additions & 7 deletions b/‎R/build.R‎
Lines changed: 19 additions & 7 deletions
@@ -1,27 +1,50 @@
 # shinyelectron 0.2.0
 
-## New app types
+## App types and autodetection
 
-* Added Python Shiny support: `py-shinylive` (browser-based via Pyodide) and
-  `py-shiny` (native with Python runtime). All four app types are now fully
-  implemented.
+* Python Shiny is now supported alongside R Shiny. `app_type` takes
+  `"r-shiny"` or `"py-shiny"`, with `NULL` (default) meaning
+  autodetect from the files in `appdir`. `detect_app_type()` resolves
+  `app.R`, `ui.R` + `server.R`, or `app.py`; ambiguous layouts abort
+  with a pointer to the multi-app-suites workflow.
+* `export(appdir, destdir)` with no other arguments now works for the
+  common case.
 
 ## Runtime strategies
 
-* Added four runtime strategies for native apps (`r-shiny`, `py-shiny`):
-  **system**, **bundled**, **auto-download** (default), and **container**.
-* Bundled strategy embeds a portable R or Python runtime inside the Electron
+* Five strategies, all legal with both languages: **shinylive** (the
+  default, compiles to WebAssembly and runs in-browser), **bundled**,
+  **system**, **auto-download**, and **container**.
+* Bundled embeds a portable R or Python runtime inside the Electron
   app for zero-dependency distribution.
-* Auto-download strategy downloads the runtime on first launch and caches it
+* Auto-download fetches the runtime on first launch and caches it
   locally.
-* Container strategy runs apps inside Docker or Podman for full environment
+* Container runs apps inside Docker or Podman for full environment
   isolation.
+* The older `app_type = "r-shinylive"` and `"py-shinylive"` values
+  are still accepted with a deprecation warning of class
+  `shinyelectron_deprecated_app_type`; they translate to the canonical
+  language plus `runtime_strategy = "shinylive"`. Pairing a legacy
+  type with a non-shinylive strategy is an error. The shim will be
+  removed in a future release.
 
 ## Multi-app suites
 
-* Bundle multiple Shiny apps into a single Electron shell with a launcher UI.
-* Configure via `_shinyelectron.yml` with an `apps` array.
-* Python suites read dependencies from a single suite-root `requirements.txt`.
+* Bundle multiple Shiny apps into a single Electron shell with a
+  launcher UI.
+* Configure via `_shinyelectron.yml` with an `apps` array; each app
+  entry may carry its own `runtime_strategy`, so a suite can mix
+  (for example) one shinylive app with a bundled R app.
+* Python suites read dependencies from a single suite-root
+  `requirements.txt`.
+
+## Config file
+
+* `build.type` may be omitted; autodetection runs at build time.
+* `build.runtime_strategy: "shinylive"` is accepted alongside the
+  other four strategies.
+* `init_config()` writes a template that leaves `build.type`
+  commented out and lists all five strategies.
 
 ## Lifecycle UI
 
@@ -31,6 +54,18 @@
   screen.
 * Port allocation uses OS-assigned ports via `findAvailablePort()` to prevent
   collisions when multiple apps run simultaneously.
+* Splash and preloader gain working knobs in `_shinyelectron.yml`:
+  `splash.enabled` toggles the splash state, `splash.duration` sets a
+  minimum display time before transitioning, `splash.background` and
+  `preloader.background` override the lifecycle window background, and
+  `preloader.style` picks the loading indicator (`spinner`, `bar`, or
+  `dots`).
+
+## Bug fixes
+
+* `auto_download` and `auto_install` were rendered as R-style `TRUE` /
+  `FALSE` in the generated `main.js`, which is invalid JavaScript. Booleans
+  now render through mustache sections so the auto-updater wiring is valid.
 
 ## Code signing
 
@@ -66,15 +101,18 @@
 
 * New vignettes: Runtime Strategies, Multi-App Suites, Code Signing, Container
   Strategy, Security Considerations.
+* Renamed the Advanced Features vignette to Customizations and rewrote it
+  around the splash, tray, and menu options with annotated diagrams.
 * Updated Getting Started, Configuration, and Troubleshooting vignettes for
   Python support, all runtime strategies, and Windows-specific guidance.
+* The GitHub Actions vignette now reads its env-vars block live from
+  `inst/templates/github-actions-build.yml`, so the documented values stay in
+  sync with the shipped template.
 
 ## Internal
 
 * Extracted `run_command_safe()` helper for repeated `processx::run()` patterns.
 * Extracted `killProcessTree()` to shared JS utils for process cleanup.
-* Added app type group constants (`SHINYLIVE_TYPES`, `NATIVE_TYPES`,
-  `R_TYPES`, `PY_TYPES`) to reduce stringly-typed code.
 * Cached `available.packages()` during bundled R builds to avoid redundant
   CRAN network calls.
 * Fixed event listener leak in multi-app mode (`removeAllListeners()` instead
 
@@ -6,7 +6,7 @@
 #'
 #' @param appdir Character string. Path to the app directory. Default ".".
 #' @param app_type Character string or NULL. App type override.
-#'   If NULL, reads from config or defaults to "r-shinylive".
+#'   If NULL, reads from config or autodetects from files in `appdir`.
 #' @param runtime_strategy Character string or NULL. Runtime strategy override.
 #' @param platform Character vector or NULL. Target platforms override.
 #' @param sign Logical or NULL. Signing override.
@@ -69,23 +69,42 @@ app_check <- function(appdir = ".", app_type = NULL, runtime_strategy = NULL,
     list()
   })
 
-  # Resolve parameters from config
-  app_type <- app_type %||% config$build$type %||% "r-shinylive"
-  runtime_strategy <- infer_runtime_strategy(runtime_strategy %||% config$build$runtime_strategy, app_type)
+  # Resolve parameters. Order: function arg > config > autodetect (type)
+  # or default (strategy).
+  normalized <- normalize_app_type_arg(app_type, runtime_strategy)
+  app_type <- normalized$app_type
+  runtime_strategy <- normalized$runtime_strategy
+
+  if (is.null(app_type)) {
+    cfg_type <- config$build$type
+    if (!is.null(cfg_type) && nzchar(cfg_type)) {
+      cfg_normalized <- normalize_app_type_arg(cfg_type, runtime_strategy)
+      app_type <- cfg_normalized$app_type
+      runtime_strategy <- runtime_strategy %||% cfg_normalized$runtime_strategy
+    }
+  }
+  if (is.null(app_type)) {
+    app_type <- tryCatch(detect_app_type(appdir), error = function(e) NULL)
+    if (is.null(app_type)) {
+      errors <- c(errors, "Could not determine app type (no app.R/app.py/server.R+ui.R found)")
+      if (verbose) cli::cli_alert_danger("App type: could not autodetect")
+      return(invisible(list(pass = FALSE, errors = errors, warnings = warnings, info = info)))
+    }
+  }
+  runtime_strategy <- runtime_strategy %||% config$build$runtime_strategy %||% "shinylive"
+
   platform <- platform %||% config$build$platforms %||% detect_current_platform()
   sign <- sign %||% isTRUE(config$signing$sign)
 
   if (verbose) {
     cli::cli_alert_info("Type: {.val {app_type}}")
-    if (app_type %in% NATIVE_TYPES) {
-      cli::cli_alert_info("Runtime strategy: {.val {runtime_strategy}}")
-    }
+    cli::cli_alert_info("Runtime strategy: {.val {runtime_strategy}}")
     cli::cli_alert_info("Platform(s): {.val {platform}}")
   }
 
   # --- Check: App structure ---
   tryCatch({
-    if (app_type %in% R_TYPES) {
+    if (app_type == "r-shiny") {
       validate_shiny_app_structure(appdir)
       if (verbose) cli::cli_alert_success("App structure: {.file app.R} found")
     } else {
@@ -114,7 +133,7 @@ app_check <- function(appdir = ".", app_type = NULL, runtime_strategy = NULL,
 
   # --- Check: Runtime ---
   if (runtime_strategy == "system") {
-    if (app_type %in% R_TYPES) {
+    if (app_type == "r-shiny") {
       tryCatch({
         rscript_path <- validate_r_available()
         if (verbose) cli::cli_alert_success("R: available at {.path {rscript_path}}")
@@ -123,7 +142,7 @@ app_check <- function(appdir = ".", app_type = NULL, runtime_strategy = NULL,
         if (verbose) cli::cli_alert_danger("R: {e$message}")
       })
     }
-    if (app_type %in% PY_TYPES) {
+    if (app_type == "py-shiny") {
       tryCatch({
         validate_python_available()
         if (verbose) cli::cli_alert_success("Python: available")
@@ -153,44 +172,43 @@ app_check <- function(appdir = ".", app_type = NULL, runtime_strategy = NULL,
     })
   }
 
-  # --- Check: R shinylive package (for r-shinylive) ---
-  if (app_type == "r-shinylive") {
-    if (requireNamespace("shinylive", quietly = TRUE)) {
-      if (verbose) cli::cli_alert_success("shinylive R package: installed")
-    } else {
-      errors <- c(errors, "shinylive R package not installed")
-      if (verbose) cli::cli_alert_danger("shinylive R package: not installed")
+  # --- Check: shinylive tooling (only when strategy is shinylive) ---
+  if (runtime_strategy == "shinylive") {
+    if (app_type == "r-shiny") {
+      if (requireNamespace("shinylive", quietly = TRUE)) {
+        if (verbose) cli::cli_alert_success("shinylive R package: installed")
+      } else {
+        errors <- c(errors, "shinylive R package not installed")
+        if (verbose) cli::cli_alert_danger("shinylive R package: not installed")
+      }
+    } else if (app_type == "py-shiny") {
+      tryCatch({
+        validate_python_available()
+        validate_python_shinylive_installed()
+        if (verbose) cli::cli_alert_success("Python shinylive: installed")
+      }, error = function(e) {
+        errors <<- c(errors, e$message)
+        if (verbose) cli::cli_alert_danger("Python shinylive: {e$message}")
+      })
     }
   }
 
-  # --- Check: Python shinylive (for py-shinylive) ---
-  if (app_type == "py-shinylive") {
-    tryCatch({
-      validate_python_available()
-      validate_python_shinylive_installed()
-      if (verbose) cli::cli_alert_success("Python shinylive: installed")
-    }, error = function(e) {
-      errors <<- c(errors, e$message)
-      if (verbose) cli::cli_alert_danger("Python shinylive: {e$message}")
-    })
-  }
-
   # --- Check: Dependencies ---
   tryCatch({
-    dep_result <- resolve_app_dependencies(appdir, app_type, config)
+    dep_result <- resolve_app_dependencies(appdir, app_type, runtime_strategy, config)
     if (!is.null(dep_result) && length(dep_result$packages) > 0) {
       dep_msg <- paste(dep_result$packages, collapse = ", ")
       info <- c(info, paste0("Dependencies (", dep_result$language, "): ", dep_msg))
       if (verbose) cli::cli_alert_success("Dependencies: {dep_msg}")
-    } else if (app_type %in% SHINYLIVE_TYPES) {
-      # For shinylive types, resolve_app_dependencies returns NULL because
-      # shinylive handles its own deps. Still scan for informational purposes.
+    } else if (runtime_strategy == "shinylive") {
+      # shinylive handles its own deps, so resolve_app_dependencies returns NULL.
+      # Still scan for informational purposes.
       detected <- tryCatch({
-        if (grepl("^r-", app_type)) detect_r_dependencies(appdir)
+        if (app_type == "r-shiny") detect_r_dependencies(appdir)
         else detect_py_dependencies(appdir)
       }, error = function(e) character(0))
       if (length(detected) > 0) {
-        lang <- if (grepl("^r-", app_type)) "R" else "Python"
+        lang <- if (app_type == "r-shiny") "R" else "Python"
         dep_msg <- paste(detected, collapse = ", ")
         info <- c(info, paste0("Dependencies (", lang, "): ", dep_msg))
         if (verbose) cli::cli_alert_success("Dependencies: {dep_msg}")
 
@@ -25,22 +25,35 @@ setup_electron_project <- function(output_dir, app_name, app_type, verbose = TRU
 #' @param app_dir Character source app directory
 #' @param output_dir Character destination directory
 #' @param app_type Character application type
+#' @param runtime_strategy Character resolved runtime strategy. When
+#'   `"shinylive"` the source is already a WebAssembly bundle, so the
+#'   Shiny entrypoint sanity check is skipped.
 #' @param verbose Logical whether to show progress
 #' @keywords internal
-copy_app_files <- function(app_dir, output_dir, app_type, verbose = TRUE) {
+copy_app_files <- function(app_dir, output_dir, app_type,
+                           runtime_strategy = NULL, verbose = TRUE) {
   if (verbose) {
     cli::cli_alert_info("Copying application files...")
   }
 
   dest_app_dir <- fs::path(output_dir, "src", "app")
   copy_dir_contents(app_dir, dest_app_dir)
 
+  # For shinylive the source directory holds index.html and WASM assets,
+  # not app.R / app.py, so skip the native-entrypoint sanity check.
+  if (!is.null(runtime_strategy) && runtime_strategy == "shinylive") {
+    if (verbose) {
+      cli::cli_alert_success("Copied application files")
+    }
+    return(invisible(NULL))
+  }
+
   # Sanity check: for native Shiny apps, confirm the entrypoint made it across.
   # Catches copy-layout bugs at build time rather than at runtime inside Electron.
   entry_files <- switch(app_type,
     "r-shiny" = c("app.R", "server.R", "ui.R"),
     "py-shiny" = "app.py",
-    NULL  # shinylive types validate their own output
+    NULL
   )
   if (!is.null(entry_files)) {
     found <- any(fs::file_exists(fs::path(dest_app_dir, entry_files)))
 
@@ -41,20 +41,17 @@ install_npm_dependencies <- function(output_dir, verbose = TRUE) {
 }
 
 
-#' Build for target platforms
-#'
-#' @param output_dir Character Electron project directory
-#' @param platform Character vector of target platforms
-#' @param arch Character vector of target architectures
-#' @param verbose Logical whether to show progress
-#' @keywords internal
-#' Check whether electron-builder produced output for a platform.
+#' Check whether electron-builder produced output for a platform
 #'
 #' electron-builder 26.x has a known bug where the build completes and the
 #' installer is written to disk, but the process then exits with status 1
 #' during post-build publish metadata. When that happens, processx-invoked
 #' npm inherits the non-zero exit even though the .dmg/.exe/.AppImage is
 #' sitting right there. We treat "artifact exists" as success.
+#'
+#' @param output_dir Character Electron project directory
+#' @param p Character platform identifier (`"mac"`, `"win"`, or `"linux"`)
+#' @return Logical: `TRUE` if a platform-specific installer is present.
 #' @keywords internal
 dist_has_platform_artifact <- function(output_dir, p) {
   dist_dir <- fs::path(output_dir, "dist")
@@ -74,6 +71,14 @@ dist_has_platform_artifact <- function(output_dir, p) {
              logical(1)))
 }
 
+#' Build for target platforms
+#'
+#' @param output_dir Character Electron project directory
+#' @param platform Character vector of target platforms
+#' @param arch Character vector of target architectures
+#' @param sign Logical whether to code-sign the build
+#' @param verbose Logical whether to show progress
+#' @keywords internal
 build_for_platforms <- function(output_dir, platform, arch, sign = FALSE, verbose = TRUE) {
   if (verbose) {
     cli::cli_alert_info("Building for platforms: {paste(platform, collapse = ', ')}")
 
@@ -6,9 +6,13 @@
 #' @param app_dir Character string. Path to the converted Shiny/shinylive application.
 #' @param output_dir Character string. Path where the built Electron app will be saved.
 #' @param app_name Character string. Name of the application. If NULL, uses the base name of app_dir.
-#' @param app_type Character string. Type of application: "r-shinylive", "r-shiny", "py-shinylive", or "py-shiny".
-#' @param runtime_strategy Character string. Runtime strategy: "shinylive", "bundled",
-#'   "system", "auto-download", or "container". Default is "shinylive".
+#' @param app_type Character string. Language of the Shiny app: `"r-shiny"` or
+#'   `"py-shiny"`. The legacy values `"r-shinylive"` / `"py-shinylive"` are
+#'   accepted with a deprecation warning and translate to the canonical
+#'   language plus `runtime_strategy = "shinylive"`.
+#' @param runtime_strategy Character string. Runtime strategy: `"shinylive"`,
+#'   `"bundled"`, `"system"`, `"auto-download"`, or `"container"`. Default
+#'   `"shinylive"`.
 #' @param platform Character vector. Target platforms: "win", "mac", "linux". If NULL, builds for current platform.
 #' @param arch Character vector. Target architectures: "x64", "arm64". If NULL, uses current architecture.
 #' @param icon Character string. Path to application icon file. Platform-specific format required.
@@ -37,28 +41,35 @@
 #'   app_dir = "path/to/shinylive/app",
 #'   output_dir = "path/to/electron/build",
 #'   app_name = "My Shiny App",
-#'   app_type = "r-shinylive"
+#'   app_type = "r-shiny"
 #' )
 #'
 #' # Build for multiple platforms
 #' build_electron_app(
 #'   app_dir = "path/to/app",
 #'   output_dir = "path/to/build",
 #'   app_name = "My App",
-#'   app_type = "r-shinylive",
+#'   app_type = "r-shiny",
 #'   platform = c("win", "mac", "linux")
 #' )
 #' }
 #'
 #' @export
-build_electron_app <- function(app_dir, output_dir, app_name = NULL, app_type = "r-shinylive",
+build_electron_app <- function(app_dir, output_dir, app_name = NULL, app_type = "r-shiny",
                                runtime_strategy = "shinylive", sign = FALSE,
                                platform = NULL, arch = NULL, icon = NULL,
                                config = NULL, overwrite = FALSE, verbose = TRUE) {
 
   # Validate inputs
   validate_directory_exists(app_dir, "Application directory")
+
+  # Normalize legacy app_type values
+  normalized <- normalize_app_type_arg(app_type, runtime_strategy)
+  app_type <- normalized$app_type %||% app_type
+  runtime_strategy <- normalized$runtime_strategy %||% runtime_strategy
+
   validate_app_type(app_type)
+  validate_runtime_strategy(runtime_strategy)
 
   if (is.null(app_name)) {
     app_name <- basename(app_dir)
@@ -119,7 +130,8 @@ build_electron_app <- function(app_dir, output_dir, app_name = NULL, app_type =
 
     # Step 2: Copy application files
     if (verbose) cli::cli_progress_update(id = pb, set = 2)
-    copy_app_files(app_dir, output_dir, app_type, verbose = verbose)
+    copy_app_files(app_dir, output_dir, app_type,
+                   runtime_strategy = runtime_strategy, verbose = verbose)
 
     # Step 2.5: Embed R runtime for bundled strategy
     if (runtime_strategy == "bundled" && grepl("^r-", app_type)) {