vite-plugin-build-version-file 0.1.18 → 0.2.0

package/README.md

@@ -5,7 +5,9 @@
 它负责在开发态和构建产物中暴露统一的版本信息：
 
 - 开发态通过 dev server 提供 `version.json`
+- 开发态通过 dev server 提供 `loading.html`，便于本地调试
 - 构建后在输出目录生成 `version.json`
+- 构建后生成与 `index.html` 同级的 `loading.html` 缓存清理页
 - 普通 Vite HTML 自动注入 `window["__VERSION__"]`
 - 可选通过 `define` 将同一份 payload 编译进 JS 产物
 - VitePress 可通过顶层 `transformHtml` 注入同一份版本信息
@@ -107,7 +109,7 @@ export default defineNuxtConfig({
 
 `headScript()` 返回完整的 `<script>...</script>` 片段；`injectToHtml: false` 时、或 payload 还没生成时返回空字符串（不抛错），所以直接 `push` 是安全的。
 
-注意 Nuxt 里 `version.json` 的落点和 Vite / VitePress 不同：插件通过 `generateBundle` emit 到 Vite 客户端构建目录的根，而 Nuxt 发布到静态目录的是 assetsDir 内的内容，根目录上的文件不会被带出去。需要线上能访问这个文件时，要么把 `filename` 指到 assetsDir 内（例如 `_nuxt/version.json`），要么在构建后自行复制到 public 目录。
+插件会自动识别 Nuxt 的构建资产目录，并把 `version.json` emit 到该目录，因此 Nuxt 打包后的静态产物会包含这个文件。默认文件路径为 `/_nuxt/version.json`；如果需要固定使用根路径 `/version.json`，请将文件复制到 Nuxt `public` 目录，或在构建后自行复制。
 
 ## 默认行为
 
@@ -115,6 +117,7 @@ export default defineNuxtConfig({
 
 - 开发态访问 `/version.json` 时返回版本信息
 - 构建后输出 `version.json`
+- 构建后输出 `loading.html`
 - 向 HTML 注入 `window["__VERSION__"]`
 - 自动读取业务项目最近的 `package.json`
 - 将 `package.json` 的 `name` 写入 `pkgName`
@@ -155,6 +158,7 @@ type BuildVersionContext = {
 
 type BuildVersionPluginOptions = {
   filename?: string
+  loadingPage?: string | false
   globalName?: string
   defineName?: string | false
   injectToHtml?: boolean
@@ -194,6 +198,30 @@ dist/meta/version.json
 
 如果项目配置了 Vite `base`，访问路径会自动跟随 `base`。
 
+### `loadingPage`
+
+- 类型：`string | false`
+- 默认值：`"loading"`
+- 作用：控制构建产物中缓存清理页的文件名
+
+默认输出 `loading.html`，与 `index.html` 同级。值不带后缀时会自动补 `.html`，也支持子路径：
+
+```ts
+buildVersionPlugin({
+  loadingPage: 'cache/loading'
+})
+```
+
+构建后输出：
+
+```text
+dist/cache/loading.html
+```
+
+传 `false` 时不生成该页面。
+
+Nuxt 下与 `version.json` 使用同一规则，默认输出到 `_nuxt/loading.html`；如果需要固定使用根路径 `/loading.html`，请将文件复制到 Nuxt `public` 目录，或在构建后自行复制。
+
 ### `globalName`
 
 - 类型：`string`
@@ -465,48 +493,92 @@ void checkVersion()
 ## 刷新指定项目缓存
 
 ```ts
-import { clearUrlCache } from 'vite-plugin-build-version-file/client'
+import { redirectToLoading } from 'vite-plugin-build-version-file/client'
 
-await clearUrlCache({
+redirectToLoading({
   urls: ['/vue-app/', '/vue-app/index.html'],
   redirectUrl: '/vue-app/',
-  time: 5
+  time: 5,
+  times: 2,
+  title: '正在清理缓存',
+  filename: 'loading.html'
 })
 ```
 
-调用后会显示全屏 loading 和刷新倒计时。`time` 单位为秒，默认值为 `5`；缓存处理提前完成时会立即刷新，到达时限后则无论调用结果如何都会刷新。
+`redirectToLoading` 只负责携带参数跳转到构建产物中的 `loading.html`，不向当前页面注入任何 DOM，也不在主页面执行清理逻辑。缓存清理与跳转全部发生在 `loading.html` 内：
+
+- 打开后立即执行清理，并显示全屏 loading
+- 缓存处理提前完成时会立即跳转；到达 `time` 时限（单位秒，默认 `5`）后无论调用结果如何都会跳转
+- 跳转发生在 `loading.html` 内，主页面代码无需等待
 
-参数对象可省略。无参时按顺序检测以下两组 URL：
+参数对象可省略：
+
+```ts
+redirectToLoading()
+```
+
+无参时按顺序检测以下两组 URL：
 
 1. `location.origin + location.pathname`
 2. 第一组 URL 拼接 `index.html`
 
-两组完成后，默认携带随机时间戳跳转到第一组 URL：
+完成后跳转回 `window.location.href`（query 与 hash 原样保留，不追加缓存戳）。
+
+参数说明：
+
+- `urls`：需要清理缓存的 URL 列表，可传多个。默认如上两条
+- `redirectUrl`：清理完成或超时后跳转的目标 URL。默认为调用时的 `window.location.href`
+- `time`：最长等待秒数，默认 `5`
+- `times`：整套清理操作重复执行的次数，默认 `2`
+- `title`：传入后在 loading 页中心显示该文案；不传只显示 loading 图标
+- `filename`：`loading.html` 的路径，默认 `loading.html`，相对当前页面解析
+
+除 `filename` 外的参数会合并成一个 JSON 对象，写在随机参数名的 query 参数下；loading 页按参数值解析，不依赖参数名。
+
+loading 页默认透明背景，不遮挡页面底色；`title` 传了才显示文字。
+
+仍然可以用旧名调用，行为一致：
 
 ```ts
-await clearUrlCache()
+import { clearUrlCache } from 'vite-plugin-build-version-file/client'
+
+clearUrlCache({ urls: ['/vue-app/'] })
 ```
 
-Vue hash 路由会原样保留，缓存时间戳写在 `#` 前，确保服务器能够收到：
+Vue hash 路由会原样保留。缓存戳只加在 loading 页内部的 fetch / iframe 请求上，用于绕过旧缓存；最终跳转地址原样使用，不附加任何参数：
 
 ```text
-https://xxxx/pc/?_=随机值#/login?redirect=/dashboard/analysis
+调用页：https://xxxx/pc/#/login?redirect=/dashboard/analysis
+清理请求：https://xxxx/pc/?随机参数名=随机值
+最终跳转：https://xxxx/pc/#/login?redirect=/dashboard/analysis
 ```
 
-该方法仅支持同源 URL。它会绕过缓存请求 URL、强制刷新原 URL、通过隐藏 iframe 再次加载页面，最后携带随机时间戳跳转到该 URL。创建 iframe 前会销毁同一页面中已有的缓存刷新 iframe。单次请求或 iframe 加载失败不会阻断最终跳转。
+`loading.html` 内仅支持同源 URL。它会绕过缓存请求 URL、强制刷新原 URL、通过隐藏 iframe 再次加载页面，最后跳转到目标 URL（不附加缓存戳）。创建 iframe 前会销毁同一页面中已有的缓存刷新 iframe。单次请求或 iframe 加载失败不会阻断最终跳转。
 
 受浏览器限制，前端代码无法直接删除指定 URL 下的全部 HTTP 缓存；该方法只能尽可能刷新对应 Vue 项目的缓存。
 
+直接打开 `loading.html` 且不带 query 时，默认以 `loading.html` 所在目录作为应用根路径执行同一套清理。
+
 ## 开发态行为
 
 开发态下，插件不会向业务项目目录写入文件。
 
-它会通过 Vite dev server 直接返回 JSON：
+它会通过 Vite dev server 直接返回，不落文件：
 
+- `version.json`：版本信息 JSON
+- `loading.html`：与构建态同路径规则（可用 `loadingPage` 调整），可直接在浏览器打开调试清理与跳转流程
 - 不污染 `public/`
 - 不需要生成临时文件
 - 修改插件配置后重启 dev server 即可生效
 
+调试 loading 页时，query 参数与构建态一致：参数名随机，值是包含 `urls` 的 JSON，例如：
+
+```text
+http://localhost:5173/loading.html?x7k2q9={"urls":["http://localhost:5173/","http://localhost:5173/index.html"],"redirectUrl":"http://localhost:5173/","time":5,"times":2,"title":"调试"}
+```
+
+也可以直接打开 `http://localhost:5173/loading.html`，按所在目录执行默认清理。
+
 ## 本地开发
 
 仓库提供了两个调试用示例项目：
@@ -548,6 +620,7 @@ npm pack --dry-run
 建议检查：
 
 - `debug/fixture-app/dist/version.json` 包含 `time`、`env`、`pkgName`、`pkgVersion`
+- `debug/fixture-app/dist/loading.html` 与 `index.html` 同级生成
 - `debug/fixture-app/dist/index.html` 只注入一次 `window["__VERSION__"]`
 - `debug/vitepress-app/.vitepress/dist/meta/version.json` 包含 `fixture`、`time`、`env`
 - VitePress 每个 HTML 只注入一次 `window["__VERSION__"]`
@@ -596,7 +669,9 @@ npm pack
 It exposes one consistent version payload in development and production:
 
 - serves `version.json` through the Vite dev server
+- serves `loading.html` through the Vite dev server for local debugging
 - emits `version.json` into the build output directory
+- emits a `loading.html` cache-clearing page next to `index.html`
 - injects `window["__VERSION__"]` into normal Vite HTML
 - supports VitePress through its top-level `transformHtml` hook
 - supports custom versions, filenames, global variable names, time zones, and extra payload fields
@@ -697,7 +772,7 @@ export default defineNuxtConfig({
 
 `headScript()` returns a complete `<script>...</script>` snippet. It returns an empty string when `injectToHtml: false` or when the payload has not been created yet, so pushing it directly is safe.
 
-Note that `version.json` lands in a different place in Nuxt: the plugin emits it through `generateBundle` at the root of the Vite client build directory, while Nuxt publishes the contents of the assetsDir into the static output. Files sitting at that build root are not carried over. If the file must be reachable in production, either point `filename` inside the assetsDir (for example `_nuxt/version.json`) or copy it into the public directory after the build.
+The plugin automatically detects Nuxt's build assets directory and emits `version.json` there, so Nuxt's static output includes the file. The default URL is `/_nuxt/version.json`; if the file must stay at `/version.json`, copy it into Nuxt's `public` directory or copy it after the build.
 
 ## Default Behavior
 
@@ -705,6 +780,7 @@ With default options, the plugin:
 
 - serves `/version.json` in development
 - emits `version.json` after build
+- emits `loading.html` after build
 - injects `window["__VERSION__"]` into HTML
 - reads the nearest project `package.json`
 - writes `name` as `pkgName`
@@ -745,6 +821,7 @@ type BuildVersionContext = {
 
 type BuildVersionPluginOptions = {
   filename?: string
+  loadingPage?: string | false
   globalName?: string
   injectToHtml?: boolean
   timeZone?: string
@@ -781,6 +858,30 @@ Development URL:
 
 If your project configures Vite `base`, the URL follows that base.
 
+### `loadingPage`
+
+- Type: `string | false`
+- Default: `"loading"`
+- Controls the filename of the cache-clearing page in the build output.
+
+The default emits `loading.html` next to `index.html`. When the value has no suffix, `.html` is appended; sub-paths are supported:
+
+```ts
+buildVersionPlugin({
+  loadingPage: 'cache/loading'
+})
+```
+
+Build output:
+
+```text
+dist/cache/loading.html
+```
+
+Pass `false` to skip emitting the page.
+
+Nuxt uses the same rule as `version.json` and emits `_nuxt/loading.html` by default. If the file must stay at `/loading.html`, copy it into Nuxt's `public` directory or copy it after the build.
+
 ### `globalName`
 
 - Type: `string`
@@ -1022,48 +1123,92 @@ The example uses native `window.confirm`, so it has no UI framework dependency.
 ## Refreshing a Project Cache
 
 ```ts
-import { clearUrlCache } from 'vite-plugin-build-version-file/client'
+import { redirectToLoading } from 'vite-plugin-build-version-file/client'
 
-await clearUrlCache({
+redirectToLoading({
   urls: ['/vue-app/', '/vue-app/index.html'],
   redirectUrl: '/vue-app/',
-  time: 5
+  time: 5,
+  times: 2,
+  title: 'Clearing cache',
+  filename: 'loading.html'
 })
 ```
 
-The method displays a full-screen loading mask and refresh countdown after it is called. `time` is measured in seconds and defaults to `5`. It refreshes immediately if cache processing finishes early; once the limit is reached, it refreshes regardless of the processing result.
+`redirectToLoading` only builds the query string and navigates to the `loading.html` emitted by the build. It injects nothing into the current page and runs no cleanup logic there. Cache clearing and navigation both happen inside `loading.html`:
+
+- cleanup starts as soon as the page opens, with a full-screen loading mask
+- navigation happens as soon as cleanup finishes; once `time` seconds (default `5`) elapse, it happens regardless of the result
+- navigation is triggered inside `loading.html`, so the host page does not wait
 
-The options object is optional. Without arguments, the following URL groups are checked in order:
+The options object is optional:
+
+```ts
+redirectToLoading()
+```
+
+Without arguments, the following URL groups are checked in order:
 
 1. `location.origin + location.pathname`
 2. The first URL with `index.html` appended
 
-After both groups complete, the method navigates to the first URL with a random timestamp:
+After both groups complete, navigation goes back to the caller's `window.location.href`; query and hash are preserved and no cache-busting parameter is appended.
+
+Options:
+
+- `urls`: cache-clearing targets; multiple URLs are supported
+- `redirectUrl`: target after cleanup or timeout; defaults to `window.location.href` at call time
+- `time`: maximum wait in seconds, default `5`
+- `times`: how many times the whole cleanup pass runs, default `2`
+- `title`: when provided, shows that text in the loading page center; when omitted, only the loading icon is shown
+- `filename`: path of the loading page, default `loading.html`, resolved against the current page
+
+Every value except `filename` is merged into a single JSON object placed under a randomly named query parameter; the loading page parses values, not parameter names.
+
+The loading page uses a transparent background by default, and only shows text when `title` is provided.
+
+The old name still works and behaves the same:
 
 ```ts
-await clearUrlCache()
+import { clearUrlCache } from 'vite-plugin-build-version-file/client'
+
+clearUrlCache({ urls: ['/vue-app/'] })
 ```
 
-Vue hash routes are preserved. The cache-busting timestamp is added before `#` so the server receives it:
+Vue hash routes are preserved. Cache-busting parameters are added only to the fetch / iframe requests made by the loading page; the final navigation target stays exactly as given:
 
 ```text
-https://xxx.cn/pc/?_=random-value#/login?redirect=/dashboard/analysis
+caller: https://xxx.cn/pc/#/login?redirect=/dashboard/analysis
+cleanup request: https://xxx.cn/pc/?random-key=random-value
+final navigation: https://xxx.cn/pc/#/login?redirect=/dashboard/analysis
 ```
 
-This method only supports same-origin URLs. It bypasses the cached URL, forces a refresh of the original URL, loads the page again in a hidden iframe, and finally navigates to the URL with a random timestamp. Any existing cache-refresh iframe created by this method is removed before a new one is created. A failed request or iframe load does not prevent the final navigation.
+`loading.html` only supports same-origin URLs. It bypasses the cached URL, forces a refresh of the original URL, loads the page again in a hidden iframe, and finally navigates to the target URL without any cache-busting parameter. Any existing cache-refresh iframe created by this method is removed before a new one is created. A failed request or iframe load does not prevent the final navigation.
 
 Browser code cannot directly delete every HTTP cache entry under a specific URL. This method refreshes the corresponding Vue application cache on a best-effort basis.
 
+Opening `loading.html` directly without a query string treats the page's own directory as the application root and runs the same cleanup flow.
+
 ## Development Behavior
 
 In development, the plugin does not write files into your project directory.
 
-It serves JSON directly through the Vite dev server:
+It serves content directly through the Vite dev server without writing files:
 
+- `version.json`: the version payload as JSON
+- `loading.html`: the same cache-clearing page as the build output (path configured by `loadingPage`), so you can open it directly in the browser to debug the cleanup and navigation flow
 - no `public/` pollution
 - no temporary file generation
 - restart the dev server after changing plugin options
 
+The loading page accepts the same query parameters in development: the parameter name is random and the value is JSON containing `urls`, for example:
+
+```text
+http://localhost:5173/loading.html?x7k2q9={"urls":["http://localhost:5173/","http://localhost:5173/index.html"],"redirectUrl":"http://localhost:5173/","time":5,"times":2,"title":"debug"}
+```
+
+You can also open `http://localhost:5173/loading.html` directly to run the default cleanup for its own directory.
+
 ## Local Development
 
 The repository contains two fixture apps:
@@ -1105,6 +1250,7 @@ npm pack --dry-run
 Check:
 
 - `debug/fixture-app/dist/version.json` contains `time`, `env`, `pkgName`, and `pkgVersion`
+- `debug/fixture-app/dist/loading.html` is emitted next to `index.html`
 - `debug/fixture-app/dist/index.html` injects `window["__VERSION__"]` once
 - `debug/vitepress-app/.vitepress/dist/meta/version.json` contains `fixture`, `time`, and `env`
 - each VitePress HTML file injects `window["__VERSION__"]` once

package/dist/client.cjs

@@ -20,123 +20,46 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/client.ts
 var client_exports = {};
 __export(client_exports, {
-  clearUrlCache: () => clearUrlCache
+  clearUrlCache: () => clearUrlCache,
+  redirectToLoading: () => redirectToLoading
 });
 module.exports = __toCommonJS(client_exports);
-var CACHE_BUST_PARAM = "_";
-var IFRAME_ID = "vite-plugin-build-version-file-cache-iframe";
-var LOADING_ID = "vite-plugin-build-version-file-loading";
-var IFRAME_TIMEOUT = 5e3;
-var DEFAULT_REFRESH_TIME = 5;
-function showLoading(time) {
-  document.getElementById(LOADING_ID)?.remove();
-  const loading = document.createElement("div");
-  const spinner = document.createElement("div");
-  const text = document.createElement("div");
-  const deadline = Date.now() + time * 1e3;
-  loading.id = LOADING_ID;
-  loading.style.cssText = "position:fixed;inset:0;z-index:2147483647;display:flex;flex-direction:column;align-items:center;justify-content:center;background:rgba(0,0,0,.65);color:#fff;font:14px/1.5 sans-serif;";
-  spinner.style.cssText = "width:36px;height:36px;margin-bottom:16px;border:3px solid rgba(255,255,255,.35);border-top-color:#fff;border-radius:50%;animation:vite-build-version-loading .8s linear infinite;";
-  text.textContent = `\u8BF7\u7A0D\u7B49\uFF0C\u6B63\u5728\u68C0\u6D4B\u66F4\u65B0...\uFF08${Math.ceil(time)}\u79D2\uFF09`;
-  const style = document.createElement("style");
-  style.textContent = "@keyframes vite-build-version-loading{to{transform:rotate(360deg)}}";
-  loading.append(style, spinner, text);
-  document.documentElement.appendChild(loading);
-  const countdown = window.setInterval(() => {
-    const seconds = Math.max(0, Math.ceil((deadline - Date.now()) / 1e3));
-    text.textContent = `\u8BF7\u7A0D\u7B49\uFF0C\u6B63\u5728\u68C0\u6D4B\u66F4\u65B0...\uFF08${seconds}\u79D2\uFF09`;
-  }, 1e3);
-  return () => {
-    window.clearInterval(countdown);
-    loading.remove();
-  };
+var DEFAULT_LOADING_FILENAME = "loading.html";
+function createRandomParamKey() {
+  return Math.random().toString(36).slice(2);
 }
-function createCacheBustedUrl(url) {
-  const targetUrl = new URL(url, window.location.href);
-  const hash = targetUrl.hash;
-  targetUrl.hash = "";
-  targetUrl.searchParams.set(
-    CACHE_BUST_PARAM,
-    `${Date.now()}-${Math.random().toString(36).slice(2)}`
+function createLoadingUrl(options) {
+  const loadingUrl = new URL(
+    options.filename ?? DEFAULT_LOADING_FILENAME,
+    window.location.href
   );
-  targetUrl.hash = hash;
-  return targetUrl.href;
-}
-function createIndexUrl(url) {
-  const targetUrl = new URL(url);
-  if (!targetUrl.pathname.endsWith("/")) {
-    targetUrl.pathname += "/";
+  const defaultUrl = window.location.origin + window.location.pathname;
+  const indexUrl = defaultUrl.endsWith("/") ? `${defaultUrl}index.html` : `${defaultUrl}/index.html`;
+  const urls = options.urls && options.urls.length > 0 ? options.urls : [defaultUrl, indexUrl];
+  const payload = {
+    urls,
+    redirectUrl: options.redirectUrl ?? window.location.href
+  };
+  if (options.time !== void 0) {
+    payload.time = options.time;
   }
-  targetUrl.pathname += "index.html";
-  return targetUrl.href;
-}
-function loadIframe(url) {
-  return new Promise((resolve) => {
-    document.getElementById(IFRAME_ID)?.remove();
-    const iframe = document.createElement("iframe");
-    let completed = false;
-    const complete = () => {
-      if (completed) {
-        return;
-      }
-      completed = true;
-      window.clearTimeout(timeout);
-      resolve();
-    };
-    const timeout = window.setTimeout(complete, IFRAME_TIMEOUT);
-    iframe.hidden = true;
-    iframe.id = IFRAME_ID;
-    iframe.addEventListener("load", complete, { once: true });
-    iframe.addEventListener("error", complete, { once: true });
-    iframe.src = url;
-    document.documentElement.appendChild(iframe);
-  });
+  if (options.times !== void 0) {
+    payload.times = options.times;
+  }
+  if (options.title) {
+    payload.title = options.title;
+  }
+  loadingUrl.searchParams.set(createRandomParamKey(), JSON.stringify(payload));
+  return loadingUrl.href;
 }
-async function clearTargetUrlCache(url) {
-  const targetUrl = new URL(url, window.location.href).href;
-  console.info(`[vite-plugin-build-version] Clear cache for ${targetUrl}`);
-  await Promise.allSettled([
-    fetch(createCacheBustedUrl(targetUrl), { cache: "no-store" }).then(
-      (response) => response.arrayBuffer()
-    ),
-    fetch(targetUrl, { cache: "reload" }).then(
-      (response) => response.arrayBuffer()
-    )
-  ]);
-  await loadIframe(createCacheBustedUrl(targetUrl));
+function redirectToLoading(options = {}) {
+  window.location.href = createLoadingUrl(options);
 }
-async function clearUrlCache(options = {}) {
-  const defaultUrl = window.location.origin + window.location.pathname;
-  const urls = options.urls ?? [defaultUrl, createIndexUrl(defaultUrl)];
-  const configuredTime = options.time;
-  const time = typeof configuredTime === "number" && Number.isFinite(configuredTime) && configuredTime > 0 ? configuredTime : DEFAULT_REFRESH_TIME;
-  const redirectUrl = new URL(
-    options.redirectUrl ?? urls[0] ?? defaultUrl,
-    window.location.href
-  ).href;
-  const hideLoading = showLoading(time);
-  let refreshTimeout = 0;
-  try {
-    await Promise.race([
-      (async () => {
-        for (const url of urls) {
-          try {
-            await clearTargetUrlCache(url);
-          } catch {
-          }
-        }
-      })(),
-      new Promise((resolve) => {
-        refreshTimeout = window.setTimeout(resolve, time * 1e3);
-      })
-    ]);
-  } finally {
-    window.clearTimeout(refreshTimeout);
-    hideLoading();
-    window.location.replace(createCacheBustedUrl(redirectUrl));
-  }
+function clearUrlCache(options = {}) {
+  redirectToLoading(options);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  clearUrlCache
+  clearUrlCache,
+  redirectToLoading
 });

package/dist/client.d.cts

@@ -1,8 +1,12 @@
-interface ClearUrlCacheOptions {
+interface RedirectToLoadingOptions {
     urls?: string[];
     redirectUrl?: string;
     time?: number;
+    times?: number;
+    title?: string;
+    filename?: string;
 }
-declare function clearUrlCache(options?: ClearUrlCacheOptions): Promise<void>;
+declare function redirectToLoading(options?: RedirectToLoadingOptions): void;
+declare function clearUrlCache(options?: RedirectToLoadingOptions): void;
 
-export { type ClearUrlCacheOptions, clearUrlCache };
+export { type RedirectToLoadingOptions, clearUrlCache, redirectToLoading };

package/dist/client.d.ts

@@ -1,8 +1,12 @@
-interface ClearUrlCacheOptions {
+interface RedirectToLoadingOptions {
     urls?: string[];
     redirectUrl?: string;
     time?: number;
+    times?: number;
+    title?: string;
+    filename?: string;
 }
-declare function clearUrlCache(options?: ClearUrlCacheOptions): Promise<void>;
+declare function redirectToLoading(options?: RedirectToLoadingOptions): void;
+declare function clearUrlCache(options?: RedirectToLoadingOptions): void;
 
-export { type ClearUrlCacheOptions, clearUrlCache };
+export { type RedirectToLoadingOptions, clearUrlCache, redirectToLoading };