vue2server7 7.0.18 → 7.0.20

package/test/1/utils/route/constant.ts

@@ -1,14 +0,0 @@
-export const LAYOUT = () => import('@/layouts/index.vue');
-export const BLANK_LAYOUT = () => import('@/layouts/blank.vue');
-export const IFRAME = () => import('@/layouts/components/FrameBlank.vue');
-export const EXCEPTION_COMPONENT = () => import('@/pages/result/500/index.vue');
-export const PARENT_LAYOUT = () =>
-  new Promise((resolve) => {
-    resolve({ name: 'ParentLayout' });
-  });
-
-export const PAGE_NOT_FOUND_ROUTE = {
-  path: '/:w+',
-  name: '404Page',
-  redirect: '/result/404',
-};

package/test/1/utils/route/index.ts

@@ -1,110 +0,0 @@
-import cloneDeep from 'lodash/cloneDeep';
-
-import type { RouteItem } from '@/api/model/permissionModel';
-import type { RouteMeta } from '@/types/interface';
-import {
-  BLANK_LAYOUT,
-  EXCEPTION_COMPONENT,
-  IFRAME,
-  LAYOUT,
-  PAGE_NOT_FOUND_ROUTE,
-  PARENT_LAYOUT,
-} from '@/utils/route/constant';
-
-// 动态从包内引入单个Icon,如果没有网络环境可以使用这种方式 但是会导致产物存在多个chunk
-// const iconsPath = import.meta.glob('../../../node_modules/tdesign-icons-vue-next/esm/components/*.js');
-
-// async function getMenuIcon(iconName: string): Promise<string> {
-//   const RenderIcon = iconsPath[`../../../node_modules/tdesign-icons-vue-next/esm/components/${iconName}.js`];
-
-//   const Icon = await RenderIcon();
-//   return shallowRef(Icon.default);
-// }
-
-const LayoutMap = new Map<string, () => Promise<typeof import('*.vue')>>();
-
-LayoutMap.set('LAYOUT', LAYOUT);
-LayoutMap.set('BLANK', BLANK_LAYOUT);
-LayoutMap.set('IFRAME', IFRAME);
-
-let dynamicViewsModules: Record<string, () => Promise<Recordable>>;
-
-// 动态引入路由组件
-function asyncImportRoute(routes: RouteItem[] | undefined) {
-  dynamicViewsModules = dynamicViewsModules || import.meta.glob('../../pages/**/*.vue');
-  if (!routes) return;
-
-  routes.forEach(async (item) => {
-    const { component, name } = item;
-    const { children } = item;
-
-    if (component) {
-      const layoutFound = LayoutMap.get(component.toUpperCase());
-      if (layoutFound) {
-        item.component = layoutFound;
-      } else {
-        item.component = dynamicImport(dynamicViewsModules, component);
-      }
-    } else if (name) {
-      item.component = PARENT_LAYOUT();
-    }
-
-    // 动态从包内引入单个Icon,如果没有网络环境可以使用这种方式 但是会导致产物存在多个chunk
-    // if (item.meta.icon) item.meta.icon = await getMenuIcon(item.meta.icon);
-
-    children && asyncImportRoute(children);
-  });
-}
-
-function dynamicImport(dynamicViewsModules: Record<string, () => Promise<Recordable>>, component: string) {
-  const keys = Object.keys(dynamicViewsModules);
-  const matchKeys = keys.filter((key) => {
-    const k = key.replace('../../pages', '');
-    const startFlag = component.startsWith('/');
-    const endFlag = component.endsWith('.vue') || component.endsWith('.tsx');
-    const startIndex = startFlag ? 0 : 1;
-    const lastIndex = endFlag ? k.length : k.lastIndexOf('.');
-    return k.substring(startIndex, lastIndex) === component;
-  });
-  if (matchKeys?.length === 1) {
-    const matchKey = matchKeys[0];
-    return dynamicViewsModules[matchKey];
-  }
-  if (matchKeys?.length > 1) {
-    throw new Error(
-      'Please do not create `.vue` and `.TSX` files with the same file name in the same hierarchical directory under the views folder. This will cause dynamic introduction failure',
-    );
-  } else {
-    console.warn(`Can't find ${component} in pages folder`);
-  }
-  return EXCEPTION_COMPONENT;
-}
-
-// 将背景对象变成路由对象
-export function transformObjectToRoute<T = RouteItem>(routeList: RouteItem[]): T[] {
-  routeList.forEach(async (route) => {
-    const component = route.component as string;
-
-    if (component) {
-      if (component.toUpperCase() === 'LAYOUT') {
-        route.component = LayoutMap.get(component.toUpperCase());
-      } else {
-        route.children = [cloneDeep(route)];
-        route.component = LAYOUT;
-        route.name = `${route.name}Parent`;
-        route.path = '';
-        route.meta = (route.meta || {}) as RouteMeta;
-      }
-    } else {
-      throw new Error('component is undefined');
-    }
-
-    route.children && asyncImportRoute(route.children);
-
-    // 动态从包内引入单个Icon,如果没有网络环境可以使用这种方式 但是会导致产物存在多个chunk
-    // if (route.meta.icon)
-    // route.meta.icon = await getMenuIcon(route.meta.icon);
-  });
-
-  return [PAGE_NOT_FOUND_ROUTE, ...routeList] as unknown as T[];
-}

