Only do logic if there is SOMETHING, not NOTHING

.Rbuildignore

@@ -21,17 +21,19 @@
 ^TODO-promises.md$
 ^manualtests$
 ^\.github$
+
+^\.yarn$
 ^\.vscode$
 ^\.madgerc$
+^\.prettierrc\.yml$
+^babel\.config\.json$
+^jest\.config\.js$
 ^package\.json$
 ^tsconfig\.json$
-^package-lock\.json$
+^yarn\.lock$
 ^node_modules$
 ^coverage$
 ^.ignore$
-^eslint\.config\.mjs$
-^_dev$
-^.claude$
-^README-npm\.md$
-^CRAN-SUBMISSION$
-^LICENSE\.md$
+^\.browserslistrc$
+^\.eslintrc\.yml$
+^\.yarnrc\.yml$

.browserslistrc

@@ -0,0 +1,8 @@
+# Browsers that we support
+last 2 versions
+not dead
+> 0.2%
+# > 1%
+Firefox ESR
+phantomjs 2.1
+IE 11 # sorry

.eslintrc.yml

@@ -0,0 +1,108 @@
+root: true
+env:
+  browser: true
+  es6: true
+extends:
+  - 'eslint:recommended'
+  - 'plugin:@typescript-eslint/recommended'
+  - 'plugin:jest/recommended'
+  - 'prettier/@typescript-eslint'
+  - 'plugin:prettier/recommended'
+  - 'plugin:jest-dom/recommended'
+globals:
+  Atomics: readonly
+  SharedArrayBuffer: readonly
+parser: '@typescript-eslint/parser'
+parserOptions:
+  ecmaVersion: 2018
+  sourceType: module
+plugins:
+  - '@typescript-eslint'
+  - prettier
+  - jest-dom
+  - unicorn
+rules:
+  "@typescript-eslint/explicit-function-return-type":
+    - off
+  "@typescript-eslint/no-explicit-any":
+    - off
+  "@typescript-eslint/explicit-module-boundary-types":
+    - error
+
+  default-case:
+    - error
+  indent:
+    - error
+    - 2
+    - SwitchCase: 1
+  linebreak-style:
+    - error
+    - unix
+  quotes:
+    - error
+    - double
+    - avoid-escape
+  semi:
+    - error
+    - always
+  newline-after-var:
+    - error
+    - always
+  dot-location:
+    - error
+    - property
+
+  camelcase:
+    # - error
+    - "off"
+
+  unicorn/filename-case:
+    - error
+    - case: camelCase
+
+  "@typescript-eslint/array-type":
+    - error
+    - default: array-simple
+      readonly: array-simple
+  "@typescript-eslint/consistent-indexed-object-style":
+    - error
+    - index-signature
+
+  "@typescript-eslint/sort-type-union-intersection-members":
+    - error
+
+  "@typescript-eslint/consistent-type-imports":
+    - error
+  "@typescript-eslint/naming-convention":
+    - error
+
+    - selector: default
+      format: [camelCase]
+
+    - selector: method
+      modifiers: [private]
+      format: [camelCase]
+      leadingUnderscore: require
+    - selector: method
+      modifiers: [protected]
+      format: [camelCase]
+      leadingUnderscore: require
+
+    - selector: variable
+      format: [camelCase]
+      trailingUnderscore: forbid
+      leadingUnderscore: forbid
+
+    - selector: parameter
+      format: [camelCase]
+      trailingUnderscore: allow
+      leadingUnderscore: forbid
+
+    - selector: [enum, enumMember]
+      format: [PascalCase]
+
+    - selector: typeLike
+      format: [PascalCase]
+      custom:
+        regex: "(t|T)ype$"
+        match: false

.github/ISSUE_TEMPLATE/question.md

@@ -1,7 +1,7 @@
 ---
 name  : Ask a Question
-about : The issue tracker is not for questions -- please ask questions at https://forum.posit.co/tags/shiny.
+about : The issue tracker is not for questions -- please ask questions at https://community.rstudio.com/c/shiny.
 ---
 
-The issue tracker is not for questions. If you have a question, please feel free to ask it on our community site, at https://forum.posit.co/c/shiny.
+The issue tracker is not for questions. If you have a question, please feel free to ask it on our community site, at https://community.rstudio.com/c/shiny.
 

.github/shiny-workflows/routine.sh

@@ -1,13 +0,0 @@
-#!/bin/bash -e
-. ./tools/documentation/checkDocsCurrent.sh
-
-echo "Updating package.json version to match DESCRIPTION Version"
-Rscript ./tools/updatePackageJsonVersion.R
-if [ -n "$(git status --porcelain package.json)" ]
-then
-  echo "package.json has changed after running ./tools/updatePackageJsonVersion.R. Re-running 'npm run build'"
-  npm run build
-  git add ./inst package.json && git commit -m 'Sync package version (GitHub Actions)' || echo "No package version to commit"
-else
-  echo "No package version difference detected; package.json is current."
-fi

.github/workflows/R-CMD-check.yaml

@@ -1,25 +1,150 @@
-# Workflow derived from https://github.com/rstudio/shiny-workflows
-#
-# NOTE: This Shiny team GHA workflow is overkill for most R packages.
-# For most R packages it is better to use https://github.com/r-lib/actions
+name: R-CMD-check
 on:
   push:
-    branches: [main, rc-**]
+    branches:
+      - master
   pull_request:
     branches:
-  schedule:
-    - cron: "0 5 * * 1" # every monday
+      - master
 
-name: Package checks
 
 jobs:
-  website:
-    uses: rstudio/shiny-workflows/.github/workflows/website.yaml@v1
-  routine:
-    uses: rstudio/shiny-workflows/.github/workflows/routine.yaml@v1
+
   R-CMD-check:
-    uses: rstudio/shiny-workflows/.github/workflows/R-CMD-check.yaml@v1
-    with:
-      # On R 4.2, Cairo has difficulty installing
-      # Remove this line when https://github.com/s-u/Cairo/issues/52 is merged
-      extra-packages: Cairo=?ignore
+    runs-on: ${{ matrix.config.os }}
+
+    name: ${{ matrix.config.os }} (${{ matrix.config.r }})
+
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+          - {os: macOS-latest,   r: 'devel'}
+          - {os: macOS-latest,   r: '4.0'}
+          - {os: windows-latest, r: '4.0'}
+          - {os: ubuntu-16.04,   r: '4.0', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
+          - {os: ubuntu-16.04,   r: '3.6', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
+          - {os: ubuntu-16.04,   r: '3.5', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
+          - {os: ubuntu-16.04,   r: '3.4', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
+          - {os: ubuntu-16.04,   r: '3.3', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
+
+    env:
+      _R_CHECK_FORCE_SUGGESTS_: false
+      R_REMOTES_NO_ERRORS_FROM_WARNINGS: true
+      RSPM: ${{ matrix.config.rspm }}
+      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
+
+    steps:
+      # https://github.com/actions/checkout/issues/135
+      - name: Set git to use LF
+        if: runner.os == 'Windows'
+        run: |
+          git config --system core.autocrlf false
+          git config --system core.eol lf
+
+      - uses: actions/checkout@v2
+
+      - uses: r-lib/actions/setup-r@master
+        id: install-r
+        with:
+          r-version: ${{ matrix.config.r }}
+
+      - uses: r-lib/actions/setup-pandoc@master
+
+      - name: Install pak and query dependencies
+        shell: Rscript {0}
+        run: |
+          install.packages("pak", repos = "https://r-lib.github.io/p/pak/dev/")
+          saveRDS(pak::pkg_deps_tree("local::.", dependencies = TRUE), ".github/r-depends.rds")
+
+      - name: Cache R packages
+        uses: actions/cache@v2
+        with:
+          path: ${{ env.R_LIBS_USER }}
+          key: ${{ matrix.config.os }}-${{ steps.install-r.outputs.installed-r-version }}-1-${{ hashFiles('.github/r-depends.rds') }}
+          restore-keys: ${{ matrix.config.os }}-${{ steps.install-r.outputs.installed-r-version }}-1-
+
+      - name: Install system dependencies
+        if: runner.os == 'Linux'
+        shell: Rscript {0}
+        run: |
+          pak::local_system_requirements(execute = TRUE)
+      
+      # https://stackoverflow.com/a/66568545/591574
+      #> fatal error: 'X11/Intrinsic.h' file not found
+      - name: Install Cairo macOS R devel dependency
+        if: runner.os == 'macOS' && matrix.config.r == 'devel'
+        run: |
+          brew install libxt
+
+      # xquartz and cairo are needed for Cairo package.
+      # harfbuzz and fribidi are needed for textshaping package.
+      - name: Mac systemdeps
+        if: runner.os == 'macOS'
+        run: |
+          brew install --cask xquartz
+          brew install cairo
+          brew install harfbuzz fribidi
+
+      # Use a shorter temp directory for pak installations, due to filename
+      # length issues on Windows. https://github.com/r-lib/pak/issues/252
+      - name: Windows temp dir
+        if: runner.os == 'Windows'
+        run: |
+          New-Item -Path "C:\" -Name "tmp" -ItemType Directory
+          echo "TMPDIR=c:\tmp" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+      - name: Install dependencies
+        run: |
+          pak::local_install_dev_deps(upgrade = TRUE)
+          pak::pkg_install("rcmdcheck")
+        shell: Rscript {0}
+
+      - name: Find PhantomJS path
+        id: phantomjs
+        run: |
+          echo "::set-output name=path::$(Rscript -e 'cat(shinytest:::phantom_paths()[[1]])')"
+      - name: Cache PhantomJS
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.phantomjs.outputs.path }}
+          key: ${{ matrix.config.os }}-phantomjs
+          restore-keys: ${{ matrix.config.os }}-phantomjs
+      - name: Install PhantomJS
+        run: >
+          Rscript
+          -e "if (!shinytest::dependenciesInstalled()) shinytest::installDependencies()"
+
+      - name: Session info
+        run: |
+          options(width = 100)
+          pkgs <- installed.packages()[, "Package"]
+          sessioninfo::session_info(pkgs, include_base = TRUE)
+        shell: Rscript {0}
+
+      - name: Check
+        env:
+          _R_CHECK_CRAN_INCOMING_: false
+          _R_CHECK_FORCE_SUGGESTS_: ${{ matrix.config.r != 'devel' }}
+        run: rcmdcheck::rcmdcheck(args = c("--no-manual", "--as-cran"), error_on = "warning", check_dir = "check")
+        shell: Rscript {0}
+
+      - name: Show testthat output
+        if: always()
+        run: find check -name 'testthat.Rout*' -exec cat '{}' \; || true
+        shell: bash
+
+      - name: Upload check results
+        if: failure()
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ matrix.config.os }}-r${{ matrix.config.r }}-results
+          path: check
+
+      - name: Fix path for Windows caching
+        if: runner.os == 'Windows'
+        # This is needed because if you use the default tar at this stage,
+        # C:/Rtools/bin/tar.exe, it will say that it can't find gzip.exe. So
+        # we'll just set the path so that the original tar that would be
+        # found, will be found.
+        run: echo "C:/Program Files/Git/usr/bin" >> $GITHUB_PATH

.github/workflows/rituals.yaml

@@ -0,0 +1,172 @@
+on:
+  push:
+    branches:
+      - master
+      - ghactions
+  pull_request:
+    branches:
+      - master
+
+name: Rituals
+
+jobs:
+  rituals:
+    name: Rituals
+    # if: false
+    runs-on: ${{ matrix.config.os }}
+
+
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+        - { os: ubuntu-16.04, r: '4.0', node: "14.x", rspm: "https://packagemanager.rstudio.com/all/__linux__/xenial/latest"}
+
+    env:
+      R_REMOTES_NO_ERRORS_FROM_WARNINGS: true
+      RSPM: ${{ matrix.config.rspm }}
+      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
+
+    steps:
+      - uses: actions/checkout@v1
+
+      - uses: r-lib/actions/pr-fetch@master
+        name: Git Pull (PR)
+        if: github.event_name == 'pull_request'
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: r-lib/actions/setup-r@master
+        id: install-r
+        with:
+          r-version: ${{ matrix.config.r }}
+
+      - uses: r-lib/actions/setup-pandoc@master
+
+      - name: Git Config
+        run: |
+          git config user.name "${GITHUB_ACTOR}"
+          git config user.email "${GITHUB_ACTOR}@users.noreply.github.com"
+
+      - name: Install pak and query dependencies
+        shell: Rscript {0}
+        run: |
+          install.packages("pak", repos = "https://r-lib.github.io/p/pak/dev/")
+          saveRDS(pak::pkg_deps_tree("local::.", dependencies = TRUE), ".github/r-depends.rds")
+
+      - name: Cache R packages
+        uses: actions/cache@v2
+        with:
+          path: ${{ env.R_LIBS_USER }}
+          key: ${{ matrix.config.os }}-${{ steps.install-r.outputs.installed-r-version }}-1-${{ hashFiles('.github/r-depends.rds') }}
+          restore-keys: ${{ matrix.config.os }}-${{ steps.install-r.outputs.installed-r-version }}-1-
+
+      - name: Install system dependencies
+        # if: runner.os == 'Linux'
+        shell: Rscript {0}
+        run: |
+          pak::local_system_requirements(execute = TRUE)
+
+      - name: Install dependencies
+        shell: Rscript {0}
+        run: |
+          pak::local_install_dev_deps(upgrade = TRUE)
+
+      - name: Session info
+        shell: Rscript {0}
+        run: |
+          options(width = 100)
+          pak::pkg_install("sessioninfo")
+          pkgs <- installed.packages()[, "Package"]
+          sessioninfo::session_info(pkgs, include_base = TRUE)
+
+      - name: Url redirects
+        # only perform if in an RC branch (`rc-vX.Y.Z`)
+        if: ${{ github.event_name == 'push' && contains(github.ref, '/rc-v') }}
+        run: |
+          Rscript -e 'pak::pkg_install("r-lib/urlchecker"); urlchecker::url_update()'
+          # throw an error if man files were updated
+          if [ -n "$(git status --porcelain man)" ]
+          then
+            git status --porcelain
+            >&2 echo "Updated links found in files above"
+            >&2 echo 'Run `urlchecker::url_update()` to fix links locally'
+            exit 1
+          fi
+          # Add locally changed urls
+          git add .
+          git commit -m 'Update links (GitHub Actions)' || echo "No link changes to commit"
+
+      - name: Document
+        run: |
+          Rscript -e 'pak::pkg_install("devtools")'
+          Rscript -e 'devtools::document()'
+          git add man/\* NAMESPACE
+          git commit -m 'Document (GitHub Actions)' || echo "No documentation changes to commit"
+
+      - name: Check documentation
+        run: |
+          ./tools/documentation/checkDocsCurrent.sh
+
+      - uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.config.node }}
+      # https://github.com/actions/cache/blame/ccf96194800dbb7b7094edcd5a7cf3ec3c270f10/examples.md#L185-L200
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+      - name: yarn cache
+        uses: actions/cache@v2
+        id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ matrix.config.os }}-${{ matrix.config.node }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ matrix.config.os }}-${{ matrix.config.node }}-yarn-
+
+      - name: Sync DESCRIPTION and package.json versions
+        run: |
+          Rscript -e 'pak::pkg_install("jsonlite")'
+          Rscript -e 'pkg <- jsonlite::read_json("package.json", simplifyVector = TRUE)' \
+          -e 'version <- as.list(read.dcf("DESCRIPTION")[1,])$Version' \
+          -e 'pkg$version <- gsub("^(\\d+).(\\d+).(\\d+).(.+)$", "\\1.\\2.\\3-alpha.\\4", version)' \
+          -e 'pkg$files <- as.list(pkg$files)' \
+          -e 'jsonlite::write_json(pkg, path = "package.json", pretty = TRUE, auto_unbox = TRUE)'
+          git add package.json && git commit -m 'sync package version (GitHub Actions)' || echo "No version changes to commit"
+      - name: Build JS
+        run: |
+          tree srcts
+          rm -r srcts/types
+          yarn install --immutable && yarn build
+          git add ./srcts/src && git commit -m 'yarn lint (GitHub Actions)' || echo "No yarn lint changes to commit"
+          git add ./srcts/types && git commit -m 'yarn tsc (GitHub Actions)' || echo "No type definition changes to commit"
+          git add ./inst && git commit -m 'yarn build (GitHub Actions)' || echo "No yarn build changes to commit"
+          if [ -n "$(git status --porcelain)" ]
+          then
+            git status --porcelain
+            >&2 echo "The above files changed when we built the JavaScript assets."
+            exit 1
+          else
+            echo "No difference detected; TypeScript build is current."
+          fi
+
+      - name: Git Push (PR)
+        uses: r-lib/actions/pr-push@master
+        if: github.event_name == 'pull_request'
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Verify no un-pushed commits (MASTER)
+        if: github.event_name == 'push'
+        run: |
+          # Can't push to a protected branch
+          if [ -n "`git cherry origin/master`"]; then
+            echo "Un-pushed commits:"
+            git cherry -v origin/master
+            echo "\nCan not push to a protected branch. Exiting"
+            exit 1
+          fi
+
+      # Execute after pushing, as no updated files will be produced
+      - name: Test TypeScript code
+        run: |
+          yarn test

.gitignore

@@ -9,16 +9,20 @@
 shinyapps/
 README.html
 .*.Rnb.cached
-/_dev/
-.sass_cache_keys
+tools/yarn-error.log
 
-# TypeScript
-/node_modules/
+# TypeScript / yarn
+node_modules/
 .cache
+.yarn/*
+!.yarn/releases
+!.yarn/plugins
+!.yarn/sdks
+!.yarn/versions
+.pnp.*
 coverage/
 madge.svg
 
 
 # GHA remotes installation
 .github/r-depends.rds
-.claude/settings.local.json

.prettierrc.yml

@@ -0,0 +1,3 @@
+trailingComma: "es5"
+arrowParens: always
+endOfLine: lf

.vscode/extensions.json

@@ -1,5 +1,6 @@
 {
   "recommendations": [
+    "arcanis.vscode-zipfs",
     "dbaeumer.vscode-eslint",
     "esbenp.prettier-vscode"
   ]

.vscode/settings.json

@@ -1,23 +1,10 @@
 {
+  "typescript.tsdk": ".yarn/sdks/typescript/lib",
   "search.exclude": {
+    "**/.yarn": true,
+    "**/.pnp.*": true
   },
-  "prettier.prettierPath": "./node_modules/prettier",
-  "typescript.enablePromptUseWorkspaceTsdk": true,
-  "[r]": {
-    "files.trimTrailingWhitespace": true,
-    "files.insertFinalNewline": true,
-    "editor.formatOnSave": false,
-  },
-  "[typescript]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode",
-    "editor.formatOnSave": true,
-    "files.trimTrailingWhitespace": true,
-    "files.insertFinalNewline": true,
-  },
-  "[json]": {
-    "editor.formatOnSave": true,
-    "editor.defaultFormatter": "esbenp.prettier-vscode",
-    "files.trimTrailingWhitespace": true,
-    "files.insertFinalNewline": true,
-},
+  "eslint.nodePath": ".yarn/sdks",
+  "prettier.prettierPath": ".yarn/sdks/prettier/index.js",
+  "typescript.enablePromptUseWorkspaceTsdk": true
 }

.yarnrc.yml

@@ -0,0 +1,9 @@
+nodeLinker: node-modules
+
+plugins:
+  - path: .yarn/plugins/@yarnpkg/plugin-outdated.cjs
+    spec: "https://github.com/mskelton/yarn-plugin-outdated/raw/main/bundles/@yarnpkg/plugin-outdated.js"
+  - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
+    spec: "@yarnpkg/plugin-interactive-tools"
+
+yarnPath: .yarn/releases/yarn-2.4.0.cjs

DESCRIPTION

@@ -1,130 +1,123 @@
-Type: Package
 Package: shiny
+Type: Package
 Title: Web Application Framework for R
-Version: 1.12.1.9000
+Version: 1.6.0.9022
 Authors@R: c(
-    person("Winston", "Chang", , "winston@posit.co", role = "aut",
-           comment = c(ORCID = "0000-0002-1576-2126")),
-    person("Joe", "Cheng", , "joe@posit.co", role = "aut"),
-    person("JJ", "Allaire", , "jj@posit.co", role = "aut"),
-    person("Carson", "Sievert", , "carson@posit.co", role = c("aut", "cre"),
-           comment = c(ORCID = "0000-0002-4958-2844")),
-    person("Barret", "Schloerke", , "barret@posit.co", role = "aut",
-           comment = c(ORCID = "0000-0001-9986-114X")),
-    person("Garrick", "Aden-Buie", , "garrick@adenbuie.com", role = "aut",
-           comment = c(ORCID = "0000-0002-7111-0077")),
-    person("Yihui", "Xie", , "yihui@posit.co", role = "aut"),
-    person("Jeff", "Allen", role = "aut"),
-    person("Jonathan", "McPherson", , "jonathan@posit.co", role = "aut"),
+    person("Winston", "Chang", role = c("aut", "cre"), email = "winston@rstudio.com", comment = c(ORCID = "0000-0002-1576-2126")),
+    person("Joe", "Cheng", role = "aut", email = "joe@rstudio.com"),
+    person("JJ", "Allaire", role = "aut", email = "jj@rstudio.com"),
+    person("Carson", "Sievert", role = "aut", email = "carson@rstudio.com", comment = c(ORCID = "0000-0002-4958-2844")),
+    person("Barret", "Schloerke", role = "aut", email = "barret@rstudio.com", comment = c(ORCID = "0000-0001-9986-114X")),
+    person("Yihui", "Xie", role = "aut", email = "yihui@rstudio.com"),
+    person("Jeff", "Allen", role = "aut", email = "jeff@rstudio.com"),
+    person("Jonathan", "McPherson", role = "aut", email = "jonathan@rstudio.com"),
     person("Alan", "Dipert", role = "aut"),
     person("Barbara", "Borges", role = "aut"),
-    person("Posit Software, PBC", role = c("cph", "fnd"),
-           comment = c(ROR = "03wc8by49")),
-    person(, "jQuery Foundation", role = "cph",
-           comment = "jQuery library and jQuery UI library"),
-    person(, "jQuery contributors", role = c("ctb", "cph"),
-           comment = "jQuery library; authors listed in inst/www/shared/jquery-AUTHORS.txt"),
-    person(, "jQuery UI contributors", role = c("ctb", "cph"),
-           comment = "jQuery UI library; authors listed in inst/www/shared/jqueryui/AUTHORS.txt"),
+    person(family = "RStudio", role = "cph"),
+    person(family = "jQuery Foundation", role = "cph",
+    comment = "jQuery library and jQuery UI library"),
+    person(family = "jQuery contributors", role = c("ctb", "cph"),
+    comment = "jQuery library; authors listed in inst/www/shared/jquery-AUTHORS.txt"),
+    person(family = "jQuery UI contributors", role = c("ctb", "cph"),
+    comment = "jQuery UI library; authors listed in inst/www/shared/jqueryui/AUTHORS.txt"),
     person("Mark", "Otto", role = "ctb",
-           comment = "Bootstrap library"),
+    comment = "Bootstrap library"),
     person("Jacob", "Thornton", role = "ctb",
-           comment = "Bootstrap library"),
-    person(, "Bootstrap contributors", role = "ctb",
-           comment = "Bootstrap library"),
-    person(, "Twitter, Inc", role = "cph",
-           comment = "Bootstrap library"),
+    comment = "Bootstrap library"),
+    person(family = "Bootstrap contributors", role = "ctb",
+    comment = "Bootstrap library"),
+    person(family = "Twitter, Inc", role = "cph",
+    comment = "Bootstrap library"),
     person("Prem Nawaz", "Khan", role = "ctb",
-           comment = "Bootstrap accessibility plugin"),
+    comment = "Bootstrap accessibility plugin"),
     person("Victor", "Tsaran", role = "ctb",
-           comment = "Bootstrap accessibility plugin"),
+    comment = "Bootstrap accessibility plugin"),
     person("Dennis", "Lembree", role = "ctb",
-           comment = "Bootstrap accessibility plugin"),
+    comment = "Bootstrap accessibility plugin"),
     person("Srinivasu", "Chakravarthula", role = "ctb",
-           comment = "Bootstrap accessibility plugin"),
+    comment = "Bootstrap accessibility plugin"),
     person("Cathy", "O'Connor", role = "ctb",
-           comment = "Bootstrap accessibility plugin"),
-    person(, "PayPal, Inc", role = "cph",
-           comment = "Bootstrap accessibility plugin"),
+    comment = "Bootstrap accessibility plugin"),
+    person(family = "PayPal, Inc", role = "cph",
+    comment = "Bootstrap accessibility plugin"),
     person("Stefan", "Petre", role = c("ctb", "cph"),
-           comment = "Bootstrap-datepicker library"),
+    comment = "Bootstrap-datepicker library"),
     person("Andrew", "Rowls", role = c("ctb", "cph"),
-           comment = "Bootstrap-datepicker library"),
+    comment = "Bootstrap-datepicker library"),
     person("Brian", "Reavis", role = c("ctb", "cph"),
-           comment = "selectize.js library"),
+    comment = "selectize.js library"),
     person("Salmen", "Bejaoui", role = c("ctb", "cph"),
-           comment = "selectize-plugin-a11y library"),
+    comment = "selectize-plugin-a11y library"),
     person("Denis", "Ineshin", role = c("ctb", "cph"),
-           comment = "ion.rangeSlider library"),
+    comment = "ion.rangeSlider library"),
     person("Sami", "Samhuri", role = c("ctb", "cph"),
-           comment = "Javascript strftime library"),
-    person(, "SpryMedia Limited", role = c("ctb", "cph"),
-           comment = "DataTables library"),
+    comment = "Javascript strftime library"),
+    person(family = "SpryMedia Limited", role = c("ctb", "cph"),
+    comment = "DataTables library"),
+    person("John", "Fraser", role = c("ctb", "cph"),
+    comment = "showdown.js library"),
+    person("John", "Gruber", role = c("ctb", "cph"),
+    comment = "showdown.js library"),
     person("Ivan", "Sagalaev", role = c("ctb", "cph"),
-           comment = "highlight.js library"),
-    person("R Core Team", role = c("ctb", "cph"),
-           comment = "tar implementation from R")
-  )
+    comment = "highlight.js library"),
+    person(family = "R Core Team", role = c("ctb", "cph"),
+    comment = "tar implementation from R")
+    )
 Description: Makes it incredibly easy to build interactive web
     applications with R. Automatic "reactive" binding between inputs and
     outputs and extensive prebuilt widgets make it possible to build
     beautiful, responsive, and powerful applications with minimal effort.
-License: MIT + file LICENSE
-URL: https://shiny.posit.co/, https://github.com/rstudio/shiny
-BugReports: https://github.com/rstudio/shiny/issues
+License: GPL-3 | file LICENSE
 Depends:
-    methods,
-    R (>= 3.0.2)
+    R (>= 3.0.2),
+    methods
 Imports:
-    bslib (>= 0.6.0),
-    cachem (>= 1.1.0),
-    cli,
-    commonmark (>= 2.0.0),
-    fastmap (>= 1.1.1),
-    fontawesome (>= 0.4.0),
-    glue (>= 1.3.2),
-    grDevices,
-    htmltools (>= 0.5.4),
-    httpuv (>= 1.5.2),
-    jsonlite (>= 0.9.16),
-    later (>= 1.0.0),
-    lifecycle (>= 0.2.0),
-    mime (>= 0.3),
-    otel,
-    promises (>= 1.5.0),
-    R6 (>= 2.0),
-    rlang (>= 0.4.10),
-    sourcetools,
-    tools,
     utils,
+    grDevices,
+    httpuv (>= 1.5.2),
+    mime (>= 0.3),
+    jsonlite (>= 0.9.16),
+    xtable,
+    fontawesome (>= 0.2.1),
+    htmltools (>= 0.5.1.9003),
+    R6 (>= 2.0),
+    sourcetools,
+    later (>= 1.0.0),
+    promises (>= 1.1.0),
+    tools,
+    crayon,
+    rlang (>= 0.4.10),
+    fastmap (>= 1.1.0),
     withr,
-    xtable
+    commonmark (>= 1.7),
+    glue (>= 1.3.2),
+    bslib (>= 0.2.5.9002),
+    cachem,
+    ellipsis,
+    lifecycle (>= 0.2.0)
 Suggests:
-    Cairo (>= 1.5-5),
-    coro (>= 1.1.0),
     datasets,
-    DT,
-    dygraphs,
-    future,
-    ggplot2,
+    Cairo (>= 1.5-5),
+    testthat (>= 3.0.0),
     knitr (>= 1.6),
-    magrittr,
     markdown,
-    mirai,
-    otelsdk (>= 0.2.0),
-    ragg,
-    reactlog (>= 1.0.0),
     rmarkdown,
-    sass,
+    ggplot2,
+    reactlog (>= 1.0.0),
+    magrittr,
+    shinytest (>= 1.4.0.9003),
+    yaml,
+    future,
+    dygraphs,
+    ragg,
     showtext,
-    testthat (>= 3.2.1),
-    watcher,
-    yaml
-Config/Needs/check: shinytest2
-Config/testthat/edition: 3
-Encoding: UTF-8
-Roxygen: list(markdown = TRUE)
-RoxygenNote: 7.3.3
+    sass
+Remotes:
+    r-lib/rlang,
+    rstudio/bslib,
+    rstudio/htmltools
+URL: https://shiny.rstudio.com/
+BugReports: https://github.com/rstudio/shiny/issues
 Collate:
     'globals.R'
     'app-state.R'
@@ -139,13 +132,10 @@ Collate:
     'map.R'
     'utils.R'
     'bootstrap.R'
-    'busy-indicators-spinners.R'
-    'busy-indicators.R'
     'cache-utils.R'
     'deprecated.R'
     'devmode.R'
     'diagnose.R'
-    'extended-task.R'
     'fileupload.R'
     'graph.R'
     'reactives.R'
@@ -183,15 +173,6 @@ Collate:
     'modal.R'
     'modules.R'
     'notifications.R'
-    'otel-attr-srcref.R'
-    'otel-collect.R'
-    'otel-enable.R'
-    'otel-error.R'
-    'otel-label.R'
-    'otel-reactive-update.R'
-    'otel-session.R'
-    'otel-shiny.R'
-    'otel-with.R'
     'priorityqueue.R'
     'progress.R'
     'react.R'
@@ -212,18 +193,20 @@ Collate:
     'shinywrappers.R'
     'showcase.R'
     'snapshot.R'
-    'staticimports.R'
     'tar.R'
     'test-export.R'
     'test-server.R'
     'test.R'
     'update-input.R'
     'utils-lang.R'
-    'utils-tags.R'
     'version_bs_date_picker.R'
     'version_ion_range_slider.R'
     'version_jquery.R'
-    'version_jqueryui.R'
     'version_selectize.R'
     'version_strftime.R'
     'viewer.R'
+RoxygenNote: 7.1.1
+Encoding: UTF-8
+Roxygen: list(markdown = TRUE)
+RdMacros: lifecycle
+Config/testthat/edition: 3

LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2025 shiny authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

NAMESPACE

@@ -19,7 +19,6 @@ S3method("[[",shinyoutput)
 S3method("[[<-",reactivevalues)
 S3method("[[<-",shinyoutput)
 S3method("names<-",reactivevalues)
-S3method(as.list,Map)
 S3method(as.list,reactivevalues)
 S3method(as.shiny.appobj,character)
 S3method(as.shiny.appobj,list)
@@ -44,7 +43,6 @@ S3method(bindEvent,reactiveExpr)
 S3method(bindEvent,shiny.render.function)
 S3method(format,reactiveExpr)
 S3method(format,reactiveVal)
-S3method(length,Map)
 S3method(names,reactivevalues)
 S3method(print,reactive)
 S3method(print,reactivevalues)
@@ -55,7 +53,6 @@ S3method(str,reactivevalues)
 export("conditionStackTrace<-")
 export(..stacktraceoff..)
 export(..stacktraceon..)
-export(ExtendedTask)
 export(HTML)
 export(MockShinySession)
 export(NS)
@@ -78,7 +75,6 @@ export(br)
 export(browserViewer)
 export(brushOpts)
 export(brushedPoints)
-export(busyIndicatorOptions)
 export(callModule)
 export(captureStackTraces)
 export(checkboxGroupInput)
@@ -165,7 +161,6 @@ export(isTruthy)
 export(isolate)
 export(key_missing)
 export(loadSupport)
-export(localOtelCollect)
 export(mainPanel)
 export(makeReactiveBinding)
 export(markRenderFunction)
@@ -193,7 +188,6 @@ export(onRestore)
 export(onRestored)
 export(onSessionEnded)
 export(onStop)
-export(onUnhandledError)
 export(outputOptions)
 export(p)
 export(pageWithSidebar)
@@ -217,7 +211,6 @@ export(reactiveVal)
 export(reactiveValues)
 export(reactiveValuesToList)
 export(reactlog)
-export(reactlogAddMark)
 export(reactlogReset)
 export(reactlogShow)
 export(registerInputHandler)
@@ -320,7 +313,6 @@ export(updateTextInput)
 export(updateVarSelectInput)
 export(updateVarSelectizeInput)
 export(urlModal)
-export(useBusyIndicators)
 export(validate)
 export(validateCssUnit)
 export(varSelectInput)
@@ -330,7 +322,6 @@ export(verticalLayout)
 export(wellPanel)
 export(withLogErrors)
 export(withMathJax)
-export(withOtelCollect)
 export(withProgress)
 export(withReactiveDomain)
 export(withTags)
@@ -341,6 +332,8 @@ import(httpuv)
 import(methods)
 import(mime)
 import(xtable)
+importFrom(ellipsis,check_dots_empty)
+importFrom(ellipsis,check_dots_unnamed)
 importFrom(fastmap,fastmap)
 importFrom(fastmap,is.key_missing)
 importFrom(fastmap,key_missing)
@@ -389,20 +382,15 @@ importFrom(lifecycle,is_present)
 importFrom(promises,"%...!%")
 importFrom(promises,"%...>%")
 importFrom(promises,as.promise)
-importFrom(promises,hybrid_then)
-importFrom(promises,is.promise)
 importFrom(promises,is.promising)
-importFrom(promises,new_promise_domain)
+importFrom(promises,promise)
 importFrom(promises,promise_reject)
 importFrom(promises,promise_resolve)
-importFrom(promises,with_promise_domain)
 importFrom(rlang,"%||%")
 importFrom(rlang,"fn_body<-")
 importFrom(rlang,"fn_fmls<-")
 importFrom(rlang,as_function)
 importFrom(rlang,as_quosure)
-importFrom(rlang,check_dots_empty)
-importFrom(rlang,check_dots_unnamed)
 importFrom(rlang,enexpr)
 importFrom(rlang,enquo)
 importFrom(rlang,enquo0)

R/app_template.R

@@ -10,7 +10,8 @@
 #' 2: app.R              : Main application file
 #' 3: R/example.R        : Helper file with R code
 #' 4: R/example-module.R : Example module
-#' 5: tests/testthat/    : Tests using the testthat and shinytest2 package
+#' 5: tests/shinytest/   : Tests using the shinytest package
+#' 6: tests/testthat/    : Tests using the testthat package
 #' ```
 #'
 #' If option 1 is selected, the full example application including the
@@ -23,12 +24,13 @@
 #' |   |- example-module.R
 #' |   `- example.R
 #' `- tests
+#'     |- shinytest.R
+#'     |- shinytest
+#'     |   `- mytest.R
 #'     |- testthat.R
 #'     `- testthat
-#'         |- setup-shinytest2.R
 #'         |- test-examplemodule.R
 #'         |- test-server.R
-#'         |- test-shinytest2.R
 #'         `- test-sort.R
 #' ```
 #'
@@ -43,21 +45,20 @@
 #' * `tests/` contains various tests for the application. You may
 #'   choose to use or remove any of them. They can be executed by the
 #'   [runTests()] function.
+#' * `tests/shinytest.R` is a test runner for test files in the
+#'   `tests/shinytest/` directory.
+#' * `tests/shinytest/mytest.R` is a test that uses the
+#'   [shinytest](https://rstudio.github.io/shinytest/) package to do
+#'   snapshot-based testing.
 #' * `tests/testthat.R` is a test runner for test files in the
-#'   `tests/testthat/` directory using the
-#'   [shinytest2](https://rstudio.github.io/shinytest2/reference/test_app.html)
-#'   package.
-#' * `tests/testthat/setup-shinytest2.R` is setup file to source your `./R` folder into the testing environment.
+#'   `tests/testthat/` directory using the [testthat](https://testthat.r-lib.org/) package.
 #' * `tests/testthat/test-examplemodule.R` is a test for an application's module server function.
 #' * `tests/testthat/test-server.R` is a test for the application's server code
-#' * `tests/testthat/test-shinytest2.R` is a test that uses the
-#'   [shinytest2](https://rstudio.github.io/shinytest2/) package to do
-#'   snapshot-based testing.
 #' * `tests/testthat/test-sort.R` is a test for a supporting function in the `R/` directory.
 #'
 #' @param path Path to create new shiny application template.
 #' @param examples Either one of "default", "ask", "all", or any combination of
-#'   "app", "rdir", "module", and "tests". In an
+#'   "app", "rdir", "module", "shinytest", and "testthat". In an
 #'   interactive session, "default" falls back to "ask"; in a non-interactive
 #'   session, "default" falls back to "all". With "ask", this function will
 #'   prompt the user to select which template items will be added to the new app
@@ -78,19 +79,15 @@ shinyAppTemplate <- function(path = NULL, examples = "default", dryrun = FALSE)
   # =======================================================
 
   choices <- c(
-    app    = "app.R              : Main application file",
-    rdir   = "R/example.R        : Helper file with R code",
-    module = "R/example-module.R : Example module",
-    tests  = "tests/testthat/    : Tests using {testthat} and {shinytest2}"
+    app       = "app.R              : Main application file",
+    rdir      = "R/example.R        : Helper file with R code",
+    module    = "R/example-module.R : Example module",
+    shinytest = "tests/shinytest/   : Tests using the shinytest package",
+    testthat  = "tests/testthat/    : Tests using the testthat package"
   )
 
-  # Support legacy value
-  examples[examples == "shinytest"] <- "tests"
-  examples[examples == "testthat"] <- "tests"
-  examples <- unique(examples)
-
   if (identical(examples, "default")) {
-    if (rlang::is_interactive()) {
+    if (interactive()) {
       examples <- "ask"
     } else {
       examples <- "all"
@@ -127,8 +124,18 @@ shinyAppTemplate <- function(path = NULL, examples = "default", dryrun = FALSE)
     return(invisible())
   }
 
-  if ("tests" %in% examples) {
-    rlang::check_installed("shinytest2", "for {testthat} tests to work as expected", version = "0.2.0")
+  if ("shinytest" %in% examples) {
+    if (!is_available("shinytest", "1.4.0"))
+    {
+      message(
+        "The tests/shinytest directory needs shinytest 1.4.0 or later to work properly."
+      )
+      if (is_available("shinytest")) {
+        message("You currently have shinytest ",
+                utils::packageVersion("shinytest"), " installed.")
+      }
+
+    }
   }
 
   # =======================================================
@@ -145,7 +152,7 @@ shinyAppTemplate <- function(path = NULL, examples = "default", dryrun = FALSE)
 
   # Helper to resolve paths relative to our template
   template_path <- function(...) {
-    system_file("app_template", ..., package = "shiny")
+    system.file("app_template", ..., package = "shiny")
   }
 
   # Resolve path relative to destination
@@ -201,13 +208,16 @@ shinyAppTemplate <- function(path = NULL, examples = "default", dryrun = FALSE)
   }
 
   # Copy the files for a tests/ subdirectory
-  copy_test_dir <- function() {
+  copy_test_dir <- function(name) {
     files <- dir(template_path("tests"), recursive = TRUE)
+    # Note: This is not the same as using dir(pattern = "^shinytest"), since
+    # that will not match files inside of shinytest/.
+    files <- files[grepl(paste0("^", name), files)]
 
     # Filter out files that are not module files in the R directory.
     if (! "rdir" %in% examples) {
       # find all files in the testthat folder that are not module or server files
-      is_r_folder_file <- !grepl("module|server|shinytest2|testthat", basename(files))
+      is_r_folder_file <- (!grepl("module|server", basename(files))) & (dirname(files) == "testthat")
       files <- files[!is_r_folder_file]
     }
 
@@ -272,10 +282,12 @@ shinyAppTemplate <- function(path = NULL, examples = "default", dryrun = FALSE)
     copy_file(file.path("R", module_files))
   }
 
-  # tests/testthat dir
-  if ("tests" %in% examples) {
-    copy_test_dir()
+  # tests/ dir
+  if ("shinytest" %in% examples) {
+    copy_test_dir("shinytest")
+  }
+  if ("testthat" %in% examples) {
+    copy_test_dir("testthat")
   }
-
   invisible()
 }

R/bind-cache.R

@@ -159,8 +159,8 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'   ```
 #'
 #'   To use different settings for a session-scoped cache, you can set
-#'   `session$cache` at the top of your server function. By default, it will
-#'   create a 200 MB memory cache for each session, but you can replace it with
+#'   `self$cache` at the top of your server function. By default, it will create
+#'   a 200 MB memory cache for each session, but you can replace it with
 #'   something different. To use the session-scoped cache, you must also call
 #'   `bindCache()` with `cache="session"`. This will create a 100 MB cache for
 #'   the session:
@@ -177,7 +177,7 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'   cache by putting this at the top of your app.R, server.R, or global.R:
 #'
 #'   ```
-#'   shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache")))
+#'   shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache"))
 #'   ```
 #'
 #'   This will create a subdirectory in your system temp directory named
@@ -231,8 +231,8 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'   promises, but rather objects provided by the
 #'   \href{https://rstudio.github.io/promises/}{\pkg{promises}}  package, which
 #'   are similar to promises in JavaScript. (See [promises::promise()] for more
-#'   information.) You can also use [mirai::mirai()] or [future::future()]
-#'   objects to run code in a separate process or even on a remote machine.
+#'   information.) You can also use [future::future()] objects to run code in a
+#'   separate process or even on a remote machine.
 #'
 #'   If the value returns a promise, then anything that consumes the cached
 #'   reactive must expect it to return a promise.
@@ -255,7 +255,7 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'   the cache.
 #'
 #'   You may need to provide a `cacheHint` to [createRenderFunction()] (or
-#'   `htmlwidgets::shinyRenderWidget()`, if you've authored an htmlwidget) in
+#'   [htmlwidgets::shinyRenderWidget()], if you've authored an htmlwidget) in
 #'   order for `bindCache()` to correctly compute a cache key.
 #'
 #'   The potential problem is a cache collision. Consider the following:
@@ -453,7 +453,7 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'       bindEvent(input$go)
 #'       # The cached, eventified reactive takes a reactive dependency on
 #'       # input$go, but doesn't use it for the cache key. It uses input$x and
-#'       # input$y for the cache key, but doesn't take a reactive dependency on
+#'       # input$y for the cache key, but doesn't take a reactive depdency on
 #'       # them, because the reactive dependency is superseded by addEvent().
 #'
 #'     output$txt <- renderText(r())
@@ -478,12 +478,7 @@ bindCache.default <- function(x, ...) {
 bindCache.reactiveExpr <- function(x, ..., cache = "app") {
   check_dots_unnamed()
 
-  call_srcref <- get_call_srcref(-1)
-  label <- rassignSrcrefToLabel(
-    call_srcref,
-    defaultLabel = exprToLabel(substitute(x), "cachedReactive")
-  )
-
+  label <- exprToLabel(substitute(key), "cachedReactive")
   domain <- reactive_get_domain(x)
 
   # Convert the ... to a function that returns their evaluated values.
@@ -495,37 +490,24 @@ bindCache.reactiveExpr <- function(x, ..., cache = "app") {
   cacheHint <- rlang::hash(extractCacheHint(x))
   valueFunc <- wrapFunctionLabel(valueFunc, "cachedReactiveValueFunc", ..stacktraceon = TRUE)
 
-  x_classes <- class(x)
-  x_otel_attrs <- attr(x, "observable", exact = TRUE)$.otelAttrs
-
   # Don't hold on to the reference for x, so that it can be GC'd
   rm(x)
   # Hacky workaround for issue with `%>%` preventing GC:
   # https://github.com/tidyverse/magrittr/issues/229
-  if (exists(".GenericCallEnv") && exists(".", envir = .GenericCallEnv, inherits = FALSE)) {
-    rm(list = ".", envir = .GenericCallEnv, inherits = FALSE)
+  if (exists(".GenericCallEnv") && exists(".", envir = .GenericCallEnv)) {
+    rm(list = ".", envir = .GenericCallEnv)
   }
 
-  with_no_otel_collect({
-    res <- reactive(label = label, domain = domain, {
-      cache <- resolve_cache_object(cache, domain)
-      hybrid_chain(
-        keyFunc(),
-        generateCacheFun(valueFunc, cache, cacheHint, cacheReadHook = identity, cacheWriteHook = identity)
-      )
-    })
+
+  res <- reactive(label = label, domain = domain, {
+    cache <- resolve_cache_object(cache, domain)
+    hybrid_chain(
+      keyFunc(),
+      generateCacheFun(valueFunc, cache, cacheHint, cacheReadHook = identity, cacheWriteHook = identity)
+    )
   })
 
   class(res) <- c("reactive.cache", class(res))
-
-  local({
-    impl <- attr(res, "observable", exact = TRUE)
-    impl$.otelAttrs <- append_otel_srcref_attrs(x_otel_attrs, call_srcref, fn_name = "bindCache")
-  })
-
-  if (has_otel_collect("reactivity")) {
-    res <- enable_otel_reactive_expr(res)
-  }
   res
 }
 
@@ -552,7 +534,6 @@ bindCache.shiny.render.function <- function(x, ..., cache = "app") {
     )
   }
 
-  # Passes over the otelAttrs from valueFunc to renderFunc
   renderFunc <- addAttributes(renderFunc, renderFunctionAttributes(valueFunc))
   class(renderFunc) <- c("shiny.render.function.cache", class(valueFunc))
   renderFunc
@@ -604,7 +585,7 @@ bindCache.shiny.renderPlot <- function(x, ...,
 
     observe({
       doResizeCheck()
-    }, label = "plot-resize")
+    })
     # TODO: Make sure this observer gets GC'd if output$foo is replaced.
     # Currently, if you reassign output$foo, the observer persists until the
     # session ends. This is generally bad programming practice and should be

R/bind-event.R

@@ -196,58 +196,31 @@ bindEvent.reactiveExpr <- function(x, ..., ignoreNULL = TRUE, ignoreInit = FALSE
   valueFunc <- reactive_get_value_func(x)
   valueFunc <- wrapFunctionLabel(valueFunc, "eventReactiveValueFunc", ..stacktraceon = TRUE)
 
-  call_srcref <- get_call_srcref(-1)
-  if (is.null(label)) {
-    label <- rassignSrcrefToLabel(
-      call_srcref,
-      defaultLabel = as_default_label(sprintf(
-        'bindEvent(%s, %s)',
-        attr(x, "observable", exact = TRUE)$.label,
-        quos_to_label(qs)
-      ))
-    )
-  }
-
-  x_classes <- class(x)
-  x_otel_attrs <- attr(x, "observable", exact = TRUE)$.otelAttrs
+  label <- label %||%
+    sprintf('bindEvent(%s, %s)', attr(x, "observable", exact = TRUE)$.label, quos_to_label(qs))
 
   # Don't hold on to the reference for x, so that it can be GC'd
   rm(x)
 
   initialized <- FALSE
 
-  with_no_otel_collect({
-    res <- reactive(label = label, domain = domain, ..stacktraceon = FALSE, {
-      hybrid_chain(
-        {
-          eventFunc()
-        },
-        function(value) {
-          if (ignoreInit && !initialized) {
-            initialized <<- TRUE
-            req(FALSE)
-          }
-
-          req(!ignoreNULL || !isNullEvent(value))
-
-          isolate(valueFunc())
+  res <- reactive(label = label, domain = domain, ..stacktraceon = FALSE, {
+    hybrid_chain(
+      eventFunc(),
+      function(value) {
+        if (ignoreInit && !initialized) {
+          initialized <<- TRUE
+          req(FALSE)
         }
-      )
-    })
+
+        req(!ignoreNULL || !isNullEvent(value))
+
+        isolate(valueFunc())
+      }
+    )
   })
 
-  class(res) <- c("reactive.event", x_classes)
-
-  local({
-    impl <- attr(res, "observable", exact = TRUE)
-    impl$.otelAttrs <- append_otel_srcref_attrs(x_otel_attrs, call_srcref, fn_name = "bindEvent")
-  })
-
-
-  if (has_otel_collect("reactivity")) {
-    res <- enable_otel_reactive_expr(res)
-  }
-
+  class(res) <- c("reactive.event", class(res))
   res
 }
 
@@ -276,7 +249,6 @@ bindEvent.shiny.render.function <- function(x, ..., ignoreNULL = TRUE, ignoreIni
     )
   }
 
-  # Passes over the otelAttrs from valueFunc to renderFunc
   renderFunc <- addAttributes(renderFunc, renderFunctionAttributes(valueFunc))
   class(renderFunc) <- c("shiny.render.function.event", class(valueFunc))
   renderFunc
@@ -297,17 +269,7 @@ bindEvent.Observer <- function(x, ..., ignoreNULL = TRUE, ignoreInit = FALSE,
 
   # Note that because the observer will already have been logged by this point,
   # this updated label won't show up in the reactlog.
-  if (is.null(label)) {
-    call_srcref <- get_call_srcref(-1)
-    x$.label <- rassignSrcrefToLabel(
-      call_srcref,
-      defaultLabel = as_default_label(
-        sprintf('bindEvent(%s, %s)', x$.label, quos_to_label(qs))
-      )
-    )
-  } else {
-    x$.label <- label
-  }
+  x$.label <- label %||% sprintf('bindEvent(%s, %s)', x$.label, quos_to_label(qs))
 
   initialized <- FALSE
 
@@ -340,13 +302,6 @@ bindEvent.Observer <- function(x, ..., ignoreNULL = TRUE, ignoreInit = FALSE,
   )
 
   class(x) <- c("Observer.event", class(x))
-  call_srcref <- get_call_srcref(-1)
-  x$.otelAttrs <- append_otel_srcref_attrs(x$.otelAttrs, call_srcref, fn_name = "bindEvent")
-
-  if (has_otel_collect("reactivity")) {
-    x <- enable_otel_observe(x)
-  }
-
   invisible(x)
 }
 

R/bookmark-state.R

@@ -99,13 +99,13 @@ saveShinySaveState <- function(state) {
 
 # Encode the state to a URL. This does not save to disk.
 encodeShinySaveState <- function(state) {
+  exclude <- c(state$exclude, "._bookmark_")
+  inputVals <- serializeReactiveValues(state$input, exclude, stateDir = NULL)
+
   # Allow user-supplied onSave function to do things like add state$values.
   if (!is.null(state$onSave))
     isolate(state$onSave(state))
 
-  exclude <- c(state$exclude, "._bookmark_")
-  inputVals <- serializeReactiveValues(state$input, exclude, stateDir = NULL)
-
   inputVals <- vapply(inputVals,
     function(x) toJSON(x, strict_atomic = FALSE),
     character(1),
@@ -321,38 +321,34 @@ RestoreContext <- R6Class("RestoreContext",
       if (substr(queryString, 1, 1) == '?')
         queryString <- substr(queryString, 2, nchar(queryString))
 
-      # The "=" after "_inputs_" is optional. Shiny doesn't generate URLs with
-      # "=", but httr always adds "=".
-      inputs_reg <- "(^|&)_inputs_=?(&|$)"
-      values_reg <- "(^|&)_values_=?(&|$)"
 
       # Error if multiple '_inputs_' or '_values_'. This is needed because
       # strsplit won't add an entry if the search pattern is at the end of a
       # string.
-      if (length(gregexpr(inputs_reg, queryString)[[1]]) > 1)
+      if (length(gregexpr("(^|&)_inputs_(&|$)", queryString)[[1]]) > 1)
         stop("Invalid state string: more than one '_inputs_' found")
-      if (length(gregexpr(values_reg, queryString)[[1]]) > 1)
+      if (length(gregexpr("(^|&)_values_(&|$)", queryString)[[1]]) > 1)
         stop("Invalid state string: more than one '_values_' found")
 
       # Look for _inputs_ and store following content in inputStr
-      splitStr <- strsplit(queryString, inputs_reg)[[1]]
+      splitStr <- strsplit(queryString, "(^|&)_inputs_(&|$)")[[1]]
       if (length(splitStr) == 2) {
         inputStr <- splitStr[2]
         # Remove any _values_ (and content after _values_) that may come after
         # _inputs_
-        inputStr <- strsplit(inputStr, values_reg)[[1]][1]
+        inputStr <- strsplit(inputStr, "(^|&)_values_(&|$)")[[1]][1]
 
       } else {
         inputStr <- ""
       }
 
       # Look for _values_ and store following content in valueStr
-      splitStr <- strsplit(queryString, values_reg)[[1]]
+      splitStr <- strsplit(queryString, "(^|&)_values_(&|$)")[[1]]
       if (length(splitStr) == 2) {
         valueStr <- splitStr[2]
         # Remove any _inputs_ (and content after _inputs_) that may come after
         # _values_
-        valueStr <- strsplit(valueStr, inputs_reg)[[1]][1]
+        valueStr <- strsplit(valueStr, "(^|&)_inputs_(&|$)")[[1]][1]
 
       } else {
         valueStr <- ""
@@ -363,20 +359,16 @@ RestoreContext <- R6Class("RestoreContext",
       values <- parseQueryString(valueStr, nested = TRUE)
 
       valuesFromJSON <- function(vals) {
-        varsUnparsed <- c()
-        valsParsed <- mapply(names(vals), vals, SIMPLIFY = FALSE,
+        mapply(names(vals), vals, SIMPLIFY = FALSE,
           FUN = function(name, value) {
             tryCatch(
               safeFromJSON(value),
               error = function(e) {
-                varsUnparsed <<- c(varsUnparsed, name)
-                warning("Failed to parse URL parameter \"", name, "\"")
+                stop("Failed to parse URL parameter \"", name, "\"")
               }
             )
           }
         )
-        valsParsed[varsUnparsed] <- NULL
-        valsParsed
       }
 
       inputs <- valuesFromJSON(inputs)
@@ -452,10 +444,8 @@ RestoreInputSet <- R6Class("RestoreInputSet",
   )
 )
 
+# This is a fastmap::faststack(); value is assigned in .onLoad().
 restoreCtxStack <- NULL
-on_load({
-    restoreCtxStack <- fastmap::faststack()
-})
 
 withRestoreContext <- function(ctx, expr) {
   restoreCtxStack$push(ctx)
@@ -551,7 +541,7 @@ restoreInput <- function(id, default) {
 #' `window.history.pushState(null, null, queryString)`.
 #'
 #' @param queryString The new query string to show in the location bar.
-#' @param mode When the query string is updated, should the current history
+#' @param mode When the query string is updated, should the the current history
 #'   entry be replaced (default), or should a new history entry be pushed onto
 #'   the history stack? The former should only be used in a live bookmarking
 #'   context. The latter is useful if you want to navigate between states using

R/bootstrap-deprecated.R

@@ -6,7 +6,7 @@
 #' @param sidebarPanel The [sidebarPanel] containing input controls
 #' @param mainPanel The [mainPanel] containing outputs
 #' @keywords internal
-#' @return A UI definition that can be passed to the [shinyUI] function
+#' @return A UI defintion that can be passed to the [shinyUI] function
 #' @export
 pageWithSidebar <- function(headerPanel,
                             sidebarPanel,

R/bootstrap-layout.R

@@ -13,7 +13,7 @@
 #'   Can also be set as a side effect of the [titlePanel()] function.
 #' @inheritParams bootstrapPage
 #'
-#' @return A UI definition that can be passed to the [shinyUI] function.
+#' @return A UI defintion that can be passed to the [shinyUI] function.
 #'
 #' @details To create a fluid page use the `fluidPage` function and include
 #'   instances of `fluidRow` and [column()] within it. As an
@@ -111,7 +111,7 @@ fluidRow <- function(...) {
 #' @param title The browser window title (defaults to the host URL of the page)
 #' @inheritParams bootstrapPage
 #'
-#' @return A UI definition that can be passed to the [shinyUI] function.
+#' @return A UI defintion that can be passed to the [shinyUI] function.
 #'
 #' @details To create a fixed page use the `fixedPage` function and include
 #'   instances of `fixedRow` and [column()] within it. Note that
@@ -516,7 +516,7 @@ splitLayout <- function(..., cellWidths = NULL, cellArgs = list()) {
   children <- children[childIdx]
   count <- length(children)
 
-  if (length(cellWidths) == 0 || isTRUE(is.na(cellWidths))) {
+  if (length(cellWidths) == 0 || is.na(cellWidths)) {
     cellWidths <- sprintf("%.3f%%", 100 / count)
   }
   cellWidths <- rep(cellWidths, length.out = count)

R/bootstrap.R

@@ -24,7 +24,7 @@ NULL
 #'   This will be used as the lang in the \code{<html>} tag, as in \code{<html lang="en">}.
 #'   The default (NULL) results in an empty string.
 #'
-#' @return A UI definition that can be passed to the [shinyUI] function.
+#' @return A UI defintion that can be passed to the [shinyUI] function.
 #'
 #' @note The `basicPage` function is deprecated, you should use the
 #'   [fluidPage()] function instead.
@@ -138,7 +138,8 @@ bs_theme_deps <- function(theme) {
 }
 
 is_bs_theme <- function(x) {
-  bslib::is_bs_theme(x)
+  is_available("bslib", "0.2.0.9000") &&
+    bslib::is_bs_theme(x)
 }
 
 #' Obtain Shiny's Bootstrap Sass theme
@@ -172,10 +173,9 @@ setCurrentTheme <- function(theme) {
 
 #' Register a theme dependency
 #'
-#' This function registers a function that returns an
-#' [htmltools::htmlDependency()] or list of such objects. If
-#' `session$setCurrentTheme()` is called, the function will be re-executed, and
-#' the resulting html dependency will be sent to the client.
+#' This function registers a function that returns an [htmlDependency()] or list
+#' of such objects. If `session$setCurrentTheme()` is called, the function will
+#' be re-executed, and the resulting html dependency will be sent to the client.
 #'
 #' Note that `func` should **not** be an anonymous function, or a function which
 #' is defined within the calling function. This is so that,
@@ -215,10 +215,11 @@ registerThemeDependency <- function(func) {
 
 bootstrapDependency <- function(theme) {
   htmlDependency(
-    "bootstrap",
-    bootstrapVersion,
-    src = "www/shared/bootstrap",
-    package = "shiny",
+    "bootstrap", bootstrapVersion,
+    c(
+      href = "shared/bootstrap",
+      file = system.file("www/shared/bootstrap", package = "shiny")
+    ),
     script = c(
       "js/bootstrap.min.js",
       # Safely adding accessibility plugin for screen readers and keyboard users; no break for sighted aspects (see https://github.com/paypal/bootstrap-accessibility-plugin)
@@ -375,7 +376,8 @@ collapseSizes <- function(padding) {
 #' @param inverse `TRUE` to use a dark background and light text for the
 #'   navigation bar
 #' @param collapsible `TRUE` to automatically collapse the navigation
-#'   elements into an expandable menu on mobile devices or narrow window widths.
+#'   elements into a menu when the width of the browser is less than 940 pixels
+#'   (useful for viewing on smaller touchscreen device)
 #' @param fluid `TRUE` to use a fluid layout. `FALSE` to use a fixed
 #'   layout.
 #' @param windowTitle the browser window title (as a character string). The
@@ -385,7 +387,7 @@ collapseSizes <- function(padding) {
 #' @inheritParams bootstrapPage
 #' @param icon Optional icon to appear on a `navbarMenu` tab.
 #'
-#' @return A UI definition that can be passed to the [shinyUI] function.
+#' @return A UI defintion that can be passed to the [shinyUI] function.
 #'
 #' @details The `navbarMenu` function can be used to create an embedded
 #'   menu within the navbar that in turns includes additional tabPanels (see
@@ -533,12 +535,7 @@ wellPanel <- function(...) {
 #' }
 #' @export
 conditionalPanel <- function(condition, ..., ns = NS(NULL)) {
-  div(
-    class = "shiny-panel-conditional",
-    `data-display-if` = condition,
-    `data-ns-prefix` = ns(""),
-    ...
-  )
+  div(`data-display-if`=condition, `data-ns-prefix`=ns(""), ...)
 }
 
 #' Create a help text element
@@ -799,7 +796,7 @@ verbatimTextOutput <- function(outputId, placeholder = FALSE) {
 #' @export
 imageOutput <- function(outputId, width = "100%", height="400px",
                         click = NULL, dblclick = NULL, hover = NULL, brush = NULL,
-                        inline = FALSE, fill = FALSE) {
+                        inline = FALSE) {
 
   style <- if (!inline) {
     # Using `css()` here instead of paste/sprintf so that NULL values will
@@ -855,8 +852,7 @@ imageOutput <- function(outputId, width = "100%", height="400px",
   }
 
   container <- if (inline) span else div
-  res <- do.call(container, args)
-  bindFillRole(res, item = fill)
+  do.call(container, args)
 }
 
 #' Create an plot or image output element
@@ -924,11 +920,6 @@ imageOutput <- function(outputId, width = "100%", height="400px",
 #'   `imageOutput`/`plotOutput` calls may share the same `id`
 #'   value; brushing one image or plot will cause any other brushes with the
 #'   same `id` to disappear.
-#' @param fill Whether or not the returned tag should be treated as a fill item,
-#'   meaning that its `height` is allowed to grow/shrink to fit a fill container
-#'   with an opinionated height (see [htmltools::bindFillRole()]) with an
-#'   opinionated height. Examples of fill containers include `bslib::card()` and
-#'   `bslib::card_body_fill()`.
 #' @inheritParams textOutput
 #' @note The arguments `clickId` and `hoverId` only work for R base graphics
 #'   (see the \pkg{\link[graphics:graphics-package]{graphics}} package). They do
@@ -1099,11 +1090,11 @@ imageOutput <- function(outputId, width = "100%", height="400px",
 #' @export
 plotOutput <- function(outputId, width = "100%", height="400px",
                        click = NULL, dblclick = NULL, hover = NULL, brush = NULL,
-                       inline = FALSE, fill = !inline) {
+                       inline = FALSE) {
 
   # Result is the same as imageOutput, except for HTML class
   res <- imageOutput(outputId, width, height, click, dblclick,
-                     hover, brush, inline, fill)
+                     hover, brush, inline)
 
   res$attribs$class <- "shiny-plot-output"
   res
@@ -1113,23 +1104,17 @@ plotOutput <- function(outputId, width = "100%", height="400px",
 #' @rdname renderTable
 #' @export
 tableOutput <- function(outputId) {
-  div(id = outputId, class="shiny-html-output shiny-table-output")
+  div(id = outputId, class="shiny-html-output")
 }
 
 dataTableDependency <- list(
   htmlDependency(
-    "datatables",
-    "1.10.22",
-    src = "www/shared/datatables",
-    package = "shiny",
+    "datatables", "1.10.5", c(href = "shared/datatables"),
     script = "js/jquery.dataTables.min.js"
   ),
   htmlDependency(
-    "datatables-bootstrap",
-    "1.10.22",
-    src = "www/shared/datatables",
-    package = "shiny",
-    stylesheet = "css/dataTables.bootstrap.css",
+    "datatables-bootstrap", "1.10.5", c(href = "shared/datatables"),
+    stylesheet = c("css/dataTables.bootstrap.css", "css/dataTables.extra.css"),
     script = "js/dataTables.bootstrap.js"
   )
 )
@@ -1137,67 +1122,24 @@ dataTableDependency <- list(
 #' @rdname renderDataTable
 #' @export
 dataTableOutput <- function(outputId) {
-  legacy <- useLegacyDataTable(from = "shiny::dataTableOutput()", to = "DT::DTOutput()")
-
-  if (legacy) {
-    attachDependencies(
-      div(id = outputId, class = "shiny-datatable-output"),
-      dataTableDependency
-    )
-  } else {
-    DT::DTOutput(outputId)
-  }
+  attachDependencies(
+    div(id = outputId, class="shiny-datatable-output"),
+    dataTableDependency
+  )
 }
 
-useLegacyDataTable <- function(from, to) {
-  legacy <- getOption("shiny.legacy.datatable")
-
-  # If option has been set, user knows what they're doing
-  if (!is.null(legacy)) {
-    return(legacy)
-  }
-
-  # If not set, use DT if a suitable version is available (and inform either way)
-  hasDT <- is_installed("DT", "0.32.1")
-  details <- NULL
-  if (hasDT) {
-    details <- paste0(c(
-      "Since you have a suitable version of DT (>= v0.32.1), ",
-      from,
-      " will automatically use ",
-      to,
-      " under-the-hood.\n",
-      "If this happens to break your app, set `options(shiny.legacy.datatable = TRUE)` ",
-      "to get the legacy datatable implementation (or `FALSE` to squelch this message).\n"
-    ), collapse = "")
-  }
-
-  details <- paste0(details, "See <https://rstudio.github.io/DT/shiny.html> for more information.")
-
-  shinyDeprecated("1.8.1", from, to, details)
-
-  !hasDT
-}
-
-
 #' Create an HTML output element
 #'
 #' Render a reactive output variable as HTML within an application page. The
-#' text will be included within an HTML `div` tag, and is presumed to contain
-#' HTML content which should not be escaped.
+#' text will be included within an HTML `div` tag, and is presumed to
+#' contain HTML content which should not be escaped.
 #'
-#' `uiOutput` is intended to be used with `renderUI` on the server side. It is
-#' currently just an alias for `htmlOutput`.
+#' `uiOutput` is intended to be used with `renderUI` on the server
+#' side. It is currently just an alias for `htmlOutput`.
 #'
 #' @param outputId output variable to read the value from
 #' @param ... Other arguments to pass to the container tag function. This is
 #'   useful for providing additional classes for the tag.
-#' @param fill If `TRUE`, the result of `container` is treated as _both_ a fill
-#'   item and container (see [htmltools::bindFillRole()]), which means both the
-#'   `container` as well as its immediate children (i.e., the result of
-#'   `renderUI()`) are allowed to grow/shrink to fit a fill container with an
-#'   opinionated height. Set `fill = "item"` or `fill = "container"` to treat
-#'   `container` as just a fill item or a fill container.
 #' @inheritParams textOutput
 #' @return An HTML output element that can be included in a panel
 #' @examples
@@ -1209,16 +1151,12 @@ useLegacyDataTable <- function(from, to) {
 #' )
 #' @export
 htmlOutput <- function(outputId, inline = FALSE,
-  container = if (inline) span else div, fill = FALSE, ...)
+  container = if (inline) span else div, ...)
 {
-  if (any_unnamed(list(...))) {
+  if (anyUnnamed(list(...))) {
     warning("Unnamed elements in ... will be replaced with dynamic UI.")
   }
-  res <- container(id = outputId, class = "shiny-html-output", ...)
-  bindFillRole(
-    res, item = isTRUE(fill) || isTRUE("item" == fill),
-    container = isTRUE(fill) || isTRUE("container" == fill)
-  )
+  container(id = outputId, class="shiny-html-output", ...)
 }
 
 #' @rdname htmlOutput
@@ -1242,25 +1180,19 @@ uiOutput <- htmlOutput
 #' @examples
 #' \dontrun{
 #' ui <- fluidPage(
-#'   p("Choose a dataset to download."),
-#'   selectInput("dataset", "Dataset", choices = c("mtcars", "airquality")),
 #'   downloadButton("downloadData", "Download")
 #' )
 #'
 #' server <- function(input, output) {
-#'   # The requested dataset
-#'   data <- reactive({
-#'     get(input$dataset)
-#'   })
+#'   # Our dataset
+#'   data <- mtcars
 #'
 #'   output$downloadData <- downloadHandler(
 #'     filename = function() {
-#'       # Use the selected dataset as the suggested file name
-#'       paste0(input$dataset, ".csv")
+#'       paste("data-", Sys.Date(), ".csv", sep="")
 #'     },
 #'     content = function(file) {
-#'       # Write the dataset to the `file` that will be downloaded
-#'       write.csv(data(), file)
+#'       write.csv(data, file)
 #'     }
 #'   )
 #' }
@@ -1276,29 +1208,23 @@ downloadButton <- function(outputId,
                            class=NULL,
                            ...,
                            icon = shiny::icon("download")) {
-  tags$a(id=outputId,
-         class='btn btn-default shiny-download-link disabled',
-         class=class,
-         href='',
-         target='_blank',
-         download=NA,
-         "aria-disabled"="true",
-         tabindex="-1",
-         validateIcon(icon),
-         label, ...)
+  aTag <- tags$a(id=outputId,
+                 class=paste('btn btn-default shiny-download-link', class),
+                 href='',
+                 target='_blank',
+                 download=NA,
+                 validateIcon(icon),
+                 label, ...)
 }
 
 #' @rdname downloadButton
 #' @export
 downloadLink <- function(outputId, label="Download", class=NULL, ...) {
   tags$a(id=outputId,
-         class='shiny-download-link disabled',
-         class=class,
+         class=paste(c('shiny-download-link', class), collapse=" "),
          href='',
          target='_blank',
          download=NA,
-         "aria-disabled"="true",
-         tabindex="-1",
          label, ...)
 }
 

R/busy-indicators-spinners.R

@@ -1,4 +0,0 @@
-# Generated by tools/updateSpinnerTypes.R: do not edit by hand
-.busySpinnerTypes <-
-  c("ring", "ring2", "ring3", "bars", "bars2", "bars3", "pulse", 
-  "pulse2", "pulse3", "dots", "dots2", "dots3")

R/busy-indicators.R

@@ -1,294 +0,0 @@
-#' Enable/disable busy indication
-#'
-#' Busy indicators provide a visual cue to users when the server is busy
-#' calculating outputs or otherwise performing tasks (e.g., producing
-#' downloads). When enabled, a spinner is shown on each
-#' calculating/recalculating output, and a pulsing banner is shown at the top of
-#' the page when the app is otherwise busy. Busy indication is enabled by
-#' default for UI created with \pkg{bslib}, but must be enabled otherwise. To
-#' enable/disable, include the result of this function in anywhere in the app's
-#' UI.
-#'
-#' When both `spinners` and `pulse` are set to `TRUE`, the pulse is
-#' automatically disabled when spinner(s) are active. When both `spinners` and
-#' `pulse` are set to `FALSE`, no busy indication is shown (other than the
-#' graying out of recalculating outputs).
-#'
-#' @param ... Currently ignored.
-#' @param spinners Whether to show a spinner on each calculating/recalculating
-#'   output.
-#' @param pulse Whether to show a pulsing banner at the top of the page when the
-#'   app is busy.
-#' @param fade Whether to fade recalculating outputs. A value of `FALSE` is
-#'   equivalent to `busyIndicatorOptions(fade_opacity=1)`.
-#'
-#' @export
-#' @seealso [busyIndicatorOptions()] for customizing the appearance of the busy
-#'   indicators.
-#' @examplesIf rlang::is_interactive()
-#'
-#' library(bslib)
-#'
-#' ui <- page_fillable(
-#'   useBusyIndicators(),
-#'   card(
-#'     card_header(
-#'       "A plot",
-#'       input_task_button("simulate", "Simulate"),
-#'       class = "d-flex justify-content-between align-items-center"
-#'     ),
-#'     plotOutput("p"),
-#'   )
-#' )
-#'
-#' server <- function(input, output) {
-#'   output$p <- renderPlot({
-#'     input$simulate
-#'     Sys.sleep(4)
-#'     plot(x = rnorm(100), y = rnorm(100))
-#'   })
-#' }
-#'
-#' shinyApp(ui, server)
-useBusyIndicators <- function(..., spinners = TRUE, pulse = TRUE, fade = TRUE) {
-
-  rlang::check_dots_empty()
-
-  attrs <- list("shinyBusySpinners" = spinners, "shinyBusyPulse" = pulse)
-
-  js <- vapply(names(attrs), character(1), FUN = function(key) {
-    if (attrs[[key]]) {
-      sprintf("document.documentElement.dataset.%s = 'true';", key)
-    } else {
-      sprintf("delete document.documentElement.dataset.%s;", key)
-    }
-  })
-
-  # TODO: it'd be nice if htmltools had something like a page_attrs() that allowed us
-  # to do this without needing to inject JS into the head.
-  res <- tags$script(HTML(paste(js, collapse = "\n")))
-
-  if (!fade) {
-    res <- tagList(res, fadeOptions(opacity = 1))
-  }
-
-  res
-}
-
-#' Customize busy indicator options
-#'
-#' @description
-#' Shiny automatically includes busy indicators, which more specifically means:
-#'   1. Calculating/recalculating outputs have a spinner overlay.
-#'   2. Outputs fade out/in when recalculating.
-#'   3. When no outputs are calculating/recalculating, but Shiny is busy
-#'     doing something else (e.g., a download, side-effect, etc), a page-level
-#'     pulsing banner is shown.
-#'
-#' This function allows you to customize the appearance of these busy indicators
-#' by including the result of this function inside the app's UI. Note that,
-#' unless `spinner_selector` (or `fade_selector`) is specified, the spinner/fade
-#' customization applies to the parent element. If the customization should
-#' instead apply to the entire page, set `spinner_selector = 'html'` and
-#' `fade_selector = 'html'`.
-#'
-#' @param ... Currently ignored.
-#' @param spinner_type The type of spinner. Pre-bundled types include:
-#'   '`r paste0(.busySpinnerTypes, collapse = "', '")`'.
-#'
-#'   A path to a local SVG file can also be provided. The SVG should adhere to
-#'   the following rules:
-#'   * The SVG itself should contain the animation.
-#'   * It should avoid absolute sizes (the spinner's containing DOM element
-#'     size is set in CSS by `spinner_size`, so it should fill that container).
-#'   * It should avoid setting absolute colors (the spinner's containing DOM element
-#'     color is set in CSS by `spinner_color`, so it should inherit that color).
-#' @param spinner_color The color of the spinner. This can be any valid CSS
-#'   color. Defaults to the app's "primary" color if Bootstrap is on the page.
-#' @param spinner_size The size of the spinner. This can be any valid CSS size.
-#' @param spinner_delay The amount of time to wait before showing the spinner.
-#'   This can be any valid CSS time and can be useful for not showing the spinner
-#'   if the computation finishes quickly.
-#' @param spinner_selector A character string containing a CSS selector for
-#'   scoping the spinner customization. The default (`NULL`) will apply the
-#'   spinner customization to the parent element of the spinner.
-#' @param fade_opacity The opacity (a number between 0 and 1) for recalculating
-#'   output. Set to 1 to "disable" the fade.
-#' @param fade_selector A character string containing a CSS selector for
-#'   scoping the spinner customization. The default (`NULL`) will apply the
-#'   spinner customization to the parent element of the spinner.
-#' @param pulse_background A CSS background definition for the pulse. The
-#'   default uses a
-#'   [linear-gradient](https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/linear-gradient)
-#'   of the theme's indigo, purple, and pink colors.
-#' @param pulse_height The height of the pulsing banner. This can be any valid
-#'   CSS size.
-#' @param pulse_speed The speed of the pulsing banner. This can be any valid CSS
-#'   time.
-#'
-#' @export
-#' @seealso [useBusyIndicators()] to disable/enable busy indicators.
-#' @examplesIf rlang::is_interactive()
-#'
-#' library(bslib)
-#'
-#' card_ui <- function(id, spinner_type = id) {
-#'   card(
-#'     busyIndicatorOptions(spinner_type = spinner_type),
-#'     card_header(paste("Spinner:", spinner_type)),
-#'     plotOutput(shiny::NS(id, "plot"))
-#'   )
-#' }
-#'
-#' card_server <- function(id, simulate = reactive()) {
-#'   moduleServer(
-#'     id = id,
-#'     function(input, output, session) {
-#'       output$plot <- renderPlot({
-#'         Sys.sleep(1)
-#'         simulate()
-#'         plot(x = rnorm(100), y = rnorm(100))
-#'       })
-#'     }
-#'   )
-#' }
-#'
-#' ui <- page_fillable(
-#'   useBusyIndicators(),
-#'   input_task_button("simulate", "Simulate", icon = icon("refresh")),
-#'   layout_columns(
-#'     card_ui("ring"),
-#'     card_ui("bars"),
-#'     card_ui("dots"),
-#'     card_ui("pulse"),
-#'     col_widths = 6
-#'   )
-#' )
-#'
-#' server <- function(input, output, session) {
-#'   simulate <- reactive(input$simulate)
-#'   card_server("ring", simulate)
-#'   card_server("bars", simulate)
-#'   card_server("dots", simulate)
-#'   card_server("pulse", simulate)
-#' }
-#'
-#' shinyApp(ui, server)
-#'
-busyIndicatorOptions <- function(
-  ...,
-  spinner_type = NULL,
-  spinner_color = NULL,
-  spinner_size = NULL,
-  spinner_delay = NULL,
-  spinner_selector = NULL,
-  fade_opacity = NULL,
-  fade_selector = NULL,
-  pulse_background = NULL,
-  pulse_height = NULL,
-  pulse_speed = NULL
-) {
-
-  rlang::check_dots_empty()
-
-  res <- tagList(
-    spinnerOptions(
-      type = spinner_type,
-      color = spinner_color,
-      size = spinner_size,
-      delay = spinner_delay,
-      selector = spinner_selector
-    ),
-    fadeOptions(opacity = fade_opacity, selector = fade_selector),
-    pulseOptions(
-      background = pulse_background,
-      height = pulse_height,
-      speed = pulse_speed
-    )
-  )
-
-  bslib::as.card_item(dropNulls(res))
-}
-
-
-spinnerOptions <- function(type = NULL, color = NULL, size = NULL, delay = NULL, selector = NULL) {
-  if (is.null(type) && is.null(color) && is.null(size) && is.null(delay) && is.null(selector)) {
-    return(NULL)
-  }
-
-  url <- NULL
-  if (!is.null(type)) {
-    stopifnot(is.character(type) && length(type) == 1)
-    if (file.exists(type) && grepl("\\.svg$", type)) {
-      typeRaw <- readBin(type, "raw", n = file.info(type)$size)
-      url <- sprintf("url('data:image/svg+xml;base64,%s')", rawToBase64(typeRaw))
-    } else {
-      type <- rlang::arg_match(type, .busySpinnerTypes)
-      url <- sprintf("url('spinners/%s.svg')", type)
-    }
-  }
-
-  # Options controlled via CSS variables.
-  css_vars <- htmltools::css(
-    "--shiny-spinner-url" = url,
-    "--shiny-spinner-color" = htmltools::parseCssColors(color),
-    "--shiny-spinner-size" = htmltools::validateCssUnit(size),
-    "--shiny-spinner-delay" = delay
-  )
-
-  id <- NULL
-  if (is.null(selector)) {
-    id <- paste0("spinner-options-", p_randomInt(100, 1000000))
-    selector <- sprintf(":has(> #%s)", id)
-  }
-
-  css <- HTML(paste0(selector, " {", css_vars, "}"))
-
-  tags$style(css, id = id)
-}
-
-fadeOptions <- function(opacity = NULL, selector = NULL) {
-  if (is.null(opacity) && is.null(selector)) {
-    return(NULL)
-  }
-
-  css_vars <- htmltools::css(
-    "--shiny-fade-opacity" = opacity
-  )
-
-  id <- NULL
-  if (is.null(selector)) {
-    id <- paste0("fade-options-", p_randomInt(100, 1000000))
-    selector <- sprintf(":has(> #%s)", id)
-  }
-
-  css <- HTML(paste0(selector, " {", css_vars, "}"))
-
-  tags$style(css, id = id)
-}
-
-pulseOptions <- function(background = NULL, height = NULL, speed = NULL) {
-  if (is.null(background) && is.null(height) && is.null(speed))  {
-    return(NULL)
-  }
-
-  css_vars <- htmltools::css(
-    "--shiny-pulse-background" = background,
-    "--shiny-pulse-height" = htmltools::validateCssUnit(height),
-    "--shiny-pulse-speed" = speed
-  )
-
-  tags$style(HTML(paste0(":root {", css_vars, "}")))
-}
-
-busyIndicatorDependency <- function() {
-  htmlDependency(
-    name = "shiny-busy-indicators",
-    version = get_package_version("shiny"),
-    src = "www/shared/busy-indicators",
-    package = "shiny",
-    stylesheet = "busy-indicators.css",
-    # TODO-future: In next release make spinners and pulse opt-out
-    # head = as.character(useBusyIndicators())
-  )
-}

R/conditions.R

@@ -75,18 +75,6 @@ getCallNames <- function(calls) {
   })
 }
 
-# A stripped down version of getCallNames() that intentionally avoids deparsing expressions.
-# Instead, it leaves expressions to be directly `rlang::hash()` (for de-duplication), which
-# is much faster than deparsing then hashing.
-getCallNamesForHash <- function(calls) {
-  lapply(calls, function(call) {
-    name <- call[[1L]]
-    if (is.function(name)) return("<Anonymous>")
-    if (typeof(name) == "promise") return("<Promise>")
-    name
-  })
-}
-
 getLocs <- function(calls) {
   vapply(calls, function(call) {
     srcref <- attr(call, "srcref", exact = TRUE)
@@ -134,9 +122,7 @@ getCallCategories <- function(calls) {
 #' @rdname stacktrace
 #' @export
 captureStackTraces <- function(expr) {
-  # Use `promises::` as it shows up in the stack trace
-  promises::with_promise_domain(
-    createStackTracePromiseDomain(),
+  promises::with_promise_domain(createStackTracePromiseDomain(),
     expr
   )
 }
@@ -144,49 +130,11 @@ captureStackTraces <- function(expr) {
 #' @include globals.R
 .globals$deepStack <- NULL
 
-getCallStackDigest <- function(callStack, warn = FALSE) {
-  dg <- attr(callStack, "shiny.stack.digest", exact = TRUE)
-  if (!is.null(dg)) {
-    return(dg)
-  }
-
-  if (isTRUE(warn)) {
-    rlang::warn(
-      "Call stack doesn't have a cached digest; expensively computing one now",
-      .frequency = "once",
-      .frequency_id = "deepstack-uncached-digest-warning"
-    )
-  }
-
-  rlang::hash(getCallNamesForHash(callStack))
-}
-
-saveCallStackDigest <- function(callStack) {
-  attr(callStack, "shiny.stack.digest") <- getCallStackDigest(callStack, warn = FALSE)
-  callStack
-}
-
-# Appends a call stack to a list of call stacks, but only if it's not already
-# in the list. The list is deduplicated by digest; ideally the digests on the
-# list are cached before calling this function (you will get a warning if not).
-appendCallStackWithDedupe <- function(lst, x) {
-  digests <- vapply(lst, getCallStackDigest, character(1), warn = TRUE)
-  xdigest <- getCallStackDigest(x, warn = TRUE)
-  stopifnot(all(nzchar(digests)))
-  stopifnot(length(xdigest) == 1)
-  stopifnot(nzchar(xdigest))
-  if (xdigest %in% digests) {
-    return(lst)
-  } else {
-    return(c(lst, list(x)))
-  }
-}
-
 createStackTracePromiseDomain <- function() {
   # These are actually stateless, we wouldn't have to create a new one each time
   # if we didn't want to. They're pretty cheap though.
 
-  d <- new_promise_domain(
+  d <- promises::new_promise_domain(
     wrapOnFulfilled = function(onFulfilled) {
       force(onFulfilled)
       # Subscription time
@@ -194,14 +142,13 @@ createStackTracePromiseDomain <- function() {
         currentStack <- sys.calls()
         currentParents <- sys.parents()
         attr(currentStack, "parents") <- currentParents
-        currentStack <- saveCallStackDigest(currentStack)
         currentDeepStack <- .globals$deepStack
       }
       function(...) {
         # Fulfill time
         if (deepStacksEnabled()) {
           origDeepStack <- .globals$deepStack
-          .globals$deepStack <- appendCallStackWithDedupe(currentDeepStack, currentStack)
+          .globals$deepStack <- c(currentDeepStack, list(currentStack))
           on.exit(.globals$deepStack <- origDeepStack, add = TRUE)
         }
 
@@ -218,14 +165,13 @@ createStackTracePromiseDomain <- function() {
         currentStack <- sys.calls()
         currentParents <- sys.parents()
         attr(currentStack, "parents") <- currentParents
-        currentStack <- saveCallStackDigest(currentStack)
         currentDeepStack <- .globals$deepStack
       }
       function(...) {
         # Fulfill time
         if (deepStacksEnabled()) {
           origDeepStack <- .globals$deepStack
-          .globals$deepStack <- appendCallStackWithDedupe(currentDeepStack, currentStack)
+          .globals$deepStack <- c(currentDeepStack, list(currentStack))
           on.exit(.globals$deepStack <- origDeepStack, add = TRUE)
         }
 
@@ -253,7 +199,6 @@ doCaptureStack <- function(e) {
     calls <- sys.calls()
     parents <- sys.parents()
     attr(calls, "parents") <- parents
-    calls <- saveCallStackDigest(calls)
     attr(e, "stack.trace") <- calls
   }
   if (deepStacksEnabled()) {
@@ -280,12 +225,10 @@ withLogErrors <- function(expr,
       result <- captureStackTraces(expr)
 
       # Handle expr being an async operation
-      if (is.promise(result)) {
+      if (promises::is.promise(result)) {
         result <- promises::catch(result, function(cond) {
           # Don't print shiny.silent.error (i.e. validation errors)
-          if (cnd_inherits(cond, "shiny.silent.error")) {
-            return()
-          }
+          if (inherits(cond, "shiny.silent.error")) return()
           if (isTRUE(getOption("show.error.messages"))) {
             printError(cond, full = full, offset = offset)
           }
@@ -296,7 +239,7 @@ withLogErrors <- function(expr,
     },
     error = function(cond) {
       # Don't print shiny.silent.error (i.e. validation errors)
-      if (cnd_inherits(cond, "shiny.silent.error")) return()
+      if (inherits(cond, "shiny.silent.error")) return()
       if (isTRUE(getOption("show.error.messages"))) {
         printError(cond, full = full, offset = offset)
       }
@@ -336,113 +279,86 @@ printStackTrace <- function(cond,
   full = get_devmode_option("shiny.fullstacktrace", FALSE),
   offset = getOption("shiny.stacktraceoffset", TRUE)) {
 
-  stackTraces <- c(
-    attr(cond, "deep.stack.trace", exact = TRUE),
-    list(attr(cond, "stack.trace", exact = TRUE))
-  )
-
-  # Stripping of stack traces is the one step where the different stack traces
-  # interact. So we need to do this in one go, instead of individually within
-  # printOneStackTrace.
-  if (!full) {
-    stripResults <- stripStackTraces(lapply(stackTraces, getCallNames))
-  } else {
-    # If full is TRUE, we don't want to strip anything
-    stripResults <- rep_len(list(TRUE), length(stackTraces))
-  }
-
-  mapply(
-    seq_along(stackTraces),
-    rev(stackTraces),
-    rev(stripResults),
-    FUN = function(i, trace, stripResult) {
-      if (is.integer(trace)) {
-        noun <- if (trace > 1L) "traces" else "trace"
-        message("[ reached getOption(\"shiny.deepstacktrace\") -- omitted ", trace, " more stack ", noun, " ]")
-      } else {
-        if (i != 1) {
-          message("From earlier call:")
-        }
-        printOneStackTrace(
-          stackTrace = trace,
-          stripResult = stripResult,
-          full = full,
-          offset = offset
-        )
-      }
-      # No mapply return value--we're just printing
-      NULL
-    },
-    SIMPLIFY = FALSE
-  )
-
-  invisible()
-}
-
-printOneStackTrace <- function(stackTrace, stripResult, full, offset) {
-  calls <- offsetSrcrefs(stackTrace, offset = offset)
-  callNames <- getCallNames(stackTrace)
-  parents <- attr(stackTrace, "parents", exact = TRUE)
-
   should_drop <- !full
   should_strip <- !full
   should_prune <- !full
 
-  if (should_drop) {
-    toKeep <- dropTrivialFrames(callNames)
-    calls <- calls[toKeep]
-    callNames <- callNames[toKeep]
-    parents <- parents[toKeep]
-    stripResult <- stripResult[toKeep]
-  }
-
-  toShow <- rep(TRUE, length(callNames))
-  if (should_prune) {
-    toShow <- toShow & pruneStackTrace(parents)
-  }
-  if (should_strip) {
-    toShow <- toShow & stripResult
-  }
-
-  # If we're running in testthat, hide the parts of the stack trace that can
-  # vary based on how testthat was launched. It's critical that this is not
-  # happen at the same time as dropTrivialFrames, which happens before
-  # pruneStackTrace; because dropTrivialTestFrames removes calls from the top
-  # (or bottom? whichever is the oldest?) of the stack, it breaks `parents`
-  # which is based on absolute indices of calls. dropTrivialFrames gets away
-  # with this because it only removes calls from the opposite side of the stack.
-  toShow <- toShow & dropTrivialTestFrames(callNames)
-
-  st <- data.frame(
-    num = rev(which(toShow)),
-    call = rev(callNames[toShow]),
-    loc = rev(getLocs(calls[toShow])),
-    category = rev(getCallCategories(calls[toShow])),
-    stringsAsFactors = FALSE
+  stackTraceCalls <- c(
+    attr(cond, "deep.stack.trace", exact = TRUE),
+    list(attr(cond, "stack.trace", exact = TRUE))
   )
 
-  if (nrow(st) == 0) {
-    message("  [No stack trace available]")
-  } else {
-    width <- floor(log10(max(st$num))) + 1
-    formatted <- paste0(
-      "  ",
-      formatC(st$num, width = width),
-      ": ",
-      mapply(paste0(st$call, st$loc), st$category, FUN = function(name, category) {
-        if (category == "pkg")
-          cli::col_silver(name)
-        else if (category == "user")
-          cli::style_bold(cli::col_blue(name))
-        else
-          cli::col_white(name)
-      }),
-      "\n"
-    )
-    cat(file = stderr(), formatted, sep = "")
+  stackTraceParents <- lapply(stackTraceCalls, attr, which = "parents", exact = TRUE)
+  stackTraceCallNames <- lapply(stackTraceCalls, getCallNames)
+  stackTraceCalls <- lapply(stackTraceCalls, offsetSrcrefs, offset = offset)
+
+  # Use dropTrivialFrames logic to remove trailing bits (.handleSimpleError, h)
+  if (should_drop) {
+    # toKeep is a list of logical vectors, of which elements (stack frames) to keep
+    toKeep <- lapply(stackTraceCallNames, dropTrivialFrames)
+    # We apply the list of logical vector indices to each data structure
+    stackTraceCalls <- mapply(stackTraceCalls, FUN = `[`, toKeep, SIMPLIFY = FALSE)
+    stackTraceCallNames <- mapply(stackTraceCallNames, FUN = `[`, toKeep, SIMPLIFY = FALSE)
+    stackTraceParents <- mapply(stackTraceParents, FUN = `[`, toKeep, SIMPLIFY = FALSE)
   }
 
-  invisible(st)
+  delayedAssign("all_true", {
+    # List of logical vectors that are all TRUE, the same shape as
+    # stackTraceCallNames. Delay the evaluation so we don't create it unless
+    # we need it, but if we need it twice then we don't pay to create it twice.
+    lapply(stackTraceCallNames, function(st) {
+      rep_len(TRUE, length(st))
+    })
+  })
+
+  # stripStackTraces and lapply(stackTraceParents, pruneStackTrace) return lists
+  # of logical vectors. Use mapply(FUN = `&`) to boolean-and each pair of the
+  # logical vectors.
+  toShow <- mapply(
+    if (should_strip) stripStackTraces(stackTraceCallNames) else all_true,
+    if (should_prune) lapply(stackTraceParents, pruneStackTrace) else all_true,
+    FUN = `&`,
+    SIMPLIFY = FALSE
+  )
+
+  dfs <- mapply(seq_along(stackTraceCalls), rev(stackTraceCalls), rev(stackTraceCallNames), rev(toShow), FUN = function(i, calls, nms, index) {
+    st <- data.frame(
+      num = rev(which(index)),
+      call = rev(nms[index]),
+      loc = rev(getLocs(calls[index])),
+      category = rev(getCallCategories(calls[index])),
+      stringsAsFactors = FALSE
+    )
+
+    if (i != 1) {
+      message("From earlier call:")
+    }
+
+    if (nrow(st) == 0) {
+      message("  [No stack trace available]")
+    } else {
+      width <- floor(log10(max(st$num))) + 1
+      formatted <- paste0(
+        "  ",
+        formatC(st$num, width = width),
+        ": ",
+        mapply(paste0(st$call, st$loc), st$category, FUN = function(name, category) {
+          if (category == "pkg")
+            crayon::silver(name)
+          else if (category == "user")
+            crayon::blue$bold(name)
+          else
+            crayon::white(name)
+        }),
+        "\n"
+      )
+      cat(file = stderr(), formatted, sep = "")
+    }
+
+    st
+  }, SIMPLIFY = FALSE)
+
+  invisible()
 }
 
 stripStackTraces <- function(stackTraces, values = FALSE) {
@@ -503,17 +419,8 @@ pruneStackTrace <- function(parents) {
   # Loop over the parent indices. Anything that is not parented by current_node
   # (a.k.a. last-known-good node), or is a dupe, can be discarded. Anything that
   # is kept becomes the new current_node.
-  #
-  # jcheng 2022-03-18: Two more reasons a node can be kept:
-  #   1. parent is 0
-  #   2. parent is i
-  # Not sure why either of these situations happen, but they're common when
-  # interacting with rlang/dplyr errors. See issue rstudio/shiny#3250 for repro
-  # cases.
   include <- vapply(seq_along(parents), function(i) {
-    if ((!is_dupe[[i]] && parents[[i]] == current_node) ||
-        parents[[i]] == 0 ||
-        parents[[i]] == i) {
+    if (!is_dupe[[i]] && parents[[i]] == current_node) {
       current_node <<- i
       TRUE
     } else {
@@ -540,34 +447,6 @@ dropTrivialFrames <- function(callnames) {
   )
 }
 
-dropTrivialTestFrames <- function(callnames) {
-  if (!identical(Sys.getenv("TESTTHAT_IS_SNAPSHOT"), "true")) {
-    return(rep_len(TRUE, length(callnames)))
-  }
-
-  hideable <- callnames %in% c(
-    "test",
-    "devtools::test",
-    "test_check",
-    "testthat::test_check",
-    "test_dir",
-    "testthat::test_dir",
-    "test_file",
-    "testthat::test_file",
-    "test_local",
-    "testthat::test_local"
-  )
-
-  # Remove everything from inception to calling the test
-  # It shouldn't matter how you get there, just that you're finally testing
-  toRemove <- max(which(hideable))
-
-  c(
-    rep_len(FALSE, toRemove),
-    rep_len(TRUE, length(callnames) - toRemove)
-  )
-}
-
 offsetSrcrefs <- function(calls, offset = TRUE) {
   if (offset) {
     srcrefs <- getSrcRefs(calls)

R/devmode.R

@@ -1,6 +1,6 @@
 #' Shiny Developer Mode
 #'
-#' @description `r lifecycle::badge("experimental")`
+#' @description \lifecycle{experimental}
 #'
 #'   Developer Mode enables a number of [options()] to make a developer's life
 #'   easier, like enabling non-minified JS and printing messages about
@@ -128,12 +128,6 @@ in_devmode <- function() {
     !identical(Sys.getenv("TESTTHAT"), "true")
 }
 
-in_client_devmode <- function() {
-  # Client-side devmode enables client-side only dev features without local
-  # devmode. Currently, the main feature is the client-side error console.
-  isTRUE(getOption("shiny.client_devmode", FALSE))
-}
-
 #' @describeIn devmode Temporarily set Shiny Developer Mode and Developer
 #'   message verbosity
 #' @param code Code to execute with the temporary Dev Mode options set
@@ -196,10 +190,8 @@ devmode_inform <- function(
 
 
 
-registered_devmode_options <- NULL
-on_load({
-  registered_devmode_options <- Map$new()
-})
+#' @include map.R
+registered_devmode_options <- Map$new()
 
 #' @describeIn devmode Registers a Shiny Developer Mode option with an updated
 #'   value and Developer message. This registration method allows package
@@ -348,22 +340,21 @@ get_devmode_option <- function(
 }
 
 
-on_load({
-  register_devmode_option(
-    "shiny.autoreload",
-    "Turning on shiny autoreload. To disable, call `options(shiny.autoreload = FALSE)`",
-    TRUE
-  )
 
-  register_devmode_option(
-    "shiny.minified",
-    "Using full shiny javascript file. To use the minified version, call `options(shiny.minified = TRUE)`",
-    FALSE
-  )
+register_devmode_option(
+  "shiny.autoreload",
+  "Turning on shiny autoreload. To disable, call `options(shiny.autoreload = FALSE)`",
+  TRUE
+)
 
-  register_devmode_option(
-    "shiny.fullstacktrace",
-    "Turning on full stack trace. To disable, call `options(shiny.fullstacktrace = FALSE)`",
-    TRUE
-  )
-})
+register_devmode_option(
+  "shiny.minified",
+  "Using full shiny javascript file. To use the minified version, call `options(shiny.minified = TRUE)`",
+  FALSE
+)
+
+register_devmode_option(
+  "shiny.fullstacktrace",
+  "Turning on full stack trace. To disable, call `options(shiny.fullstacktrace = FALSE)`",
+  TRUE
+)

R/extended-task.R

@@ -1,338 +0,0 @@
-#' Task or computation that proceeds in the background
-#'
-#' @description In normal Shiny reactive code, whenever an observer, calc, or
-#'   output is busy computing, it blocks the current session from receiving any
-#'   inputs or attempting to proceed with any other computation related to that
-#'   session.
-#'
-#'   The `ExtendedTask` class allows you to have an expensive operation that is
-#'   started by a reactive effect, and whose (eventual) results can be accessed
-#'   by a regular observer, calc, or output; but during the course of the
-#'   operation, the current session is completely unblocked, allowing the user
-#'   to continue using the rest of the app while the operation proceeds in the
-#'   background.
-#'
-#'   Note that each `ExtendedTask` object does not represent a _single
-#'   invocation_ of its long-running function. Rather, it's an object that is
-#'   used to invoke the function with different arguments, keeps track of
-#'   whether an invocation is in progress, and provides ways to get at the
-#'   current status or results of the operation. A single `ExtendedTask` object
-#'   does not permit overlapping invocations: if the `invoke()` method is called
-#'   before the previous `invoke()` is completed, the new invocation will not
-#'   begin until the previous invocation has completed.
-#'
-#' @section `ExtendedTask` versus asynchronous reactives:
-#'
-#'   Shiny has long supported [using
-#'   \{promises\}](https://rstudio.github.io/promises/articles/promises_06_shiny.html)
-#'   to write asynchronous observers, calcs, or outputs. You may be wondering
-#'   what the differences are between those techniques and this class.
-#'
-#'   Asynchronous observers, calcs, and outputs are not--and have never
-#'   been--designed to let a user start a long-running operation, while keeping
-#'   that very same (browser) session responsive to other interactions. Instead,
-#'   they unblock other sessions, so you can take a long-running operation that
-#'   would normally bring the entire R process to a halt and limit the blocking
-#'   to just the session that started the operation. (For more details, see the
-#'   section on ["The Flush
-#'   Cycle"](https://rstudio.github.io/promises/articles/promises_06_shiny.html#the-flush-cycle).)
-#'
-#'   `ExtendedTask`, on the other hand, invokes an asynchronous function (that
-#'   is, a function that quickly returns a promise) and allows even that very
-#'   session to immediately unblock and carry on with other user interactions.
-#'
-#' @section OpenTelemetry Integration:
-#'
-#' When an `ExtendedTask` is created, if OpenTelemetry tracing is enabled for
-#' `"reactivity"` (see [withOtelCollect()]), the `ExtendedTask` will record
-#' spans for each invocation of the task. The tracing level at `invoke()` time
-#' does not affect whether spans are recorded; only the tracing level when
-#' calling `ExtendedTask$new()` matters.
-#'
-#' The OTel span will be named based on the label created from the variable the
-#' `ExtendedTask` is assigned to. If no label can be determined, the span will
-#' be named `<anonymous>`. Similar to other Shiny OpenTelemetry spans, the span
-#' will also include source reference attributes and session ID attributes.
-#'
-#' ```r
-#' withOtelCollect("all", {
-#'   my_task <- ExtendedTask$new(function(...) { ... })
-#' })
-#'
-#' # Span recorded for this invocation: ExtendedTask my_task
-#' my_task$invoke(...)
-#' ```
-#'
-#' @examplesIf rlang::is_interactive() && rlang::is_installed("mirai")
-#' library(shiny)
-#' library(bslib)
-#' library(mirai)
-#'
-#' # Set background processes for running tasks
-#' daemons(1)
-#' # Reset when the app is stopped
-#' onStop(function() daemons(0))
-#'
-#' ui <- page_fluid(
-#'   titlePanel("Extended Task Demo"),
-#'   p(
-#'     'Click the button below to perform a "calculation"',
-#'     "that takes a while to perform."
-#'   ),
-#'   input_task_button("recalculate", "Recalculate"),
-#'   p(textOutput("result"))
-#' )
-#'
-#' server <- function(input, output) {
-#'   rand_task <- ExtendedTask$new(function() {
-#'     mirai(
-#'       {
-#'         # Slow operation goes here
-#'         Sys.sleep(2)
-#'         sample(1:100, 1)
-#'       }
-#'     )
-#'   })
-#'
-#'   # Make button state reflect task.
-#'   # If using R >=4.1, you can do this instead:
-#'   # rand_task <- ExtendedTask$new(...) |> bind_task_button("recalculate")
-#'   bind_task_button(rand_task, "recalculate")
-#'
-#'   observeEvent(input$recalculate, {
-#'     # Invoke the extended in an observer
-#'     rand_task$invoke()
-#'   })
-#'
-#'   output$result <- renderText({
-#'     # React to updated results when the task completes
-#'     number <- rand_task$result()
-#'     paste0("Your number is ", number, ".")
-#'   })
-#' }
-#'
-#' shinyApp(ui, server)
-#'
-#' @export
-ExtendedTask <- R6Class("ExtendedTask", portable = TRUE, cloneable = FALSE,
-  public = list(
-    #' @description
-    #' Creates a new `ExtendedTask` object. `ExtendedTask` should generally be
-    #' created either at the top of a server function, or at the top of a module
-    #' server function.
-    #'
-    #' @param func The long-running operation to execute. This should be an
-    #'   asynchronous function, meaning, it should use the
-    #'   [\{promises\}](https://rstudio.github.io/promises/) package, most
-    #'   likely in conjunction with the
-    #'   [\{mirai\}](https://mirai.r-lib.org) or
-    #'   [\{future\}](https://rstudio.github.io/promises/articles/promises_04_futures.html)
-    #'   package. (In short, the return value of `func` should be a
-    #'   [`mirai`][mirai::mirai()], [`Future`][future::future()], `promise`,
-    #'   or something else that [promises::as.promise()] understands.)
-    #'
-    #'   It's also important that this logic does not read from any
-    #'   reactive inputs/sources, as inputs may change after the function is
-    #'   invoked; instead, if the function needs to access reactive inputs, it
-    #'   should take parameters and the caller of the `invoke()` method should
-    #'   read reactive inputs and pass them as arguments.
-    initialize = function(func) {
-      private$func <- func
-
-      # Do not show these private reactive values in otel spans
-      with_no_otel_collect({
-        private$rv_status <- reactiveVal("initial", label = "ExtendedTask$private$status")
-        private$rv_value <- reactiveVal(NULL, label = "ExtendedTask$private$value")
-        private$rv_error <- reactiveVal(NULL, label = "ExtendedTask$private$error")
-      })
-
-      private$invocation_queue <- fastmap::fastqueue()
-
-      domain <- getDefaultReactiveDomain()
-
-      # Set a label for the reactive values for easier debugging
-      # Go up an extra sys.call() to get the user's call to ExtendedTask$new()
-      # The first sys.call() is to `initialize(...)`
-      call_srcref <- get_call_srcref(-1)
-      label <- rassignSrcrefToLabel(
-        call_srcref,
-        defaultLabel = "<anonymous>"
-      )
-      private$otel_span_label <- otel_span_label_extended_task(label, domain = domain)
-      private$otel_log_label_add_to_queue <- otel_log_label_extended_task_add_to_queue(label, domain = domain)
-
-      private$otel_attrs <- c(
-        otel_srcref_attributes(call_srcref, "ExtendedTask"),
-        otel_session_id_attrs(domain)
-      ) %||% list()
-
-      # Capture this value at init-time, not run-time
-      # This way, the span is only created if otel was enabled at time of creation... just like other spans
-      private$is_recording_otel <- has_otel_collect("reactivity")
-    },
-    #' @description
-    #' Starts executing the long-running operation. If this `ExtendedTask` is
-    #' already running (meaning, a previous call to `invoke()` is not yet
-    #' complete) then enqueues this invocation until after the current
-    #' invocation, and any already-enqueued invocation, completes.
-    #'
-    #' @param ... Parameters to use for this invocation of the underlying
-    #'   function. If reactive inputs are needed by the underlying function,
-    #'   they should be read by the caller of `invoke` and passed in as
-    #'   arguments.
-    invoke = function(...) {
-      args <- rlang::dots_list(..., .ignore_empty = "none")
-      call <- rlang::caller_call(n = 0)
-
-      if (
-        isolate(private$rv_status()) == "running" ||
-          private$invocation_queue$size() > 0
-      ) {
-        otel_log(
-          private$otel_log_add_to_queue_label,
-          severity = "debug",
-          attributes = c(
-            private$otel_attrs,
-            list(
-              queue_size = private$invocation_queue$size() + 1L
-            )
-          )
-        )
-        private$invocation_queue$add(list(args = args, call = call))
-      } else {
-
-        if (private$is_recording_otel) {
-          private$otel_span <- start_otel_span(
-            private$otel_span_label,
-            attributes = private$otel_attrs
-          )
-          otel::local_active_span(private$otel_span)
-        }
-
-        private$do_invoke(args, call = call)
-      }
-      invisible(NULL)
-    },
-    #' @description
-    #' This is a reactive read that invalidates the caller when the task's
-    #' status changes.
-    #'
-    #' Returns one of the following values:
-    #'
-    #' * `"initial"`: This `ExtendedTask` has not yet been invoked
-    #' * `"running"`: An invocation is currently running
-    #' * `"success"`: An invocation completed successfully, and a value can be
-    #'   retrieved via the `result()` method
-    #' * `"error"`: An invocation completed with an error, which will be
-    #'   re-thrown if you call the `result()` method
-    status = function() {
-      private$rv_status()
-    },
-    #' @description
-    #' Attempts to read the results of the most recent invocation. This is a
-    #' reactive read that invalidates as the task's status changes.
-    #'
-    #' The actual behavior differs greatly depending on the current status of
-    #' the task:
-    #'
-    #' * `"initial"`: Throws a silent error (like [`req(FALSE)`][req()]). If
-    #'   this happens during output rendering, the output will be blanked out.
-    #' * `"running"`: Throws a special silent error that, if it happens during
-    #'   output rendering, makes the output appear "in progress" until further
-    #'   notice.
-    #' * `"success"`: Returns the return value of the most recent invocation.
-    #' * `"error"`: Throws whatever error was thrown by the most recent
-    #'   invocation.
-    #'
-    #' This method is intended to be called fairly naively by any output or
-    #' reactive expression that cares about the output--you just have to be
-    #' aware that if the result isn't ready for whatever reason, processing will
-    #' stop in much the same way as `req(FALSE)` does, but when the result is
-    #' ready you'll get invalidated, and when you run again the result should be
-    #' there.
-    #'
-    #' Note that the `result()` method is generally not meant to be used with
-    #' [observeEvent()], [eventReactive()], [bindEvent()], or [isolate()] as the
-    #' invalidation will be ignored.
-    result = function() {
-      switch (private$rv_status(),
-        running = req(FALSE, cancelOutput = "progress"),
-        success = if (private$rv_value()$visible) {
-          private$rv_value()$value
-        } else {
-          invisible(private$rv_value()$value)
-        },
-        error = stop(private$rv_error()),
-        # default case (initial, cancelled)
-        req(FALSE)
-      )
-    }
-  ),
-  private = list(
-    func = NULL,
-    # reactive value with "initial"|"running"|"success"|"error"
-    rv_status = NULL,
-    rv_value = NULL,
-    rv_error = NULL,
-    invocation_queue = NULL,
-
-    otel_span_label = NULL,
-    otel_log_label_add_to_queue = NULL,
-    otel_attrs = list(),
-    is_recording_otel = FALSE,
-    otel_span = NULL,
-
-    do_invoke = function(args, call = NULL) {
-      private$rv_status("running")
-      private$rv_value(NULL)
-      private$rv_error(NULL)
-
-      p <- promise_resolve(
-        maskReactiveContext(do.call(private$func, args))
-      )
-
-      p <- promises::then(
-        p,
-        onFulfilled = function(value, .visible) {
-          if (is_otel_span(private$otel_span)) {
-
-            private$otel_span$end(status_code = "ok")
-            private$otel_span <- NULL
-          }
-          private$on_success(list(value = value, visible = .visible))
-        },
-        onRejected = function(error) {
-          if (is_otel_span(private$otel_span)) {
-            private$otel_span$end(status_code = "error")
-            private$otel_span <- NULL
-          }
-          private$on_error(error, call = call)
-        }
-      )
-
-      promises::finally(p, onFinally = function() {
-        if (private$invocation_queue$size() > 0) {
-          next_call <- private$invocation_queue$remove()
-          private$do_invoke(next_call$args, next_call$call)
-        }
-      })
-
-      invisible(NULL)
-    },
-
-    on_error = function(err, call = NULL) {
-      cli::cli_warn(
-        "ERROR: An error occurred when invoking the ExtendedTask.",
-        parent = err,
-        call = call
-      )
-      private$rv_status("error")
-      private$rv_error(err)
-    },
-
-    on_success = function(value) {
-      private$rv_status("success")
-      private$rv_value(value)
-    }
-  )
-)

R/globals.R

@@ -1,31 +1,74 @@
 # A scope where we can put mutable global state
 .globals <- new.env(parent = emptyenv())
 
+register_s3_method <- function(pkg, generic, class, fun = NULL) {
+  stopifnot(is.character(pkg), length(pkg) == 1)
+  stopifnot(is.character(generic), length(generic) == 1)
+  stopifnot(is.character(class), length(class) == 1)
+
+  if (is.null(fun)) {
+    fun <- get(paste0(generic, ".", class), envir = parent.frame())
+  } else {
+    stopifnot(is.function(fun))
+  }
+
+  if (pkg %in% loadedNamespaces()) {
+    registerS3method(generic, class, fun, envir = asNamespace(pkg))
+  }
+
+  # Always register hook in case pkg is loaded at some
+  # point the future (or, potentially, but less commonly,
+  # unloaded & reloaded)
+  setHook(
+    packageEvent(pkg, "onLoad"),
+    function(...) {
+      registerS3method(generic, class, fun, envir = asNamespace(pkg))
+    }
+  )
+}
+
+register_upgrade_message <- function(pkg, version) {
+
+  msg <- sprintf(
+    "This version of Shiny is designed to work with '%s' >= %s.
+    Please upgrade via install.packages('%s').",
+    pkg, version, pkg
+  )
+
+  if (pkg %in% loadedNamespaces() && !is_available(pkg, version)) {
+    packageStartupMessage(msg)
+  }
+
+  # Always register hook in case pkg is loaded at some
+  # point the future (or, potentially, but less commonly,
+  # unloaded & reloaded)
+  setHook(
+    packageEvent(pkg, "onLoad"),
+    function(...) {
+      if (!is_available(pkg, version)) packageStartupMessage(msg)
+    }
+  )
+}
+
 .onLoad <- function(libname, pkgname) {
   # R's lazy-loading package scheme causes the private seed to be cached in the
   # package itself, making our PRNG completely deterministic. This line resets
   # the private seed during load.
   withPrivateSeed(set.seed(NULL))
 
-  for (expr in on_load_exprs) {
-    eval(expr, envir = environment(.onLoad))
-  }
+  # Create this at the top level, but since the object is from a different
+  # package, we don't want to bake it into the built binary package.
+  restoreCtxStack <<- fastmap::faststack()
 
   # Make sure these methods are available to knitr if shiny is loaded but not
   # attached.
-  s3_register("knitr::knit_print", "reactive")
-  s3_register("knitr::knit_print", "shiny.appobj")
-  s3_register("knitr::knit_print", "shiny.render.function")
+  register_s3_method("knitr", "knit_print", "reactive")
+  register_s3_method("knitr", "knit_print", "shiny.appobj")
+  register_s3_method("knitr", "knit_print", "shiny.render.function")
+
+  # Shiny 1.4.0 bumps jQuery 1.x to 3.x, which caused a problem
+  # with static-rendering of htmlwidgets, and htmlwidgets 1.5
+  # includes a fix for this problem
+  # https://github.com/rstudio/shiny/issues/2630
+  register_upgrade_message("htmlwidgets", 1.5)
 }
-
-
-on_load_exprs <- list()
-# Register an expression to be evaluated when the package is loaded (in the
-# .onLoad function).
-on_load <- function(expr) {
-  on_load_exprs[[length(on_load_exprs) + 1]] <<- substitute(expr)
-}
-
-on_load({
-  IS_SHINY_LOCAL_PKG <- exists(".__DEVTOOLS__")
-})

R/graph.R

@@ -1,3 +1,32 @@
+# Check that the version of an suggested package satisfies the requirements
+#
+# @param package The name of the suggested package
+# @param version The version of the package
+check_suggested <- function(package, version = NULL) {
+
+  if (is_available(package, version)) {
+    return()
+  }
+
+  msg <- paste0(
+    sQuote(package),
+    if (is.na(version %||% NA)) "" else paste0("(>= ", version, ")"),
+    " must be installed for this functionality."
+  )
+
+  if (interactive()) {
+    message(msg, "\nWould you like to install it?")
+    if (utils::menu(c("Yes", "No")) == 1) {
+      return(utils::install.packages(package))
+    }
+  }
+
+  stop(msg, call. = FALSE)
+}
+
+
+
+
 # domain is like session
 
 
@@ -19,7 +48,7 @@ reactIdStr <- function(num) {
 #' dependencies and execution in your application.
 #'
 #' To use the reactive log visualizer, start with a fresh R session and
-#' run the command `reactlog::reactlog_enable()`; then launch your
+#' run the command `options(shiny.reactlog=TRUE)`; then launch your
 #' application in the usual way (e.g. using [runApp()]). At
 #' any time you can hit Ctrl+F3 (or for Mac users, Command+F3) in your
 #' web browser to launch the reactive log visualization.
@@ -42,20 +71,16 @@ reactIdStr <- function(num) {
 #' call `reactlogShow()` explicitly.
 #'
 #' For security and performance reasons, do not enable
-#' `options(shiny.reactlog=TRUE)` (or `reactlog::reactlog_enable()`) in
-#' production environments. When the option is enabled, it's possible
-#' for any user of your app to see at least some of the source code of
-#' your reactive expressions and observers. In addition, reactlog
-#' should be considered a memory leak as it will constantly grow and
-#' will never reset until the R session is restarted.
+#' `shiny.reactlog` in production environments. When the option is
+#' enabled, it's possible for any user of your app to see at least some
+#' of the source code of your reactive expressions and observers.
 #'
 #' @name reactlog
 NULL
 
 
-#' @describeIn reactlog Return a list of reactive information.  Can be used in
-#'   conjunction with [reactlog::reactlog_show] to later display the reactlog
-#'   graph.
+#' @describeIn reactlog Return a list of reactive information.  Can be used in conjunction with
+#'   [reactlog::reactlog_show] to later display the reactlog graph.
 #' @export
 reactlog <- function() {
   rLog$asList()
@@ -70,34 +95,12 @@ reactlogShow <- function(time = TRUE) {
   reactlog::reactlog_show(reactlog(), time = time)
 }
 
-#' @describeIn reactlog Resets the entire reactlog stack.  Useful for debugging
-#' and removing all prior reactive history.
+#' @describeIn reactlog Resets the entire reactlog stack.  Useful for debugging and removing all prior reactive history.
 #' @export
 reactlogReset <- function() {
   rLog$reset()
 }
 
-#' @describeIn reactlog Adds "mark" entry into the reactlog stack. This is
-#' useful for programmatically adding a marked entry in the reactlog, rather
-#' than using your keyboard's key combination.
-#'
-#' For example, we can _mark_ the reactlog at the beginning of an
-#' `observeEvent`'s calculation:
-#' ```r
-#' observeEvent(input$my_event_trigger, {
-#'   # Add a mark in the reactlog
-#'   reactlogAddMark()
-#'   # Run your regular event reaction code here...
-#'   ....
-#' })
-#' ```
-#' @param session The Shiny session to assign the mark to. Defaults to the
-#' current session.
-#' @export
-reactlogAddMark <- function(session = getDefaultReactiveDomain()) {
-  rLog$userMark(session)
-}
-
 # called in "/reactlog" middleware
 renderReactlog <- function(sessionToken = NULL, time = TRUE) {
   check_reactlog()
@@ -107,15 +110,28 @@ renderReactlog <- function(sessionToken = NULL, time = TRUE) {
     time = time
   )
 }
-
 check_reactlog <- function() {
-  if (!is_installed("reactlog", reactlog_min_version)) {
-    rlang::check_installed("reactlog", reactlog_min_version)
+  check_suggested("reactlog", reactlog_version())
+}
+# read reactlog version from description file
+# prevents version mismatch in code and description file
+reactlog_version <- function() {
+  desc <- read.dcf(system.file("DESCRIPTION", package = "shiny", mustWork = TRUE))
+  suggests <- desc[1,"Suggests"][[1]]
+  suggests_pkgs <- strsplit(suggests, "\n")[[1]]
+
+  reactlog_info <- suggests_pkgs[grepl("reactlog", suggests_pkgs)]
+  if (length(reactlog_info) == 0) {
+    stop("reactlog can not be found in shiny DESCRIPTION file")
   }
+
+  reactlog_info <- sub("^[^\\(]*\\(", "", reactlog_info)
+  reactlog_info <- sub("\\)[^\\)]*$", "", reactlog_info)
+  reactlog_info <- sub("^[>= ]*", "", reactlog_info)
+
+  package_version(reactlog_info)
 }
 
-# Should match the (suggested) version in DESCRIPTION file
-reactlog_min_version <- "1.0.0"
 
 RLog <- R6Class(
   "RLog",
@@ -123,6 +139,7 @@ RLog <- R6Class(
   private = list(
     option = "shiny.reactlog",
     msgOption = "shiny.reactlog.console",
+
     appendEntry = function(domain, logEntry) {
       if (self$isLogging()) {
         sessionToken <- if (is.null(domain)) NULL else domain$token
@@ -137,19 +154,20 @@ RLog <- R6Class(
   public = list(
     msg = "<MessageLogger>",
     logStack = "<Stack>",
+
     noReactIdLabel = "NoCtxReactId",
     noReactId = reactIdStr("NoCtxReactId"),
     dummyReactIdLabel = "DummyReactId",
     dummyReactId = reactIdStr("DummyReactId"),
+
     asList = function() {
       ret <- self$logStack$as_list()
       attr(ret, "version") <- "1"
       ret
     },
+
     ctxIdStr = function(ctxId) {
-      if (is.null(ctxId) || identical(ctxId, "")) {
-        return(NULL)
-      }
+      if (is.null(ctxId) || identical(ctxId, "")) return(NULL)
       paste0("ctx", ctxId)
     },
     namesIdStr = function(reactId) {
@@ -164,6 +182,7 @@ RLog <- R6Class(
     keyIdStr = function(reactId, key) {
       paste0(reactId, "$", key)
     },
+
     valueStr = function(value, n = 200) {
       if (!self$isLogging()) {
         # return a placeholder string to avoid calling str
@@ -173,9 +192,10 @@ RLog <- R6Class(
         # only capture the first level of the object
         utils::capture.output(utils::str(value, max.level = 1))
       })
-      outputTxt <- paste0(output, collapse = "\n")
+      outputTxt <- paste0(output, collapse="\n")
       msg$shortenString(outputTxt, n = n)
     },
+
     initialize = function(rlogOption = "shiny.reactlog", msgOption = "shiny.reactlog.console") {
       private$option <- rlogOption
       private$msgOption <- msgOption
@@ -195,6 +215,7 @@ RLog <- R6Class(
     isLogging = function() {
       isTRUE(getOption(private$option, FALSE))
     },
+
     define = function(reactId, value, label, type, domain) {
       valueStr <- self$valueStr(value)
       if (msg$hasReact(reactId)) {
@@ -225,10 +246,9 @@ RLog <- R6Class(
     defineObserver = function(reactId, label, domain) {
       self$define(reactId, value = NULL, label, "observer", domain)
     },
+
     dependsOn = function(reactId, depOnReactId, ctxId, domain) {
-      if (is.null(reactId)) {
-        return()
-      }
+      if (is.null(reactId)) return()
       ctxId <- ctxIdStr(ctxId)
       msg$log("dependsOn:", msg$reactStr(reactId), " on", msg$reactStr(depOnReactId), msg$ctxStr(ctxId))
       private$appendEntry(domain, list(
@@ -241,6 +261,7 @@ RLog <- R6Class(
     dependsOnKey = function(reactId, depOnReactId, key, ctxId, domain) {
       self$dependsOn(reactId, self$keyIdStr(depOnReactId, key), ctxId, domain)
     },
+
     dependsOnRemove = function(reactId, depOnReactId, ctxId, domain) {
       ctxId <- self$ctxIdStr(ctxId)
       msg$log("dependsOnRemove:", msg$reactStr(reactId), " on", msg$reactStr(depOnReactId), msg$ctxStr(ctxId))
@@ -254,6 +275,7 @@ RLog <- R6Class(
     dependsOnKeyRemove = function(reactId, depOnReactId, key, ctxId, domain) {
       self$dependsOnRemove(reactId, self$keyIdStr(depOnReactId, key), ctxId, domain)
     },
+
     createContext = function(ctxId, label, type, prevCtxId, domain) {
       ctxId <- self$ctxIdStr(ctxId)
       prevCtxId <- self$ctxIdStr(prevCtxId)
@@ -264,9 +286,10 @@ RLog <- R6Class(
         label = msg$shortenString(label),
         type = type,
         prevCtxId = prevCtxId,
-        srcref = as.vector(attr(label, "srcref")), srcfile = attr(label, "srcfile")
+        srcref = as.vector(attr(label, "srcref")), srcfile=attr(label, "srcfile")
       ))
     },
+
     enter = function(reactId, ctxId, type, domain) {
       ctxId <- self$ctxIdStr(ctxId)
       if (identical(type, "isolate")) {
@@ -309,6 +332,7 @@ RLog <- R6Class(
         ))
       }
     },
+
     valueChange = function(reactId, value, domain) {
       valueStr <- self$valueStr(value)
       msg$log("valueChange:", msg$reactStr(reactId), msg$valueStr(valueStr))
@@ -330,6 +354,8 @@ RLog <- R6Class(
     valueChangeKey = function(reactId, key, value, domain) {
       self$valueChange(self$keyIdStr(reactId, key), value, domain)
     },
+
+
     invalidateStart = function(reactId, ctxId, type, domain) {
       ctxId <- self$ctxIdStr(ctxId)
       if (identical(type, "isolate")) {
@@ -372,6 +398,7 @@ RLog <- R6Class(
         ))
       }
     },
+
     invalidateLater = function(reactId, runningCtx, millis, domain) {
       msg$log("invalidateLater: ", millis, "ms", msg$reactStr(reactId), msg$ctxStr(runningCtx))
       private$appendEntry(domain, list(
@@ -381,12 +408,14 @@ RLog <- R6Class(
         millis = millis
       ))
     },
+
     idle = function(domain = NULL) {
       msg$log("idle")
       private$appendEntry(domain, list(
         action = "idle"
       ))
     },
+
     asyncStart = function(domain = NULL) {
       msg$log("asyncStart")
       private$appendEntry(domain, list(
@@ -399,6 +428,7 @@ RLog <- R6Class(
         action = "asyncStop"
       ))
     },
+
     freezeReactiveVal = function(reactId, domain) {
       msg$log("freeze:", msg$reactStr(reactId))
       private$appendEntry(domain, list(
@@ -409,6 +439,7 @@ RLog <- R6Class(
     freezeReactiveKey = function(reactId, key, domain) {
       self$freezeReactiveVal(self$keyIdStr(reactId, key), domain)
     },
+
     thawReactiveVal = function(reactId, domain) {
       msg$log("thaw:", msg$reactStr(reactId))
       private$appendEntry(domain, list(
@@ -419,60 +450,54 @@ RLog <- R6Class(
     thawReactiveKey = function(reactId, key, domain) {
       self$thawReactiveVal(self$keyIdStr(reactId, key), domain)
     },
+
     userMark = function(domain = NULL) {
       msg$log("userMark")
       private$appendEntry(domain, list(
         action = "userMark"
       ))
     }
+
   )
 )
 
-MessageLogger <- R6Class(
+MessageLogger = R6Class(
   "MessageLogger",
   portable = FALSE,
   public = list(
     depth = 0L,
     reactCache = list(),
     option = "shiny.reactlog.console",
+
     initialize = function(option = "shiny.reactlog.console", depth = 0L) {
       if (!missing(depth)) self$depth <- depth
       if (!missing(option)) self$option <- option
     },
+
     isLogging = function() {
       isTRUE(getOption(self$option))
     },
     isNotLogging = function() {
-      !isTRUE(getOption(self$option))
+      ! isTRUE(getOption(self$option))
     },
     depthIncrement = function() {
-      if (self$isNotLogging()) {
-        return(NULL)
-      }
+      if (self$isNotLogging()) return(NULL)
       self$depth <- self$depth + 1L
     },
     depthDecrement = function() {
-      if (self$isNotLogging()) {
-        return(NULL)
-      }
+      if (self$isNotLogging()) return(NULL)
       self$depth <- self$depth - 1L
     },
     hasReact = function(reactId) {
-      if (self$isNotLogging()) {
-        return(FALSE)
-      }
+      if (self$isNotLogging()) return(FALSE)
       !is.null(self$getReact(reactId))
     },
     getReact = function(reactId, force = FALSE) {
-      if (identical(force, FALSE) && self$isNotLogging()) {
-        return(NULL)
-      }
+      if (identical(force, FALSE) && self$isNotLogging()) return(NULL)
       self$reactCache[[reactId]]
     },
     setReact = function(reactObj, force = FALSE) {
-      if (identical(force, FALSE) && self$isNotLogging()) {
-        return(NULL)
-      }
+      if (identical(force, FALSE) && self$isNotLogging()) return(NULL)
       self$reactCache[[reactObj$reactId]] <- reactObj
     },
     shortenString = function(txt, n = 250) {
@@ -491,17 +516,13 @@ MessageLogger <- R6Class(
     },
     valueStr = function(valueStr) {
       paste0(
-        " '", self$shortenString(self$singleLine(valueStr)), "'"
+        " '",  self$shortenString(self$singleLine(valueStr)), "'"
       )
     },
     reactStr = function(reactId) {
-      if (self$isNotLogging()) {
-        return(NULL)
-      }
+      if (self$isNotLogging()) return(NULL)
       reactInfo <- self$getReact(reactId)
-      if (is.null(reactInfo)) {
-        return(" <UNKNOWN_REACTID>")
-      }
+      if (is.null(reactInfo)) return(" <UNKNOWN_REACTID>")
       paste0(
         " ", reactInfo$reactId, ":'", self$shortenString(self$singleLine(reactInfo$label)), "'"
       )
@@ -510,15 +531,11 @@ MessageLogger <- R6Class(
       self$ctxStr(ctxId = NULL, type = type)
     },
     ctxStr = function(ctxId = NULL, type = NULL) {
-      if (self$isNotLogging()) {
-        return(NULL)
-      }
+      if (self$isNotLogging()) return(NULL)
       self$ctxPrevCtxStr(ctxId = ctxId, prevCtxId = NULL, type = type)
     },
     ctxPrevCtxStr = function(ctxId = NULL, prevCtxId = NULL, type = NULL, preCtxIdTxt = " in ") {
-      if (self$isNotLogging()) {
-        return(NULL)
-      }
+      if (self$isNotLogging()) return(NULL)
       paste0(
         if (!is.null(ctxId)) paste0(preCtxIdTxt, ctxId),
         if (!is.null(prevCtxId)) paste0(" from ", prevCtxId),
@@ -526,9 +543,7 @@ MessageLogger <- R6Class(
       )
     },
     log = function(...) {
-      if (self$isNotLogging()) {
-        return(NULL)
-      }
+      if (self$isNotLogging()) return(NULL)
       msg <- paste0(
         paste0(rep("= ", depth), collapse = ""), "- ", paste0(..., collapse = ""),
         collapse = ""
@@ -538,6 +553,4 @@ MessageLogger <- R6Class(
   )
 )
 
-on_load({
-  rLog <- RLog$new("shiny.reactlog", "shiny.reactlog.console")
-})
+rLog <- RLog$new("shiny.reactlog", "shiny.reactlog.console")

R/history.R

@@ -14,7 +14,7 @@ NULL
 #' depending on the values in the query string / hash (e.g. instead of basing
 #' the conditional on an input or a calculated reactive, you can base it on the
 #' query string). However, note that, if you're changing the query string / hash
-#' programmatically from within the server code, you must use
+#' programatically from within the server code, you must use
 #' `updateQueryString(_yourNewQueryString_, mode = "push")`. The default
 #' `mode` for `updateQueryString` is `"replace"`, which doesn't
 #' raise any events, so any observers or reactives that depend on it will

R/image-interact.R

@@ -182,8 +182,8 @@ brushedPoints <- function(df, brush, xvar = NULL, yvar = NULL,
 #  $ xmax     : num 3.78
 #  $ ymin     : num 17.1
 #  $ ymax     : num 20.4
-#  $ panelvar1: chr "6"
-#  $ panelvar2: chr "0
+#  $ panelvar1: int 6
+#  $ panelvar2: int 0
 #  $ coords_css:List of 4
 #   ..$ xmin: int 260
 #   ..$ xmax: int 298
@@ -367,8 +367,8 @@ nearPoints <- function(df, coordinfo, xvar = NULL, yvar = NULL,
 #  $ img_css_ratio:List of 2
 #   ..$ x: num 1.25
 #   ..$ y: num 1.25
-#  $ panelvar1 : chr "6"
-#  $ panelvar2 : chr "0"
+#  $ panelvar1 : int 6
+#  $ panelvar2 : int 0
 #  $ mapping   :List of 4
 #   ..$ x        : chr "wt"
 #   ..$ y        : chr "mpg"

R/imageutils.R

@@ -1,23 +1,22 @@
 startPNG <- function(filename, width, height, res, ...) {
-  pngfun <- if ((getOption('shiny.useragg') %||% TRUE) && is_installed("ragg")) {
-    ragg::agg_png
+  # shiny.useragg is an experimental option that isn't officially supported or
+  # documented. It's here in the off chance that someone really wants
+  # to use ragg (say, instead of showtext, for custom font rendering).
+  # In the next shiny release, this option will likely be superseded in
+  # favor of a fully customizable graphics device option
+  if ((getOption('shiny.useragg') %||% FALSE) && is_available("ragg")) {
+    pngfun <- ragg::agg_png
   } else if (capabilities("aqua")) {
     # i.e., png(type = 'quartz')
-    grDevices::png
-  } else if ((getOption('shiny.usecairo') %||% TRUE) && is_installed("Cairo")) {
-    Cairo::CairoPNG
+    pngfun <- grDevices::png
+  } else if ((getOption('shiny.usecairo') %||% TRUE) && is_available("Cairo")) {
+    pngfun <- Cairo::CairoPNG
   } else {
     # i.e., png(type = 'cairo')
-    grDevices::png
+    pngfun <- grDevices::png
   }
 
-  args <- list2(filename = filename, width = width, height = height, res = res, ...)
-
-  # It's possible for width/height to be NULL/numeric(0) (e.g., when using
-  # suspendWhenHidden=F w/ tabsetPanel(), see rstudio/shiny#1409), so when
-  # this happens let the device determine what the default size should be.
-  if (length(args$width) == 0) args$width <- NULL
-  if (length(args$height) == 0) args$height <- NULL
+  args <- rlang::list2(filename=filename, width=width, height=height, res=res, ...)
 
   # Set a smarter default for the device's bg argument (based on thematic's global state).
   # Note that, technically, this is really only needed for CairoPNG, since the other
@@ -58,35 +57,33 @@ startPNG <- function(filename, width, height, res, ...) {
   grDevices::dev.cur()
 }
 
-#' Capture a plot as a PNG file.
+#' Run a plotting function and save the output as a PNG
 #'
-#' The PNG graphics device used is determined in the following order:
-#'   * If the ragg package is installed (and the `shiny.useragg` is not
-#'    set to `FALSE`), then use [ragg::agg_png()].
-#'   * If a quartz device is available (i.e., `capabilities("aqua")` is
-#'    `TRUE`), then use `png(type = "quartz")`.
-#'   * If the Cairo package is installed (and the `shiny.usecairo` option
-#'    is not set to `FALSE`), then use [Cairo::CairoPNG()].
-#'   * Otherwise, use [grDevices::png()]. In this case, Linux and Windows
-#'    may not antialias some point shapes, resulting in poor quality output.
+#' This function returns the name of the PNG file that it generates. In
+#' essence, it calls `png()`, then `func()`, then `dev.off()`.
+#' So `func` must be a function that will generate a plot when used this
+#' way.
 #'
-#' @details
-#'   A `NULL` value provided to `width` or `height` is ignored (i.e., the
-#'   default `width` or `height` of the graphics device is used).
+#' For output, it will try to use the following devices, in this order:
+#' quartz (via [grDevices::png()]), then [Cairo::CairoPNG()],
+#' and finally [grDevices::png()]. This is in order of quality of
+#' output. Notably, plain `png` output on Linux and Windows may not
+#' antialias some point shapes, resulting in poor quality output.
+#'
+#' In some cases, `Cairo()` provides output that looks worse than
+#' `png()`. To disable Cairo output for an app, use
+#' `options(shiny.usecairo=FALSE)`.
 #'
 #' @param func A function that generates a plot.
 #' @param filename The name of the output file. Defaults to a temp file with
 #'   extension `.png`.
 #' @param width Width in pixels.
 #' @param height Height in pixels.
-#' @param res Resolution in pixels per inch. This value is passed to the
-#'   graphics device. Note that this affects the resolution of PNG rendering in
+#' @param res Resolution in pixels per inch. This value is passed to
+#'   [grDevices::png()]. Note that this affects the resolution of PNG rendering in
 #'   R; it won't change the actual ppi of the browser.
-#' @param ... Arguments to be passed through to the graphics device. These can
-#'   be used to set the width, height, background color, etc.
-#'
-#' @return A path to the newly generated PNG file.
-#'
+#' @param ... Arguments to be passed through to [grDevices::png()].
+#'   These can be used to set the width, height, background color, etc.
 #' @export
 plotPNG <- function(func, filename=tempfile(fileext='.png'),
                     width=400, height=400, res=72, ...) {
@@ -100,7 +97,7 @@ plotPNG <- function(func, filename=tempfile(fileext='.png'),
 createGraphicsDevicePromiseDomain <- function(which = dev.cur()) {
   force(which)
 
-  new_promise_domain(
+  promises::new_promise_domain(
     wrapOnFulfilled = function(onFulfilled) {
       force(onFulfilled)
       function(...) {

R/input-action.R

@@ -7,8 +7,6 @@
 #' @param label The contents of the button or link--usually a text label, but
 #'   you could also use any other HTML, like an image.
 #' @param icon An optional [icon()] to appear on the button.
-#' @param disabled If `TRUE`, the button will not be clickable. Use
-#'   [updateActionButton()] to dynamically enable/disable the button.
 #' @param ... Named attributes to be applied to the button or link.
 #'
 #' @family input elements
@@ -51,29 +49,16 @@
 #'   * Event handlers (e.g., [observeEvent()], [eventReactive()]) won't execute on initial load.
 #'   * Input validation (e.g., [req()], [need()]) will fail on initial load.
 #' @export
-actionButton <- function(inputId, label, icon = NULL, width = NULL,
-  disabled = FALSE, ...) {
+actionButton <- function(inputId, label, icon = NULL, width = NULL, ...) {
 
   value <- restoreInput(id = inputId, default = NULL)
 
-  icon <- validateIcon(icon)
-
-  if (!is.null(icon)) {
-    icon <- span(icon, class = "action-icon")
-  }
-
-  if (!is.null(label)) {
-    label <- span(label, class = "action-label")
-  }
-
-  tags$button(
-    id = inputId,
+  tags$button(id=inputId,
     style = css(width = validateCssUnit(width)),
-    type = "button",
-    class = "btn btn-default action-button",
+    type="button",
+    class="btn btn-default action-button",
     `data-val` = value,
-    disabled = if (isTRUE(disabled)) NA else NULL,
-    icon, label,
+    list(validateIcon(icon), label),
     ...
   )
 }
@@ -83,40 +68,30 @@ actionButton <- function(inputId, label, icon = NULL, width = NULL,
 actionLink <- function(inputId, label, icon = NULL, ...) {
   value <- restoreInput(id = inputId, default = NULL)
 
-  icon <- validateIcon(icon)
-
-  if (!is.null(icon)) {
-    icon <- span(icon, class = "action-icon")
-  }
-
-  if (!is.null(label)) {
-    label <- span(label, class = "action-label")
-  }
-
-  tags$a(
-    id = inputId,
-    href = "#",
-    class = "action-button action-link",
+  tags$a(id=inputId,
+    href="#",
+    class="action-button",
     `data-val` = value,
-    icon, label,
+    list(validateIcon(icon), label),
     ...
   )
 }
 
 
-# Throw an informative warning if icon isn't html-ish
+# Check that the icon parameter is valid:
+# 1) Check  if the user wants to actually add an icon:
+#    -- if icon=NULL, it means leave the icon unchanged
+#    -- if icon=character(0), it means don't add an icon or, more usefully,
+#       remove the previous icon
+# 2) If so, check that the icon has the right format (this does not check whether
+# it is a *real* icon - currently that would require a massive cross reference
+# with the "font-awesome" and the "glyphicon" libraries)
 validateIcon <- function(icon) {
-  if (length(icon) == 0) {
+  if (is.null(icon) || identical(icon, character(0))) {
     return(icon)
+  } else if (inherits(icon, "shiny.tag") && icon$name == "i") {
+    return(icon)
+  } else {
+    stop("Invalid icon. Use Shiny's 'icon()' function to generate a valid icon")
   }
-  if (!isTagLike(icon)) {
-    rlang::warn(
-      c(
-        "It appears that a non-HTML value was provided to `icon`.",
-        i = "Try using a `shiny::icon()` (or an equivalent) to get an icon."
-      ),
-      class = "shiny-validate-icon"
-    )
-  }
-  icon
 }

R/input-checkbox.R

@@ -31,7 +31,7 @@ checkboxInput <- function(inputId, label, value = FALSE, width = NULL) {
 
   value <- restoreInput(id = inputId, default = value)
 
-  inputTag <- tags$input(id = inputId, type="checkbox", class = "shiny-input-checkbox")
+  inputTag <- tags$input(id = inputId, type="checkbox")
   if (!is.null(value) && value)
     inputTag$attribs$checked <- "checked"
 

R/input-date.R

@@ -138,8 +138,7 @@ datePickerDependency <- function(theme) {
     htmlDependency(
       name = "bootstrap-datepicker-js",
       version = version_bs_date_picker,
-      src = "www/shared/datepicker",
-      package = "shiny",
+      src = c(href = "shared/datepicker"),
       script = if (getOption("shiny.minified", TRUE)) "js/bootstrap-datepicker.min.js"
                else                                   "js/bootstrap-datepicker.js",
       # Need to enable noConflict mode. See #1346.
@@ -153,28 +152,23 @@ datePickerDependency <- function(theme) {
   )
 }
 
-datePickerSass <- function() {
-  sass::sass_file(
-    system_file(package = "shiny", "www/shared/datepicker/scss/build3.scss")
-  )
-}
-
 datePickerCSS <- function(theme) {
   if (!is_bs_theme(theme)) {
     return(htmlDependency(
       name = "bootstrap-datepicker-css",
       version = version_bs_date_picker,
-      src = "www/shared/datepicker",
-      package = "shiny",
+      src = c(href = "shared/datepicker"),
       stylesheet = "css/bootstrap-datepicker3.min.css"
     ))
   }
 
+  scss_file <- system.file(package = "shiny", "www/shared/datepicker/scss/build3.scss")
+
   bslib::bs_dependency(
-    input = datePickerSass(),
+    input = sass::sass_file(scss_file),
     theme = theme,
     name = "bootstrap-datepicker",
     version = version_bs_date_picker,
-    cache_key_extra = get_package_version("shiny")
+    cache_key_extra = shinyPackageVersion()
   )
 }

R/input-file.R

@@ -2,13 +2,8 @@
 #'
 #' Create a file upload control that can be used to upload one or more files.
 #'
-#' Whenever a file upload completes, the corresponding input variable is set to
-#' a dataframe. See the `Server value` section.
-#'
-#' Each time files are uploaded, they are written to a new random subdirectory
-#' inside of R's process-level temporary directory. The Shiny user session keeps
-#' track of all uploads in the session, and when the session ends, Shiny deletes
-#' all of the subdirectories where files where uploaded to.
+#' Whenever a file upload completes, the corresponding input variable is set
+#' to a dataframe. See the `Server value` section.
 #'
 #' @family input elements
 #'
@@ -16,30 +11,19 @@
 #' @param multiple Whether the user should be allowed to select and upload
 #'   multiple files at once. **Does not work on older browsers, including
 #'   Internet Explorer 9 and earlier.**
-#' @param accept A character vector of "unique file type specifiers" which gives
-#'   the browser a hint as to the type of file the server expects. Many browsers
-#'   use this prevent the user from selecting an invalid file.
+#' @param accept A character vector of "unique file type specifiers" which
+#'   gives the browser a hint as to the type of file the server expects.
+#'   Many browsers use this prevent the user from selecting an invalid file.
 #'
 #'   A unique file type specifier can be:
 #'   * A case insensitive extension like `.csv` or `.rds`.
 #'   * A valid MIME type, like `text/plain` or `application/pdf`
 #'   * One of `audio/*`, `video/*`, or `image/*` meaning any audio, video,
-#'   or image type, respectively.
+#'     or image type, respectively.
 #' @param buttonLabel The label used on the button. Can be text or an HTML tag
 #'   object.
 #' @param placeholder The text to show before a file has been uploaded.
-#' @param capture What source to use for capturing image, audio or video data.
-#'   This attribute facilitates user access to a device's media capture
-#'   mechanism, such as a camera, or microphone, from within a file upload
-#'   control.
 #'
-#'   A value of `user` indicates that the user-facing camera and/or microphone
-#'   should be used. A value of `environment` specifies that the outward-facing
-#'   camera and/or microphone should be used.
-#'
-#'   By default on most phones, this will accept still photos or video. For
-#'   still photos only, also use `accept="image/*"`. For video only, use
-#'   `accept="video/*"`.
 #' @examples
 #' ## Only run examples in interactive R sessions
 #' if (interactive()) {
@@ -72,9 +56,7 @@
 #' }
 #'
 #' @section Server value:
-#'
-#'   A `data.frame` that contains one row for each selected file, and following
-#'   columns:
+#' A `data.frame` that contains one row for each selected file, and following columns:
 #' \describe{
 #'   \item{`name`}{The filename provided by the web browser. This is
 #'   **not** the path to read to get at the actual data that was uploaded
@@ -91,8 +73,7 @@
 #'
 #' @export
 fileInput <- function(inputId, label, multiple = FALSE, accept = NULL,
-  width = NULL, buttonLabel = "Browse...", placeholder = "No file selected",
-  capture = NULL) {
+  width = NULL, buttonLabel = "Browse...", placeholder = "No file selected") {
 
   restoredValue <- restoreInput(id = inputId, default = NULL)
 
@@ -108,7 +89,6 @@ fileInput <- function(inputId, label, multiple = FALSE, accept = NULL,
 
   inputTag <- tags$input(
     id = inputId,
-    class = "shiny-input-file",
     name = inputId,
     type = "file",
     # Don't use "display: none;" style, which causes keyboard accessibility issue; instead use the following workaround: https://css-tricks.com/places-its-tempting-to-use-display-none-but-dont/
@@ -121,9 +101,6 @@ fileInput <- function(inputId, label, multiple = FALSE, accept = NULL,
   if (length(accept) > 0)
     inputTag$attribs$accept <- paste(accept, collapse=',')
 
-  if (!is.null(capture)) {
-    inputTag$attribs$capture <- capture
-  }
 
   div(class = "form-group shiny-input-container",
     style = css(width = validateCssUnit(width)),

R/input-numeric.R

@@ -29,36 +29,22 @@
 #' A numeric vector of length 1.
 #'
 #' @export
-numericInput <- function(
-  inputId,
-  label,
-  value,
-  min = NA,
-  max = NA,
-  step = NA,
-  width = NULL,
-  ...,
-  updateOn = c("change", "blur")
-) {
-  rlang::check_dots_empty()
-  updateOn <- rlang::arg_match(updateOn)
+numericInput <- function(inputId, label, value, min = NA, max = NA, step = NA,
+  width = NULL) {
 
   value <- restoreInput(id = inputId, default = value)
 
   # build input tag
-  inputTag <- tags$input(
-    id = inputId,
-    type = "number",
-    class = "shiny-input-number form-control",
-    value = formatNoSci(value),
-    `data-update-on` = updateOn
-  )
-  if (!is.na(min)) inputTag$attribs$min = min
-  if (!is.na(max)) inputTag$attribs$max = max
-  if (!is.na(step)) inputTag$attribs$step = step
+  inputTag <- tags$input(id = inputId, type = "number", class="form-control",
+                         value = formatNoSci(value))
+  if (!is.na(min))
+    inputTag$attribs$min = min
+  if (!is.na(max))
+    inputTag$attribs$max = max
+  if (!is.na(step))
+    inputTag$attribs$step = step
 
-  div(
-    class = "form-group shiny-input-container",
+  div(class = "form-group shiny-input-container",
     style = css(width = validateCssUnit(width)),
     shinyInputLabel(inputId, label),
     inputTag

R/input-password.R

@@ -30,29 +30,12 @@
 #' shinyApp(ui, server)
 #' }
 #' @export
-passwordInput <- function(
-  inputId,
-  label,
-  value = "",
-  width = NULL,
-  placeholder = NULL,
-  ...,
-  updateOn = c("change", "blur")
-) {
-  rlang::check_dots_empty()
-  updateOn <- rlang::arg_match(updateOn)
-
-  div(
-    class = "form-group shiny-input-container",
+passwordInput <- function(inputId, label, value = "", width = NULL,
+                          placeholder = NULL) {
+  div(class = "form-group shiny-input-container",
     style = css(width = validateCssUnit(width)),
     shinyInputLabel(inputId, label),
-    tags$input(
-      id = inputId,
-      type = "password",
-      class = "shiny-input-password form-control",
-      value = value,
-      placeholder = placeholder,
-      `data-update-on` = updateOn
-    )
+    tags$input(id = inputId, type="password", class="form-control", value=value,
+               placeholder = placeholder)
   )
 }

R/input-select.R

@@ -4,7 +4,7 @@
 #' from a list of values.
 #'
 #' By default, `selectInput()` and `selectizeInput()` use the JavaScript library
-#' \pkg{selectize.js} (<https://selectize.dev/>) instead of
+#' \pkg{selectize.js} (<https://github.com/selectize/selectize.js>) instead of
 #' the basic select input element. To use the standard HTML select input
 #' element, use `selectInput()` with `selectize=FALSE`.
 #'
@@ -106,7 +106,6 @@ selectInput <- function(inputId, label, choices, selected = NULL,
   # create select tag and add options
   selectTag <- tags$select(
     id = inputId,
-    class = "shiny-input-select",
     class = if (!selectize) "form-control",
     size = size,
     selectOptions(choices, selected, inputId, selectize)
@@ -173,7 +172,7 @@ needOptgroup <- function(choices) {
 
 #' @rdname selectInput
 #' @param ... Arguments passed to `selectInput()`.
-#' @param options A list of options. See the documentation of \pkg{selectize.js}(<https://selectize.dev/docs/usage>)
+#' @param options A list of options. See the documentation of \pkg{selectize.js}
 #'   for possible options (character option values inside [base::I()] will
 #'   be treated as literal JavaScript code; see [renderDataTable()]
 #'   for details).
@@ -214,7 +213,14 @@ selectizeIt <- function(inputId, select, options, nonempty = FALSE) {
   deps <- list(selectizeDependency())
 
   if ('drag_drop' %in% options$plugins) {
-    deps[[length(deps) + 1]] <- jqueryuiDependency()
+    deps <- c(
+      deps,
+      list(htmlDependency(
+        'jqueryui', '1.12.1',
+        c(href = 'shared/jqueryui'),
+        script = 'jquery-ui.min.js'
+      ))
+    )
   }
 
   # Insert script on same level as <select> tag
@@ -241,8 +247,11 @@ selectizeDependencyFunc <- function(theme) {
     return(selectizeStaticDependency(version_selectize))
   }
 
+  selectizeDir <- system.file(package = "shiny", "www/shared/selectize/")
   bs_version <- bslib::theme_version(theme)
-
+  stylesheet <- file.path(
+    selectizeDir, "scss", paste0("selectize.bootstrap", bs_version, ".scss")
+  )
   # It'd be cleaner to ship the JS in a separate, href-based,
   # HTML dependency (which we currently do for other themable widgets),
   # but DT, crosstalk, and maybe other pkgs include selectize JS/CSS
@@ -250,46 +259,28 @@ selectizeDependencyFunc <- function(theme) {
   # name, the JS/CSS would be loaded/included twice, which leads to
   # strange issues, especially since we now include a 3rd party
   # accessibility plugin https://github.com/rstudio/shiny/pull/3153
-  selectizeDir <- system_file(package = "shiny", "www/shared/selectize/")
-  script <- file.path(selectizeDir, selectizeScripts())
-
+  script <- file.path(
+    selectizeDir, c("js/selectize.min.js", "accessibility/js/selectize-plugin-a11y.min.js")
+  )
   bslib::bs_dependency(
-    input = selectizeSass(bs_version),
+    input = sass::sass_file(stylesheet),
     theme = theme,
     name = "selectize",
     version = version_selectize,
-    cache_key_extra = get_package_version("shiny"),
+    cache_key_extra = shinyPackageVersion(),
     .dep_args = list(script = script)
   )
 }
 
-selectizeSass <- function(bs_version) {
-  selectizeDir <- system_file(package = "shiny", "www/shared/selectize/")
-  stylesheet <- file.path(
-    selectizeDir, "scss", paste0("selectize.bootstrap", bs_version, ".scss")
-  )
-  sass::sass_file(stylesheet)
-}
-
 selectizeStaticDependency <- function(version) {
   htmlDependency(
-    "selectize",
-    version,
-    src = "www/shared/selectize",
-    package = "shiny",
+    "selectize", version,
+    src = c(href = "shared/selectize"),
     stylesheet = "css/selectize.bootstrap3.css",
-    script = selectizeScripts()
-  )
-}
-
-selectizeScripts <- function() {
-  isMinified <- isTRUE(get_devmode_option("shiny.minified", TRUE))
-  paste0(
-    c(
-      "js/selectize",
-      "accessibility/js/selectize-plugin-a11y"
-    ),
-    if (isMinified) ".min.js" else ".js"
+    script = c(
+      "js/selectize.min.js",
+      "accessibility/js/selectize-plugin-a11y.min.js"
+    )
   )
 }
 
@@ -301,7 +292,7 @@ selectizeScripts <- function() {
 #'
 #' By default, `varSelectInput()` and `selectizeInput()` use the
 #' JavaScript library \pkg{selectize.js}
-#' (<https://selectize.dev/>) to instead of the basic
+#' (<https://github.com/selectize/selectize.js>) to instead of the basic
 #' select input element. To use the standard HTML select input element, use
 #' `selectInput()` with `selectize=FALSE`.
 #'
@@ -397,7 +388,7 @@ varSelectInput <- function(
 
 #' @rdname varSelectInput
 #' @param ... Arguments passed to `varSelectInput()`.
-#' @param options A list of options. See the documentation of \pkg{selectize.js}(<https://selectize.dev/docs/usage>)
+#' @param options A list of options. See the documentation of \pkg{selectize.js}
 #'   for possible options (character option values inside [base::I()] will
 #'   be treated as literal JavaScript code; see [renderDataTable()]
 #'   for details).

R/input-slider.R

@@ -205,49 +205,40 @@ ionRangeSliderDependency <- function() {
   list(
     # ion.rangeSlider also needs normalize.css, which is already included in Bootstrap.
     htmlDependency(
-      "ionrangeslider-javascript",
-      version_ion_range_slider,
-      src = "www/shared/ionrangeslider",
-      package = "shiny",
+      "ionrangeslider-javascript", version_ion_range_slider,
+      src = c(href = "shared/ionrangeslider"),
       script = "js/ion.rangeSlider.min.js"
     ),
     htmlDependency(
-      "strftime",
-      version_strftime,
-      src = "www/shared/strftime",
-      package = "shiny",
+      "strftime", version_strftime,
+      src = c(href = "shared/strftime"),
       script = "strftime-min.js"
     ),
     bslib::bs_dependency_defer(ionRangeSliderDependencyCSS)
   )
 }
 
-ionRangeSliderDependencySass <- function() {
-  list(
-    list(accent = "$component-active-bg"),
-    sass::sass_file(
-      system_file(package = "shiny", "www/shared/ionrangeslider/scss/shiny.scss")
-    )
-  )
-}
-
 ionRangeSliderDependencyCSS <- function(theme) {
   if (!is_bs_theme(theme)) {
     return(htmlDependency(
       "ionrangeslider-css",
       version_ion_range_slider,
-      src = "www/shared/ionrangeslider",
-      package = "shiny",
+      src = c(href = "shared/ionrangeslider"),
       stylesheet = "css/ion.rangeSlider.css"
     ))
   }
 
   bslib::bs_dependency(
-    input = ionRangeSliderDependencySass(),
+    input = list(
+      list(accent = "$component-active-bg"),
+      sass::sass_file(
+        system.file(package = "shiny", "www/shared/ionrangeslider/scss/shiny.scss")
+      )
+    ),
     theme = theme,
     name = "ionRangeSlider",
     version = version_ion_range_slider,
-    cache_key_extra = get_package_version("shiny")
+    cache_key_extra = shinyPackageVersion()
   )
 }
 

R/input-submit.R

@@ -57,7 +57,7 @@ submitButton <- function(text = "Apply Changes", icon = NULL, width = NULL) {
   div(
     tags$button(
       type="submit",
-      class="btn btn-primary shiny-submit-button",
+      class="btn btn-primary",
       style = css(width = validateCssUnit(width)),
       list(icon, text)
     )

R/input-text.R

@@ -10,14 +10,6 @@
 #' @param placeholder A character string giving the user a hint as to what can
 #'   be entered into the control. Internet Explorer 8 and 9 do not support this
 #'   option.
-#' @param ... Ignored, included to require named arguments and for future
-#'   feature expansion.
-#' @param updateOn A character vector specifying when the input should be
-#'   updated. Options are `"change"` (default) and `"blur"`. Use `"change"` to
-#'   update the input immediately whenever the value changes. Use `"blur"`to
-#'   delay the input update until the input loses focus (the user moves away
-#'   from the input), or when Enter is pressed (or Cmd/Ctrl + Enter for
-#'   [textAreaInput()]).
 #' @return A text input control that can be added to a UI definition.
 #'
 #' @family input elements
@@ -42,31 +34,15 @@
 #' unless `value` is provided.
 #'
 #' @export
-textInput <- function(
-  inputId,
-  label,
-  value = "",
-  width = NULL,
-  placeholder = NULL,
-  ...,
-  updateOn = c("change", "blur")
-) {
-  rlang::check_dots_empty()
-  updateOn <- rlang::arg_match(updateOn)
+textInput <- function(inputId, label, value = "", width = NULL,
+  placeholder = NULL) {
 
   value <- restoreInput(id = inputId, default = value)
 
-  div(
-    class = "form-group shiny-input-container",
+  div(class = "form-group shiny-input-container",
     style = css(width = validateCssUnit(width)),
     shinyInputLabel(inputId, label),
-    tags$input(
-      id = inputId,
-      type = "text",
-      class = "shiny-input-text form-control",
-      value = value,
-      placeholder = placeholder,
-      `data-update-on` = updateOn
-    )
+    tags$input(id = inputId, type="text", class="form-control", value=value,
+      placeholder = placeholder)
   )
 }

R/input-textarea.R

@@ -16,8 +16,6 @@
 #' @param resize Which directions the textarea box can be resized. Can be one of
 #'   `"both"`, `"none"`, `"vertical"`, and `"horizontal"`. The default, `NULL`,
 #'   will use the client browser's default setting for resizing textareas.
-#' @param autoresize If `TRUE`, the textarea will automatically resize to fit
-#'   the input text.
 #' @return A textarea input control that can be added to a UI definition.
 #'
 #' @family input elements
@@ -43,22 +41,8 @@
 #' unless `value` is provided.
 #'
 #' @export
-textAreaInput <- function(
-  inputId,
-  label,
-  value = "",
-  width = NULL,
-  height = NULL,
-  cols = NULL,
-  rows = NULL,
-  placeholder = NULL,
-  resize = NULL,
-  ...,
-  autoresize = FALSE,
-  updateOn = c("change", "blur")
-) {
-  rlang::check_dots_empty()
-  updateOn <- rlang::arg_match(updateOn)
+textAreaInput <- function(inputId, label, value = "", width = NULL, height = NULL,
+  cols = NULL, rows = NULL, placeholder = NULL, resize = NULL) {
 
   value <- restoreInput(id = inputId, default = value)
 
@@ -66,30 +50,23 @@ textAreaInput <- function(
     resize <- match.arg(resize, c("both", "none", "vertical", "horizontal"))
   }
 
-  classes <- "form-control"
-  if (autoresize) {
-    classes <- c(classes, "textarea-autoresize")
-    if (is.null(rows)) {
-      rows <- 1
-    }
-  }
+  style <- css(
+    # The width is specified on the parent div.
+    width = if (!is.null(width)) "width: 100%;",
+    height = validateCssUnit(height),
+    resize = resize
+  )
 
-  div(
-    class = "shiny-input-textarea form-group shiny-input-container",
-    style = css(width = validateCssUnit(width)),
+  div(class = "form-group shiny-input-container",
     shinyInputLabel(inputId, label),
+    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
     tags$textarea(
       id = inputId,
-      class = classes,
+      class = "form-control",
       placeholder = placeholder,
-      style = css(
-        width = if (!is.null(width)) "100%",
-        height = validateCssUnit(height),
-        resize = resize
-      ),
+      style = style,
       rows = rows,
       cols = cols,
-      `data-update-on` = updateOn,
       value
     )
   )

R/input-utils.R

@@ -41,7 +41,7 @@ normalizeChoicesArgs <- function(choices, choiceNames, choiceValues,
     if (length(choiceNames) != length(choiceValues)) {
       stop("`choiceNames` and `choiceValues` must have the same length.")
     }
-    if (any_named(choiceNames) || any_named(choiceValues)) {
+    if (anyNamed(choiceNames) || anyNamed(choiceValues)) {
       stop("`choiceNames` and `choiceValues` must not be named.")
     }
   } else {

R/insert-ui.R

@@ -1,6 +1,6 @@
 #' Insert and remove UI objects
 #'
-#' These functions allow you to dynamically add and remove arbitrary UI
+#' These functions allow you to dynamically add and remove arbirary UI
 #' into your app, whenever you want, as many times as you want.
 #' Unlike [renderUI()], the UI generated with `insertUI()` is persistent:
 #' once it's created, it stays there until removed by `removeUI()`. Each
@@ -11,7 +11,7 @@
 #' function.
 #'
 #' It's particularly useful to pair `removeUI` with `insertUI()`, but there is
-#' no restriction on what you can use it on. Any element that can be selected
+#' no restriction on what you can use on. Any element that can be selected
 #' through a jQuery selector can be removed through this function.
 #'
 #' @param selector A string that is accepted by jQuery's selector

R/jqueryui.R

@@ -76,20 +76,16 @@ absolutePanel <- function(...,
 
   style <- paste(paste(names(cssProps), cssProps, sep = ':', collapse = ';'), ';', sep='')
   divTag <- tags$div(style=style, ...)
-
-  if (identical(draggable, FALSE)) {
+  if (isTRUE(draggable)) {
+    divTag <- tagAppendAttributes(divTag, class='draggable')
+    return(tagList(
+      singleton(tags$head(tags$script(src='shared/jqueryui/jquery-ui.min.js'))),
+      divTag,
+      tags$script('$(".draggable").draggable();')
+    ))
+  } else {
     return(divTag)
   }
-
-  # Add Shiny inputs and htmlwidgets to 'non-draggable' elements
-  # Cf. https://api.jqueryui.com/draggable/#option-cancel
-  dragOpts <- '{cancel: ".shiny-input-container,.html-widget,input,textarea,button,select,option"}'
-  dragJS <- sprintf('$(".draggable").draggable(%s);', dragOpts)
-  tagList(
-    tagAppendAttributes(divTag, class='draggable'),
-    jqueryuiDependency(),
-    tags$script(HTML(dragJS))
-  )
 }
 
 #' @rdname absolutePanel
@@ -103,14 +99,3 @@ fixedPanel <- function(...,
                 width=width, height=height, draggable=draggable, cursor=match.arg(cursor),
                 fixed=TRUE)
 }
-
-
-jqueryuiDependency <- function() {
-  htmlDependency(
-    "jqueryui",
-    version_jqueryui,
-    src = "www/shared/jqueryui",
-    package = "shiny",
-    script = "jquery-ui.min.js"
-  )
-}

R/knitr.R

@@ -63,7 +63,7 @@ knit_print.shiny.appobj <- function(x, ...) {
 #' @param inline Whether the object is printed inline.
 knit_print.shiny.render.function <- function(x, ..., inline = FALSE) {
   x <- htmltools::as.tags(x, inline = inline)
-  output <- knitr::knit_print(tagList(x), ..., inline = inline)
+  output <- knitr::knit_print(tagList(x))
   attr(output, "knit_cacheable") <- FALSE
   attr(output, "knit_meta") <- append(attr(output, "knit_meta"),
                                       shiny_rmd_warning())
@@ -77,5 +77,5 @@ knit_print.reactive <- function(x, ..., inline = FALSE) {
   renderFunc <- if (inline) renderText else renderPrint
   knitr::knit_print(renderFunc({
     x()
-  }), ..., inline = inline)
+  }), inline = inline)
 }

R/map.R

@@ -48,12 +48,9 @@ Map <- R6Class(
   )
 )
 
-#' @export
-as.list.Map <- function(x, ...) {
-  x$values()
+as.list.Map <- function(map) {
+  map$values()
 }
-
-#' @export
-length.Map <- function(x) {
-  x$size()
+length.Map <- function(map) {
+  map$size()
 }

R/middleware.R

@@ -348,7 +348,7 @@ HandlerManager <- R6Class("HandlerManager",
                   httpResponse(status = 500L,
                     content_type = "text/html; charset=UTF-8",
                     content = as.character(htmltools::htmlTemplate(
-                      system_file("template", "error.html", package = "shiny"),
+                      system.file("template", "error.html", package = "shiny"),
                       message = conditionMessage(err)
                     ))
                   )

R/mock-session.R

@@ -1,5 +1,5 @@
 # Promise helpers taken from:
-#   https://github.com/rstudio/promises/blob/main/tests/testthat/common.R
+#   https://github.com/rstudio/promises/blob/master/tests/testthat/common.R
 # Block until all pending later tasks have executed
 wait_for_it <- function() {
   while (!later::loop_empty()) {
@@ -436,36 +436,29 @@ MockShinySession <- R6Class(
       if (!is.function(func))
         stop(paste("Unexpected", class(func), "output for", name))
 
-      with_no_otel_collect({
-        obs <- observe({
-          # We could just stash the promise, but we get an "unhandled promise error". This bypasses
-          prom <- NULL
-          tryCatch({
-            v <- private$withCurrentOutput(name, func(self, name))
-            if (!is.promise(v)){
-              # Make our sync value into a promise
-              prom <- promise_resolve(v)
-            } else {
-              prom <- v
-            }
-          }, error=function(e){
-            # Error running value()
-            prom <<- promise_reject(e)
-          })
-
-          private$outs[[name]]$promise <- hybrid_chain(
-            prom,
-            function(v){
-              list(val = v, err = NULL)
-            }, catch=function(e){
-              if (
-                !inherits(e, c("shiny.custom.error", "shiny.output.cancel", "shiny.output.progress", "shiny.silent.error"))
-              ) {
-                self$unhandledError(e, close = FALSE)
-              }
-              list(val = NULL, err = e)
-            })
+      obs <- observe({
+        # We could just stash the promise, but we get an "unhandled promise error". This bypasses
+        prom <- NULL
+        tryCatch({
+          v <- private$withCurrentOutput(name, func(self, name))
+          if (!promises::is.promise(v)){
+            # Make our sync value into a promise
+            prom <- promises::promise(function(resolve, reject){ resolve(v) })
+          } else {
+            prom <- v
+          }
+        }, error=function(e){
+          # Error running value()
+          prom <<- promises::promise(function(resolve, reject){ reject(e) })
         })
+
+        private$outs[[name]]$promise <- hybrid_chain(
+          prom,
+          function(v){
+            list(val = v, err = NULL)
+          }, catch=function(e){
+            list(val = NULL, err = e)
+          })
       })
       private$outs[[name]] <- list(obs = obs, func = func, promise = NULL)
     },
@@ -567,26 +560,10 @@ MockShinySession <- R6Class(
     rootScope = function() {
       self
     },
-    #' @description Add an unhandled error callback.
-    #' @param callback The callback to add, which should accept an error object
-    #'   as its first argument.
-    #' @return A deregistration function.
-    onUnhandledError = function(callback) {
-      private$unhandledErrorCallbacks$register(callback)
-    },
     #' @description Called by observers when a reactive expression errors.
     #' @param e An error object.
-    #' @param close If `TRUE`, the session will be closed after the error is
-    #'  handled, defaults to `FALSE`.
-    unhandledError = function(e, close = TRUE) {
-      if (close) {
-        class(e) <- c("shiny.error.fatal", class(e))
-      }
-
-      private$unhandledErrorCallbacks$invoke(e, onError = printError)
-      .globals$onUnhandledErrorCallbacks$invoke(e, onError = printError)
-
-      if (close) self$close()
+    unhandledError = function(e) {
+      self$close()
     },
     #' @description Freeze a value until the flush cycle completes.
     #' @param x A `ReactiveValues` object.
@@ -643,9 +620,6 @@ MockShinySession <- R6Class(
     flushedCBs = NULL,
     # @field endedCBs `Callbacks` called when session ends.
     endedCBs = NULL,
-    # @field unhandledErrorCallbacks `Callbacks` called when an unhandled error
-    #   occurs.
-    unhandledErrorCallbacks = Callbacks$new(),
     # @field timer `MockableTimerCallbacks` called at particular times.
     timer = NULL,
     # @field was_closed Set to `TRUE` once the session is closed.
@@ -718,7 +692,7 @@ MockShinySession <- R6Class(
         stop("Nested calls to withCurrentOutput() are not allowed.")
       }
 
-      with_promise_domain(
+      promises::with_promise_domain(
         createVarPromiseDomain(private, "currentOutputName", name),
         expr
       )

R/modal.R

@@ -43,10 +43,7 @@ removeModal <- function(session = getDefaultReactiveDomain()) {
 #' @param title An optional title for the dialog.
 #' @param footer UI for footer. Use `NULL` for no footer.
 #' @param size One of `"s"` for small, `"m"` (the default) for medium,
-#'   `"l"` for large, or `"xl"` for extra large. Note that `"xl"` only 
-#'    works with Bootstrap 4 and above (to opt-in to Bootstrap 4+, 
-#'    pass [bslib::bs_theme()] to the `theme` argument of a page container 
-#'    like [fluidPage()]).
+#'   or `"l"` for large.
 #' @param easyClose If `TRUE`, the modal dialog can be dismissed by
 #'   clicking outside the dialog box, or be pressing the Escape key. If
 #'   `FALSE` (the default), the modal dialog can't be dismissed in those

R/otel-attr-srcref.R

@@ -1,65 +0,0 @@
-
-
-# Very similar to srcrefFromShinyCall(),
-# however, this works when the function does not have a srcref attr set
-otel_srcref_attributes <- function(srcref, fn_name = NULL) {
-  if (is.function(srcref)) {
-    srcref <- getSrcRefs(srcref)[[1]][[1]]
-  }
-
-  if (is.null(srcref)) {
-    return(NULL)
-  }
-
-  stopifnot(inherits(srcref, "srcref"))
-
-  # Semantic conventions for code: https://opentelemetry.io/docs/specs/semconv/registry/attributes/code/
-  #
-  # Inspiration from https://github.com/r-lib/testthat/pull/2087/files#diff-92de3306849d93d6f7e76c5aaa1b0c037e2d716f72848f8a1c70536e0c8a1564R123-R124
-  filename <- attr(srcref, "srcfile")$filename
-  dropNulls(list(
-    "code.function.name" = fn_name,
-    # Location attrs
-    "code.file.path" = filename,
-    "code.line.number" = srcref[1],
-    "code.column.number" = srcref[2],
-    # Remove these deprecated location names once Logfire supports the preferred names
-    # https://github.com/pydantic/logfire/issues/1559
-    "code.filepath" = filename,
-    "code.lineno" = srcref[1],
-    "code.column" = srcref[2]
-  ))
-}
-
-#' Get the srcref for the call at the specified stack level
-#'
-#' If you need to go farther back in the `sys.call()` stack, supply a larger
-#' negative number to `which_offset`. The default of 0 gets the immediate
-#' caller. `-1` would get the caller's caller, and so on.
-#' @param which_offset The stack level to get the call from. Defaults to -1 (the
-#'   immediate caller).
-#' @return An srcref object, or NULL if none is found.
-#' @noRd
-get_call_srcref <- function(which_offset = 0) {
-  # Go back one call to account for this function itself
-  call <- sys.call(which_offset - 1)
-
-  srcref <- attr(call, "srcref", exact = TRUE)
-  srcref
-}
-
-
-append_otel_srcref_attrs <- function(attrs, call_srcref, fn_name) {
-  if (is.null(call_srcref)) {
-    return(attrs)
-  }
-
-  srcref_attrs <- otel_srcref_attributes(call_srcref, fn_name)
-  if (is.null(srcref_attrs)) {
-    return(attrs)
-  }
-
-  attrs[names(srcref_attrs)] <- srcref_attrs
-
-  attrs
-}

R/otel-collect.R

@@ -1,55 +0,0 @@
-otel_collect_choices <- c(
-  "none",
-  "session",
-  "reactive_update",
-  "reactivity",
-  "all"
-)
-
-# Check if the collect level is sufficient
-otel_collect_is_enabled <- function(
-  impl_level,
-  # Listen to option and fall back to the env var
-  opt_collect_level = getOption("shiny.otel.collect", Sys.getenv("SHINY_OTEL_COLLECT", "all"))
-) {
-  opt_collect_level <- as_otel_collect(opt_collect_level)
-
-  which(opt_collect_level == otel_collect_choices) >=
-    which(impl_level == otel_collect_choices)
-}
-
-# Check if tracing is enabled and if the collect level is sufficient
-has_otel_collect <- function(collect) {
-  # Only check pkg author input iff loaded with pkgload
-  if (IS_SHINY_LOCAL_PKG) {
-    stopifnot(length(collect) == 1, any(collect == otel_collect_choices))
-  }
-
-  otel_is_tracing_enabled() && otel_collect_is_enabled(collect)
-}
-
-# Run expr with otel collection disabled
-with_no_otel_collect <- function(expr) {
-  withOtelCollect("none", expr)
-}
-
-
-## -- Helpers -----------------------------------------------------
-
-# shiny.otel.collect can be:
-# "none"; To do nothing / fully opt-out
-# "session" for session/start events
-# "reactive_update" (includes "session" features) and reactive_update spans
-# "reactivity" (includes "reactive_update" features) and spans for all reactive things
-# "all" - Anything that Shiny can do. (Currently equivalent to the "reactivity" level)
-
-as_otel_collect <- function(collect = "all") {
-  if (!is.character(collect)) {
-    stop("`collect` must be a character vector.")
-  }
-
-  # Match to collect enum
-  collect <- match.arg(collect, otel_collect_choices, several.ok = FALSE)
-
-  return(collect)
-}

R/otel-enable.R

@@ -1,194 +0,0 @@
-# # Approach
-# Use flags on the reactive object to indicate whether to record OpenTelemetry spans.
-#
-# Cadence:
-# * `$.isRecordingOtel` - Whether to record OpenTelemetry spans for this reactive object
-# * `$.otelLabel` - The label to use for the OpenTelemetry span
-# * `$.otelAttrs` - Additional attributes to add to the OpenTelemetry span
-
-
-#' Add OpenTelemetry for reactivity to an object
-#'
-#' @description
-#'
-#' `enable_otel_*()` methods add OpenTelemetry flags for [reactive()] expressions
-#' and `render*` functions (like [renderText()], [renderTable()], ...).
-#'
-#' Wrapper to creating an active reactive OpenTelemetry span that closes when
-#' the reactive expression is done computing. Typically this is when the
-#' reactive expression finishes (synchronous) or when the returned promise is
-#' done computing (asynchronous).
-
-#' @section Async with OpenTelemetry:
-#'
-#'   With a reactive expression, the key and/or value expression can be
-#'   _asynchronous_. In other words, they can be promises --- not regular R
-#'   promises, but rather objects provided by the
-#'   \href{https://rstudio.github.io/promises/}{\pkg{promises}}  package, which
-#'   are similar to promises in JavaScript. (See [promises::promise()] for more
-#'   information.) You can also use [mirai::mirai()] or [future::future()]
-#'   objects to run code in a separate process or even on a remote machine.
-#'
-#'   When reactive expressions are being calculated in parallel (by having
-#'   another reactive promise compute in the main process), the currently active
-#'   OpenTelemetry span will be dynamically swapped out according to the
-#'   currently active reactive expression. This means that as long as a promise
-#'   was `then()`ed or `catch()`ed with an active OpenTelemetry span, the span
-#'   will be correctly propagated to the next step (and subsequently other
-#'   steps) in the promise chain.
-#'
-#'   While the common case is for a reactive expression to be created
-#'   synchronously, troubles arise when the reactive expression is created
-#'   asynchronously. The span **must** be created before the reactive expression
-#'   is executed, it **must** be active for the duration of the expression, and
-#'   it **must** not be closed until the reactive expression is done executing.
-#'   This is not easily achieved with a single function call, so we provide a
-#'   way to create a reactive expression that is bound to an OpenTelemetry
-#'   span.
-#'
-#' @section Span management and performance:
-#'
-#' Dev note - Barret 2025-10:
-#' Typically, an OpenTelemetry span (`otel_span`) will inherit from the parent
-#' span. This works well and we can think of the hierarchy as a tree. With
-#' `options("shiny.otel.collect" = <value>)`, we are able to control with a sliding
-#' dial how much of the tree we are interested in: "none", "session",
-#' "reactive_update", "reactivity", and finally "all".
-#'
-#' Leveraging this hierarchy, we can avoid creating spans that are not needed.
-#' The act of making a noop span takes on the order of 10microsec. Handling of
-#' the opspan is also in the 10s of microsecond range. We should avoid this when
-#' we **know** that we're not interested in the span.  Therefore, manually
-#' handling spans should be considered for Shiny.
-#'
-#' * Q:
-#'   * But what about app author who want the current span? Is there any
-#'     guarantee that the current span is expected `reactive()` span?
-#' * A:
-#'   * No. The current span is whatever the current span is. If the app author
-#'     wants a specific span, they should create it themselves.
-#' * Proof:
-#'   ```r
-#'   noop <- otel::get_active_span()
-#'   noop$get_context()$get_span_id()
-#'   #> [1] "0000000000000000"
-#'   ignore <- otelsdk::with_otel_record({
-#'     a <- otel::start_local_active_span("a")
-#'     a$get_context()$get_span_id() |> str()
-#'     otel::with_active_span(noop, {
-#'       otel::get_active_span()$get_context()$get_span_id() |> str()
-#'     })
-#'   })
-#'   #> chr "2645e95715841e75"
-#'   #> chr "2645e95715841e75"
-#'   # ## It is reasonable to expect the second id to be `0000000000000000`, but it's not.
-#'   ```
-#'   Therefore, the app author has no guarantee that the current span is the
-#'   span they're expecting. If the app author wants a specific span, they should
-#'   create it themselves and let natural inheritance take over.
-#'
-#' Given this, I will imagine that app authors will set
-#' `options("shiny.otel.collect" = "reactive_update")` as their default behavior.
-#' Enough to know things are happening, but not overwhelming from **everything**
-#' that is reactive.
-#'
-#' To _light up_ a specific area, users can call `withr::with_options(list("shiny.otel.collect" = "all"), { ... })`.
-#'
-#' @param x The object to add caching to.
-#' @param ... Future parameter expansion.
-#' @noRd
-NULL
-
-
-enable_otel_reactive_val <- function(x) {
-
-  impl <- attr(x, ".impl", exact = TRUE)
-  # Set flag for otel logging when setting the value
-  impl$.isRecordingOtel <- TRUE
-
-  class(x) <- c("reactiveVal.otel", class(x))
-
-  x
-}
-
-enable_otel_reactive_values <- function(x) {
-
-  impl <- .subset2(x, "impl")
-  # Set flag for otel logging when setting values
-  impl$.isRecordingOtel <- TRUE
-
-  class(x) <- c("reactivevalues.otel", class(x))
-
-  x
-}
-
-enable_otel_reactive_expr <- function(x) {
-
-  domain <- reactive_get_domain(x)
-
-  impl <- attr(x, "observable", exact = TRUE)
-  impl$.isRecordingOtel <- TRUE
-  # Covers both reactive and reactive.event
-  impl$.otelLabel <- otel_span_label_reactive(x, domain = impl$.domain)
-
-  class(x) <- c("reactiveExpr.otel", class(x))
-
-  x
-}
-
-enable_otel_observe <- function(x) {
-  x$.isRecordingOtel <- TRUE
-  x$.otelLabel <- otel_span_label_observer(x, domain = x$.domain)
-
-  class(x) <- c("Observer.otel", class(x))
-  invisible(x)
-}
-
-
-
-enable_otel_shiny_render_function <- function(x) {
-
-  valueFunc <- force(x)
-  otel_span_label <- NULL
-  otel_span_attrs <- NULL
-
-  renderFunc <- function(...) {
-    # Dynamically determine the span label given the current reactive domain
-    if (is.null(otel_span_label)) {
-      domain <- getDefaultReactiveDomain()
-      otel_span_label <<-
-        otel_span_label_render_function(x, domain = domain)
-      otel_span_attrs <<- c(
-        attr(x, "otelAttrs"),
-        otel_session_id_attrs(domain)
-      )
-    }
-
-    with_otel_span(
-      otel_span_label,
-      {
-        hybrid_then(
-          valueFunc(...),
-          on_failure = set_otel_exception_status_and_throw,
-          # Must save the error object
-          tee = FALSE
-        )
-      },
-      attributes = otel_span_attrs
-    )
-  }
-
-  renderFunc <- addAttributes(renderFunc, renderFunctionAttributes(valueFunc))
-  class(renderFunc) <- c("shiny.render.function.otel", class(valueFunc))
-  renderFunc
-}
-
-
-# ## If we ever expose a S3 function, I'd like to add this method.
-# bindOtel.function <- function(x, ...) {
-#   cli::cli_abort(paste0(
-#     "Don't know how to add OpenTelemetry recording to a plain function. ",
-#     "If this is a {.code render*()} function for Shiny, it may need to be updated. ",
-#     "Please see {.help shiny::bindOtel} for more information."
-#   ))
-# }

R/otel-error.R

@@ -1,56 +0,0 @@
-
-has_seen_otel_exception <- function(cnd) {
-  !is.null(cnd$.shiny_otel_exception)
-}
-
-mark_otel_exception_as_seen <- function(cnd) {
-  cnd$.shiny_otel_exception <- TRUE
-  cnd
-}
-
-set_otel_exception_status_and_throw <- function(cnd) {
-  cnd <- set_otel_exception_status(cnd)
-
-  # Rethrow the (possibly updated) error
-  signalCondition(cnd)
-}
-
-set_otel_exception_status <- function(cnd) {
-  if (inherits(cnd, "shiny.custom.error")) {
-    # No-op
-  } else if (inherits(cnd, "shiny.output.cancel")) {
-    # No-op
-  } else if (inherits(cnd, "shiny.output.progress")) {
-    # No-op
-  } else if (cnd_inherits(cnd, "shiny.silent.error")) {
-    # No-op
-  } else {
-    # Only when an unknown error occurs do we set the span status to error
-    span <- otel::get_active_span()
-
-    # Only record the exception once at the original point of failure,
-    # not every reactive expression that it passes through
-    if (!has_seen_otel_exception(cnd)) {
-      span$record_exception(
-        # Record a sanitized error if sanitization is enabled
-        get_otel_error_obj(cnd)
-      )
-      cnd <- mark_otel_exception_as_seen(cnd)
-    }
-
-    # Record the error status on the span for any context touching this error
-    span$set_status("error")
-  }
-
-  cnd
-}
-
-
-get_otel_error_obj <- function(e) {
-  # Do not expose errors to otel if sanitization is enabled
-  if (getOption("shiny.otel.sanitize.errors", TRUE)) {
-    sanitized_error()
-  } else {
-    e
-  }
-}

R/otel-label.R

@@ -1,198 +0,0 @@
-# observe mymod:<anonymous>
-# observe <anonymous>
-# observe mylabel
-
-# -- Reactives --------------------------------------------------------------
-
-#' OpenTelemetry Label Generation Functions
-#'
-#' Functions for generating formatted labels for OpenTelemetry tracing spans
-#' in Shiny applications. These functions handle module namespacing and
-#' cache/event modifiers for different Shiny reactive constructs.
-#'
-#' @param x The object to generate a label for (reactive, observer, etc.)
-#' @param label Character string label for reactive values
-#' @param key Character string key for reactiveValues operations
-#' @param ... Additional arguments (unused)
-#' @param domain Shiny domain object containing namespace information
-#'
-#' @return Character string formatted for OpenTelemetry span labels
-#' @name otel_label
-#' @noRd
-NULL
-
-otel_span_label_reactive <- function(x, ..., domain) {
-  fn_name <- otel_label_with_modifiers(
-    x,
-    "reactive",
-    cache_class = "reactive.cache",
-    event_class = "reactive.event"
-  )
-
-  label <- attr(x, "observable", exact = TRUE)[[".label"]]
-  otel_span_label <- otel_label_upgrade(label, domain = domain)
-
-  sprintf("%s %s", fn_name, otel_span_label)
-}
-
-otel_span_label_render_function <- function(x, ..., domain) {
-  fn_name <- otel_label_with_modifiers(
-    x,
-    "output",
-    cache_class = "shiny.render.function.cache",
-    event_class = "shiny.render.function.event"
-  )
-
-  label <- getCurrentOutputInfo(session = domain)$name %||% "<unknown>"
-  otel_span_label <- otel_label_upgrade(label, domain = domain)
-
-  sprintf("%s %s", fn_name, otel_span_label)
-}
-
-otel_span_label_observer <- function(x, ..., domain) {
-  fn_name <- otel_label_with_modifiers(
-    x,
-    "observe",
-    cache_class = NULL, # Do not match a cache class here
-    event_class = "Observer.event"
-  )
-
-  otel_span_label <- otel_label_upgrade(x$.label, domain = domain)
-
-  sprintf("%s %s", fn_name, otel_span_label)
-}
-
-# -- Set reactive value(s) ----------------------------------------------------
-
-otel_log_label_set_reactive_val <- function(label, ..., domain) {
-  sprintf(
-    "Set reactiveVal %s",
-    otel_label_upgrade(label, domain = domain)
-  )
-}
-
-otel_log_label_set_reactive_values <- function(label, key, ..., domain) {
-  sprintf(
-    "Set reactiveValues %s$%s",
-    otel_label_upgrade(label, domain = domain),
-    key
-  )
-}
-
-# -- ExtendedTask -------------------------------------------------------------
-
-otel_span_label_extended_task <- function(label, suffix = NULL, ..., domain) {
-  sprintf(
-    "ExtendedTask %s",
-    otel_label_upgrade(label, domain = domain)
-  )
-}
-otel_log_label_extended_task_add_to_queue <- function(label, ..., domain) {
-  sprintf(
-    "ExtendedTask %s add to queue",
-    otel_label_upgrade(label, domain = domain)
-  )
-}
-
-# -- Debounce / Throttle -------------------------------------------------------
-
-otel_label_debounce <- function(label, ..., domain) {
-  sprintf(
-    "debounce %s",
-    otel_label_upgrade(label, domain = domain)
-  )
-}
-
-otel_label_throttle <- function(label, ..., domain) {
-  sprintf(
-    "throttle %s",
-    otel_label_upgrade(label, domain = domain)
-  )
-}
-
-# ---- Reactive Poll / File Reader -----------------------------------------------
-otel_label_reactive_poll <- function(label, ..., domain) {
-  sprintf(
-    "reactivePoll %s",
-    otel_label_upgrade(label, domain = domain)
-  )
-}
-otel_label_reactive_file_reader <- function(label, ..., domain) {
-  sprintf(
-    "reactiveFileReader %s",
-    otel_label_upgrade(label, domain = domain)
-  )
-}
-
-# -- Helpers --------------------------------------------------------------
-
-#' Modify function name based on object class modifiers
-#'
-#' @param x Object to check class of
-#' @param fn_name Base function name
-#' @param cache_class Optional class name that indicates cache operation
-#' @param event_class Optional class name that indicates event operation
-#'
-#' @return Modified function name with "cache" or "event" suffix if applicable
-#' @noRd
-otel_label_with_modifiers <- function(
-  x,
-  fn_name,
-  cache_class = NULL,
-  event_class = NULL
-) {
-  for (x_class in rev(class(x))) {
-    if (!is.null(cache_class) && x_class == cache_class) {
-      fn_name <- sprintf("%s cache", fn_name)
-    } else if (!is.null(event_class) && x_class == event_class) {
-      fn_name <- sprintf("%s event", fn_name)
-    }
-  }
-
-  fn_name
-}
-
-
-#' Upgrade and format OpenTelemetry labels with module namespacing
-#'
-#' Processes labels for OpenTelemetry tracing, replacing default verbose labels
-#' with cleaner alternatives and prepending module namespaces when available.
-#'
-#' @param label Character string label to upgrade
-#' @param ... Additional arguments (unused)
-#' @param domain Shiny domain object containing namespace information
-#'
-#' @return Modified label string with module prefix if applicable
-#' @noRd
-#'
-#' @details
-#' Module prefix examples:
-#' - "" -> ""
-#' - "my-nested-mod-" -> "my-nested-mod"
-otel_label_upgrade <- function(label, ..., domain) {
-  # By default, `observe()` sets the label to `observe(CODE)`
-  # This label is too big and inconsistent.
-  # Replace it with `<anonymous>`
-  # (Similar with `eventReactive()` and `observeEvent()`)
-  if (is_default_label(label) && grepl("(", label, fixed = TRUE)) {
-    label <- "<anonymous>"
-    # label <- sprintf("<anonymous> - %s", label)
-  }
-
-  if (is.null(domain)) {
-    return(label)
-  }
-
-  namespace <- domain$ns("")
-
-  if (!nzchar(namespace)) {
-    return(label)
-  }
-
-  # Remove trailing module separator
-  mod_ns <- sub(sprintf("%s$", ns.sep), "", namespace)
-
-  # Prepend the module name to the label
-  # Ex: `"mymod:x"`
-  sprintf("%s:%s", mod_ns, label)
-}

R/otel-reactive-update.R

@@ -1,114 +0,0 @@
-# * `session$userData[["_otel_span_reactive_update"]]` - The active reactive update span (or `NULL`)
-
-
-#' Start a `reactive_update` OpenTelemetry span and store it
-#'
-#' Used when a reactive expression is updated
-#' Will only start the span iff the otel tracing is enabled
-#' @param ... Ignored
-#' @param domain The reactive domain to associate with the span
-#' @return Invisibly returns.
-#' @seealso `otel_span_reactive_update_teardown()`
-#' @noRd
-otel_span_reactive_update_init <- function(..., domain) {
-
-  if (!has_otel_collect("reactive_update")) return()
-
-  # Ensure cleanup is registered only once per session
-  if (is.null(domain$userData[["_otel_has_reactive_cleanup"]])) {
-    domain$userData[["_otel_has_reactive_cleanup"]] <- TRUE
-
-    # Clean up any dangling reactive spans on an unplanned exit
-    domain$onSessionEnded(function() {
-      otel_span_reactive_update_teardown(domain = domain)
-    })
-  }
-
-  # Safety check
-  if (is_otel_span(domain$userData[["_otel_span_reactive_update"]])) {
-    stop("Reactive update span already exists")
-  }
-
-  domain$userData[["_otel_span_reactive_update"]] <-
-    start_otel_span(
-      "reactive_update",
-      ...,
-      attributes = otel_session_id_attrs(domain)
-    )
-
-  invisible()
-}
-
-#' End a `reactive_update` OpenTelemetry span and remove it from the session
-#' @param ... Ignored
-#' @param domain The reactive domain to associate with the span
-#' @return Invisibly returns.
-#' @seealso `otel_span_reactive_update_init()`
-#' @noRd
-otel_span_reactive_update_teardown <- function(..., domain) {
-  ospan <- domain$userData[["_otel_span_reactive_update"]]
-
-  if (is_otel_span(ospan)) {
-    otel::end_span(ospan)
-    domain$userData[["_otel_span_reactive_update"]] <- NULL
-  }
-
-  invisible()
-}
-
-
-#' Run expr within a `reactive_update` OpenTelemetry span
-#'
-#' Used to wrap the execution of a reactive expression. Will only
-#' require/activate the span iff the otel tracing is enabled
-#' @param expr The expression to executed within the span
-#' @param ... Ignored
-#' @param domain The reactive domain to associate with the span
-#' @noRd
-with_otel_span_reactive_update <- function(expr, ..., domain) {
-  ospan <- domain$userData[["_otel_span_reactive_update"]]
-
-  if (!is_otel_span(ospan)) {
-    return(force(expr))
-  }
-
-  # Given the reactive update span is started before and ended when exec count
-  # is 0, we only need to wrap the expr in the span context
-  otel::with_active_span(ospan, {force(expr)})
-}
-
-
-#' Run expr within `reactive_update` otel span if not already active
-#'
-#' If the reactive update otel span is not already active, run the expression
-#' within the reactive update otel span context. This ensures that nested calls
-#' to reactive expressions do not attempt to re-enter the same span.
-#'
-#' This method is used within Context `run()` and running an Output's observer
-#' implementation
-#' @param expr The expression to executed within the span
-#' @param ... Ignored
-#' @param domain The reactive domain to associate with the span
-#' @noRd
-maybe_with_otel_span_reactive_update <- function(expr, ..., domain) {
-  if (is.null(domain$userData[["_otel_reactive_update_is_active"]])) {
-    domain$userData[["_otel_reactive_update_is_active"]] <- TRUE
-
-    # When the expression is done promising, clear the active flag
-    hybrid_then(
-      {
-        with_otel_span_reactive_update(domain = domain, expr)
-      },
-      on_success = function(value) {
-        domain$userData[["_otel_reactive_update_is_active"]] <- NULL
-      },
-      on_failure = function(e) {
-        domain$userData[["_otel_reactive_update_is_active"]] <- NULL
-      },
-      # Return the value before the callbacks
-      tee = TRUE
-    )
-  } else {
-    expr
-  }
-}

R/otel-session.R

@@ -1,96 +0,0 @@
-# Semantic conventions for session: https://opentelemetry.io/docs/specs/semconv/general/session/
-
-#' Create and use session span and events
-#'
-#' If otel is disabled, the session span and events will not be created,
-#' however the expression will still be evaluated.
-#'
-#' Span: `session_start`, `session_end`
-#' @param expr Expression to evaluate within the session span
-#' @param ... Ignored
-#' @param domain The reactive domain
-#' @noRd
-otel_span_session_start <- function(expr, ..., domain) {
-
-  if (!has_otel_collect("session")) {
-    return(force(expr))
-  }
-
-  # Wrap the server initialization
-  with_otel_span(
-    "session_start",
-    expr,
-    attributes = otel::as_attributes(c(
-      otel_session_id_attrs(domain),
-      otel_session_attrs(domain)
-    ))
-  )
-}
-
-
-otel_span_session_end <- function(expr, ..., domain) {
-  if (!has_otel_collect("session")) {
-    return(force(expr))
-  }
-
-  id_attrs <- otel_session_id_attrs(domain)
-  with_otel_span(
-    "session_end",
-    expr,
-    attributes = id_attrs
-  )
-}
-
-# -- Helpers -------------------------------
-
-
-# Occurs when the websocket connection is established
-otel_session_attrs <- function(domain) {
-  # TODO: Future: Posit Connect integration
-  # > we are still trying to identify all of the information we want to track/expose
-  #
-  # * `POSIT_PRODUCT` (Fallback to RSTUDIO_PRODUCT) for host environment
-  # * `CONNECT_SERVER` envvar to get the `session.address`.
-  # * `CONNECT_CONTENT_GUID` for the consistent app distinguisher
-  # * Maybe `CONNECT_CONTENT_JOB_KEY`?
-  # * Maybe `user.id` to be their user name: https://opentelemetry.io/docs/specs/semconv/registry/attributes/user/
-  attrs <- list(
-    server.path =
-      sub(
-        "/websocket/$", "/",
-        domain[["request"]][["PATH_INFO"]] %||% ""
-      ),
-    server.address = domain[["request"]][["HTTP_HOST"]] %||% "",
-    server.origin = domain[["request"]][["HTTP_ORIGIN"]] %||% "",
-    ## Currently, Shiny does not expose QUERY_STRING when connecting the websocket
-    # so we do not provide it here.
-    # QUERY_STRING = domain[["request"]][["QUERY_STRING"]] %||% "",
-    server.port = domain[["request"]][["SERVER_PORT"]] %||% NA_integer_
-  )
-  # Safely convert SERVER_PORT to integer
-  # If conversion fails, leave as-is (string or empty)
-  # This avoids warnings/errors if SERVER_PORT is not a valid integer
-  server_port <- suppressWarnings(as.integer(attrs$server.port))
-  if (!is.na(server_port)) {
-    attrs$server.port <- server_port
-  }
-
-  attrs
-}
-
-otel_session_id_attrs <- function(domain) {
-  token <- domain$token
-  if (is.null(token)) {
-    return(list())
-  }
-
-  list(
-    # Convention for client-side with session.start and session.end events
-    # https://opentelemetry.io/docs/specs/semconv/general/session/
-    #
-    # Since we are the server, we'll add them as an attribute to _every_ span
-    # within the session as we don't know exactly when they will be called.
-    # Given it's only a single attribute, the cost should be minimal, but it ties every reactive calculation together.
-    session.id = token
-  )
-}

R/otel-shiny.R

@@ -1,127 +0,0 @@
-# Used by otel to identify the tracer and logger for this package
-# https://github.com/r-lib/otel/blob/afc31bc1f4bd177870d44b051ada1d9e4e685346/R/tracer-name.R#L33-L49
-# DO NOT CHANGE THIS VALUE without understanding the implications for existing telemetry data!
-otel_tracer_name <- "co.posit.r-package.shiny"
-
-init_otel <- function() {
-  .globals$otel_tracer <- otel::get_tracer()
-  .globals$otel_is_tracing_enabled <- otel::is_tracing_enabled(.globals$otel_tracer)
-
-  .globals$otel_logger <- otel::get_logger()
-  # .globals$otel_is_logging_enabled <- otel::is_logging_enabled()
-}
-on_load({init_otel()})
-
-#' Run expr within a Shiny OpenTelemetry recording context
-#'
-#' Reset the OpenTelemetry tracer and logger for Shiny.
-#' Used for testing purposes only.
-#' @param expr Expression to evaluate within the recording context
-#' @return The result of evaluating `otelsdk::with_otel_record(expr)` with freshly enabled Shiny otel tracer and logger
-#' @noRd
-with_shiny_otel_record <- function(expr) {
-  # Only use within internal testthat tests
-  stopifnot(testthat__is_testing())
-  withr::defer({ init_otel() })
-
-  otelsdk::with_otel_record({
-    init_otel()
-
-    force(expr)
-  })
-}
-
-#' Check if OpenTelemetry tracing is enabled
-#'
-#' @param tracer The OpenTelemetry tracer to check (default: Shiny otel tracer)
-#' @return `TRUE` if tracing is enabled, `FALSE` otherwise
-#' @noRd
-otel_is_tracing_enabled <- function() {
-  .globals[["otel_is_tracing_enabled"]]
-}
-
-#' Shiny OpenTelemetry logger
-#'
-#' Used for logging OpenTelemetry events via `otel_log()`
-#' @return An OpenTelemetry logger
-#' @noRd
-shiny_otel_logger <- function() {
-  .globals[["otel_logger"]]
-}
-
-
-
-#' Shiny OpenTelemetry tracer
-#'
-#' Used for creating OpenTelemetry spans via `with_otel_span()` and
-#' `start_otel_span()`
-#'
-#' Inspired by httr2:::get_tracer().
-#' @return An OpenTelemetry tracer
-#' @noRd
-shiny_otel_tracer <- function() {
-  .globals[["otel_tracer"]]
-}
-
-
-
-
-#' Create and use a Shiny OpenTelemetry span
-#'
-#' If otel is disabled, the span will not be created,
-#' however the expression will still be evaluated.
-#' @param name Span name
-#' @param expr Expression to evaluate within the span
-#' @param ... Ignored
-#' @param attributes Optional span attributes
-#' @return The result of evaluating `expr`
-#' @noRd
-with_otel_span <- function(name, expr, ..., attributes = NULL) {
-  promises::with_otel_span(name, expr, ..., attributes = attributes, tracer = shiny_otel_tracer())
-}
-
-
-#' Start a Shiny OpenTelemetry span
-#'
-#' @param name Span name
-#' @param ... Additional arguments passed to `otel::start_span()`
-#' @return An OpenTelemetry span
-#' @noRd
-start_otel_span <- function(name, ...) {
-  otel::start_span(name, ..., tracer = shiny_otel_tracer())
-}
-
-
-# # TODO: Set attributes on the current active span
-# # 5. Set attributes on the current active span
-# set_otel_span_attrs(status = 200L)
-
-
-# -- Helpers --------------------------------------------------------------
-
-
-is_otel_span <- function(x) {
-  inherits(x, "otel_span")
-}
-
-testthat__is_testing <- function() {
-  # testthat::is_testing()
-  identical(Sys.getenv("TESTTHAT"), "true")
-}
-
-#' Log a message using the Shiny OpenTelemetry logger
-#'
-#' @param msg The log message
-#' @param ... Additional attributes to add to the log record
-#' @param severity The log severity level (default: "info")
-#' @param logger The OpenTelemetry logger to use (default: Shiny otel logger)
-#' @return Invisibly returns.
-#' @noRd
-otel_log <- function(
-  msg,
-  ...,
-  severity = "info",
-  logger = shiny_otel_logger()
-) {
-  otel::log(msg, ..., severity = severity, logger = logger)
-}

R/otel-with.R

@@ -1,125 +0,0 @@
-#' Temporarily set OpenTelemetry (OTel) collection level
-#'
-#' @description
-#' Control Shiny's OTel collection level for particular reactive expression(s).
-#'
-#' `withOtelCollect()` sets the OpenTelemetry collection level for
-#' the duration of evaluating `expr`. `localOtelCollect()` sets the collection
-#' level for the remainder of the current function scope.
-#'
-#' @details
-#' Note that `"session"` and `"reactive_update"` levels are not permitted as
-#' these are runtime-specific levels that should only be set permanently via
-#' `options(shiny.otel.collect = ...)` or the `SHINY_OTEL_COLLECT` environment
-#' variable, not temporarily during reactive expression creation.
-#'
-#' @section Best practice:
-#'
-#' Best practice is to set the collection level for code that *creates* reactive
-#' expressions, not code that *runs* them. For instance:
-#'
-#' ```r
-#' # Disable telemetry for a reactive expression
-#' withOtelCollect("none", {
-#'   my_reactive <- reactive({ ... })
-#' })
-#'
-#' # Disable telemetry for a render function
-#' withOtelCollect("none", {
-#'   output$my_plot <- renderPlot({ ... })
-#' })
-#'
-#' #' # Disable telemetry for an observer
-#' withOtelCollect("none", {
-#'   observe({ ... }))
-#' })
-#'
-#' # Disable telemetry for an entire module
-#' withOtelCollect("none", {
-#'   my_result <- my_module("my_id")
-#' })
-#' # Use `my_result` as normal here
-#' ```
-#'
-#' NOTE: It's not recommended to pipe existing reactive objects into
-#' `withOtelCollect()` since they won't inherit their intended OTel settings,
-#' leading to confusion.
-#'
-#' @param collect Character string specifying the OpenTelemetry collection level.
-#'   Must be one of the following:
-#'
-#'     * `"none"` - No telemetry data collected
-#'     * `"reactivity"` - Collect reactive execution spans (includes session and
-#'       reactive update events)
-#'     * `"all"` - All available telemetry (currently equivalent to `"reactivity"`)
-#' @param expr Expression to evaluate with the specified collection level
-#'   (for `withOtelCollect()`).
-#' @param envir Environment where the collection level should be set
-#'   (for `localOtelCollect()`). Defaults to the parent frame.
-#'
-#' @return
-#' * `withOtelCollect()` returns the value of `expr`.
-#' * `localOtelCollect()` is called for its side effect and returns the previous
-#'   `collect` value invisibly.
-#'
-#' @seealso See the `shiny.otel.collect` option within [`shinyOptions`]. Setting
-#' this value will globally control OpenTelemetry collection levels.
-#'
-#' @examples
-#' \dontrun{
-#' # Temporarily disable telemetry collection
-#' withOtelCollect("none", {
-#'   # Code here won't generate telemetry
-#'   reactive({ input$x + 1 })
-#' })
-#'
-#' # Collect reactivity telemetry but not other events
-#' withOtelCollect("reactivity", {
-#'   # Reactive execution will be traced
-#'   observe({ print(input$x) })
-#' })
-#'
-#' # Use local variant in a function
-#' my_function <- function() {
-#'   localOtelCollect("none")
-#'   # Rest of function executes without telemetry
-#'   reactive({ input$y * 2 })
-#' }
-#' }
-#'
-#' @rdname withOtelCollect
-#' @export
-withOtelCollect <- function(collect, expr) {
-  collect <- as_otel_collect_with(collect)
-
-  withr::with_options(
-    list(shiny.otel.collect = collect),
-    expr
-  )
-}
-
-#' @rdname withOtelCollect
-#' @export
-localOtelCollect <- function(collect, envir = parent.frame()) {
-  collect <- as_otel_collect_with(collect)
-
-  old <- withr::local_options(
-    list(shiny.otel.collect = collect),
-    .local_envir = envir
-  )
-
-  invisible(old)
-}
-
-# Helper function to validate collect levels for with/local functions
-# Only allows "none", "reactivity", and "all" - not "session" or "reactive_update"
-as_otel_collect_with <- function(collect) {
-  if (!is.character(collect)) {
-    stop("`collect` must be a character vector.")
-  }
-
-  allowed_levels <- c("none", "reactivity", "all")
-  collect <- match.arg(collect, allowed_levels, several.ok = FALSE)
-
-  return(collect)
-}

R/react.R

@@ -16,60 +16,6 @@ processId <- local({
   }
 })
 
-ctx_otel_info_obj <- function(
-  isRecordingOtel = FALSE,
-  otelLabel = "<unknown>",
-  otelAttrs = list()
-) {
-  structure(
-    list(
-      isRecordingOtel = isRecordingOtel,
-      otelLabel = otelLabel,
-      otelAttrs = otelAttrs
-    ),
-    class = "ctx_otel_info"
-  )
-}
-
-with_otel_span_context <- function(otel_info, expr, domain) {
-  if (!otel_is_tracing_enabled()) {
-    return(force(expr))
-  }
-
-  isRecordingOtel <- .subset2(otel_info, "isRecordingOtel")
-  otelLabel <- .subset2(otel_info, "otelLabel")
-  otelAttrs <- .subset2(otel_info, "otelAttrs")
-
-  # Always set the reactive update span as active
-  # This ensures that any spans created within the reactive context
-  # are at least children of the reactive update span
-  maybe_with_otel_span_reactive_update(domain = domain, {
-    if (isRecordingOtel) {
-      with_otel_span(
-        otelLabel,
-        {
-          # Works with both sync and async expressions
-          # Needed for both observer and reactive contexts
-          hybrid_then(
-            expr,
-            on_failure = set_otel_exception_status_and_throw,
-            # Must upgrade the error object
-            tee = FALSE
-          )
-        },
-        # expr,
-        attributes = otelAttrs
-      )
-    } else {
-      force(expr)
-    }
-  })
-
-}
-
-
-
-
 #' @include graph.R
 Context <- R6Class(
   'Context',
@@ -87,14 +33,11 @@ Context <- R6Class(
     .pid = NULL,
     .weak = NULL,
 
-    .otel_info = NULL,
-
     initialize = function(
       domain, label='', type='other', prevId='',
       reactId = rLog$noReactId,
       id = .getReactiveEnvironment()$nextId(), # For dummy context
-      weak = FALSE,
-      otel_info = ctx_otel_info_obj()
+      weak = FALSE
     ) {
       id <<- id
       .label <<- label
@@ -104,27 +47,16 @@ Context <- R6Class(
       .reactType <<- type
       .weak <<- weak
       rLog$createContext(id, label, type, prevId, domain)
-      if (!is.null(otel_info)) {
-        if (IS_SHINY_LOCAL_PKG) {
-          stopifnot(inherits(otel_info, "ctx_otel_info"))
-        }
-        .otel_info <<- otel_info
-      }
     },
     run = function(func) {
       "Run the provided function under this context."
 
-      # Use `promises::` as it shows up in the stack trace
       promises::with_promise_domain(reactivePromiseDomain(), {
         withReactiveDomain(.domain, {
-          with_otel_span_context(.otel_info, domain = .domain, {
-            captureStackTraces({
-              env <- .getReactiveEnvironment()
-              rLog$enter(.reactId, id, .reactType, .domain)
-              on.exit(rLog$exit(.reactId, id, .reactType, .domain), add = TRUE)
-              env$runWith(self, func)
-            })
-          })
+          env <- .getReactiveEnvironment()
+          rLog$enter(.reactId, id, .reactType, .domain)
+          on.exit(rLog$exit(.reactId, id, .reactType, .domain), add = TRUE)
+          env$runWith(self, func)
         })
       })
     },
@@ -287,31 +219,27 @@ getDummyContext <- function() {
 
 wrapForContext <- function(func, ctx) {
   force(func)
-  force(ctx) # may be NULL (in the case of maskReactiveContext())
+  force(ctx)
 
   function(...) {
-    .getReactiveEnvironment()$runWith(ctx, function() {
-      func(...)
+    ctx$run(function() {
+      captureStackTraces(
+        func(...)
+      )
     })
   }
 }
 
 reactivePromiseDomain <- function() {
-  new_promise_domain(
+  promises::new_promise_domain(
     wrapOnFulfilled = function(onFulfilled) {
       force(onFulfilled)
-
-      # ctx will be NULL if we're in a maskReactiveContext()
-      ctx <- if (hasCurrentContext()) getCurrentContext() else NULL
-
+      ctx <- getCurrentContext()
       wrapForContext(onFulfilled, ctx)
     },
     wrapOnRejected = function(onRejected) {
       force(onRejected)
-
-      # ctx will be NULL if we're in a maskReactiveContext()
-      ctx <- if (hasCurrentContext()) getCurrentContext() else NULL
-
+      ctx <- getCurrentContext()
       wrapForContext(onRejected, ctx)
     }
   )

R/reactive-domains.R

@@ -45,8 +45,6 @@ createMockDomain <- function() {
   callbacks <- Callbacks$new()
   ended <- FALSE
   domain <- new.env(parent = emptyenv())
-  domain$ns <- function(id) id
-  domain$token <- "mock-domain"
   domain$onEnded <- function(callback) {
     return(callbacks$register(callback))
   }
@@ -97,11 +95,7 @@ getDefaultReactiveDomain <- function() {
 #' @rdname domains
 #' @export
 withReactiveDomain <- function(domain, expr) {
-  # Use `promises::` as it shows up in the stack trace
-  promises::with_promise_domain(
-    createVarPromiseDomain(.globals, "domain", domain),
-    expr
-  )
+  promises::with_promise_domain(createVarPromiseDomain(.globals, "domain", domain), expr)
 }
 
 #

R/reactives.R

@@ -79,26 +79,19 @@ ReactiveVal <- R6Class(
     dependents = NULL
   ),
   public = list(
-    .isRecordingOtel = FALSE, # Needs to be set by Shiny
-    .otelLabel = NULL, # Needs to be set by Shiny
-    .otelAttrs = NULL, # Needs to be set by Shiny
-
     initialize = function(value, label = NULL) {
       reactId <- nextGlobalReactId()
       private$reactId <- reactId
       private$value <- value
       private$label <- label
       private$dependents <- Dependents$new(reactId = private$reactId)
-
-      domain <- getDefaultReactiveDomain()
-      rLog$define(private$reactId, value, private$label, type = "reactiveVal", domain)
-      .otelLabel <<- otel_log_label_set_reactive_val(private$label, domain = domain)
+      rLog$define(private$reactId, value, private$label, type = "reactiveVal", getDefaultReactiveDomain())
     },
     get = function() {
       private$dependents$register()
 
       if (private$frozen)
-      reactiveStop()
+        reactiveStop()
 
       private$value
     },
@@ -106,16 +99,7 @@ ReactiveVal <- R6Class(
       if (identical(private$value, value)) {
         return(invisible(FALSE))
       }
-
-      domain <- getDefaultReactiveDomain()
-      if ((!is.null(domain)) && .isRecordingOtel) {
-        otel_log(
-          .otelLabel,
-          severity = "info",
-          attributes = c(private$.otelAttrs, otel_session_id_attrs(domain))
-        )
-      }
-      rLog$valueChange(private$reactId, value, domain)
+      rLog$valueChange(private$reactId, value, getDefaultReactiveDomain())
       private$value <- value
       private$dependents$invalidate()
       invisible(TRUE)
@@ -221,20 +205,13 @@ ReactiveVal <- R6Class(
 #'
 #' @export
 reactiveVal <- function(value = NULL, label = NULL) {
-  call_srcref <- get_call_srcref()
   if (missing(label)) {
-    label <- rassignSrcrefToLabel(
-      call_srcref,
-      defaultLabel = paste0("reactiveVal", createUniqueId(4))
-    )
+    call <- sys.call()
+    label <- rvalSrcrefToLabel(attr(call, "srcref", exact = TRUE))
   }
 
   rv <- ReactiveVal$new(value, label)
-  if (!is.null(call_srcref)) {
-    rv$.otelAttrs <- otel_srcref_attributes(call_srcref, fn_name = "reactiveVal")
-  }
-
-  ret <- structure(
+  structure(
     function(x) {
       if (missing(x)) {
         rv$get()
@@ -247,12 +224,6 @@ reactiveVal <- function(value = NULL, label = NULL) {
     label = label,
     .impl = rv
   )
-
-  if (has_otel_collect("reactivity")) {
-    ret <- enable_otel_reactive_val(ret)
-  }
-
-  ret
 }
 
 #' @rdname freezeReactiveValue
@@ -291,11 +262,8 @@ format.reactiveVal <- function(x, ...) {
 # assigned to (e.g. for `a <- reactiveVal()`, the result should be "a"). This
 # is a fragile, error-prone operation, so we default to a random label if
 # necessary.
-rassignSrcrefToLabel <- function(
-  srcref,
-  defaultLabel,
-  fnName = "([a-zA-Z0-9_.]+)"
-) {
+rvalSrcrefToLabel <- function(srcref,
+  defaultLabel = paste0("reactiveVal", createUniqueId(4))) {
 
   if (is.null(srcref))
     return(defaultLabel)
@@ -319,11 +287,7 @@ rassignSrcrefToLabel <- function(
 
   firstLine <- substring(lines[srcref[1]], srcref[2] - 1)
 
-  m <- regexec(
-    # Require the first assignment within the line
-    paste0("^\\s*([^[:space:]]+)\\s*(<<-|<-|=)\\s*", fnName, "\\b"),
-    firstLine
-  )
+  m <- regexec("\\s*([^[:space:]]+)\\s*(<-|=)\\s*reactiveVal\\b", firstLine)
   if (m[[1]][1] == -1) {
     return(defaultLabel)
   }
@@ -362,12 +326,6 @@ ReactiveValues <- R6Class(
     .dedupe = logical(0),
     # Key, asList(), or names() have been retrieved
     .hasRetrieved = list(),
-    # All names, in insertion order. The names are also stored in the .values
-    # object, but it does not preserve order.
-    .nameOrder = character(0),
-
-    .isRecordingOtel = FALSE, # Needs to be set by Shiny
-    .otelAttrs = NULL, # Needs to be set by Shiny
 
 
     initialize = function(
@@ -445,26 +403,6 @@ ReactiveValues <- R6Class(
         return(invisible())
       }
 
-      if ((!is.null(domain)) && .isRecordingOtel) {
-        if (
-          # Any reactiveValues (other than input or clientData) are fair game
-          !(.label == "input" || .label == "clientData") ||
-          # Do not include updates to input or clientData unless _some_ reactivity has occured
-          !is.null(domain$userData[["_otel_has_reactive_cleanup"]])
-        ) {
-          otel_log(
-            otel_log_label_set_reactive_values(.label, key, domain = domain),
-            severity = "info",
-            attributes = c(.otelAttrs, otel_session_id_attrs(domain))
-          )
-        }
-      }
-
-      # If it's new, append key to the name order
-      if (!key_exists) {
-        .nameOrder[length(.nameOrder) + 1] <<- key
-      }
-
       # set the value for better logging
       .values$set(key, value)
 
@@ -506,13 +444,14 @@ ReactiveValues <- R6Class(
     },
 
     names = function() {
+      nameValues <- .values$keys()
       if (!isTRUE(.hasRetrieved$names)) {
         domain <- getDefaultReactiveDomain()
-        rLog$defineNames(.reactId, .nameOrder, .label, domain)
+        rLog$defineNames(.reactId, nameValues, .label, domain)
         .hasRetrieved$names <<- TRUE
       }
       .namesDeps$register()
-      return(.nameOrder)
+      return(nameValues)
     },
 
     # Get a metadata value. Does not trigger reactivity.
@@ -560,7 +499,7 @@ ReactiveValues <- R6Class(
     },
 
     toList = function(all.names=FALSE) {
-      listValue <- .values$mget(.nameOrder)
+      listValue <- .values$values()
       if (!all.names) {
         listValue <- listValue[!grepl("^\\.", base::names(listValue))]
       }
@@ -633,28 +572,10 @@ reactiveValues <- function(...) {
   if ((length(args) > 0) && (is.null(names(args)) || any(names(args) == "")))
     rlang::abort("All arguments passed to reactiveValues() must be named.")
 
-  values <- .createReactiveValues(ReactiveValues$new(), withOtel = FALSE)
+  values <- .createReactiveValues(ReactiveValues$new())
 
   # Use .subset2() instead of [[, to avoid method dispatch
-  impl <- .subset2(values, 'impl')
-
-  call_srcref <- get_call_srcref()
-  if (!is.null(call_srcref)) {
-    impl$.label <- rassignSrcrefToLabel(
-      call_srcref,
-      # Pass through the random default label created in ReactiveValues$new()
-      defaultLabel = impl$.label
-    )
-
-    impl$.otelAttrs <- otel_srcref_attributes(call_srcref, fn_name = "reactiveValues")
-  }
-
-  impl$mset(args)
-
-  # Add otel collection after `$mset()` so that we don't log the initial values
-  # Add otel collection after `.label` so that any logging uses the correct label
-  values <- maybeAddReactiveValuesOtel(values)
-
+  .subset2(values, 'impl')$mset(args)
   values
 }
 
@@ -669,11 +590,10 @@ checkName <- function(x) {
 # @param values A ReactiveValues object
 # @param readonly Should this object be read-only?
 # @param ns A namespace function (either `identity` or `NS(namespace)`)
-# @param withOtel Should otel collection be attempted?
 .createReactiveValues <- function(values = NULL, readonly = FALSE,
-  ns = identity, withOtel = TRUE) {
+  ns = identity) {
 
-  ret <- structure(
+  structure(
     list(
       impl = values,
       readonly = readonly,
@@ -681,20 +601,6 @@ checkName <- function(x) {
     ),
     class='reactivevalues'
   )
-
-  if (withOtel) {
-    ret <- maybeAddReactiveValuesOtel(ret)
-  }
-
-  ret
-}
-
-maybeAddReactiveValuesOtel <- function(x) {
-  if (!has_otel_collect("reactivity")) {
-    return(x)
-  }
-
-  enable_otel_reactive_values(x)
 }
 
 #' @export
@@ -918,10 +824,6 @@ Observable <- R6Class(
     .mostRecentCtxId = character(0),
     .ctx = 'Context',
 
-    .isRecordingOtel = FALSE, # Needs to be set by Shiny
-    .otelLabel = NULL, # Needs to be set by Shiny
-    .otelAttrs = NULL, # Needs to be set by Shiny
-
     initialize = function(func, label = deparse(substitute(func)),
                           domain = getDefaultReactiveDomain(),
                           ..stacktraceon = TRUE) {
@@ -976,19 +878,9 @@ Observable <- R6Class(
       simpleExprToFunction(fn_body(.origFunc), "reactive")
     },
     .updateValue = function() {
-      ctx <- Context$new(
-        .domain,
-        .label,
-        type = 'observable',
-        prevId = .mostRecentCtxId,
-        reactId = .reactId,
-        weak = TRUE,
-        otel_info = ctx_otel_info_obj(
-          isRecordingOtel = .isRecordingOtel,
-          otelLabel = .otelLabel,
-          otelAttrs = c(.otelAttrs, otel_session_id_attrs(.domain))
-        )
-      )
+      ctx <- Context$new(.domain, .label, type = 'observable',
+                         prevId = .mostRecentCtxId, reactId = .reactId,
+                         weak = TRUE)
       .mostRecentCtxId <<- ctx$id
 
       # A Dependency object will have a weak reference to the context, which
@@ -1021,15 +913,6 @@ Observable <- R6Class(
           },
 
           error = function(cond) {
-            if (.isRecordingOtel) {
-              # `cond` is too early in the stack to be updated by `ctx`'s
-              # `with_otel_span_context()` where it calls
-              # `set_otel_exception_status_and_throw()` on eval error.
-              # So we mark it as seen here.
-              # When the error is re-thrown later, it won't be a _new_ error
-              cond <- mark_otel_exception_as_seen(cond)
-            }
-
             # If an error occurs, we want to propagate the error, but we also
             # want to save a copy of it, so future callers of this reactive will
             # get the same error (i.e. the error is cached).
@@ -1061,10 +944,7 @@ Observable <- R6Class(
 #' See the [Shiny tutorial](https://shiny.rstudio.com/tutorial/) for
 #' more information about reactive expressions.
 #'
-#' @param x For `is.reactive()`, an object to test. For `reactive()`, an
-#'   expression. When passing in a [`rlang::quo()`]sure with `reactive()`,
-#'   remember to use [`rlang::inject()`] to distinguish that you are passing in
-#'   the content of your quosure, not the expression of the quosure.
+#' @param x For `is.reactive()`, an object to test. For `reactive()`, an expression. When passing in a [`quo()`]sure with `reactive()`, remember to use [`rlang::inject()`] to distinguish that you are passing in the content of your quosure, not the expression of the quosure.
 #' @template param-env
 #' @templateVar x x
 #' @templateVar env env
@@ -1127,24 +1007,12 @@ reactive <- function(
   label <- exprToLabel(userExpr, "reactive", label)
 
   o <- Observable$new(func, label, domain, ..stacktraceon = ..stacktraceon)
-
-  call_srcref <- get_call_srcref()
-  if (!is.null(call_srcref)) {
-    o$.otelAttrs <- otel_srcref_attributes(call_srcref, fn_name = "reactive")
-  }
-
-  ret <- structure(
+  structure(
     o$getValue,
     observable = o,
     cacheHint = list(userExpr = zap_srcref(userExpr)),
     class = c("reactiveExpr", "reactive", "function")
   )
-
-  if (has_otel_collect("reactivity")) {
-    ret <- enable_otel_reactive_expr(ret)
-  }
-
-  ret
 }
 
 # Given the srcref to a reactive expression, attempts to figure out what the
@@ -1152,7 +1020,7 @@ reactive <- function(
 # scans the line of code that started the reactive block and looks for something
 # that looks like assignment. If we fail, fall back to a default value (likely
 # the block of code in the body of the reactive).
-rexprSrcrefToLabel <- function(srcref, defaultLabel, fnName) {
+rexprSrcrefToLabel <- function(srcref, defaultLabel) {
   if (is.null(srcref))
     return(defaultLabel)
 
@@ -1175,8 +1043,7 @@ rexprSrcrefToLabel <- function(srcref, defaultLabel, fnName) {
 
   firstLine <- substring(lines[srcref[1]], 1, srcref[2] - 1)
 
-  # Require the assignment to be parsed from the start
-  m <- regexec(paste0("^(.*)(<<-|<-|=)\\s*", fnName, "\\s*\\($"), firstLine)
+  m <- regexec("(.*)(<-|=)\\s*reactive\\s*\\($", firstLine)
   if (m[[1]][1] == -1) {
     return(defaultLabel)
   }
@@ -1250,10 +1117,6 @@ Observer <- R6Class(
     .prevId = character(0),
     .ctx = NULL,
 
-    .isRecordingOtel = FALSE, # Needs to be set by Shiny
-    .otelLabel = NULL, # Needs to be set by Shiny
-    .otelAttrs = NULL, # Needs to be set by Shiny
-
     initialize = function(observerFunc, label, suspended = FALSE, priority = 0,
                           domain = getDefaultReactiveDomain(),
                           autoDestroy = TRUE, ..stacktraceon = TRUE) {
@@ -1288,18 +1151,7 @@ Observer <- R6Class(
       .createContext()$invalidate()
     },
     .createContext = function() {
-      ctx <- Context$new(
-        .domain,
-        .label,
-        type = 'observer',
-        prevId = .prevId,
-        reactId = .reactId,
-        otel_info = ctx_otel_info_obj(
-          isRecordingOtel = .isRecordingOtel,
-          otelLabel = .otelLabel,
-          otelAttrs = c(.otelAttrs, otel_session_id_attrs(.domain))
-        )
-      )
+      ctx <- Context$new(.domain, .label, type='observer', prevId=.prevId, reactId = .reactId)
       .prevId <<- ctx$id
 
       if (!is.null(.ctx)) {
@@ -1351,13 +1203,13 @@ Observer <- R6Class(
             # validation = function(e) NULL,
             # shiny.output.cancel = function(e) NULL
 
-            if (cnd_inherits(e, "shiny.silent.error")) {
+            if (inherits(e, "shiny.silent.error")) {
               return()
             }
 
             printError(e)
             if (!is.null(.domain)) {
-              .domain$unhandledError(e, close = TRUE)
+              .domain$unhandledError(e)
             }
           },
           finally = .domain$decrementBusyCount
@@ -1568,14 +1420,7 @@ observe <- function(
   check_dots_empty()
 
   func <- installExprFunction(x, "func", env, quoted)
-
-  call_srcref <- get_call_srcref()
-  if (is.null(label)) {
-    label <- rassignSrcrefToLabel(
-      call_srcref,
-      defaultLabel = funcToLabel(func, "observe", label)
-    )
-  }
+  label <- funcToLabel(func, "observe", label)
 
   o <- Observer$new(
     func,
@@ -1586,14 +1431,6 @@ observe <- function(
     autoDestroy = autoDestroy,
     ..stacktraceon = ..stacktraceon
   )
-  if (!is.null(call_srcref)) {
-    o$.otelAttrs <- otel_srcref_attributes(call_srcref, fn_name = "observe")
-  }
-
-  if (has_otel_collect("reactivity")) {
-    o <- enable_otel_observe(o)
-  }
-
   invisible(o)
 }
 
@@ -1981,64 +1818,34 @@ coerceToFunc <- function(x) {
 #' }
 #' @export
 reactivePoll <- function(intervalMillis, session, checkFunc, valueFunc) {
-  reactive_poll_impl(
-    fnName = "reactivePoll",
-    intervalMillis = intervalMillis,
-    session = session,
-    checkFunc = checkFunc,
-    valueFunc = valueFunc
-  )
-}
-
-reactive_poll_impl <- function(
-  fnName,
-  intervalMillis,
-  session,
-  checkFunc,
-  valueFunc
-) {
   intervalMillis <- coerceToFunc(intervalMillis)
 
-  fnName <- match.arg(fnName, c("reactivePoll", "reactiveFileReader"), several.ok = FALSE)
-
-  call_srcref <- get_call_srcref(-1)
-  label <- rassignSrcrefToLabel(
-    call_srcref,
-    defaultLabel = "<anonymous>",
-    fnName = fnName
-  )
+  rv <- reactiveValues(cookie = isolate(checkFunc()))
 
   re_finalized <- FALSE
   env <- environment()
 
-  with_no_otel_collect({
-    cookie <- reactiveVal(
-      isolate(checkFunc()),
-      label = sprintf("%s %s cookie", fnName, label)
-    )
+  o <- observe({
+    # When no one holds a reference to the reactive returned from
+    # reactivePoll, destroy and remove the observer so that it doesn't keep
+    # firing and hold onto resources.
+    if (re_finalized) {
+      o$destroy()
+      rm(o, envir = env)
+      return()
+    }
 
-    o <- observe({
-      # When no one holds a reference to the reactive returned from
-      # reactivePoll, destroy and remove the observer so that it doesn't keep
-      # firing and hold onto resources.
-      if (re_finalized) {
-        o$destroy()
-        rm(o, envir = env)
-        return()
-      }
-
-      cookie(checkFunc())
-      invalidateLater(intervalMillis(), session)
-    }, label = sprintf("%s %s cleanup", fnName, label))
+    rv$cookie <- checkFunc()
+    invalidateLater(intervalMillis(), session)
   })
 
-  re <- reactive(label = sprintf("%s %s", fnName, label), {
-    # Take a dependency on the cookie, so that when it changes, this
-    # reactive expression is invalidated.
-    cookie()
+  # TODO: what to use for a label?
+  re <- reactive({
+    rv$cookie
 
     valueFunc()
-  })
+
+  }, label = NULL)
 
   reg.finalizer(attr(re, "observable"), function(e) {
     re_finalized <<- TRUE
@@ -2048,16 +1855,6 @@ reactive_poll_impl <- function(
   # reference to `re` and thus prevent it from getting GC'd.
   on.exit(rm(re))
 
-  local({
-    impl <- attr(re, "observable", exact = TRUE)
-    impl$.otelLabel <-
-      if (fnName == "reactivePoll")
-        otel_label_reactive_poll(label, domain = impl$.domain)
-      else if (fnName == "reactiveFileReader")
-        otel_label_reactive_file_reader(label, domain = impl$.domain)
-    impl$.otelAttrs <- append_otel_srcref_attrs(impl$.otelAttrs, call_srcref, fn_name = fnName)
-  })
-
   return(re)
 }
 
@@ -2121,16 +1918,14 @@ reactiveFileReader <- function(intervalMillis, session, filePath, readFunc, ...)
   filePath <- coerceToFunc(filePath)
   extraArgs <- list2(...)
 
-  reactive_poll_impl(
-    fnName = "reactiveFileReader",
-    intervalMillis = intervalMillis,
-    session = session,
-    checkFunc = function() {
+  reactivePoll(
+    intervalMillis, session,
+    function() {
       path <- filePath()
       info <- file.info(path)
       return(paste(path, info$mtime, info$size))
     },
-    valueFunc = function() {
+    function() {
       do.call(readFunc, c(filePath(), extraArgs))
     }
   )
@@ -2212,8 +2007,6 @@ isolate <- function(expr) {
   } else {
     reactId <- rLog$noReactId
   }
-
-  # Do not track otel spans for `isolate()`
   ctx <- Context$new(getDefaultReactiveDomain(), '[isolate]', type='isolate', reactId = reactId)
   on.exit(ctx$invalidate())
   # Matching ..stacktraceon../..stacktraceoff.. pair
@@ -2387,8 +2180,8 @@ maskReactiveContext <- function(expr) {
 #' @param autoDestroy If `TRUE` (the default), the observer will be
 #'   automatically destroyed when its domain (if any) ends.
 #' @param ignoreNULL Whether the action should be triggered (or value
-#'   calculated, in the case of `eventReactive`) when the input event expression
-#'   is `NULL`. See Details.
+#'   calculated, in the case of `eventReactive`) when the input is
+#'   `NULL`. See Details.
 #' @param ignoreInit If `TRUE`, then, when this `observeEvent` is
 #'   first created/initialized, ignore the `handlerExpr` (the second
 #'   argument), whether it is otherwise supposed to run or not. The default is
@@ -2492,41 +2285,26 @@ observeEvent <- function(eventExpr, handlerExpr,
   eventQ <- exprToQuo(eventExpr, event.env, event.quoted)
   handlerQ <- exprToQuo(handlerExpr, handler.env, handler.quoted)
 
-  call_srcref <- get_call_srcref()
-  if (is.null(label)) {
-    label <- rassignSrcrefToLabel(
-      call_srcref,
-      defaultLabel = quoToLabel(eventQ, "observeEvent", label)
-    )
-  }
+  label <- quoToLabel(eventQ, "observeEvent", label)
 
-  with_no_otel_collect({
-    handler <- inject(observe(
-      !!handlerQ,
-      label = label,
-      suspended = suspended,
-      priority = priority,
-      domain = domain,
-      autoDestroy = TRUE,
-      ..stacktraceon = TRUE
-    ))
+  handler <- inject(observe(
+    !!handlerQ,
+    label = label,
+    suspended = suspended,
+    priority = priority,
+    domain = domain,
+    autoDestroy = TRUE,
+    ..stacktraceon = FALSE # TODO: Does this go in the bindEvent?
+  ))
 
-    o <- inject(bindEvent(
-      ignoreNULL = ignoreNULL,
-      ignoreInit = ignoreInit,
-      once = once,
-      label = label,
-      !!eventQ,
-      x = handler
-    ))
-  })
-
-  if (!is.null(call_srcref)) {
-    o$.otelAttrs <- otel_srcref_attributes(call_srcref, fn_name = "observeEvent")
-  }
-  if (has_otel_collect("reactivity")) {
-    o <- enable_otel_observe(o)
-  }
+  o <- inject(bindEvent(
+    ignoreNULL = ignoreNULL,
+    ignoreInit = ignoreInit,
+    once = once,
+    label = label,
+    !!eventQ,
+    x = handler
+  ))
 
   invisible(o)
 }
@@ -2545,40 +2323,15 @@ eventReactive <- function(eventExpr, valueExpr,
   eventQ <- exprToQuo(eventExpr, event.env, event.quoted)
   valueQ <- exprToQuo(valueExpr, value.env, value.quoted)
 
-  func <- installExprFunction(eventExpr, "func", event.env, event.quoted, wrappedWithLabel = FALSE)
-  # Attach a label and a reference to the original user source for debugging
-  userEventExpr <- fn_body(func)
+  label <- quoToLabel(eventQ, "eventReactive", label)
 
-  call_srcref <- get_call_srcref()
-  if (is.null(label)) {
-    label <- rassignSrcrefToLabel(
-      call_srcref,
-      defaultLabel = exprToLabel(userEventExpr, "eventReactive", label)
-    )
-  }
-
-  with_no_otel_collect({
-    value_r <- inject(reactive(!!valueQ, domain = domain, label = label))
-
-    r <- inject(bindEvent(
-      ignoreNULL = ignoreNULL,
-      ignoreInit = ignoreInit,
-      label = label,
-      !!eventQ,
-      x = value_r
-    ))
-  })
-
-  if (!is.null(call_srcref)) {
-    impl <- attr(r, "observable", exact = TRUE)
-    impl$.otelAttrs <- otel_srcref_attributes(call_srcref, fn_name = "eventReactive")
-  }
-  if (has_otel_collect("reactivity")) {
-    r <- enable_otel_reactive_expr(r)
-  }
-
-
-  return(r)
+  invisible(inject(bindEvent(
+    ignoreNULL = ignoreNULL,
+    ignoreInit = ignoreInit,
+    label = label,
+    !!eventQ,
+    x = reactive(!!valueQ, domain = domain, label = label)
+  )))
 }
 
 isNullEvent <- function(value) {
@@ -2636,7 +2389,7 @@ isNullEvent <- function(value) {
 #' reactive recently (within the time window) invalidated. New `r`
 #' invalidations do not reset the time window. This means that if invalidations
 #' continually come from `r` within the time window, the throttled reactive
-#' will invalidate regularly, at a rate equal to or slower than the time
+#' will invalidate regularly, at a rate equal to or slower than than the time
 #' window.
 #'
 #' `ooo-oo-oo---- => o--o--o--o---`
@@ -2693,103 +2446,71 @@ isNullEvent <- function(value) {
 #'
 #' @export
 debounce <- function(r, millis, priority = 100, domain = getDefaultReactiveDomain()) {
-  # Do not bind OpenTelemetry spans for debounce reactivity internals,
-  # except for the eventReactive that is returned.
+
+  # TODO: make a nice label for the observer(s)
 
   force(r)
   force(millis)
 
-  call_srcref <- get_call_srcref()
-  label <- rassignSrcrefToLabel(
-    call_srcref,
-    defaultLabel = "<anonymous>"
-  )
-
   if (!is.function(millis)) {
     origMillis <- millis
     millis <- function() origMillis
   }
 
-  with_no_otel_collect({
-    trigger <- reactiveVal(NULL, label = sprintf("debounce %s trigger", label))
-    # the deadline for the timer to fire; NULL if not scheduled
-    when <- reactiveVal(NULL, label = sprintf("debounce %s when", label))
-
-    # Responsible for tracking when r() changes.
-    firstRun <- TRUE
-    observe(
-      label = sprintf("debounce %s tracker", label),
-      domain = domain,
-      priority = priority,
-      {
-        if (firstRun) {
-          # During the first run we don't want to set `when`, as this will kick
-          # off the timer. We only want to do that when we see `r()` change.
-          firstRun <<- FALSE
-
-          # Ensure r() is called only after setting firstRun to FALSE since r()
-          # may throw an error
-          try(r(), silent = TRUE)
-          return()
-        }
-        # This ensures r() is still tracked after firstRun
-        try(r(), silent = TRUE)
-
-        # The value (or possibly millis) changed. Start or reset the timer.
-        when(
-          getDomainTimeMs(domain) + millis()
-        )
-      }
-    )
-
-    # This observer is the timer. It rests until `when` elapses, then touches
-    # `trigger`.
-    observe(
-      label = sprintf("debounce %s timer", label),
-      domain = domain,
-      priority = priority,
-      {
-        if (is.null(when()))
-          return()
-
-        now <- getDomainTimeMs(domain)
-        if (now >= when()) {
-          # Mod by 999999999 to get predictable overflow behavior
-          trigger(
-            isolate(trigger() %||% 0) %% 999999999 + 1
-          )
-          when(NULL)
-        } else {
-          invalidateLater(when() - now)
-        }
-      }
-    )
-
-  })
-
-  # This is the actual reactive that is returned to the user. It returns the
-  # value of r(), but only invalidates/updates when `trigger` is touched.
-  er <- eventReactive(
-    {trigger()}, {r()},
-    label = sprintf("debounce %s result", label), ignoreNULL = FALSE, domain = domain
+  v <- reactiveValues(
+    trigger = NULL,
+    when = NULL # the deadline for the timer to fire; NULL if not scheduled
   )
 
-  # Update the otel label
-  local({
-    er_impl <- attr(er, "observable", exact = TRUE)
-    er_impl$.otelLabel <- otel_label_debounce(label, domain = domain)
-    er_impl$.otelAttrs <- append_otel_srcref_attrs(er_impl$.otelAttrs, call_srcref, fn_name = "debounce")
-  })
+  # Responsible for tracking when r() changes.
+  firstRun <- TRUE
+  observe({
+    if (firstRun) {
+      # During the first run we don't want to set v$when, as this will kick off
+      # the timer. We only want to do that when we see r() change.
+      firstRun <<- FALSE
 
-  with_no_otel_collect({
-    # Force the value of er to be immediately cached upon creation. It's very hard
-    # to explain why this observer is needed, but if you want to understand, try
-    # commenting it out and studying the unit test failure that results.
-    primer <- observe({
-      primer$destroy()
-      try(er(), silent = TRUE)
-    }, label = sprintf("debounce %s primer", label), domain = domain, priority = priority)
-  })
+      # Ensure r() is called only after setting firstRun to FALSE since r()
+      # may throw an error
+      r()
+      return()
+    }
+    # This ensures r() is still tracked after firstRun
+    r()
+
+    # The value (or possibly millis) changed. Start or reset the timer.
+    v$when <- getDomainTimeMs(domain) + millis()
+  }, label = "debounce tracker", domain = domain, priority = priority)
+
+  # This observer is the timer. It rests until v$when elapses, then touches
+  # v$trigger.
+  observe({
+    if (is.null(v$when))
+      return()
+
+    now <- getDomainTimeMs(domain)
+    if (now >= v$when) {
+      # Mod by 999999999 to get predictable overflow behavior
+      v$trigger <- isolate(v$trigger %||% 0) %% 999999999 + 1
+      v$when <- NULL
+    } else {
+      invalidateLater(v$when - now)
+    }
+  }, label = "debounce timer", domain = domain, priority = priority)
+
+  # This is the actual reactive that is returned to the user. It returns the
+  # value of r(), but only invalidates/updates when v$trigger is touched.
+  er <- eventReactive(v$trigger, {
+    r()
+  }, label = "debounce result", ignoreNULL = FALSE, domain = domain)
+
+  # Force the value of er to be immediately cached upon creation. It's very hard
+  # to explain why this observer is needed, but if you want to understand, try
+  # commenting it out and studying the unit test failure that results.
+  primer <- observe({
+    primer$destroy()
+    er()
+  }, label = "debounce primer", domain = domain, priority = priority)
 
   er
 }
@@ -2797,88 +2518,69 @@ debounce <- function(r, millis, priority = 100, domain = getDefaultReactiveDomai
 #' @rdname debounce
 #' @export
 throttle <- function(r, millis, priority = 100, domain = getDefaultReactiveDomain()) {
-  # Do not bind OpenTelemetry spans for throttle reactivity internals,
-  # except for the eventReactive that is returned.
+
+  # TODO: make a nice label for the observer(s)
 
   force(r)
   force(millis)
 
-  call_srcref <- get_call_srcref()
-  label <- rassignSrcrefToLabel(
-    call_srcref,
-    defaultLabel = "<anonymous>"
-  )
-
   if (!is.function(millis)) {
     origMillis <- millis
     millis <- function() origMillis
   }
 
-  with_no_otel_collect({
-    trigger <- reactiveVal(0, label = sprintf("throttle %s trigger", label))
-    # Last time we fired; NULL if never
-    lastTriggeredAt <- reactiveVal(NULL, label = sprintf("throttle %s last triggered at", label))
-    # If TRUE, trigger again when timer elapses
-    pending <- reactiveVal(FALSE, label = sprintf("throttle %s pending", label))
-  })
+  v <- reactiveValues(
+    trigger = 0,
+    lastTriggeredAt = NULL, # Last time we fired; NULL if never
+    pending = FALSE # If TRUE, trigger again when timer elapses
+  )
 
   blackoutMillisLeft <- function() {
-    if (is.null(lastTriggeredAt())) {
+    if (is.null(v$lastTriggeredAt)) {
       0
     } else {
-      max(0, lastTriggeredAt() + millis() - getDomainTimeMs(domain))
+      max(0, v$lastTriggeredAt + millis() - getDomainTimeMs(domain))
     }
   }
 
-  update_trigger <- function() {
-    lastTriggeredAt(getDomainTimeMs(domain))
+  trigger <- function() {
+    v$lastTriggeredAt <- getDomainTimeMs(domain)
     # Mod by 999999999 to get predictable overflow behavior
-    trigger(isolate(trigger()) %% 999999999 + 1)
-    pending(FALSE)
+    v$trigger <- isolate(v$trigger) %% 999999999 + 1
+    v$pending <- FALSE
   }
 
-  with_no_otel_collect({
-    # Responsible for tracking when f() changes.
-    observeEvent(try(r(), silent = TRUE), {
-      if (pending()) {
-        # In a blackout period and someone already scheduled; do nothing
-      } else if (blackoutMillisLeft() > 0) {
-        # In a blackout period but this is the first change in that period; set
-        # pending so that a trigger will be scheduled at the end of the period
-        pending(TRUE)
-      } else {
-        # Not in a blackout period. Trigger, which will start a new blackout
-        # period.
-        update_trigger()
-      }
-    }, label = sprintf("throttle %s tracker", label), ignoreNULL = FALSE, priority = priority, domain = domain)
+  # Responsible for tracking when f() changes.
+  observeEvent(r(), {
+    if (v$pending) {
+      # In a blackout period and someone already scheduled; do nothing
+    } else if (blackoutMillisLeft() > 0) {
+      # In a blackout period but this is the first change in that period; set
+      # v$pending so that a trigger will be scheduled at the end of the period
+      v$pending <- TRUE
+    } else {
+      # Not in a blackout period. Trigger, which will start a new blackout
+      # period.
+      trigger()
+    }
+  }, label = "throttle tracker", ignoreNULL = FALSE, priority = priority, domain = domain)
 
-    observe({
-      if (!pending()) {
-        return()
-      }
+  observe({
+    if (!v$pending) {
+      return()
+    }
 
-      timeout <- blackoutMillisLeft()
-      if (timeout > 0) {
-        invalidateLater(timeout)
-      } else {
-        update_trigger()
-      }
-    }, label = sprintf("throttle %s trigger", label), priority = priority, domain = domain)
-  })
+    timeout <- blackoutMillisLeft()
+    if (timeout > 0) {
+      invalidateLater(timeout)
+    } else {
+      trigger()
+    }
+  }, priority = priority, domain = domain)
 
   # This is the actual reactive that is returned to the user. It returns the
-  # value of r(), but only invalidates/updates when trigger is touched.
-  er <- eventReactive({trigger()}, {
+  # value of r(), but only invalidates/updates when v$trigger is touched.
+  eventReactive(v$trigger, {
     r()
-  }, label = sprintf("throttle %s result", label), ignoreNULL = FALSE, domain = domain)
-
-  # Update the otel label
-  local({
-    er_impl <- attr(er, "observable", exact = TRUE)
-    er_impl$.otelLabel <- otel_label_throttle(label, domain = domain)
-    er_impl$.otelAttrs <- append_otel_srcref_attrs(er_impl$.otelAttrs, call_srcref, fn_name = "throttle")
-  })
-
-  er
+  }, label = "throttle result", ignoreNULL = FALSE, domain = domain)
 }

R/reexports.R

@@ -1,6 +1,6 @@
 ####
-# Generated by `./tools/documentation/updateReexports.R`: do not edit by hand
-# Please call `source('tools/documentation/updateReexports.R')` from the root folder to update`
+# Generated by `./tools/updateReexports.R`: do not edit by hand
+# Please call `source('tools/updateReexports.R') from the root folder to update`
 ####
 
 
@@ -90,20 +90,17 @@ htmltools::em
 #' @export
 htmltools::hr
 
+
+# htmltools tag.Rd -------------------------------------------------------------
+
 #' @importFrom htmltools tag
 #' @export
 htmltools::tag
 
-
-# htmltools tagList.Rd ---------------------------------------------------------
-
 #' @importFrom htmltools tagList
 #' @export
 htmltools::tagList
 
-
-# htmltools tagAppendAttributes.Rd ---------------------------------------------
-
 #' @importFrom htmltools tagAppendAttributes
 #' @export
 htmltools::tagAppendAttributes
@@ -116,9 +113,6 @@ htmltools::tagHasAttribute
 #' @export
 htmltools::tagGetAttribute
 
-
-# htmltools tagAppendChild.Rd --------------------------------------------------
-
 #' @importFrom htmltools tagAppendChild
 #' @export
 htmltools::tagAppendChild

R/render-cached-plot.R

@@ -181,7 +181,7 @@
 #' # At the top of app.R, this set the application-scoped cache to be a disk
 #' # cache that can be shared among multiple concurrent R processes, and is
 #' # deleted when the system reboots.
-#' shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache")))
+#' shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache"))
 #'
 #' # At the top of app.R, this set the application-scoped cache to be a disk
 #' # cache that can be shared among multiple concurrent R processes, and

R/render-plot.R

@@ -34,7 +34,7 @@
 #'   When rendering an inline plot, you must provide numeric values (in pixels)
 #'   to both \code{width} and \code{height}.
 #' @param res Resolution of resulting plot, in pixels per inch. This value is
-#'   passed to [plotPNG()]. Note that this affects the resolution of PNG
+#'   passed to [grDevices::png()]. Note that this affects the resolution of PNG
 #'   rendering in R; it won't change the actual ppi of the browser.
 #' @param alt Alternate text for the HTML `<img>` tag if it cannot be displayed
 #'   or viewed (i.e., the user uses a screen reader). In addition to a character
@@ -44,7 +44,7 @@
 #'   ggplot objects; for other plots, `NA` results in alt text of "Plot object".
 #'   `NULL` or `""` is not recommended because those should be limited to
 #'   decorative images.
-#' @param ... Arguments to be passed through to [plotPNG()].
+#' @param ... Arguments to be passed through to [grDevices::png()].
 #'   These can be used to set the width, height, background color, etc.
 #' @inheritParams renderUI
 #' @param execOnResize If `FALSE` (the default), then when a plot is
@@ -194,8 +194,8 @@ renderPlot <- function(expr, width = 'auto', height = 'auto', res = 72, ...,
 }
 
 resizeSavedPlot <- function(name, session, result, width, height, alt, pixelratio, res, ...) {
-  if (isTRUE(result$img$width == width && result$img$height == height &&
-      result$pixelratio == pixelratio && result$res == res)) {
+  if (result$img$width == width && result$img$height == height &&
+      result$pixelratio == pixelratio && result$res == res) {
     return(result)
   }
 
@@ -253,7 +253,7 @@ drawPlot <- function(name, session, func, width, height, alt, pixelratio, res, .
 
   hybrid_chain(
     hybrid_chain(
-      with_promise_domain(domain, {
+      promises::with_promise_domain(domain, {
         hybrid_chain(
           func(),
           function(value) {
@@ -266,8 +266,6 @@ drawPlot <- function(name, session, func, width, height, alt, pixelratio, res, .
               # addition to ggplot, and there's a print method for that class, that we
               # won't override that method. https://github.com/rstudio/shiny/issues/841
               print.ggplot <- custom_print.ggplot
-              # For compatibility with ggplot2 >v4.0.0
-              `print.ggplot2::ggplot` <- custom_print.ggplot
 
               # Use capture.output to squelch printing to the actual console; we
               # are only interested in plot output
@@ -614,7 +612,7 @@ getGgplotCoordmap <- function(p, width, height, res) {
 find_panel_info <- function(b) {
   # Structure of ggplot objects changed after 2.1.0. After 2.2.1, there was a
   # an API for extracting the necessary information.
-  ggplot_ver <- get_package_version("ggplot2")
+  ggplot_ver <- utils::packageVersion("ggplot2")
 
   if (ggplot_ver > "2.2.1") {
     find_panel_info_api(b)

R/run-url.R

@@ -23,10 +23,10 @@
 #' @examples
 #' ## Only run this example in interactive R sessions
 #' if (interactive()) {
-#'   runUrl('https://github.com/rstudio/shiny_example/archive/main.tar.gz')
+#'   runUrl('https://github.com/rstudio/shiny_example/archive/master.tar.gz')
 #'
 #'   # Can run an app from a subdirectory in the archive
-#'   runUrl("https://github.com/rstudio/shiny_example/archive/main.zip",
+#'   runUrl("https://github.com/rstudio/shiny_example/archive/master.zip",
 #'     subdir = "inst/shinyapp/")
 #' }
 runUrl <- function(url, filetype = NULL, subdir = NULL, destdir = NULL, ...) {
@@ -121,8 +121,7 @@ runGist <- function(gist, destdir = NULL, ...) {
 #' @param username GitHub username. If `repo` is of the form
 #'   `"username/repo"`, `username` will be taken from `repo`.
 #' @param ref Desired git reference. Could be a commit, tag, or branch name.
-#'   Defaults to `"HEAD"`, which means the default branch on GitHub, typically
-#'   `"main"` or `"master"`.
+#'   Defaults to `"master"`.
 #' @export
 #' @examples
 #' ## Only run this example in interactive R sessions
@@ -134,7 +133,7 @@ runGist <- function(gist, destdir = NULL, ...) {
 #'   runGitHub("shiny_example", "rstudio", subdir = "inst/shinyapp/")
 #' }
 runGitHub <- function(repo, username = getOption("github.user"),
-                      ref = "HEAD", subdir = NULL, destdir = NULL, ...) {
+                      ref = "master", subdir = NULL, destdir = NULL, ...) {
 
   if (grepl('/', repo)) {
     res <- strsplit(repo, '/')[[1]]

R/runapp.R

@@ -28,7 +28,7 @@
 #'   ports will be tried.
 #' @param launch.browser If true, the system's default web browser will be
 #'   launched automatically after the app is started. Defaults to true in
-#'   interactive sessions only. The value of this parameter can also be a
+#'   interactive sessions only. This value of this parameter can also be a
 #'   function to call with the application's URL.
 #' @param host The IPv4 address that the application should listen on. Defaults
 #'   to the `shiny.host` option, if set, or `"127.0.0.1"` if not. See
@@ -84,22 +84,13 @@
 #'   runApp(app)
 #' }
 #' @export
-runApp <- function(
-  appDir=getwd(),
-  port=getOption('shiny.port'),
-  launch.browser = getOption('shiny.launch.browser', interactive()),
-  host=getOption('shiny.host', '127.0.0.1'),
-  workerId="", quiet=FALSE,
-  display.mode=c("auto", "normal", "showcase"),
-  test.mode=getOption('shiny.testmode', FALSE)
-) {
-
-  # * Wrap **all** execution of the app inside the otel promise domain
-  # * While this could be done at a lower level, it allows for _anything_ within
-  #   shiny's control to allow for the opportunity to have otel active spans be
-  #   reactivated upon promise domain restoration
-  promises::local_otel_promise_domain()
-
+runApp <- function(appDir=getwd(),
+                   port=getOption('shiny.port'),
+                   launch.browser = getOption('shiny.launch.browser', interactive()),
+                   host=getOption('shiny.host', '127.0.0.1'),
+                   workerId="", quiet=FALSE,
+                   display.mode=c("auto", "normal", "showcase"),
+                   test.mode=getOption('shiny.testmode', FALSE)) {
   on.exit({
     handlerManager$clear()
   }, add = TRUE)
@@ -454,20 +445,8 @@ stopApp <- function(returnValue = invisible()) {
 #' @param host The IPv4 address that the application should listen on. Defaults
 #'   to the `shiny.host` option, if set, or `"127.0.0.1"` if not.
 #' @param display.mode The mode in which to display the example. Defaults to
-#'   `"auto"`, which uses the value of `DisplayMode` in the example's
-#'   `DESCRIPTION` file. Set to `"showcase"` to show the app code and
-#'   description with the running app, or `"normal"` to see the example without
+#'   `showcase`, but may be set to `normal` to see the example without
 #'   code or commentary.
-#' @param package The package in which to find the example (defaults to
-#'   `"shiny"`).
-#'
-#'   To provide examples in your package, store examples in the
-#'   `inst/examples-shiny` directory of your package. Each example should be
-#'   in its own subdirectory and should be runnable when [runApp()] is called
-#'   on the subdirectory. Example apps can include a `DESCRIPTION` file and a
-#'   `README.md` file to provide metadata and commentary about the example. See
-#'   the article on [Display Modes](https://shiny.posit.co/r/articles/build/display-modes/)
-#'   on the Shiny website for more information.
 #' @inheritParams runApp
 #'
 #' @examples
@@ -483,46 +462,32 @@ stopApp <- function(returnValue = invisible()) {
 #'   system.file("examples", package="shiny")
 #' }
 #' @export
-runExample <- function(
-  example = NA,
-  port = getOption("shiny.port"),
-  launch.browser = getOption("shiny.launch.browser", interactive()),
-  host = getOption("shiny.host", "127.0.0.1"),
-  display.mode = c("auto", "normal", "showcase"),
-  package = "shiny"
-) {
-  if (!identical(package, "shiny") && !is_installed(package)) {
-    rlang::check_installed(package)
-  }
-
-  use_legacy_shiny_examples <-
-    identical(package, "shiny") &&
-    isTRUE(getOption('shiny.legacy.examples', FALSE))
-
-  examplesDir <- system_file(
-    if (use_legacy_shiny_examples) "examples" else "examples-shiny",
-    package = package
-  )
-
+runExample <- function(example=NA,
+                       port=getOption("shiny.port"),
+                       launch.browser = getOption('shiny.launch.browser', interactive()),
+                       host=getOption('shiny.host', '127.0.0.1'),
+                       display.mode=c("auto", "normal", "showcase")) {
+  examplesDir <- system.file('examples', package='shiny')
   dir <- resolve(examplesDir, example)
-
   if (is.null(dir)) {
-    valid_examples <- sprintf(
-      'Valid examples in {%s}: "%s"',
-      package,
-      paste(list.files(examplesDir), collapse = '", "')
-    )
-
     if (is.na(example)) {
-      message(valid_examples)
-      return(invisible())
+      errFun <- message
+      errMsg <- ''
+    }
+    else {
+      errFun <- stop
+      errMsg <- paste('Example', example, 'does not exist. ')
     }
 
-    stop("Example '", example, "' does not exist. ", valid_examples)
+    errFun(errMsg,
+           'Valid examples are "',
+           paste(list.files(examplesDir), collapse='", "'),
+           '"')
+  }
+  else {
+    runApp(dir, port = port, host = host, launch.browser = launch.browser,
+           display.mode = display.mode)
   }
-
-  runApp(dir, port = port, host = host, launch.browser = launch.browser,
-         display.mode = display.mode)
 }
 
 #' Run a gadget

R/server-input-handlers.R

@@ -1,9 +1,5 @@
-# Create a Map object for input handlers and register the defaults.
-# This is assigned in .onLoad time.
-inputHandlers <- NULL
-on_load({
-  inputHandlers <- Map$new()
-})
+# Create a map for input handlers and register the defaults.
+inputHandlers <- Map$new()
 
 #' Register an Input Handler
 #'
@@ -45,9 +41,9 @@ on_load({
 #' })
 #'
 #' ## On the Javascript side, the associated input binding must have a corresponding getType method:
-#' # getType: function(el) {
-#' #   return "mypackage.validint";
-#' # }
+#' getType: function(el) {
+#'   return "mypackage.validint";
+#' }
 #'
 #' }
 #' @seealso [removeInputHandler()] [applyInputHandlers()]
@@ -129,117 +125,115 @@ applyInputHandlers <- function(inputs, shinysession = getDefaultReactiveDomain()
   inputs
 }
 
-on_load({
-  # Takes a list-of-lists and returns a matrix. The lists
-  # must all be the same length. NULL is replaced by NA.
-  registerInputHandler("shiny.matrix", function(data, ...) {
-    if (length(data) == 0)
-      return(matrix(nrow=0, ncol=0))
 
-    m <- matrix(unlist(lapply(data, function(x) {
-      sapply(x, function(y) {
-        ifelse(is.null(y), NA, y)
-      })
-    })), nrow = length(data[[1]]), ncol = length(data))
-    return(m)
-  })
+# Takes a list-of-lists and returns a matrix. The lists
+# must all be the same length. NULL is replaced by NA.
+registerInputHandler("shiny.matrix", function(data, ...) {
+  if (length(data) == 0)
+    return(matrix(nrow=0, ncol=0))
 
-
-  registerInputHandler("shiny.number", function(val, ...){
-    ifelse(is.null(val), NA, val)
-  })
-
-  registerInputHandler("shiny.password", function(val, shinysession, name) {
-    # Mark passwords as not serializable
-    setSerializer(name, serializerUnserializable)
-    val
-  })
-
-  registerInputHandler("shiny.date", function(val, ...){
-    # First replace NULLs with NA, then convert to Date vector
-    datelist <- ifelse(lapply(val, is.null), NA, val)
-
-    res <- NULL
-    tryCatch({
-        res <- as.Date(unlist(datelist))
-      },
-      error = function(e) {
-        # It's possible for client to send a string like "99999-01-01", which
-        # as.Date can't handle.
-        warning(e$message)
-        res <<- as.Date(rep(NA, length(datelist)))
-      }
-    )
-
-    res
-  })
-
-  registerInputHandler("shiny.datetime", function(val, ...){
-    # First replace NULLs with NA, then convert to POSIXct vector
-    times <- lapply(val, function(x) {
-      if (is.null(x)) NA
-      else x
+  m <- matrix(unlist(lapply(data, function(x) {
+    sapply(x, function(y) {
+      ifelse(is.null(y), NA, y)
     })
-    as.POSIXct(unlist(times), origin = "1970-01-01", tz = "UTC")
-  })
-
-  registerInputHandler("shiny.action", function(val, shinysession, name) {
-    # mark up the action button value with a special class so we can recognize it later
-    class(val) <- c("shinyActionButtonValue", class(val))
-    val
-  })
-
-  registerInputHandler("shiny.file", function(val, shinysession, name) {
-    # This function is only used when restoring a Shiny fileInput. When a file is
-    # uploaded the usual way, it takes a different code path and won't hit this
-    # function.
-    if (is.null(val))
-      return(NULL)
-
-    # The data will be a named list of lists; convert to a data frame.
-    val <- as.data.frame(lapply(val, unlist), stringsAsFactors = FALSE)
-
-    # `val$datapath` should be a filename without a path, for security reasons.
-    if (basename(val$datapath) != val$datapath) {
-      stop("Invalid '/' found in file input path.")
-    }
-
-    # Prepend the persistent dir
-    oldfile <- file.path(getCurrentRestoreContext()$dir, val$datapath)
-
-    # Copy the original file to a new temp dir, so that a restored session can't
-    # modify the original.
-    newdir <- file.path(tempdir(), createUniqueId(12))
-    dir.create(newdir)
-    val$datapath <- file.path(newdir, val$datapath)
-    file.copy(oldfile, val$datapath)
-
-    # Need to mark this input value with the correct serializer. When a file is
-    # uploaded the usual way (instead of being restored), this occurs in
-    # session$`@uploadEnd`.
-    setSerializer(name, serializerFileInput)
-
-    snapshotPreprocessInput(name, snapshotPreprocessorFileInput)
-
-    val
-  })
-
-
-  # to be used with !!!answer
-  registerInputHandler("shiny.symbolList", function(val, ...) {
-    if (is.null(val)) {
-      list()
-    } else {
-      lapply(val, as.symbol)
-    }
-  })
-  # to be used with !!answer
-  registerInputHandler("shiny.symbol", function(val, ...) {
-    if (is.null(val) || identical(val, "")) {
-      NULL
-    } else {
-      as.symbol(val)
-    }
-  })
-
+  })), nrow = length(data[[1]]), ncol = length(data))
+  return(m)
+})
+
+
+registerInputHandler("shiny.number", function(val, ...){
+  ifelse(is.null(val), NA, val)
+})
+
+registerInputHandler("shiny.password", function(val, shinysession, name) {
+  # Mark passwords as not serializable
+  setSerializer(name, serializerUnserializable)
+  val
+})
+
+registerInputHandler("shiny.date", function(val, ...){
+  # First replace NULLs with NA, then convert to Date vector
+  datelist <- ifelse(lapply(val, is.null), NA, val)
+
+  res <- NULL
+  tryCatch({
+      res <- as.Date(unlist(datelist))
+    },
+    error = function(e) {
+      # It's possible for client to send a string like "99999-01-01", which
+      # as.Date can't handle.
+      warning(e$message)
+      res <<- as.Date(rep(NA, length(datelist)))
+    }
+  )
+
+  res
+})
+
+registerInputHandler("shiny.datetime", function(val, ...){
+  # First replace NULLs with NA, then convert to POSIXct vector
+  times <- lapply(val, function(x) {
+    if (is.null(x)) NA
+    else x
+  })
+  as.POSIXct(unlist(times), origin = "1970-01-01", tz = "UTC")
+})
+
+registerInputHandler("shiny.action", function(val, shinysession, name) {
+  # mark up the action button value with a special class so we can recognize it later
+  class(val) <- c(class(val), "shinyActionButtonValue")
+  val
+})
+
+registerInputHandler("shiny.file", function(val, shinysession, name) {
+  # This function is only used when restoring a Shiny fileInput. When a file is
+  # uploaded the usual way, it takes a different code path and won't hit this
+  # function.
+  if (is.null(val))
+    return(NULL)
+
+  # The data will be a named list of lists; convert to a data frame.
+  val <- as.data.frame(lapply(val, unlist), stringsAsFactors = FALSE)
+
+  # `val$datapath` should be a filename without a path, for security reasons.
+  if (basename(val$datapath) != val$datapath) {
+    stop("Invalid '/' found in file input path.")
+  }
+
+  # Prepend the persistent dir
+  oldfile <- file.path(getCurrentRestoreContext()$dir, val$datapath)
+
+  # Copy the original file to a new temp dir, so that a restored session can't
+  # modify the original.
+  newdir <- file.path(tempdir(), createUniqueId(12))
+  dir.create(newdir)
+  val$datapath <- file.path(newdir, val$datapath)
+  file.copy(oldfile, val$datapath)
+
+  # Need to mark this input value with the correct serializer. When a file is
+  # uploaded the usual way (instead of being restored), this occurs in
+  # session$`@uploadEnd`.
+  setSerializer(name, serializerFileInput)
+
+  snapshotPreprocessInput(name, snapshotPreprocessorFileInput)
+
+  val
+})
+
+
+# to be used with !!!answer
+registerInputHandler("shiny.symbolList", function(val, ...) {
+  if (is.null(val)) {
+    list()
+  } else {
+    lapply(val, as.symbol)
+  }
+})
+# to be used with !!answer
+registerInputHandler("shiny.symbol", function(val, ...) {
+  if (is.null(val) || identical(val, "")) {
+    NULL
+  } else {
+    as.symbol(val)
+  }
 })

R/server.R

@@ -1,12 +1,7 @@
 #' @include server-input-handlers.R
 
-appsByToken <- NULL
-appsNeedingFlush <- NULL
-on_load({
-  appsByToken <- Map$new()
-  appsNeedingFlush <- Map$new()
-})
-
+appsByToken <- Map$new()
+appsNeedingFlush <- Map$new()
 
 # Provide a character representation of the WS that can be used
 # as a key in a Map.
@@ -34,7 +29,7 @@ registerClient <- function(client) {
 
 #' Define Server Functionality
 #'
-#' @description `r lifecycle::badge("superseded")`
+#' @description \lifecycle{superseded}
 #'
 #' @description Defines the server-side logic of the Shiny application. This generally
 #' involves creating functions that map user inputs to various kinds of output.
@@ -54,7 +49,7 @@ registerClient <- function(client) {
 #' optional `session` parameter, which is used when greater control is
 #' needed.
 #'
-#' See the [tutorial](https://shiny.rstudio.com/tutorial/) for more
+#' See the [tutorial](https://rstudio.github.io/shiny/tutorial/) for more
 #' on how to write a server function.
 #'
 #' @param func The server function for this application. See the details section
@@ -127,16 +122,13 @@ decodeMessage <- function(data) {
   return(mainMessage)
 }
 
-autoReloadCallbacks <- NULL
-on_load({
-  autoReloadCallbacks <- Callbacks$new()
-})
+autoReloadCallbacks <- Callbacks$new()
 
 createAppHandlers <- function(httpHandlers, serverFuncSource) {
   appvars <- new.env()
   appvars$server <- NULL
 
-  sys.www.root <- system_file('www', package='shiny')
+  sys.www.root <- system.file('www', package='shiny')
 
   # This value, if non-NULL, must be present on all HTTP and WebSocket
   # requests as the Shiny-Shared-Secret header or else access will be
@@ -274,20 +266,15 @@ createAppHandlers <- function(httpHandlers, serverFuncSource) {
                 args <- argsForServerFunc(serverFunc, shinysession)
 
                 withReactiveDomain(shinysession, {
-                  otel_span_session_start(domain = shinysession, {
-
-                    do.call(
-                      # No corresponding ..stacktraceoff; the server func is pure
-                      # user code
-                      wrapFunctionLabel(appvars$server, "server",
-                        ..stacktraceon = TRUE
-                      ),
-                      args
-                    )
-
-                  })
+                  do.call(
+                    # No corresponding ..stacktraceoff; the server func is pure
+                    # user code
+                    wrapFunctionLabel(appvars$server, "server",
+                      ..stacktraceon = TRUE
+                    ),
+                    args
+                  )
                 })
-
               })
             },
             update = {
@@ -344,7 +331,7 @@ argsForServerFunc <- function(serverFunc, session) {
 getEffectiveBody <- function(func) {
   if (is.null(func))
     NULL
-  else if (isS4(func) && inherits(func, "functionWithTrace"))
+  else if (isS4(func) && class(func) == "functionWithTrace")
     body(func@original)
   else
     body(func)
@@ -398,7 +385,7 @@ startApp <- function(appObj, port, host, quiet) {
     list(
       # Always handle /session URLs dynamically, even if / is a static path.
       "session" = excludeStaticPath(),
-      "shared" = system_file(package = "shiny", "www", "shared")
+      "shared" = system.file(package = "shiny", "www", "shared")
     ),
     .globals$resourcePaths
   )

R/shiny-options.R

@@ -65,20 +65,16 @@ getShinyOption <- function(name, default = NULL) {
 #'   changes are detected, all connected Shiny sessions are reloaded. This
 #'   allows for fast feedback loops when tweaking Shiny UI.
 #'
-#'   Monitoring for changes is no longer expensive, thanks to the \pkg{watcher}
-#'   package, but this feature is still intended only for development.
+#'   Since monitoring for changes is expensive (we simply poll for last
+#'   modified times), this feature is intended only for development.
 #'
 #'   You can customize the file patterns Shiny will monitor by setting the
-#'   shiny.autoreload.pattern option. For example, to monitor only `ui.R`:
-#'   `options(shiny.autoreload.pattern = glob2rx("ui.R"))`.
+#'   shiny.autoreload.pattern option. For example, to monitor only ui.R:
+#'   `options(shiny.autoreload.pattern = glob2rx("ui.R"))`
 #'
-#'   As mentioned above, Shiny no longer polls watched files for changes.
-#'   Instead, using \pkg{watcher}, Shiny is notified of file changes as they
-#'   occur. These changes are batched together within a customizable latency
-#'   period. You can adjust this period by setting
-#'   `options(shiny.autoreload.interval = 2000)` (in milliseconds). This value
-#'   converted to seconds and passed to the `latency` argument of
-#'   [watcher::watcher()]. The default latency is 250ms.}
+#'   The default polling interval is 500 milliseconds. You can change this
+#'   by setting e.g. `options(shiny.autoreload.interval = 2000)` (every
+#'   two seconds).}
 #' \item{shiny.deprecation.messages (defaults to `TRUE`)}{This controls whether messages for
 #'   deprecated functions in Shiny will be printed. See
 #'   [shinyDeprecated()] for more information.}
@@ -94,15 +90,10 @@ getShinyOption <- function(name, default = NULL) {
 #' \item{shiny.jquery.version (defaults to `3`)}{The major version of jQuery to use.
 #'   Currently only values of `3` or `1` are supported. If `1`, then jQuery 1.12.4 is used. If `3`,
 #'   then jQuery `r version_jquery` is used.}
-#' \item{shiny.json.digits (defaults to `I(16)`)}{Max number of digits to use when converting
-#'   numbers to JSON format to send to the client web browser. Use [I()] to specify significant digits.
-#'   Use `NA` for max precision.}
+#' \item{shiny.json.digits (defaults to `16`)}{The number of digits to use when converting
+#'   numbers to JSON format to send to the client web browser.}
 #' \item{shiny.launch.browser (defaults to `interactive()`)}{A boolean which controls the default behavior
 #'   when an app is run. See [runApp()] for more information.}
-#' \item{shiny.mathjax.url (defaults to `"https://mathjax.rstudio.com/latest/MathJax.js"`)}{
-#'   The URL that should be used to load MathJax, via [withMathJax()].}
-#' \item{shiny.mathjax.config (defaults to `"config=TeX-AMS-MML_HTMLorMML"`)}{The querystring
-#'   used to load MathJax, via [withMathJax()].}
 #' \item{shiny.maxRequestSize (defaults to 5MB)}{This is a number which specifies the maximum
 #'   web request size, which serves as a size limit for file uploads.}
 #' \item{shiny.minified (defaults to `TRUE`)}{By default
@@ -117,7 +108,7 @@ getShinyOption <- function(name, default = NULL) {
 #'   production.}
 #' \item{shiny.sanitize.errors (defaults to `FALSE`)}{If `TRUE`, then normal errors (i.e.
 #'   errors not wrapped in `safeError`) won't show up in the app; a simple
-#'   generic error message is printed instead (the error and stack trace printed
+#'   generic error message is printed instead (the error and strack trace printed
 #'   to the console remain unchanged). If you want to sanitize errors in general, but you DO want a
 #'   particular error `e` to get displayed to the user, then set this option
 #'   to `TRUE` and use `stop(safeError(e))` for errors you want the
@@ -134,9 +125,6 @@ getShinyOption <- function(name, default = NULL) {
 #'   console.}
 #' \item{shiny.testmode (defaults to `FALSE`)}{If `TRUE`, then various features for testing Shiny
 #'   applications are enabled.}
-#' \item{shiny.snapshotsortc (defaults to `FALSE`)}{If `TRUE`, test snapshot keys
-#'   for \pkg{shinytest} will be sorted consistently using the C locale.  Snapshots
-#'   retrieved by \pkg{shinytest2} will always sort using the C locale.}
 #' \item{shiny.trace (defaults to `FALSE`)}{Print messages sent between the R server and the web
 #'   browser client to the R console. This is useful for debugging. Possible
 #'   values are `"send"` (only print messages sent to the client),
@@ -145,46 +133,15 @@ getShinyOption <- function(name, default = NULL) {
 #'   messages).}
 #' \item{shiny.autoload.r (defaults to `TRUE`)}{If `TRUE`, then the R/
 #'   of a shiny app will automatically be sourced.}
-#' \item{shiny.useragg (defaults to `TRUE`)}{Set to `FALSE` to prevent PNG rendering via the
-#'   ragg package. See [plotPNG()] for more information.}
-#' \item{shiny.usecairo (defaults to `TRUE`)}{Set to `FALSE` to prevent PNG rendering via the
-#'   Cairo package. See [plotPNG()] for more information.}
+#' \item{shiny.usecairo (defaults to `TRUE`)}{This is used to disable graphical rendering by the
+#'   Cairo package, if it is installed. See [plotPNG()] for more
+#'   information.}
 #' \item{shiny.devmode (defaults to `NULL`)}{Option to enable Shiny Developer Mode. When set,
 #'   different default `getOption(key)` values will be returned. See [devmode()] for more details.}
 ### Not documenting as 'shiny.devmode.verbose' is for niche use only
 # ' \item{shiny.devmode.verbose (defaults to `TRUE`)}{If `TRUE`, will display messages printed
 # '   about which options are being set. See [devmode()] for more details. }
 ### (end not documenting 'shiny.devmode.verbose')
-### start shiny.client_devmode is primarily for niche, internal shinylive usage
-# ' \item{shiny.client_devmode (defaults to `FALSE`)}{If `TRUE`, enables client-
-# '  side devmode features. Currently the primary feature is the client-side
-# '  error console.}
-### end shiny.client_devmode
-#' \item{shiny.otel.collect (defaults to `Sys.getenv("SHINY_OTEL_COLLECT",
-#'   "all")`)}{Determines how Shiny will interact with OpenTelemetry.
-#'
-#'   Supported values:
-#'   * `"none"` - No Shiny OpenTelemetry tracing.
-#'   * `"session"` - Adds session start/end spans.
-#'   * `"reactive_update"` - Spans for any synchronous/asynchronous reactive
-#'     update. (Includes `"session"` features).
-#'   * `"reactivity"` - Spans for all reactive expressions and logs for setting
-#'     reactive vals and values. (Includes `"reactive_update"` features). This
-#'     option must be set when creating any reactive objects that should record
-#'     OpenTelemetry spans / logs. See [`withOtelCollect()`] and
-#'     [`localOtelCollect()`] for ways to set this option locally when creating
-#'     your reactive expressions.
-#'   * `"all"` - All Shiny OpenTelemetry tracing. Currently equivalent to
-#'     `"reactivity"`.
-#'
-#'   This option is useful for debugging and profiling while in production. This
-#'   option will only be useful if the `otelsdk` package is installed and
-#'   `otel::is_tracing_enabled()` returns `TRUE`. Please have any OpenTelemetry
-#'   environment variables set before loading any relevant R packages.
-#'
-#'   To set this option locally within a specific part of your Shiny
-#'   application, see [`withOtelCollect()`] and [`localOtelCollect()`].}
-#' \item{shiny.otel.sanitize.errors (defaults to `TRUE`)}{If `TRUE`, fatal and unhandled errors will be sanitized before being sent to the OpenTelemetry backend. The default value of `TRUE` is set to avoid potentially sending sensitive information to the OpenTelemetry backend. If you want the full error message and stack trace to be sent to the OpenTelemetry backend, set this option to `FALSE` or use `safeError(e)`.}
 #' }
 #'
 #'

R/shiny-package.R

@@ -1,15 +1,15 @@
 # See also R/reexports.R
 
 ## usethis namespace: start
+## usethis namespace: end
 #' @importFrom lifecycle deprecated is_present
 #' @importFrom grDevices dev.set dev.cur
 #' @importFrom fastmap fastmap
+#' @importFrom promises %...!%
+#' @importFrom promises %...>%
 #' @importFrom promises
-#'     %...!% %...>%
-#'    as.promise is.promising is.promise
-#'    promise_resolve promise_reject
-#'    hybrid_then
-#'    with_promise_domain new_promise_domain
+#'    promise promise_resolve promise_reject is.promising
+#'    as.promise
 #' @importFrom rlang
 #'    quo enquo enquo0 as_function get_expr get_env new_function enquos
 #'    eval_tidy expr pairlist2 new_quosure enexpr as_quosure is_quosure inject
@@ -18,13 +18,13 @@
 #'    is_false list2
 #'    missing_arg is_missing maybe_missing
 #'    quo_is_missing fn_fmls<- fn_body fn_body<-
+#' @importFrom ellipsis
 #'    check_dots_empty check_dots_unnamed
 #' @import htmltools
 #' @import httpuv
 #' @import xtable
 #' @import R6
 #' @import mime
-## usethis namespace: end
 NULL
 
 # It's necessary to Depend on methods so Rscript doesn't fail. It's necessary
@@ -34,11 +34,3 @@ NULL
 # since we call require(shiny) as part of loading the app.
 #' @import methods
 NULL
-
-
-# For usethis::use_release_issue()
-release_bullets <- function() {
-  c(
-    "Update static imports: `staticimports::import()`"
-  )
-}

R/shiny.R

@@ -16,7 +16,8 @@ NULL
 #'
 #' @name shiny-package
 #' @aliases shiny
-"_PACKAGE"
+#' @docType package
+NULL
 
 createUniqueId <- function(bytes, prefix = "", suffix = "") {
   withPrivateSeed({
@@ -32,12 +33,8 @@ createUniqueId <- function(bytes, prefix = "", suffix = "") {
 }
 
 toJSON <- function(x, ...,  dataframe = "columns", null = "null", na = "null",
-  auto_unbox = TRUE,
-  # Shiny has had a legacy value of 16 significant digits
-  # We can use `I(16)` mixed with the default behavior in jsonlite's `use_signif=`
-  # https://github.com/jeroen/jsonlite/commit/728efa9
-  digits = getOption("shiny.json.digits", I(16)), use_signif = is(digits, "AsIs"),
-  force = TRUE, POSIXt = "ISO8601", UTC = TRUE,
+  auto_unbox = TRUE, digits = getOption("shiny.json.digits", 16),
+  use_signif = TRUE, force = TRUE, POSIXt = "ISO8601", UTC = TRUE,
   rownames = FALSE, keep_vec_names = TRUE, strict_atomic = TRUE) {
 
   if (strict_atomic) {
@@ -188,11 +185,9 @@ workerId <- local({
 #'   session is actually connected.
 #' }
 #' \item{request}{
-#'   An environment that implements the [Rook
-#'   specification](https://github.com/jeffreyhorner/Rook#the-environment) for
-#'   HTTP requests. This is the request that was used to initiate the websocket
-#'   connection (as opposed to the request that downloaded the web page for the
-#'   app).
+#'   An environment that implements the Rook specification for HTTP requests.
+#'   This is the request that was used to initiate the websocket connection
+#'   (as opposed to the request that downloaded the web page for the app).
 #' }
 #' \item{userData}{
 #'   An environment for app authors and module/package authors to store whatever
@@ -214,7 +209,7 @@ workerId <- local({
 #'   Sends a custom message to the web page. `type` must be a
 #'   single-element character vector giving the type of message, while
 #'   `message` can be any jsonlite-encodable value. Custom messages
-#'   have no meaning to Shiny itself; they are used solely to convey information
+#'   have no meaning to Shiny itself; they are used soley to convey information
 #'   to custom JavaScript logic in the browser. You can do this by adding
 #'   JavaScript code to the browser that calls
 #'   \code{Shiny.addCustomMessageHandler(type, function(message){...})}
@@ -362,7 +357,6 @@ ShinySession <- R6Class(
     flushCallbacks = 'Callbacks',
     flushedCallbacks = 'Callbacks',
     inputReceivedCallbacks = 'Callbacks',
-    unhandledErrorCallbacks = 'Callbacks',
     bookmarkCallbacks = 'Callbacks',
     bookmarkedCallbacks = 'Callbacks',
     restoreCallbacks = 'Callbacks',
@@ -409,7 +403,7 @@ ShinySession <- R6Class(
     sendMessage = function(...) {
       # This function is a wrapper for $write
       msg <- list(...)
-      if (any_unnamed(msg)) {
+      if (anyUnnamed(msg)) {
         stop("All arguments to sendMessage must be named.")
       }
       private$write(toJSON(msg))
@@ -428,7 +422,7 @@ ShinySession <- R6Class(
         stop("Nested calls to withCurrentOutput() are not allowed.")
       }
 
-      with_promise_domain(
+      promises::with_promise_domain(
         createVarPromiseDomain(private, "currentOutputName", name),
         expr
       )
@@ -484,35 +478,6 @@ ShinySession <- R6Class(
           # "json" unless requested otherwise. The only other valid value is
           # "rds".
           format <- params$format %||% "json"
-          # Machines can test their snapshot under different locales.
-          # R CMD check runs under the `C` locale.
-          # However, before this parameter, existing snapshots were most likely not
-          #   under the `C` locale is would cause failures. This parameter allows
-          #   users to opt-in to the `C` locale.
-          # From ?sort:
-          #   However, there are some caveats with the radix sort:
-          #     If ‘x’ is a ‘character’ vector, all elements must share the
-          #   same encoding. Only UTF-8 (including ASCII) and Latin-1
-          #   encodings are supported. Collation always follows the "C"
-          #   locale.
-          # {shinytest2} will always set `sortC=1`
-          # {shinytest} does not have `sortC` functionality.
-          #    Users should set `options(shiny.snapshotsortc = TRUE)` within their app.
-          # The sortingMethod should always be `radix` going forward.
-          sortMethod <-
-            if (!is.null(params$sortC)) {
-              if (params$sortC != "1") {
-                stop("The `sortC` parameter can only be `1` or not supplied")
-              }
-              "radix"
-            } else {
-              # Allow users to set an option for {shinytest2}.
-              if (isTRUE(getShinyOption("snapshotsortc", default = FALSE))) {
-                "radix"
-              } else {
-                "auto"
-              }
-            }
 
           values <- list()
 
@@ -555,7 +520,7 @@ ShinySession <- R6Class(
               }
             )
 
-            values$input <- sortByName(values$input, method = sortMethod)
+            values$input <- sortByName(values$input)
           }
 
           if (!is.null(params$output)) {
@@ -583,7 +548,7 @@ ShinySession <- R6Class(
               }
             )
 
-            values$output <- sortByName(values$output, method = sortMethod)
+            values$output <- sortByName(values$output)
           }
 
           if (!is.null(params$export)) {
@@ -604,7 +569,7 @@ ShinySession <- R6Class(
               )
             }
 
-            values$export <- sortByName(values$export, method = sortMethod)
+            values$export <- sortByName(values$export)
           }
 
           # Make sure input, output, and export are all named lists (at this
@@ -724,7 +689,6 @@ ShinySession <- R6Class(
       private$flushCallbacks <- Callbacks$new()
       private$flushedCallbacks <- Callbacks$new()
       private$inputReceivedCallbacks <- Callbacks$new()
-      private$unhandledErrorCallbacks <- Callbacks$new()
       private$.input      <- ReactiveValues$new(dedupe = FALSE, label = "input")
       private$.clientData <- ReactiveValues$new(dedupe = TRUE, label = "clientData")
       private$timingRecorder <- ShinyServerTimingRecorder$new()
@@ -861,7 +825,7 @@ ShinySession <- R6Class(
             dots <- eval(substitute(alist(...)))
           }
 
-          if (any_unnamed(dots))
+          if (anyUnnamed(dots))
             stop("exportTestValues: all arguments must be named.")
 
           names(dots) <- ns(names(dots))
@@ -949,7 +913,7 @@ ShinySession <- R6Class(
 
         # Copy `values` from scopeState to state, adding namespace
         if (length(scopeState$values) != 0) {
-          if (any_unnamed(scopeState$values)) {
+          if (anyUnnamed(scopeState$values)) {
             stop("All scope values in must be named.")
           }
 
@@ -1045,34 +1009,8 @@ ShinySession <- R6Class(
       new data from the client."
       return(private$inputReceivedCallbacks$register(callback))
     },
-    onUnhandledError = function(callback) {
-      "Registers the callback to be invoked when an unhandled error occurs."
-      return(private$unhandledErrorCallbacks$register(callback))
-    },
-    unhandledError = function(e, close = TRUE) {
-      "Call the global and session unhandled error handlers and then close the
-       session if the error is fatal."
-      if (close) {
-        class(e) <- c("shiny.error.fatal", class(e))
-      }
-
-      # For fatal errors, always log.
-      # For non-fatal errors, only log if we haven't seen this error before.
-      if (close || !has_seen_otel_exception(e)) {
-        otel_log(
-          if (close) "Fatal error" else "Unhandled error",
-          severity = if (close) "fatal" else "error",
-          attributes = otel::as_attributes(list(
-            session.id = self$token,
-            error = get_otel_error_obj(e)
-          ))
-        )
-      }
-
-      private$unhandledErrorCallbacks$invoke(e, onError = printError)
-      .globals$onUnhandledErrorCallbacks$invoke(e, onError = printError)
-
-      if (close) self$close()
+    unhandledError = function(e) {
+      self$close()
     },
     close = function() {
       if (!self$closed) {
@@ -1086,9 +1024,7 @@ ShinySession <- R6Class(
       }
       # ..stacktraceon matches with the top-level ..stacktraceoff..
       withReactiveDomain(self, {
-        otel_span_session_end(domain = self, {
-          private$closedCallbacks$invoke(onError = printError, ..stacktraceon = TRUE)
-        })
+        private$closedCallbacks$invoke(onError = printError, ..stacktraceon = TRUE)
       })
     },
     isClosed = function() {
@@ -1157,8 +1093,7 @@ ShinySession <- R6Class(
         attr(label, "srcref") <- srcref
         attr(label, "srcfile") <- srcfile
 
-        # Do not bind this `observe()` call
-        obs <- with_no_otel_collect(observe(..stacktraceon = FALSE, {
+        obs <- observe(..stacktraceon = FALSE, {
 
           private$sendMessage(recalculating = list(
             name = name, status = 'recalculating'
@@ -1170,9 +1105,7 @@ ShinySession <- R6Class(
             hybrid_chain(
               {
                 private$withCurrentOutput(name, {
-                  maybe_with_otel_span_reactive_update({
-                    shinyCallingHandlers(func())
-                  }, domain = self)
+                  shinyCallingHandlers(func())
                 })
               },
               catch = function(cond) {
@@ -1181,14 +1114,7 @@ ShinySession <- R6Class(
                   structure(list(), class = "try-error", condition = cond)
                 } else if (inherits(cond, "shiny.output.cancel")) {
                   structure(list(), class = "cancel-output")
-                } else if (inherits(cond, "shiny.output.progress")) {
-                  structure(list(), class = "progress-output")
-                } else if (cnd_inherits(cond, "shiny.silent.error")) {
-                  # The error condition might have been chained by
-                  # foreign code, e.g. dplyr. Find the original error.
-                  while (!inherits(cond, "shiny.silent.error")) {
-                    cond <- cond$parent
-                  }
+                } else if (inherits(cond, "shiny.silent.error")) {
                   # Don't let shiny.silent.error go through the normal stop
                   # path of try, because we don't want it to print. But we
                   # do want to try to return the same looking result so that
@@ -1197,9 +1123,10 @@ ShinySession <- R6Class(
                 } else {
                   if (isTRUE(getOption("show.error.messages"))) printError(cond)
                   if (getOption("shiny.sanitize.errors", FALSE)) {
-                    cond <- sanitized_error()
+                    cond <- simpleError(paste("An error has occurred. Check your",
+                      "logs or contact the app author for",
+                      "clarification."))
                   }
-                  self$unhandledError(cond, close = FALSE)
                   invisible(structure(list(), class = "try-error", condition = cond))
                 }
               }
@@ -1210,33 +1137,6 @@ ShinySession <- R6Class(
               # client knows that progress is over.
               self$requestFlush()
 
-              if (inherits(value, "progress-output")) {
-                # This is the case where an output needs to compute for longer
-                # than this reactive flush. We put the output into progress mode
-                # (i.e. adding .recalculating) with a special flag that means
-                # the progress indication should not be cleared until this
-                # specific output receives a new value or error.
-                self$showProgress(name, persistent=TRUE)
-
-                # It's conceivable that this output already ran successfully
-                # within this reactive flush, in which case we could either show
-                # the new output while simultaneously making it .recalculating;
-                # or we squelch the new output and make whatever output is in
-                # the client .recalculating. I (jcheng) decided on the latter as
-                # it seems more in keeping with what we do with these kinds of
-                # intermediate output values/errors in general, i.e. ignore them
-                # and wait until we have a final answer. (Also kind of feels
-                # like a bug in the app code if you routinely have outputs that
-                # are executing successfully, only to be invalidated again
-                # within the same reactive flush--use priority to fix that.)
-                private$invalidatedOutputErrors$remove(name)
-                private$invalidatedOutputValues$remove(name)
-
-                # It's important that we return so that the existing output in
-                # the client remains untouched.
-                return()
-              }
-
               private$sendMessage(recalculating = list(
                 name = name, status = 'recalculated'
               ))
@@ -1261,7 +1161,7 @@ ShinySession <- R6Class(
                 private$invalidatedOutputValues$set(name, value)
             }
           )
-        }, suspended=private$shouldSuspend(name), label=label))
+        }, suspended=private$shouldSuspend(name), label=label)
 
         # If any output attributes were added to the render function attach
         # them to observer.
@@ -1369,29 +1269,23 @@ ShinySession <- R6Class(
         private$startCycle()
       }
     },
-    showProgress = function(id, persistent=FALSE) {
+    showProgress = function(id) {
       'Send a message to the client that recalculation of the output identified
       by \\code{id} is in progress. There is currently no mechanism for
       explicitly turning off progress for an output component; instead, all
-      progress is implicitly turned off when flushOutput is next called.
-
-      You can use persistent=TRUE if the progress for this output component
-      should stay on beyond the flushOutput (or any subsequent flushOutputs); in
-      that case, progress is only turned off (and the persistent flag cleared)
-      when the output component receives a value or error, or, if
-      showProgress(id, persistent=FALSE) is called and a subsequent flushOutput
-      occurs.'
+      progress is implicitly turned off when flushOutput is next called.'
 
       # If app is already closed, be sure not to show progress, otherwise we
       # will get an error because of the closed websocket
       if (self$closed)
         return()
 
-      if (!id %in% private$progressKeys) {
-        private$progressKeys <- c(private$progressKeys, id)
-      }
+      if (id %in% private$progressKeys)
+        return()
 
-      self$sendProgress('binding', list(id = id, persistent = persistent))
+      private$progressKeys <- c(private$progressKeys, id)
+
+      self$sendProgress('binding', list(id = id))
     },
     sendProgress = function(type, message) {
       private$sendMessage(
@@ -1807,7 +1701,7 @@ ShinySession <- R6Class(
         dots <- eval(substitute(alist(...)))
       }
 
-      if (any_unnamed(dots))
+      if (anyUnnamed(dots))
         stop("exportTestValues: all arguments must be named.")
 
       # Create a named list where each item is a list with an expression and
@@ -1820,7 +1714,7 @@ ShinySession <- R6Class(
     },
 
     getTestSnapshotUrl = function(input = TRUE, output = TRUE, export = TRUE,
-                                  format = "json", sortC = FALSE) {
+                                  format = "json") {
       reqString <- function(group, value) {
         if (isTRUE(value))
           paste0(group, "=1")
@@ -1834,7 +1728,6 @@ ShinySession <- R6Class(
         reqString("input", input),
         reqString("output", output),
         reqString("export", export),
-        reqString("sortC", sortC),
         paste0("format=", format),
         sep = "&"
       )
@@ -2039,8 +1932,8 @@ ShinySession <- R6Class(
           ext <- paste(".", ext, sep = "")
         tmpdata <- tempfile(fileext = ext)
         return(Context$new(getDefaultReactiveDomain(), '[download]')$run(function() {
-          with_promise_domain(reactivePromiseDomain(), {
-            captureStackTraces({
+          promises::with_promise_domain(reactivePromiseDomain(), {
+            promises::with_promise_domain(createStackTracePromiseDomain(), {
               self$incrementBusyCount()
               hybrid_chain(
                 # ..stacktraceon matches with the top-level ..stacktraceoff..
@@ -2211,8 +2104,6 @@ ShinySession <- R6Class(
       if (private$busyCount == 0L) {
         rLog$asyncStart(domain = self)
         private$sendMessage(busy = "busy")
-
-        otel_span_reactive_update_init(domain = self)
       }
       private$busyCount <- private$busyCount + 1L
     },
@@ -2234,8 +2125,6 @@ ShinySession <- R6Class(
             private$startCycle()
           }
         })
-
-        otel_span_reactive_update_teardown(domain = self)
       }
     }
   )
@@ -2405,89 +2294,23 @@ getCurrentOutputInfo <- function(session = getDefaultReactiveDomain()) {
 
 #' Add callbacks for Shiny session events
 #'
-#' @description
 #' These functions are for registering callbacks on Shiny session events.
-#' `onFlush` registers a function that will be called before Shiny flushes the
-#' reactive system. `onFlushed` registers a function that will be called after
-#' Shiny flushes the reactive system. `onUnhandledError` registers a function to
-#' be called when an unhandled error occurs before the session is closed.
-#' `onSessionEnded` registers a function to be called after the client has
-#' disconnected.
+#' `onFlush` registers a function that will be called before Shiny flushes
+#' the reactive system. `onFlushed` registers a function that will be
+#' called after Shiny flushes the reactive system. `onSessionEnded`
+#' registers a function to be called after the client has disconnected.
 #'
 #' These functions should be called within the application's server function.
 #'
 #' All of these functions return a function which can be called with no
 #' arguments to cancel the registration.
 #'
-#' @section Unhandled Errors:
-#' Unhandled errors are errors that aren't otherwise handled by Shiny or by the
-#' application logic. In other words, they are errors that will either cause the
-#' application to crash or will result in "Error" output in the UI.
-#'
-#' You can use `onUnhandledError()` to register a function that will be called
-#' when an unhandled error occurs. This function will be called with the error
-#' object as its first argument. If the error is fatal and will result in the
-#' session closing, the error condition will have the `shiny.error.fatal` class.
-#'
-#' Note that the `onUnhandledError()` callbacks cannot be used to prevent the
-#' app from closing or to modify the error condition. Instead, they are intended
-#' to give you an opportunity to log the error or perform other cleanup
-#' operations.
-#'
 #' @param fun A callback function.
 #' @param once Should the function be run once, and then cleared, or should it
 #'   re-run each time the event occurs. (Only for `onFlush` and
 #'   `onFlushed`.)
 #' @param session A shiny session object.
 #'
-#' @examplesIf interactive()
-#' library(shiny)
-#'
-#' ui <- fixedPage(
-#'   markdown(c(
-#'     "Set the number to 8 or higher to cause an error",
-#'     "in the `renderText()` output."
-#'   )),
-#'   sliderInput("number", "Number", 0, 10, 4),
-#'   textOutput("text"),
-#'   hr(),
-#'   markdown(c(
-#'     "Click the button below to crash the app with an unhandled error",
-#'     "in an `observe()` block."
-#'   )),
-#'   actionButton("crash", "Crash the app!")
-#' )
-#'
-#' log_event <- function(level, ...) {
-#'   ts <- strftime(Sys.time(), " [%F %T] ")
-#'   message(level, ts, ...)
-#' }
-#'
-#' server <- function(input, output, session) {
-#'   log_event("INFO", "Session started")
-#'
-#'   onUnhandledError(function(err) {
-#'     # log the unhandled error
-#'     level <- if (inherits(err, "shiny.error.fatal")) "FATAL" else "ERROR"
-#'     log_event(level, conditionMessage(err))
-#'   })
-#'
-#'   onStop(function() {
-#'     log_event("INFO", "Session ended")
-#'   })
-#'
-#'   observeEvent(input$crash, stop("Oops, an unhandled error happened!"))
-#'
-#'   output$text <- renderText({
-#'     if (input$number > 7) {
-#'       stop("that's too high!")
-#'     }
-#'     sprintf("You picked number %d.", input$number)
-#'   })
-#' }
-#'
-#' shinyApp(ui, server)
-#'
 #' @export
 onFlush <- function(fun, once = TRUE, session = getDefaultReactiveDomain()) {
   session$onFlush(fun, once = once)
@@ -2508,27 +2331,6 @@ onSessionEnded <- function(fun, session = getDefaultReactiveDomain()) {
   session$onSessionEnded(fun)
 }
 
-.globals$onUnhandledErrorCallbacks <- NULL
-on_load({
-  .globals$onUnhandledErrorCallbacks <- Callbacks$new()
-})
-
-#' @rdname onFlush
-#' @export
-onUnhandledError <- function(fun, session = getDefaultReactiveDomain()) {
-  if (!is.function(fun) || length(formals(fun)) == 0) {
-    rlang::abort(
-      "The unhandled error callback must be a function that takes an error object as its first argument."
-    )
-  }
-
-  if (is.null(session)) {
-    .globals$onUnhandledErrorCallbacks$register(fun)
-  } else {
-    session$onUnhandledError(fun)
-  }
-}
-
 
 flushPendingSessions <- function() {
   lapply(appsNeedingFlush$values(), function(shinysession) {
@@ -2743,10 +2545,3 @@ validate_session_object <- function(session, label = as.character(sys.call(sys.p
     )
   }
 }
-
-
-sanitized_error <- function() {
-  simpleError(paste("An error has occurred. Check your",
-    "logs or contact the app author for",
-    "clarification."))
-}

R/shinyapp.R

@@ -162,29 +162,11 @@ shinyAppDir_serverR <- function(appDir, options=list()) {
     sharedEnv <- globalenv()
   }
 
-  # To enable hot-reloading of support files, this function is called
-  # whenever the UI or Server func source is updated. To avoid loading
-  # support files 2x, we follow the last cache update trigger timestamp.
-  autoload_r_support_if_needed <- local({
-    autoload_last_loaded <- -1
-    function() {
-      if (!isTRUE(getOption("shiny.autoload.r", TRUE))) return()
-      
-      last_cache_trigger <- cachedAutoReloadLastChanged$get()
-      if (identical(autoload_last_loaded, last_cache_trigger)) return()
-
-      loadSupport(appDir, renv = sharedEnv, globalrenv = globalenv())
-
-      autoload_last_loaded <<- last_cache_trigger
-    }
-  })
-
   # uiHandlerSource is a function that returns an HTTP handler for serving up
   # ui.R as a webpage. The "cachedFuncWithFile" call makes sure that the closure
   # we're creating here only gets executed when ui.R's contents change.
   uiHandlerSource <- cachedFuncWithFile(appDir, "ui.R", case.sensitive = FALSE,
     function(uiR) {
-      autoload_r_support_if_needed()
       if (file.exists(uiR)) {
         # If ui.R contains a call to shinyUI (which sets .globals$ui), use that.
         # If not, then take the last expression that's returned from ui.R.
@@ -211,11 +193,10 @@ shinyAppDir_serverR <- function(appDir, options=list()) {
     staticPaths <- list()
   }
 
-  fallbackWWWDir <- system_file("www-dir", package = "shiny")
+  fallbackWWWDir <- system.file("www-dir", package = "shiny")
 
   serverSource <- cachedFuncWithFile(appDir, "server.R", case.sensitive = FALSE,
     function(serverR) {
-      autoload_r_support_if_needed()
       # If server.R contains a call to shinyServer (which sets .globals$server),
       # use that. If not, then take the last expression that's returned from
       # server.R.
@@ -251,9 +232,10 @@ shinyAppDir_serverR <- function(appDir, options=list()) {
   onStart <- function() {
     oldwd <<- getwd()
     setwd(appDir)
+    # TODO: we should support hot reloading on global.R and R/*.R changes.
     if (getOption("shiny.autoload.r", TRUE)) {
-      autoload_r_support_if_needed()
-    } else {
+      loadSupport(appDir, renv=sharedEnv, globalrenv=globalenv())
+    }  else {
       if (file.exists(file.path.ci(appDir, "global.R")))
         sourceUTF8(file.path.ci(appDir, "global.R"))
     }
@@ -304,81 +286,37 @@ shinyAppDir_serverR <- function(appDir, options=list()) {
 #
 # The return value is a function that halts monitoring when called.
 initAutoReloadMonitor <- function(dir) {
-  if (!get_devmode_option("shiny.autoreload", FALSE)) {
+  if (!getOption("shiny.autoreload", FALSE)) {
     return(function(){})
   }
 
-  filePattern <- getOption(
-    "shiny.autoreload.pattern",
-    ".*\\.(r|html?|js|css|png|jpe?g|gif)$"
-  )
+  filePattern <- getOption("shiny.autoreload.pattern",
+    ".*\\.(r|html?|js|css|png|jpe?g|gif)$")
 
-  
-  if (is_installed("watcher")) {
-    check_for_update <- function(paths) {
-      paths <- grep(
-        filePattern,
-        paths,
-        ignore.case = TRUE,
-        value = TRUE
-      )
-      
-      if (length(paths) == 0) {
-        return()
-      }
-      
-      cachedAutoReloadLastChanged$set()
+  lastValue <- NULL
+  observeLabel <- paste0("File Auto-Reload - '", basename(dir), "'")
+  obs <- observe(label = observeLabel, {
+    files <- sort_c(
+      list.files(dir, pattern = filePattern, recursive = TRUE, ignore.case = TRUE)
+    )
+    times <- file.info(files)$mtime
+    names(times) <- files
+
+    if (is.null(lastValue)) {
+      # First run
+      lastValue <<- times
+    } else if (!identical(lastValue, times)) {
+      # We've changed!
+      lastValue <<- times
       autoReloadCallbacks$invoke()
     }
-    
-    # [garrick, 2025-02-20] Shiny <= v1.10.0 used `invalidateLater()` with an
-    # autoreload.interval in ms. {watcher} instead uses a latency parameter in
-    # seconds, which serves a similar purpose and that I'm keeping for backcompat.
-    latency <- getOption("shiny.autoreload.interval", 250) / 1000
-    watcher <- watcher::watcher(dir, check_for_update, latency = latency)
-    watcher$start()
-    onStop(watcher$stop)
-  } else {
-    # Fall back to legacy observer behavior
-    if (!is_false(getOption("shiny.autoreload.legacy_warning", TRUE))) {
-      cli::cli_warn(
-        c(
-          "Using legacy autoreload file watching. Please install {.pkg watcher} for a more performant autoreload file watcher.",
-          "i" = "Set {.run options(shiny.autoreload.legacy_warning = FALSE)} to suppress this warning."
-        ),
-        .frequency = "regularly",
-        .frequency_id = "shiny.autoreload.legacy_warning"
-      )
-    }
 
-    lastValue <- NULL
-    observeLabel <- paste0("File Auto-Reload - '", basename(dir), "'")
-    watcher <- observe(label = observeLabel, {
-      files <- sort_c(
-        list.files(dir, pattern = filePattern, recursive = TRUE, ignore.case = TRUE)
-      )
-      times <- file.info(files)$mtime
-      names(times) <- files
-  
-      if (is.null(lastValue)) {
-        # First run
-        lastValue <<- times
-      } else if (!identical(lastValue, times)) {
-        # We've changed!
-        lastValue <<- times
-        cachedAutoReloadLastChanged$set()
-        autoReloadCallbacks$invoke()
-      }
-  
-      invalidateLater(getOption("shiny.autoreload.interval", 500))
-    })
-  
-    onStop(watcher$destroy)
-  
-    watcher$destroy
-  }
+    invalidateLater(getOption("shiny.autoreload.interval", 500))
+  })
 
-  invisible(watcher)
+  onStop(obs$destroy)
+
+  obs$destroy
 }
 
 #' Load an app's supporting R files
@@ -401,7 +339,7 @@ initAutoReloadMonitor <- function(dir) {
 #' @param appDir The application directory. If `appDir` is `NULL` or
 #'   not supplied, the nearest enclosing directory that is a Shiny app, starting
 #'   with the current directory, is used.
-#' @param renv The environment in which the files in the `R/` directory should
+#' @param renv The environmeny in which the files in the `R/` directory should
 #'   be evaluated.
 #' @param globalrenv The environment in which `global.R` should be evaluated. If
 #'   `NULL`, `global.R` will not be evaluated at all.
@@ -413,6 +351,17 @@ loadSupport <- function(appDir=NULL, renv=new.env(parent=globalenv()), globalren
     appDir <- findEnclosingApp(".")
   }
 
+  descFile <- file.path.ci(appDir, "DESCRIPTION")
+  if (file.exists(file.path.ci(appDir, "NAMESPACE")) ||
+      (file.exists(descFile) &&
+       identical(as.character(read.dcf(descFile, fields = "Type")), "Package")))
+  {
+    warning(
+      "Loading R/ subdirectory for Shiny application, but this directory appears ",
+      "to contain an R package. Sourcing files in R/ may cause unexpected behavior."
+    )
+  }
+
   if (!is.null(globalrenv)){
     # Evaluate global.R, if it exists.
     globalPath <- file.path.ci(appDir, "global.R")
@@ -427,12 +376,10 @@ loadSupport <- function(appDir=NULL, renv=new.env(parent=globalenv()), globalren
   helpersDir <- file.path(appDir, "R")
 
   disabled <- list.files(helpersDir, pattern="^_disable_autoload\\.r$", recursive=FALSE, ignore.case=TRUE)
-  if (length(disabled) > 0) {
+  if (length(disabled) > 0){
     return(invisible(renv))
   }
 
-  warn_if_app_dir_is_package(appDir)
-
   helpers <- list.files(helpersDir, pattern="\\.[rR]$", recursive=FALSE, full.names=TRUE)
   # Ensure files in R/ are sorted according to the 'C' locale before sourcing.
   # This convention is based on the default for packages. For details, see:
@@ -447,27 +394,6 @@ loadSupport <- function(appDir=NULL, renv=new.env(parent=globalenv()), globalren
   invisible(renv)
 }
 
-warn_if_app_dir_is_package <- function(appDir) {
-  has_namespace <- file.exists(file.path.ci(appDir, "NAMESPACE"))
-  has_desc_pkg <- FALSE
-
-  if (!has_namespace) {
-    descFile <- file.path.ci(appDir, "DESCRIPTION")
-
-    has_desc_pkg <-
-      file.exists(descFile) &&
-      identical(as.character(read.dcf(descFile, fields = "Type")), "Package")
-  }
-
-  if (has_namespace || has_desc_pkg) {
-    warning(
-      "Loading R/ subdirectory for Shiny application, but this directory appears ",
-      "to contain an R package. Sourcing files in R/ may cause unexpected behavior. ",
-      "See `?loadSupport` for more details."
-    )
-  }
-}
-
 # This reads in an app dir for a single-file application (e.g. app.R), and
 # returns a shiny.appobj.
 # appDir must be a normalized (absolute) path, not a relative one
@@ -483,6 +409,8 @@ shinyAppDir_appR <- function(fileName, appDir, options=list())
       wasDir <- setwd(appDir)
       on.exit(setwd(wasDir))
 
+      # TODO: we should support hot reloading on R/*.R changes.
+      # In an upcoming version of shiny, this option will go away.
       if (getOption("shiny.autoload.r", TRUE)) {
         # Create a child env which contains all the helpers and will be the shared parent
         # of the ui.R and server.R load.
@@ -527,7 +455,7 @@ shinyAppDir_appR <- function(fileName, appDir, options=list())
     staticPaths <- list()
   }
 
-  fallbackWWWDir <- system_file("www-dir", package = "shiny")
+  fallbackWWWDir <- system.file("www-dir", package = "shiny")
 
   oldwd <- NULL
   monitorHandle <- NULL

R/shinyui.R

@@ -14,11 +14,7 @@ NULL
 #' # now we can just write "static" content without withMathJax()
 #' div("more math here $$\\sqrt{2}$$")
 withMathJax <- function(...) {
-  path <- paste0(
-    getOption("shiny.mathjax.url", "https://mathjax.rstudio.com/latest/MathJax.js"),
-    "?",
-    getOption("shiny.mathjax.config", "config=TeX-AMS-MML_HTMLorMML")
-  )
+  path <- 'https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'
   tagList(
     tags$head(
       singleton(tags$script(src = path, type = 'text/javascript'))
@@ -43,7 +39,7 @@ renderPage <- function(ui, showcase=0, testMode=FALSE) {
 
     # Put the body into the default template
     ui <- htmlTemplate(
-      system_file("template", "default.html", package = "shiny"),
+      system.file("template", "default.html", package = "shiny"),
       lang = lang,
       body = ui,
       # this template is a complete HTML document
@@ -59,31 +55,10 @@ renderPage <- function(ui, showcase=0, testMode=FALSE) {
   if (testMode) {
     # Add code injection listener if in test mode
     shiny_deps[[length(shiny_deps) + 1]] <-
-      htmlDependency(
-        "shiny-testmode",
-        get_package_version("shiny"),
-        src = "www/shared",
-        package = "shiny",
-        script = "shiny-testmode.js",
-        all_files = FALSE
-      )
+      htmlDependency("shiny-testmode", shinyPackageVersion(),
+                     c(href="shared"), script = "shiny-testmode.js")
   }
 
-  if (in_devmode() || in_client_devmode()) {
-    # If we're in dev mode, add a simple script to the head that injects a
-    # global variable for the client to use to detect dev mode.
-    shiny_deps[[length(shiny_deps) + 1]] <-
-      htmlDependency(
-        "shiny-devmode",
-        get_package_version("shiny"),
-        src = "www/shared",
-        package = "shiny",
-        head="<script>window.__SHINY_DEV_MODE__ = true;</script>",
-        all_files = FALSE
-      )
-  }
-
-
   html <- renderDocument(ui, shiny_deps, processDep = createWebDependency)
   enc2utf8(paste(collapse = "\n", html))
 }
@@ -93,19 +68,23 @@ jqueryDependency <- function() {
   if (version == 3) {
     return(htmlDependency(
       "jquery", version_jquery,
-      src = "www/shared",
+      src = c(
+        href = "shared",
+        file = "www/shared"
+      ),
       package = "shiny",
-      script = "jquery.min.js",
-      all_files = FALSE
+      script = "jquery.min.js"
     ))
   }
   if (version == 1) {
     return(htmlDependency(
       "jquery", "1.12.4",
-      src = "www/shared/legacy",
+      src = c(
+        href = "shared/legacy",
+        file = "www/shared/legacy"
+      ),
       package = "shiny",
-      script = "jquery.min.js",
-      all_files = FALSE
+      script = "jquery.min.js"
     ))
   }
   stop("Unsupported version of jQuery: ", version)
@@ -114,12 +93,10 @@ jqueryDependency <- function() {
 shinyDependencies <- function() {
   list(
     bslib::bs_dependency_defer(shinyDependencyCSS),
-    busyIndicatorDependency(),
     htmlDependency(
       name = "shiny-javascript",
-      version = get_package_version("shiny"),
-      src = "www/shared",
-      package = "shiny",
+      version = shinyPackageVersion(),
+      src = c(href = "shared"),
       script =
         if (isTRUE(
           get_devmode_option(
@@ -129,38 +106,29 @@ shinyDependencies <- function() {
         ))
           "shiny.min.js"
         else
-          "shiny.js",
-      all_files = FALSE
+          "shiny.js"
     )
   )
 }
 
-shinyDependencySass <- function(bs_version) {
-  bootstrap_scss <- paste0("shiny.bootstrap", bs_version, ".scss")
-
-  scss_home <- system_file("www/shared/shiny_scss", package = "shiny")
-  scss_files <- file.path(scss_home, c(bootstrap_scss, "shiny.scss"))
-  lapply(scss_files, sass::sass_file)
-}
-
 shinyDependencyCSS <- function(theme) {
-  version <- get_package_version("shiny")
+  version <- shinyPackageVersion()
 
   if (!is_bs_theme(theme)) {
     return(htmlDependency(
       name = "shiny-css",
       version = version,
-      src = "www/shared",
-      package = "shiny",
-      stylesheet = "shiny.min.css",
-      all_files = FALSE
+      src = c(href = "shared"),
+      stylesheet = "shiny.min.css"
     ))
   }
 
-  bs_version <- bslib::theme_version(theme)
+  scss_home <- system.file("www/shared/shiny_scss", package = "shiny")
+  scss_files <- file.path(scss_home, c("bootstrap.scss", "shiny.scss"))
+  scss_files <- lapply(scss_files, sass::sass_file)
 
   bslib::bs_dependency(
-    input = shinyDependencySass(bs_version),
+    input = scss_files,
     theme = theme,
     name = "shiny-sass",
     version = version,
@@ -170,7 +138,7 @@ shinyDependencyCSS <- function(theme) {
 
 #' Create a Shiny UI handler
 #'
-#' @description `r lifecycle::badge("superseded")`
+#' @description \lifecycle{superseded}
 #'
 #' @description Historically this function was used in ui.R files to register a user
 #' interface with Shiny. It is no longer required as of Shiny 0.10; simply
@@ -178,7 +146,7 @@ shinyDependencyCSS <- function(theme) {
 #' This function is kept for backwards compatibility with older applications. It
 #' returns the value that is passed to it.
 #'
-#' @param ui A user interface definition
+#' @param ui A user interace definition
 #' @return The user interface definition, without modifications or side effects.
 #' @keywords internal
 #' @export

R/shinywrappers.R

@@ -134,14 +134,7 @@ markRenderFunction <- function(
     else renderFunc(...)
   }
 
-  otelAttrs <-
-    otel_srcref_attributes(
-      attr(renderFunc, "wrappedFunc", exact = TRUE),
-      # Can't retrieve the render function used at this point, so just use NULL
-      fn_name = NULL
-    )
-
-  ret <- structure(
+  structure(
     wrappedRenderFunc,
     class          = c("shiny.render.function", "function"),
     outputFunc     = uiFunc,
@@ -149,15 +142,8 @@ markRenderFunction <- function(
     hasExecuted    = hasExecuted,
     cacheHint      = cacheHint,
     cacheWriteHook = cacheWriteHook,
-    cacheReadHook  = cacheReadHook,
-    otelAttrs      = otelAttrs
+    cacheReadHook  = cacheReadHook
   )
-
-  if (has_otel_collect("reactivity")) {
-    ret <- enable_otel_shiny_render_function(ret)
-  }
-
-  ret
 }
 
 #' @export
@@ -285,7 +271,9 @@ createRenderFunction <- function(
   # Hoist func's wrappedFunc attribute into renderFunc, so that when we pass
   # renderFunc on to markRenderFunction, it is able to find the original user
   # function.
-  attr(renderFunc, "wrappedFunc") <- attr(func, "wrappedFunc", exact = TRUE)
+  if (identical(cacheHint, "auto")) {
+    attr(renderFunc, "wrappedFunc") <- attr(func, "wrappedFunc", exact = TRUE)
+  }
 
   markRenderFunction(outputFunc, renderFunc, outputArgs, cacheHint,
                      cacheWriteHook, cacheReadHook)
@@ -333,7 +321,7 @@ as.tags.shiny.render.function <- function(x, ..., inline = FALSE) {
 
 # Get relevant attributes from a render function object.
 renderFunctionAttributes <- function(x) {
-  attrs <- c("outputFunc", "outputArgs", "hasExecuted", "cacheHint", "otelAttrs")
+  attrs <- c("outputFunc", "outputArgs", "hasExecuted", "cacheHint")
   names(attrs) <- attrs
   lapply(attrs, function(name) attr(x, name, exact = TRUE))
 }
@@ -395,10 +383,8 @@ markOutputAttrs <- function(renderFunc, snapshotExclude = NULL,
 #' The corresponding HTML output tag should be `div` or `img` and have
 #' the CSS class name `shiny-image-output`.
 #'
-#' @seealso
-#' * For more details on how the images are generated, and how to control
+#' @seealso For more details on how the images are generated, and how to control
 #'   the output, see [plotPNG()].
-#' * Use [outputOptions()] to set general output options for an image output.
 #'
 #' @param expr An expression that returns a list.
 #' @inheritParams renderUI
@@ -612,7 +598,6 @@ isTemp <- function(path, tempDir = tempdir(), mustExist) {
 #'   used in an interactive RMarkdown document.
 #'
 #' @example res/text-example.R
-#' @seealso [outputOptions()]
 #' @export
 renderPrint <- function(expr, env = parent.frame(), quoted = FALSE,
                         width = getOption('width'), outputArgs=list())
@@ -628,7 +613,7 @@ renderPrint <- function(expr, env = parent.frame(), quoted = FALSE,
     domain <- createRenderPrintPromiseDomain(width)
     hybrid_chain(
       {
-        with_promise_domain(domain, func())
+        promises::with_promise_domain(domain, func())
       },
       function(value) {
         res <- withVisible(value)
@@ -657,7 +642,7 @@ renderPrint <- function(expr, env = parent.frame(), quoted = FALSE,
 createRenderPrintPromiseDomain <- function(width) {
   f <- file()
 
-  new_promise_domain(
+  promises::new_promise_domain(
     wrapOnFulfilled = function(onFulfilled) {
       force(onFulfilled)
       function(...) {
@@ -734,7 +719,7 @@ renderText <- function(expr, env = parent.frame(), quoted = FALSE,
 #'   call to [uiOutput()] when `renderUI` is used in an
 #'   interactive R Markdown document.
 #'
-#' @seealso [uiOutput()], [outputOptions()]
+#' @seealso [uiOutput()]
 #' @export
 #' @examples
 #' ## Only run examples in interactive R sessions
@@ -793,9 +778,9 @@ renderUI <- function(expr, env = parent.frame(), quoted = FALSE,
 #'   function.)
 #' @param contentType A string of the download's
 #'   [content type](https://en.wikipedia.org/wiki/Internet_media_type), for
-#'   example `"text/csv"` or `"image/png"`. If `NULL`, the content type
-#'   will be guessed based on the filename extension, or
-#'   `application/octet-stream` if the extension is unknown.
+#'   example `"text/csv"` or `"image/png"`. If `NULL` or
+#'   `NA`, the content type will be guessed based on the filename
+#'   extension, or `application/octet-stream` if the extension is unknown.
 #' @param outputArgs A list of arguments to be passed through to the implicit
 #'   call to [downloadButton()] when `downloadHandler` is used
 #'   in an interactive R Markdown document.
@@ -824,15 +809,8 @@ renderUI <- function(expr, env = parent.frame(), quoted = FALSE,
 #'
 #' shinyApp(ui, server)
 #' }
-#'
-#' @seealso
-#' * The download handler, like other outputs, is suspended (disabled) by
-#'   default for download buttons and links that are hidden. Use
-#'   [outputOptions()] to control this behavior, e.g. to set
-#'   `suspendWhenHidden = FALSE` if the download is initiated by
-#'   programmatically clicking on the download button using JavaScript.
 #' @export
-downloadHandler <- function(filename, content, contentType=NULL, outputArgs=list()) {
+downloadHandler <- function(filename, content, contentType=NA, outputArgs=list()) {
   renderFunc <- function(shinysession, name, ...) {
     shinysession$registerDownload(name, filename, contentType, content)
   }
@@ -844,12 +822,18 @@ downloadHandler <- function(filename, content, contentType=NULL, outputArgs=list
 #' Table output with the JavaScript DataTables library
 #'
 #' @description
-#' `r lifecycle::badge("deprecated")`
+#' `r lifecycle::badge("superseded")` Please use [`DT::renderDataTable()`]. (Shiny 0.11.1)
 #'
-#' This function is deprecated, use
-#' [DT::renderDT()](https://rstudio.github.io/DT/shiny.html) instead. It
-#' provides a superset of functionality, better performance, and better user
-#' experience.
+#' Makes a reactive version of the given function that returns a data frame (or
+#' matrix), which will be rendered with the [DataTables](https://datatables.net)
+#' library. Paging, searching, filtering, and sorting can be done on the R side
+#' using Shiny as the server infrastructure.
+#'
+#' This function only provides the server-side version of DataTables (using R
+#' to process the data object on the server side). There is a separate
+#' [DT](https://github.com/rstudio/DT) that allows you to create both
+#' server-side and client-side DataTables, and supports additional features.
+#' Learn more at <https://rstudio.github.io/DT/shiny.html>.
 #'
 #' @param expr An expression that returns a data frame or a matrix.
 #' @inheritParams renderTable
@@ -901,60 +885,18 @@ downloadHandler <- function(filename, content, contentType=NULL, outputArgs=list
 #'     }
 #'   )
 #' }
-#' @keywords internal
 renderDataTable <- function(expr, options = NULL, searchDelay = 500,
                             callback = 'function(oTable) {}', escape = TRUE,
                             env = parent.frame(), quoted = FALSE,
-                            outputArgs = list()) {
+                            outputArgs=list())
+{
 
-  legacy <- useLegacyDataTable(
-    from = "shiny::renderDataTable()",
-    to = "DT::renderDT()"
-  )
-
-  if (!quoted) {
-    expr <- substitute(expr)
-    quoted <- TRUE
-  }
-
-  if (legacy) {
-
-    legacyRenderDataTable(
-      expr, env = env, quoted = quoted,
-      options = options,
-      searchDelay = searchDelay,
-      callback = callback,
-      escape = escape,
-      outputArgs = outputArgs
-    )
-
-  } else {
-
-    if (!missing(searchDelay)) {
-      warning("Ignoring renderDataTable()'s searchDelay value (since DT::renderDT() has no equivalent).")
-    }
-
-    force(options)
-    force(callback)
-    force(escape)
-    force(outputArgs)
-
-    DT::renderDataTable(
-      expr, env = env, quoted = quoted,
-      options = if (is.null(options)) list() else options,
-      # Turn function into a statement
-      callback = DT::JS(paste0("(", callback, ")(table)")),
-      escape = escape,
-      outputArgs = outputArgs
+  if (in_devmode()) {
+    shinyDeprecated(
+      "0.11.1", "shiny::renderDataTable()", "DT::renderDataTable()",
+      details = "See <https://rstudio.github.io/DT/shiny.html> for more information"
     )
   }
-}
-
-
-legacyRenderDataTable <- function(expr, options = NULL, searchDelay = 500,
-                                  callback = 'function(oTable) {}', escape = TRUE,
-                                  env = parent.frame(), quoted = FALSE,
-                                  outputArgs=list()) {
 
   func <- installExprFunction(expr, "func", env, quoted, label = "renderDataTable")
 
@@ -1009,7 +951,7 @@ legacyRenderDataTable <- function(expr, options = NULL, searchDelay = 500,
 DT10Names <- function() {
   rbind(
     utils::read.table(
-      system_file('www/shared/datatables/upgrade1.10.txt', package = 'shiny'),
+      system.file('www/shared/datatables/upgrade1.10.txt', package = 'shiny'),
       stringsAsFactors = FALSE
     ),
     c('aoColumns', 'Removed')  # looks like an omission on the upgrade guide

R/showcase.R

@@ -32,34 +32,26 @@ licenseLink <- function(licenseName) {
 showcaseHead <- function() {
 
   deps  <- list(
-    jqueryuiDependency(),
-    htmlDependency(
-      "highlight.js",
-      "6.2",
-      src = "www/shared/highlight",
-      package="shiny",
-      script = "highlight.pack.js",
-      stylesheet = "rstudio.css"
-    ),
-    htmlDependency(
-      "showcase",
-      "0.1.0",
-      src = "www/shared",
-      package = "shiny",
-      script = "shiny-showcase.js",
-      stylesheet = "shiny-showcase.css",
-      all_files = FALSE
-    )
+    htmlDependency("jqueryui", "1.12.1", c(href="shared/jqueryui"),
+      script = "jquery-ui.min.js"),
+    htmlDependency("showdown", "0.3.1", c(href="shared/showdown/compressed"),
+      script = "showdown.js"),
+    htmlDependency("highlight.js", "6.2", c(href="shared/highlight"),
+      script = "highlight.pack.js")
   )
 
   mdfile <- file.path.ci(getwd(), 'Readme.md')
-  html <- tagList(
-    if (file.exists(mdfile)) {
-      md_content <- paste(readUTF8(mdfile), collapse="\n")
-      md_html <- commonmark::markdown_html(md_content, extensions = TRUE)
-      tags$template(id="showcase-markdown-content", HTML(md_html))
-    } else ""
-  )
+  html <- with(tags, tagList(
+    script(src="shared/shiny-showcase.js"),
+    link(rel="stylesheet", type="text/css",
+         href="shared/highlight/rstudio.css"),
+    link(rel="stylesheet", type="text/css",
+         href="shared/shiny-showcase.css"),
+    if (file.exists(mdfile))
+      script(type="text/markdown", id="showcase-markdown-content",
+        paste(readUTF8(mdfile), collapse="\n"))
+    else ""
+  ))
 
   return(attachDependencies(html, deps))
 }

R/staticimports.R

@@ -1,200 +0,0 @@
-# Generated by staticimports; do not edit by hand.
-# ======================================================================
-# Imported from pkg:staticimports
-# ======================================================================
-
-# Given a vector, return TRUE if any elements are named, FALSE otherwise.
-# For zero-length vectors, always return FALSE.
-any_named <- function(x) {
-  if (length(x) == 0) return(FALSE)
-  nms <- names(x)
-  !is.null(nms) && any(nzchar(nms))
-}
-
-# Given a vector, return TRUE if any elements are unnamed, FALSE otherwise.
-# For zero-length vectors, always return FALSE.
-any_unnamed <- function(x) {
-  if (length(x) == 0) return(FALSE)
-  nms <- names(x)
-  is.null(nms) || !all(nzchar(nms))
-}
-
-# Borrowed from pkgload:::dev_meta, with some modifications.
-# Returns TRUE if `pkg` was loaded with `devtools::load_all()`.
-devtools_loaded <- function(pkg) {
-  ns <- .getNamespace(pkg)
-  if (is.null(ns) || is.null(ns$.__DEVTOOLS__)) {
-    return(FALSE)
-  }
-  TRUE
-}
-
-get_package_version <- function(pkg) {
-  # `utils::packageVersion()` can be slow, so first try the fast path of
-  # checking if the package is already loaded.
-  ns <- .getNamespace(pkg)
-  if (is.null(ns)) {
-    utils::packageVersion(pkg)
-  } else {
-    as.package_version(ns$.__NAMESPACE__.$spec[["version"]])
-  }
-}
-
-is_installed <- function(pkg, version = NULL) {
-  installed <- isNamespaceLoaded(pkg) || nzchar(system_file_cached(package = pkg))
-
-  if (is.null(version)) {
-    return(installed)
-  }
-
-  if (!is.character(version) && !inherits(version, "numeric_version")) {
-    # Avoid https://bugs.r-project.org/show_bug.cgi?id=18548
-    alert <- if (identical(Sys.getenv("TESTTHAT"), "true")) stop else warning
-    alert("`version` must be a character string or a `package_version` or `numeric_version` object.")
-
-    version <- numeric_version(sprintf("%0.9g", version))
-  }
-
-  installed && isTRUE(get_package_version(pkg) >= version)
-}
-
-# Simplified version rlang:::s3_register() that just uses
-# warning() instead of rlang::warn() when registration fails
-# https://github.com/r-lib/rlang/blob/main/R/compat-s3-register.R
-s3_register <- function(generic, class, method = NULL) {
-  stopifnot(is.character(generic), length(generic) == 1)
-  stopifnot(is.character(class), length(class) == 1)
-
-  pieces <- strsplit(generic, "::")[[1]]
-  stopifnot(length(pieces) == 2)
-  package <- pieces[[1]]
-  generic <- pieces[[2]]
-
-  caller <- parent.frame()
-
-  get_method_env <- function() {
-    top <- topenv(caller)
-    if (isNamespace(top)) {
-      asNamespace(environmentName(top))
-    } else {
-      caller
-    }
-  }
-  get_method <- function(method, env) {
-    if (is.null(method)) {
-      get(paste0(generic, ".", class), envir = get_method_env())
-    } else {
-      method
-    }
-  }
-
-  register <- function(...) {
-    envir <- asNamespace(package)
-
-    # Refresh the method each time, it might have been updated by
-    # `devtools::load_all()`
-    method_fn <- get_method(method)
-    stopifnot(is.function(method_fn))
-
-    # Only register if generic can be accessed
-    if (exists(generic, envir)) {
-      registerS3method(generic, class, method_fn, envir = envir)
-    } else {
-      warning(
-        "Can't find generic `", generic, "` in package ", package,
-        " register S3 method. Do you need to update ", package,
-        " to the latest version?", call. = FALSE
-      )
-    }
-  }
-
-  # Always register hook in case package is later unloaded & reloaded
-  setHook(packageEvent(package, "onLoad"), function(...) {
-    register()
-  })
-
-  # Avoid registration failures during loading (pkgload or regular).
-  # Check that environment is locked because the registering package
-  # might be a dependency of the package that exports the generic. In
-  # that case, the exports (and the generic) might not be populated
-  # yet (#1225).
-  if (isNamespaceLoaded(package) && environmentIsLocked(asNamespace(package))) {
-    register()
-  }
-
-  invisible()
-}
-
-# Borrowed from pkgload::shim_system.file, with some modifications. This behaves
-# like `system.file()`, except that (1) for packages loaded with
-# `devtools::load_all()`, it will return the path to files in the package's
-# inst/ directory, and (2) for other packages, the directory lookup is cached.
-# Also, to keep the implementation simple, it doesn't support specification of
-# lib.loc or mustWork.
-system_file <- function(..., package = "base") {
-  if (!devtools_loaded(package))  {
-    return(system_file_cached(..., package = package))
-  }
-
-  if (!is.null(names(list(...)))) {
-    stop("All arguments other than `package` must be unnamed.")
-  }
-
-  # If package was loaded with devtools (the package loaded with load_all),
-  # also search for files under inst/, and don't cache the results (it seems
-  # more likely that the package path will change during the development
-  # process)
-  pkg_path <- find.package(package)
-
-  # First look in inst/
-  files_inst <- file.path(pkg_path, "inst", ...)
-  present_inst <- file.exists(files_inst)
-
-  # For any files that weren't present in inst/, look in the base path
-  files_top <- file.path(pkg_path, ...)
-  present_top <- file.exists(files_top)
-
-  # Merge them together. Here are the different possible conditions, and the
-  # desired result. NULL means to drop that element from the result.
-  #
-  # files_inst:   /inst/A  /inst/B  /inst/C  /inst/D
-  # present_inst:    T        T        F        F
-  # files_top:      /A       /B       /C       /D
-  # present_top:     T        F        T        F
-  # result:       /inst/A  /inst/B    /C       NULL
-  #
-  files <- files_top
-  files[present_inst] <- files_inst[present_inst]
-  # Drop cases where not present in either location
-  files <- files[present_inst | present_top]
-  if (length(files) == 0) {
-    return("")
-  }
-  # Make sure backslashes are replaced with slashes on Windows
-  normalizePath(files, winslash = "/")
-}
-
-# A wrapper for `system.file()`, which caches the package path because
-# `system.file()` can be slow. If a package is not installed, the result won't
-# be cached.
-system_file_cached <- local({
-  pkg_dir_cache <- character()
-
-  function(..., package = "base") {
-    if (!is.null(names(list(...)))) {
-      stop("All arguments other than `package` must be unnamed.")
-    }
-
-    not_cached <- is.na(match(package, names(pkg_dir_cache)))
-    if (not_cached) {
-      pkg_dir <- system.file(package = package)
-      if (nzchar(pkg_dir)) {
-        pkg_dir_cache[[package]] <<- pkg_dir
-      }
-    } else {
-      pkg_dir <- pkg_dir_cache[[package]]
-    }
-
-    file.path(pkg_dir, ...)
-  }
-})

R/test.R

@@ -158,7 +158,8 @@ print.shiny_runtests <- function(x, ..., reporter = "summary") {
 
 
   if (any(x$pass)) {
-    cli::cat_bullet("Success", bullet = "tick", bullet_col = "green")
+    # TODO in future... use clisymbols::symbol$tick and crayon green
+    cat("* Success\n")
     mapply(
       x$file,
       x$pass,
@@ -170,8 +171,9 @@ print.shiny_runtests <- function(x, ..., reporter = "summary") {
       }
     )
   }
-  if (!all(x$pass)) {
-    cli::cat_bullet("Failure", bullet = "cross", bullet_col = "red")
+  if (any(!x$pass)) {
+    # TODO in future... use clisymbols::symbol$cross and crayon red
+    cat("* Failure\n")
     mapply(
       x$file,
       x$pass,

R/update-input.R

@@ -37,11 +37,7 @@
 updateTextInput <- function(session = getDefaultReactiveDomain(), inputId, label = NULL, value = NULL, placeholder = NULL) {
   validate_session_object(session)
 
-  message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
-    value = value,
-    placeholder = placeholder
-  ))
+  message <- dropNulls(list(label=label, value=value, placeholder=placeholder))
   session$sendInputMessage(inputId, message)
 }
 
@@ -115,10 +111,7 @@ updateTextAreaInput <- updateTextInput
 updateCheckboxInput <- function(session = getDefaultReactiveDomain(), inputId, label = NULL, value = NULL) {
   validate_session_object(session)
 
-  message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
-    value = value
-  ))
+  message <- dropNulls(list(label=label, value=value))
   session$sendInputMessage(inputId, message)
 }
 
@@ -126,8 +119,6 @@ updateCheckboxInput <- function(session = getDefaultReactiveDomain(), inputId, l
 #' Change the label or icon of an action button on the client
 #'
 #' @template update-input
-#' @param disabled If `TRUE`, the button will not be clickable; if `FALSE`, it
-#'   will be.
 #' @inheritParams actionButton
 #'
 #' @seealso [actionButton()]
@@ -157,13 +148,13 @@ updateCheckboxInput <- function(session = getDefaultReactiveDomain(), inputId, l
 #'       label = "New label",
 #'       icon = icon("calendar"))
 #'
-#'     # Leaves goButton2's label unchanged and
+#'     # Leaves goButton2's label unchaged and
 #'     # removes its icon
 #'     updateActionButton(session, "goButton2",
 #'       icon = character(0))
 #'
 #'     # Leaves goButton3's icon, if it exists,
-#'     # unchanged and changes its label
+#'     # unchaged and changes its label
 #'     updateActionButton(session, "goButton3",
 #'       label = "New label 3")
 #'
@@ -178,21 +169,16 @@ updateCheckboxInput <- function(session = getDefaultReactiveDomain(), inputId, l
 #' }
 #' @rdname updateActionButton
 #' @export
-updateActionButton <- function(session = getDefaultReactiveDomain(), inputId, label = NULL, icon = NULL, disabled = NULL) {
+updateActionButton <- function(session = getDefaultReactiveDomain(), inputId, label = NULL, icon = NULL) {
   validate_session_object(session)
 
-  message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
-    icon = if (!is.null(icon)) processDeps(validateIcon(icon), session),
-    disabled = disabled
-  ))
+  if (!is.null(icon)) icon <- as.character(validateIcon(icon))
+  message <- dropNulls(list(label=label, icon=icon))
   session$sendInputMessage(inputId, message)
 }
 #' @rdname updateActionButton
 #' @export
-updateActionLink <- function(session = getDefaultReactiveDomain(), inputId, label = NULL, icon = NULL) {
-  updateActionButton(session, inputId=inputId, label=label, icon=icon)
-}
+updateActionLink <- updateActionButton
 
 
 #' Change the value of a date input on the client
@@ -235,12 +221,7 @@ updateDateInput <- function(session = getDefaultReactiveDomain(), inputId, label
   min   <- dateYMD(min, "min")
   max   <- dateYMD(max, "max")
 
-  message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
-    value = value,
-    min = min,
-    max = max
-  ))
+  message <- dropNulls(list(label=label, value=value, min=min, max=max))
   session$sendInputMessage(inputId, message)
 }
 
@@ -290,7 +271,7 @@ updateDateRangeInput <- function(session = getDefaultReactiveDomain(), inputId,
   max <- dateYMD(max, "max")
 
   message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
+    label = label,
     value = dropNulls(list(start = start, end = end)),
     min = min,
     max = max
@@ -389,16 +370,13 @@ updateNavlistPanel <- updateTabsetPanel
 #' }
 #' @export
 updateNumericInput <- function(session = getDefaultReactiveDomain(), inputId, label = NULL, value = NULL,
-  min = NULL, max = NULL, step = NULL) {
+    min = NULL, max = NULL, step = NULL) {
 
   validate_session_object(session)
 
   message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
-    value = formatNoSci(value),
-    min = formatNoSci(min),
-    max = formatNoSci(max),
-    step = formatNoSci(step)
+    label = label, value = formatNoSci(value),
+    min = formatNoSci(min), max = formatNoSci(max), step = formatNoSci(step)
   ))
   session$sendInputMessage(inputId, message)
 }
@@ -445,23 +423,6 @@ updateSliderInput <- function(session = getDefaultReactiveDomain(), inputId, lab
 {
   validate_session_object(session)
 
-  if (!is.null(value)) {
-    if (!is.null(min) && !is.null(max)) {
-      # Validate value/min/max together if all three are provided
-      tryCatch(
-        validate_slider_value(min, max, value, "updateSliderInput"),
-        error = function(err) warning(conditionMessage(err), call. = FALSE)
-      )
-    } else if (length(value) <  1 || length(value) > 2 || any(is.na(value))) {
-      # Otherwise ensure basic assumptions about value are met
-      warning(
-        "In updateSliderInput(): value must be a single value or a length-2 ",
-        "vector and cannot contain NA values.",
-        call. = FALSE
-      )
-    }
-  }
-
   # If no min/max/value is provided, we won't know the
   # type, and this will return an empty string
   dataType <- getSliderType(min, max, value)
@@ -478,7 +439,7 @@ updateSliderInput <- function(session = getDefaultReactiveDomain(), inputId, lab
   }
 
   message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
+    label = label,
     value = formatNoSci(value),
     min = formatNoSci(min),
     max = formatNoSci(max),
@@ -509,11 +470,7 @@ updateInputOptions <- function(session, inputId, label = NULL, choices = NULL,
     ))
   }
 
-  message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
-    options = options,
-    value = selected
-  ))
+  message <- dropNulls(list(label = label, options = options, value = selected))
 
   session$sendInputMessage(inputId, message)
 }
@@ -666,11 +623,7 @@ updateSelectInput <- function(session = getDefaultReactiveDomain(), inputId, lab
   choices <- if (!is.null(choices)) choicesWithNames(choices)
   if (!is.null(selected)) selected <- as.character(selected)
   options <- if (!is.null(choices)) selectOptions(choices, selected, inputId, FALSE)
-  message <- dropNulls(list(
-    label = if (!is.null(label)) processDeps(label, session),
-    options = options,
-    value = selected
-  ))
+  message <- dropNulls(list(label = label, options = options, value = selected))
   session$sendInputMessage(inputId, message)
 }
 

R/utils-lang.R

@@ -53,8 +53,8 @@ formalsAndBody <- function(x) {
 
 #' @describeIn createRenderFunction convert a quosure to a function.
 #' @param q Quosure of the expression `x`. When capturing expressions to create
-#'   your quosure, it is recommended to use [`rlang::enquo0()`] to not unquote
-#'   the object too early. See [`rlang::enquo0()`] for more details.
+#'   your quosure, it is recommended to use [`enquo0()`] to not unquote the
+#'   object too early. See [`enquo0()`] for more details.
 #' @inheritParams installExprFunction
 #' @export
 quoToFunction <- function(
@@ -208,10 +208,8 @@ exprToLabel <- function(expr, function_name, label = NULL) {
   if (is.null(label)) {
     label <- rexprSrcrefToLabel(
       srcref[[1]],
-      simpleExprToFunction(expr, function_name),
-      function_name
+      simpleExprToFunction(expr, function_name)
     )
-    label <- as_default_label(label)
   }
   if (length(srcref) >= 2) attr(label, "srcref") <- srcref[[2]]
   attr(label, "srcfile") <- srcFileOfRef(srcref[[1]])
@@ -231,12 +229,10 @@ funcToLabelBody <- function(func) {
 funcToLabel <- function(func, functionLabel, label = NULL) {
   if (!is.null(label)) return(label)
 
-  as_default_label(
-    sprintf(
-      '%s(%s)',
-      functionLabel,
-      funcToLabelBody(func)
-    )
+  sprintf(
+    '%s(%s)',
+    functionLabel,
+    funcToLabelBody(func)
   )
 }
 quoToLabelBody <- function(q) {
@@ -245,19 +241,9 @@ quoToLabelBody <- function(q) {
 quoToLabel <- function(q, functionLabel, label = NULL) {
   if (!is.null(label)) return(label)
 
-  as_default_label(
-    sprintf(
-      '%s(%s)',
-      functionLabel,
-      quoToLabelBody(q)
-    )
+  sprintf(
+    '%s(%s)',
+    functionLabel,
+    quoToLabelBody(q)
   )
 }
-
-as_default_label <- function(x) {
-  class(x) <- c("default_label", class(x))
-  x
-}
-is_default_label <- function(x) {
-  inherits(x, "default_label")
-}

R/utils-tags.R

@@ -1,21 +0,0 @@
-# Check if `x` is a tag(), tagList(), or HTML()
-# @param strict If `FALSE`, also consider a normal list() of 'tags' to be a tag list.
-isTagLike <- function(x, strict = FALSE) {
-  isTag(x) || isTagList(x, strict = strict) || isTRUE(attr(x, "html"))
-}
-
-isTag <- function(x) {
-  inherits(x, "shiny.tag")
-}
-
-isTagList <- function(x, strict = TRUE) {
-  if (strict) {
-    return(inherits(x, "shiny.tag.list"))
-  }
-
-  if (!is.list(x)) {
-    return(FALSE)
-  }
-
-  all(vapply(x, isTagLike, logical(1)))
-}

R/utils.R

@@ -2,11 +2,6 @@
 #' @include map.R
 NULL
 
-# @staticimports pkg:staticimports
-#   is_installed get_package_version system_file
-#   s3_register
-#   any_named any_unnamed
-
 #' Make a random number generator repeatable
 #'
 #' Given a function that generates random data, returns a wrapped version of
@@ -131,6 +126,34 @@ dropNullsOrEmpty <- function(x) {
   x[!vapply(x, nullOrEmpty, FUN.VALUE=logical(1))]
 }
 
+# Given a vector/list, return TRUE if any elements are named, FALSE otherwise.
+anyNamed <- function(x) {
+  # Zero-length vector
+  if (length(x) == 0) return(FALSE)
+
+  nms <- names(x)
+
+  # List with no name attribute
+  if (is.null(nms)) return(FALSE)
+
+  # List with name attribute; check for any ""
+  any(nzchar(nms))
+}
+
+# Given a vector/list, return TRUE if any elements are unnamed, FALSE otherwise.
+anyUnnamed <- function(x) {
+  # Zero-length vector
+  if (length(x) == 0) return(FALSE)
+
+  nms <- names(x)
+
+  # List with no name attribute
+  if (is.null(nms)) return(TRUE)
+
+  # List with name attribute; check for any ""
+  any(!nzchar(nms))
+}
+
 
 # Given a vector/list, returns a named vector/list (the labels will be blank).
 asNamed <- function(x) {
@@ -150,7 +173,7 @@ empty_named_list <- function() {
 # name as elements in a, the element in a is dropped. Also, if there are any
 # duplicated names in a or b, only the last one with that name is kept.
 mergeVectors <- function(a, b) {
-  if (any_unnamed(a) || any_unnamed(b)) {
+  if (anyUnnamed(a) || anyUnnamed(b)) {
     stop("Vectors must be either NULL or have names for all elements")
   }
 
@@ -162,27 +185,15 @@ mergeVectors <- function(a, b) {
 # Sort a vector by the names of items. If there are multiple items with the
 # same name, preserve the original order of those items. For empty
 # vectors/lists/NULL, return the original value.
-sortByName <- function(x, method = "auto") {
-  if (any_unnamed(x))
+sortByName <- function(x) {
+  if (anyUnnamed(x))
     stop("All items must be named")
 
   # Special case for empty vectors/lists, and NULL
   if (length(x) == 0)
     return(x)
 
-  # Must provide consistent sort order
-  #  https://github.com/rstudio/shinytest/issues/409
-  # Using a flag in the snapshot url to determine the method
-  # `method="radix"` uses `C` locale, which is consistent across platforms
-  # Even if two platforms share `en_us.UTF-8`, they may not sort consistently
-  #  https://blog.zhimingwang.org/macos-lc_collate-hunt
-  #  (macOS) $ LC_ALL=en_US.UTF-8 sort <<<$'python-dev\npython3-dev'
-  #  python-dev
-  #  python3-dev
-  #  (Linux) $ LC_ALL=en_US.UTF-8 sort <<<$'python-dev\npython3-dev'
-  #  python3-dev
-  #  python-dev
-  x[order(names(x), method = method)]
+  x[order(names(x))]
 }
 
 # Sort a vector. If a character vector, sort using C locale, which is consistent
@@ -484,7 +495,7 @@ shinyCallingHandlers <- function(expr) {
   withCallingHandlers(captureStackTraces(expr),
     error = function(e) {
       # Don't intercept shiny.silent.error (i.e. validation errors)
-      if (cnd_inherits(e, "shiny.silent.error"))
+      if (inherits(e, "shiny.silent.error"))
         return()
 
       handle <- getOption('shiny.error')
@@ -493,6 +504,7 @@ shinyCallingHandlers <- function(expr) {
   )
 }
 
+
 #' Register a function with the debugger (if one is active).
 #'
 #' Call this function after exprToFunction to give any active debugger a hook
@@ -770,45 +782,22 @@ formatNoSci <- function(x) {
   format(x, scientific = FALSE, digits = 15)
 }
 
-# A simple getter/setting to track the last time the auto-reload process
-# updated. This value is used by `cachedFuncWithFile()` when auto-reload is
-# enabled to reload app/ui/server files when watched supporting files change.
-cachedAutoReloadLastChanged <- local({
-  last_update <- 0
-
-  list(
-    set = function() {
-      last_update <<- as.integer(Sys.time())
-      invisible(last_update)
-    },
-    get = function() {
-      last_update
-    }
-  )
-})
-
 # Returns a function that calls the given func and caches the result for
 # subsequent calls, unless the given file's mtime changes.
 cachedFuncWithFile <- function(dir, file, func, case.sensitive = FALSE) {
-  dir <- normalizePath(dir, mustWork = TRUE)
-
+  dir <- normalizePath(dir, mustWork=TRUE)
+  mtime <- NA
   value <- NULL
-  last_mtime_file <- NA
-  last_autoreload <- 0
-
   function(...) {
-    fname <- if (case.sensitive) {
+    fname <- if (case.sensitive)
       file.path(dir, file)
-    } else {
+    else
       file.path.ci(dir, file)
-    }
 
     now <- file.info(fname)$mtime
-    autoreload <- last_autoreload < cachedAutoReloadLastChanged$get()
-    if (autoreload || !identical(last_mtime_file, now)) {
+    if (!identical(mtime, now)) {
       value <<- func(fname, ...)
-      last_mtime_file <<- now
-      last_autoreload <<- cachedAutoReloadLastChanged$get()
+      mtime <<- now
     }
     value
   }
@@ -1115,7 +1104,7 @@ need <- function(expr, message = paste(label, "must be provided"), label) {
 #'
 #' You can use `req(FALSE)` (i.e. no condition) if you've already performed
 #' all the checks you needed to by that point and just want to stop the reactive
-#' chain now. There is no advantage to this, except perhaps ease of readability
+#' chain now. There is no advantange to this, except perhaps ease of readibility
 #' if you have a complicated condition to check for (or perhaps if you'd like to
 #' divide your condition into nested `if` statements).
 #'
@@ -1137,10 +1126,7 @@ need <- function(expr, message = paste(label, "must be provided"), label) {
 #' @param ... Values to check for truthiness.
 #' @param cancelOutput If `TRUE` and an output is being evaluated, stop
 #'   processing as usual but instead of clearing the output, leave it in
-#'   whatever state it happens to be in. If `"progress"`, do the same as `TRUE`,
-#'   but also keep the output in recalculating state; this is intended for cases
-#'   when an in-progress calculation will not be completed in this reactive
-#'   flush cycle, but is still expected to provide a result in the future.
+#'   whatever state it happens to be in.
 #' @return The first value that was passed in.
 #' @export
 #' @examples
@@ -1172,8 +1158,6 @@ req <- function(..., cancelOutput = FALSE) {
     if (!isTruthy(item)) {
       if (isTRUE(cancelOutput)) {
         cancelOutput()
-      } else if (identical(cancelOutput, "progress")) {
-        reactiveStop(class = "shiny.output.progress")
       } else {
         reactiveStop(class = "validation")
       }
@@ -1267,12 +1251,14 @@ dotloop <- function(fun_, ...) {
 #' @param x An expression whose truthiness value we want to determine
 #' @export
 isTruthy <- function(x) {
-  if (is.null(x))
-    return(FALSE)
   if (inherits(x, 'try-error'))
     return(FALSE)
+
   if (!is.atomic(x))
     return(TRUE)
+
+  if (is.null(x))
+    return(FALSE)
   if (length(x) == 0)
     return(FALSE)
   if (all(is.na(x)))
@@ -1433,11 +1419,7 @@ URLencode <- function(value, reserved = FALSE) {
 dateYMD <- function(date = NULL, argName = "value") {
   if (!length(date)) return(NULL)
   tryCatch({
-      if (inherits(date, "POSIXt")) {
-        res <- format(date, "%Y-%m-%d")
-      } else {
-        res <- format(as.Date(date), "%Y-%m-%d")
-      }
+      res <- format(as.Date(date), "%Y-%m-%d")
       if (any(is.na(res))) stop()
       date <- res
     },
@@ -1460,12 +1442,6 @@ wrapFunctionLabel <- function(func, name, ..stacktraceon = FALSE, dots = TRUE) {
   if (name == "name" || name == "func" || name == "relabelWrapper") {
     stop("Invalid name for wrapFunctionLabel: ", name)
   }
-  if (nchar(name, "bytes") > 10000) {
-    # Max variable length in R is 10000 bytes. Truncate to a shorter number of
-    # chars because some characters could be multi-byte.
-    name <- substr(name, 1, 5000)
-  }
-
   assign(name, func, environment())
   registerDebugHook(name, environment(), name)
 
@@ -1529,7 +1505,7 @@ promise_chain <- function(promise, ..., catch = NULL, finally = NULL,
   }
 
   if (!is.null(domain)) {
-    with_promise_domain(domain, do(), replace = replace)
+    promises::with_promise_domain(domain, do(), replace = replace)
   } else {
     do()
   }
@@ -1546,7 +1522,7 @@ hybrid_chain <- function(expr, ..., catch = NULL, finally = NULL,
       {
         captureStackTraces({
           result <- withVisible(force(expr))
-          if (is.promising(result$value)) {
+          if (promises::is.promising(result$value)) {
             # Purposefully NOT including domain (nor replace), as we're already in
             # the domain at this point
             p <- promise_chain(valueWithVisible(result), ..., catch = catch, finally = finally)
@@ -1580,7 +1556,7 @@ hybrid_chain <- function(expr, ..., catch = NULL, finally = NULL,
   }
 
   if (!is.null(domain)) {
-    with_promise_domain(domain, do(), replace = replace)
+    promises::with_promise_domain(domain, do(), replace = replace)
   } else {
     do()
   }
@@ -1598,7 +1574,7 @@ createVarPromiseDomain <- function(env, name, value) {
   force(name)
   force(value)
 
-  new_promise_domain(
+  promises::new_promise_domain(
     wrapOnFulfilled = function(onFulfilled) {
       function(...) {
         orig <- env[[name]]
@@ -1740,20 +1716,24 @@ findEnclosingApp <- function(path = ".") {
   }
 }
 
-# Until `rlang::cnd_inherits()` is on CRAN
-cnd_inherits <- function(cnd, class) {
-  cnd_some(cnd, ~ inherits(.x, class))
-}
-cnd_some <- function(.cnd, .p, ...) {
-  .p <- rlang::as_function(.p)
-
-  while (rlang::is_condition(.cnd)) {
-    if (.p(.cnd, ...)) {
-      return(TRUE)
-    }
-
-    .cnd <- .cnd$parent
+# Check if a package is installed, and if version is specified,
+# that we have at least that version
+is_available <- function(package, version = NULL) {
+  installed <- nzchar(system.file(package = package))
+  if (is.null(version)) {
+    return(installed)
   }
-
-  FALSE
+  installed && isTRUE(utils::packageVersion(package) >= version)
 }
+
+
+# cached version of utils::packageVersion("shiny")
+shinyPackageVersion <- local({
+  version <- NULL
+  function() {
+    if (is.null(version)) {
+      version <<- utils::packageVersion("shiny")
+    }
+    version
+  }
+})

R/version_bs_date_picker.R

@@ -1,2 +1,2 @@
 # Generated by tools/updateBootstrapDatepicker.R; do not edit by hand
-version_bs_date_picker <- "1.10.0"
+version_bs_date_picker <- "1.9.0"

R/version_jquery.R

@@ -1,2 +1,2 @@
 # Generated by tools/updatejQuery.R; do not edit by hand
-version_jquery <- "3.7.1"
+version_jquery <- "3.6.0"

R/version_jqueryui.R

@@ -1,2 +0,0 @@
-# Generated by tools/updatejQueryUI.R; do not edit by hand
-version_jqueryui <- "1.14.1"

R/version_selectize.R

@@ -1,2 +1,2 @@
 # Generated by tools/updateSelectize.R; do not edit by hand
-version_selectize <- "0.15.2"
+version_selectize <- "0.12.4"

README-npm.md

@@ -1,14 +0,0 @@
-@posit/shiny
-============
-
-This npm package contains TypeScript type definitions for Shiny's client-side JavaScript libraries.
-
-It does not include the Shiny framework itself, though that may change in the future.
-
-[Shiny](https://github.com/rstudio/shiny) is a web application framework for both R and Python, developed by Posit PBC.
-
-## Installation
-
-```bash
-npm install @posit/shiny
-```

README.md

@@ -2,8 +2,8 @@
 
 <!-- badges: start -->
 [![CRAN](https://www.r-pkg.org/badges/version/shiny)](https://CRAN.R-project.org/package=shiny)
-[![R build status](https://github.com/rstudio/shiny/actions/workflows/R-CMD-check.yaml/badge.svg)](https://github.com/rstudio/shiny/actions)
-[![RStudio community](https://img.shields.io/badge/community-shiny-blue?style=social&logo=rstudio&logoColor=75AADB)](https://forum.posit.co/new-topic?category=shiny&tags=shiny)
+[![R build status](https://github.com/rstudio/shiny/workflows/R-CMD-check/badge.svg)](https://github.com/rstudio/shiny/actions)
+[![RStudio community](https://img.shields.io/badge/community-shiny-blue?style=social&logo=rstudio&logoColor=75AADB)](https://community.rstudio.com/new-topic?category=shiny&tags=shiny)
 
 <!-- badges: end -->
 
@@ -16,7 +16,7 @@ Easily build rich and productive interactive web apps in R &mdash; no HTML/CSS/J
 * A prebuilt set of highly sophisticated, customizable, and easy-to-use widgets (e.g., plots, tables, sliders, dropdowns, date pickers, and more).
 * An attractive default look based on [Bootstrap](https://getbootstrap.com/) which can also be easily customized with the [bslib](https://github.com/rstudio/bslib) package or avoided entirely with more direct R bindings to HTML/CSS/JavaScript.
 * Seamless integration with [R Markdown](https://shiny.rstudio.com/articles/interactive-docs.html), making it easy to embed numerous applications natively within a larger dynamic document.
-* Tools for improving and monitoring performance, including native support for [async programming](https://posit.co/blog/shiny-1-1-0/), [caching](https://talks.cpsievert.me/20201117), [load testing](https://rstudio.github.io/shinyloadtest/), and more.
+* Tools for improving and monitoring performance, including native support for [async programming](https://blog.rstudio.com/2018/06/26/shiny-1-1-0/), [caching](https://talks.cpsievert.me/20201117), [load testing](https://rstudio.github.io/shinyloadtest/), and [more](https://support.rstudio.com/hc/en-us/articles/231874748-Scaling-and-Performance-Tuning-in-RStudio-Connect).
 * [Modules](https://shiny.rstudio.com/articles/modules.html): a framework for reducing code duplication and complexity.
 * An ability to [bookmark application state](https://shiny.rstudio.com/articles/bookmarking-state.html) and/or [generate code to reproduce output(s)](https://github.com/rstudio/shinymeta).
 * A rich ecosystem of extension packages for more [custom widgets](http://www.htmlwidgets.org/), [input validation](https://github.com/rstudio/shinyvalidate), [unit testing](https://github.com/rstudio/shinytest), and more.
@@ -45,24 +45,20 @@ For more examples and inspiration, check out the [Shiny User Gallery](https://sh
 
 For help with learning fundamental Shiny programming concepts, check out the [Mastering Shiny](https://mastering-shiny.org/) book and the [Shiny Tutorial](https://shiny.rstudio.com/tutorial/). The former is currently more up-to-date with modern Shiny features, whereas the latter takes a deeper, more visual, dive into fundamental concepts.
 
-## Join the conversation
-
-If you want to chat about Shiny, meet other developers, or help us decide what to work on next, [join us on Discord](https://discord.com/invite/yMGCamUMnS).
-
 ## Getting Help
 
-To ask a question about Shiny, please use the [RStudio Community website](https://forum.posit.co/new-topic?category=shiny&tags=shiny).
+To ask a question about Shiny, please use the [RStudio Community website](https://community.rstudio.com/new-topic?category=shiny&tags=shiny). 
 
-For bug reports, please use the [issue tracker](https://github.com/rstudio/shiny/issues) and also keep in mind that by [writing a good bug report](https://github.com/rstudio/shiny/wiki/Writing-Good-Bug-Reports), you're more likely to get help with your problem.
+For bug reports, please use the [issue tracker](https://github.com/rstudio/shiny/issues) and also keep in mind that by [writing a good bug report](https://github.com/rstudio/shiny/wiki/Writing-Good-Bug-Reports), you're more likely to get help with your problem. 
 
 ## Contributing
 
-We welcome contributions to the **shiny** package. Please see our [CONTRIBUTING.md](https://github.com/rstudio/shiny/blob/main/.github/CONTRIBUTING.md) file for detailed guidelines of how to contribute.
+We welcome contributions to the **shiny** package. Please see our [CONTRIBUTING.md](https://github.com/rstudio/shiny/blob/master/.github/CONTRIBUTING.md) file for detailed guidelines of how to contribute.
 
 ## License
 
-The shiny package as a whole is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
+The shiny package as a whole is licensed under the GPLv3. See the [LICENSE](LICENSE) file for more details.
 
 ## R version support
 
-Shiny is supported on the latest release version of R, as well as the previous four minor release versions of R. For example, if the latest release R version is 4.3, then that version is supported, as well as 4.2, 4.1, 4.0, 3.6.
+Shiny is supported on the latest release version of R, as well as the previous four minor release versions of R. For example, if the latest release R version is 4.1, then that version is supported, as well as 4.0, 3.6, 3.5, and 3.4.

babel.config.json

@@ -0,0 +1,15 @@
+{
+  "presets": [
+    "@babel/preset-typescript",
+    [
+      "@babel/preset-env",
+      {
+        "useBuiltIns": "usage",
+        "corejs": "3.12"
+      }
+    ]
+  ],
+  "ignore":[
+    "node_modules/core-js"
+  ]
+}

cran-comments.md

@@ -1,129 +0,0 @@
-## Comments
-
-#### 2025-12-08
-
-Test has been removed from CRAN checks.
-
-Also added a couple bug fixes as found by users.
-
-Please let me know if you need any further changes.
-
-Thank you,
-Carson
-
-#### 2025-12-04
-
-Error:
-
-```
-Check Details
-Version: 1.12.0
-Check: tests
-Result: ERROR
-    Running ‘testthat.R’ [100s/394s]
-  Running the tests in ‘tests/testthat.R’ failed.
-  Complete output:
-    > library(testthat)
-    > library(shiny)
-    >
-    > test_check("shiny")
-    Saving _problems/test-timer-35.R
-    [ FAIL 1 | WARN 0 | SKIP 22 | PASS 1981 ]
-
-    ══ Skipped tests (22) ══════════════════════════════════════════════════════════
-    • File system is not case-sensitive (1): 'test-app.R:36:5'
-    • I'm not sure of a great way to test this without timers. (1):
-      'test-test-server.R:216:3'
-    • Not testing in CI (1): 'test-devmode.R:17:3'
-    • On CRAN (18): 'test-actionButton.R:59:1', 'test-busy-indication.R:1:1',
-      'test-busy-indication.R:15:1', 'test-busy-indication.R:50:1',
-      'test-otel-error.R:1:1', 'test-otel-mock.R:1:1', 'test-pkgdown.R:3:3',
-      'test-reactivity.r:146:1', 'test-reactivity.r:1240:5',
-      'test-reactivity.r:1240:5', 'test-stacks-deep.R:93:1',
-      'test-stacks-deep.R:141:1', 'test-stacks.R:140:3', 'test-tabPanel.R:46:1',
-      'test-tabPanel.R:66:1', 'test-tabPanel.R:73:1', 'test-tabPanel.R:83:1',
-      'test-utils.R:177:3'
-    • {shinytest2} is not installed (1): 'test-test-shinyAppTemplate.R:2:1'
-
-    ══ Failed tests ════════════════════════════════════════════════════════════════
-    ── Failure ('test-timer.R:35:3'): Unscheduling works ───────────────────────────
-    Expected `timerCallbacks$.times` to be identical to `origTimes`.
-    Differences:
-    `attr(actual, 'row.names')` is an integer vector ()
-    `attr(expected, 'row.names')` is a character vector ()
-
-
-    [ FAIL 1 | WARN 0 | SKIP 22 | PASS 1981 ]
-    Error:
-    ! Test failures.
-    Execution halted
-```
-
-
-#### 2025-12-03
-
-```
-Dear maintainer,
-
-Please see the problems shown on
-<https://cran.r-project.org/web/checks/check_results_shiny.html>.
-
-Please correct before 2025-12-17 to safely retain your package on CRAN.
-
-The CRAN Team
-```
-
-## `R CMD check` results:
-
-0 errors | 0 warning | 1 note
-
-```
-─  checking CRAN incoming feasibility ... [7s/70s] NOTE (1m 9.5s)
-   Maintainer: ‘Carson Sievert <carson@posit.co>’
-
-   Days since last update: 5
-```
-
-
-## revdepcheck results
-
-We checked 1383 reverse dependencies (1376 from CRAN + 7 from Bioconductor), comparing R CMD check results across CRAN and dev versions of this package.
-
- * We saw 0 new problems
- * We failed to check 31 packages
-
-Issues with CRAN packages are summarised below.
-
-### Failed to check
-
-* AssumpSure
-* boinet
-* brms
-* cheem
-* ctsem
-* detourr
-* FAfA
-* fio
-* fitteR
-* FossilSimShiny
-* GDINA
-* ggsem
-* grandR
-* hbsaems
-* langevitour
-* lavaan.shiny
-* lcsm
-* linkspotter
-* loon.shiny
-* MOsemiind
-* MVN
-* pandemonium
-* polarisR
-* RCTrep
-* rstanarm
-* semdrw
-* shotGroups
-* sphereML
-* spinifex
-* SurprisalAnalysis
-* TestAnaAPP

eslint.config.mjs

@@ -1,108 +0,0 @@
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import prettier from "eslint-plugin-prettier";
-import unicorn from "eslint-plugin-unicorn";
-import globals from "globals";
-import tsParser from "@typescript-eslint/parser";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-    baseDirectory: __dirname,
-    recommendedConfig: js.configs.recommended,
-    allConfig: js.configs.all
-});
-
-export default [{
-    ignores: ["**/*.d.ts"],
-}, ...compat.extends(
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:prettier/recommended",
-), {
-    plugins: {
-        "@typescript-eslint": typescriptEslint,
-        prettier,
-        unicorn,
-    },
-
-    languageOptions: {
-        globals: {
-            ...globals.browser,
-            Atomics: "readonly",
-            SharedArrayBuffer: "readonly",
-        },
-
-        parser: tsParser,
-        ecmaVersion: 2021,
-        sourceType: "module",
-
-        parserOptions: {
-            project: ["./tsconfig.json"],
-        },
-    },
-
-    rules: {
-        "@typescript-eslint/explicit-function-return-type": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/explicit-module-boundary-types": "error",
-        "default-case": ["error"],
-        "linebreak-style": ["error", "unix"],
-        quotes: ["error", "double", "avoid-escape"],
-        semi: ["error", "always"],
-        "dot-location": ["error", "property"],
-        camelcase: ["off"],
-
-        "unicorn/filename-case": ["error", {
-            case: "camelCase",
-        }],
-
-        "@typescript-eslint/array-type": ["error", {
-            default: "array-simple",
-            readonly: "array-simple",
-        }],
-
-        "@typescript-eslint/consistent-indexed-object-style": ["error", "index-signature"],
-        "@typescript-eslint/consistent-type-imports": "error",
-        "@typescript-eslint/no-floating-promises": "error",
-
-        "@typescript-eslint/naming-convention": ["error", {
-            selector: "default",
-            format: ["camelCase"],
-        }, {
-            selector: "method",
-            modifiers: ["private"],
-            format: ["camelCase"],
-            leadingUnderscore: "require",
-        }, {
-            selector: "method",
-            modifiers: ["protected"],
-            format: ["camelCase"],
-            leadingUnderscore: "require",
-        }, {
-            selector: "variable",
-            format: ["camelCase"],
-            trailingUnderscore: "forbid",
-            leadingUnderscore: "forbid",
-        }, {
-            selector: "parameter",
-            format: ["camelCase"],
-            trailingUnderscore: "allow",
-            leadingUnderscore: "forbid",
-        }, {
-            selector: ["enum", "enumMember"],
-            format: ["PascalCase"],
-        }, {
-            selector: "typeLike",
-            format: ["PascalCase"],
-
-            custom: {
-                regex: "(t|T)ype$",
-                match: false,
-            },
-        }],
-    },
-}];

inst/app_template/tests/shinytest.R

@@ -0,0 +1,2 @@
+library(shinytest)
+expect_pass(testApp("../", suffix = osName()))

inst/app_template/tests/shinytest/mytest.R

@@ -0,0 +1,12 @@
+app <- ShinyDriver$new("../../")
+app$snapshotInit("mytest")
+
+app$snapshot()
+{{
+if (isTRUE(module)) {
+'
+app$setInputs(`examplemodule1-button` = "click")
+app$setInputs(`examplemodule1-button` = "click")
+app$snapshot()'
+}
+}}