package/test/1/utils/version-check.worker.ts

@@ -1,58 +0,0 @@
-declare function postMessage(message: unknown): void;
-
-let timer: ReturnType<typeof setInterval> | null = null;
-let currentVersion = '';
-let checkUrl = '';
-let interval = 60_000;
-
-async function check() {
-  try {
-    const res = await fetch(`${checkUrl}?t=${Date.now()}`);
-    if (!res.ok) return;
-    const data = await res.json();
-    if (data.version && data.version !== currentVersion) {
-      postMessage({ type: 'update-available', version: data.version });
-      stop();
-    }
-  } catch {
-    // Network error — silently ignore, next tick will retry
-  }
-}
-
-function stop() {
-  if (timer) {
-    clearInterval(timer);
-    timer = null;
-  }
-}
-
-function start() {
-  stop();
-  check();
-  timer = setInterval(check, interval);
-}
-
-onmessage = (e: MessageEvent) => {
-  const msg = e.data;
-
-  switch (msg.type) {
-    case 'start':
-      currentVersion = msg.version;
-      checkUrl = msg.url;
-      interval = msg.interval || 60_000;
-      start();
-      break;
-
-    case 'pause':
-      stop();
-      break;
-
-    case 'resume':
-      start();
-      break;
-
-    case 'stop':
-      stop();
-      break;
-  }
-};

package/test/1/utils/version-update.ts

@@ -1,150 +0,0 @@
-import { ElNotification } from 'element-plus';
-import { h } from 'vue';
-
-/**
- * 前端版本热更新检测模块（Element Plus 版）
- *
- * 工作原理：
- *   1. 应用启动时，从 <meta name="app-version"> 读取当前构建版本号
- *   2. 启动一个 Web Worker 按固定间隔轮询 version.json（构建时生成）
- *   3. Worker 发现远端版本号与当前不一致时，通过 postMessage 通知主线程
- *   4. 主线程弹出确认弹窗，用户可选择"立即刷新"或"稍后提醒"
- *   5. 选择稍后提醒时，等待 SNOOZE_INTERVAL 后重新开始轮询
- *
- * 附加行为：
- *   - 页面切到后台时暂停轮询，回到前台时恢复（节省资源）
- *   - 开发环境（DEV）下不启用检测
- */
-
-/** 正常轮询间隔：60 秒 */
-const POLL_INTERVAL = 60 * 1000;
-
-/** 用户点击"稍后提醒"后的静默期：5 分钟，期间不再弹窗 */
-const SNOOZE_INTERVAL = 5 * 60 * 1000;
-
-/** 负责后台轮询的 Web Worker 实例 */
-let worker: Worker | null = null;
-
-/** 防重复弹窗标记：同一轮检测周期内只弹一次 */
-let hasNotified = false;
-
-/** 当前前端构建版本号，来自 HTML meta 标签 */
-let currentVersion = '';
-
-/** version.json 的完整 URL（含 BASE_URL 前缀，适配子路径部署） */
-let versionUrl = '';
-
-/**
- * 初始化版本检测，应在应用挂载后调用一次
- *
- * 流程：
- *   1. 开发环境直接跳过
- *   2. 读取 meta 标签中的版本号，读不到则放弃
- *   3. 创建 Web Worker；浏览器不支持时静默降级
- *   4. 监听 Worker 消息，收到 update-available 则弹窗
- *   5. 监听 visibilitychange 实现前后台暂停/恢复
- */
-export function initVersionCheck() {
-  if (import.meta.env.DEV) return;
-
-  currentVersion = document.querySelector('meta[name="app-version"]')?.getAttribute('content') || '';
-  if (!currentVersion) return;
-
-  versionUrl = `${import.meta.env.BASE_URL}version.json`;
-
-  try {
-    worker = new Worker(new URL('./version-check.worker.ts', import.meta.url), { type: 'module' });
-  } catch {
-    return;
-  }
-
-  worker.onmessage = (e: MessageEvent) => {
-    if (e.data.type === 'update-available' && !hasNotified) {
-      hasNotified = true;
-      showUpdateDialog();
-    }
-  };
-
-  worker.postMessage({ type: 'start', version: currentVersion, url: versionUrl, interval: POLL_INTERVAL });
-
-  document.addEventListener('visibilitychange', handleVisibilityChange);
-}
-
-/**
- * 页面可见性变化回调
- * - 回到前台：恢复轮询
- * - 切到后台：暂停轮询（避免不必要的网络请求）
- */
-function handleVisibilityChange() {
-  if (!worker || hasNotified) return;
-  if (document.visibilityState === 'visible') {
-    worker.postMessage({ type: 'resume', interval: POLL_INTERVAL });
-  } else {
-    worker.postMessage({ type: 'pause' });
-  }
-}
-
-/**
- * 弹出版本更新通知
- * - 点击"立即刷新"：刷新页面加载新版本
- * - 关闭通知：进入静默期后重新开始检测
- */
-function showUpdateDialog() {
-  const notification = ElNotification({
-    title: '发现新版本',
-    message: h('div', [
-      h('p', { style: 'margin: 0 0 12px' }, '系统已更新，请刷新页面以获取最新功能和修复。'),
-      h('div', { style: 'text-align: right' }, [
-        h(
-            'button',
-            {
-              style: 'margin-right: 8px; padding: 5px 15px; cursor: pointer; border: 1px solid #dcdfe6; border-radius: 4px; background: #fff; color: #606266; font-size: 14px;',
-              onClick: () => {
-                notification.close();
-                scheduleRecheck();
-              },
-            },
-            '稍后提醒',
-        ),
-        h(
-            'button',
-            {
-              style: 'padding: 5px 15px; cursor: pointer; border: none; border-radius: 4px; background: #409eff; color: #fff; font-size: 14px;',
-              onClick: () => {
-                notification.close();
-                window.location.reload();
-              },
-            },
-            '立即刷新',
-        ),
-      ]),
-    ]),
-    type: 'info',
-    position: 'bottom-right',
-    duration: 0,
-    showClose: false,
-    onClose: scheduleRecheck,
-  });
-}
-
-/**
- * 安排延迟重新检测
- * 重置弹窗标记，等待 SNOOZE_INTERVAL 后重新启动 Worker 轮询
- */
-function scheduleRecheck() {
-  hasNotified = false;
-  setTimeout(() => {
-    worker?.postMessage({ type: 'start', version: currentVersion, url: versionUrl, interval: POLL_INTERVAL });
-  }, SNOOZE_INTERVAL);
-}
-
-/**
- * 销毁版本检测，应在应用卸载时调用
- * 移除事件监听、停止并终止 Worker，释放资源
- */
-export function destroyVersionCheck() {
-  document.removeEventListener('visibilitychange', handleVisibilityChange);
-  worker?.postMessage({ type: 'stop' });
-  worker?.terminate();
-  worker = null;
-}

package/test/1/version-hot-update.md

@@ -1,277 +0,0 @@
-# 前端版本热更新检测
-
-## 概述
-
-本项目实现了一套前端版本热更新检测机制，用于在系统发布新版本后，**自动通知用户刷新页面**以获取最新代码。
-
-核心思路：每次构建生成唯一版本号，运行时通过 Web Worker 后台轮询版本文件，发现版本不一致即弹窗提示。
-
----
-
-## 涉及文件
-
-| 文件 | 层级 | 职责 |
-|------|------|------|
-| `build/vite-plugin-version.ts` | 构建层 | Vite 插件，构建时生成版本号并写入 HTML 和 JSON |
-| `src/utils/version-update.ts` | 运行层（主线程） | 初始化检测、管理 Worker 生命周期、弹窗交互 |
-| `src/utils/version-check.worker.ts` | 运行层（Worker 线程） | 后台定时轮询 `version.json` 并比对版本号 |
-| `src/main.ts` | 入口层 | 应用启动后调用 `initVersionCheck()` |
-
----
-
-## 架构总览
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                        构建阶段 (Vite Build)                      │
-│                                                                   │
-│  vite-plugin-version.ts                                           │
-│  ├─ 生成版本号: "1742000000000.a3f2k1"                             │
-│  ├─ 注入 <meta name="app-version" content="..."> 到 index.html    │
-│  └─ 写入 dist/version.json { "version": "..." }                   │
-└─────────────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                      运行阶段 (Browser Runtime)                   │
-│                                                                   │
-│  main.ts                                                          │
-│  └─ initVersionCheck()                                            │
-│       │                                                           │
-│       ▼                                                           │
-│  version-update.ts (主线程)                                        │
-│  ├─ 读取 <meta> 中的当前版本号                                      │
-│  ├─ 创建 Web Worker                                               │
-│  ├─ 监听 Worker 消息                                               │
-│  ├─ 监听 visibilitychange 事件                                     │
-│  │                                                                │
-│  │    postMessage          onmessage                              │
-│  │   ─────────────►  ┌──────────────────────┐                     │
-│  │                    │  version-check       │                     │
-│  │   ◄─────────────  │  .worker.ts          │                     │
-│  │    postMessage     │  (Worker 线程)        │                     │
-│  │                    │                      │                     │
-│  │                    │  每 60s fetch         │                     │
-│  │                    │  version.json        │                     │
-│  │                    └──────────────────────┘                     │
-│  │                              │                                 │
-│  │                              ▼                                 │
-│  │                     版本不一致？                                  │
-│  │                     ├─ 是 → postMessage('update-available')     │
-│  │                     └─ 否 → 等待下一轮                           │
-│  │                                                                │
-│  ▼                                                                │
-│  弹窗提示用户                                                       │
-│  ├─ "立即刷新" → window.location.reload()                          │
-│  └─ "稍后提醒" → 5 分钟后重新轮询                                    │
-└─────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 详细流程
-
-### 1. 构建阶段
-
-**文件：`build/vite-plugin-version.ts`**
-
-构建时，Vite 插件自动执行以下操作：
-
-1. **生成版本号**：使用 `Date.now()` + 6 位随机字符串，确保每次构建唯一
-   ```
-   例如："1742000000000.a3f2k1"
-   ```
-
-2. **注入 HTML meta 标签**：通过 `transformIndexHtml` 钩子，在 `<head>` 中注入：
-   ```html
-   <meta name="app-version" content="1742000000000.a3f2k1">
-   ```
-   这个标签会随 `index.html` 一起被浏览器缓存，代表用户当前加载的版本。
-
-3. **生成 version.json**：通过 `closeBundle` 钩子，在产物目录写入：
-   ```json
-   { "version": "1742000000000.a3f2k1" }
-   ```
-   这个文件部署后可被远程访问，代表服务器上的最新版本。
-
-> 插件设置了 `apply: 'build'`，仅在生产构建时生效，开发模式不产生任何输出。
-
----
-
-### 2. 应用启动
-
-**文件：`src/main.ts`**
-
-应用挂载到 DOM 后调用 `initVersionCheck()`：
-
-```typescript
-app.mount('#app');
-
-import { initVersionCheck } from './utils/version-update';
-initVersionCheck();
-```
-
-放在 `mount()` 之后是因为需要确保 DOM 中的 `<meta>` 标签已经可以被 `querySelector` 读取到。
-
----
-
-### 3. 初始化检测
-
-**文件：`src/utils/version-update.ts` → `initVersionCheck()`**
-
-```
-开发环境？─── 是 ──→ 直接返回（不检测）
-    │
-    否
-    ▼
-读取 <meta name="app-version"> 的 content
-    │
-    空？─── 是 ──→ 直接返回
-    │
-    否
-    ▼
-创建 Web Worker（version-check.worker.ts）
-    │
-    失败？── 是 ──→ 静默降级，不检测
-    │
-    否
-    ▼
-监听 Worker 的 onmessage 事件
-    │
-    ▼
-发送 start 指令给 Worker（携带版本号、URL、轮询间隔）
-    │
-    ▼
-注册 visibilitychange 事件监听
-```
-
----
-
-### 4. 后台轮询
-
-**文件：`src/utils/version-check.worker.ts`**
-
-Worker 收到 `start` 指令后：
-
-1. **立即执行一次检测**（不等第一个间隔周期）
-2. **启动定时器**，默认每 **60 秒** 执行一次检测
-3. 每次检测：
-   - `fetch` 请求 `version.json?t={timestamp}`（时间戳参数绕过 CDN/浏览器缓存）
-   - 解析返回的 JSON，提取 `version` 字段
-   - 与启动时传入的 `currentVersion` 比较
-   - **不一致** → `postMessage({ type: 'update-available' })` 通知主线程，并停止轮询
-   - **一致** → 什么都不做，等待下一轮
-   - **网络错误** → 静默忽略，下一轮自动重试
-
----
-
-### 5. 页面可见性优化
-
-**文件：`src/utils/version-update.ts` → `handleVisibilityChange()`**
-
-监听 `document.visibilitychange` 事件：
-
-| 场景 | 动作 | 目的 |
-|------|------|------|
-| 用户切到其他标签页 / 最小化窗口 | 发送 `pause` → Worker 清除定时器 | 避免后台无意义的网络请求 |
-| 用户切回页面 | 发送 `resume` → Worker 重新启动轮询 | 回到前台立即检测一次并恢复定时 |
-
----
-
-### 6. 弹窗交互
-
-**文件：`src/utils/version-update.ts` → `showUpdateDialog()`**
-
-主线程收到 `update-available` 消息后，使用 TDesign 的 `DialogPlugin.confirm` 弹出确认框：
-
-```
-┌─────────────────────────────────┐
-│         发现新版本                │
-│                                  │
-│  系统已更新，请刷新页面            │
-│  以获取最新功能和修复。            │
-│                                  │
-│    [稍后提醒]     [立即刷新]      │
-└─────────────────────────────────┘
-```
-
-用户操作对应的行为：
-
-| 操作 | 行为 |
-|------|------|
-| **立即刷新** | `window.location.reload()` 强制刷新，加载新版本 |
-| **稍后提醒** | 进入 5 分钟静默期，之后重新开始轮询 |
-| **关闭弹窗**（点 X） | 同"稍后提醒" |
-
----
-
-### 7. 稍后提醒机制
-
-**文件：`src/utils/version-update.ts` → `scheduleRecheck()`**
-
-用户选择"稍后提醒"后：
-
-1. 重置 `hasNotified = false`（允许再次弹窗）
-2. 设置 **5 分钟**（`SNOOZE_INTERVAL`）的 `setTimeout`
-3. 超时后重新向 Worker 发送 `start` 指令，开始新一轮轮询
-4. 检测到新版本后再次弹窗，如此循环直到用户刷新
-
----
-
-### 8. 销毁清理
-
-**文件：`src/utils/version-update.ts` → `destroyVersionCheck()`**
-
-应用卸载时调用，执行以下清理：
-
-1. 移除 `visibilitychange` 事件监听
-2. 向 Worker 发送 `stop` 指令（清除 Worker 内部定时器）
-3. `worker.terminate()` 终止 Worker 线程
-4. 置空 Worker 引用
-
----
-
-## 时间参数
-
-| 参数 | 值 | 说明 |
-|------|------|------|
-| `POLL_INTERVAL` | 60 秒 | Worker 正常轮询间隔 |
-| `SNOOZE_INTERVAL` | 5 分钟 | 用户点击"稍后提醒"后的静默期 |
-
----
-
-## 为什么使用 Web Worker？
-
-1. **不阻塞主线程**：`setInterval` + `fetch` 在 Worker 中执行，不影响 UI 渲染和交互响应
-2. **独立生命周期**：Worker 有自己的事件循环，即使主线程繁忙（如大量 DOM 操作），轮询也不会被延迟
-3. **干净的通信模型**：通过 `postMessage` 解耦，主线程只关心"有没有新版本"，不关心轮询细节
-
----
-
-## 开发环境行为
-
-开发环境下，版本检测**完全不生效**，双重保障：
-
-1. **构建层**：`vite-plugin-version` 设置了 `apply: 'build'`，`dev` 模式不注入 meta、不生成 version.json
-2. **运行层**：`initVersionCheck()` 第一行 `if (import.meta.env.DEV) return` 直接跳过
-
----
-
-## 缓存策略
-
-- **`version.json`**：请求时附带 `?t={timestamp}` 查询参数，绕过浏览器缓存和 CDN 缓存，确保每次拿到最新内容
-- **`index.html`**：服务器应配置为 `Cache-Control: no-cache`，确保用户刷新后能拿到最新的 HTML（包含新的 meta 标签）
-- **JS/CSS 资源**：Vite 构建产物自带 hash 文件名，天然支持长期缓存，新版本会生成新的文件名
-
----
-
-## 边界场景处理
-
-| 场景 | 处理方式 |
-|------|------|
-| 浏览器不支持 Web Worker | `try/catch` 捕获异常，静默降级，不影响正常使用 |
-| `<meta>` 标签缺失 | `initVersionCheck()` 检查到空值后直接返回 |
-| 网络请求失败 | Worker 中 `catch` 静默忽略，等下一轮自动重试 |
-| `version.json` 返回非 200 | `res.ok` 检查不通过，跳过本次比对 |
-| 用户反复点击"稍后提醒" | 每次都重新进入 5 分钟静默期，不会叠加弹窗 |
-| 同一检测周期内重复触发 | `hasNotified` 标记防止重复弹窗 |

package/test/1/vite-plugin-version.ts

@@ -1,35 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-import type { Plugin } from 'vite';
-
-export function vitePluginVersion(): Plugin {
-  const version = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
-  let outDir: string;
-
-  return {
-    name: 'vite-plugin-version',
-    apply: 'build',
-
-    configResolved(config) {
-      outDir = resolve(config.root, config.build.outDir);
-    },
-
-    transformIndexHtml() {
-      return [
-        {
-          tag: 'meta',
-          attrs: { name: 'app-version', content: version },
-          injectTo: 'head' as const,
-        },
-      ];
-    },
-
-    closeBundle() {
-      const filePath = resolve(outDir, 'version.json');
-      writeFileSync(filePath, JSON.stringify({ version }, null, 2));
-
-      console.log(`\n✅ Version file generated: ${version}\n`);
-    },
-  };
-}

package/test/1/vite.config.ts

@@ -1,46 +0,0 @@
-import path from 'node:path';
-
-import vue from '@vitejs/plugin-vue';
-import vueJsx from '@vitejs/plugin-vue-jsx';
-import type { ConfigEnv, UserConfig } from 'vite';
-import { loadEnv } from 'vite';
-import svgLoader from 'vite-svg-loader';
-
-import { vitePluginVersion } from './build/vite-plugin-version';
-
-const CWD = process.cwd();
-
-// https://vitejs.dev/config/
-export default ({ mode }: ConfigEnv): UserConfig => {
-  const { VITE_BASE_URL, VITE_API_URL_PREFIX } = loadEnv(mode, CWD);
-  return {
-    base: VITE_BASE_URL,
-    resolve: {
-      alias: {
-        '@': path.resolve(__dirname, './src'),
-      },
-    },
-
-    css: {
-      preprocessorOptions: {
-        less: {
-          modifyVars: {
-            hack: `true; @import (reference) "${path.resolve('src/style/variables.less')}";`,
-          },
-          math: 'strict',
-          javascriptEnabled: true,
-        },
-      },
-    },
-
-    plugins: [vue(), vueJsx(), svgLoader(), vitePluginVersion()],
-
-    server: {
-      port: 3002,
-      host: '0.0.0.0',
-      proxy: {
-        [VITE_API_URL_PREFIX]: 'http://127.0.0.1:3000/',
-      },
-    },
-  };
-};